代码随想录算法训练营day64 | 98. 所有可达路径

图论理论基础

1、图的种类

整体上一般分为 有向图 和 无向图。

加权有向图，就是图中边是有权值的，加权无向图也是同理。

2、度

无向图中有几条边连接该节点，该节点就有几度

在有向图中，每个节点有出度和入度。出度：从该节点出发的边的个数。入度：指向该节点边的个数。

3、连通性

在图中表示节点的连通情况，我们称之为连通性

连通图和强连通图

• 在无向图中，任何两个节点都是可以到达的，我们称之为连通图。如果有节点不能到达其他节点，则为非连通图。
• 在有向图中，任何两个节点是可以相互到达的，我们称之为 强连通图。

连通分量和强连通分量

• 在无向图中的极大连通子图称之为该图的一个连通分量。
• 在有向图中极大强连通子图称之为该图的强连通分量。

4、图的构造

一般使用邻接表、邻接矩阵 或者用类来表示。主要是 朴素存储、邻接表和邻接矩阵。

邻接矩阵 使用 二维数组来表示图结构。 邻接矩阵是从节点的角度来表示图，有多少节点就申请多大的二维数组。

邻接矩阵

优点：

• 表达方式简单，易于理解
• 检查任意两个顶点间是否存在边的操作非常快
• 适合稠密图，在边数接近顶点数平方的图中，邻接矩阵是一种空间效率较高的表示方法。

缺点：

• 遇到稀疏图，会导致申请过大的二维数组造成空间浪费 且遍历 边 的时候需要遍历整个n * n矩阵，造成时间浪费
• 邻接表 使用 数组 + 链表的方式来表示。 邻接表是从边的数量来表示图，有多少边 才会申请对应大小的链表。

邻接表

优点：

• 对于稀疏图的存储，只需要存储边，空间利用率高
• 遍历节点连接情况相对容易

缺点：

• 检查任意两个节点间是否存在边，效率相对低，需要 O(V)时间，V表示某节点连接其他节点的数量。
• 实现相对复杂，不易理解

5、图的遍历方式

• 深度优先搜索（dfs）
• 广度优先搜索（bfs）

深搜理论基础

关键就两点：

• 搜索方向，是认准一个方向搜，直到碰壁之后再换方向
• 换方向是撤销原路径，改为节点链接的下一个路径，回溯的过程

代码框架

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

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

98. 所有可达路径（卡码网）

深搜三部曲

• 确认递归函数，参数
• 确认终止条件
• 处理目前搜索节点出发的路径

邻接矩阵写法

def dfs(graph, x, n, result, path):
    # 当前遍历的节点x 到达节点n 
    if x == n: # 找到符合条件的一条路径
        result.append(path[:])
        return

    for i in range(1, n+1):  # 遍历节点x链接的所有节点
        if graph[x][i] == 1:  
            path.append(i)
            dfs(graph, i, n, result, path)
            path.pop()


if __name__ == "__main__":

    n, m = map(int, input().strip().split())

    # 节点编号从1到n，所以申请 n+1 这么大的数组
    graph = [[0] * (n + 1) for _ in range(n+1)]

    for _ in range(m):
        s, t = map(int, input().strip().split())
        # 使用邻接矩阵 表示无线图，1 表示 s 与 t 是相连的
        graph[s][t] = 1
   
    result = []
    dfs(graph, 1, n, result, [1])

    # 输出结果
    if len(result) == 0:
        print(-1)
    for path in result:
        print(" ".join([str(i) for i in path]))

邻接表写法

def dfs(graph, x, n, result, path):
    # 当前遍历的节点x 到达节点n 
    if x == n: # 找到符合条件的一条路径
        result.append(path[:])
        return

    for i in graph[x]:  # 遍历节点x链接的所有节点
        path.append(i)
        dfs(graph, i, n, result, path)
        path.pop()


if __name__ == "__main__":

    n, m = map(int, input().strip().split())

    # 节点编号从1到n，所以申请 n+1 这么大的数组
    graph = [[] for _ in range(n+1)]  # 邻接表

    for _ in range(m):
        s, t = map(int, input().strip().split())
        # 使用邻接表
        graph[s].append(t)
   
    result = []
    dfs(graph, 1, n, result, [1])

    # 输出结果
    if len(result) == 0:
        print(-1)
    for path in result:
        print(" ".join([str(i) for i in path]))

主要在生成图和遍历图的时候不一样

广搜理论基础

广搜的使用场景

广搜的搜索方式就适合于解决两个点之间的最短路径问题。因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。

代码框架

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; // 只要加入队列立刻标记，避免重复访问
            }
        }
    }

}