qq_56272102的博客

通过x来维护到当前节点为止的最大值，更新x和判断大小的步骤可以修改调整顺序。

在自顶向下的过程中，需要保留上层的信息，每次向下一层的时候都要将上层总和*10，因此设置x。对叶子结点，x更新后即为答案。空节点为0，非空节点为x更新后再加上左右节点的sumnumbers值。

对当前节点root，非空情况下，如果它是叶子结点，那么判断其是否满足条件，满足则为true。如果它不是叶子结点，那么判断其左右子节点是否满足。每经过一个节点，targetsum-=当前节点值。时间复杂度O(n) n为二叉树节点个数。

判断一个支结束，也即判断一个节点为叶子结点，需要其left、right均为空。如果简单的用ans=min(left,right)+1，那么可能出现某个节点左空右非空，但是其并未结束。这是最大深度情况下用max所不会发生的问题。应对方案为：判断左右都空、左空右非空、左非空右空、左右均非空四种情况。不能直接套用104最大深度。

涉及二叉树的问题递归方便。

时间复杂度O(a+b+m) m为list2长度。简单按顺序一步一步做即可。

麻烦的点在于很难判断本节点是否需要移除，本节点是否移除不一定由下一个节点值决定，可能与下下一个，甚至再下一个节点等等来决定。将链表反转，那么可以用本节点来判断下一个节点是否需要移除，思路就顺很多，结束后将链表再次反转即可。

这里不能遍历节点再遍历数组，时间复杂度为O(mn)会超时。时间复杂度O(n+m) 遍历一遍数组再遍历一遍链表。空间复杂度O(n) 哈希表来存储数组。使用哈希表，空间换时间。

设置pre和cur，判断如果cur的val==val，那么删除该节点，具体操作为pre->next=cur->next。否则将pre移动到cur。然后cur移动到下一个。有可能对头节点进行操作，因此使用dummy简化书写。

每次判断cur和cur->next的val是否相等，相等则删去cur，不相等时跳出内层while，并且根据flag来判断是否删除cur。只要某个元素重复，那么删除其所有的节点，由于已经按照升序排列，那么删的时候一定是一块一块删。设置pre和cur，flag用于判断是否出现重复节点。可能删除头节点，因此使用dummy方便操作。时间复杂度O(n) 一共遍历n个结点。

非空情况下，判断cur->next->val与cur->val是否相等，是则cur连接到下下一个节点，否则cur移动到下一个节点。最后cur->next=nullptr。也就是一个一个删除节点。首先要判断其是否为空链表，空链表没有head->next。由于head一定不删去，故不需要dummy。在已经保证升序排列的情况下很简单。时间复杂度O(n) n为链表长度。

前后指针，保证前后两个指针相差为n。当前指针指向最后一个节点时，后指针指向倒数第n+1个结点，只需要让后指针->next指向后指针->next->next即可，也即删除倒数第n个结点。时间复杂度O(n) n为链表长度，两个while加起来让pre走了n。由于可能删除头节点，使用dummy可以简化代码书写。

正常的删除某个节点的思路应当是：令1->3.但是在本题中2的前一个节点，也就是1是未知的，无法做到1->3.令2=3，然后2->4，相当于把原来3的位置的节点挪到了2。对于1->2->3->4，假设要删除2。

同样143修改，head和head2两个指针同时遍历，每次遍历更新ans。

对143稍作修改即可，判断两个指针指向的是否一直相等。终止条件为不等或者head2=nullptr。

不能简单的头尾交替，尾部没法倒着寻结点，因此需要从中间的结点开始，右边部分反转链表，然后按照顺序重连链表。需要实现的功能：找中间结点，反转链表，链表重新排序。

快指针速度为慢指针两倍，第一次相遇时可以建立变量间数值关系。根据上面的推导，确认head和fast一定会在入环结点相遇。与141相比，变化的是输出量，需要输出环的起始结点。

如果有环，那么快指针一定能在环上追上慢指针，否则快指针->next会为nullptr。这样只需要遍历一遍，并且空间复杂度小。时间复杂度O(n) n为链表长度。

边界：快指针->nullptr（奇数个结点）或者快指针->->nullptr（偶数个结点）快指针每次走2步，慢指针每次走1步。

如果下一位没有了，那么不需要考虑，如果下一位存在并且产生进位，那么本位+1.由于本位翻倍进位后+1与本位翻倍，对上一位产生的进位结果是相同的，9*2+1进1位，9*2也是进1位，其余的也一样，因此本位是否接收进1对上一位是否进位无影响，只有本位本身的数字有影响。翻倍数字，主要问题在于1、当前位翻倍后可能影响上一位的结果，以及2、首位翻倍可能产生新的进位，位数增加。对于2、首位大于4时创建一个新节点为1，指向原来的head，并且将head指向新节点即可。时间复杂度O(n) n为链表长度。

反转链表，head指向最低位，开始逐位相加，并且需要注意是否有进位。计算结束后再反转链表。时间复杂度O(n) n为较长的链表长度。注意其中是否有l1/l2为空的情况。

25、K个一组翻转链表 的特殊情况 K=2即可。时间复杂度O(n) 与链表长度有关。

对2，在开头用for统计节点个数n。在反转时，当n>=k时继续进行，每次n-=k即可，这里用while可能思路更清晰一些(while(n>=k))对1，用一个k次的for循环移动p0 k次即可，或者设置一个变量记录，在反转的末尾将p0移动过去。1、每次结束一组反转后，p0移动到该组的末尾节点，该节点也是下一组的头节点的前一个节点。在92. 反转链表 II的基础上多了一点东西。2、最后一组不翻转，也就是需要计算翻转个数。

在反转过程中cur、pre等最后都在right附近，因此需要一个变量存储left的前一个节点（当然也可以用for循环，但是时间会变多），记p0指向left的前一个节点。反转结束后，p0依旧指向left，使用p0->next来获得p0的下一个节点left，先令left指向right(pre)的后一个节点cur，再令left的前一个节点p0指向right(pre)，即完成了对[left,right]的反转。由于left已知，用for循环遍历left-1次，p0即指向left的前一个节点。

2、cur->next = pre cur本来指向nxt，改为指向pre，也就是cur前一个节点。原来是1->2->3->4->5,反转后围殴1<-2<-3<-4<-5,pre指向5为head。cur指向当前节点，pre指向cur前一个节点，nxt指向cur后一个节点。1、nxt=cur->nxt nxt为cur下一个节点，用于存储cur->next的信息。最后一个节点的->next=nullptr，因此cur为null时结束while。反转后，头节点为cur的前一个节点，也就是ptr。

相比于153，多了个有重复值。

二分的是行，for循环寻找行中最大值。时间复杂度O(nlogm)

如果出现down=-1，说明matrix[0][0]<target 那么所有数都小于target，return false即可。如果出现upper越界，也就是down指向最后一行，只能说明matrix[m][0]>target,并不能说明最后一行所有数都大于target。第二次二分查找，如果没找到，循环结束后return false，否则找到时return true。第一次闭区间查找，最后upper=down+1,在down这一行查找即可。时间复杂度O(log(mn))

如果是蓝色，那么要求target也在左边这一串，并且在mid的左边，也就是mid比target大，target比右边这一串的最大值nums[n-1]大，此时mid染蓝，right=mid-1。如果是蓝色，那么要求target夹在mid和nums[n-1]中间，也就是target<nums[n-1]并且nums[mid]<target，此时染蓝，right=mid-1.否则target在右边这一串的mid左边或者在左边这一串，染红，left=mid+1。nums[mid]==target,return即可。

对nums[mid]与nums[n-1]进行比较，小于则说明[mid,n-1]递增，那么最小值在[0,mid]中。不断更新mid,检查[mid,n-1]的单调性，小于说明单调，大于说明不单调，最小值在其中。也就是旋转后的nums数组为两个升序数组（不是旋转n=nums长度次的话）寻找原来的第一个数，也就是整个数组的最小值。left=0，right=n-2，mid将数组划分为两个区间[0,mid][mid,n-1],这两个区间一定有一个是单调递增的，另一个是增减增，在最大值与最小值处出现下降。

当left==right时一定为峰值。时间复杂度O(logn)

如：5,5,8,8... mid=6 那么i=3时remain=-2，左边不能再帮助右边分担多余值的压力，那么mid就太小了。令left=mid+1.如果全部满足，那么令right=mid-1即可。引入remain用于记录下标从0到i范围[0,i]内,允许右边匀过来多少，也即i及其左边的值空余。left=min-1，right=max，mid为查找的最大值。右边-1，左边+1，也就是说右边的数可以向左边的数“匀”，但是左边不能给右边“匀”。时间复杂度O（nlog(max-min)）

对每一个数量，相应计算需要的金额，与money作比较。写了个ReLU函数，在计算时会方便一些。money计算时会产生溢出，需要使用1LL。时间复杂度O(m*log(right)) 受二分查找边界影响。对每一台机器，二分查询其能制造的最大合金数量。外层for循环用于遍历每一台机器。

while中，进行遍历，统计满足条件的“糖果对”。如果在这个mid条件下满足条件的糖果数量cnt>=k，说明这个mid满足条件，也即[left,mid]全部满足，那么在闭区间写法下left=mid+1，否则right=mid-1.最后left=right+1时停止，return left-1即可。price排序，左边界left=0，右边界right=(最大price-最小price)/(k-1)+1,右边界情况下可以保证一定无法选择k类糖果。时间复杂度：O(nlogn+nlog(right-left))

对时间进行二分查找，其最小为mintime-1，此情况下一定不能完成任何一次trip。最大时间取两种情况的最小值，一种是最小的time完成所有trip，即mintime*totaltrips，另一种是将所有的time都视作maxtime，并行完成trip然后+1.取二者最小即可，两种都一定能完成所有的trip。中间两个int计算会溢出，使用1LL临时拓展为long long。时间复杂度O(nlogm) m为mintime和maxtime上下界之差。

判断条件：吃的时间h小于k。h的计算需要通过遍历piles数组计算。每个piles[i]，吃的时间应该是(piles[i]-1)/k。累加判断是否超过即可，注意溢出。判断其是否超过h，套二分的模板即可。使用二分查找来确定位置，这里的时间复杂度是log(max(piles[i])),后续写成logm，m记为最大值。h为k的单调不增加函数，因此可以通过查找k的位置来获得k。k的范围应当是[1，max(piles[i])]时间复杂度O(nlogm)

设当前为第i篇论文，如果i满足，那么从i开始往右的i+1,i+2，...，n-1篇都满足，这里一共n-i篇论文。也就是说，我们需要找一个尽可能小的i，满足nums[i]>=n-i，i越大，nums[i]越大，n-i越小，如果放到同一边那就是一个随着i单调递增的函数。“至少有h篇论文被引用了h次”注意最后return的不是i是n-i。

遍历，对第i个数(i为下标，从0开始)，寻找能令其满足题设条件的数x,lower<=nums[i]+x<=upper,再使用两次二分，查找满足nums[i]+x<lower的最小下标对应的数和nums[i]+x<=upper的最小下标对应的数。二者相减即获得nums[i]对应的。那么ans+=二者相减来更新。时间复杂度O(nlogn) 排序nlogn，遍历*查找也是n*logn。二分查找过程中，left初始值从i+1开始即可。先sort nums，让其有序。

sort后二分查找，闭区间写法，找到可以满足条件的数的位置，对这个咒语x（spells[x]），[left,n-1]均可满足，一共n-1-(left-1)=n-left个。时间复杂度O(nlogm+mlogm) sort用到了mlogm，后面遍历+二分查找是nlogm。注意相乘可能会溢出，需要定义一个long，然后用*=来算。空间复杂度O(n) 如果忽略return的就是O(1)

同理，找[left,mid]小于等于0的，停止时[0,left)都小于等于0，那么大于0的个数用len减去left即可。本体转换为：找0的第一个和最后一个位置，这两个位置找到了也就知道大于0和小于0的个数了。先找[left,mid]均小于0的，二分查找停止时[0,left)都小于0，那么小于0的元素个数为left个。中间left=0的一步也可以注释，没啥用，小于0的范围一定在小于等于0的范围内。没有0的时候也无所谓，返回二者的最大值即可。最后max取两个个数的最大值。时间复杂度O(logn)