73 - 77

 

 73： 矩阵置零

我跟官方解竟然一样哎  难点在于原地 

 

 

 

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """ 
        m = len(matrix)
        n = len(matrix[0])
        fir0row = -1
        fir0col = -1
        #找到第一个0所在的行列
        for i in range(m):
            for j in range(n):
                if matrix[i][j] == 0:
                    fir0row = i
                    fir0col = j
                    break
            else:
                continue
            break
        if fir0row == -1:          #找不到就返回
            return matrix
        else:
            for i in range(fir0row,m):
                for j in range(n):
                    if matrix[i][j] == 0:
                        matrix[fir0row][j] = 0
                        matrix[i][fir0col] = 0      #遍历整个数组  用记录器记录
            for j in range(n):
                if j == fir0col:
                    continue
                if matrix[fir0row][j] == 0:       #如果参考行的某一列为0 那么 这一列全变成0
                    for i in range(m):
                        matrix[i][j] = 0
            for i in range(m):
                if i == fir0row:
                    continue
                if matrix[i][fir0col] == 0:       #如果参考列的某一行为0 那么 这一行全变成0
                    for j in range(n):
                        matrix[i][j] = 0
            for i in range(m):          #变记录器所在行列
                matrix[i][fir0col] = 0
            for j in range(n):
                matrix[fir0row][j] = 0
            return matrix

 

74 ： 搜索二维矩阵 

为什么会有这么多人击败我 为什么？？ 我知道额 因为我只用了一次二分法

没想到要用两个 二分法

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        row = -1
        m = len(matrix)
        n = len(matrix[0])
        if target > matrix[m-1][n-1] or target < matrix[0][0]:
            return False
        for i in range(m):
            if target <= matrix[i][n-1]:
                row = i
                break
        left = 0
        right = n-1
        while left <= right:
            mid = (left+right)//2
            if matrix[row][mid]== target:
                return True
            elif matrix[row][mid] > target:
                right = mid - 1
            else:
                left = mid + 1
        return False

75“：  颜色分类  快排的思路  

將數組劃分爲三段，

ord0之前全是0

ord0到ord2后全是未排序的

ord2之后全是2

遍历时 遇到0就和ord0的交换

遇到2就和ord2的交换

注意遍历位置的移动。

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        pos = 0
        ord0 = 0
        n = len(nums)
        ord2 = n-1
        while pos <= ord2:
            if nums[pos] == 0:
                nums[ord0],nums[pos] = nums[pos],nums[ord0]
                ord0 += 1
                pos += 1
            elif nums[pos] == 1:
                pos += 1
            else:
                nums[ord2],nums[pos] = nums[pos],nums[ord2]
                ord2 -= 1
        return nums

 

76： 

最小覆盖子串 

就是滑动窗口 遍历就不说了 就是遇到一个字典加一个

重要的是遇到一个满足条件的子串后怎么办！！！ 满足条件就是包含t中所有的

我做了两步

1：收缩左边界 直到不满足条件 这样左窗口会多滑一格 它左边的一位也是我们要的

2： 比较现窗口和最小窗口的长度 注意长度是R-L+2 因为上面少了一位 如果小 结果改为现在的窗口

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        def check(dict1,dict2):
            for each in dict1:
                if dict1[each] < dict2[each]:
                    return False
            return True
        tdict = {}
        left = 0
        right = 0
        ns = len(s)
        sdict = {}
        rel =""
        minlen = ns+1
        for each in t:
            if each not in tdict:
                tdict[each] = 1
                sdict[each] = 0
            else:
                tdict[each] += 1
        while right< ns:
            if s[right] in sdict:
                sdict[s[right]] += 1
            if check(sdict , tdict):
                while check(sdict,tdict):
                    if s[left]  in sdict:
                        sdict[s[left]] -= 1
                    left += 1
                    if left == ns:
                        return s[-1]
                if right-left+2 < minlen:
                    minlen = right-left+2
                    rel = s[left-1:right+1]
                while s[left] not in sdict:
                    left += 1
                    if left == ns:
                        return rel
            right += 1
        return rel

 

 

 

77 组合  

普通·的回溯 普通的一天

每次回溯传入的是当前层可以加入的最小的数 保证递增的结果

只回溯了n-k+2 作为开头的那些 后面的长度不够

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        rel = []
        currel = []
        def dfs(s):
            if len(currel) == k:
                rel.append(currel[:])
            for i in range(s,n+1):
                currel.append(i)
                dfs(i+1)
                currel.pop()
        for i in range(1,n-k+2):
            currel.append(i)
            dfs(i+1)
            currel.pop()
        return rel