1 | bfs/dfs | 网格染色
- 访问到马上就染色（
将visited标为 true)auto [cur_x, cur_y] = que.front();结构化绑定（C++17）- 也可以不使用
visited数组，直接修改原始数组- 时间复杂度: O(n * m)，最多将 visited 数组全部标为 true
- 空间复杂度：考虑visited 数组的话就是 O(n*m), 原地修改就是
O(min(n, m))只考虑递归栈深度（DFS）或队列最大深度（BFS），栈深度或队列最多为网格的一边大小
[模板][dfs][染色]
cpp
class Solution {
public:
const int direction[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
// 为什么 dfs 看起来好像没有终止条件？因为已经通过代码保证传入的节点都是合法节点
void dfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
for (int i = 0; i < 4; ++i) {
int next_x = x + direction[i][0], next_y = y + direction[i][1];
if (next_x < 0 || next_x >= grid.size() || \
next_y < 0 || next_y >= grid[0].size() || \
grid[next_x][next_y] == '0' || \
visited[next_x][next_y] == true) {
continue;
}
visited[next_x][next_y] = true;
dfs(grid, visited, next_x, next_y);
}
}
int numIslands(vector<vector<char>>& grid) {
int n = grid.size(), m = grid[0].size();
vector<vector<bool>> visited(n, vector<bool>(m, false));
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (grid[i][j] == '1' && visited[i][j] == false) {
++ans;
visited[i][j] = true;
dfs(grid, visited, i, j);
}
}
}
return ans;
}
};
cpp
class Solution {
public:
const int direction[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
// 不管节点是否合法，上来就dfs，然后在终止条件的地方进行判断
// 效率会略低一些
void dfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
if (grid[x][y] == '0' || visited[x][y]) return;
visited[x][y] = true;
for (int i = 0; i < 4; ++i) {
int next_x = x + direction[i][0], next_y = y + direction[i][1];
if (next_x < 0 || next_x >= grid.size() || \
next_y < 0 || next_y >= grid[0].size()) {
continue;
}
dfs(grid, visited, next_x, next_y);
}
}
int numIslands(vector<vector<char>>& grid) {
int n = grid.size(), m = grid[0].size();
vector<vector<bool>> visited(n, vector<bool>(m, false));
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (grid[i][j] == '1' && visited[i][j] == false) {
++ans;
dfs(grid, visited, i, j);
}
}
}
return ans;
}
};[模板][bfs][染色]
cpp
class Solution {
public:
const int direction[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
queue<pair<int,int>> que;
visited[x][y] = true; // 在加入队列之前将其标为访问过
que.push(make_pair(x, y));
while (!que.empty()) {
auto [cur_x, cur_y] = que.front(); // 结构化绑定
que.pop();
for (int i = 0; i < 4; ++i) {
int next_x = cur_x + direction[i][0], next_y = cur_y + direction[i][1];
if (next_x < 0 || next_x >= grid.size() || \
next_y < 0 || next_y >= grid[0].size() || \
grid[next_x][next_y] == '0' || \
visited[next_x][next_y] == true) {
continue;
}
visited[next_x][next_y] = true;
que.push(make_pair(next_x, next_y));
}
}
}
int numIslands(vector<vector<char>>& grid) {
int n = grid.size(), m = grid[0].size();
vector<vector<bool>> visited(n, vector<bool>(m, false));
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (grid[i][j] == '1' && visited[i][j] == false) {
++ans;
bfs(grid, visited, i, j);
}
}
}
return ans;
}
};
类似题目
695. 岛屿的最大面积
在 染色的时候统计面积即可
cpp
visited[next_x][next_y] = true;
++area;130. 被围绕的区域
两个步骤：
- 从地图周边出发，将 'O' 都做上标记，visited = true
- 然后再遍历一遍地图，遇到 'O' 且没做过标记的，那么都是地图中间的 'O' ，全部改成 'X' 就行
417. 太平洋大西洋水流问题
cpp
class Solution {
public:
// 太平洋：i == 0 || j == 0
// 大西洋：i == m-1 || j == n-1
// 方式1：从每个节点出发，如果可以到达太平洋且大西洋，记录结果
// 方式2：从四周出发，逆向找可达节点
int direction[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
// array<array<int, 2>, 4> direction = {-1, 0, 0, -1, 1, 0, 0, 1};
void dfs(const vector<vector<int>>& heights, vector<vector<bool>>& visited, int x, int y) {
for (int i = 0; i < 4; ++i) {
int next_x = x + direction[i][0], next_y = y + direction[i][1];
if (next_x < 0 || next_x >= heights.size() || \
next_y < 0 || next_y >= heights[0].size() || \
visited[next_x][next_y] == true ||
heights[next_x][next_y] < heights[x][y]) {
continue;
}
visited[next_x][next_y] = true;
dfs(heights, visited, next_x, next_y);
}
}
vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
int m = heights.size(), n = heights[0].size();
vector<vector<bool>> pacific_visited(m, vector<bool>(n, false));
vector<vector<bool>> atlantic_visited(m, vector<bool>(n, false));
for (int i = 0; i < n; ++i) {
if (pacific_visited[0][i] == false) {
pacific_visited[0][i] = true;
dfs(heights, pacific_visited, 0, i);
}
}
for (int i = 1; i < m; ++i) {
if (pacific_visited[i][0] == false) {
pacific_visited[i][0] = true;
dfs(heights, pacific_visited, i, 0);
}
}
for (int i = 0; i < n; ++i) {
if (atlantic_visited[m-1][i] == false) {
atlantic_visited[m-1][i] = true;
dfs(heights, atlantic_visited, m-1, i);
}
}
for (int i = 0; i < m - 1; ++i) {
if (atlantic_visited[i][n-1] == false) {
atlantic_visited[i][n-1] = true;
dfs(heights, atlantic_visited, i, n-1);
}
}
vector<vector<int>> result;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (pacific_visited[i][j] && atlantic_visited[i][j]) {
result.push_back({i,j});
}
}
}
return result;
}
};建造最大工岛
2 | bfs | 无权最短路径
- 如果只需要路径长度，每次先获取队列的长度然后再往外扩展，或者可以采用使用 int 类型的 visited 数组来记录路径长度
- 如果需要输出路径，需要记录节点的
前驱节点，最后从终点到起点获取前驱节点从而输出路径
[模板] 获取最短路径长度 - 记录steps
cpp
int bfs_shortest_path_length(const vector<vector<int>>& graph, int start, int goal) {
int n = graph.size(); // 节点的总数
queue<int> q; // 队列用于BFS
vector<bool> visited(n, false); // 记录已经访问过的节点
q.push(start);
visited[start] = true;
int steps = 0; // 用于记录步数
while (!q.empty()) {
int que_size = q.size();
while (que_size--) {
int node = q.front();
q.pop();
if (node == goal) {
return steps;
}
for (int neighbor : graph[node]) {
if (!visited[neighbor]) {
visited[neighbor] = true;
q.push(neighbor);
}
}
}
++steps;
}
return -1;
}[模板] 获取最短路径 - 记录前驱节点
cpp
// 使用BFS寻找从start到goal的最短路径，并使用前驱数组记录路径
vector<int> bfs_shortest_path(const vector<vector<int>>& graph, int start, int goal) {
int n = graph.size(); // 节点的总数
vector<int> prev(n, -1); // 用于记录前驱节点，初始化为-1表示未访问
queue<int> q; // 队列用于BFS
unordered_set<int> visited; // 记录已经访问过的节点
// 初始化BFS
q.push(start);
visited.insert(start);
// 开始BFS
while (!q.empty()) {
int node = q.front();
q.pop();
// 如果找到了目标节点，回溯路径
if (node == goal) {
vector<int> path;
for (int at = goal; at != -1; at = prev[at]) {
path.push_back(at);
}
reverse(path.begin(), path.end());
return path; // 返回从start到goal的路径
}
// 遍历当前节点的所有邻居
for (int neighbor : graph[node]) {
if (visited.find(neighbor) == visited.end()) {
// 如果邻居节点未被访问，标记为已访问并记录前驱节点
visited.insert(neighbor);
prev[neighbor] = node;
q.push(neighbor);
}
}
}
// 如果没有找到路径，返回空路径
return {};
}类似题目
[最短路径长度]1926. 迷宫中离入口最近的出口
cpp
class Solution {
public:
int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) {
int m = maze.size(), n = maze[0].size();
int x = entrance[0], y = entrance[1];
queue<pair<int, int>> que;
maze[x][y] = '+';
que.push({x, y});
// 定义四个方向：上、下、左、右
const int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
int steps = 0;
// 广度优先搜索
while (!que.empty()) {
int q_size = que.size();
for (int i = 0; i < q_size; ++i) {
auto [cur_x, cur_y] = que.front();
que.pop();
for (int d = 0; d < 4; ++d) {
int next_x = cur_x + dir[d][0];
int next_y = cur_y + dir[d][1];
// 检查边界条件
if (next_x < 0 || next_x >= m || \
next_y < 0 || next_y >= n || \
maze[next_x][next_y] == '+') {
continue;
}
// 如果到达边界并且不是入口，返回步数
if (next_x == 0 || next_x == m - 1 ||\
next_y == 0 || next_y == n - 1) {
return steps + 1;
}
// 标记为已访问，并将其加入队列
maze[next_x][next_y] = '+';
que.push({next_x, next_y});
}
}
++steps;
}
// 如果没有找到出口，返回 -1
return -1;
}
};[最短路径长度] 433. 最小基因变化
cpp
class Solution {
public:
bool canConvert(const string& s1, const string& s2) {
int diffCount = 0;
for (int i = 0; i < s1.size(); ++i) {
if (s1[i] != s2[i]) {
if (++diffCount > 1) return false;
}
}
return true;
}
int minMutation(string startGene, string endGene, vector<string>& bank) {
if (startGene == endGene) return 0;
int n = bank.size();
int startIndex = -1, endIndex = -1;
// 查找 startGene 和 endGene 在 bank 中的位置
for (int i = 0; i < n; ++i) {
if (bank[i] == endGene) endIndex = i;
else if (bank[i] == startGene) startIndex = i;
}
// 如果终止基因不在 bank 中，直接返回 -1
if (endIndex == -1) return -1;
// 如果起始基因不在 bank 中，则将其作为附加节点处理
if (startIndex == -1) startIndex = n;
// 构建邻接表
vector<list<int>> adj(n + 1);
// 如果 startGene 不在 bank 中，构造与它相邻的节点
if (startIndex == n) {
for (int i = 0; i < n; ++i) {
if (canConvert(startGene, bank[i])) {
adj[n].push_back(i);
}
}
}
// 构造 bank 中基因的邻接关系
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (canConvert(bank[i], bank[j])) {
adj[i].push_back(j);
adj[j].push_back(i);
}
}
}
// BFS 进行最短路径搜索
queue<int> q;
vector<bool> visited(n + 1, false);
q.push(startIndex);
visited[startIndex] = true;
int steps = 0;
while (!q.empty()) {
int que_size = q.size();
while (que_size--) {
int node = q.front();
q.pop();
// 找到终止基因，返回步数
if (node == endIndex) return steps;
// 遍历邻居节点
for (int neighbor : adj[node]) {
if (!visited[neighbor]) {
visited[neighbor] = true;
q.push(neighbor);
}
}
}
++steps; // 每一轮BFS增加一步
}
// 如果找不到转换路径，返回 -1
return -1;
}
};[最短路径长度]127. 单词接龙
和最小基因变化基本没区别
3 | dfs | 回溯 | 所有可能路径
[模板] 797. 所有可能的路径
本题为有向无环图，如果存在环的话需要加一个 visited 数组时间复杂度：O(2^n)，最坏情况下可能有 2 的 n 次方条路径，其中 n 是图的节点数。空间复杂度：O(n)，递归深度最深为 n（即从 0 到目标节点的最长路径长度），以及存储路径所需的空间。
cpp
// 有向无环图求所有可行路径
// 如果存在环的话需要加一个 visited 数组
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void dfs(vector<vector<int>>& graph, int start) {
if (start == graph.size() - 1) {
result.push_back(path);
}
for (auto& next : graph[start]) {
path.push_back(next);
dfs(graph, next);
path.pop_back();
}
}
vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
path.push_back(0);
dfs(graph, 0);
return result;
}
};4 | 并查集 | 判断节点相连
[模板][有向图][无向图]
- 并查集初始化：将所有节点的根节点初始化为节点本身
在查询父节点的时候要执行路径压缩
有向边: 按方向合并
cpp
struct UnionSet {
vector<int> root;
UnionSet(int n) : root(n, 0) {
for (int i = 0; i < n; ++i) {
root[i] = i;
}
}
int Find(int u) {
if (u == root[u]) return u;
root[u] = Find(root[u]); // 路径压缩
return root[u];
}
bool IsConnected(int u, int v) {
return Find(u) == Find(v);
}
void Join(int u, int v) {
int root_u = Find(u);
int root_v = Find(v);
root[root_v] = root_u;
}
};无向边：按秩合并
秩在并查集（Union-Find）的按秩合并中，通常用于表示树的高度（或深度）- 插入新连接的时候选择秩小的作为根节点
- 如果二者秩相同，秩需要加一
cpp
struct UnionSet{
vector<int> root;
vector<int> rank;
UnionSet(int n) : root(n, 0), rank(n, 1) {
for (int i = 0; i < n; ++i) {
root[i] = i;
}
}
int Find(int u) {
if (u == root[u]) return u;
root[u] = Find(root[u]); // 路径压缩
return root[u];
}
bool IsConnected(int u, int v) {
return Find(u) == Find(v);
}
void Join(int u, int v) {
int root_u = Find(u);
int root_v = Find(v);
if (rank[root_u] > rank[root_v]) {
root[root_v] = root_u;
} else if (rank[root_u] < rank[root_v]) {
root[root_u] = root_v;
} else {
root[root_u] = root_v;
rank[root_v]++;
}
}
};类似题目
[无向边]684. 冗余连接
如果边的两个节点已经出现在同一个集合里，说明这条边的两个节点已经连在一起了，再加入这条边一定就出现环了。
cpp
vector<int> findRedundantConnection(vector<vector<int>>& edges) {
int n = edges.size();
UnionSet union_set(n + 1);
for (auto& edge : edges) {
int u = edge[0], v = edge[1];
if (union_set.IsConnected(u, v)) {
return {u, v};
} else {
union_set.Join(u, v);
}
}
return {};
}[有向边]685. 冗余连接 II
cpp
class Solution {
public:
// 查找冗余的有向边
vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
int n = edges.size();
vector<int> parent(n + 1, 0);
vector<int> edge_to_remove1, edge_to_remove2;
int two_in_node = -1;
// 检测入度为2的情况
for (auto& edge : edges) {
int u = edge[0], v = edge[1];
if (parent[v] == 0) {
parent[v] = u;
} else {
// 发现入度为2的节点 v
two_in_node = v;
edge_to_remove1 = {parent[v], v}; // 之前的边
edge_to_remove2 = {u, v}; // 当前的边
break;
}
}
// 重建并查集，处理有环的情况
UnionSet union_set(n + 1);
for (auto& edge : edges) {
int u = edge[0], v = edge[1];
if (edge == edge_to_remove2) {
// 跳过第二条边，先验证第一条边
continue;
}
if (union_set.IsConnected(u, v)) {
// 出现环
// + 如果不存在入度为2的节点，只需要考虑环的问题
// + 说明正是[u,v]导致环的出现，删除 [u, v] 即可
if (two_in_node == -1) return edge;
// + 存在入度为 2 的节点
// + edge_to_remove1 必然属于这个环的一部分
// + 否则就会出现两条不合法的边了，不合题意
// + 因此我们删除两个不合法的交集，也即 edge_to_remove1
return edge_to_remove1;
}
union_set.Join(u, v);
}
// 循环正常结束，说明没有出现环
// 说明异常情况为：存在入度为 2 的节点
// 删除最后一条导致入度为 2 的边，也即 edge_to_remove2
return edge_to_remove2;
}
};5 | 拓扑排序 | 有向图 | 判断是否有环 | 无环图线性排序
[模板]207. 课程表
- 遍历所有边，记录所有节点的入度，将入度为 0 的节点加入队列和结果数组
- 当队列不为空时，从队列中弹出节点，
遍历节点的所有邻居，将邻居的入度减1，如果此时邻居的入度为0，则将该邻居加入队列和结果数组- 队列为空，若结果数组的长度不等于节点个数，说明存在环，否则返回结果数组
cpp
class Solution {
public:
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<int> indegrees(numCourses, 0);
vector<list<int>> adj(numCourses);
for (const auto& pre : prerequisites) {
++indegrees[pre[0]];
adj[pre[1]].push_back(pre[0]);
}
int count = 0;
queue<int> que;
for (int i = 0; i < numCourses; ++i) {
if (indegrees[i] == 0) {
que.push(i);
++count;
}
}
while (!que.empty()) {
int cur = que.front();
que.pop();
for (auto next : adj[cur]) {
if (--indegrees[next] == 0) {
que.push(next);
++count;
}
}
}
return (count == numCourses);
}
};6 | Dijistra | 带正权图最短路径
[模板]参加科学大会
- 使用 堆来存储当前最短路径节点
{节点到起点的距离, 节点索引}- 每次从优先队列中选择当前距离最小的未处理节点
cpp
#include <iostream>
#include <vector>
#include <queue>
#include <climits>
#include <list>
using namespace std;
int dijkstra(vector<list<pair<int, int>>>& adj_list) {
int n = adj_list.size() - 1;
int start = 1, end = n;
vector<int> costs(n + 1, INT_MAX); // 记录距离
vector<int> visited(n + 1, false); // 标记是否找到最短路
// 堆存储 {节点到起点的距离，节点索引}
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
// 初始化
costs[start] = 0;
pq.push({0, start});
while (!pq.empty()) {
// 每次从优先队列中选择当前距离最小的未处理节点
int cost = pq.top().first;
int cur = pq.top().second;
pq.pop();
if (visited[cur]) continue; // 节点已经访问过，跳过
visited[cur] = true; // 未访问过，标记为访问过
if (cur == end) return costs[end]; // 到达终点
// 遍历相邻节点
for (auto& [next, time] : adj_list[cur]) {
if (!visited[next] && costs[cur] + time < costs[next]) {
// 找到更短的路径了
costs[next] = costs[cur] + time;
pq.push({costs[next], next});
}
}
}
return -1; // 如果没有路径到达终点
}
int main(int argc, char* argv[]) {
if (argc == 1) return -1;
freopen(argv[1], "r", stdin);
int n, m;
cin >> n >> m; // n 个 车站 m 条公路
vector<list<pair<int, int>>> adj_list(n + 1);
for (int i = 0; i < m; ++i) { // 输入 m 条边：起点 终点 和 时间
int start, end, time;
cin >> start >> end >> time;
adj_list[start].push_back({end, time});
}
cout << dijkstra(adj_list) << endl;
return 0;
}7 | Floyd | 多源最短路 | 动态规划 | 适合稠密图且源点较多
[模板]97. 小明逛公园
cpp
#include <iostream>
#include <vector>
#include <list>
#include <climits>
using namespace std;
int main() {
int n, m, p1, p2, val;
cin >> n >> m;
vector<vector<vector<int>>> grid(n + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, INT_MAX))); // 因为边的最大距离是10^4
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
grid[p1][p2][0] = val;
grid[p2][p1][0] = val; // 注意这里是双向图
}
// 开始 floyd
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (grid[i][k][k-1] == INT_MAX || grid[k][j][k-1] == INT_MAX) {
grid[i][j][k] = grid[i][j][k-1];
} else {
grid[i][j][k] = min(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1]);
}
}
}
}
// 输出结果
int z, start, end;
cin >> z;
while (z--) {
cin >> start >> end;
if (grid[start][end][n] == INT_MAX) cout << -1 << endl;
else cout << grid[start][end][n] << endl;
}
}空间优化
cpp
#include <iostream>
#include <vector>
#include <list>
#include <climits>
using namespace std;
int main() {
int n, m, p1, p2, val;
cin >> n >> m;
vector<vector<int>> grid(n + 1, vector<int>(n + 1, INT_MAX)); // 因为边的最大距离是10^4
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
grid[p1][p2] = val;
grid[p2][p1] = val; // 注意这里是双向图
}
// 开始 floyd
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (grid[i][k] != INT_MAX && grid[k][j] != INT_MAX) {
grid[i][j] = min(grid[i][j], grid[i][k] + grid[k][j]);
}
}
}
}
// 输出结果
int z, start, end;
cin >> z;
while (z--) {
cin >> start >> end;
if (grid[start][end] == INT_MAX) cout << -1 << endl;
else cout << grid[start][end] << endl;
}
}8 | Prim | 贪心 | 最小生成树 | 花最小的代价连通所有的点
[模板] 53. 寻宝（第七期模拟笔试）
cpp
#include<iostream>
#include<vector>
#include <climits>
using namespace std;
int main() {
int v, e; // 顶点数和边数
cin >> v >> e;
vector<vector<int>> grid(v + 1, vector<int>(v + 1, INT_MAX));
int x, y, k; // 起点，终点和权值
while (e--) {
cin >> x >> y >> k;
grid[x][y] = k;
grid[y][x] = k; // 无向图
}
// Prim算法部分
vector<int> minDist(v + 1, INT_MAX); // 所有节点到最小生成树的最小距离
vector<bool> isInTree(v + 1, false); // 是否已经在最小生成树中
minDist[1] = 0; // 从第1个节点开始
int result = 0;
for (int i = 1; i <= v; i++) {
int cur = -1;
int minVal = INT_MAX;
// 找到距离当前生成树最近的节点
for (int j = 1; j <= v; j++) {
if (!isInTree[j] && minDist[j] < minVal) {
minVal = minDist[j];
cur = j;
}
}
// 如果没有找到合适的节点，则图不连通
if (cur == -1) {
cout << "Graph is not connected" << endl;
return -1;
}
isInTree[cur] = true;
result += minVal; // 把该点与生成树相连的最小边的权值加入结果
// 更新其他节点到生成树的最短距离
for (int j = 1; j <= v; j++) {
if (!isInTree[j] && grid[cur][j] != INT_MAX && grid[cur][j] < minDist[j]) {
minDist[j] = grid[cur][j];
}
}
}
// 输出最小生成树的权重
cout << result << endl;
return 0;
}