Python小白 Leetcode刷题历程 No.71-No.75 简化路径、编辑距离、矩阵置零、搜索二维矩阵、颜色分类

写在前面：

作为一个计算机院的大学生，总觉得仅仅在学校粗略的学习计算机专业课是不够的，尤其是假期大量的空档期，作为一个小白，实习也莫得路子，又不想白白耗费时间。于是选择了Leetcode这个平台来刷题库。编程我只学过基础的C语言，现在在自学Python，所以用Python3.8刷题库。现在我Python掌握的还不是很熟练，算法什么的也还没学，就先不考虑算法上的优化了，单纯以解题为目的，复杂程度什么的以后有时间再优化。计划顺序五个题写一篇日志，希望其他初学编程的人起到一些帮助，写算是对自己学习历程的一个见证了吧。

有一起刷LeetCode的可以关注我一下，我会一直发LeetCode题库Python3解法的，也可以一起探讨。

觉得有用的话可以点赞关注下哦，谢谢大家！
········································································································································································

No.71.简化路径

难度：中等
题目描述：

题解代码（Python3.8）

class Solution:
    def simplifyPath(self, path: str) -> str:
        stack=[]
        path=path.split('/')
        for item in path:
            if item == '..':
                if stack:
                    stack.pop()
            elif item and item!='.':
                stack.append(item)
        return '/'+'/'.join(stack)

或许有用的知识点：
这道题可能用到split()函数，split()函数的一些介绍如下：

解题思路：
这道题有关路径，可以运用栈的思想。先初始化一下，将原字符串在有”/”的地方分割开，形成一系列小字符串，再将小字符串依次压入栈中，碰到”…”就将栈中最后一个元素弹出，碰到”.”不做修改。最后将栈中元素按照目录的格式依次输出形成字符串即可。

No.72.编辑距离

难度：困难
题目描述：

题解代码（Python3.8）

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        l1 = len(word1)
        l2 = len(word2)
        dp = [[0]*(l2+1) for _ in range(l1+1)]
        for j in range(1,l2+1):                     #第一行
            dp[0][j] = dp[0][j-1] + 1   
        for i in range(1,l1+1):                     #第一列
            dp[i][0] = dp[i-1][0] + 1
        for i in range(1,l1+1):
            for j in range(1,l2+1):
                if word1[i-1] == word2[j-1]:        #word[i]对应dp[i+1]        
                    dp[i][j] = dp[i-1][j-1]
                else:                               #进行‘增’,‘删’,‘改’
                #(dp[i-1][j]+1)为‘增’，(dp[i][j-1]+1)为‘删’，(dp[i-1][j-1]+1)为‘改’
                    dp[i][j] = min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1
        return dp[l1][l2]

或许有用的知识点：
这道题要用到动态规划，且有动态规划问题中‘自底向上’思路和‘自顶向下’思路区别的分析（‘自顶向下’的思路可能要用到‘缓存+递归’的方法，此时会用到functools.lru_cache装饰器，再本题’优解代码及分析中有详细介绍‘）。
‘自底向上’的思路是比较容易想到的，是先依次解决小问题，最终解决所求问题；在树形结构中，就是先解决底部的问题，再一层层解决向上的问题，最后解决顶部的所求问题。
而‘自顶向下’的思路是比较不容易想到的，是先看解决最终问题依次需要解决哪些小问题，再解决所有的小问题；在树形结构中，就是先看解决顶部的问题需要解决哪些子问题，再看解决这些子问题需要解决哪些子问题，直到解决最底部的问题。引用知乎大佬给出的生动形象的小例子：
某日小明上数学课，他的老师给了很多个不同的直角三角板让小明用尺子去量三角板的三个边，并将长度记录下来。两个小时过去，小明完成任务，把数据拿给老师。老师给他说，还有一个任务就是观察三条边之间的数量关系。又是两个小时，聪明的小明连蹦带跳走进了办公室，说：“老师，我找到了，三条边之中有两条，它们的平方和约等于另外一条的平方。”老师拍拍小明的头，“你今天学会了一个定理，勾股定理。它就是说直角三角形有两边平方和等于第三边的平方和”。
另一个故事，某日老师告诉小明“今天要教你一个定理，勾股定理。”小明说，“什么是勾股定理呢？”“勾股定理是说，直角三角形中有两条边的平方和等于第三边的平方。”然后老师给了一大堆直角三角板给小明，让他去验证。两个小时后，小明告诉老师定理是正确的.
两个故事刚好是语法分析里面对应的两个方法：第一个故事说的是自底向上的分析方法，第二个故事说的是自顶而下的分析方法。

解题思路：
这道题是求最优解的问题，我们可以使用动态规划的方法。套用动态规划算法的模板，对于这道题，令dp[i][j]为代表word1到i位置转换成word2到j位置需要最少步数,则动态规划的三要素为：
状态：
对“dp[i-1][j-1] 表示替换操作，dp[i-1][j] 表示删除操作，dp[i][j-1] 表示插入操作。”的理解：以 word1 为 “horse”，word2 为 “ros”，且 dp[5][3] 为例，即要将 word1的前 5 个字符转换为 word2的前 3 个字符，也就是将 horse 转换为 ros，因此有：
(1) dp[i-1][j-1]，即先将 word1 的前 4 个字符 hors 转换为 word2 的前 2 个字符 ro，然后将第五个字符 word1[4]（因为下标基数以 0 开始） 由 e 替换为 s（即替换为 word2 的第三个字符，word2[2]）。
(2) dp[i][j-1]，即先将 word1 的前 5 个字符 horse 转换为 word2 的前 2 个字符 ro，然后在末尾补充一个 s，即插入操作。
(3) dp[i-1][j]，即先将 word1 的前 4 个字符 hors 转换为 word2 的前 3 个字符 ros，然后删除 word1 的第 5 个字符。
状态转移方程：
if word1[i-1] == word2[j-1]: dp[i][j] = dp[i-1][j-1]
else: dp[i][j] = min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1
边界条件：
for j in range(1,l2+1): dp[0][j] = dp[0][j-1] + 1
for i in range(1,l1+1): dp[i][0] = dp[i-1][0] + 1

优解代码及分析：
优解代码（Python3.8）

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        import functools
        @functools.lru_cache(None)
        def helper(i, j):
            if i == len(word1) or j == len(word2):
                return len(word1) - i + len(word2) - j
            if word1[i] == word2[j]:
                return helper(i + 1, j + 1)
            else:
                inserted = helper(i, j + 1)
                deleted = helper(i + 1, j)
                replaced = helper(i + 1, j + 1)
                return min(inserted, deleted, replaced) + 1
        return helper(0, 0)

分析：
这其实是缓存+递归的方式，原理和动态规划一样。要用到functools.lru_cache装饰器。

No.73.矩阵置零

难度：中等
题目描述：

题解代码（Python3.8）

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        l_row = len(matrix)
        l_col = len(matrix[0])
        flag_row0 = False
        flag_col0 = False
        for j in range(l_col):       #判断第一行是否有0
            if matrix[0][j] == 0:
                flag_row0 = True
                break
        for i in range(l_row):        #判断第一列是否有0
            if matrix[i][0] == 0:
                flag_col0 = True
                break
        for i in range(l_row):      #以第一行、第一列列作为标志位，记录0的存在与否
            for j in range(l_col):
                if matrix[i][j] == 0:
                    matrix[i][0] = matrix[0][j] = 0
        for i in range(1,l_row):      #置0过程(除边界)
            for j in range(1,l_col):
                if matrix[i][0] == 0 or matrix[0][j] == 0:
                    matrix[i][j] = 0
        if flag_row0:               #第一行置0
            for j in range(l_col):
                matrix[0][j] = 0
        if flag_col0:               #第一列置0
            for i in range(l_row):  
                matrix[i][0] = 0

解题思路：
用matrix第一行和第一列记录该行该列是否有0,作为标志位。但是对于第一行,和第一列要设置一个标志位,为了防止自己这一行(一列)也有0的情况.注释写在代码里,直接看代码很好理解!

优解代码及分析：
优解代码（Python3.8）

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        flag_col = False
        l_row = len(matrix)
        l_col = len(matrix[0])
        for i in range(l_row):
            if matrix[i][0] == 0: 
                flag_col = True
            for j in range(1,l_col):
                if matrix[i][j] == 0:
                    matrix[i][0] = matrix[0][j] = 0
        for i in range(l_row - 1, -1, -1):
            for j in range(l_col - 1, 0, -1):
                if matrix[i][0] == 0 or matrix[0][j] == 0:
                    matrix[i][j] = 0
            if flag_col == True: 
                matrix[i][0] = 0

分析：
这是之前题解的简化版，用循环减少了一个空间复杂度。

No.74.搜索二维矩阵

难度：中等
题目描述：

题解代码（Python3.8）

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

或许有用的知识点：
这道题要用到二分查找算法。

解题思路：
首先将二维数组投影为一维数组，如下图所示。
算法流程：
1.特判，若matrix为空或matrix[0]为空，主要应对[]和[[]]。
2.初始化矩阵行数m和列数n。初试化查询左右界l=0，r=m*n-1。
3.循环条件，当l<=r时进入循环：mid=(l+r)//2，若matrix[mid//n][mid%n]==target，直接返回True；如果matrix[mid//n][mid%n]>target，令r=mid-1；否则，令l=mid+1返回False。

No.75.颜色分类

难度：中等
题目描述：

题解代码（Python3.8）

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        l = len(nums)
        if l < 2:
            return
        zero = 0
        two = l
        i = 0
        # all in [0, zero) = 0
        # all in [zero, i) = 1
        # all in [two, len - 1] = 2
        while i < two:
            if nums[i] == 0:
                nums[i],nums[zero] = nums[zero],nums[i]
                i += 1
                zero += 1
            elif nums[i] == 1:
                i += 1
            else:
                two -= 1
                nums[i],nums[two] = nums[two],nums[i]

或许有用的知识点：
这道题要用到双指针的思想。
做对这道题需要熟悉快速排序的 partition 过程，重点是设置循环不变量（在Java的JDK源码中Arrays.sort()有同种方法，如下图）。

解题思路：
循环不变量是这样定义的：
所有在子区间 [0, zero) 的元素都等于 0；所有在子区间 [zero, i) 的元素都等于 1；所有在子区间 [two, len - 1] 的元素都等于 2。这满足了设计循环不变量的原则——“不重不漏”。
1、len 是数组的长度；2、变量 zero 是前两个子区间的分界点，一个是闭区间，另一个就必须是开区间；3、变量 i 是循环变量，一般设置为开区间，表示 i 之前的元素是遍历过的；4、two 是另一个分界线，我设计成闭区间。
编码的时候，zero 和 two 初始化的值就应该保证上面的三个子区间全为空。在遍历的过程中，“索引先加减再交换”、还是“先交换再加减”就看初始化的时候变量在哪里。退出循环的条件也看上面定义的循环不变量，在 i == two 成立的时候，上面的三个子区间就正好“不重不漏”地覆盖了整个数组，并且给出的性质成立，题目的任务也就完成了。