【原】 POJ 1094 Sorting It All Out 拓扑排序 解题报告

http://poj.org/problem?id=1094

方法：
每加入一条边就进行一次拓扑排序，从而找到符合条件的最少边数
拓扑排序的基本思想就是依次找到图中入度为0的节点，将该节点和其对应的边删除，这样就使得它的邻接节点的入度-1。反复循环这样做直到所有节点都从图中删除（都被编上拓扑编号），或者因为有环所以还剩下某些节点未被删除

Description

An ascending sorted sequence of distinct values is one in which some form of a less-than operator is used to order the elements from smallest to largest. For example, the sorted sequence A, B, C, D implies that A < B, B < C and C < D. in this problem, we will give you a set of relations of the form A < B and ask you to determine whether a sorted order has been specified or not.

Input

Input consists of multiple problem instances. Each instance starts with a line containing two positive integers n and m. the first value indicated the number of objects to sort, where 2 <= n <= 26. The objects to be sorted will be the first n characters of the uppercase alphabet. The second value m indicates the number of relations of the form A < B which will be given in this problem instance. Next will be m lines, each containing one such relation consisting of three characters: an uppercase letter, the character "<" and a second uppercase letter. No letter will be outside the range of the first n letters of the alphabet. Values of n = m = 0 indicate end of input.

Output

For each problem instance, output consists of one line. This line should be one of the following three:
Sorted sequence determined after xxx relations: yyy...y.
Sorted sequence cannot be determined.
Inconsistency found after xxx relations.
where xxx is the number of relations processed at the time either a sorted sequence is determined or an inconsistency is found, whichever comes first, and yyy...y is the sorted, ascending sequence.

Sample Input

4 6

A<B

A<C

B<C

C<D

B<D

A<B

3 2

A<B

B<A

26 1

A<Z

0 0

Sample Output

Sorted sequence determined after 4 relations: ABCD.

Inconsistency found after 2 relations.

Sorted sequence cannot be determined.

#include <stdio.h>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
#include <string>
#include <fstream>

using namespace std ;

const int N=26 ;
typedef vector< vector<char> > Graph ;

void run1094()
{
    //ifstream in("in.txt") ;

    Graph G ;
    set<char> vertexSet ;

    int n,m ;
    int relnum ;
    int i,cnt ;
    bool sucFlag,cyFlag,notdeterFlag ;
    char s,t,vertex ;

    set<char>::iterator sIter ;
    vector<char>::iterator vIter ;

    //while( scanf( "%d%d", &n,&m ) && n!= 0 )
    while(cin>>n>>m && n!=0)
    {
        vertexSet.clear() ;  //一定注意使用容器前要clear
        G.clear() ;
        G.resize(N) ;
        string *relation = new string[m] ;
        int indegree[N] = {0} ;
        int tmpIndegree[N]= {0} ;
        char topnum[N] = {0} ;

        sucFlag = false ;
        cyFlag = false ;

        i = 0 ;
        while( i < m )
            cin>>relation[i++] ;

        //对关系数从1~m枚举，每次往图中增加一条边而得到一个新图，对该图拓扑排序以找到符合条件的最小的关系数（边数）
        for( relnum=1 ; relnum<=m ; ++relnum )
        {
            notdeterFlag = false ;  //***每次循环需要将其初始化

            queue<char> Q ;
            for( i=0 ; i<n ; ++i )
                topnum[i] = 0 ;

            //得到此时的图的邻接表，vertexSet中存放的是当前图中的节点
            s = relation[relnum-1][0] ;
            t = relation[relnum-1][2] ;
            vertexSet.insert(s) ;
            vertexSet.insert(t) ;
            G[s-'A'].push_back(t) ;  //更新邻接表
            ++indegree[t-'A'] ;      //更新indegree

            for( i=0 ; i<N ; ++i )
                tmpIndegree[i] = indegree[i] ;  //复制此时的indegree，因为需要改变此数组

            //找到初始时入度为0的vertex
            for( sIter=vertexSet.begin() ; sIter!=vertexSet.end() ; ++sIter )
            {
                if( tmpIndegree[*sIter-'A']==0 )
                    Q.push(*sIter) ;
            }
            //任何时刻当入度为0的vertex多于1个时，则拓扑排序的结果不唯一
            //此时将notdeterFlag置为true表示该暂时图的拓扑结果不唯一
            if( Q.size() > 1 )
                notdeterFlag = true ;

            //循环进行拓扑排序
            cnt = 0 ;
            while( !Q.empty() )
            {
                vertex = Q.front() ;
                Q.pop() ;
                topnum[cnt++] = vertex ;  //分配拓扑排序编号

                //将需要从图中删除的节点的边也删除掉，这意味着它的所有邻接点的入度-1
                for( vIter=G[vertex-'A'].begin() ; vIter!=G[vertex-'A'].end() ; ++vIter )
                {
                    //所有邻接点的入度-1，并将入度减为0的节点入队等待分配拓扑排序编号
                    if( --tmpIndegree[*vIter-'A'] == 0 )
                        Q.push(*vIter) ;
                }
                //任何时刻当入度为0的vertex多于1个时，则拓扑排序的结果不唯一
                if( Q.size() > 1 )
                    notdeterFlag = true ;
            }

            //若该暂时图所有节点还没有全部被排序，就已经找不出入度为0的节点了，则证明该图有环
            //跳出判断循环并输出结果“有环”
            if( cnt!=vertexSet.size() )
            {
                cyFlag = true ;
                break ;
            }

            //若该图已被排序，并且排序结果唯一（由notdeterFlag为false决定）
            //同时被排序的节点数等于完整图中的所有节点的个数
            //跳出判断循环并输出结果“可以唯一地排序”
            if( !notdeterFlag && cnt==n )
            {
                sucFlag = true ;
                break ;
            }
        }
        delete []relation ;

        if( sucFlag )
        {
            printf( "Sorted sequence determined after %d relations: " , relnum );
            for( i=0 ; i<n ; ++i )
                printf( "%c" , topnum[i] ) ;  //输出char用%c
            printf( ".\n" ) ;
        }
        else if( cyFlag )
            printf( "Inconsistency found after %d relations.\n" , relnum ) ;
        else if( notdeterFlag )
            printf( "Sorted sequence cannot be determined.\n" ) ;
    }
}