拓扑排序

 一种拓扑排序算法。该算法是简单而直观的，实质上属于广度优先遍历，因此称为广度优先拓扑排序算法。该算法包含下列几个步骤：

           

[1] 从有向图中找一个没有前趋的结点v，若v不存在，则表明不可进行拓扑排序（图中有环路），结束（不完全成功）；

          

[2] 将v输出；

   

[3] 将v从图中删除，同时删除关联于v的所有的边

    

[4] 若图中全部结点均已输出，则结束（成功），否则转[1]继续进行

 

下面以杭电1285这道题目为例写出模板：点击打开链接

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
int n,m;
int map[501][501];
int prenode[501];
int ans[501];
int L;
void topsort()
{
    int i,j,k;
    L=0;
    for(i=1;i<=n;i++)//n个节点，共n次
    {
        for(j=1;j<=n;j++)
        {
            if(prenode[j]==0)
            {
                ans[L++]=j;
                prenode[j]--;
                for(k=1;k<=n;k++)
                {
                    if(map[j][k])
                        prenode[k]--;
                }
            //    for(int f=1;f<=n;f++)printf("**%d %d\n",f,prenode[f]);
                break;
            }
        }
        if(j==n+1){
                cout<<"存在环"<<endl;
                return;
        }
    }
}

int main()
{
    while(cin>>n>>m)
    {
        int i,a,b;
        memset(map,0,sizeof(map));
        memset(prenode,0,sizeof(prenode));
        while(m--)
        {
            cin>>a>>b;
            if(!map[a][b]){
                map[a][b]=1;
                prenode[b]++;
            }
        }

        topsort();
        for(i=0;i<L;i++)
        {
            if(i<L-1)printf("%d ",ans[i]);
            else printf("%d\n",ans[i]);
        }
    }

    return 0;
}

ZOJ1060 花了一下午时间，错了好几次，先存着吧，感到世界深深的饿意

参考文章：

http://blog.csdn.net/l04205613/article/details/6303356

http://www.cnblogs.com/sysuwhj/archive/2011/03/19/1989119.html

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<string>
#include<queue>
using namespace std;
int n,m;
int prenode[27];//第i个节点前驱节点数，即第i个节点的度数
bool map[27][27];//记录关系网
bool isused[27];//节点是否全部被用完
bool isexist[27];//节点是否存在
string path;
int f1,f2;
/*
1. Sorted sequence determined after 4 relations: ABCD.
      每次要保证入度为0的点只有1个 且 n个点全部用完且仅被用一次
2. Inconsistency found after 2 relations.
       存在环
3. Sorted sequence cannot be determined.
       关系不能确定，条件不足
*/
int Cnt()
{
    int sum=0;
    for(int i=0;i<27;i++)if(isexist[i])sum++;
    return sum;
}

int floyd()
{
    int i,j,k;
    for(k=0;k<n;k++)
    {
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                map[i][j]=map[i][j]||map[i][k]&&map[k][j];
    }
    for(i=0;i<n;i++)
        if(map[i][i])return 0;   //有环
    return 1;  //无环
}

bool ifused()//节点是否全部被用完
{
    int f=1;
    for(int i=0;i<n;i++){
            if(!isused[i]){
                 f=0;
                 break;
            }
    }
    return f;
}

void topsort()
{
    if(!floyd()){
        f2=1;
        return;
    }

    queue<int>q;
    int i,j;
    path="";
    memset(prenode,0,sizeof(prenode));
    memset(isused,0,sizeof(isused));

    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            if(map[j][i])prenode[i]++;
        }
        if(isexist[i]&&!prenode[i]){
                q.push(i);
    ///            printf("    %c\n",i+'A');
        }
    }
    if(q.empty()){
        f2=1;//存在环
        return;
    }
    if(q.size()>1){
        return;//关系无法确定
    }
    int nnow=Cnt();//计算当前节点数
  ///  printf("    nnow=%d\n",nnow);

    int cnt=0;//记录所用字母数
    while(nnow--)
    {
        if(q.empty())
        {
            f2=1;//存在环
          ///  printf("huan2\n");
            return;
        }

        int temp=q.front();
        q.pop();
        prenode[temp]--;
        isused[temp]=1;
        path+=(char)(temp+'A');
      ///  printf("*    %c\n",temp+'A');
        cnt++;
        for(i=0;i<n;i++){
                if(map[temp][i]){
                        prenode[i]--;
                        if(!prenode[i])q.push(i);
                }
        }

        if(q.size()>1)return;
    }
    if(cnt==n&&ifused())f1=1;
}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    while(cin>>n>>m&&(n+m))
    {
        char a,b,c;
        memset(map,0,sizeof(map));
        memset(isexist,0,sizeof(isexist));
        int i,ans;
        f1=f2=0;
        for(i=1;i<=m;i++)
        {
            cin>>a>>c>>b;
            a=a-'A';
            b=b-'A';
            map[a][b]=1;
            isexist[a]=1;
            isexist[b]=1;
            if(f1||f2)continue;
            topsort();
            if(f2==1)ans=i;
            if(f1==1)ans=i;
        }
        if(f1==1)cout<<"Sorted sequence determined after "<<ans<<" relations: "<<path<<"."<<endl;
        else if(f2==1)cout<<"Inconsistency found after "<<ans<<" relations."<<endl;
        else cout<<"Sorted sequence cannot be determined."<<endl;
    }
    return 0;
}

ZOJ1060 拓扑排序，错了好几次

注意三点

1.用拓扑排序判环： 即不存在入度为0的点就表示有环

2.用拓扑排序求稳定排序，每次入度为0的点只能有1个

3 求稳定排序过程中入度为0的点可能大于一个，这是由条件不足引起的，但这种情况下也可能是存在环的！！！

测试案例：

7 7
G<F
A<B
B<C
C<D
D<F
F<B
D<E

图：

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
using namespace std;
#define N 27
vector<int>G[N],res,point;
int n,ru[N];
int topsort()
{
    int i,j,k,p;
    memset(ru,0,sizeof(ru));
    for(i=0;i<n;i++)
    {
        for(j=0;j<G[i].size();j++)ru[G[i][j]]++;
    }
    int num,ans=0;
    res.clear();
    int flag=1;
    while(1){
      //  for(i=0;i<point.size();i++)printf("-- %d %d\n",point[i],ru[point[i]]);
       // printf("*****\n");
        num=0;
        for(i=0;i<point.size();i++)
        {
            if(ru[point[i]]==0)
            {
                num++;
                p=point[i];
            }
        }
        if(num==0)return -1;//huan?
        if(num>1)flag=0;//tianjianbuzu?
        ru[p]=-1;
        ans++;
        res.push_back(p);
        if(ans==n&&flag)return 1;
        for(i=0;i<G[p].size();i++)ru[G[p][i]]--;
        if(ans==point.size())return -2;
    }
    return -2;//?

}
int main()
{
    char ch[5];
    int x,y,m,i;
    while(~scanf("%d%d",&n,&m)&&(n+m))
    {
        int flag=0,t,k;
        for(i=0;i<27;i++)G[i].clear();
        point.clear();
        for(k=1;k<=m;k++)
        {
            scanf("%s",&ch);
            x=ch[0]-'A';
            y=ch[2]-'A';
            if(flag)continue;
            for(i=0;i<point.size();i++)if(point[i]==x)break;
            if(i==point.size())point.push_back(x);
            for(i=0;i<point.size();i++)if(point[i]==y)break;
            if(i==point.size())point.push_back(y);
            for(i=0;i<G[x].size();i++)if(G[x][i]==y)break;//quchong
            if(i<G[x].size())continue;
            G[x].push_back(y);
            t=topsort();
            if(t==1)
            {
                printf("Sorted sequence determined after %d relations: ",k);
                for(i=0;i<res.size();i++)printf("%c",res[i]+'A');
                printf(".\n");
                flag=1;
            }
            else if(t==-1)
            {
                printf("Inconsistency found after %d relations.\n",k);
                flag=1;
            }
        }
        if(!flag)printf("Sorted sequence cannot be determined.\n");

    }

    return 0;
}
/*
4 6
A<B
A<C
B<C
C<B
C<D
B<D

7 7
A<B
B<C
C<D
D<F
F<B
D<E
G<F

3 2
A<B
C<B
*/