拓扑排序入门

最新推荐文章于 2023-05-19 21:45:00 发布
最新推荐文章于 2023-05-19 21:45:00 发布
阅读量151 收藏
点赞数
分类专栏： 数据结构

在一个有向图中，对所有的节点进行排序，要求没有一个节点指向它前面的节点。

先统计所有节点的入度，对于入度为0的节点就可以分离出来，然后把这个节点指向的节点的入度减一。

一直做改操作，直到所有的节点都被分离出来。

如果最后不存在入度为0的节点，那就说明有环，不存在拓扑排序，也就是很多题目的无解的情况。

下面是算法的演示过程。


下面是我以前的写法，比较好理解，但是效率低


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
       
       //b[]为每个点的入度
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       for(i=
       
       1;i<=n;i++){
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
       
       
       for(j=
       
       1;j<=n;j++){
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       if(b[j]==
       
       0){   
       
       //找到一个入度为0的点
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               ans=j;
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               vis[cnt++]=j;
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               b[j]--;
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       break;
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
              }
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for(j=
       
       1;j<=n;j++)
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if(a[ans][j]) b[j]--; 
       
       //与入度为0的点相连的点的入度减一
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       printf(
       
       "%d",vis[
       
       0]);
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for(i=
       
       1;i<cnt;i++) 
       
       printf(
       
       " %d",vis[i]);
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       printf(
       
       "\n");

下面是我现在一直以来的写法，貌似挺快的。


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       queue<
       
       int>q;
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for(
       
       int i=
       
       0;i<n;i++)  
       
       //n  节点的总数
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if(in[i]==
       
       0) q.push(i);  
       
       //将入度为0的点入队列
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       vector<
       
       int>ans;   
       
       //ans 为拓扑序列
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while(!q.empty())
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       int p=q.top(); q.pop(); 
       
       // 选一个入度为0的点，出队列
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               ans.push_back(p);
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       for(
       
       int i=
       
       0;i<edge[p].size();i++)
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               {
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       int y=edge[p][i];
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   in[y]--;
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if(in[y]==
       
       0)
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       q.push(y);  
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if(ans.size()==n)   
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       for(
       
       int i=
       
       0;i<ans.size();i++)
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       printf( 
       
       "%d ",ans[i] );
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       printf(
       
       "\n");
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       else 
       
       printf(
       
       "No Answer!\n");   
       
       //  ans 中的长度与n不相等，就说明无拓扑序列

有些拓扑排序要求字典序最小什么的，那就把队列换成优先队列就好了。

例如：ZCMU-2153点击打开链接

代码：


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include<bits/stdc++.h>
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       using 
       
       namespace 
       
       std;
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       typedef 
       
       long 
       
       long LL;
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       const 
       
       int inf=
       
       1e9;
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       const 
       
       int maxn=
       
       1e6+
       
       5;
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       vector<
       
       int>edge[
       
       50];
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int in[
       
       50];
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int main()
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       char s[
       
       5];
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       set<
       
       int>k;
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while(
       
       cin>>s)
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               k.insert(s[
       
       2]-
       
       'A');
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               k.insert(s[
       
       0]-
       
       'A');
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if(s[
       
       1]==
       
       '>')
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               {
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   in[s[
       
       2]-
       
       'A']++;
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   edge[s[
       
       0]-
       
       'A'].push_back(s[
       
       2]-
       
       'A');
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       else
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               {
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   in[s[
       
       0]-
       
       'A']++;
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   edge[s[
       
       2]-
       
       'A'].push_back(s[
       
       0]-
       
       'A');
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           priority_queue<
       
       int,
       
       vector<
       
       int>,greater<
       
       int> >q;
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for(
       
       int i=
       
       0;i<
       
       30;i++)
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if(in[i]==
       
       0&&k.count(i)!=
       
       0)
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   q.push(i);
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       vector<
       
       int>ans;
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while(!q.empty())
      
      
    
     
     
  35. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  36. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       int p=q.top(); q.pop();
      
      
    
     
     
  37. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               ans.push_back(p);
      
      
    
     
     
  38. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       for(
       
       int i=
       
       0;i<edge[p].size();i++)
      
      
    
     
     
  39. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               {
      
      
    
     
     
  40. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       int y=edge[p][i];
      
      
    
     
     
  41. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   in[y]--;
      
      
    
     
     
  42. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if(in[y]==
       
       0&&k.count(y)!=
       
       0)
      
      
    
     
     
  43. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       q.push(y);
      
      
    
     
     
  44. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  45. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  46. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if(ans.size()==k.size())
      
      
    
     
     
  47. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  48. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       for(
       
       int i=
       
       0;i<ans.size();i++)
      
      
    
     
     
  49. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       printf(
       
       "%c",ans[i]+
       
       'A');
      
      
    
     
     
  50. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       printf(
       
       "\n");
      
      
    
     
     
  51. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  52. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       else 
       
       printf(
       
       "No Answer!\n");
      
      
    
     
     
  53. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       return 
       
       0;
      
      
    
     
     
  54. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }

还有一种比较坑的排序 要求编号小的尽量排在前面，这里与字典序最小是不一样的，看一下例题。

HDU-4857 点击打开链接


逃生

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 6725    Accepted Submission(s): 1965

Problem Description
糟糕的事情发生啦，现在大家都忙着逃命。但是逃命的通道很窄，大家只能排成一行。

现在有n个人，从1标号到n。同时有一些奇怪的约束条件，每个都形如：a必须在b之前。
同时，社会是不平等的，这些人有的穷有的富。1号最富，2号第二富，以此类推。有钱人就贿赂负责人，所以他们有一些好处。

负责人现在可以安排大家排队的顺序，由于收了好处，所以他要让1号尽量靠前，如果此时还有多种情况，就再让2号尽量靠前，如果还有多种情况，就让3号尽量靠前，以此类推。

那么你就要安排大家的顺序。我们保证一定有解。
 

Input
第一行一个整数T(1 <= T <= 5),表示测试数据的个数。
然后对于每个测试数据，第一行有两个整数n(1 <= n <= 30000)和m(1 <= m <= 100000)，分别表示人数和约束的个数。

然后m行，每行两个整数a和b，表示有一个约束a号必须在b号之前。a和b必然不同。
 

Output
对每个测试数据，输出一行排队的顺序，用空格隔开。
 

Sample Input 
 
   

     15 103 51 42 51 23 41 42 31 53 51 2 
   
 
  
 
  

      
  
 
  
 
  

    Sample Output 
  
 
  
 
   
 
   

     1 2 3 4 5 
   
 
   
 
  
 
  
 
  
举个例子如图：
 
  

 
  
如果你用优先队列拓扑排序得到的是：3 5 6 4 1 7 8 9 2 0
 
  
但是正确答案为 6 4 1 3 9 2 5 7 8 0 这样使得小的（1）尽量在前面。
 
  
这里我们可以得到 前面的小的不一定排在前面，但是有一点后面大的一定排在后面。
 
  
我们看 6和3不一定3排在前面，因为6后面连了一个更小的数字1能使得6更往前排。
 
  
在看 2和 8，8一定排在后面，因为8后面已经没有东西能使它更往前排（除了0）。
 
  
所以最后我们的做法就是 建立一个反图，跑一边字典序最大的拓扑排序，最后再把这个排序倒过来就是答案了。
 
  

   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include<iostream>
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include<cstdio>
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include<cstring>
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include<algorithm>
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include<vector>
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include<queue>
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       using 
       
       namespace 
       
       std;
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       typedef 
       
       long 
       
       long ll;
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       vector<
       
       int>edge[
       
       30010],ans;
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       priority_queue<
       
       int>q;
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int in[
       
       30010];
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int T,n,m;
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       void init()
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for(
       
       int i=
       
       1;i<=n;i++)
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               edge[i].clear();
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               in[i]=
       
       0;
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while(!q.empty()) q.pop();
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           ans.clear();
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       void solve()
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       int i,j;
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for(i=
       
       1;i<=n;i++)
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if(in[i]==
       
       0) q.push(i);
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while(!q.empty())
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       int p=q.top(); q.pop();
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               ans.push_back(p);
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       for( i=
       
       0; i<edge[p].size(); i++ )
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               {
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       int v=edge[p][i];
      
      
    
     
     
  35. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   in[v]--;
      
      
    
     
     
  36. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if(in[v]==
       
       0) q.push(v);
      
      
    
     
     
  37. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  38. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  39. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for(i=ans.size()
       
       -1;i>
       
       0;i--)
      
      
    
     
     
  40. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       printf(
       
       "%d ",ans[i]);
      
      
    
     
     
  41. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       printf(
       
       "%d\n",ans[
       
       0]);
      
      
    
     
     
  42. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  43. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int main()
      
      
    
     
     
  44. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  45. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       int a,b;
      
      
    
     
     
  46. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       scanf(
       
       "%d",&T);
      
      
    
     
     
  47. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while(T--)
      
      
    
     
     
  48. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           {
      
      
    
     
     
  49. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       scanf(
       
       "%d%d",&n,&m);
      
      
    
     
     
  50. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               init();
      
      
    
     
     
  51. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       while(m--)
      
      
    
     
     
  52. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               {
      
      
    
     
     
  53. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       scanf(
       
       "%d%d",&a,&b);
      
      
    
     
     
  54. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   edge[b].push_back(a);
      
      
    
     
     
  55. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   in[a]++;
      
      
    
     
     
  56. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  57. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               solve();
      
      
    
     
     
  58. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  59. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       return 
       
       0;
      
      
    
     
     
  60. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     

   
   
 
  
 
  

 
  
 
  
 
  
 
 
 


                

                
                
        

        

    




    

      

        

            

              
                
                  爱跑步的george
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
数据结构 拓扑排序

				
			

			

				

					07-02
				

			

		

		

			
				
以邻接矩阵给出一张以整数为结点的有向图，其中0表示不是相邻结点，1表示两个结点相连且由当前结点为初始点。利用拓扑排序判断图中是否有环，若有输出YES没有输出NO。
输入： 结点数邻接矩阵
输出： YES/NO

			
		

	



                

              
                



	

		

			

				
					
拓扑排序

					
热门推荐

				
			

			

				

					chenweiye1的博客
				

				

					02-02
					
					6万+
					
				

			

		

		

			
				
拓扑排序
一、拓扑排序的定义：
先引用一段百度百科上对于拓扑排序的定义：

对一个有向无环图 ( Directed Acyclic Graph 简称 DAG ) G 进行拓扑排序，是将 G
中所有顶点排成一个线性序列，使得图中任意一对顶点 u 和 v ，若边 < u , v > ∈ E ( G )，则 u 在线性序列中出现在 v
之前。通常，这样的线性序列称为满足拓扑次序 ( Topological Order )
的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这

			
		

	



                


  
              

                


	

		

			

				
					
拓扑排序(topological sorting)介绍及Python实现

				
			

			

				

					chenxy_bwave的专栏
				

				

					06-01
					
					2万+
					
				

			

		

		

			
				
拓扑排序(topological sorting)介绍及Python实现，介绍了拓扑排序基本算法原理，并给出基于深度优先搜索和基于广度优先搜索的Python实现。

			
		

	





	

		

			

				
					
图结构专栏——拓扑排序

				
			

			

				

					lizefeng1998的博客
				

				

					04-12
					
					6875
					
				

			

		

		

			
				
三种方法实现拓扑排序
一、什么是拓扑排序
在图论中，拓扑排序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列。且该序列必须满足下面两个条件：

每个顶点出现且只出现一次。 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。
有向无环图（DAG）才有拓扑排序，非DAG图没有拓扑排序一说。

例如，下面这个图：

它是一个 DAG 图，那么如何写出它的拓扑排序呢？这里说一种比较常用的方法

			
		

	



		

			
		



	

		

			

				
					
拓扑排序详解（包含算法原理图解、算法实现过程详解、算法例题变式全面讲解等）

				
			

			

				

					aliyonghang的博客
				

				

					05-06
					
					6870
					
				

			

		

		

			
				
非常详细的讲解。点开有惊喜！

			
		

	





	

		

			

				
					
拓扑排序_As.pptx

				
			

			

				

					02-03
				

			

		

		

			
				
拓扑排序课件 ，解答较为详细，对于拓扑排序、图论、BFS/DFS有较为详细的理解，适合入门一段时间的ACMer和想自学编程，研究学习算法者。

			
		

	





	

		

			

				
					
grunt-concat-in-order:Gruntjs插件，用于保留具有依存关系树拓扑排序的文件

				
			

			

				

					04-28
				

			

		

		

			
				
入门这个插件需要~0.4.1 如果您以前从未使用过 ，请务必查看《指南》，因为它说明了如何创建以及安装和使用Grunt插件。 熟悉该过程后，可以使用以下命令安装此插件： npm install grunt-concat-in-order --save-dev ...

			
		

	





	

		

			

				
					
breizhcamp_2015:Apache Storm 入门

				
			

			

				

					05-31
				

			

		

		

			
				
羊柜台Sheep-counter 是一种 Storm 拓扑，用于按发送到 Redis pub/sub 的羊的颜色进行排序和计数。 要启动它： 运行bzh.cjuste.breizhcamp.sheepcounter.SheepCounterTopology类等待消息Ready to receive messages !...

			
		

	





	

		

			

				
					
graph_tutorial_python.zip

				
			

			

				

					12-18
				

			

		

		

			
				
超简洁的python版本 graph入门教程代码，step-by-step, 代码直接运行，小白专属  1.图表示 2.图可视化 3. 图BFS 4.图DFS 5.图拓扑排序 6.图全部路径 7.带节点属性的图 8.图配置文件 9.子图切分

			
		

	





	

		

			

				
					
(MySQL入门到精通操作手册

				
			

			

				

					03-20
				

			

		

		

			
				
所有的可实例化几何类是这样定义的，从而使得几何类的实例从拓扑意义上讲是闭合的（也就是说，所有定义的几何类包含其边界）。  基本Geometry类具有关于Point、Curve、Surface和GeometryCollection的子类：  · ...

			
		

	





	

		

			

				
					
拓扑排序详解

				
			

			

				

					qq_56012214的博客
				

				

					05-25
					
					1万+
					
				

			

		

		

			
				
古人学问无遗力 少壮功夫老始成

			
		

	





	

		

			

				
					
java 拓扑运算_拓扑排序(三)之 Java详解

				
			

			

				

					weixin_42551967的博客
				

				

					02-13
					
					1108
					
				

			

		

		

			
				
拓扑排序介绍拓扑排序(Topological Order)是指，将一个有向无环图(Directed Acyclic Graph简称DAG)进行排序进而得到一个有序的线性序列。这样说，可能理解起来比较抽象。下面通过简单的例子进行说明！例如，一个项目包括A、B、C、D四个子部分来完成，并且A依赖于B和D，C依赖于D。现在要制定一个计划，写出A、B、C、D的执行顺序。这时，就可以利用到拓扑排序，它就是用...

			
		

	





	

		

			

				
					
基本图算法(二) 拓扑排序

				
			

			

				

					m0_73633144的博客
				

				

					05-19
					
					3597
					
				

			

		

		

			
				
​对于一个有向无环图GVE来说，其拓扑排序是G中所有节点的一种线性次序，该次序满足如下条件：如果图G包含边uv，则节点u在拓扑排序中处于节点v的前面。显然，如果图G包含环路，则不可能排出一个线性次序。我们可以将图的拓扑排序看做是将图中的所有节点在同一水平线上排开，图的所有有向边都从左边指向右边，因此，图的拓扑排序与冒泡排序、堆排序等通常意义上的“排序”是不同的。接下来代码的实现中，采用邻接表存储图。

			
		

	





	

		

			

				
					
拓扑排序介绍

				
			

			

				

					qq_68095060的博客
				

				

					12-06
					
					1669
					
				

			

		

		

			
				
关于拓扑排序的简单介绍

			
		

	





	

		

			

				
					
拓扑排序(简单版)

				
			

			

				

					Njhemu的博客
				

				

					09-12
					
					1034
					
				

			

		

		

			
				
拓扑排序是图论中的知识。就是将一个有向无环图中的节点进行阶级划分，具体来说就是求出一个有序点列使其严格满足其中的每一个节点都不能指向它的前一个结点。具体做法很简单：每次遍历每个点，将入度为0的点记录，而后删掉该点及其所在边。反复直至点删完，最后将记录的点打印下来。显然1是第一阶级，2,3,4第二阶级，5,6第三阶级，但往往同一阶级的节点只要求输出一种，做起来会方便一些。主要用途就是判断回路之类的。注意题目要求输出，比如要求是字典序的话就用优先队列之类的。

			
		

	





	

		

			

				
					
拓 扑 排 序

				
			

			

				

					bolite的博客
				

				

					08-09
					
					1071
					
				

			

		

		

			
				
一.什么是拓扑排序
拓扑排序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列。 且该序列必须满足下面两个条件： 每个顶点出现且只出现一次。 若存在一条从顶点A 到顶点B 的路径，那么在序列中顶点A 出现在顶点B 的前面。
二.图片描述
该算法解决的问题类似于办事的流程一样
在做一件事情之前必须完成之前的一件或多件相关的事情

三.代码的实现图示

1.先在所有任务中找到没有需要其他任务做铺垫的任务，图片中体现为点1。将1

			
		

	





	

		

			

				
					
拓扑排序（算法笔记）

				
			

			

				

					Arabot_的博客
				

				

					05-03
					
					643
					
				

			

		

		

			
				
拓扑排序是将有向无环图G的所有顶点排成一个线性序列，使得对图G中的任意两个顶点u、v，如果存在边u->v，那么在序列中u一定在v前面。这个序列又被称为拓扑序列。

			
		

	





	

		

			

				
					
拓扑排序 逆拓扑排序

					
最新发布

				
			

			

				

					04-16
				

			

		

		

			
				
拓扑排序是种对有向无环图（DAG进行排序的算法。它将图中节点按照种特定的顺序进行排序，使得对于任意一条有向边 (u, v)，节点 u 在排序结果中都出现节点 v 的前面。  拓扑排序的实现方式如下： 1. 首先，找到图入度...

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值