代码随想录算法训练营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>& grid, vector>& visited, int x, int y) {
    queue> que; // 定义队列
    que.push({x, y}); // 起始节点加入队列
    visited[x][y] = true; // 只要加入队列,立刻标记为访问过的节点
    while(!que.empty()) { // 开始遍历队列里的元素
        pair 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; // 只要加入队列立刻标记,避免重复访问
            }
        }
    }

}

你可能感兴趣的:(代码随想录二刷,算法)