拓扑排序复习——Chemist

一、基本算法

拓扑序列：对于一张有向图，求一个序列a_i若对于每一条边(u,v)，都满足a_u<=a_v ，则称这个序列为这张有向图的拓扑序列，一张图可能有多个拓扑序列。

求拓扑序列：找到入度为0的点，加入队列中，每次取出队列顶端的点加入拓扑序列的最后，将它到达的点的入度-1，然后再重复做，直到没有点的入度为0，若最后还是有点的入度大于0，则说明有向图中存在环。

代码：

void add(int x,int y)
{
    num++;
    in[y]++;
    End[num]=y;
    Next[num]=Head[x];
    Head[x]=num;
}
void topsort()
{
    queue<int>q;
    for(int i=;i<=n;i++)
     if(!in[i])q.push(i);
    while(!q.empty())
    {
        int x=q.front();q.pop();
        seq[++cnt]=x;
        for(int i=Head[x];i;i=Next[i])
        {
            int y=End[i];
            in[y]--;
            if(in[y]==)q.push(y);
        }
    }
}

二、应用

1.求字典序最小/最大的拓扑序列。

只需将上面代码中的队列换成小根堆/大根堆即可，每次取出堆顶，方法相同。

2.洛谷P1983车站分级

由于存在明显的优先级关系，所以考虑拓扑排序，按照小于的关系连边，然后拓扑排序一遍，找到最大的d[i]就是最少需要分的级别，因为这一段序列中的点必须满足级别严格递减。（再具体的题解可以看cellur的题解）

代码：

 #include<bits/stdc++.h>
 using namespace std;
 const int M=2e6;
 int n,m,cnt=,sta[],d[],in[],w[];
 bool v[];
 int num=,end[M],next[M],head[];
 void add(int x,int y)
 {
     if()puts("AC");
     num++;
     in[y]++;
     end[num]=y;
     next[num]=head[x];
     head[x]=num;
 }
 void topsort()
 {
     queue<int>q;
     for(int i=;i<=n+m;i++)
      if(!in[i])q.push(i),d[i]=w[i];
     while(q.size())
     {
         int x=q.front();q.pop();
         for(int i=head[x];i;i=next[i])
         {
             int y=end[i];
             in[y]--;
             d[y]=d[x]+w[y];
             if(in[y]==)q.push(y);
         }
     }
 }
 int main()
 {
     cin>>n>>m;
     for(int i=;i<=n;i++)
      w[i]=;
     for(int i=;i<=m;i++)
     {
         memset(v,,sizeof v);
         cin>>cnt;
         for(int j=;j<=cnt;j++)
          scanf("%d",&sta[j]),v[sta[j]]=;
         for(int j=sta[];j<=sta[cnt];j++)
          if(!v[j])add(j,n+i);
         for(int j=;j<=cnt;j++)
          add(n+i,sta[j]);
     }
     topsort();
     int ans=;
     for(int i=;i<=n;i++)
      ans=max(ans,d[i]);
     cout<<ans<<endl;
     return ;
 }

3.洛谷P3243菜肴

最先想到的就是求出字典序最小的拓扑序列，然而我们很容易举出反例，如两个限制：5>2，4>3，这时的答案显然是1 5 2 4 3，而不是1 4 3 5 2，而后者的字典序小于前者。那么我们不妨换一种思路，在反图中求出字典序最大的序列，然后反着输出，如果遇到环就特判输出Impossible。这样为什么是对的呢？因为求最大的拓扑序的话就是在能放的中选择一个最大的放到最前面，如果不放这个而放次大的能放的，那么反过来之后，这个最大的一定在次大的前面，而本来它是可以放到次大的后面的，所以这样一定是最优的。

至于求字典序最大的拓扑序的方法在前面已经说过，这里用大根堆实现，直接看代码：

 #include<bits/stdc++.h>
 using namespace std;
 const int M=1e5+;
 int T,n,m,in[M],seq[M];
 int num=,cnt=,Head[M],Next[M],End[M];
 void add(int x,int y)
 {
     num++;
     End[num]=y;
     Next[num]=Head[x];
     Head[x]=num;
 }
 void clear()
 {
     cnt=num=;
     for(int i=;i<=n;i++)
      in[i]=Head[i]=;
     for(int i=;i<=m;i++)
      Next[i]=End[i]=;
 }
 bool topsort()
 {
     priority_queue<int>q;//大根堆
     for(int i=n;i>=;i--)
      if(!in[i])q.push(i);
     while(!q.empty())
     {
         int x=q.top();q.pop();
         seq[++cnt]=x;
         for(int i=Head[x];i;i=Next[i])
         {
             int y=End[i];
             in[y]--;
             if(in[y]==)q.push(y);
         }
     }
     for(int i=;i<=n;i++)
      if(in[i]>)return ;
     return ;
 }
 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d",&n,&m);
         clear();
         for(int i=;i<=m;i++)
         {
             int x,y;
             scanf("%d%d",&x,&y);
             add(y,x);
             in[x]++;
         }
         if(!topsort())puts("Impossible!");
         else{
             for(int i=n;i>=;i--)
              printf("%d ",seq[i]);
             puts("");
         }
     }
     return ;
 }

4.HDU5222 Exploration

题意：给你一张混合图（既有有向边又有无向边），问有没有简单环。

先将无向边连接的点通过并查集合并成一个点，同时判断是否只通过无向边就能形成环，然后再加入有向边，注意添加的边的起始点为起始点所在集合编号，终点为终点所在集合编号，同时也要判断添加的起始点是否已经属于同一个集合，然后拓扑排序一遍，判断缩点后的有向图是否存在环，当然也可以用Tarjan做。注意多组数据一定要每次把邻接表也清零，因为这个WA了好多次。。。

代码：

 #include<iostream>
 #include<cstdio>
 #include<queue>
 using namespace std;
 const int M=1e6+;
 int T,n,m1,m2;
 int fa[M],in[M];
 int num=,Head[M],Next[M],End[M];
 int get(int x)
 {
     if(x==fa[x])return x;
     else return fa[x]=get(fa[x]);
 }
 void Union(int x,int y)
 {
     fa[get(x)]=get(y);
 }
 void add(int x,int y)
 {
     num++;
     End[num]=y;
     Next[num]=Head[x];
     Head[x]=num;
 }
 void clear()
 {
     num=;
     for(int i=;i<=n;i++)
      fa[i]=i,in[i]=,Head[i]=;
     for(int i=;i<=m2;i++)
      End[i]=Next[i]=;
 }
 bool topsort()
 {
     queue<int>q;
     for(int i=;i<=n;i++)
      if(fa[i]==i&&in[i]==)q.push(i);
     while(q.size())
     {
         int x=q.front();q.pop();
         for(int i=Head[x];i;i=Next[i])
         {
             int y=End[i];
             in[y]--;
             if(in[y]==)q.push(y);
         }
     }
     for(int i=;i<=n;i++)
      if(fa[i]==i&&in[i]>)return ;
     return ;
 }
 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         bool flag=;
         int x,y;
         scanf("%d%d%d",&n,&m1,&m2);
         clear();
         for(int i=;i<=m1;i++)//加无向边
         {
             scanf("%d%d",&x,&y);
             if(get(x)==get(y))flag=;
             //如果无向边就能构成环
             else Union(x,y);
         }
         for(int i=;i<=m2;i++)
         {
             scanf("%d%d",&x,&y);
             int fx=get(x),fy=get(y);
             if(fx==fy)flag=;
             add(fx,fy);
             in[fy]++;
         }
         if(flag)puts("YES");
         else{
             bool f=topsort();
             if(f)puts("YES");
             else puts("NO");
         }
     }
     return ;
 }