leetcode–DFS、BFS
22. 括号生成
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
输入：n = 3
输出：[“((()))”,“(()())”,“(())()”,“()(())”,“()()()”]
思路：回溯法，长度满足2n返回
Python
def generateParenthesis(n: int):
res = []
def dfs(cur, l, r):
if len(cur) == 2 * n: # 长度满足返回
print(cur)
res.append(''.join(cur))
return
if l < n:
cur.append('(')
dfs(cur, l + 1, r)
cur.pop()
if r < l:
cur.append(')')
dfs(cur, l, r + 1)
cur.pop()
dfs([], 0, 0)
return res
C++
void dfs(vector<string>& res, string& cur, int n, int l, int r)
{
if (cur.size() == 2 * n) {
res.push_back(cur);
return;
}
if (l < n) {
cur += "(";
dfs(res, cur, n, l + 1, r);
cur.pop_back();
}
if (r < l) {
cur += ")";
dfs(res, cur, n, l, r + 1);
cur.pop_back();
}
}
vector<string> generateParenthesis(int n) {
vector<string> res;
string cur;
dfs(res, cur, n, 0, 0);
return res;
}
37. 解数独
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。
思路：回溯法，找到行、列、块的交集，进行回溯
def solveSudoku(board: List[List[str]]) -> None:
"""
Do not return anything, modify board in-place instead.
"""
row = [set(range(1, 10)) for _ in range(9)] # 行
col = [set(range(1, 10)) for _ in range(9)] # 列
block = [set(range(1, 10)) for _ in range(9)] # 块
empty = []
for i in range(9):
for j in range(9):
if board[i][j] == '.':
empty.append((i, j))
else:
val = int(board[i][j])
row[i].remove(val)
col[j].remove(val)
block[(i // 3) * 3 + j // 3].remove(val)
def dfs(idx):
if idx == len(empty):
return True
i, j = empty[idx]
v = (i // 3) * 3 + j // 3
for value in row[i] & col[j] & block[v]:
row[i].remove(value)
col[j].remove(value)
block[v].remove(value)
board[i][j] = str(value)
if dfs(idx + 1):
return True
row[i].add(value)
col[j].add(value)
block[v].add(value)
return False
dfs(0)
40. 组合总和 II
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。
注意：解集不能包含重复的组合。
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
思路：先排序，回溯索引需要指向下一个，防止重复需要剪枝
Python
def combinationSum2(candidates: List[int], target: int) -> List[List[int]]:
candidates.sort()
res = []
def dfs(cur, begin, val):
if val == target:
res.append(cur[:])
return
for k in range(begin, len(candidates)):
if val + candidates[k] > target: # 大于直接break
break
if k > begin and candidates[k] == candidates[k - 1]: # 去重剪枝
continue
cur.append(candidates[k])
dfs(cur, k + 1, val + candidates[k])
cur.pop()
dfs([], 0, 0)
return res
C++
void dfs(vector<vector<int>>& res, vector<int>& cur, int target, vector<int>& candidates, int begin)
{
if (accumulate(cur.begin(), cur.end(), 0) == target)
{
res.push_back(cur);
return;
}
if (accumulate(cur.begin(), cur.end(), 0) < target)
{
for (int i = begin; i < candidates.size(); i++)
{
if (i > begin && candidates[i] == candidates[i - 1]) {
continue;
}
cur.push_back(candidates[i]);
dfs(res, cur, target, candidates, i + 1);
cur.pop_back();
}
}
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
sort(candidates.begin(), candidates.end());
vector<vector<int>> res;
vector<int> cur;
dfs(res, cur, target, candidates, 0);
return res;
}
47. 全排列 II
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
思路：先排序，增加列表表示当前位置是否被用过，防止重复需要剪枝
Python
def permuteUnique(nums: List[int]) -> List[List[int]]:
nums.sort()
used = [False for _ in range(len(nums))] # 记录是否用过
res = []
def dfs(cur, used):
if len(cur) == len(nums):
res.append(cur[:])
return
for i in range(len(nums)):
if not used[i]:
if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]: # 防止重复
continue
cur.append(nums[i])
used[i] = True
dfs(cur, used)
cur.pop()
used[i] = False
dfs([], used)
return res
C++
void dfs(vector<vector<int>>& res, vector<int>& cur, vector<int>& path, vector<int>& nums)
{
if (cur.size() == nums.size()) {
res.push_back(cur);
return;
}
for (int i = 0; i < nums.size(); ++i) {
if (!path[i]) continue;
if (i > 0 && nums[i] == nums[i - 1] && path[i - 1]) continue;
cur.push_back(nums[i]);
path[i] = 0;
dfs(res, cur, path, nums);
cur.pop_back();
path[i] = 1;
}
}
vector<vector<int>> permuteUnique(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<vector<int>> res;
vector<int> cur;
vector<int> path(nums.size(), 1);
dfs(res, cur, path, nums);
return res;
}
79. 单词搜索
给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”
输出：true
思路：设置四个方向，增加列表表示当前位置是否被用过，从每个起始位置开始回溯
def exist(board: List[List[str]], word: str) -> bool:
dir = [(1, 0), (-1, 0), (0, 1), (0, -1)] # 记录方向
begin = []
row = len(board)
col = len(board[0])
used = [[False] * col for _ in range(row)] # 记录位置是否使用过
for r in range(row):
for c in range(col):
if board[r][c] == word[0]:
begin.append((r, c))
def dfs(index, i, j, used):
if index == len(word):
return True
for d in dir:
ci = i + d[0]
cj = j + d[1]
if 0 <= ci < row and 0 <= cj < col and board[ci][cj] == word[index]:
if used[ci][cj]:
continue
used[ci][cj] = True
if dfs(index + 1, ci, cj, used):
return True
else:
used[ci][cj] = False
for i, j in begin: # 每个起始位置开始回溯
used[i][j] = True
if dfs(1, i, j, used):
return True
else:
used[i][j] = False
return False
286. 墙与门
你被给定一个 m × n 的二维网格 rooms ，网格中有以下三种可能的初始化值：
-1 表示墙或是障碍物
0 表示一扇门
INF 无限表示一个空的房间。然后，我们用 231 - 1 = 2147483647 代表 INF。你可以认为通往门的距离总是小于 2147483647 的。
你要给每个空房间位上填上该房间到 最近门的距离 ，如果无法到达门，则填 INF 即可。
输入：rooms = [[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]
输出：[[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]
思路：使用广度优先搜索，从门的位置开始BFS，直到没有空的房间
Python
def wallsAndGates(rooms: List[List[int]]) -> None:
"""
Do not return anything, modify rooms in-place instead.
"""
row = len(rooms)
col = len(rooms[0])
INF = 2147483647
if row == 0:
return
queue = []
for r in range(row):
for c in range(col):
if rooms[r][c] == 0:
queue.append((r, c, 0))
while queue:
i, j, step = queue.pop(0)
for di, dj in [(-1, 0), (1, 0), (0, 1), (0, -1)]:
ci = di + i
cj = dj + j
if 0 <= ci < row and 0 <= cj < col and rooms[ci][cj] == INF:
rooms[ci][cj] = step + 1
queue.append((ci, cj, step + 1))
C++
const int INF = 2147483647;
void wallsAndGates(vector<vector<int>>& rooms) {
deque<vector<int>> dq;
int row = rooms.size();
int col = rooms[0].size();
for (int r = 0; r < row; ++r) {
for (int c = 0; c < col; ++c) {
if (rooms[r][c] == 0) {
dq.push_back({ r, c, 0 });
}
}
}
while (!dq.empty()) {
int r = dq[0][0];
int c = dq[0][1];
int distance = dq[0][2];
dq.pop_front();
for (auto x : vector<pair<int, int>>{ {-1,0}, {1,0}, {0,-1}, {0,1} }) {
int cr = r + x.first;
int cc = c + x.second;
if (0 <= cr && cr < row && 0 <= cc && cc < col && rooms[cr][cc] == INF) {
rooms[cr][cc] = distance + 1;
dq.push_back({ cr, cc, distance + 1 });
}
}
}
}
扫一扫
1080
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
