深圳幻海软件技术有限公司 欢迎您！
更多

搜索与图论 - 搜索与图在算法中的应用【上】

2023-04-27

int amp for
目录DFS        排列数字        n-皇后问题BFS      

目录

DFS

        排列数字

        n-皇后问题

BFS

        走迷宫

        八数码

树与图的深度优先遍历

数的重心 

树与图的广度优先遍历

图中点的层次

拓扑排序

有向图的拓扑序列

DFS

排列数字

 

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. const int N=10;
  5. int n;
  6. int path[N];
  7. bool st[N];
  8.  
  9. void dfs(int u)
  10. {
  11.     if(u==n)
  12.     {
  13.         for(int i=0;i<n;i++) cout<<path[i]<<" ";
  14.         puts("");
  15.         return ;
  16.         
  17.     }
  18.     for(int i=1;i<=n;i++) //1 ~ n
  19.     {
  20.         if(!st[i])  //如果没用过
  21.         {
  22.             path[u]=i;  
  23.             st[i]=true;     //表示这个数用过
  24.             dfs(u+1);
  25.             st[i]=false;    //回溯，完整还原使用前样子
  26.         }
  27.     }
  28. }
  29.  
  30.  
  31. int main()
  32. {
  33.     cin>>n;
  34.     dfs(0);
  35.     return 0;
  36. }

n-皇后问题

思路：

按行枚举  时间复杂度O(n*!n) 

难点：如果判断是否在同一条斜线

因为斜线斜率相同，所以唯一区分就是截距，截距相同则是同一条斜线

截距表示方法：

下面分析中的(x,y)相当于上面的(u,i)

  1. 反对角线 y=x+b 截距 b=y−x，因为我们要把 b 当做数组下标来用，显然 b 不能是负的，所以我们加上 +n （实际上+n+4,+2n都行），来保证是结果是正的，即 y - x + n
  2. 正对角线 y=−x+b, 截距是 b=y+x，这里截距一定是正的，所以不需要加偏移量

注意：列col必须由 i 表示，因为后面会一直递归是由dfs（u+1）推进的，若由 u 表示则造成第一行相同的情况；

也就是说 col，dg，udg保证列、对角线、反对角线上无重复元素，而col固定保证列不重时再由u+1推进才能保证行不重

  1. #include <iostream>
  2. using namespace std;
  3. const int N = 20; 
  4.  
  5. // bool数组用来判断搜索的下一个位置是否可行
  6. // col列，dg对角线，udg反对角线
  7. // g[N][N]用来存路径
  8.  
  9. int n;
  10. char g[N][N];
  11. bool col[N], dg[N], udg[N];
  12.  
  13. void dfs(int u) {
  14.     // u == n 表示已经搜了n行，故输出这条路径
  15.     if (u == n) {
  16.         for (int i = 0; i < n; i ++ ) puts(g[i]);   // 等价于cout << g[i] << endl;
  17.         puts("");  
  18.         return;
  19.     }
  20.  
  21.     //对n个位置按行搜索
  22.     for (int i = 0; i < n; i ++ )
  23.         // 剪枝(对于不满足要求的点，不再继续往下搜索)  
  24.         // udg[n - u + i]，+n是为了保证下标非负
  25.         if (!col[i] && !dg[u + i] && !udg[n - u + i]) {
  26.             g[u][i] = 'Q';
  27.             col[i] = dg[u + i] = udg[n - u + i] = true;
  28.             dfs(u + 1);
  29.             col[i] = dg[u + i] = udg[n - u + i] = false; // 回溯，还原使用前所有情况
  30.             g[u][i] = '.';
  31.  
  32.         }
  33. }
  34.  
  35. int main() {
  36.     cin >> n;
  37.     for (int i = 0; i < n; i ++ )
  38.         for (int j = 0; j < n; j ++ )
  39.             g[i][j] = '.';
  40.  
  41.     dfs(0);
  42.  
  43.     return 0;
  44. }   
  45.

BFS

走迷宫

思路：

记忆：

初始化队头、距离数组、四个方向

从初始化点开始遍历，符合条件的点都入队

 数组模拟队列 

  1. #include<iostream>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int N = 110; 
  6. typedef pair<int, int> PII;
  7. int n, m;
  8. int g[N][N];//存放地图
  9. int d[N][N];//存 每一个点到起点的距离
  10. PII q[N * N];//手写队列 地图有N*N个点
  11. int bfs()
  12. {
  13.     int hh = 0, tt = 0;
  14.     q[0] = {0, 0};
  15.  
  16.     memset(d, - 1, sizeof d);//距离初始化为- 1表示没有走过
  17.  
  18.     d[0][0] = 0;//表示起点走过了
  19.  
  20.     int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};//x 方向的向量和 y 方向的向量组成的上、右、下、左
  21.  
  22.     while(hh <= tt)//队列不空
  23.     {
  24.         PII t = q[hh ++ ];//取队头元素，hh++相当于头删q.pop();
  25.  
  26.         for(int i = 0; i < 4; i ++ )//枚举4个方向
  27.         {
  28.             int x = t.first + dx[i], y = t.second + dy[i];//x表示沿着此方向走会走到哪个点
  29.             if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)//在边界内 并且是空地可以走 且之前没有走过
  30.             {
  31.                 d[x][y] = d[t.first][t.second] + 1; //到起点的距离+1
  32.                 q[ ++ tt ] = {x, y};//新坐标入队
  33.             }
  34.         }
  35.     }
  36.     return d[n - 1][m - 1]; //输出右下角点距起点的距离即可
  37. }
  38. int main() 
  39. {
  40.     cin >> n >> m;
  41.     for(int i = 0; i < n; i ++ )
  42.         for(int j = 0; j < m; j ++ )
  43.             cin >> g[i][j];
  44.  
  45.     cout << bfs() << endl;
  46.  
  47.     return 0;
  48. }
  49.

C++ queue

  1. #include <iostream>
  2. #include <cstring>
  3. #include <queue>
  4.  
  5. using namespace std;
  6.  
  7. const int N = 110;
  8.  
  9. typedef pair<int, int> PII;
  10.  
  11. int n, m;
  12. int g[N][N], d[N][N];
  13.  
  14. int bfs()
  15. {
  16.     queue< pair<int, int> > q;
  17.  
  18.     q.push({0, 0});
  19.  
  20.     memset(d, -1, sizeof(d));
  21.  
  22.     d[0][0] = 0;
  23.  
  24.  
  25.     int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
  26.  
  27.     while (q.size())//队列不为空
  28.     {
  29.         PII t = q.front();//取队头元素
  30.  
  31.         q.pop();//出队
  32.  
  33.         for (int i = 0; i < 4; i++)
  34.         {
  35.             int x = t.first + dx[i], y = t.second + dy[i];
  36.  
  37.             if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
  38.             {
  39.                 d[x][y] = d[t.first][t.second] + 1;//当前点到起点的距离
  40.                 q.push({x, y});//将新坐标入队
  41.             }
  42.         }
  43.     }
  44.  
  45.     return d[n - 1][m -1];
  46. }
  47.  
  48. int main()
  49. {
  50.     cin >> n >> m;
  51.     for (int i = 0; i < n; i++)
  52.         for (int j = 0; j < m; j++)
  53.             cin >> g[i][j];
  54.  
  55.     cout << bfs() << endl;
  56.  
  57.     return 0;
  58. }

补充：打印路径

因为Prve存的是该路径的上一步操作

  1. #include<iostream>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5. const int N = 110;
  6. typedef pair<int, int> PII;
  7. PII q[N*N],Prev[N][N];
  8. int g[N][N], d[N][N];
  9. int n, m;
  10. int bfs()
  11. {
  12.     int hh = 0, tt = 0;
  13.     q[0] = {0, 0};
  14.     memset(d, -1, sizeof d);
  15.  
  16.     int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
  17.     d[0][0] = 0;
  18.     while(hh <= tt)
  19.     {
  20.         PII t = q[hh ++ ];
  21.         for(int i = 0; i < 4; i ++ )
  22.         {
  23.             int x = dx[i] + t.first, y = t.second + dy[i];
  24.  
  25.             if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
  26.             {
  27.                 d[x][y] = d[t.first][t.second] + 1;
  28.                 Prev[x][y] = t;
  29.                 q[++ tt] = {x, y};
  30.             }
  31.         }
  32.     }
  33.     int x = n - 1, y = m - 1;
  34.     while(x || y)//有一个不d等于0
  35.     {
  36.         cout << x << ' ' << y << endl;
  37.         PII t = Prev[x][y];
  38.         x = t.first, y = t.second;
  39.     }
  40.  
  41.     return d[n - 1][m - 1];
  42. }
  43. int main()
  44. {
  45.     cin >> n >> m;
  46.     for(int i = 0; i < n; i ++ )
  47.         for(int j = 0; j < m;j ++)
  48.             cin >> g[i][j];
  49.  
  50.     cout << bfs() << endl;
  51.  
  52.     return 0;
  53. }
  54.  
  1. #include <iostream>
  2. #include <cstring>
  3. #include <queue>
  4.  
  5. using namespace std;
  6.  
  7. const int N = 110;
  8.  
  9. typedef pair<int, int> PII;
  10. PII Prve[N][N];
  11. int n, m;
  12. int g[N][N], d[N][N];
  13.  
  14. int bfs()
  15. {
  16.     queue< pair<int, int> > q;
  17.     q.push({0, 0});
  18.     memset(d, -1, sizeof(d));
  19.     d[0][0] = 0;
  20.     int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
  21.  
  22.     while (q.size())//队列不为空
  23.     {
  24.         PII t = q.front();//取队头元素
  25.         q.pop();//出队
  26.         for (int i = 0; i < 4; i++)
  27.         {
  28.             int x = t.first + dx[i], y = t.second + dy[i];
  29.             if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
  30.             {
  31.                 d[x][y] = d[t.first][t.second] + 1;//当前点到起点的距离
  32.                 Prve[x][y]=t;
  33.                 q.push({x, y});//将新坐标入队
  34.             }
  35.         }
  36.     }
  37.     int x=n-1,y=m-1;
  38.     while(x||y)
  39.     {
  40.         cout<<x<<" "<<y<<endl;
  41.         PII t=Prve[x][y];
  42.         x=t.first,y=t.second;
  43.     }
  44.  
  45.     return d[n - 1][m -1];
  46. }
  47.  
  48.  
  49.  
  50. int main()
  51. {
  52.     cin >> n >> m;
  53.     for (int i = 0; i < n; i++)
  54.         for (int j = 0; j < m; j++)
  55.             cin >> g[i][j];
  56.  
  57.     cout << bfs() << endl;
  58.  
  59.     return 0;
  60. }

蓝桥杯2019省赛填空题：迷宫

 

  1. 01010101001011001001010110010110100100001000101010
  2. 00001000100000101010010000100000001001100110100101
  3. 01111011010010001000001101001011100011000000010000
  4. 01000000001010100011010000101000001010101011001011
  5. 00011111000000101000010010100010100000101100000000
  6. 11001000110101000010101100011010011010101011110111
  7. 00011011010101001001001010000001000101001110000000
  8. 10100000101000100110101010111110011000010000111010
  9. 00111000001010100001100010000001000101001100001001
  10. 11000110100001110010001001010101010101010001101000
  11. 00010000100100000101001010101110100010101010000101
  12. 11100100101001001000010000010101010100100100010100
  13. 00000010000000101011001111010001100000101010100011
  14. 10101010011100001000011000010110011110110100001000
  15. 10101010100001101010100101000010100000111011101001
  16. 10000000101100010000101100101101001011100000000100
  17. 10101001000000010100100001000100000100011110101001
  18. 00101001010101101001010100011010101101110000110101
  19. 11001010000100001100000010100101000001000111000010
  20. 00001000110000110101101000000100101001001000011101
  21. 10100101000101000000001110110010110101101010100001
  22. 00101000010000110101010000100010001001000100010101
  23. 10100001000110010001000010101001010101011111010010
  24. 00000100101000000110010100101001000001000000000010
  25. 11010000001001110111001001000011101001011011101000
  26. 00000110100010001000100000001000011101000000110011
  27. 10101000101000100010001111100010101001010000001000
  28. 10000010100101001010110000000100101010001011101000
  29. 00111100001000010000000110111000000001000000001011
  30. 10000001100111010111010001000110111010101101111000

简述：

题目要求非常简单，就是打印路径，打印方式优先级为下>左>右>上（使得字典序最小）

int dx[4] = { 1,0,0,-1 }, dy[4] = { 0,-1,1,0 };        //D<L<R<U      字典序直接把方向数组处理好就可以了

  1. #include <iostream>
  2. #include <cstring>
  3. #include <algorithm>
  4. #include<queue>
  5. using namespace std;
  6.  
  7. typedef pair<int, int> PII;
  8. const int N = 110;
  9.  
  10. int d[N][N];
  11. char g[N][N];
  12. PII Prev[N][N];
  13. int n, m;
  14. string s;
  15. int bfs()
  16. {
  17.  
  18.     queue<PII> q;
  19.     memset(d, -1, sizeof d);
  20.     d[1][1] = 0;
  21.     q.push({ 1,1 });
  22.     int dx[4] = { 1, 0, 0, -1 }, dy[4] = { 0, -1, 1, 0 };//方向优先级为 下>左>右>上
  23.  
  24.     while (q.size())
  25.     {
  26.         PII t = q.front();
  27.         q.pop();
  28.  
  29.         for (int i = 0; i < 4; i++)
  30.         {
  31.  
  32.             int x = t.first + dx[i], y = t.second + dy[i];
  33.             if (x > 0 && x <= n && y > 0 && y <= m && g[x][y] == '0' && d[x][y] == -1)
  34.             {
  35.                 d[x][y] = d[t.first][t.second] + 1;
  36.                 Prev[x][y]=t;
  37.                 q.push({ x,y });
  38.             }
  39.         }
  40.     }
  41.     char dir[4]={'D','L','R','U'};
  42.     
  43.     int x=n,y=m;
  44.     while(x!=1||y!=1)
  45.     {
  46.         cout<<x<<" "<<y<<endl;
  47.         int tmpx=x,tmpy=y;//当前步
  48.         PII t=Prev[x][y];
  49.         x=t.first,y=t.second;//前一步
  50.         
  51.         int l=tmpx-x,r=tmpy-y;//计算出走的方向
  52.         if(l==1&&r==0) s+=dir[0];
  53.         else if(l==0&&r==-1) s+=dir[1];
  54.         else if(l==0&&r==1) s+=dir[2];
  55.         else if(l==-1&&r==0) s+=dir[3];
  56.     }
  57.     
  58.     return d[n][m];
  59. }
  60.  
  61. int main()
  62. {
  63.  
  64.     cin >> n >> m;
  65.     for (int i = 1; i <= n; i++)
  66.         for (int j = 1; j <= m; j++)
  67.             cin >> g[i][j];
  68.             
  69.     int dist=bfs();
  70.     
  71.     for(int i=s.size()-1;i>=0;i--)//方向
  72.         cout<<s[i];
  73.         cout<<endl;
  74.         
  75.     cout << dist<<endl;//最短距离
  76.     
  77.     return 0;
  78. }

八数码

思路：

用map<string,int>存储状态与状态对应的距离；将一维字符串转化为二维数组，对x的上下左右4个方向数字交换以形成新状态，存储新状态，并让距离加1；重复操作直到到达最终状态

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<queue>
  4. #include<unordered_map>
  5. using namespace std;
  6.  
  7. int bfs(string start)
  8. {
  9.     string end="12345678x";//最终完成的状态
  10.     
  11.     queue<string> q;
  12.     unordered_map<string,int>  d;//利用字符串记录距离
  13.     
  14.     q.push(start);
  15.     d[start]=0;
  16.     
  17.     int dx[4]={0,0,-1,1},dy[4]={1,-1,0,0};
  18.     
  19.     while(q.size())
  20.     {
  21.         auto t=q.front();
  22.         q.pop();
  23.         
  24.         int distance=d[t];
  25.         if(t==end) return distance;
  26.         
  27.         int k=t.find('x');  //一维下标转换为二维坐标
  28.         int x=k/3,y=k%3;
  29.         
  30.         for(int i=0;i<4;i++)
  31.         {
  32.             int a=x+dx[i],b=y+dy[i];//(a,b)表示移动后x坐标
  33.             if(a>=0&&a<3&&b>=0&&b<3)
  34.             {
  35.                 swap(t[k],t[3*a+b]);
  36.                 //当前状态是第一次遍历，记录距离，入队
  37.                 if(!d.count(t))
  38.                 {
  39.                     d[t]=distance+1;
  40.                     q.push(t);
  41.                 }
  42.                 //还原状态，为下一状态准备，因为该状态有4种走法
  43.                 swap(t[k],t[3*a+b]);
  44.             }
  45.         }
  46.     }
  47.     return -1;
  48. }
  49.  
  50. int main()
  51. {
  52.     string c,start;
  53.     for(int i=0;i<9;i++)
  54.     {
  55.         cin>>c;
  56.         start+=c;
  57.     }
  58.     cout<<bfs(start)<<endl;
  59.     return 0;
  60. }

树与图的深度优先遍历

数的重心 

 1、由题意画图得：如图删除1节点，连通快最大值为4，是所有连通块最大值中最小的

2、存储无向图我们可以看成特殊的有向图，即让每个节点都双向连接；

存储有向图我们用邻接表存储

  1. void add(int a,int x)
  2. {
  3.     e[idx]=x,ne[idx]=h[a],h[a]=idx++;
  4. }

该操作表示以节点a为头，头插插入入一个为x的结点

3、如何遍历树？

树的dfs模板 

  1. // 需要标记数组st[N],  遍历节点的每个相邻的便
  2. void dfs(int u) {
  3.     st[u] = true; // 标记一下，记录为已经被搜索过了，下面进行搜索过程
  4.     for (int i = h[u]; i != -1; i = ne[i]) {
  5.         int j = e[i];
  6.         if (!st[j]) {
  7.             dfs(j);
  8.         }
  9.     }
  10. }

4、如何求最大连通子图

如图所示，假设节点4为树的重心，那么可以通过dfs（4）来遍历以4为根的子树，求该树得节点数；然后我们可以惊奇的发现，除了该子树以外，其他节点必构成连通子图，那么连通子图值就为n-size4

对于树中的连通子图，利用dfs不断更新取最大值；

  1. int dfs(int u)
  2. {
  3.     int res=0;//存储删除某节点后 最大连通子图值
  4.     st[u]=true;//表示u节点已经访问过
  5.     int sum=1;//以u为根的树的节点数（包括u）
  6.     
  7.     //访问u的每个子节点
  8.     for(int i=h[u];i!=-1;i=ne[i])
  9.     {
  10.         int point=e[i];
  11.         if(!st[point])//若该节点没访问过
  12.         {
  13.             int s=dfs(point);// u节点的单颗子树节点数
  14.             res=max(res,s);//记录最大连通子图
  15.             sum+=s;//以point为根的树 的节点数
  16.         }
  17.     }
  18.     res=max(res,n-sum);
  19.  
  20.     return sum;
  21. }

本题的本质是树的dfs，每次dfs可以确定以u为重心的最大连通块的节点数，并且更新一下ans。

也就是说，dfs并不直接返回答案，而是在每次更新中迭代一次答案。

这样的套路会经常用到，在 树的dfs 题目中

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. using namespace std;
  5.  
  6. const int N=1e5+10;
  7. const int M=2*N;
  8.  
  9. int h[N],e[M],ne[M],idx,n;
  10. int ans=N;
  11. bool st[N];
  12.  
  13. void add(int a,int x)//只是用于存储节点和指向的工具，idx与节点数值point无关
  14. {
  15.     e[idx]=x,ne[idx]=h[a],h[a]=idx++;
  16. }
  17.  
  18. int dfs(int u)
  19. {
  20.     int res=0;//存储删除某节点后 最大连通子图值
  21.     st[u]=true;//表示u节点已经访问过
  22.     int sum=1;//以u为根的树的节点数（包括u）
  23.     
  24.     //访问u的每个子节点
  25.     for(int i=h[u];i!=-1;i=ne[i])
  26.     {
  27.         int point=e[i];
  28.         if(!st[point])//若该节点没访问过
  29.         {
  30.             int s=dfs(point);// u节点的单颗子树节点数
  31.             res=max(res,s);//记录最大连通子图
  32.             sum+=s;//以point为根的树 的节点数
  33.         }
  34.     }
  35.     res=max(res,n-sum);
  36.     ans=min(ans,res);//遍历过的假设重心中，最小的最大联通子图的 节点数
  37.     return sum;
  38. }
  39.  
  40.  
  41. int main()
  42. {
  43.     memset(h,-1,sizeof h);
  44.     cin>>n;
  45.     for(int i=0;i<n-1;i++)
  46.     {
  47.         int a,b;
  48.         cin>>a>>b;
  49.         add(a,b),add(b,a);
  50.     }
  51.     dfs(1);
  52.     cout<<ans<<endl;
  53.     return 0;
  54. }

树与图的广度优先遍历

图中点的层次

  1. #include<iostream>
  2. #include<cstring>
  3. using namespace std;
  4.  
  5. const int N=1e5+10;
  6.  
  7. int h[N],e[N],ne[N],idx;
  8. int d[N];
  9. int q[N];
  10. int n,m;
  11.  
  12. void add(int a,int b)//用于存储有向图
  13. {
  14.     e[idx]=b,ne[idx]=h[a],h[a]=idx++;
  15. }
  16.  
  17. int bfs()
  18. {
  19.     int hh=0,tt=0;
  20.     q[0]=1;//存入1号节点
  21.     memset(d,-1,sizeof d);//用于判断是否遍历过
  22.     d[1]=0;//每个节点距离1号点的距离
  23.     
  24.     while(hh<=tt)
  25.     {
  26.         int t=q[hh++];
  27.         
  28.         for(int i=h[t];i!=-1;i=ne[i])//遍历t节点的每一个邻边
  29.         {
  30.             int j=e[i];
  31.             if(d[j]==-1)//没有遍历过
  32.             {
  33.                 d[j]=d[t]+1;//加上到相邻节点的距离，每条边长为1
  34.                 q[++tt]=j;
  35.             }
  36.         }
  37.     }
  38.     return d[n];
  39. }
  40.  
  41. int main()
  42. {
  43.     cin>>n>>m;
  44.     memset(h,-1,sizeof h);
  45.     for(int i=0;i<m;i++)
  46.     {
  47.         int a,b;
  48.         cin>>a>>b;
  49.         add(a,b);
  50.     }
  51.     cout<<bfs()<<endl;
  52.     return 0;
  53. }


拓扑排序

有向图的拓扑序列

一个有向图，如果图中有入度为 0 的点，就把这个点删掉，同时也删掉这个点所连的边。

一直进行上面出处理，如果所有点都能被删掉，则这个图可以进行拓扑排序。

思路：

  1. 用邻接表构造图，顺便记录各个节点的入度；
  2. 将如度为0的点入队
  3. 将队列里的点依次出队列，然后找出所有出队列这个点发出的边，删除边（邻接点入度减1），若该点入度减为0则入队，继续操作
  4. 若所有点入队则是拓扑排序
  1. #include<iostream>
  2. #include<cstring>
  3. using namespace std;
  4.  
  5. const int N=100010;
  6. int h[N],e[N],ne[N],idx;
  7. int n,m;
  8. int q[N],d[N];//q表示队列，d表示入度
  9.  
  10. void add(int a,int b)
  11. {
  12.     e[idx]=b,ne[idx]=h[a],h[a]=idx++;
  13. }
  14.  
  15. bool topsort()
  16. {
  17.     int hh=0,tt=-1;
  18.     for(int i=1;i<=n;i++)
  19.     {
  20.         if(!d[i]) q[++tt]=i;//首先将入度为0的点入队
  21.     }
  22.     while(hh<=tt)
  23.     {
  24.         int t=q[hh++];//将t点出队
  25.         for(int i=h[t];i!=-1;i=ne[i])
  26.         {
  27.             int j=e[i];
  28.             d[j]--;//t点出队，t指向j的边删除，入度减1
  29.             if(d[j]==0) q[++tt]=j; //再将入度为0的点出队
  30.         }
  31.     }
  32.     return tt==n-1;//如果n个点都入队，则是拓扑图，返回true
  33. }
  34.  
  35. int main()
  36. {
  37.     cin>>n>>m;
  38.     memset(h,-1,sizeof h);
  39.     for(int i=0;i<m;i++)
  40.     {
  41.         int a,b;
  42.         cin>>a>>b;
  43.         add(a,b);
  44.         d[b]++;//a指向b，b的入度加1
  45.     }
  46.     if(topsort())
  47.     {
  48.         for(int i=0;i<n;i++)//入队顺序就是拓扑序
  49.             cout<<q[i]<<" ";
  50.     }
  51.     else puts("-1");
  52.     return 0;
  53. }

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览45136 人正在系统学习中
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪