Leetcode-D48-数组-75. 颜色分类&77. 组合

一、复习

74、搜索二维矩阵

连成一维矩阵再做处理。
没啥问题

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m = len(matrix)
        n = len(matrix[0])

        l=0
        r=m*n-1

        while l<=r:
            mid = (l+r)>>1
            x = mid//n
            y = mid%n
            if matrix[x][y]<target:
                l = mid+1
            elif target<matrix[x][y]:
                r=mid-1
            else:
                return True
        return False 

75. 颜色分类（需复习）

1、感觉直接用冒泡就可以啊
2、题目最后给出的「进阶」要求，其实考察的是「快速排序」的子过程 partition，即：通过一次遍历，把数组分成三个部分。
3、大概理解了一下，就是和前面换、和后面换、中间不动。
4、刚开始错了，但是调试了一下，发现是因为你swap后面的数字时【nums[i]==2时】，如果i+1会导致，有一些数被忽略去。也就相当于，被换过来的数还没有排序，就被当成是已经排序的了。

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        size = len(nums)
        zero = 0
        i= 0

        def swap(nums,index1,index2):
            nums[index1],nums[index2]=nums[index2],nums[index1]

        while (i<size):
            if nums[i]==0:
                swap(nums,i,zero)
                zero+=1
                i+=1
            elif nums[i]==2:
                swap(nums,size-1,i)
                size-=1
            else:
                i+=1
        return nums

77. 组合（需复习）

1、感觉很像递归
2、感觉变量串在一块了，乱七八糟的

    def combine(self, n: int, k: int) -> List[List[int]]:
        nums = [i for i in range(1,n+1)]
        def com(nums,k,res,path):
            for j in range(len(nums)):
                tmp_num = nums[:j]+nums[j+1:]
                path.append(nums[j])
                k-=1
                if k==0:
                    res.append(path)
                    return
                else:
                    com(tmp_num,k,res,path)
        res =[]
        com(nums,k,res,[])
        return res

3、确实是这个想法，看一下别人怎么写的，才能不tingle
4、好不容易差不多了，好像还有重复的，需要剪枝。

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        nums = [i for i in range(1, n + 1)]

        def com(nums, k, res, path):
            for j in range(len(nums)):
                if k == 0:
                    res.append(path)
                    return
                else:
                    com(nums[:j] + nums[j + 1:],k-1, res, path+[nums[j]])

        res = []
        com(nums, k, res, [])
        return res

5、没想到，极其糟心的代码居然通过了，还是看看大佬们的把。
不过回溯问题，最好还是把path的改变写在函数里，要不然变量容易混。

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        nums = [i for i in range(1, n + 1)]

        def com(nums, k, res, path):
            if k > len(nums):
                return
            if len(nums)==0 and k==0:
                res.append(path)
                return
            for j in range(len(nums)):
                if k == 0:
                    res.append(path)
                    return
                else:
                    com(nums[j + 1:], k - 1, res, path + [nums[j]])

        res = []
        com(nums, k, res, [])
        return res

6、看了看答案，还是觉得自己想得比较重要。再修改一下。
好像也没什么可以精进的。先这样叭_{明天再想想}