【模板】拓扑排序 及 练习

4-25 号和熊神商定开始搞图论，自然从基础开始学习，这两天把自己以前一直很有疑惑的一个基础算法搞懂了：拓扑排序。

用的模板是acdream的链式前向星结构，但是看到教主们 都用的是领接表，没有认真研究过两者差别，TUT

先贴上模板：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
const int N = 10005;

bool vis[N];
int head[N],degree[N];
int Q[N],cnt,num;
int f[N]; //分层图

struct EdgeNode
{
    int to;
    int next;
};

EdgeNode Edge[N];

void Init()
{
    cnt = 0;
    memset(vis,false,sizeof(vis));
    memset(head,-1,sizeof(head));
    memset(degree,0,sizeof(degree));
    memset(f,0,sizeof(f));
}

void add(int u,int v)
{
    degree[v]++;
    Edge[cnt].to = v;
    Edge[cnt].next = head[u];   //即存以u为开头的上一条边的编号，方便下方遍历
    head[u] = cnt++;            // 记录这一条以u为开头的边
}

void TopSort(int n)
{
    num = 0;
    for(int i=1;i<=n;i++) //先将没有前驱的节点加入队列
       if(!degree[i]&&vis[i]){ //在某些情况，不需要在连通分量里
           Q[num++] = i;
           f[i]=1;
       }
    for(int i=0;i<num;i++)
    {
        //删除从该节点出发的所有边，更新degree数组
        for(int k = head[Q[i]];k != -1;k = Edge[k].next)
        {
            degree[Edge[k].to]--;
            //如果degree数组为0，说明新的没有前驱的节点找到,加入队列中
            if(!degree[Edge[k].to]){
               Q[num++] = Edge[k].to;
               f[Edge[k].to]=f[Q[i]]+1;
            }
        }
    }
}

int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        Init();
        while(m--)
        {
            int sta,to;
            cin>>sta>>to;
            vis[sta] = true;
            vis[to] = true;
            add(sta,to);
        }
        TopSort(n);
        for(int i=0;i<num;i++)
           cout<<Q[i]<<" ";
        cout<<endl;
    }
    return 0;
}

在别人的模板上我自己增加了一个分层图f，便于自己做一些操作
这几天做的题目：

Hdu 1285 ，水题 直接v*v 就好了，用不到链式结构

Hdu 2647 ，刚开始像sb一顿乱搞一通， 实际上我们只要反向建图就可以很轻松的完成这个题目，这种反向建图的方法好像就是叫逆拓扑排序。

Hdu3342 理解为 判断有向图是否存在环，即可。水题

Codeforces #290 div2 C. Fox And Names
拓扑排序：先建立1-26 个点代表a-z，每两个串之间可以建立一条边，或者不建立边（比如a和 ab， absc和abscc） 然后跑一遍拓扑排序，分一下层，把所有独立点放到第一层，然后逐层输出即可。
有一个坑点： 如果存在（aaa，aa） 这种情况是impossible，因为这种数据是不合题意的，在字典序相同的情况之下应该按短的在前面。

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
const int N = 10005;

bool vis[N];
int head[N],degree[N];
int Q[N],cnt,num;
char str[105][110];
int f[N];

struct EdgeNode
{
    int to;
    int next;
};

EdgeNode Edge[N];

void Init()
{
    cnt = 0;
    memset(vis,false,sizeof(vis));
    memset(head,-1,sizeof(head));
    memset(degree,0,sizeof(degree));
    memset(f,0,sizeof(f));
}

void add(int u,int v)
{
    degree[v]++;
    Edge[cnt].to = v;
    Edge[cnt].next = head[u];   //即存以u为开头的上一条边的编号，方便下方遍历
    head[u] = cnt++;            // 记录这一条以u为开头的边
}

void TopSort(int n)
{
    num = 0;
    for(int i=1;i<=n;i++) //先将没有前驱的节点加入队列
       if(!degree[i]){ //在某些情况，不需要在连通分量里
           Q[num++] = i;
           f[i]=1;
       }
    for(int i=0;i<num;i++)
    {
        //删除从该节点出发的所有边，更新degree数组
        for(int k = head[Q[i]];k != -1;k = Edge[k].next)
        {
            degree[Edge[k].to]--;
            //如果degree数组为0，说明新的没有前驱的节点找到,加入队列中
            if(!degree[Edge[k].to]){
               Q[num++] = Edge[k].to;
               f[Edge[k].to]=f[Q[i]] + 1;
            }
        }
    }
}

int main()
{
    int n,nn;
   // freopen("1.txt","r",stdin);
    while(~scanf("%d",&nn)){
        Init();
        n=26;
        int flag=1;
        for(int i=1;i<=nn;i++)
            scanf("%s",str[i]);
        for(int i=1;i<nn;i++){
            int pos=0;
//             cout<<str[i][pos] << " "<<str[i+1][pos]<<endl;
            while(str[i][pos]==str[i+1][pos] && pos<strlen(str[i]) && pos<strlen(str[i+1])){
//              cout<<str[i][pos] << " "<<str[i+1][pos]<<endl;
                pos++;
            }
            if(pos==strlen(str[i+1]) && pos<strlen(str[i]) ){
                flag=0;
                break;
            }

            if(pos==strlen(str[i]) )
               continue;
            int sta,to;
            sta=str[i][pos]-'a'+1;
            to=str[i+1][pos]-'a'+1;
            vis[sta]=vis[to]=1;
            add(sta,to);
        }
        TopSort(n);
//        for(int i=0;i<n;i++)
//                  printf("%d ",degree[i]);
//        cout<<endl;
        if(flag==0){
              printf("Impossible\n");
              continue;
        }
        for(int i=0;i<n;i++){
           if(degree[i]){
               printf("Impossible\n");
               flag=0;
               break;
           }
        }
        if(flag){
            for(int i=1;i<105;i++){
                for(int j=1;j<=n;j++)
                    if(f[j]==i){
                        printf("%c",j+'a'-1);
                    }
            }
            cout<<endl;
        }
    }
    return 0;
}

Codeforces #645 D Robot Rapping Results Report
没有坑点，如果只用拓扑排序会超时，但是只需要加个二分就很轻松的过了。
题意：
每个机器人都有能力，每一次给出两个机器人的相对顺序，问最少由前几组即可决定所有机器人的顺序

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
const int N = 100005;

bool vis[N];
int head[N],degree[N];
int Q[N],cnt,num;
int f[N]; //分层
int flag[N];
struct EdgeNode
{
    int to;
    int next;
};

EdgeNode Edge[N];

void Init()
{
    cnt = 0;
    memset(vis,false,sizeof(vis));
    memset(head,-1,sizeof(head));
    memset(degree,0,sizeof(degree));
    memset(f,0,sizeof(f));
    memset(flag,0,sizeof(flag));
}

void add(int u,int v)
{
    degree[v]++;
    Edge[cnt].to = v;
    Edge[cnt].next = head[u];   //即存以u为开头的上一条边的编号，方便下方遍历
    head[u] = cnt++;            // 记录这一条以u为开头的边
}

void TopSort(int n)
{
    num = 0;
    for(int i=1;i<=n;i++) //先将没有前驱的节点加入队列
       if(!degree[i]&&vis[i]){ //在某些情况，不需要在连通分量里
           Q[num++] = i;
           f[i]=1;
       }
    for(int i=0;i<num;i++)
    {
        //删除从该节点出发的所有边，更新degree数组
        for(int k = head[Q[i]];k != -1;k = Edge[k].next)
        {
            degree[Edge[k].to]--;
            //如果degree数组为0，说明新的没有前驱的节点找到,加入队列中
            if(!degree[Edge[k].to]){
               Q[num++] = Edge[k].to;
               f[Edge[k].to]=f[Q[i]]+1;
            }
        }
    }
}
int sta[100005],to[100005];
int jud(int n){
     int ans=1;
     for(int i=1;i<=n;i++){
         if(!f[i]){
              ans=0;
              break;
         }
         if(flag[f[i]]==0)
             flag[f[i]]++;
         else if(flag[f[i]]>0){
             ans=0;
             break;
         }
     }
     return ans;
}
int main()
{
    //freopen("1.txt","r",stdin);
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        Init();
        for(int i=1;i<=m;i++){
            int u,v;
            cin>>u>>v;
            sta[i] = u;
            to[i] = v;
            add(u,v);
            vis[u]=vis[v]=1;
        }
        TopSort(n);
        if(jud(n)==0){
            printf("-1\n");
            continue;
        }
        int loww=1,highh=m;
        while(loww<highh ){
            Init();
            int mid=(loww+highh)/2;
            for(int i=1;i<=mid;i++){
                vis[sta[i]]=vis[to[i]]=1;
                add(sta[i],to[i]);
            }
            TopSort(n);
            int ans=jud(n);
            if(ans==1){
                highh=mid;
            }
            else
                loww=mid+1;
        }
        printf("%d\n",loww);
    }
    return 0;
}

Codeforces Round #292 (Div. 2) D. Drazil and Tiles
题意：有n*m图，用<>^去填充图形
问能不能填满表格，或者说是独一无二的填充方法。

这个题 先建图，点与点之间的图，如果成环必然不独特（但是如果有:

*. .
. . .

这种情况下是不成环的，然后找度为1 的点 拓扑排序弄出来就好，代码我写的很长，而且我交的时候题目数据损坏，暂时交不了，过几天再交试试：

这个想法感觉是有问题的