第三章搜索与图论（一）

最新推荐文章于 2024-07-18 20:50:59 发布
最新推荐文章于 2024-07-18 20:50:59 发布
阅读量153 收藏
点赞数
分类专栏： Acwing 基础算法 文章标签： 图论 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49448331/article/details/126230830
版权

文章目录


框架

image-20220807203130059

DFS与BFS区别

DFS:

执着：一直走到头，回去的时候边回去边看能不能向下走

BFS:

稳重：每次只扩展一层，不会离家太远

image-20220807203747530

算法数据结构空间特征
DFSstackO(h)不具有最短性
BFSqueueO(2h)、指数级别“最短路”

DFS

DFS中重要概念：回溯+剪枝

DFS熟称“暴搜”，最重要的是需要考虑顺序

画一棵树

全排列

给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。

现在，请你按照字典序将所有的排列方法输出。

输入格式
共一行，包含一个整数 n。

输出格式
按字典序输出所有排列方案，每个方案占一行。

数据范围
1≤n≤7
输入样例：
3
输出样例：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

步骤

  1. 找到第一个解

image-20220807204519261

  1. 回溯

    image-20220807204619705

  2. 最终结果

​ image-20220807204721240

image-20220807204935128

没有必要区分DFS与递归，DFS就是递归。

虽然看上去是树的形式，但存储的话只会存当前路径，回溯的时候就没有了。

没有必要把整颗树存储下来。

不需要真的把栈写出来，系统会为我们做回溯。写在递归函数中，有隐藏栈来维护，不需要开额外空间。

回溯中一定要注意恢复现场，下来的时候是什么样子，回去之后就是什么样子

image-20220807205500783

#include <iostream>
using namespace std;
const int N = 10;

int n; 
//将状态[路径]存储下来，当向下搜时，path上数字会逐渐填满
int path[N];
//需要知道当前位置上可以填哪些数，即清楚哪些数已经用过了。等于true,表示该点被用过了
bool st[N];

void dfs(int u)
{
    //一开始在第0个位置，当到达第n个位置，表明均填满，此时输出即可
    if(u == n)
    {
        for(int i = 0 ; i < n;i++) printf("%d ",path[i]);
        //输出空行
        puts("");
        return;
    }
    for(int i = 1;i<=n;i++)
        //找到一个没有被用过的数，只有没有用过的才可以使用
        if(!st[i])
        {
            //将数字放到当前位置上去
            path[u] = i;
            //记录i已经被用过了
            st[i] = true;
            //将状态处理好后，递归至下一层
            dfs(u+1);
            //dfs结束时，表明下面的所有路都走完了，就要回溯；
            //回溯时注意恢复现场。出去时什么样，回来时什么样，回溯后继续运行for循环
            // path[u] = 0没有什么用，因为path[u]的值会被不断覆盖掉。不管是几都没问题，因此没必要恢复
            //path[u] = 0;
            st[i] = false;
        }
}

int main()
{
    cin>>n;
    dfs(0);
    return 0;
}

n皇后

n− 皇后问题是指将 n 个皇后放在 n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。

image-20220807213121695

现在给定整数 n，请你输出所有的满足条件的棋子摆法。

输入格式
共一行，包含整数 n。

输出格式
每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。

其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。

每个方案输出完成后，输出一个空行。

注意：行末不能有多余空格。

输出方案的顺序任意，只要不重复且没有遗漏即可。

数据范围
1≤n≤9
输入样例：
4
输出样例：
.Q..
...Q
Q...
..Q.

..Q.
Q...
...Q
.Q..

重要的是顺序：顺序一定要想清楚

  1. 全排列

    每一行只有一个皇后

    第一行皇后可以放在哪一列

    注意剪枝

    image-20220807213502463

    提前判断当前方案是不合法的，停止向下搜索，直接回溯

    image-20220807213937481

    对角线

    两种对角线的截距b有两种：

    y-x:截距不能是负数；所以添加偏移量n

    y+x

    image-20220807214504247

    对角线的数目是2*N-1

    #include <iostream>

using namespace std;

const int N = 20;

int n;
//存储方案
char g[N][N];
//状态数组：列、正对角线、反对角线
bool col[N],dg[N],udg[N];

//对行进行遍历
void dfs(int u)
{
    //当到达第u行，当找到一组方案时
    if(u == n)
    {
        //输出
        for(int i = 0;i<n;i++) puts(g[i]);
        puts("");
        return;
    }
    //从第一列开始枚举
    for(int i = 0 ;i<n;i++)
        //这一列之前没有放过并且对角线上没有放过并且反对角线上没有放过
        //i代表y，u代表x 反对角线 -x+y+n
        if(!col[i] && !dg[u+i] && !udg[-u + i +n])
        {
            //在第u行第i列放置皇后
            g[u][i] = 'Q';
            //第i列为true，表示这一列/对角线/反对角线上已经有皇后了
            col[i] = dg[u+i] = udg[-u+i+n] = true;
            dfs(u+1);
            //恢复现场
            col[i] = dg[u+i] = udg[-u+i+n] = false;
            g[u][i] = '.';
        }
}
int main()
{
    cin>>n;
    for(int i = 0;i< n;i++)
        for(int j = 0;j<n;j++)
            g[i][j] = '.';
    dfs(0);
    
    return 0 ;
}

    时间复杂度：n*n！

  2. 上一种方式经过一步分析，即每一行放置一个皇后。

    也可以采用一种更原始的方式进行枚举八皇后问题。

    一格格枚举，每个节点代表一个格子

    n2个格子

    image-20220807221416555

    考虑格子的边界问题：如果出界，直接返回

    image-20220807221727110

    时间复杂度：2n2

    #include <iostream>

using namespace std;

const int N = 20;

int n;
//存储方案
char g[N][N];
//状态数组：行、列、正对角线、反对角线
bool row[N],col[N],dg[N],udg[N];

void dfs(int x,int y,int s)
{
    //到达y的边界后，y置为0，跳转至下一行
    if(y == n) y = 0,x++;
    //枚举到最后一行，需要停止
    if(x == n)
    {
        //皇后个数等于n，找到一组解
        //s有可能小于n，有可能一个皇后都没有摆，只有n个皇后才有解
        if(s == n)
        {
            for(int i = 0; i<n;i++)
            {
                puts(g[i]);
            }
            puts("");
        }
        //注意：此处必须有return，否则无限递归导致空间不足
        return;
    }
    /*枚举当前格子的两种选择
    上一种方式有n种选择
    */
    //不放皇后：直接递归至下一个格子
    dfs(x,y+1,s);
    //放皇后：判断条件
    if(!row[x] && !col[y] && !dg[x+y] && !udg[-x + y +n])
    {
        //更新状态
        g[x][y] = 'Q';
        row[x] = col[y] = dg[x+y] = udg[-x+y+n] = true;
        //递归至下一层
        dfs(x,y+1,s+1);
        //恢复现场
        row[x] = col[y] = dg[x+y] = udg[-x+y+n] = false;
        g[x][y] = '.';
    }
}
int main()
{
    cin>>n;
    for(int i = 0;i< n;i++)
        for(int j = 0;j<n;j++)
            g[i][j] = '.';
    //从左上角开始搜素，记录当前一共有多少个皇后
    dfs(0,0,0);

    return 0 ;
}

​

BFS

一圈一圈，搜索的距离离当前起点越来越远

image-20220807224840393

给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。

最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。

数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。

输入格式
第一行包含两个整数 n 和 m。

接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。

输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围
1≤n,m≤100
输入样例：
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出样例：
8

样例：

image-20220807225134408

BFS：

每个数字表示它是第几层被扩展到的。

image-20220807225341347

若采用深搜，结果不一定对。可以保证找到终点，但不能保证是最短的

image-20220807225754092

深搜没有固定框架但宽搜有固定框架。

  1. 将初始状态放到队列中
  2. 写while循环：队列不为空
    1. 每次把队头拿出来
    2. 扩展队头
    3. 结束

image-20220807230120604

假设绿点是队头，尝试向上下左右四个方向拓展

image-20220807230644637

用向量表示方向

上 （-1，0）//横坐标减一，纵坐标不变
右 （0，+1）//横坐标不变，纵坐标加一
下 （+1，0）//横坐标加一，纵坐标不变
左 （0，-1）//横坐标不变，纵坐标减一

image-20220807231006308

#include <iostream>
#include <algorithm>
#include <cstring>
//一般需要队列，此处手写队列
//#include <queue>
using namespace std;
//用于表示(x,y)
typedef pair<int,int> PII;
const int N = 110;
int n,m;
int g[N][N]; //存储图,不改变图的信息，只改变队列
int d[N][N]; //存储每个点到起点的距离
//队列，用于存储当前点
PII q[N*N];

int bfs()
{
    //队头hh，队尾tt,由于队列中现在存放第一个数据，因此tt = 0 ；空队列tt = -1;
    q[0] = {0,0};
    int hh = 0 ,tt = 0;
    //初始化为-1
    memset(d,-1,sizeof d);
    //从[0,0]点开始走，一开始距离为0
    d[0][0] = 0;
    //四个方向向量
    int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1}; 
    //队列不为空
    while(hh <= tt)
    {
        //每次取出来队头
        auto t = q[hh++];
        for(int i = 0;i < 4;i++)
        {
            //(x,y)表示沿着该方向可以走到哪个点
            int x = t.first + dx[i],y = t.second + dy[i];
            //判断点是否在边界以内 并且 点是可以走的 并且 这个点还没有走过
            // 如果已经走过，表明该点不是第一次搜到，bfs是第一次搜到的点才是最短距离
            // 注意 x的边界为n，y的边界为m
            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                //当前点的距离是之前点的距离加1
                d[x][y] = d[t.first][t.second] + 1;
 				//将点添加至队列中
                q[++tt] = {x,y};
            }
        }
        
    }
    //返回右下角点的距离
    return d[n-1][m-1];
    
}

int main()
{
    cin>>n>>m;
    //把整个图读进来
    for(int i = 0;i<n;i++ )
        for(int j = 0;j<m;j++)
            cin>>g[i][j];
    cout<<bfs()<<endl;
    return 0;
    
}

如何显示路径–新建一个变量【数组】存储Prev,记录该位置上的点是由上面哪个点扩展而来的

#include <iostream>
#include <algorithm>
#include <cstring>
//一般需要队列，此处手写队列
//#include <queue>
using namespace std;
//用于表示(x,y)
typedef pair<int,int> PII;
const int N = 110;
int n,m;
int g[N][N]; //存储图,不改变图的信息，只改变队列
int d[N][N]; //存储每个点到起点的距离
//队列，用于存储当前点
PII q[N*N];
//最后用于显示路径，每个点存储上一个点的信息，所以每个元素是一个坐标
PII Prev[N][N];

int bfs()
{
    //队头hh，队尾tt,由于队列中现在存放第一个数据，因此tt = 0 ；空队列tt = -1;
    q[0] = {0,0};
    int hh = 0 ,tt = 0;
    //初始化为-1
    memset(d,-1,sizeof d);
    //从[0,0]点开始走，一开始距离为0
    d[0][0] = 0;
    //四个方向向量
    int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1}; 
    //队列不为空
    while(hh <= tt)
    {
        //每次取出来队头
        auto t = q[hh++];
        for(int i = 0;i < 4;i++)
        {
            //(x,y)表示沿着该方向可以走到哪个点
            int x = t.first + dx[i],y = t.second + dy[i];
            //判断点是否在边界以内 并且 点是可以走的 并且 这个点还没有走过
            // 如果已经走过，表明该点不是第一次搜到，bfs是第一次搜到的点才是最短距离
            // 注意 x的边界为n，y的边界为m
            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                //当前点的距离是之前点的距离加1
                d[x][y] = d[t.first][t.second] + 1;
                //Prev[x][y]中存储上一个点
                Prev[x][y] = t;
 				//将点添加至队列中
                q[++tt] = {x,y};
            }
        }
        
    }
    
    //从结尾向前输出
    int x= n-1,y = m-1;
    //当x y不同时等于0的时候，前进。x、y同时为0，表明到达起点
    while(x||y)
    {
        cout<<x<<' '<<y<<endl;
        //获取上一个点，二维点用auto较为方便
        auto t = Prev[x][y];
        //到达上一个点
        x = t.first,y = t.second;
    }
    //返回右下角点的距离
    return d[n-1][m-1];
    
}

int main()
{
    cin>>n>>m;
    //把整个图读进来
    for(int i = 0;i<n;i++ )
        for(int j = 0;j<m;j++)
            cin>>g[i][j];
    cout<<bfs()<<endl;
    return 0;
    
}

DP问题与最短路问题是互通的，dp问题可以看作是一种特殊的最短路问题。

树和图的遍历

树和图的存储

树是一种特殊的图，即无环连通图，因此只需要考虑图的存储方式即可。

图可以分为有向图与无向图。无向图可以建立两个有向边来表示。因此无向图是一种特殊的有向图。只需要考虑有向图如何存储。

image-20220808101744791

存储方式空间场景
邻接矩阵n2适合存储稠密矩阵
邻接表[每个节点有一个单链表]

举例：四个点，开四个单链表。

每个链表存储直接可以到达的点。单链表内部次序是无关紧要的。

image-20220621093332358

当添加新的边时2->3，在链表头部进行插入节点

image-20220808102424543

添加后邻接表

image-20220808102528437

注意

  1. 邻接表使用数组而不使用vector : vector的效率不如数组快
  2. 区分使用cin、scanf的场景：当输入输出的规模在 100 0000[一百万]时 ，才必须用scanf，否则两者效率都差不多
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int N = 100010,M = N * 2;
/*
h--N个链表的链表头
e--存储链表的值，在邻接表中表示连接的节点编号，在图中表现为所有的边。
ne--每个节点的next值
*/
int h[N],e[M],ne[M],idx;

//插入一条边：a->b:即在a节点对应的链表中插入节点b
void add(int a, int b)
{
    e[idx] = b;ne[idx] = h[a];h[a] = idx++;
}


int main()
{
    //链表初始化：将所有的链表头初始化为-1即可
    memset(h,-1,sizeof h);
}

数和图的遍历

遍历时每个点只遍历一次

深度优先遍历

有向图

image-20220808104759188

遍历顺序

image-20220808104816708

image-20220808104850733

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int N = 100010,M = N * 2;
/*
h--N个链表的链表头
e--存储链表的值，在邻接表中表示连接的节点编号，在图中表现为所有的边。
ne--每个节点的next值
*/
int h[N],e[M],ne[M],idx;


//每个点只需要遍历一次，需要存储bool数组表示哪些点已经遍历过了
bool st[N];
//插入一条边：a->b:即在a节点对应的链表中插入节点b
void add(int a, int b)
{
    e[idx] = b;ne[idx] = h[a];h[a] = idx++;
}

//u表示当前已经dfs到的点
void dfs(int u)
{
    //首先更新状态，标记当前点已经被搜索过了
    st[u] = true;
    //遍历u的所有出边,与遍历单链表相同
    for(int i = h[u];i != -1; i = ne[i])
    {
        //获取节点值，即对应的图中节点编号
        int j = e[i];
        //判断条件,如果j没有被搜过，则继续搜，一条路走到黑
        if(!st[j]) dfs(j);
    }
}

int main()
{
    //链表初始化：将所有的链表头初始化为-1即可
    memset(h,-1,sizeof h);
    //从第一个节点开始搜素
    dfs(1);
}


846 树的重心
给定一颗树，树中包含 n 个结点（编号 1∼n）和 n−1 条无向边。

请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。

重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。

输入格式
第一行包含整数 n，表示树的结点数。

接下来 n−1 行，每行包含两个整数 a 和 b，表示点 a 和点 b 之间存在一条边。

输出格式
输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最大值。

数据范围
1≤n≤105
输入样例
9
1 2
1 7
1 4
2 8
2 5
4 3
3 9
4 6
输出样例：
4
  1. 无向图，建立相反方向的边
  2. 输出最小的最大值

举例：说明重心是什么

image-20220808110628526

依次枚举删除每个点后剩余部分的最大值

点连通块最大值
14
26
45

image-20220808111002220

做法：

每个点删除后，剩余连通块的最大值，在所有点中找最小的

深度优先遍历可以快速算出每棵子树的大小

以去除4为例

image-20220808111505404

image-20220808111602458

时间复杂度：O(n+m)

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int N = 100010,M = N * 2;
/*
h--N个链表的链表头
e--存储链表的值，在邻接表中表示连接的节点编号，在图中表现为所有的边。
ne--每个节点的next值
*/
int h[N],e[M],ne[M],idx;
int n;
//记录全局的答案，表明最小的最大值
int ans = N;



//每个点只需要遍历一次，需要存储bool数组表示哪些点已经遍历过了
bool st[N];
//插入一条边：a->b:即在a节点对应的链表中插入节点b
void add(int a, int b)
{
    e[idx] = b;ne[idx] = h[a];h[a] = idx++;
}

//dfs返回以u为根的子树中点的数量
//u表示当前已经dfs到的点
int dfs(int u)
{
    //首先更新状态，标记当前点已经被搜索过了
    st[u] = true;
    //sum:记录当前以u为树根的子树的大小，用于返回值 
    //res:将该点删除后连通块的最大值，初始化为0
    //注：定义变量后一定要及时初始化
    int sum = 1,res = 0;
    //遍历u的所有出边,与遍历单链表相同
    for(int i = h[u];i != -1; i = ne[i])
    {
        //获取节点值，即对应的图中节点编号
        int j = e[i];
        //判断条件,如果j没有被搜过，则继续搜，一条路走到黑
        if(!st[j])
        {
            //s表示当前子树的大小
            int s = dfs(j);
            //当前子树也是一个连通块
            res = max(res,s);
            //当前子树是以u为根节点树的一部分
            sum += s;
            
        }
    }
    //计算剩余的连通块的数量 n - sum
    res = max(res, n - sum);
    //最后，res存储删除该点后最大的连通块点数
    ans = min(ans,res);
    return sum;
    
}

int main()
{
    //处理输入输出
    cin>>n;
    
    //链表初始化：将所有的链表头初始化为-1即可
    memset(h,-1,sizeof h);
    
    for(int i = 0;i < n;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b),add(b,a);
    }
    //从第一个节点开始搜素
    //为什么不是0：idx存放的是边，也就是下标，节点为对应的值。图的节点由输入决定,输入的节点最小为1。以那个点开始搜索都是一样的,以哪个点为根节点均可以
    dfs(1);
    cout<<ans<<endl;
    return 0;
}

宽度优先遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mTfsenij-1659948153547)(https://gitee.com/jgyong/blogimg/raw/master/img/image-20220808105008157.png)]

847 图中点的层次
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环。

所有边的长度都是 1，点的编号为 1∼n。 //可以用宽搜求最短路

请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1。

输入格式
第一行包含两个整数 n 和 m。

接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

数据范围
1≤n,m≤105
输入样例：
4 5
1 2
2 3
3 4
1 3
1 4
输出样例：
1

image-20220808115152414

image-20220808115418666

宽搜图的基本框架：

  1. 将初始状态放到队列中 -->将1号点放至队列中
  2. 初始化：距离[其他点的距离为-1，头结点的距离为0]
  3. 写while循环：队列不为空
    1. 每次取得队头元素
    2. 扩展队头：扩展所有能到的点
      1. 如果x没有被遍历过[因为只有第一次遍历才是最短路径，以后的遍历都不是了]
        1. x入队
        2. 更新x的距离
  4. 结束

image-20220808120851921

最重要的是：关注思想

#include <iostream>
#include <string.h>

using namespace std;
//有向图，节点与边的上限可以都设置为N
const int N = 100010;
int n,m;

int h[N],e[N],ne[N],idx;
int d[N],q[N];

void add(int a,int b)
{
    e[idx] = b;ne[idx] = h[a];h[a] = idx++;
}

int bfs()
{
    //将0节点放置在队列中
    int hh = 0,tt=0;
    //将1号节点放在队列的0号位置
    q[0] = 1;
    //初始化距离
    memset(d,-1,sizeof(d));
    //d[节点]：初始化1号节点距离为0
    d[1] = 0;
    
    while(hh <= tt)
    {
        //取头结点
        int t = q[hh++];
        //拓展每个点的临边
        for(int i = h[t];i != -1;i = ne[i])
        {
            //获取节点，进行判断
            int j = e[i];
            if(d[j] == -1)
            {
                d[j] = d[t] + 1;
                q[++tt] = j;
            }
        }
    }
    return d[n];
    
}

int main()
{
    cin>>n>>m;
    
    memset(h,-1,sizeof(h));
    for(int i = 0 ;i < m;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
    }
    cout<<bfs()<<endl;
    return 0;
}

图的宽搜应用

最经典应用为求拓扑距

848. 有向图的拓扑序列
给定一个 n 个点 m 条边的有向图，点的编号是 1 到 n，图中可能存在重边和自环。

请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1。

若一个由图中所有点构成的序列 A 满足：对于图中的每条边 (x,y)，x 在 A 中都出现在 y 之前，则称 A 是该图的一个拓扑序列。

输入格式
第一行包含两个整数 n 和 m。

接下来 m 行，每行包含两个整数 x 和 y，表示存在一条从点 x 到点 y 的有向边 (x,y)。

输出格式
共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可。

否则输出 −1。

数据范围
1≤n,m≤105
输入样例：
3 3
1 2
2 3
1 3
输出样例：
1 2 3

拓扑序列针对有向图而言，无向图没有拓扑序列

举例

image-20220808144738487

对于每条边，起点都在终点前面，它就是个拓扑序列。

拓扑序列对应图中每个边都是由前指向后的。

image-20220808144940507

并不是所有的图都有拓扑序列。有环的图没有拓扑序列。

有向无环图一定存在拓扑序列的，因此有向无环图又被称为拓扑图。

image-20220808145057939

度数：

有向图中每个点有两个度

入度：一个点有几条边进来，边数叫做入度

出度：一个点有几条边出去，边数叫做出度

image-20220808145528959

如何求拓扑序列？

拓扑序列都是由前指向后，入度为0的点都可以作为起点

入度为0，没有一条边指向我，没有任何一个节点在我前面，所有点都可以排在最前面的位置

如果有环的话，所有点的入度都不是0

image-20220808151317497

框架：

  1. 将所有入度为0的点入队
  2. 宽搜
    1. 队列不空
      1. 取队头 t
      2. 枚举t的所有出边 t->j
      3. 删掉边，使得后面节点j的入度–
      4. 如果j的入度为0[j前面的点都拍好序 放好了]
      5. j没有任何限制，j入队

image-20220808151215873

没有环的图一定可以依次解决每一个点。

image-20220808151354944

一个有向无环图，一定至少存在一个入度为0的点

image-20220808152326143

有向无环图，删除一个点后还是有向无环图。

#include <cstring>
#include <iostream>
using namespace std;

const int N = 100010;
int n,m;
int h[N],e[N],ne[N],idx;
//q存储队列
int q[N];
//d存储入度
int d[N];

void add(int a,int b)
{
    e[idx] = b,ne[idx]= h[a],h[a] = idx++;
}

bool topsort()
{
    int hh = 0,tt = -1;
    //遍历所有点，将所有入度为0的点插入到队列中去
    for(int i = 1;i <= n;i++)
        if(!d[i])
            //从队尾插入
            q[++tt] = i;
    //while队列不空
    while(hh <= tt)
    {
        //取出队头元素
        int t =q[hh++];
        for(int i = h[t];i != -1;i = ne[i])
        {
            //找到出边
            int j = e[i];
            //因为弹出队头，所以之后点的入度减一
            d[j]--;
            //如果入度为0，添加至队列
            if(d[j] == 0) q[++tt] = j;
        }
    }
    //如果所有点都进入队列，表明是有向无环图，n个点，一开始tt = -1
    //队列中次序就是拓扑序。出队的顺序是拓扑序。出队只是将指针从前向后移动一位，前面的顺序都是不变的。因此遍历完成后q中顺序就是拓扑序
    return tt == n-1;
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(int i = 0;i < m;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
        //更新入度
        d[b]++;
    }
    if(topsort())
    {
        for(int i = 0;i < n;i++) printf("%d ",q[i]);
        puts("");
    }
    else puts("-1");
    return 0;
}

题目的答案并不是唯一的

一只积极向上的小咸鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法基础课——第三章 搜索与图论（一）
m0_62021646的博客
02-01 838
第三章 搜索与图论（一） DFS与BFS的区别与联系 都可以对整个问题空间进行遍历； 搜索的结构都像树一样； 但搜索的顺序是不同的； 深度优先搜索是尽可能往深里搜，当搜到叶子节点的时候回溯； DFSDFSDFS 就像一个非常执着的人，它会不断往深里搜，搜到头后回去的时候也还不是直接回到头，而是边回去边看能不能继续往前走，只有确定当前点所有路都走不了的时候，才会往回退一步； 下图中的树代表整个问题空间，节点上的数字代表 DFSDFSDFS 遍历的...
Acwing-基础算法-第三章-搜素与图论
04-01
【Acwing-基础算法-第三章-搜索与图论】主要涵盖了两个核心概念：搜索算法和图论。在本章中，重点讲述了如何利用搜索算法解决图论问题。 1. **深度优先搜索（DFS, Depth-First Search）** - DFS是一种用于遍历或...
BFS解决走迷宫问题
m0_56015524的博客
03-28 229
#BFS解决走迷宫问题 下面是题目 给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。 最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。 请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。 数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。 输入格式 第一行包含两个整数 n 和 m。 接下来 n 行，每行包含 m 个整数（0 或 1
第三章 搜索与图论(一)
starryHW的博客
04-16 71
与上题不同点在于减枝–去掉不满足条件的分支走法解法二：–比较原始的搜索顺序–效率比上面低一些。
第三章 搜索与图论(二)
m0_49448331的博客
08-09 586
知识结构图根据图的性质，选择不同的算法最短路算法的侧重点与难点在于建图，如何把原问题抽象为最短路问题不同的算法侧重点不同，最短路算法侧重于实现，其余算法可能侧重于原理。
第三章 搜索与图论（一）
Blueqwq的小黑屋
12-05 133
第三章 搜索与图论（一）搜索深度优先搜索（DFS）广度优先搜索（BFS）图论图 搜索 深度优先搜索（DFS） AcWing 842. 排列数字 AcWing 843. n-皇后问题 搜索方式：直接搜索到叶节点，再回溯 剪枝： 分为可行性剪枝和最优性剪枝 可行性剪枝：判断当前状况是否合法 最优性剪枝：判断当前情况是不是最优解（与当前出现的最优解进行比较） 广度优先搜索（BFS） AcWing 844. 走迷宫 AcWing 845. 八数码 搜索方式：一层一层搜索，可以得到最短路径 图论 图 1.图的分类 分
Acwing 第三章模板及详解（搜索与图论）
weixin_64393298的博客
02-04 1088
一、DFS与BFS 二、树与图的遍历：拓扑排序 三、最短路 四、最小生成树 五、二分图：染色法、匈牙利算法 一、DFS与BFS 概述 DFS：深度优先搜索（Depth-First-Search） BFS：宽度优先搜索（Breadth-First-Search） DFS和BFS的对比 DFS使用栈（stack）来实现，BFS使用队列（queue）来实现 DFS所需要的空间是树的高度h，而BFS需要的空间是2h （DFS的空间复杂度较低） DFS不具有最短路的特性，BFS具有最短路的特.
acwing算法基础笔记第三章搜索与图论
d_mail的博客
08-24 99
每一行都要放一个皇后，并且只能放一个皇后，所以可以从前往后枚举每一行的皇后可以放到哪一个位置上，比如写出n行，即n个空位，如果在第一行的把皇后放到第一列就是1，第二行把皇后放到第三列就是3，即搜索顺序和全排列的搜索顺序是一样的，树是一种特殊的图，无向图是一种特殊的有向图，对于每一条无向边，建两条边就可以了，所以只需要考虑有向图如何存储就可以了，第u行所在的对角线和反对角线是对应的直线的截距b，因为y-x可能为负数，所以补上n这个偏移量，反对角线是y+x，一个有向无环图的拓扑序不一定是唯一的，
ACwing 第三章 搜索与图论
大一实习生的博客
11-18 343
DFS 与 BFS DFS中有两个重要的概念：回溯和剪枝 当图中所有边的权重为1时，BFS搜到的一定是最短路 回溯时一定要注意恢复现场 排列数字 #include<iostream> using namespace std; const int N = 10; int n; int path[N];//记录所有的搜索路径 bool st[N];//记录这些点有没有被用过，1表示是，0表示否 void dfs(int u) // 第u层 { if(u == n)//从0开始作为第一
第三章 搜索与图论
weixin_62707591的博客
03-07 118
DFS与BFS 树与图的遍历：拓扑排序 最短路 最小生成树 二分图：染色法、匈牙利算法 DFS 深度优先搜索（DFS，Depth First Search），就是按照深度优先的顺序对“问题状态空间”进行搜索的算法。 深度优先搜索与“递归”和“栈”密切相关，“深搜”是一类包括遍历形式、状态记录与检索、剪枝优化等算法整体设计的统称。 剪枝，就是减少搜索树规模、尽早排除搜索树中不必要的分支的一种手段。形象地看，就好像剪掉了搜索树的枝条，故被称为“剪枝”。 题目：排列数字 给定一个整
第11章-图论模型与算法
12-10
本章"第11章-图论模型与算法"深入探讨了多种关键概念和算法，这些对于优化问题求解和网络分析尤其有用。以下是本章涉及的主要知识点： 1. **树**：树是一种特殊的图，具有连通性、无环性和n-1条边的特性。无根树...
考研数据结构第七章-图论必刷题
04-27
【考研数据结构第七章-图论必刷题】这一部分主要涵盖了图论在数据结构中的重要知识点，包括图的基本概念、性质以及相关的算法。以下是详细的内容解析： 1. 图的路径定义：图中的路径是由顶点按顺序连接的边构成的...
10第10章 图论模型(Python 程序及数据).zip
09-03
在本压缩包“10第10章 图论模型(Python 程序及数据).zip”中，主要涵盖了图论这一计算机科学领域的知识，并结合Python编程语言进行了实践。图论是数学的一个分支，它研究如何用图形表示实体及其相互关系，而Python则...
图论及其应用课后题全部答案
06-05
《图论及其应用》是计算机科学与数学领域中的一门重要课程，主要研究网络结构、关系和算法。张先迪和李正良编写的教材深入浅出地介绍了这一主题，并包含了丰富的课后习题，旨在帮助学生巩固理论知识并提升实践能力。...
代码随想录学习 54day 图论 A star算法
qq_40445763的博客
07-17 473
【代码】代码随想录学习 54day 图论 A star算法。
C++树形结构（2 树的直径）
最新发布
Archie28的博客
07-18 996
树的直径
代码随想录学习 day54 图论 Bellman_ford 队列优化算法（又名SPFA） 学习
qq_40445763的博客
07-17 296
【代码】代码随想录学习 54day 图论 Bellman_ford 队列优化算法（又名SPFA） 学习。
代码随想三刷图论篇2
张丁花的博客
07-16 758
【代码】代码随想三刷图论篇2。
数据结构第六章详解：图论与遍历算法
本章节是关于数据结构课程的第六章，主要探讨图论的相关概念和应用。图是一种重要的数据结构，它描述的是数据元素之间的多对多关系，包括线性结构、树形结构、集合和图形结构中的图。具体学习内容分为以下几个部分：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值