打卡第五十天：图论理论基础、深度优先搜索理论基础、所有可达路径、广度优先搜索理论基础

Nothingville0v02024-08-26 15:59

一、图论理论基础

图的基本概念

二维坐标中，两点可以连成线，多个点连成的线就构成了图。当然图也可以就一个节点，甚至没有节点（空图）

图的种类

整体上一般分为 有向图 和 无向图。有向图是指 图中边是有方向的：

无向图是指 图中边没有方向：

加权有向图，就是图中边是有权值的，例如：

加权无向图也是同理。

度

无向图中有几条边连接该节点，该节点就有几度。例如，该无向图中，节点4的度为5，节点6的度为3。

在有向图中，每个节点有出度和入度。

出度：从该节点出发的边的个数。

入度：指向该节点边的个数。

例如，该有向图中，节点3的入度为2，出度为1，节点1的入度为0，出度为2。

连通性

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

连通图

在无向图中，任何两个节点都是可以到达的，称之为连通图 ，如图：

如果有节点不能到达其他节点，则为非连通图，如图：

节点1 不能到达节点4。

强连通图

在有向图中，任何两个节点是可以相互到达的，我们称之为 强连通图。

看这个有向图：

初步一看，好像这节点都连着呢，但这不是强连通图，节点1 可以到节点5，但节点5不能到节点1。强连通图是在有向图中任何两个节点是可以相互到达

下面这个有向图才是强连通图：

连通分量

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

该无向图中 节点1、节点2、节点5 构成的子图就是 该无向图中的一个连通分量，该子图所有节点都是相互可达到的。

同理，节点3、节点4、节点6 构成的子图 也是该无向图中的一个连通分量。

必须是极大联通子图才能是连通分量，所以 必须是节点3、节点4、节点6 构成的子图才是连通分量。

在图论中，连通分量是一个很重要的概念，例如岛屿问题其实就是求连通分量。

强连通分量

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

如图：

节点1、节点2、节点3、节点4、节点5 构成的子图是强连通分量，因为这是强连通图，也是极大图。

节点6、节点7、节点8 构成的子图 不是强连通分量，因为这不是强连通图，节点8 不能达到节点6。

节点1、节点2、节点5 构成的子图 也不是 强连通分量，因为这不是极大图。

图的构造

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

邻接矩阵

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

例如： grid[2][5] = 6，表示 节点 2 连接 节点5 为有向图，节点2 指向 节点5，边的权值为6。

如果想表示无向图，即：grid[2][5] = 6，grid[5][2] = 6，表示节点2 与 节点5 相互连通，权值为6。

如图：

在一个 n （节点数）为8 的图中，就需要申请 8 * 8 这么大的空间。

图中有一条双向边，即：grid[2][5] = 6，grid[5][2] = 6

这种表达方式（邻接矩阵） 在 边少，节点多的情况下，会导致申请过大的二维数组，造成空间浪费。而且在寻找节点连接情况的时候，需要遍历整个矩阵，即 n * n 的时间复杂度，同样造成时间浪费。

邻接矩阵的优点：

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

缺点：

  • 遇到稀疏图，会导致申请过大的二维数组造成空间浪费 且遍历 边 的时候需要遍历整个n * n矩阵，造成时间浪费

邻接表

邻接表 使用 数组 + 链表的方式来表示。 邻接表是从边的数量来表示图，有多少边 才会申请对应大小的链表。

邻接表的构造如图：

这里表达的图是：

  • 节点1 指向 节点3 和 节点5
  • 节点2 指向 节点4、节点3、节点5
  • 节点3 指向 节点4
  • 节点4指向节点1

有多少边 邻接表才会申请多少个对应的链表节点。从图中可以直观看出 使用 数组 + 链表 来表达 边的连接情况 。

邻接表的优点：

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

缺点：

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

图的遍历方式

图的遍历方式基本是两大类：

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

二叉树的递归遍历，是dfs 在二叉树上的遍历方式。

二叉树的层序遍历，是bfs 在二叉树上的遍历方式。

dfs 和 bfs 一种搜索算法，可以在不同的数据结构上进行搜索，在二叉树章节里是在二叉树这样的数据结构上搜索。而在图论章节，则是在图（邻接表或邻接矩阵）上进行搜索。

二、深度优先搜索理论基础

dfs 与 bfs 区别

提到深度优先搜索（dfs），就不得不说和广度优先搜索（bfs）有什么区别

先来了解dfs的过程，很多录友可能对dfs（深度优先搜索），bfs（广度优先搜索）分不清。

两者大概的区别：

  • dfs是一个方向去搜，搜不下去了再换方向（换方向的过程就涉及到了回溯）。
  • bfs是先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍，搜索方向更像是广度，四面八方的搜索过程。

dfs 搜索过程

如图一，是一个无向图，我们要搜索从节点1到节点6的所有路径。

那么dfs搜索的第一条路径是这样的： （假设第一次延默认方向，就找到了节点6），图二

此时我们找到了节点6，（遇到黄河了，是不是应该回头了），那么应该再去搜索其他方向了。 如图三：

路径2撤销了，改变了方向，走路径3（红色线）， 接着也找到终点6。 那么撤销路径2，改为路径3，在dfs中其实就是回溯的过程

又找到了一条从节点1到节点6的路径，此时再回头，下图图四中，路径4撤销（回溯的过程），改为路径5。

又找到了一条从节点1到节点6的路径，此时再回头，下图图五，路径6撤销（回溯的过程），改为路径7，路径8 和 路径7，路径9， 结果发现死路一条，都走到了自己走过的节点。

那么节点2所连接路径和节点3所链接的路径 都走过了，撤销路径只能向上回退，去选择撤销当初节点4的选择，也就是撤销路径5，改为路径10 。 如图图六：

上图演示中，其实我并没有把 所有的 从节点1 到节点6的dfs（深度优先搜索）的过程都画出来，那样太冗余了，但 已经把dfs 关键的地方都涉及到了，关键就两点：

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

代码框架

正是因为dfs搜索可一个方向，并需要回溯，所以用递归的方式来实现是最方便的。

cpp 复制代码 
void dfs(参数) {
    处理节点
    dfs(图，选择的节点); // 递归
    回溯，撤销处理结果
}

可以看到回溯操作就在递归函数的下面，递归和回溯是相辅相成的。二叉树的递归法其实就是dfs，而二叉树的迭代法，就是bfs（广度优先搜索）

所以dfs，bfs其实是基础搜索算法，也广泛应用与其他数据结构与算法中。

回顾一下回溯法的代码框架：

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

回溯算法，其实就是dfs的过程，这里给出dfs的代码框架：

cpp 复制代码 
void dfs(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

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

可以发现dfs的代码框架和回溯算法的代码框架是差不多的。

深搜三部曲

  1. 确认递归函数，参数
cpp 复制代码 
void dfs(参数)

递归的时候，归搜索需要了解哪些参数，其实也可以在写递归函数的时候，发现需要什么参数，再去补充就可以。

一般情况，深搜需要 二维数组数组结构保存所有路径，需要一维数组保存单一路径，这种保存结果的数组，可以定义一个全局变量，避免让我们的函数参数过多。

例如这样：

cpp 复制代码 
vector<vector<int>> result; // 保存符合条件的所有路径
vector<int> path; // 起点到终点的路径
void dfs (图，目前搜索的节点)
  1. 确认终止条件

终止条件很重要，很多同学写dfs的时候，之所以容易死循环，栈溢出等等这些问题，都是因为终止条件没有想清楚。

cpp 复制代码 
if (终止条件) {
    存放结果;
    return;
}

终止添加不仅是结束本层递归，同时也是收获结果的时候。

另外，其实很多dfs写法，没有写终止条件，其实终止条件写在了， 下面dfs递归的逻辑里了，也就是不符合条件，直接不会向下递归。

  1. 处理目前搜索节点出发的路径

一般这里就是一个for循环的操作，去遍历 目前搜索节点 所能到的所有节点。

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

dfs代码框架中for循环里分明已经处理节点了，那么 dfs函数下面 为什么还要撤销的呢。

如图七所示， 路径2 已经走到了 目的地节点6，那么 路径2 是如何撤销，然后改为 路径3呢？ 其实这就是 回溯的过程，撤销路径2，走换下一个方向。

三、所有可达路径

题目

文章

深度优先搜索比较好的入门题。

二叉树的前中后序遍历其实就是深搜在二叉树这种数据结构上的应用 。其实 回溯算法就是 深搜，只不过针对某一搜索场景 我们给他一个更细分的定义，叫做回溯算法。

图的存储

两种 图的存储方式：邻接表 和 邻接矩阵。

邻接矩阵

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

本题我们会有n 个节点，因为节点标号是从1开始的，为了节点标号和下标对齐，我们申请 n + 1 * n + 1 这么大的二维数组。

cpp 复制代码 
vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0));

输入m个边，构造方式如下：

cpp 复制代码 
while (m--) {
    cin >> s >> t;
    // 使用邻接矩阵 ，1 表示 节点s 指向 节点t
    graph[s][t] = 1;
}

邻接表

邻接表 使用 数组 + 链表的方式来表示。 邻接表是从边的数量来表示图，有多少边 才会申请对应大小的链表。邻接表的构造相对邻接矩阵难理解一些。

这里表达的图是：

  • 节点1 指向 节点3 和 节点5
  • 节点2 指向 节点4、节点3、节点5
  • 节点3 指向 节点4
  • 节点4指向节点1

需要构造一个数组，数组里的元素是一个链表。

C++写法：

cpp 复制代码 
// 节点编号从1到n，所以申请 n+1 这么大的数组
vector<list<int>> graph(n + 1); // 邻接表，list为C++里的链表

输入m个边，构造方式如下：

cpp 复制代码 
while (m--) {
    cin >> s >> t;
    // 使用邻接表 ，表示 s -> t 是相连的
    graph[s].push_back(t);
}

本题使用邻接表 或者 邻接矩阵都可以，因为后台数据并没有对图的大小以及稠密度做很大的区分。以下使用邻接矩阵的方式来讲解。

深度优先搜索

本题是深度优先搜索的基础题目

深搜三部曲来分析题目：

  1. 确认递归函数，参数

首先dfs函数一定要存一个图，用来遍历的，需要存一个目前遍历的节点，定义为x。还需要存一个n，表示终点，我们遍历的时候，用来判断当 x==n 时候 标明找到了终点。

（其实在递归函数的参数 不容易一开始就确定了，一般是在写函数体的时候发现缺什么，参加就补什么）

至于 单一路径 和 路径集合 可以放在全局变量，那么代码是这样的：

cpp 复制代码 
vector<vector<int>> result; // 收集符合条件的路径
vector<int> path; // 0节点到终点的路径
// x：目前遍历的节点
// graph：存当前的图
// n：终点
void dfs (const vector<vector<int>>& graph, int x, int n) {
  1. 确认终止条件

当目前遍历的节点 为 最后一个节点 n 的时候 就找到了一条 从出发点到终止点的路径。

cpp 复制代码 
// 当前遍历的节点x 到达节点n 
if (x == n) { // 找到符合条件的一条路径
    result.push_back(path);
    return;
}
  1. 处理目前搜索节点出发的路径

接下来是走 当前遍历节点x的下一个节点。 遍历方式是这样的：

cpp 复制代码 
for (int i = 1; i <= n; i++) { // 遍历节点x链接的所有节点
    if (graph[x][i] == 1) { // 找到 x指向的节点，就是节点i
    }
}

接下来就是将 选中的x所指向的节点，加入到 单一路径来。

cpp 复制代码 
path.push_back(i); // 遍历到的节点加入到路径中来

进入下一层递归

cpp 复制代码 
dfs(graph, i, n); // 进入下一层递归

最后就是回溯的过程，撤销本次添加节点的操作。

该过程整体代码：

cpp 复制代码 
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(); // 回溯，撤销本节点
    }
}

打印结果

ACM格式在输出结果的时候，要关注看看格式问题，特别是字符串，有的题目说的是每个元素后面都有空格，有的题目说的是 每个元素间有空格，最后一个元素没有空格。有的题目压根没说，那只能提交去试一试了。

例如示例输出是：

1 3 5 而不是 1 3 5

即 5 的后面没有空格

这是我们在输出的时候需要注意的点。

以上代码中，结果都存在了 result数组里（二维数组，每一行是一个结果），最后将其打印出来。（重点看注释）

cpp 复制代码 
// 输出结果
if (result.size() == 0) cout << -1 << endl;
for (const vector<int> &pa : result) {
    for (int i = 0; i < pa.size() - 1; i++) { // 这里指打印到倒数第二个
        cout << pa[i] << " ";
    }
    cout << pa[pa.size() - 1]  << endl; // 这里再打印倒数第一个，控制最后一个元素后面没有空格
}

本题代码

邻接矩阵写法

cpp 复制代码 
#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> result; // 收集符合条件的路径
vector<int> path; // 1节点到终点的路径

void dfs (const vector<vector<int>>& graph, int x, int n) {
    // 当前遍历的节点x 到达节点n 
    if (x == n) { // 找到符合条件的一条路径
        result.push_back(path);
        return;
    }
    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(); // 回溯，撤销本节点
        }
    }
}

int main() {
    int n, m, s, t;
    cin >> n >> m;

    // 节点编号从1到n，所以申请 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;
    }

    path.push_back(1); // 无论什么路径已经是从0节点出发
    dfs(graph, 1, n); // 开始遍历

    // 输出结果
    if (result.size() == 0) cout << -1 << endl;
    for (const vector<int> &pa : result) {
        for (int i = 0; i < pa.size() - 1; i++) {
            cout << pa[i] << " ";
        }
        cout << pa[pa.size() - 1]  << endl;
    }
}

邻接表写法

cpp 复制代码 
#include <iostream>
#include <vector>
#include <list>
using namespace std;

vector<vector<int>> result; // 收集符合条件的路径
vector<int> path; // 1节点到终点的路径

void dfs (const vector<list<int>>& graph, int x, int n) {

    if (x == n) { // 找到符合条件的一条路径
        result.push_back(path);
        return;
    }
    for (int i : graph[x]) { // 找到 x指向的节点
        path.push_back(i); // 遍历到的节点加入到路径中来
        dfs(graph, i, n); // 进入下一层递归
        path.pop_back(); // 回溯，撤销本节点
    }
}

int main() {
    int n, m, s, t;
    cin >> n >> m;

    // 节点编号从1到n，所以申请 n+1 这么大的数组
    vector<list<int>> graph(n + 1); // 邻接表
    while (m--) {
        cin >> s >> t;
        // 使用邻接表 ，表示 s -> t 是相连的
        graph[s].push_back(t);

    }

    path.push_back(1); // 无论什么路径已经是从0节点出发
    dfs(graph, 1, n); // 开始遍历

    // 输出结果
    if (result.size() == 0) cout << -1 << endl;
    for (const vector<int> &pa : result) {
        for (int i = 0; i < pa.size() - 1; i++) {
            cout << pa[i] << " ";
        }
        cout << pa[pa.size() - 1]  << endl;
    }
}

四、广度优先搜索理论基础

广搜的使用场景

广搜的搜索方式就适合于解决两个点之间的最短路径问题。因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。当然，也有一些问题是广搜 和 深搜都可以解决的，例如岛屿问题，这类问题的特征就是不涉及具体的遍历方式，只要能把相邻且相同属性的节点标记上就行。

广搜的过程

BFS是一圈一圈的搜索过程，但具体是怎么一圈一圈来搜呢。用一个方格地图，假如每次搜索的方向为 上下左右（不包含斜上方），那么给出一个start起始位置，那么BFS就是从四个方向走出第一步。

如果加上一个end终止位置，那么使用BFS的搜索过程如图所示：

从start起点开始，是一圈一圈向外搜索，方格编号1为第一步遍历的节点，方格编号2为第二步遍历的节点，第四步的时候找到终止点end。

正是因为BFS一圈一圈的遍历方式，所以一旦遇到终止点，那么一定是一条最短路径。

而且地图还可以有障碍，如图所示：

在第五步，第六步 只把关键的节点染色了，其他方向周边没有去染色，只要关注关键地方染色的逻辑就可以。从图中可以看出，如果添加了障碍，第六步才能走到end终点。只要BFS只要搜到终点一定是一条最短路径。

代码框架

仅仅需要一个容器保存我们要遍历过的元素就可以，那么用队列，还是用栈，甚至用数组，都是可以的 。用队列的话，就是保证每一圈都是一个方向去转，例如统一顺时针或者逆时针 。因为队列是先进先出，加入元素和弹出元素的顺序是没有改变的。如果用栈的话，就是第一圈顺时针遍历，第二圈逆时针遍历，第三圈有顺时针遍历。因为栈是先进后出，加入元素和弹出元素的顺序改变了。所以用队列，还是用栈都是可以的

下面给出广搜代码模板，该模板针对的就是，上面的四方格的地图： （详细注释）

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

}
相关推荐
TENET信条15 小时前
day53 第十一章：图论part04
开发语言·c#·图论
不想当程序猿_17 小时前
【蓝桥杯每日一题】分糖果——DFS
c++·算法·蓝桥杯·深度优先
TENET信条2 天前
代码随想录 day50 第十一章 图论part01
图论
XiaoLeisj2 天前
【递归，搜索与回溯算法 & 综合练习】深入理解暴搜决策树：递归，搜索与回溯算法综合小专题（二）
数据结构·算法·leetcode·决策树·深度优先·剪枝
闻缺陷则喜何志丹2 天前
【C++动态规划 图论】3243. 新增道路查询后的最短距离 I|1567
c++·算法·动态规划·力扣·图论·最短路·路径
TENET信条2 天前
代码随想录 day52 第十一章 图论part03
图论
鸽鸽程序猿2 天前
【算法】【优选算法】宽搜（BFS）中队列的使用
算法·宽度优先·队列
南宫生2 天前
力扣-图论-17【算法学习day.67】
java·学习·算法·leetcode·图论
single5943 天前
【c++笔试强训】（第四十一篇）
java·c++·算法·深度优先·图论·牛客
清弦墨客3 天前
【数据结构与算法】深度优先搜索：树与图的路径探寻之道
数据结构·python·算法·蓝桥杯·深度优先
热门推荐
0119个Web前端交互式3D JavaScript框架和库02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05【一文读懂】NTN（非地面网络）技术介绍06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07ZZ038 物联网应用与服务赛题第J套08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Docker 夺命连环 15 问10VSCode插件 —— Cody AI （免费AI助手！）