POJ 1094 Sorting It All Out

Sorting It All Out

【题目链接】http://poj.org/problem?id=1094

【解题思路】Floyd判环+拓扑排序；当Floy[i][i] = true 的时候就说明图中有环，拓扑排序在原图中找到路径，其实也没什么好说的，都是赤裸裸的图算法的运用，坑点的就是不知道A<B B<A这种情况是属于那种输出

【随笔】这题虽然简单，但是很久没写过拓扑，不敢确定在提交WA之后不是算法出了错误，所以一直在找错误，后来的情况确实是这样，算法并没有错二十输入的时候没考虑到情况，我是用了Floyd判环后得图用作拓扑排序，统计节点的入度的时候重复计算了节点的入度，没有考虑到的情况是在输入时的两点连通的情况在判环的时候可能已有统计，所以有重复的边计算出来的入度比正确情况下的大，所以拓扑不出来，WA了不少

#include <iostream>
#include <cstring>
#include <cstdio>
#define SIZE 27
using namespace std;

bool alpha[SIZE][SIZE];
int num[SIZE], copynum[SIZE];
int path[SIZE], visit[SIZE];
int nv, ne;

bool Floyd()
{
    for(int k=0; k<nv; ++k)
    for(int i=0; i<nv; ++i)
    for(int j=0; j<nv; ++j)
    {
        if(alpha[i][j] || (alpha[i][k] && alpha[k][j]))
        {
            if(!alpha[i][j] && i != j) num[j]++;
            if(i == j) return true;
            alpha[i][j] = true;
        }
    }
    return false;
}

bool DFS(int cur, int sum)
{
    if(cur == -1)
    {
        int cnt = 0;
        for(int i=0; i<nv; ++i) if(num[i] == 0)
        {
            if(cnt == 0) cnt++;
            else return false;
            cur = i;
        }
        if(cnt == 0) return false;
       memcpy(copynum, num, sizeof(num));
    }
    path[sum] = cur;
    if(sum  == nv - 1) return true;
    for(int i=0; i<nv; ++i) if(alpha[cur][i] && cur != i) copynum[i]--;
    int cnt = 0, next = -1 ;
    for(int i=0; i<nv; ++i) if(alpha[cur][i] && cur != i && copynum[i] == 0)
    {
        if(cnt == 0) cnt++;
        else return false;
        next = i;
    }
    if(next != -1 && DFS(next, sum+1)) return true;
    return false;

}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("F:\test\input.txt", "r", stdin);
    #endif
    while(cin >> nv >> ne, nv + ne)
    {
        for(int i=0; i<nv; ++i)
        for(int j=i; j<nv; ++j)
        {
            num[i] = 0;
            alpha[i][j] = alpha[j][i] = false;
        }
        int flag = -1, where = -1;
        char u, v, op;
        for(int i=0; i<ne; ++i)
        {
            cin >> u >> op >> v;
            if(flag != -1) continue;
            if(alpha[u-'A'][v-'A'] != true) num[v-'A']++;
            alpha[u-'A'][v-'A'] = true;

            if(Floyd()) flag = 0, where = i+1;
            else if(DFS(-1, 0)) flag = 1, where = i+1;
        }
        if(flag == -1)
            cout << "Sorted sequence cannot be determined." << endl;
        else if(flag == 0)
            cout << "Inconsistency found after "<< where << " relations." << endl;
        else
        {
            cout << "Sorted sequence determined after " << where << " relations: ";
            for(int i=0; i<nv; ++i)
            {
                char temp = path[i] + 'A';
                cout << temp;
            }
            cout << "." << endl;
        }



    }
    return 0;
}