前言：
引用百度百科的话：
对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。
拓扑排序最有用的一点就是判断当前图是否存在环
简单来说：
一个图的所有节点排序,使得每一条有向边(u,v)对应的u都排在v的前面，实质上它就是对有向图的顶点排成一个线性序列。
举个例子：某校的选课系统规定，每门课可能有若干个先修课，如果要修读某一门课程，则必须要先 修完所有的先修课才能修读。假设一个学生同时只能报一门课程，那么选课系统允许他修完所有课程的顺序就是一个拓扑序。
相关知识点
-
入度，出度：
入度就是：有向图的某个顶点作为终点的次数和。
出度就是：有向图的某个顶点作为起点的次数和。 -
有向无环图 (DAG)
在图论中，有向图用边来描述结点与结点之间的方向关系， 如果一个有向图从任意顶点出发无法经过若干条边回到这个点，则称这个图是一个有向无环图。如图所示，箭头代表边，圆圈代表结点：
-
拓扑排序
- 有向无环图（DAG）才有拓扑排序，非 DAG 图没有拓扑排序。 当有向无环图满足以下条件时：
- 每一个顶点出现且只出现一次
- 若A在序列中排在B的前面，则在图中不存在从B到A的路径。
- 有向无环图（DAG）才有拓扑排序，非 DAG 图没有拓扑排序。 当有向无环图满足以下条件时：
那么就存在拓扑序列！
演示过程
（必须明白一件事，一个图的拓扑排序可以有很多个，有可能不是唯一的，具体应该看题目要求，后面会讲到这些问题，既然有很多个拓扑序列，那么我们一般最关心的就是按照字典序最小的那个序列）
对了，有个非常重要的点，我们平时所遇到最常见的就是正序建立图，在本章的后面会出现一道题，是反向建图，请读者好好理解反向建立图的意义所在！！！
解题套路：
先来了解一下一些性质：
1、 拓扑排序在有向无环图中才能排出有效的序列，否则能判断该有向图有环。
2、如果一开始输入的有向图中的点,不存在入度为0的点,那我们就可以直接判断该有向图存在回路
3、如果存在的入度为0的点大于一个,则该有向图存在多个拓扑序列；但如果每次队列（这里我们用队列存储入度为0的点）中只有一个入度为0的点，那么这个拓扑序列就是唯一的
拓扑排序步骤：
-
首先根据题目中的点进行建图， 这里要注意一下重边的情况，下面的代码中会说到。
-
在有向图中选入度为0的顶点，然后入队列；
-
每次出队后的那个点，可以用vector存储，然后在图中删除该顶点和以它为尾的弧；
-
重复这两步骤，直至全部顶点输出，此时得到无环有向图的所有顶点的拓扑序列；或者图中剩下顶点中再也没有入度为0的顶点（也就是vector容器内的元素个数不等于顶点个数），此时拓扑序列不存在，且图中必有环。
-
输出vector容器内的元素即可，这就是我们所求的拓扑序
我们拿一道简单题目练练手，如下：
# include <iostream>
# include <string>
# include <algorithm>
# include <stack>
# include <queue>
using namespace std;
const int N = 510;
int head[N],to[N*2],nex[N*2],idx;
int du[N];
void add(int x,int y){
nex[++idx] = head[x];
to[idx] = y;
head[x] = idx;
du[y]++;
}
struct cmp{
bool operator()(const int& a,const int& b)const{
return a>b;
}
};
int main(void)
{
int n,m;
while(cin>>n>>m){
//初始化变量以及数组，因为多组输入
for(int i=1;i<=n;++i){
head[i] = 0;
du[i]=0;
}
idx = 0;
//建图，这里用链式前向星，不懂的百度看看
for(int i=1;i<=m;++i){
int x,y;
cin>>x>>y;
add(x,y);
//这里如果重边的话，你也可以不用理睬，就这样写
//但是会引来时间效率的问题;当然你可以去重，
//把元素放进容器内去重，如map,set或者开个二维数组都行
}
//因为这道题要字典序最小，所以用优先队列，每次出来的肯定是最小的字母
priority_queue<int,vector<int>,cmp> q;
//循环遍历，把入度为0的点入队
for(int i=1;i<=n;++i){
if(du[i]==0) q.push(i);
}
vector<int> p;
while(q.size()){
int x = q.top();
q.pop();
p.push_back(x);
for(int i=head[x];i;i=nex[i]){ //去除与该点相连的所有边的入度
int y = to[i];
if( (--du[y]) == 0){ //如果某点的入度为0，继续入队
q.push(y);
// cout<<y<<endl;
}
}
}
//输出拓扑序列
for(int i=0;i<p.size()-1;++i){
cout<<p[i]<<' ';
}cout<<p.back();
cout<<endl;
}
return 0;
}
例题集合
例题一：poj1270 - Following Orders（所有拓扑序列）
题目大意：给出两行字符串，第一行代表有哪些点，第二行有很多个字符，每两个字符A,B代表A<B
问满足条件的所有答案
比如有a b f g四个点
然后a b b f，代表a<b并且b<f
现在要求输出的一个由所有点组成的字符串，并且不能出现b>a和b>f的情况
思路:这道题其实就是求拓扑排序的全排序，即求所有的拓扑序列，也是我们要掌握的知识点，想想之前我们是怎么求全排列的？然后只不过在那思想上增加拓扑序列的要求即可。
这里要注意重边的情况，显然重边我们可以去除掉的，这里我们用二维数组记录每条边，只记录一次，然后后续如果再次出现之前记录过的边，我们就直接continue。（当然你也可以用map或者set去重）
变量声明：
- flag[]数组记录哪个字母是出现过的（这里我们转换成数字来记录）
- used[]数组就是记录当前点是否遍历过
- in[]数组就是记录是否可以走，因为只有入度为0的点才有资格放进目标数组里
- path[]数组存放目标值
#include <cstdio>
#include <cstring>
#define MAXN 30
using namespace std;
char str[1005];
int n,in[MAXN],path[MAXN];
bool g[MAXN][MAXN],flag[MAXN],used[MAXN];
void dfs(int cnt)
{
if(cnt==n+1){
for(int i=1;i<=n;i++)
printf("%c",path[i]+'a');
printf("\n");
}
for(int i=0;i<26;i++){
if(flag[i]&&!used[i]&&!in[i]){
for(int j=0;j<26;j++)
if(g[i][j])in[j]--;
used[i]=true;
path[cnt]=i;
dfs(cnt+1);
used[i]=false;
for(int j=0;j<26;j++)
if(g[i][j])in[j]++;
}
}
}
int main()
{
while(gets(str)){
memset(g,false,sizeof(g));
n=0;
for(int i=0;i<=26;i++)in[i]=flag[i]=used[i]=0; //初始化
for(int i=0;str[i];i++){
if(str[i]!=' '){
flag[str[i]-'a']=true;
n++;
}
}
gets(str);
for(int i=0;str[i];i++){
if(str[i]!=' '){
int x=str[i]-'a',y=str[i+2]-'a';
i=i+2;
if(g[x][y])continue; //重边
g[x][y]=true;
in[y]++;
}
}
dfs(1);
printf("\n");
}
}
例题二：D - 逃生 HDU - 4857 （反向建图）
思路：这道题有点小坑，题目意思中需要特别注意一点，那就是如果a和b没有约束的情况下，应该让编号小的在前面。
那怎么才能实现这一点呢？之前我们是直接正序建图，用优先队列输出字典序最小的拓扑序列，那这里大家是不是也想这么做，那我举个例子：
3 1 3个点，一个关系
3 1 3必须在1前面
如果按照上面的来走，那么输出的答案就是231，很明显是错的，正确答案是312。
这里我们必须反向建图，其实无论你正向建图还是反向建图，输出的序列一定是拓扑序列，只不过这两种输出的拓扑序列有可能是不一样的，我们得根据题目要求去输出人家需要的拓扑序列。
反向建图，用优先队列来做，这里我们让队列每次出来的是字典序大的，就拿上面那个例子来说，由于反向建图，那么1就是在3 前面，队列中就有2和1，这时出来的应该是2，然后1，经过遍历，3入队，3出队，最终答案是213，然后我们反向遍历，得到我们的最终正确答案312。
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<string.h>
#include<math.h>
using namespace std;
struct list
{
int u,v,w;
int next;
}edge[110000];
int head[33000];
int nums;
void add(int u,int v,int w)
{
edge[nums].u=u;
edge[nums].v=v;
edge[nums].w=w;
edge[nums].next=head[u];
head[u]=nums++;
}
int du[33000];
void init()
{
memset(head,-1,sizeof(head));
nums=1;
memset(du,0,sizeof(du));
}
priority_queue<int>que;
vector<int>vec;
int n;
void dos()
{
vec.clear();
while(!que.empty())que.pop();
for(int i=1;i<=n;i++)
{
if(du[i]==0)que.push(i);
}
while(!que.empty())
{
int x=que.top();
que.pop();
for(int i=head[x];i!=-1;i=edge[i].next)
{
int y=edge[i].v;
du[y]--;
if(du[y]==0)
{
que.push(y);
}
}
vec.push_back(x);
}
for(int i=n-1;i>=0;i--)
{
if(i!=n-1)printf(" ");
printf("%d",vec[i]);
}
cout<<endl;
}
int main()
{
int T,m,a,b;
scanf("%d",&T);
while(T--)
{
init();
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&a,&b);
add(b,a,1);
du[a]++;
}
dos();
}
return 0;
}
例题三：F - Reward HDU - 2647（反向建图）
思路：这道题也是反向建图，跟上一道题不一样的事，这里没用到优先队列，之所以要反向建图，那是因为要知道最后面的人有哪些，他们的工资是最低的，在他们前面的人工资是+1累加的，所以这里要反向建图，然后bfs层序搜索，因为同一层人的工资是一样的。
# include <iostream>
# include <algorithm>
# include <queue>
using namespace std;
const int N = 1e4+10;
int head[N*2],to[N*2],nex[N*2],idx;
int in_du[N*2];
void add(int x,int y){
nex[++idx] = head[x];
to[idx] = y;
head[x] = idx;
++in_du[y];
}
void inio(int n){
for(int i=1;i<=n;++i){
head[i] = 0;
in_du[i] = 0;
}
idx=0;
}
int main(void)
{
int n,m;
while(cin>>n>>m){
inio(max(n,m));
for(int i=1;i<=m;++i){
int x,y;
cin>>x>>y;
add(y,x);
}
queue<int> que;
for(int i=1;i<=n;++i){
if(in_du[i]==0) que.push(i);
}
long long ans = 0;
int num = 0;
int sk = 888;
while(que.size()){
int len = que.size();
num+=len;
for(int i=1;i<=len;++i){
int k = que.front();
que.pop();
for(int j=head[k];j;j=nex[j]){
int y = to[j];
if((--in_du[y]) == 0) que.push(y);
}
}
ans+=len*(sk++);
}
if(num==n)
cout<<ans<<endl;
else cout<<"-1"<<endl;
}
return 0;
}
# include <iostream>
# include <algorithm>
# include <queue>
using namespace std;
const int N = 1e4+10;
int head[N*2],to[N*2],nex[N*2],idx;
int in_du[N*2];
void add(int x,int y){
nex[++idx] = head[x];
to[idx] = y;
head[x] = idx;
++in_du[y];
}
void inio(int n){
for(int i=1;i<=n;++i){
head[i] = 0;
in_du[i] = 0;
}
idx=0;
}
int main(void)
{
int n,m;
while(cin>>n>>m){
inio(max(n,m));
for(int i=1;i<=m;++i){
int x,y;
cin>>x>>y;
add(y,x);
}
queue<int> que;
for(int i=1;i<=n;++i){
if(in_du[i]==0) que.push(i);
}
long long ans = 0;
int num = 0;
int sk = 888;
while(que.size()){
int len = que.size();
num+=len;
for(int i=1;i<=len;++i){
int k = que.front();
que.pop();
for(int j=head[k];j;j=nex[j]){
int y = to[j];
if((--in_du[y]) == 0) que.push(y);
}
}
ans+=len*(sk++);
}
if(num==n)
cout<<ans<<endl;
else cout<<"-1"<<endl;
}
return 0;
}
例题四：E - Rank of Tetris HDU - 1811 （并查集+拓扑排序）
思路：这里用到并查集是要判断在集合里的点是否有不符合的情况，比如a==b，但后面又出现a>b，很明显就是错的；之后我们只要拿并查集当中集合的老大以及那些x>y这些拿去建图，然后用拓扑排序解答。
这里其实是求此拓扑序是否唯一（如果存在的话），那么我们在那个队列出队的情况下加上一个判断语句，如果每次当前的队列的长度是1,那么就可以证明此拓扑序列是唯一的
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF=0x7fffffffffffffff;
const int mod=1e9+7;
const int maxn = 1e6+5;
int re[maxn],a[maxn],b[maxn],in[maxn];
char ch[maxn];
int n,m;
vector<int>edge[maxn];
int flag_CONFLICT,flag_UNCERTAIN;
//冲突 拓扑排序不唯一
void init()
{
flag_CONFLICT=flag_UNCERTAIN=0;
for(int i=1; i<=n; i++)
{
re[i]=i;
in[i]=0;
edge[i].clear();
}
}
int fin(int x)
{
return re[x]==x?x:re[x]=fin(re[x]);
}
void merg(int x,int y)
{
int fx=fin(x);
int fy=fin(y);
if(fx!=fy)
re[fy]=fx;
}
void add(int x,int y)
{
edge[x].push_back(y);
}
void tupo()
{
int sum=0;//节点数
queue<int>q;
for(int i=1;i<=n;i++)
{
if(fin(i)==i)
{
sum++;
if(in[i]==0)
q.push(i);
}
}
while(!q.empty())
{
if(q.size()>1) flag_UNCERTAIN=1;
int now=q.front();q.pop();
sum--;
for(auto v:edge[now])
{
if(--in[v]==0)
q.push(v);
}
}
if(sum!=0)
flag_CONFLICT=1;
}
int main()
{
ios;
while(cin>>n>>m)
{
init();
for(int i=1;i<=m;i++)
{
cin>>a[i]>>ch[i]>>b[i];
a[i]++,b[i]++;
if(ch[i]=='=')
merg(a[i],b[i]);
}
for(int i=1;i<=m;i++)//建立图
{
if(ch[i]!='=')
{
int fx=fin(a[i]),fy=fin(b[i]);
if(fx==fy)
{
flag_CONFLICT=1;
break;
}
if(ch[i]=='<')
swap(fx,fy);
add(fx,fy);
in[fy]++;
}
}
if(flag_CONFLICT)
{
cout<<"CONFLICT\n";
continue;
}
tupo();
if(flag_CONFLICT)
cout<<"CONFLICT\n";
else if(flag_UNCERTAIN)
cout<<"UNCERTAIN\n";
else
cout<<"OK\n";
}
}
1647
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
