拓扑排序

最新推荐文章于 2022-12-03 00:45:00 发布
最新推荐文章于 2022-12-03 00:45:00 发布
阅读量1k 收藏
点赞数 1
分类专栏： ☆☆☆数据结构 ◇◇◇图论 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaoyueziji123/article/details/38389411
版权
抬头是山，路在脚下！
拓扑排序


拓 扑 排 序


    一个较大的工程往往被划分成许多子工程，我们把这些子工程称作活动(activity)。在整个工程中，有些子工程(活动)必须在其它有关子工程完成之后才能开始，也就是说，一个子工程的开始是以它的所有前序子工程的结束为先决条件的，但有些子工程没有先决条件，可以安排在任何时间开始。为了形象地反映出整个工程中各个子工程(活动)之间的先后关系，可用一个有向图来表示，图中的顶点代表活动(子工程)，图中的有向边代表活动的先后关系，即有向边的起点的活动是终点活动的前序活动，只有当起点活动完成之后，其终点活动才能进行。通常，我们把这种顶点表示活动、边表示活动间先后关系的有向图称做顶点活动网(Activity On Vertex network)，简称AOV网。


       


         课程代号      课程名称        先修课程


           C1          高等数学          无


           C2          程序设计基础      无


           C3          离散数学          C1,C2


           C4          数据结构          C3,C5


           C5          算法语言          C2


           C6          编译技术          C4,C5


           C7          操作系统          C4,C9


           C8          普通物理          C1


           C9          计算机原理        C8


图3-4 课程表


 


例如，假定一个计算机专业的学生必须完成图3-4所列出的全部课程。在这里，课程代表活动，学习一门课程就表示进行一项活动，学习每门课程的先决条件是学完它的全部先修课程。如学习《数据结构》课程就必须安排在学完它的两门先修课程《离散数学》和《算法语言》之后。学习《高等数学》课程则可以随时安排，因为它是基础课程，没有先修课。若用AOV网来表示这种课程安排的先后关系，则如图3-5所示。图中的每个顶点代表一门课程，每条有向边代表起点对应的课程是终点对应课程的先修课。图中的每个顶点代表一从图中可以清楚地看出各课程之间的先修和后续的关系。如课程C5的先修课为C2，后续课程为C4和C6。


 


 
   


             图3-5 AOV网             图3-6 三个顶点的回路


 


    一个AOV网应该是一个有向无环图，即不应该带有回路，因为若带有回路，则回路上的所有活动都无法进行。如图3-6是一个具有三个顶点的回路，由<A,B>边可得B活动必须在A活动之后，由<B,C>边可得C活动必须在B活动之后，所以推出C活动必然在A活动之后，但由<C,A>边可得C活动必须在A活动之前，从而出现矛盾，使每一项活动都无法进行。这种情况若在程序中出现，则称为死锁或死循环，是应该必须避免的。


    在AOV网中，若不存在回路，则所有活动可排列成一个线性序列，使得每个活动的所有前驱活动都排在该活动的前面，我们把此序列叫做拓扑序列(Topological order)，由AOV网构造拓扑序列的过程叫做拓扑排序(Topological sort)。AOV网的拓扑序列不是唯一的，满足上述定义的任一线性序列都称作它的拓扑序列。例如，下面的三个序列都是图3-5的拓扑序列，当然还可以写出许多。


    (1) C1,C8,C9,C2,C3,C5,C4,C7,C6


    (2) C2,C1,C3,C5,C4,C6,C8,C9,C7


    (3) C1,C2,C3,C8,C9,C5,C4,C6,C7


    由AOV网构造出拓扑序列的实际意义是：如果按照拓扑序列中的顶点次序，在开始每一项活动时，能够保证它的所有前驱活动都已完成，从而使整个工程顺序进行，不会出现冲突的情况。


    由AOV网构造拓扑序列的拓扑排序算法主要是循环执行以下两步，直到不存在入度为0的顶点为止。


    (1) 选择一个入度为0的顶点并输出之；


    (2) 从网中删除此顶点及所有出边。


    循环结束后，若输出的顶点数小于网中的顶点数，则输出“有回路”信息，否则输出的顶点序列就是一种拓扑序列。


    下面以图3-7(a)为例，来说明拓扑排序算法的执行过程。


 


 
   
 


图3-7 拓扑排序的图形说明


    (1) 在(a)图中v0和v1的入度都为0，不妨选择v0并输出之，接着删去顶点v0及出边<0,2>，得到的结果如(b)图所示。


    (2) 在(b)图中只有一个入度为0的顶点v1，输出v1，接着删去v1和它的三条出边<1,2>,<1,3>和<1,4>，得到的结果如(c)图所示。


    (3) 在(c)图中v2和v4的入度都为0，不妨选择v2并输出之，接着删去v2及两条出边<2,3>和<2,5>，得到的结果如(d)图所示。


    (4) 在(d)图上依次输出顶点v3,v4和v5，并在每个顶点输出后删除该顶点及出边，操作都很简单，不再赘述。


为了利用C++语言在计算机上实现拓扑排序算法，AOV网采用邻接表表示较方便。如对于图3-8(a)，对应的邻接表如图3-8所示。


 


 
   


图3-8 图3-7(a)的链接表


 


在拓扑排序算法中，需要设置一个包含n个元素的一维整型数组，假定用d表示，用它来保存AOV网中每个顶点的入度值。如对于图3-8(a)，得到数组d的初始值为


 


                          0    1    2    3    4    5


 0


 0


 2


 2


 1


 3


 


    在进行拓扑排序中，为了把所有入度为0的顶点都保存起来，而且又便于插入、删除以及节省存储，最好的方法是把它们链接成一个栈。另外，当一个顶点vi的入度为0时，数组d中下标为i的元素d[i]的值为0，正好可利用该元素作为链栈中的一个结点使用，保存下一个入度为0的顶点的序号，这样就可以把所有入度为0的顶点通过数组d中的对应元素静态链接成一个栈。在这个链栈中，栈顶指针top指向第一个入度为0的顶点所对应的数组d中的元素，该元素的值则指向第二个入度为0的顶点所对应的数组d中的元素，依此类推，最后一个入度为0顶点所对应的数组d中的元素保存着-1，表示为栈底。


    例如，根据图3-8所示的邻接表，建立的入度为0的初始栈的过程为：


    (1) 开始置链栈为空，即给链栈指针top赋初值为-1：


            top=-1;


    (2) 将入度为0的元素d[0]进栈，即：


            d[0]=top; top=0;    


    此时top指向d[0]元素，表示顶点v0的入度为0，而d[0]的值为-1，表明为栈底。


    (3) 将入度为0的元素d[1]进栈，即:


            d[1]=top; top=1;


    此时top指向d[1]元素，表示顶点v1的入度为0，而d[1]的值为0，表明下一个入度为0的元素为d[0]，即对应下一个入度为0的顶点为v0，d[0]的值为-1，所以此栈当前有两个元素d[1]和d[0]。


    (4) 因d[2]至d[5]的值均不为0，即对应的v2到v5的入度均不为0，所以它们均不进栈，至此，初始栈建立完毕，得到的数组d为：


                          0    1    2    3    4    5


-1


 0


 2


 2


 1


 3


                                top


 


    将入度为0的顶点利用上述链栈链接起来后，拓扑算法中循环执行的第(1)步“选择一个入度为0的顶点并输出之”，可通过输出栈顶指针top所代表的顶点序号来实现；第(2)步“从AOV网中删除刚输出的顶点（假定为vj，其中j等于top的值）及所有出边”，可通过首先作退栈处理，使top指向下一个入度为0的元素，然后遍历vj的邻接点表，分别把所有邻接点的入度减1，若减1后的入度为0则令该元素进栈来实现。此外，该循环的终止条件“直到不存在入度为0的顶点为止”，可通过判断栈空来实现。


    对于图3-7(a)，当删除由top值所代表的顶点v1及所有出边后，数组d变为：


                         0    1    2    3    4    5


-1


 


 1


 1


 0


 3


                                               top


    当依次删除top所表示的每个顶点及所有出边后，数组d的变化分别如图3-9(a)至(d)所示：


 


                          0    1    2    3    4    5


-1


 


 1


 1


 


 2


                          top


                             (a) 删除顶点v4及所有出边


 


                          0    1    2    3    4    5


 
 


-1


 1


 


 2


                                     top


                             (b) 删除顶点v0及所有出边


 


                          0    1    2    3    4    5


 


 


 


-1


 


 1


                                          top


                             (c) 删除顶点v2及所有出边


 


                          0    1    2    3    4    5


 


 


 


 


 


-1


                                                     top


                             (d) 删除顶点v3及所有出边


 


                              图3-9 数组d变化示意图


 


    当删除顶点v5及所有出边后，top的值为1，表示栈空，至此算法执行结束，得到的拓扑序列为：1,4,0,2,3,5。


    根据以上分析，给出拓扑排序算法的具体描述为：


        void Toposort(adjlist GL, int n)


               //对用邻接表GL表示的有向图进行拓扑排序


        {


            int i,j,k,top,m=0; //m用来统计拓扑序列中的顶点数


            edgenode *p;


          //定义存储图中每个顶点入度的一维整型数组d


            int* d=new int[n];


          //初始化数组d中的每个元素值为0


            for(i=0; i<n; i++)


                d[i]=0;


          //利用数组d中的对应元素统计出每个顶点的入度


            for(i=0; i<n; i++) {


                p=GL[i];


                while(p!=NULL) {


                    j=p->adjvex;


                    d[j]++;


                    p=p->next;


                }


            }


          //初始化用于链接入度为0的元素的栈的栈顶指针top为-1


            top=-1;


          //建立初始化栈


            for(i=0; i<n; i++)


                if(d[i]==0) {


                    d[i]=top;


                    top=i;


                }


          //每循环一次删除一个顶点及所有出边


            while(top!=-1)


            {


                j=top;  //j的值为一个入度为0的顶点序号


                top=d[top];  //删除栈顶元素


                cout<<j<<' ';  //输出一个顶点


                m++;  //输出的顶点个数加1


                p=GL[j];  //p指向vj邻接点表的第一个结点


                while(p!=NULL)


                {


                    k=p->adjvex;  //vk是vj的一个邻接点


                    d[k]--;  //vk的入度减1


                    if(d[k]==0) {  //把入度为0的元素进栈


                        d[k]=top;


                        top=k;


                    }


                    p=p->next;  //p指向vj邻接点表的下一个结点


                }


            }


            cout<<endl;


            if(m<n)


  //当输出的顶点数小于图中的顶点数时，输出有回路信息


                cout<<"The network has a cycle!"<<endl;


        }


 


    拓扑排序实际上是对邻接表表示的图G进行遍历的过程，每次访问一个入度为0的顶点。若图G中没有回路，则需要扫描邻接表中的所有边结点，再加上在算法开始时，为建立入度数组d需要访问表头向量中的每个域和其单链表中的每个结点，所以此算法的时间复杂性为O(n+e)。
/*
拓扑排序的第一种模板
*/
/* 
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int map[505][505],pre[505];
int c[505];
int n,m;
void topsort()
{
    int i,j,k,p=1;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++)
        {
            if(pre[j]==0)
            {
                pre[j]--;
                c[p++]=j;
                for(k=1;k<=n;k++)
                {
                    if(map[k][j]==1)
                    {
                        pre[k]--;
                    }
                } 
                break;
            }
        }
    }
}
int main()
{
    int a,b,i;
    while(~scanf("%d%d",&n,&m))
    {
        memset(pre,0,sizeof(pre));
        memset(map,0,sizeof(map));
        for(i=0;i<m;i++)
        {
            scanf("%d %d",&a,&b);
            if(map[a][b]==0)
            {
                map[a][b]=1;
                pre[b]++;
            }
        }
        topsort();
        for(i=1;i<=n;i++)
        {
            if(i!=n)
                printf("%d ",c[i]);
            else
                printf("%d\n",c[i]);
        } 
    }
    return 0;
}
*/
#include<iostream>
using namespace std;
#defien arraysize 501
int map[arraysize][arraysize];
int n,m;
int indegree[arraysize];
int main()
{
    int i,j,k;
    int p1,p2;
    while(cin>>n>>m)
    {
        memset(map,0,sizeof(map));
        memset(indegree,0,sizeof(indegree));
        for(i=0;i<m;++i)
        {
            cin>>p1>>p2;
            if(!map[p1][p2])//判重操作
            {
                map[p1][p2]=1;
                indegree[p2]++;
            }
        }
        for(i=1;i<n+1;++i)
        {
            for(j=1;j<n+1;++j)
            {
                if(indegree[j]==0)
                {
                    indegree[j]--;
                    if(i!=n)
                        cout<<j<<" ";
                    else
                        cout<<j<<endl;
                    for(k=1;k<n+1;++k)
                    {
                        if(map[j][k]==1)
                        {
                            indegree[k]--;
                        }
                    }
                    break;
                }
            }
        }
    }
    return 0;
}


用优先队列来进行拓扑排序

#include<stdio.h>
#include<string.h>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
vector<int>my[505];
struct node{
int id;
int count;
bool operator<(const node x)const
{
return x.id<id;
}
}g[505];
int c[505];
int main()
{
int n,m,st,en,i;
while(scanf("%d%d",&n,&m)!=EOF)
{
priority_queue<node>q;
for(i=0;i<505;i++)
{
my[i].clear();
g[i].count=0;
g[i].id=i;
}
while(m--)
{
scanf("%d%d",&st,&en);
g[en].count++;
my[st].push_back(en);
}
for(i=1;i<=n;i++)
if(g[i].count==0)
q.push(g[i]);
int k=0;
while(!q.empty())
{
node p=q.top();
q.pop();
if(p.id<=n)
c[k++]=p.id;
for(i=0;i<my[p.id].size();i++)
{
int now=my[p.id][i];
g[now].count--;
if(g[now].count==0)
{
q.push(g[now]);
}
}
}
for(i=0;i<k-1;i++)
printf("%d ",c[i]);
printf("%d\n",c[k-1]);
}
return 0;
}



#include <iostream>
using namespace std;
int ind[517];     


// indegree入度个数int adj[250017];  
//adjacency list邻接表位置值int adj_next[250017];
//邻接表下一指针int tail[517];   
//邻接表尾int main()
{   
	int n,m,i,j,a,b;  
	while(scanf("%d%d",&n,&m)!=EOF)  
	{       
		for(i = 0; i <= n; i++) 
		{         
			tail[i] = -1;   
			adj[i] = -1;   
			adj_next[i] = -1;  
			ind[i] = 0;       
		}      
		for(i = 0; i < m; ++i)   
		{          
			scanf("%d%d",&a,&b);  
			int x = tail[a],flag = 0;   
			while(x != -1)  //判断是否重边    
			{          
				if(adj[x] == b)	
				{            
					flag = 1;       
					break;        
				}            
				x = adj_next[x];   
			}        
			if(!flag)//关联a的邻接表     
			{              
				adj[i] = b;     
				adj_next[i] = tail[a];      
				tail[a] = i;        
				ind[b] ++;        
			}      
		}       
		for(i = 1;i <= n; i++)//找n次  
		{         
			for(j = 1;j <= n;j++)//遍历   
			{         
				if(ind[j] == 0)//当入度为0时，说明靠前	
				{		
					ind[j] = -1;//在下次寻找入度为0时跳过  
					if(i == 1)  			
						printf("%d",j);      
					else       		
						printf(" %d",j);      
					for(int k = tail[j]; k != -1; k = adj_next[k])//邻接位置入度减一      
					{                   
						ind[adj[k]]--;         
					}            
					break;      
				}     
			}     
		}      
		printf("\n");  
	} 
	return 0;
}



/*
用邻接表写
*/
/* 
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<cstdio>
#include<queue>
#include<bitset>
using namespace std;
#define maxn 517
struct node
{    int num;  
node *next;
};
node map[maxn];
int d[maxn], n;
void Insert(int a, int b);
void Free();
void Topsort();
int main(){   
int m; 
while(cin >> n >> m) 
{        int i, a, b;    
memset(d, 0, sizeof(d));    
for(i=0; i<m; i++)    
{        
cin >> a >> b;  
Insert(a, b);    
d[b]++;     
}      
Topsort();   
Free();  
}   
return 0;
}
void Insert(int a, int b)
{   
node *newnode;   
newnode = (node *)malloc(sizeof(node)); 
newnode->num = b; 
newnode->next = map[a].next; 
map[a].next = newnode;
}
void Free()
{   
node *cur, *old; 
for(int i=1; i<=n; i++) 
{     
cur = map[i].next;  
while(cur)    
{        
old = cur;   
cur = cur->next;  
free(old);      
}       
map[i].next = NULL;  
}
}
void Topsort()
{  
priority_queue<int, vector<int>, greater<int> > que; 
int nx, i; 
int q[maxn]={0}, k=0;  
node *cur;   
for(i=1; i<=n; i++) 
{       
if(d[i] == 0)      
que.push(i);  
}  
while(que.size())   
{       
nx = que.top(), que.pop();  
q[k++] = nx;   
cur = map[nx].next;  
while(cur)     
{        
nx = cur->num;   
d[nx] -= 1;    
if(d[nx] == 0)    
que.push(nx);  
cur = cur->next;   
}  
}   
cout << q[0];   
for(i=1; i<k; i++)  
cout <<" "<< q[i]; 
cout <<endl;
}


*/






































































 
chaoyueziji123
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【转】非常详尽的【拓扑排序】
weixin_34326179的博客
07-03 154
2019独角兽企业重金招聘Python工程师标准>>> ...
数据结构与算法之拓扑排序
LInthunder的博客
01-19 1185
数据结构与算法系列 数据结构与算法之哈希表 数据结构与算法之跳跃表 数据结构与算法之字典树 数据结构与算法之2-3树 数据结构与算法之平衡二叉树 数据结构与算法之十大经典排序 数据结构与算法之二分查找三模板 数据结构与算法之动态规划 数据结构与算法之回溯算法 数据结构与算法之Morris算法 数据结构与算法之贪心算法 数据结构与算法之拓扑排序 目录数据结构与算法系列数据结构与算法之哈希表数据结构与算法之跳跃表数据结构与算法之字典树数据结构与算法之2-3树数据结构与算法之平衡二叉树数据结构与算法之十大经典排.
数据结构拓扑排序课程设计.docx
07-11
【拓扑排序】是图论中的一个重要概念，用于对有向无环图（DAG，Directed Acyclic Graph）进行线性排序。在这个过程中，我们尝试按照一定的顺序排列顶点，使得对于图中的每一条有向边 (u, v)，顶点 u 总是出现在顶点 ...
Golang实现拓扑排序(DFS算法版)
09-18
拓扑排序是一种对有向无环图(DAG, Directed Acyclic Graph)的顶点进行排序的方法，使得对于图中的每一条有向边 `(u, v)`，顶点 `u` 的排序位置总在顶点 `v` 之前。在本例中，拓扑排序被用来解决一个数字顺序排列的...
拓扑排序拓扑排序拓扑排序拓扑排序
最新发布
11-03
拓扑排序是图论中的一个重要概念，特别是在有向无环图（DAG，Directed Acyclic Graph）中。它是对有向无环图的顶点的一种线性排序，使得对于每一条有向边 (u, v)，都有 u 排在 v 的前面。换句话说，拓扑排序的结果是...
拓扑排序拓扑排序拓扑排序
11-03
拓扑排序是图论中的一个重要概念，特别是在有向无环图（DAG，Directed Acyclic Graph）中。它是对有向无环图的顶点的一种线性排序，使得对于每一条有向边 `(u, v)`，都有 `u` 在排序结果中出现在 `v` 之前。如果存在...
数据结构课程设计教学计划编制问题
06-22
1 需求分析 1 2 概要设计 1 3 详细设计 3 3.1 图的存储表示 3 3.2图的相关算法 4 3.3栈的存储 7 3.4栈的相关算法 8 3.5主函数 9 4 编码调试 10 5 设计体会 17 6 致谢 19 7 参考文献 19 8 附录（源程序清单） 19
Unity3D教程：手游开发常用排序算法 -上
小小姑娘
12-03 712
每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。，凡扫描到违反本原则的轻气泡，就使其向上“漂浮”，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准。
拓扑排序 模板
要继续努力的孤独的博客
06-20 158
    了解拓扑排序之前，先要清楚一个概念：DAG（Directed Acyclic Graph)——有向无环图，即不包含有向环的有向图。    在实际生活中常常会遇到这样的问题：在着手处理工作B之前先要处理完工作A和工作X，如何排列工作的顺序才能符合所有的条件？假若把每一种工作看作一个节点，工作顺序看作一条边，就可以得到一个有向无环图。将该图的节点进行排序，使得每一条有向边的起点都在终点之前，这...
图论模板（拓扑排序、最短路）
心升明月的博客
09-10 634
图论模板一、拓扑排序题意代码二、Dijkstra题意代码1（朴素版）代码2（堆优化版）2.读入数据总结 一、拓扑排序 题意 输出拓扑排序，如果不存在输出-1. 代码 void topsort() { queue<int> que; for(int i=1;i<=n;i++) if(!din[i]) que.push(i), ans[++num] = i; while(que.size()){ int t = que.fron
数据结构之图论算法（四）—— 拓扑算法
huxxyyy的博客
08-26 5876
一、有向无环图（DAG图）：无环的有向图 应用示例1： 描述含公共子式的表达式的工具——实现对相同子式的共享，从而节省存储空间； 应用示例2： 描述工程项目或系统过程的工具 工程可分为若干个成为活动的子工程； 子工程间存在一定约束，如某些子工程的开始必须在另一些子工程完成之后 主要关心的问题 1.工程是否能顺利进行； 2.整个工程完成所必须的最短时间。 二、AOV网和拓扑排序 AOV网： 结点为活动，弧的指向表示活动执行的次序 AOE网： 结点为事件，弧表示活动，权表示活动持续时间 AOV网所代
经典算法之拓扑排序
热门推荐
有酒醉三生丶
07-16 2万+
定义： 把AOV网（用定点表示活动，用弧表示活动间优先关系的有向图）络中各个顶点按照它们互相之间的优先关系排列成一个线性序列的过程叫做拓扑排序。 方法： 在有向图中选一个没有前驱的顶点并且输出 从图中删除该顶点和所有以它为尾的弧，即删除所有与它有关的边。 重复上述两步，直至全部顶点均已输出；或者当图中不存在无前驱的顶点为止。 例题： 首先我们找到无前驱顶点C1和C9，我们删除掉C1...
拓扑路径详细原理
Superb_day
07-17 9556
一、拓扑排序概述 一场大型工程，我们往往把它看做多个子工程的集合体，这些小工程有的相互连接，一个是一个的子工程，有的相互并列，共处于一个工程的顺序之下，我们可以画一个图来表示这个工程和这些子工程的联系，它称为AOV网。 举个例子：小S作为班级的学习委员，掌管全班的收发作业，他手下还有一些班干部，但是作业实在太多了，而且人手有限，不可能同时收发所有科目作业，所以，他决定权衡利弊，优先收脾气不好的...
数据结构——图（3），拓扑排序
wayblink的博客
03-30 762
拓扑排序概念拓扑排序(Topological Order)是指，将一个有向无环图(Directed Acyclic Graph简称DAG)进行排序进而得到一个有序的线性序列。这样说，可能理解起来比较抽象。下面通过简单的例子进行说明！ 例如，一个项目包括A、B、C、D四个子部分来完成，并且A依赖于B和D，C依赖于D。现在要制定一个计划，写出A、B、C、D的执行顺序。这时，就可以利用到拓扑排序，它就
拓扑排序解决士兵排队问题
"士兵排队问题可以通过拓扑排序解决，它涉及到图论中的有向无环图(DAG)处理。在给定的士兵排列问题中，每个士兵作为一个节点，比较关系作为有向边，构建出的有向图进行拓扑排序，以得到符合身高顺序的线性序列。拓扑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值