3.10 一轮练习hot100（48. 旋转图像 49. 字母异位词分组 64. 最小路径和 75. 颜色分类）

题一：48. 旋转图像

链接

题目链接：
文章链接：

关键点

编程思路

Me：

力扣实战

思路一：储存法

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        n=len(matrix)
        if n==1:
            return
        tem = [[0]*n for _ in range(n)] #tem[:][:] = matrix[:][:];  tem = matrix
         #想用一个临时矩阵来储存matrix，但是这个语法不对，这样tem会和matrix一起改变
        for i in range(n):
            for j in range(n):
                tem[i][j]=matrix[i][j]
        for i in range(n):
            for j in range(n):
                matrix[j][n-1-i]=tem[i][j] 
	#去除了我冗余的一步
class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)
        # Python 这里不能 matrix_new = matrix 或 matrix_new = matrix[:] 因为是引用拷贝
        matrix_new = [[0] * n for _ in range(n)]
        for i in range(n):
            for j in range(n):
                matrix_new[j][n - i - 1] = matrix[i][j]
        # 不能写成 matrix = matrix_new
        matrix[:] = matrix_new

        
# 反思1：

思路二：用翻转代替旋转

 class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)
        # 水平翻转
        for i in range(n // 2):
            for j in range(n):
                matrix[i][j], matrix[n - i - 1][j] = matrix[n - i - 1][j], matrix[i][j]
        # 主对角线翻转
        for i in range(n):
            for j in range(i):
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

题二：49. 字母异位词分组

链接

题目链接：
文章链接：

关键点

编程思路

Me：

1. 考虑使用字典或者set来判断是否相同
2. 若是暴力的话会重复判断许多，所以考虑双指针，把相同的部分换到最后

力扣实战

思路一：哈希法

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        #哈希法
        mp = collections.defaultdict(list)
        strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
        for st in strs:
            counts = [0] * 26
            for ch in st:
                counts[ord(ch) - ord("a")] += 1
            # 需要将 list 转换成 tuple 才能进行哈希
            tem = tuple(counts)
            mp[tem].append(st)  # key是元组，val 是是一个列表，列表里的元素是字符串，所以才能够对val进行append
        return list(mp.values())   
        # 此时若是打印mp.values(): dict_values([['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']])

 
        
# 反思1：

思路二：排序法

 class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        #排序法
        mp = collections.defaultdict(list)

        for st in strs:
            key = "".join(sorted(st))   #对字符串排序，且sorted返回一个新的对象
            mp[key].append(st)
        
        return list(mp.values())

题三：64. 最小路径和

链接

题目链接：

编程思路

Me：

1. dp法

力扣实战

思路一：最基本的二维动态规划法

 class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        #最基本的二维动态规划法，
        m,n = len(grid),len(grid[0])
        dp = [[0]*n for _ in range(m)] # dp[i][j]表示走到i行j列的最小花费
        dp[0][0]=grid[0][0]
        for i in range(1,n):
            dp[0][i]=dp[0][i-1] +grid[0][i]
        for i in range(1,m):
            dp[i][0]=dp[i-1][0] +grid[i][0]
        for i in range(1,m):
            for j in range(1,n):
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j]
        return dp[-1][-1] 
        
# 反思1：

思路二：一维dp，优化了空间，ez

 class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        #最基本的一维动态规划法，
        m,n = len(grid),len(grid[0])
        dp = [0]*n  # dp[i][j]表示走到i行j列的最小花费
        dp[0]=grid[0][0]
        for i in range(1,n):
            dp[i]=dp[i-1] +grid[0][i]
        for i in range(1,m):
            dp[0] += grid[i][0]
            for j in range(1,n):
                dp[j]=min(dp[j-1],dp[j])+grid[i][j]
        return dp[-1]

题四：75. 颜色分类

链接

题目链接：
文章链接：

编程思路

Me：

1. 提示了只使用常数空间一次扫描，明显是多指针法三指针，左指针用来存放0，右指针用来存放2，中指针用来找0和2
2. 本题还可以使用哈希表存储三个元素出现的次数，然后再输出数组，哈希表可以用.数组或者字典模拟
3. 或者多趟扫描：第一趟扫描0，用一个指针储存并且记录第二趟的起点，第二趟扫描1

力扣实战

思路一：两趟扫描，先保证ac

 class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # 思路：提示了只使用常数空间一次扫描，明显是多指针法三指针，左指针用来存放0，右指针用来存放2，中指针用来找0和2
        # 本题还可以使用哈希表存储三个元素出现的次数，然后再输出数组，哈希表可以用数组或者字典模拟
        # 或者多趟扫描：第一趟扫描0，用一个指针储存并且记录第二趟的起点，第二趟扫描1
        left ,mid =0,0
        right = len(nums)-1
        for i in range(right+1):
            if nums[i]==0:
                nums[i],nums[left]=nums[left],nums[i]
                left+=1
        l = left
        for i in range(l,right+1):
            if nums[i]==1:
                nums[i],nums[left]=nums[left],nums[i]
                left+=1
        
# 反思1：

思路二：一次遍历通过！！！yes！这55min值了…555

 class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # 思路：提示了只使用常数空间一次扫描，明显是多指针法三指针，左指针用来存放0，右指针用来存放2，中指针用来找0和2
        # 本题还可以使用哈希表存储三个元素出现的次数，然后再输出数组，哈希表可以用数组或者字典模拟
        # 或者多趟扫描：第一趟扫描0，用一个指针储存并且记录第二趟的起点，第二趟扫描1
        left ,mid =0,0
        right = len(nums)-1
        while left<=mid<=right:   #注意此处的边界问题，必须加=，最好在边界问题多做几个假设。
            while left<=mid<=right and (nums[mid]==0 or nums[mid]==2):
                if nums[mid]==0:
                    nums[left],nums[mid]=nums[mid],nums[left]
                    left+=1
                elif nums[mid]==2:
                    nums[right],nums[mid]=nums[mid],nums[right]
                    right-=1
            mid+=1
    #bug过程：1.mid<right 导致示例2没有通过；2.改为mid<=right，提交，过了40个，一半，[1,2,0]不过
    #3.考虑mid换后为0或者2的情况，使用while，只过了一个示例！
    #4.观察错误时的特点，发现mid和left会陷入互换死循环，偶然想到加上左边的小于等于，恰好可以终止死循环，ac！