首先说明一下关于图中顶点的度
无向图中顶点的度，指和该顶点相关联的边数。
有向图中顶点的度分为入度和出度，通俗的讲入度就是箭头指向自己(顶点)的边的个数，出度就是箭头背离自己的边的个数。
有向图
b的入度为3 出度为0，c的入度为1 出度为2，d的入度为2 出度为1，a的入度为1 出度为4
无向图
v1点的度为4，v3点的度为2，v1点的度数为4（一个环有两个度）
------->直入主题
拓扑排序：有向图顶点的线性排序就是其拓扑排序。其实可以理解为一个有依赖关系的任务顺序。前提是有向无环图。
例如，图形的顶点可以表示要执行的任务，并且边可以表示一个任务必须在另一个任务之前执行的约束; 在这个应用中，拓扑排序只是一个有效的任务顺序。当且仅当图形没有定向循环，即如果它是有向无环图（DAG），则拓扑排序是可能的。
——来自维基百科
在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序（英语：Topological sorting）。
1、每个顶点出现且只出现一次；
2、若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。
易于理解的解释：
比如有人想要制作一件工具，但是这个工具不是一次就可以完成的，分很多个步骤，而且这些步骤是有顺序的，也就是说，假设B的顺序在A的后面，那么你就必须要先完成A再完成B，但是也有些步骤不分顺序，意思是你先做哪一个都是可以的。
比如学习拓扑排序都会提到的这个很火的课程修读关系图：
每个顶点表示学期中的课程，箭头表示学习的先后顺序，有向边（ A->D）表示在学习高等代数之前必须要学完代数。我们怎么才能将这些课程处理成一个序列呢？这个序列是我们学习课程，序列保证，箭头左边的点不会出现在箭头右边点的后面。拓扑排序就是处理这样的问题哦
求拓扑排序常用的方法：
（1）从 DAG 图中选择一个 没有前驱（即入度为0）的顶点并输出。
（2）从图中删除该顶点和所有以它为起点的有向边。
（3）重复 1 和 2 直到当前的 DAG 图为空或当前图中不存在无前驱的顶点为止。后一种情况说明有向图中必然存在环。
求此图的拓扑排序。
模板代码：
#include <bits/stdc++.h>
#define Max 505
using namespace std;
vector<int> vec[Max]; //vec 存图
priority_queue<int,vector<int>,greater<int> > q; //优先队列
int in_deg[Max];//入度
int ans[Max];
int n,m;
void topsort()
{
for(int i=1;i<=n;i++)
{
if(in_deg[i]==0)
{
q.push(i);
}
}
int cnt=0;
while(!q.empty())
{
int u=q.top();
q.pop();
ans[cnt++]=u;
for(int v=0;v<vec[u].size();v++)
{
in_deg[vec[u][v]]--;
if(!in_deg[vec[u][v]])
{
q.push(vec[u][v]);
}
}
}
if(cnt!=n) cout<<"-1"<<endl; //环
else {
cout<<ans[0];
for(int i=1;i<cnt;i++)
cout<<" "<<ans[i];
cout<<endl;
}
}
有关拓扑排序的简单题及代码：
/*
拓扑模板 +优先队列
*/
#include <bits/stdc++.h>
#define Max 505
using namespace std;
vector<int> vec[Max]; //vec 存图
priority_queue<int,vector<int>,greater<int> > q; //优先队列
int in_deg[Max];//入度
int ans[Max];
int n,m;
void init()
{
memset(in_deg,0,sizeof(in_deg));
for(int i=0;i<=n;i++)
{
vec[i].clear();
}
while(!q.empty())
{
q.pop();
}
}
void topsort()
{
for(int i=1;i<=n;i++)
{
if(in_deg[i]==0)
{
q.push(i);
}
}
int cnt=0;
while(!q.empty())
{
int u=q.top();
q.pop();
ans[cnt++]=u;
for(int v=0;v<vec[u].size();v++)
{
in_deg[vec[u][v]]--;
if(!in_deg[vec[u][v]])
{
q.push(vec[u][v]);
}
}
}
if(cnt!=n) cout<<"-1"<<endl; //环
else {
cout<<ans[0];
for(int i=1;i<cnt;i++)
cout<<" "<<ans[i];
cout<<endl;
}
}
int main()
{
ios::sync_with_stdio(false);
while(cin>>n>>m)
{
init();
int u,v;
for(int i=0;i<m;i++)
{
cin>>u>>v;
vec[u].push_back(v);
in_deg[v]++;
}
topsort();
}
return 0;
}
/*
HH is 3xian's master and, at the same time, 3xian is HH's master,which is quite illegal!
To avoid this,please help us to judge whether their relationship is legal or not.
判断有没有环
*/
#include <bits/stdc++.h>
#define Max 101
using namespace std;
vector<int> vec[Max];
int in_deg[Max];
queue<int>q;
int n,m;
void init(int nn)
{
for(int i=0;i<=nn;i++)
{
vec[i].clear();
}
while(!q.empty()) q.pop();
memset(in_deg,0,sizeof(in_deg));
}
int topsort()
{
for(int i=0;i<n;i++)
{
if(in_deg[i]==0)
{
q.push(i);
}
}
int cnt=0;
while(!q.empty())
{
int u=q.front();
q.pop();
cnt++;
for(int v=0;v<vec[u].size();v++)
{
in_deg[vec[u][v]]--;
if(!in_deg[vec[u][v]])
{
q.push(vec[u][v]);
}
}
}
/*
if(cnt==n)
{
return 1;//有向无环图
}else return 0;//非 有向无环图
*/
return cnt==n;
}
int main()
{
ios::sync_with_stdio(false);
while(cin>>n>>m)
{
if(n==0&&m==0) break;
init(n);
int u,v;
for(int i=0;i<m;i++){
cin>>u>>v;
vec[u].push_back(v);
in_deg[v]++;
}
bool ans=topsort();
if(ans==1) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
}
/*
题意：老板给员工发工资
n个员工，m中关系
每次输入 a，b
要求：a的工资必须比 b 高
最低工资是 888
求老板一共最少需要付多少工资
如果不能满足所有人的需求的话 就输出-1
*/
#include <bits/stdc++.h>
#define ll long long
#define Max 10002
using namespace std;
int n,m;
int mon[Max];//分层 相当于每个人888工资的加成
int in_deg[Max];
vector<int> vec[Max];
queue<int>q;
void init(int nn)//注意初始化
{
for(int i=0;i<=nn;i++)
{
vec[i].clear();
}
memset(in_deg,0,sizeof(in_deg));
while(!q.empty()) q.pop();
memset(mon,0,sizeof(mon));
}
int topsort()
{
for(int i=1;i<=n;i++)
{
if(in_deg[i]==0)
{
q.push(i);
}
}
int cnt=0;
while(!q.empty())
{
int u=q.front();
q.pop();
cnt++;
for(int v=0;v<vec[u].size();v++)
{
in_deg[vec[u][v]]--;
if(!in_deg[vec[u][v]])
{
q.push(vec[u][v]);
mon[vec[u][v]]=max(mon[u]+1,mon[vec[u][v]]);
//money分层
}
}
}
return cnt==n;
}
int main()
{
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
ios::sync_with_stdio(false);
while(cin>>n>>m)
{
init(n);
int u,v;
for(int i=0;i<m;i++)
{
cin>>u>>v;
vec[v].push_back(u);// 反向建边
in_deg[u]++;
}
ll ans=0;
if(topsort())
{
for(int i=1;i<=n;i++)
{
// cout<<i<<": "<<mon[i]<<endl;
ans+=(888+mon[i]);
}
cout<<ans<<endl;
}else
{
cout<<"-1"<<endl;
}
}return 0;
}
/*
4 4 1 2 2 3 1 4 3 4
3 2 1 2 1 3
3 1 1 2
7 7
1 2
2 6
3 2
3 4
4 5
5 6
7 6
*/
/*
we will give you a set of relations of the form A < B and ask you to determine whether a sorted order has been specified or not.
1、处理到第一个关系的时候能全部确定所有关系 -> Sorted sequence determined after x relations: %&^%.
2、处理到第几个时能发现矛盾（环） -> Inconsistency found after x relations.
3、没有矛盾但是给出的关系无法确定关系 -> Sorted sequence cannot be determined.
题意就是给你一系列的关系，让你从他给出的关系中从小到大排一个序，如果给出的关系中发生冲突，输出发生冲突的那一步，如果可以得到一个序，输出题目给出到第几个关系才能确定顺序。
注意：之前已经确定了符合约束的序列，那么之后再给出的矛盾的条件是无效的
eg:--->
5 5
A<B
B<C
C<D
D<E
E<A
output:
Sorted sequence determined after 4 relations: ABCDE
----------------------------------------------------------------------
因为最多只有26个字母，所以怎么写都不会超时。
*/
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
int n,m,cnt;
int in_deg[30];//节点入度数组
int in_degTemp[30];//临时节点入度数组 为了保证加入一个关系后 前后 节点度的统一
char Ans[30];//最后排序的结果
vector<int>vec[30]; //存图
queue<int>q; //队列
void init()
{
//26个英文字母
for(int i=0;i<26;i++)
{
vec[i].clear();
}
while(!q.empty()) q.pop();
memset(in_deg,0,sizeof(in_deg));
memset(in_degTemp,0,sizeof(in_degTemp));
memset(Ans,0,sizeof(Ans));
}
int topsort()
{
//每次输入一个关系要判断一次是否有结果，
//in_degTemp是 记录每一次加边后-度-改变的-数组 in_deg不能改
for(int i=0;i<n;i++)
{
if(!in_deg[i])
{
q.push(i);
}
}
bool unSure=false;//不确定(3)的情况的标记
cnt=0;
while(!q.empty())
{
//一旦出现有的点没有涉及(比较的关系中)，入度为0的点必然大于1,则肯定可以说明 有的点无法确定关系
if(q.size()>1) unSure=true;
int u=q.front();
q.pop();
Ans[cnt++]=u+'A';
for(int v=0;v<vec[u].size();v++)
{
in_deg[vec[u][v]]--;
if(!in_deg[vec[u][v]])
{
q.push(vec[u][v]);
}
}
}
if(cnt<n)//存在环
{
return 3;
}
if(unSure)//不确定
{
return 2;
}
return 1;// 确定了
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
init();
if(n==0&&m==0) break;
char op[3];
bool flag=false;
int step=0,ans;
for(int i=0;i<m;i++)
{
scanf("%s",op);
//已经有结果了 就不需要判断后边的关系 但是 还要读入所有数据
if(flag) continue;
vec[op[0]-'A'].push_back(op[2]-'A');
in_deg[op[2]-'A']++;
memcpy(in_degTemp,in_deg,sizeof(in_deg));
ans=topsort();//每加一个关系 拓扑处理一次 并且用临时数组存一下，当前入度情况
memcpy(in_deg,in_degTemp,sizeof(in_degTemp));
if(ans!=2){
step=i+1;
flag=true;
}//如果不是无结果的话 那么就是 回路或者有结果
}
if(ans==1){
Ans[cnt]='\0';
printf("Sorted sequence determined after %d relations: %s.\n",step,Ans);
}else if(ans==2)
{
printf("Sorted sequence cannot be determined.\n");
}else if(ans==3)
{
printf("Inconsistency found after %d relations.\n", step);
}
}
return 0;
}
/*
注意此题不是保证字典序，而是要最小的尽量在前面。
对于有m组限制即a必须在b前面出去，而对于那些没有限制的就必须按照标号从小到大出去，也就是说假设有三个人，3号必须在1号前面除去，2号没限制，那么出去的顺序为3 1 2，为了满足这个需求，反向建图+拓扑排序+优先队列+逆序输出
*/
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#define ll long long
#define Max 30002
using namespace std;
int n,m,a,b;
int in_deg[Max],ans[Max];
vector<int> vec[Max];
priority_queue<int,vector<int>,less<int> > q;//从大到小
//priority_queue<Type, Container, Functional>
void init()
{
while(!q.empty()) q.pop();
memset(in_deg,0,sizeof(in_deg));
memset(ans,0,sizeof(ans));
for(int i=1;i<=n;i++){
vec[i].clear();
}
}
void toposort()
{
for(int i=1;i<=n;i++)
{
if(in_deg[i]==0)
{
q.push(i);
}
}
int cnt=0;
while(!q.empty())
{
int u=q.top();q.pop();
ans[cnt++]=u;
for(int v=0;v<vec[u].size();v++)
{
in_deg[vec[u][v]]--;
if(in_deg[vec[u][v]]==0)
{
q.push(vec[u][v]);
}
}
}
if(cnt!=n) {
// cout<<"-1"<<endl;
printf("-1\n");
}else
{
// cout<<ans[0];
printf("%d",ans[cnt-1]);
for(int i=cnt-2;i>=0;i--)
printf(" %d",ans[i]);
// cout<<" "<<ans[i];
printf("\n");
}
}
int main()
{
// ios::sync_with_stdio(false);
int t;
scanf("%d",&t);
while(t--)
{
//cin>>n>>m;
scanf("%d%d",&n,&m);
init();
for(int i=0;i<m;i++)
{
//cin>>a>>b;
scanf("%d%d",&a,&b);
vec[b].push_back(a);//反向建图
//vec[a].push_back(b);
in_deg[a]++;
}
toposort();
}
return 0;
}
/*
1
3 1
3 1
------
3 1 2
*/
/*
在主要的拓扑排序的基础上又添加了一个要求：编号最小的节点要尽量排在前面；在满足上一个条件的基础上，编号第二小的节点要尽量排在前面；在满足前两个条件的基础上，编号第三小的节点要尽量排在前面……依此类推。（注意，这和字典序是两回事，不能够混淆。）
*/
/*
是反向建边，点大的优先级高，用拓扑排序+优先队列，逆向输出序列即可。
根据每对限制，可确定拓扑序列，但此时的拓扑序列可能有多个（没有之间关系的点的顺序不定）。本题要求较小的点排到前面，则可确定序列。
（1）如果点a和点b有直接和简接的拓扑关系，那么a和b的先后顺序可有拓扑排序确定。
（2）如果点a和点b没有直接和简接的拓扑关系，那么a和b的先后顺序由a和b所能到达的点的确定。
如：
1
3 2
3 1
3 1
应输出结果为 3 1 2
点3 和 点2 没有直接的拓扑关系，但是3到达最小点为1，2到达最小点为2。
综合（1）和（2）本题需要逆向处理。
PS：欧拉回路的路径输出也是逆向输出的。
*/
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstdio>
#define ll long long
#define Max 202
using namespace std;
int n,m,a,b;
int in_deg[Max],ans[Max];
vector<int> vec[Max];
priority_queue<int,vector<int>,less<int> > q;//从大到小
void init()
{
memset(ans,0,sizeof(ans));
memset(in_deg,0,sizeof(in_deg));
for(int i=1;i<=n;i++)
vec[i].clear();
while(!q.empty()) q.pop();
}
void toposort()
{
for(int i=1;i<=n;i++)
{
if(in_deg[i]==0) q.push(i);
}
int cnt=0;
int weigh=n;
while(!q.empty()){
int u=q.top(); q.pop();
cnt++;
ans[u]=weigh--;
for(int v=0;v<vec[u].size();v++)
{
in_deg[vec[u][v]]--;
if(in_deg[vec[u][v]]==0)
{
q.push(vec[u][v]);
}
}
}
if(cnt!=n)
printf("-1\n");
else
{
printf("%d",ans[1]);
for(int i=2;i<=cnt;i++)
printf(" %d",ans[i]);
printf("\n");
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
init();
for(int i=0;i<m;i++)
{
scanf("%d%d",&a,&b);
vec[b].push_back(a);
in_deg[a]++;
}
toposort();
}
return 0;
}
/*
有n个球，分别编号为1到n，并且每个球有对应的重量，输入时，每行输入的两个数，表示“编号”为a的球的重量小于“编号为b的球的重量”，分别输出1到n编号对应的球的重量，尽量保证编号较小的球重量也较小。注意仔细理解题：读入的时候是球的编号，输出的是对应编号的球的重量，看到dicuss区的数据才发现自己题目都读错了。
*/
/*
3
5 4
5 1
4 2
1 3
2 3
10 5
4 1
8 1
7 8
4 1
2 8
5 4
1 4
4 2
5 3
3 2
ans:
2 4 5 3 1 逆向建图
5 1 6 2 7 8 3 4 9 10 重边的话就输出 -1
标签小的重量尽量小
1~n编号的盒子，放1~n重量的球，给出m对盒子装的小球之间大小的关系，输出1~n编号盒子重量，要求编号越小的盒子，放的重量越小。
*/
END,BYEBYE!
