拓扑排序

有向图拓扑排序算法：

 1,从有向图中选择一个没有前驱（即入度为零）的顶点并且输出它。

2，从网中删除该顶点，并且删去从该顶点发出的全部有向边。

3，重复上述两步，直到剩余的网中不再存在没有前驱的顶点为止。

 

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>

using namespace std;

typedef struct {
    int date;
    int count;//in_degree
    int next[26];
    int co;//out_degree
    bool used;
}Node;

Node Q[26];
 Node temp[26];
int Count;
int Mark[26][26];
char print[26];

void Initial(int n)
{
    memset(Mark,0,sizeof(Mark));
    for(int i = 0;i < n;i++){
        Q[i].used = false;
        Q[i].count = 0;
        Q[i].co = 0;
        memset(Q[i].next,-1,sizeof(Q[i].next));
    }
}

void Copy(int n)
{
    for(int i = 0;i < n;i++){
        temp[i].used = false;
        temp[i].count = Q[i].count;
        temp[i].co = Q[i].co;

        for(int j = 0;j < Q[i].co;j++)
          temp[i].next[j] = Q[i].next[j];
    }
}

int topo(int n)// 1: sure 0:flase -1:not sure
{
    int is_onlyone = 1;
    int cc = 0;
        for(int i = 0;i < n;i++){
          int numofzero = 0;
          int first = -1;
          for(int j = 0;j < n;j++){
              if(!temp[j].used){
                  if(temp[j].count == 0){
                      first = j;
                      numofzero++;
                  }
              }
              else
               continue;
           }

            if(first == -1) return 0;

            if(numofzero > 1) is_onlyone = 0;

            temp[first].used = true;
            print[cc++] = 'A' + first;

            for(int j = 0;j < temp[first].co;j++)
            {
                int te = temp[first].next[j];
                temp[te].count--;
            }

        }

        if(is_onlyone) return 1;
        else return 2;
}

int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        if(!n && !m) break;

        Initial(n);

        int flage = 0;

        if(m == 0)
         cout<<"Sorted sequence cannot be determined."<<endl;

        for(int i = 0;i < m;i++)
        {
            char str[4];
            cin>>str;
            if(flage) continue;
            int a,b;
            a = str[0] - 'A';
            b = str[2] - 'A';
            if(!Mark[a][b]){
                Q[a].next[Q[a].co] = b;
                Q[a].co++;
                Q[b].count++;
                Copy(n);
                Mark[a][b] = 1;
            }
            else
              continue;
            memset(print,0,sizeof(print));
            int aa = topo(n);

            if(!aa){//false
                printf("Inconsistency found after %d relations.\n",i+1);
                flage = 1;
                continue;
            }
            else if(aa == 1)
            {
                printf("Sorted sequence determined after %d relations: ",i+1);
                cout<<print<<"."<<endl;
                flage = 1;
                continue;
            }
            else if(i == (m-1))
            {
                cout<<"Sorted sequence cannot be determined."<<endl;
                break;
            }
            else
               continue;
        }
    }
    return 0;
}