Update

Author: youngyangyang04

problems/0017.电话号码的字母组合.md

@@ -282,61 +282,74 @@ class Solution {
 ```
 
 ## Python 
-
-```Python
+**回溯**
+```python3
 class Solution:
-    ans = []
-    s = ''
-    letterMap = {
-        '2': 'abc',
-        '3': 'def',
-        '4': 'ghi',
-        '5': 'jkl',
-        '6': 'mno',
-        '7': 'pqrs',
-        '8': 'tuv',
-        '9': 'wxyz'
-    }
+    def __init__(self):
+        self.answers: List[str] = []
+        self.answer: str = ''
+        self.letter_map = {
+            '2': 'abc',
+            '3': 'def',
+            '4': 'ghi',
+            '5': 'jkl',
+            '6': 'mno',
+            '7': 'pqrs',
+            '8': 'tuv',
+            '9': 'wxyz'
+        }
 
-    def letterCombinations(self, digits):
-        self.ans.clear()
-        if digits == '':
-            return self.ans
+    def letterCombinations(self, digits: str) -> List[str]:
+        self.answers.clear()
+        if not digits: return []
         self.backtracking(digits, 0)
-        return self.ans
-
-    def backtracking(self, digits, index):
-        if index == len(digits):
-            self.ans.append(self.s)
-            return
-        else:
-            letters = self.letterMap[digits[index]]  # 取出数字对应的字符集
-            for letter in letters:
-                self.s = self.s + letter  # 处理
-                self.backtracking(digits, index + 1)
-                self.s = self.s[:-1]      # 回溯
+        return self.answers
+    
+    def backtracking(self, digits: str, index: int) -> None:
+        # 回溯函数没有返回值
+        # Base Case
+        if index == len(digits):    # 当遍历穷尽后的下一层时
+            self.answers.append(self.answer)
+            return 
+        # 单层递归逻辑  
+        letters: str = self.letter_map[digits[index]]
+        for letter in letters:
+            self.answer += letter   # 处理
+            self.backtracking(digits, index + 1)    # 递归至下一层
+            self.answer = self.answer[:-1]  # 回溯
 ```
-
-python3：
-
-```py
+**回溯简化**
+```python3
 class Solution:
+    def __init__(self):
+        self.answers: List[str] = []
+        self.letter_map = {
+            '2': 'abc',
+            '3': 'def',
+            '4': 'ghi',
+            '5': 'jkl',
+            '6': 'mno',
+            '7': 'pqrs',
+            '8': 'tuv',
+            '9': 'wxyz'
+        }
+
     def letterCombinations(self, digits: str) -> List[str]:
-        res = []
-        s = ""
-        letterMap = ["","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"]
-        if not len(digits): return res
-        def backtrack(digits,index, s):
-            if index == len(digits):
-                return res.append(s)
-            digit = int(digits[index])  #将index指向的数字转为int
-            letters = letterMap[digit]  #取数字对应的字符集
-            for i in range(len(letters)):
-                s += letters[i]
-                backtrack(digits, index+1, s)  #递归，注意index+1，一下层要处理下一个数字
-                s = s[:-1]  #回溯
-        backtrack(digits, 0, s)
-        return res
+        self.answers.clear()
+        if not digits: return []
+        self.backtracking(digits, 0, '')
+        return self.answers
+    
+    def backtracking(self, digits: str, index: int, answer: str) -> None:
+        # 回溯函数没有返回值
+        # Base Case
+        if index == len(digits):    # 当遍历穷尽后的下一层时
+            self.answers.append(answer)
+            return 
+        # 单层递归逻辑  
+        letters: str = self.letter_map[digits[index]]
+        for letter in letters:
+            self.backtracking(digits, index + 1, answer + letter)    # 递归至下一层 + 回溯
 ```
 
 

problems/0019.删除链表的倒数第N个节点.md

@@ -50,7 +50,7 @@
 * fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图：
 <img src='https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B91.png' width=600> </img></div>
 
-* fast和slow同时移动，之道fast指向末尾，如题：
+* fast和slow同时移动，直到fast指向末尾，如题：
 <img src='https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B92.png' width=600> </img></div>
 
 * 删除slow指向的下一个节点，如图：

problems/0028.实现strStr.md

@@ -215,7 +215,7 @@ next数组就可以是前缀表，但是很多实现都是把前缀表统一减
 
 其实**这并不涉及到KMP的原理，而是具体实现，next数组即可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。**
 
-后面我会提供两种不同的实现代码，大家就明白了了。
+后面我会提供两种不同的实现代码，大家就明白了。
 
 # 使用next数组来匹配
 

problems/0035.搜索插入位置.md

@@ -227,7 +227,24 @@ class Solution {
     }
 }
 ```
-
+Golang:
+```golang
+// 第一种二分法
+func searchInsert(nums []int, target int) int {
+    l, r := 0, len(nums) - 1
+    for l <= r{
+        m := l + (r - l)/2
+        if nums[m] == target{
+            return m
+        }else if nums[m] > target{
+            r = m - 1
+        }else{
+            l = m + 1
+        }
+    }
+    return r + 1
+}
+```
 
 ### Python 
 ```python3

problems/0037.解数独.md

@@ -292,85 +292,40 @@ class Solution:
         """
         Do not return anything, modify board in-place instead.
         """
-        def backtrack(board):
-            for i in range(len(board)):  #遍历行
-                for j in range(len(board[0])):  #遍历列
-                    if board[i][j] != ".": continue
-                    for k in range(1,10):  #(i, j) 这个位置放k是否合适
-                        if isValid(i,j,k,board):
-                            board[i][j] = str(k)  #放置k
-                            if backtrack(board): return True  #如果找到合适一组立刻返回
-                            board[i][j] = "."  #回溯，撤销k
-                    return False  #9个数都试完了，都不行，那么就返回false
-            return True  #遍历完没有返回false，说明找到了合适棋盘位置了
-        def isValid(row,col,val,board):
-            for i in range(9):  #判断行里是否重复
-                if board[row][i] == str(val):
-                    return False
-            for j in range(9):  #判断列里是否重复
-                if board[j][col] == str(val):
-                    return False
-            startRow = (row // 3) * 3
-            startcol = (col // 3) * 3
-            for i in range(startRow,startRow + 3):  #判断9方格里是否重复
-                for j in range(startcol,startcol + 3):
-                    if board[i][j] == str(val):
-                        return False
-            return True
-        backtrack(board)
-```
-
-### Python3 
-
-```python3
-class Solution:
-    def __init__(self) -> None:
-        self.board = []
-
-    def isValid(self, row: int, col: int, target: int) -> bool:
-        for idx in range(len(self.board)):
-            # 同列是否重复
-            if self.board[idx][col] == str(target):
+        self.backtracking(board)
+
+    def backtracking(self, board: List[List[str]]) -> bool:
+        # 若有解，返回True；若无解，返回False
+        for i in range(len(board)): # 遍历行
+            for j in range(len(board[0])):  # 遍历列
+                # 若空格内已有数字，跳过
+                if board[i][j] != '.': continue
+                for k in range(1, 10):  
+                    if self.is_valid(i, j, k, board):
+                        board[i][j] = str(k)
+                        if self.backtracking(board): return True
+                        board[i][j] = '.'
+                # 若数字1-9都不能成功填入空格，返回False无解
                 return False
-            # 同行是否重复
-            if self.board[row][idx] == str(target):
+        return True # 有解
+
+    def is_valid(self, row: int, col: int, val: int, board: List[List[str]]) -> bool:
+        # 判断同一行是否冲突
+        for i in range(9):
+            if board[row][i] == str(val):
                 return False
-            # 9宫格里是否重复
-            box_row, box_col = (row // 3) * 3 + idx // 3, (col // 3) * 3 + idx % 3
-            if self.board[box_row][box_col] == str(target):
+        # 判断同一列是否冲突
+        for j in range(9):
+            if board[j][col] == str(val):
                 return False
+        # 判断同一九宫格是否有冲突
+        start_row = (row // 3) * 3
+        start_col = (col // 3) * 3
+        for i in range(start_row, start_row + 3):
+            for j in range(start_col, start_col + 3):
+                if board[i][j] == str(val):
+                    return False
         return True
-    
-    def getPlace(self) -> List[int]:
-        for row in range(len(self.board)):
-            for col in range(len(self.board)):
-                if self.board[row][col] == ".":
-                    return [row, col]
-        return [-1, -1]
-    
-    def isSolved(self) -> bool:
-        row, col = self.getPlace() # 找个空位置
-        
-        if row == -1 and col == -1: # 没有空位置，棋盘被填满的
-            return True
-        
-        for i in range(1, 10):
-            if self.isValid(row, col, i): # 检查这个空位置放i，是否合适
-                self.board[row][col] = str(i) # 放i
-                if self.isSolved(): # 合适，立刻返回, 填下一个空位置。
-                    return True
-                self.board[row][col] = "." # 不合适，回溯
-        
-        return False # 空位置没法解决
-
-    def solveSudoku(self, board: List[List[str]]) -> None:
-        """
-        Do not return anything, modify board in-place instead.
-        """
-        if board is None or len(board) == 0:
-            return
-        self.board = board
-        self.isSolved()
 ```
 
 ### Go 

problems/0039.组合总和.md

@@ -264,25 +264,73 @@ class Solution {
 }
 ```
 
-## Python
+## Python  
+**回溯**
 ```python3
 class Solution:
+    def __init__(self):
+        self.path = []
+        self.paths = []
+
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        '''
+        因为本题没有组合数量限制，所以只要元素总和大于target就算结束
+        '''
+        self.path.clear()
+        self.paths.clear()
+        self.backtracking(candidates, target, 0, 0)
+        return self.paths
+
+    def backtracking(self, candidates: List[int], target: int, sum_: int, start_index: int) -> None:
+        # Base Case
+        if sum_ == target:
+            self.paths.append(self.path[:]) # 因为是shallow copy，所以不能直接传入self.path
+            return
+        if sum_ > target:
+            return 
+        
+        # 单层递归逻辑 
+        for i in range(start_index, len(candidates)):
+            sum_ += candidates[i]
+            self.path.append(candidates[i])
+            self.backtracking(candidates, target, sum_, i)  # 因为无限制重复选取，所以不是i-1
+            sum_ -= candidates[i]   # 回溯
+            self.path.pop()        # 回溯
+```
+**剪枝回溯**
+```python3
+class Solution:
+    def __init__(self):
+        self.path = []
+        self.paths = []
+
     def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
-        res = []
-        path = []
-        def backtrack(candidates,target,sum,startIndex):
-            if sum > target: return 
-            if sum == target: return res.append(path[:])
-            for i in range(startIndex,len(candidates)):
-                if sum + candidates[i] >target: return  #如果 sum + candidates[i] > target 就终止遍历
-                sum += candidates[i] 
-                path.append(candidates[i])
-                backtrack(candidates,target,sum,i)  #startIndex = i:表示可以重复读取当前的数
-                sum -= candidates[i]  #回溯
-                path.pop()  #回溯
-        candidates = sorted(candidates)  #需要排序
-        backtrack(candidates,target,0,0)
-        return res
+        '''
+        因为本题没有组合数量限制，所以只要元素总和大于target就算结束
+        '''
+        self.path.clear()
+        self.paths.clear()
+
+        # 为了剪枝需要提前进行排序
+        candidates.sort()
+        self.backtracking(candidates, target, 0, 0)
+        return self.paths
+
+    def backtracking(self, candidates: List[int], target: int, sum_: int, start_index: int) -> None:
+        # Base Case
+        if sum_ == target:
+            self.paths.append(self.path[:]) # 因为是shallow copy，所以不能直接传入self.path
+            return
+        # 单层递归逻辑 
+        # 如果本层 sum + condidates[i] > target，就提前结束遍历，剪枝
+        for i in range(start_index, len(candidates)):
+            if sum_ + candidates[i] > target: 
+                return 
+            sum_ += candidates[i]
+            self.path.append(candidates[i])
+            self.backtracking(candidates, target, sum_, i)  # 因为无限制重复选取，所以不是i-1
+            sum_ -= candidates[i]   # 回溯
+            self.path.pop()        # 回溯
 ```
 
 ## Go