Leetcode刷题第三天-贪心-双指针

738:单调递增

链接：738. 单调递增的数字 - 力扣（LeetCode）

嘶~介个介个恶心心，从后往前遍历，前一个数比当前数大，前一个数-1，当前数变为9

需要注意的是，保证每个9后面全是9

100，第一轮遍历完时90T_T

class Solution:
    def monotoneIncreasingDigits(self, n: int) -> int:
        if(n<10):   return n
        nums=[]
        tmp=n
        while tmp:
            nums.insert(0,tmp%10)
            tmp=tmp//10
        lens=len(nums)
        i=lens-1
        flage=False
        while i>0:
            if(nums[i-1]>nums[i]):
                nums[i-1]-=1
                nums[i]=9
                flage=True
            i-=1
        n=0
        start=False
        for i in range(lens):
            if(flage and nums[i]==9):
                start=True
            if(start):
                n=n*10+9
            else:
                n=n*10+nums[i]
        return n

968:监控二叉树

链接：968. 监控二叉树 - 力扣（LeetCode）

吐了，真的吐了，从未见过如次厚颜无耻之题

先是统计了每层节点个数，想按层安装，但是会出现子层节点少于父层节点，若在子层节点安装，还需要计算父-父层，跳不出来了T_T

然后迭代，后序遍历T_T左在前，左空的时候直接安到根上，右丢了，右在前，左空了，又跑根上了

最后递归，俩孩子有一个没有被覆盖，父就要安，俩孩子都被覆盖到了，父歇着就好，等待后续判断要不要安，其他情况父被覆盖，最后返回根的左右俩孩子状态，俩孩子都是0，根安T_T我真的已经哭死了

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def minCameraCover(self, root: Optional[TreeNode]) -> int:
        re=[0]
        if(self.help(root,re)==0):  re[0]+=1
        return re[0]

    def help(self,root,re):
        if(not root):   return 2
        left=self.help(root.left,re)
        right=self.help(root.right,re)
        #左右都有覆盖，当前什么都不做
        if(left==2 and right==2):
            return 0
        #左右有一个没覆盖，自己有摄像头
        elif(left==0 or right==0):
            re[0]+=1
            return 1
        else:
            #左右有一个摄像头，自己被覆盖
            return 2

更新迭代做法

利用数组（python没有栈，数组就好）pop()取最后加入数组得元素，按照【根空右左】顺序加入数组，左右节点空不加，在根节点后面加入一个空值作为标记，当从数组种取出得元素为空时，证明他的左右节点已经判断完，需要对当前节点进行判断

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def minCameraCover(self, root: Optional[TreeNode]) -> int:
        if(not root):   return 0
        sums=0
        stack=[root]
        while stack:
            cur=stack.pop()
            if(cur):
                stack.append(cur)
                #插入一个空节点，作为标记，遇到空节点就要开始判断是否安摄像头
                stack.append(None)
                #左右孩子入栈，空不入
                if(cur.right):  stack.append(cur.right)
                if(cur.left):   stack.append(cur.left)
            else:
                #遇到空，继续取最后一个，判断自己是否安
                cur=stack.pop()
                left,right=2,2
                if(cur.left):   left=cur.left.val
                if(cur.right):  right=cur.right.val
                if(left==0 or right==0):
                    sums+=1
                    cur.val=1
                elif(left==2 and right==2):
                    cur.val=0
                    #栈空，说明到最后一个根节点，左右孩子被覆盖但是没有摄像头，自己没有被覆盖，所以自己还要安一个
                    if(not stack):  sums+=1
                else:
                    cur.val=2
        return sums

 

不行了，需要换个脑子了，开始双指针之旅

167:两个数之和

链接：167. 两数之和 II - 输入有序数组 - 力扣（LeetCode）

(⊙﹏⊙)就两头开始加

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        if(not numbers):    return numbers
        left,right=0,len(numbers)-1
        while True:
            if(left==right):    break
            if(numbers[left]+numbers[right]==target):   return [left+1,right+1]
            elif(numbers[left]+numbers[right]>target):  right-=1
            else:   left+=1
        return []

            

142:环形链表

链接：142. 环形链表 II - 力扣（LeetCode）

俩个指针，快的每次走两步，慢的每次走一步，链表有环，快的会再比慢的多走n个环的距离时相遇（跑步套圈）

找环的入口：从头再来一个指针3，也是每次都走一步，指针3和慢指针相遇的时候，比慢指针少走了一个环，相遇位置就是环口

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if(not head):   return None
        start,link=head,head
        while link and link.next:
            link=link.next.next
            start=start.next
            if(link==start):
                start=head
                while start!=link:
                    start=start.next
                    link=link.next
                return link
        return None

    

76：最小覆盖字串

链接：76. 最小覆盖子串 - 力扣（LeetCode）

更新更新，把一坨更新了一下，终于可以看清了T_T

class Solution(object):
    def minWindow(self,s,t):
        if(not s):  return ""
        #t长度，要找到得字符得个数
        lent=len(t)
        lens=len(s)
        if(lens<lent):  return ""
        #记录t中每个字母出现得频率
        flage={x:t.count(x) for x in t}
        left,minleft,minright=0,-1,lens
        for right in range(lens):
            #遍历s，开始移动右边界，如果当前得字符在t中，对应频率数组-1，如果频率大于0，要找得字符个数-1
            if(s[right] in t):
                flage[s[right]]-=1
                if(flage[s[right]]>=0): lent-=1
            #要找得字符个数为0时，当前[left,right]范围内包含全部得t中字符，闭区间
            if(lent==0):
                while left<=right:
                    #开始移动左边界，如果当前字符在t中，并且lent==0,表示为当前满足题意左边界最大值，判断当前窗口和要窗口大小，谁小取谁，并且频率数组+1，表示左边界开始移动，目标窗口内得字符个数减少
                    if(s[left] in t):
                        if(minright-minleft>right-left and lent==0):
                            minright=right
                            minleft=left
                        flage[s[left]]+=1
                        #当字符频率大于0时，表示当前窗口缺少这个字符，要找得字符长度+1
                        if(flage[s[left]]>0): lent+=1
                    left+=1
                    #要找得字符个数大于0，结束循环
                    if(lent>0): break
        #右边界为s长度，表示没有合适得长度
        if(minright==lens): return ""
        return s[minleft:minright+1]