Skip to content

Commit

Permalink
Update
Browse files Browse the repository at this point in the history
  • Loading branch information
@youngyangyang04
youngyangyang04 committed Oct 25, 2021
2 parents 104ba7c + bed1f5a commit c3cc5fb
Show file tree
Hide file tree
Showing 61 changed files with 1,995 additions and 612 deletions.
111 changes: 62 additions & 49 deletions problems/0017.电话号码的字母组合.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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) # 递归至下一层 + 回溯
```


Expand Down
2 changes: 1 addition & 1 deletion problems/0019.删除链表的倒数第N个节点.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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指向的下一个节点，如图：
Expand Down
2 changes: 1 addition & 1 deletion problems/0028.实现strStr.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -215,7 +215,7 @@ next数组就可以是前缀表，但是很多实现都是把前缀表统一减

其实**这并不涉及到KMP的原理，而是具体实现，next数组即可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。**

后面我会提供两种不同的实现代码，大家就明白了了。
后面我会提供两种不同的实现代码，大家就明白了。

# 使用next数组来匹配

Expand Down
19 changes: 18 additions & 1 deletion problems/0035.搜索插入位置.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
105 changes: 30 additions & 75 deletions problems/0037.解数独.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
80 changes: 64 additions & 16 deletions problems/0039.组合总和.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
Loading

0 comments on commit c3cc5fb

Please sign in to comment.