文章链接：图论理论基础、深搜理论基础、98. 所有可达路径、广搜理论基础
题目链接：98. 所有可达路径
图论理论基础
幕布链接：https://www.mubu.com/doc/bGiESMLhfR
深搜理论基础
关键点：
1.搜索方向，是认准一个方向搜，直到碰壁之后再换方向
2.换方向是撤销原路径，改为节点链接的下一个路径，回溯的过程。
代码框架：
// 递归函数的代码框架
void dfs(参数) {
处理节点
dfs(图，选择的节点); // 递归
回溯，撤销处理结果
}// dfs的代码框架
void dfs(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本节点所连接的其他节点) {
处理节点;
dfs(图，选择的节点); // 递归
回溯，撤销处理结果
}
}深搜三部曲：
1.确认递归函数，参数；
2.确认终止条件；
3.处理目前搜索节点出发的路径
98.所有可达路径
思路：
1.构造邻接矩阵
// n 个节点，因为节点标号是从1开始的，为了节点标号和下标对齐，
// 我们申请 n + 1 * n + 1 这么大的二维数组。
vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0));
while (m--) {
cin >> s >> t;
// 使用邻接矩阵 ，1 表示 节点s 指向 节点t
graph[s][t] = 1;
}2.构造邻接表
// 节点编号从1到n，所以申请 n+1 这么大的数组
vector<list<int>> graph(n + 1); // 邻接表，list为C++里的链表
while (m--) {
cin >> s >> t;
// 使用邻接表 ，表示 s -> t 是相连的
graph[s].push_back(t);
}深搜三部曲：
1.确认递归函数，参数：
vector<vector<int>> result; // 收集符合条件的路径
vector<int> path; // 0节点到终点的路径
// x：目前遍历的节点
// graph：存当前的图
// n：终点
void dfs (const vector<vector<int>>& graph, int x, int n)2.确认终止条件：当目前遍历的节点 为 最后一个节点 n 的时候 就找到了一条 从出发点到终止点的路径。
3.处理目前搜索节点出发的路径：
for (int i = 1; i <= n; i++) { // 遍历节点x链接的所有节点
if (graph[x][i] == 1) { // 找到 x链接的节点
path.push_back(i); // 遍历到的节点加入到路径中来
dfs(graph, i, n); // 进入下一层递归
path.pop_back(); // 回溯，撤销本节点
}
}代码如下：
// 邻接矩阵
#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> result;
vector<int> path;
void dfs (const vector<vector<int>>& graph, int x, int n) {
if (x == n) {
result.push_back(path);
return;
}
for (int i = 1; i <= n; i++) { // 单层逻辑
if (graph[x][i] == 1) { // 找到x链接的节点
path.push_back(i);
dfs(graph, i, n); // 下一层递归
path.pop_back(); // 回溯
}
}
}
int main() {
int n, m, s, t;
cin >> n >> m;
vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0));
while(m--) {
cin >> s >> t;
graph[s][t] = 1;// 1表示s与t是相连的
}
path.push_back(1); // 从节点1开始
dfs(graph, 1, n); // 开始遍历
// 输出结果
if (result.size() == 0) cout << -1 << '\n';
for (const vector<int> &pa : result) {
for (int i = 0; i < pa.size() - 1; i++) {
cout << pa[i] << " ";
}
cout << pa[pa.size() - 1] << '\n';
}
}// 邻接表
#include <iostream>
#include <vector>
#include <list>
using namespace std;
vector<vector<int>> result;
vector<int> path;
void dfs (const vector<list<int>>& graph, int x, int n) {
if (x == n) {
result.push_back(path);
return;
}
for (int i : graph[x]) { // 单层逻辑
path.push_back(i);
dfs(graph, i, n); // 下一层递归
path.pop_back(); // 回溯
}
}
int main() {
int n, m, s, t;
cin >> n >> m;
vector<list<int>> graph(n + 1);
while(m--) {
cin >> s >> t;
graph[s].push_back(t);// 1表示s与t是相连的
}
path.push_back(1); // 从节点1开始
dfs(graph, 1, n); // 开始遍历
// 输出结果
if (result.size() == 0) cout << -1 << '\n';
for (const vector<int> &pa : result) {
for (int i = 0; i < pa.size() - 1; i++) {
cout << pa[i] << " ";
}
cout << pa[pa.size() - 1] << '\n';
}
}广搜理论基础
使用场景：
广搜的搜索方式就适合于解决两个点之间的最短路径问题。
原因：因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。
代码框架：
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 表示四个方向
// grid 是地图，也就是一个二维数组
// visited标记访问过的节点，不要重复访问
// x,y 表示开始搜索节点的下标
void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
queue<pair<int, int>> que; // 定义队列
que.push({x, y}); // 起始节点加入队列
visited[x][y] = true; // 只要加入队列，立刻标记为访问过的节点
while(!que.empty()) { // 开始遍历队列里的元素
pair<int ,int> cur = que.front(); que.pop(); // 从队列取元素
int curx = cur.first;
int cury = cur.second; // 当前节点坐标
for (int i = 0; i < 4; i++) { // 开始想当前节点的四个方向左右上下去遍历
int nextx = curx + dir[i][0];
int nexty = cury + dir[i][1]; // 获取周边四个方向的坐标
if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 坐标越界了，直接跳过
if (!visited[nextx][nexty]) { // 如果节点没被访问过
que.push({nextx, nexty}); // 队列添加该节点为下一轮要遍历的节点
visited[nextx][nexty] = true; // 只要加入队列立刻标记，避免重复访问
}
}
}
}
