Studying-代码随想录训练营day50| 图论理论基础、深搜理论基础、98. 所有可达路径、广搜理论基础

yachihaoteng

已于 2024-08-01 15:31:35 修改

阅读量478

点赞数 18

文章标签：图论 c++ 算法 dfs bfs

于 2024-08-01 15:31:09 首次发布

本文链接：https://blog.csdn.net/yachihaoteng/article/details/140833590

版权

第50天，图论开始！最后的刷题冲刺！💪(ง •_•)ง，编程语言：C++

图论理论基础

文档讲解：代码随想录图论理论基础

图的基本概念

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

图的种类

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

有向图：图上的边是存在方向的。（两个节点之间连接是具有朝向性的）

无向图：图上的边是没有方向的。（无向图两个节点之间有一条边，就意味着两个节点之间能够进行双向通信（等于有向图有两条相互指向的边））

加权有向图：指是有向图的同时，边还具备权值。（同理加权无向图，就是指无向图的同时，边还具备权值）

度

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

有向图中：每个节点有出度和入度。出度表示从该节点出发的边的个数。入度表示指向该节点边的个数。例如，该有向图中，节点3的入度为2，出度为1，节点1的入度为0，出度为2。

连通性

在图中表示节点的连通情况，我们称之为连通性。（也即一个节点在图中能否到达另一个节点）

连通图（无向图概念）

无向图：从任何一个节点出发，都可以到达任何一个其他的节点，我们称之为连通图。

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

强连通图（有向图概念）

有向图：从任何一个节点出发，都可以到达任何一个其他的节点，我们称之为强连通图。

如果有节点不能到达其他节点，则为非强连通图，如图，节点3,4，到达不了节点1.

连通分量

在无向图中的极大连通子图称之为该图的一个连通分量。（一定要注意是极大的，也就是必须尽可能的多）

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

而无向图中节点3 、节点4 构成的子图不是该无向图的联通分量。

强连通分量

在有向图中极大强连通子图称之为该图的强连通分量。（同样也要是极大的，也就是必须尽可能的多）。

节点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 * n 的时间复杂度，同样造成时间浪费。

总结邻接矩阵的优缺点。

优点：

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

缺点：

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

邻接表

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

图中的含义是：

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

总结邻接表的优缺点：

优点：

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

缺点：

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

图的遍历方式

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

深度优先搜索（dfs）：Depth First Search
广度优先搜索（bfs）：Breadth First Search

在讲解二叉树章节的时候，其实就已经讲过这两种遍历方式。二叉树的递归遍历，是dfs 在二叉树上的遍历方式。二叉树的层序遍历，是bfs 在二叉树上的遍历方式。

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

深搜理论基础

文档讲解：代码随想录深搜理论基础（dfs）

首先明确深搜(dfs）和广搜(bfs）的区别：

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

下面主要讲解深搜的理论基础。

dfs搜索过程

dfs是朝着一个方向搜，直到搜到终点。以无向图为例：

我们搜索的第一条路径可以是：节点6就是指我们的终点了。

接着我们可以回头（回溯）进行下一条路径的搜索

总结来说，深搜主要的关键点就两点：

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

代码框架

我们知道深搜是需要进行回溯的，因此一般我们实现深搜采用的就是递归的方式。

我们可以根据递归三部曲（回溯三部曲）来构建深搜的代码结构。（dfs，bfs其实是基础搜索算法，也广泛应用与其他数据结构与算法中）

回溯法的代码结构：

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

由此我们可以得到dfs的代码结构框架：

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

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

深搜三部曲

我们可以依据回溯三部曲的方式，进行深搜三部曲的分析。

1.确认递归函数，参数列表

void dfs(参数)

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

vector<vector<int>> result; // 保存符合条件的所有路径
vector<int> path; // 起点到终点的路径
void dfs (图，目前搜索的节点)

2.确定终止条件

终止添加不仅是结束本层递归，同时也是我们收获结果的时候。终止条件很重要，需要考虑清楚。

if (终止条件) {
    存放结果;
    return;
}

3.处理目前搜索节点出发的路径（单层地柜逻辑）

一般这里就是一个for循环的操作，去遍历目前搜索节点所能到的所有节点。从一个路径到另一个路径依靠的就是回溯撤销的过程。

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

题目：98. 所有可达路径

文档讲解：手撕所有可达路径

题目： 98. 所有可达路径 (kamacoder.com)（ACM模式）

学习：本题是深度搜索的经典题目之一。此前我们在二叉树章节和回溯算法章节，也做过类似的寻找路径的题目。本质上来说回溯其实就是深搜，只不过针对某一搜索场景我们给他一个更细分的定义，叫做回溯算法。

本题代码书写采用的是ACM模式，因此本题主要有三个部分

图的存储

我们可以采用邻接矩阵和邻接表两个方式进行图的存储。

邻接矩阵：使用二维数组来表示图结构。邻接矩阵是从节点的角度来表示图，有多少节点就申请多大的二维数组。本题我们会有n 个节点，因为节点标号是从1开始的，为了节点标号和下标对齐，我们申请 n + 1 * n + 1 这么大的二维数组。最后根据边m来进行矩阵赋值。

vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0));
while (m--) {
    cin >> s >> t;
    // 使用邻接矩阵 ，1 表示 节点s 指向 节点t
    graph[s][t] = 1;
}

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

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

深度优先搜索

我们可以依据深搜三部曲来进行分析：

1.确认递归函数，参数：首先我们dfs函数一定要存一个图，用来遍历的，需要存一个目前我们遍历的节点，定义为x。还需要存一个n，表示终点，我们遍历的时候，用来判断当 x==n 时候标明找到了终点。（其实在递归函数的参数不容易一开始就确定了，一般是在写函数体的时候发现缺什么，参加就补什么）

至于单一路径和路径集合可以放在全局变量，因此代码为：

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

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

// 当前遍历的节点x 到达节点n 
if (x == n) { // 找到符合条件的一条路径
    result.push_back(path);
    return;
}

3.处理目前搜索节点的逻辑：找到 x节点指向了哪些节点，将选中的x所指向的节点，加入到单一路径来，进入下一层递归，最后还需要进行回溯。

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模式相对于核心代码模式（力扣）更考验大家对代码的掌控能力。例如工程代码里，输出输出都是要自己控制的。这也是为什么大公司笔试，都是ACM模式。

// 输出结果
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; // 这里再打印倒数第一个，控制最后一个元素后面没有空格
}

代码整合

代码：邻接矩阵

#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表示当前遍历的节点
    //2.确定终止条件
    if(x == n) {
        result.push_back(path);
        return;
    }
    
    //3.处理目前搜索节点出发的路径
    for(int i = 1; i <= n; i++) { //注意每次i都得从1开始，遍历所有路径
        if(graph[x][i] == 1) {
            path.push_back(i);
            dfs(graph, i, n);
            path.pop_back(); //回溯
        }
    }
    return;
}

int main() {
    int n, m; 
    cin >> n >> m;
    
    vector<vector<int>> graph(n + 1, vector<int>(n + 1, 0)); //邻接矩阵
    int s, t;
    while(m--) {
        cin >> s >> t;
        graph[s][t] = 1;
    }
    
    path.push_back(1);
    dfs(graph, 1, n); //得到所有路径

    //打印路径
    if(result.size() == 0) cout << -1 << endl;
    for(const vector<int> &it : result) {
        for(int i = 0; i < it.size() - 1; i++) {
            cout << it[i] << " ";
        }
        cout << it[it.size() - 1] << endl; //最后一个元素没有空格
    }
    return 0;
}

代码：邻接表

#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) { //x表示当前遍历的节点
    //2.确定终止条件
    if(x == n) {
        result.push_back(path);
        return;
    }
    
    //3.处理目前搜索节点出发的路径
    for(int i : graph[x]) { //找到x指向的节点
        path.push_back(i);// 遍历到的节点加入到路径中来
        dfs(graph, i, n);// 进入下一层递归
        path.pop_back();// 回溯，撤销本节点
    }
    return;
}

int main() {
    int n, m; 
    cin >> n >> m;
    
    vector<list<int>> graph(n + 1); //邻接表
    int s, t;
    while(m--) {
        cin >> s >> t;
        graph[s].push_back(t);
    }
    
    path.push_back(1);
    dfs(graph, 1, n); //得到所有路径

    //打印路径
    if(result.size() == 0) cout << -1 << endl;
    for(const vector<int> &it : result) {
        for(int i = 0; i < it.size() - 1; i++) {
            cout << it[i] << " ";
        }
        cout << it[it.size() - 1] << endl; //最后一个元素没有空格
    }
    return 0;
}

广搜理论基础

文档讲解：代码随想录广搜理论基础

广搜的使用场景

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

广搜的过程

BFS是一圈一圈的搜索过程，把第一个顶点周围的连接都考虑到。以方格地图为例：

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

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

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

代码框架

如何实现这一圈一圈的搜索过程。主要是需要一个容器，能保存我们要遍历过的元素，用队列，用栈，甚至用数组，都是可以的。

用队列的话，就是保证每一圈都是一个方向去转，例如统一顺时针或者逆时针。因为队列是先进先出，加入元素和弹出元素的顺序是没有改变的。

如果用栈的话，就是第一圈顺时针遍历，第二圈逆时针遍历，第三圈有顺时针遍历。因为栈是先进后出，加入元素和弹出元素的顺序改变了。（但广搜实际上不需要考虑转圈搜索的顺序）

常用的方式是使用队列来作为容器。

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

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

}

实际上二叉树的层序遍历，就是一种广搜在二叉树这种数据结构上的应用。

yachihaoteng

关注

18
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Studying-代码随想录训练营day50| 图论理论基础、深搜理论基础、98. 所有可达路径、广搜理论基础

图论理论基础、深搜理论基础、98. 所有可达路径、广搜理论基础
复制链接

扫一扫