目录
LeetCode 216. 组合总和III
本题与LeetCode 77. 组合基本一致，只是增加了总和的限制，仍然使用回溯算法
class Solution:
def combinationSum3(self, k: int, n: int) -> List[List[int]]:
result = []
self.backtracking([], result, n, k, 1)
return result
def backtracking(self, path, result, n, k, start):
if len(path) == k:
if sum(path) == n:
result.append(path[:])
return
else:
return
for i in range(start,11 - (k - len(path))):
path.append(i)
self.backtracking(path, result, n, k, i + 1)
path.pop()
LeetCode 17. 电话号码的字母组合
力扣题目链接
本题与组合问题不同的是，每次遍历的集合是不一样的。组合问题的回溯函数中使用了start表示当前从哪个数字开始遍历，但本题需要指定的是当前遍历到第几个数字，从而把对应的字母集合取出来，在这个集合中进行遍历。
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
table = [
"", # 0
"", # 1
"abc", # 2
"def", # 3
"ghi", # 4
"jkl", # 5
"mno", # 6
"pqrs", # 7
"tuv", # 8
"wxyz" # 9
]
result = []
if digits:
self.backtracking(digits, result, "", 0, table)
return result
def backtracking(self, digits, result, s, index, table):
# index表示当前遍历到第几个数字，也就是到n叉树结构的第几层
if index == len(digits):
result.append(s)
return
digit = int(digits[index])
for i in range(len(table[digit])):
s += table[digit][i]
self.backtracking(digits, result, s, index+1, table)
s = s[:-1]
LeetCode 39. 组合总和
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
result = []
self.backtracking(result, [], candidates, target, 0)
return result
def backtracking(self, result, path, candidates, target, index):
if sum(path) > target:
return
elif sum(path) == target:
result.append(path[:])
for i in range(index, len(candidates)):
path.append(candidates[i])
self.backtracking(result, path, candidates, target, i)
path.pop()
剪枝：可以先对candidates进行排序，然后当遇到和大于target时，后面的肯定都大于target，就没有必要继续搜索了。
LeetCode 40. 组合总和II
本题的关键在于 如何去重，题目强调candidates包含重复元素，且其中的每个元素只能用一次，解集中不能包含重复组合。
这意味着在树枝方向，是可以有相同元素的（candidates中包含的多个相同元素），但树层方向用过的元素就不要再用了，因为这样势必会搜出重复的组合。
class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
result = []
candidates.sort()
self.backtracking(result, [], candidates, target, 0, 0)
return result
def backtracking(self, result, path, candidates, target, index, cur_sum):
if cur_sum > target:
return
elif cur_sum == target:
result.append(path[:])
return
for i in range(index, len(candidates)):
if i > index and candidates[i] == candidates[i-1]:
continue
path.append(candidates[i])
cur_sum += candidates[i]
self.backtracking(result, path, candidates, target, i+1, cur_sum)
path.pop()
cur_sum -= candidates[i]
LeetCode 131.分割回文串
力扣题目链接
本题是一个切割问题，关键就是遍历选取切割线的位置。在组合问题中，确定一个start之后遍历i代表选取第i个元素加入组合，切割问题中i就代表在第i个元素后面添加切割线，此时切割的子串就是s[start:i+1]。取出子串后判断是否是回文串，如果是进入下一层递归，如果不是就不进入递归，到这里就终止了。
class Solution:
def partition(self, s: str) -> List[List[str]]:
result = []
self.backtracking([], result, s, 0)
return result
def backtracking(self, path, result, s, start):
if start == len(s):
result.append(path[:])
return
for i in range(start, len(s)):
temp = s[start:i+1]
if temp == temp[::-1]:
path.append(temp)
self.backtracking(path, result, s, i+1)
path.pop()
LeetCode 93.复原IP地址
力扣题目链接
本题一次性通过，爽！
本题就是一个很经典的分割问题。
class Solution:
def restoreIpAddresses(self, s: str) -> List[str]:
result = []
if len(s) <= 12:
self.backtracking(result, [], s, 0)
return result
def backtracking(self, result, path, s, start):
if len(path) == 4:
if ''.join(path) != s:
return
else:
result.append('.'.join(path))
return
for i in range(start, len(s)):
temp = s[start:i+1]
# 如果有前导0，那么本次递归都可以剪枝掉
if len(temp) > 1 and temp[0] == '0':
return
if int(temp) >= 0 and int(temp) <= 255:
path.append(temp)
self.backtracking(result, path, s, i+1)
path.pop()
LeetCode 78. 子集
力扣题目链接
本题十分简单
class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
result = [[]]
self.backtracking(result, [], nums, 0)
return result
def backtracking(self, result, path, nums, start):
for i in range(start, len(nums)):
path.append(nums[i])
result.append(path[:])
self.backtracking(result, path, nums, i+1)
path.pop()
LeetCode 90. 子集II
力扣题目链接
本题需要注意去重，现将数组排序，遍历搜索时下一个元素与当前元素相同是，就不需要搜索了，会出现重复的
class Solution:
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
result = []
nums.sort()
self.backtracking(result, [], nums, 0)
return result
def backtracking(self, result, path, nums, start):
result.append(path[:])
for i in range(start, len(nums)):
if i > start and nums[i] == nums[i-1]:
continue
path.append(nums[i])
self.backtracking(result, path, nums, i+1)
path.pop()
LeetCode 491. 递增子序列
力扣题目链接
首先本题不能将数组排序。
其次本题需要注意去重，比如[1,2,3,1,1]，在遍历第一个1时会有[1], [1,1], [1,1,1]，当遍历倒数第二个1时也会有[1], [1,1]，此时按照之前的写法会出现重复。去重的逻辑是，在同一树层，相同的元素不能重复用了，因为前面会把可能的情况都搜到；不同层是可以用的，判断一下是否满足递增条件即可。
那么同一树层是哪些元素呢？其实就是nums[start:i]，这就是同一层前面已经用过的元素。
class Solution:
def findSubsequences(self, nums: List[int]) -> List[List[int]]:
result = []
self.backtracking(result, [], nums, 0)
return result
def backtracking(self, result, path, nums, start):
if len(path) >= 2:
result.append(path[:])
for i in range(start, len(nums)):
if i > start and nums[i] in nums[start:i]: # 当前树层用过的元素
continue
if not path or path[-1] <= nums[i]:
path.append(nums[i])
self.backtracking(result, path, nums, i+1)
path.pop()
LeetCode 46. 全排列
力扣题目链接
本题是排列问题，使用used数组标记排列中已取的元素
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
result = []
used = [0] * len(nums)
self.backtracking(result, [], nums, used)
return result
def backtracking(self, result, path, nums, used):
if len(path) == len(nums):
result.append(path[:])
for i in range(len(nums)):
if used[i]:
continue
path.append(nums[i])
used[i] = 1
self.backtracking(result, path, nums, used)
path.pop()
used[i] = 0
LeetCode 47. 全排列II
力扣题目链接
本题在全排列的基础上涉及去重，在树层上，前面用的数字后面重复出现了就应该剪枝，否则会出现重复的排列；在树枝上是可以出现重复的。树层上，体现在used数组对应元素为0，因为用过该元素之后，通过回溯去掉之后变为0，所以如果此时添加这个元素会进行重复搜索。
class Solution:
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
result = []
nums.sort()
used = [0] * len(nums)
self.backtracking(result, [], nums, used)
return result
def backtracking(self, result, path, nums, used):
if len(path) == len(nums):
result.append(path[:])
return
for i in range(len(nums)):
if i > 0 and nums[i] == nums[i-1] and not used[i-1]:
continue
if used[i]:
continue
used[i] = 1
path.append(nums[i])
self.backtracking(result, path, nums, used)
path.pop()
used[i] = 0
LeetCode 332. 重新安排行程
第一次做的时候超时了，
class Solution:
def findItinerary(self, tickets: List[List[str]]) -> List[str]:
starts = [i[0] for i in tickets]
ends = [i[1] for i in tickets]
used_s = [0] * len(tickets)
used_e = [0] * len(tickets)
result = []
self.dfs(result, ['JFK'], starts, ends, used_s, used_e, 'JFK')
result.sort()
return result[0]
def dfs(self, result, path, starts, ends, used_s, used_e, start):
if len(path) == len(starts) + 1:
result.append(path[:])
return
for i in range(len(starts)):
if starts[i] != start or used_s[i] == 1:
continue
# path.append(starts[i])
path.append(ends[i])
used_s[i] = 1
used_e[i] = 1
self.dfs(result, path, starts, ends, used_s, used_e, ends[i])
path.pop()
# path.pop()
used_s[i] = 0
used_e[i] = 0
其实只需先排序，一旦找到满足条件的路径即可返回，不用继续搜索了，一定是最小的。最开始没有考虑清楚这个排序。
class Solution:
def findItinerary(self, tickets: List[List[str]]) -> List[str]:
tickets.sort()
used = [0] * len(tickets)
result = []
self.dfs(result, ['JFK'], tickets, used, 'JFK')
return result[0]
def dfs(self, result, path, tickets, used, start):
if len(path) == len(tickets) + 1:
result.append(path[:])
return True
for i in range(len(tickets)):
if tickets[i][0] == start and used[i] == 0:
path.append(tickets[i][1])
used[i] = 1
state = self.dfs(result, path, tickets, used, tickets[i][1])
if state:
return
path.pop()
used[i] = 0
LeetCode 51. N皇后
力扣题目链接
本题可以每次在一行中填皇后，递归n次。在每一行填皇后的时候，有n个选择，判断当前选择是否合法，如果合法填进去之后再递归下一行。
class Solution:
def solveNQueens(self, n: int) -> List[List[str]]:
result = []
chessboard = [['.'] * n for _ in range(n)]
self.dfs(result, chessboard, n, 0)
return result
def dfs(self, result, chessboard, n, row):
if row == n:
result.append([''.join(i) for i in chessboard])
return
for i in range(n):
if self.isValid(chessboard, n, row, i):
chessboard[row][i] = 'Q'
self.dfs(result, chessboard, n, row+1)
chessboard[row][i] = '.'
def isValid(self, chessboard, n, row, col):
if 'Q' in chessboard[row]:
return False
if 'Q' in [i[col] for i in chessboard]:
return False
for delta_r, delta_c in [(-1, -1), (-1, 1), (1, -1), (1, 1)]:
r, c = row, col
while (r >= 0 and r < n) and (c >= 0 and c < n):
if chessboard[r][c] == 'Q':
return False
r += delta_r
c += delta_c
return True
LeetCode 37. 解数独
超时答案
class Solution:
def solveSudoku(self, board: List[List[str]]) -> None:
"""
Do not return anything, modify board in-place instead.
"""
self.backtracking(board, 0, 0, [0]*9)
def backtracking(self, board, row, col, used):
if row > 8:
return
if board[row][col] == '.':
for num in range(9):
if used[num] == 1:
continue
if self.isValid(board, row, col, str(num+1)):
board[row][col] = str(num+1)
used[num] == 1
if col == 8:
self.backtracking(board, row+1, 0, [0]*9)
else:
self.backtracking(board, row, col+1, used)
board[row][col] = '.'
used[num] == 0
else:
if col == 8:
self.backtracking(board, row+1, 0, used)
else:
self.backtracking(board, row, col+1, [0]*9)
def isValid(self, board, row, col, num):
if num in board[row]:
return False
if num in [row[col] for row in board]:
return False
r = (row // 3) * 3
c = (col // 3) * 3
sub_board = [row[c:c+3] for row in board][r:r+3]
for i in sub_board:
if num in sub_board:
return False
return True
修改答案，其实就是每个格往里填，符合条件就填，不符合就返回False
class Solution:
def solveSudoku(self, board: List[List[str]]) -> None:
"""
Do not return anything, modify board in-place instead.
"""
self.backtracking(board)
def backtracking(self, 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):
if self.isValid(board, i, j, k):
board[i][j] = str(k)
if self.backtracking(board): return True
board[i][j] = '.'
return False
return True
def isValid(self, board, row, col, num):
num = str(num)
if num in board[row]:
return False
if num in [row[col] for row in board]:
return False
r = (row // 3) * 3
c = (col // 3) * 3
for i in range(r, r+3):
for j in range(c, c+3):
if board[i][j] == num:
return False
return True
349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
