代码随想录算法训练营第五十天｜（图论）深搜理论基础 、98. 所有可达路径、广搜理论基础

深度优先搜索：

由于dfs是向一个方向进行搜索的，因此需要回溯。

backtracking的代码框架：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }
    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

dfs的代码框架：

void dfs(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本节点所连接的其他节点) {
        处理节点;
        dfs(图，选择的节点); // 递归
        回溯，撤销处理结果
    }
}

98. 所有可达路径

*可用map函数来迭代对象

map(function, iterable, ...)

numbers = [1, 2, 3, 4]
squared_numbers = map(lambda x: x**2, numbers)
print(list(squared_numbers))  # 输出: [1, 4, 9, 16]

邻接矩阵写法：

def dfs(graph, x, n, path, result):
    if x == n:
        result.append(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()
            

def main():
    n, m = map(int, input().split())
    graph = [[0 for _ in range(n+1)] for _ in range(n+1)]
    
    for i in range(m):
        s,t = map(int, input().split())
        graph[s][t] = 1
        
    result = []
    dfs(graph, 1, n, [], result)
    
    if not result:
        return -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()

广度优先搜索：

使用队列实现，先搜索先入队列的点的邻接点。具体思路讲解：广度度优先(BFS)遍历（2分钟入门）_哔哩哔哩_bilibili