两者大概的区别：
dfs是可一个方向去搜，不到黄河不回头，直到遇到绝境了，搜不下去了，再换方向（换方向的过程就涉及到了回溯）。
bfs是先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍，搜索方向更像是广度，四面八方的搜索过程。
就地递归函数的下面，例如如下代码：
void dfs(参数) {
处理节点
dfs(图，选择的节点); // 递归
回溯，撤销处理结果
}回溯算法，其实就是dfs的过程，这里给出dfs的代码框架：
void dfs(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本节点所连接的其他节点) {
处理节点;
dfs(图，选择的节点); // 递归
回溯，撤销处理结果
}
}
797.所有可能的路径
深搜三部曲来分析题目：
1；确认递归函数，参数
首先我们dfs函数一定要存一个图，用来遍历的，还要存一个目前我们遍历的节点，定义为x
至于 单一路径，和路径集合可以放在全局变量，那么代码是这样的：
vector<vector<int>> result; // 收集符合条件的路径
vector<int> path; // 0节点到终点的路径
// x：目前遍历的节点
// graph：存当前的图
void dfs (vector<vector<int>>& graph, int x)2；确认终止条件
什么时候我们就找到一条路径了？
当目前遍历的节点 为 最后一个节点的时候，就找到了一条，从 出发点到终止点的路径。
当前遍历的节点，我们定义为x，最后一点节点，就是 graph.size() - 1（因为题目描述是找出所有从节点 0 到节点 n-1 的路径并输出）。
所以 但 x 等于 graph.size() - 1 的时候就找到一条有效路径。 代码如下：
// 要求从节点 0 到节点 n-1 的路径并输出，所以是 graph.size() - 1
if (x == graph.size() - 1) { // 找到符合条件的一条路径
result.push_back(path); // 收集有效路径
return;
}3；处理目前搜索节点出发的路径
接下来是走 当前遍历节点x的下一个节点。
首先是要找到 x节点链接了哪些节点呢？ 遍历方式是这样的：
for (int i = 0; i < graph[x].size(); i++) { // 遍历节点n链接的所有节点接下来就是将 选中的x所连接的节点，加入到 单一路径来。
path.push_back(graph[x][i]); // 遍历到的节点加入到路径中来二维数组中，graph[x][i] 都是x链接的节点，当前遍历的节点就是 graph[x][i] 。
进入下一层递归
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}回溯算法，其实就是dfs的过程，这里给出dfs的代码框架：
void dfs(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本节点所连接的其他节点) {
处理节点;
dfs(图，选择的节点); // 递归
回溯，撤销处理结果
}
}#邻接矩阵的写法 二维矩阵
def dfs(graph, x, n, path, result):
if x == n:
result.append(path.copy()) # 节点i添加到当前路径path ，path.copy() 是因为路径列表 path 在后续的递归中会被修改。
return
for i in range(1, n + 1):
if graph[x][i] == 1:
path.append(i)
dfs(graph, i, n, path, result)
path.pop() #节点i从当前路径移除
def main():
n, m = map(int, input().split()) # input 读取一行输入，用空格分隔，split空格分成列表 map 字符串转换为整数
#返回一个迭代器 （5，10）
graph = [[0] * (n + 1) for _ in range(n + 1)]
#[0] * (n + 1) 表达式会生成一个包含 n + 1 个 0 的列表。例如，如果 n 是 5，则 [0] * (6) 生成 [0, 0, 0, 0, 0, 0]
#这个循环部分生成 n + 1 个这样的列表。循环变量 _ 是一个占位符，因为在这种情况下它的值并不重要。
#实际上，循环会执行 n + 1 次，每次生成一个 [0] * (n + 1) 的列表
#range(n + 1) 生成 range(4)，即 0, 1, 2, 3
#[[0] * (n + 1) for _ in range(n + 1)] 生成一个 4 x 4 的矩阵
'''
[
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]
]
'''
for _ in range(m):
s, t = map(int, input().split())
graph[s][t] = 1
result = []
dfs(graph, 1, n, [1], result)
if not result:
print(-1)
else:
for path in result:
print(' '.join(map(str, path)))
if __name__ == "__main__":
main()#邻接表的写法
from collections import defaultdict
result = [] # 收集符合条件的路径
path = [] # 1节点到终点的路径
def dfs(graph, x, n):
if x == n: # 找到符合条件的一条路径
result.append(path.copy())
return
for i in graph[x]: # 找到 x指向的节点
path.append(i) # 遍历到的节点加入到路径中来
dfs(graph, i, n) # 进入下一层递归
path.pop() # 回溯，撤销本节点
def main():
n, m = map(int, input().split())
graph = defaultdict(list) # 邻接表
for _ in range(m):
s, t = map(int, input().split())
graph[s].append(t)
path.append(1) # 无论什么路径已经是从1节点出发
dfs(graph, 1, n) # 开始遍历
# 输出结果
if not result:
print(-1)
for pa in result:
print(' '.join(map(str, pa)))
if __name__ == "__main__":
main()
