poj1094 Sorting It All Out【floyd】【传递闭包】【拓扑序】

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions:39731		Accepted: 13975

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.

Source

East Central North America 2001

题意：

给定关于n个字母的对应优先级关系，问是否可以根据优先级对他们进行排序。并且要求输出是在第几组可以得出结果。

会有优先级不一致和无法排序的情况。

思路：

感觉这题数据很迷啊，m的范围都不给我都不好估计复杂度。

以及，要注意输出时候的句号。特别是可以sort的时候。

是一道传递闭包的问题，用邻接矩阵建图，如果$A<B$，则表示$A$到$B$有一条有向边，$g['A']['B'] = 1$

每次添加一个关系，使用一次floyd计算能否得出结果，或者是否出现不一致。

输出排序结果的时候，其实只需要比较每个点的入度，按照入度从大到小排序就行了。

因为最后的矩阵是一个传递闭包，最小的那个字母肯定小于其他所有字母，也就是说他这一行会有$n-1$个$1$

#include<iostream>
//#include<bits/stdc++.h>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#include<set>
#include<climits>
using namespace std;
typedef long long LL;
#define N 100010
#define pi 3.1415926535
#define inf 0x3f3f3f3f

int n, m;
int g[30][30], tmpg[30][30];

int floyd()
{
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            tmpg[i][j] = g[i][j];
        }
    }
    for(int k = 0; k < n; k++){
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                tmpg[i][j] |= tmpg[i][k] & tmpg[k][j];
                if(tmpg[i][j] == tmpg[j][i] && tmpg[i][j] == 1 && i != j){
                    return -1;
                }
            }
        }
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(tmpg[i][j] == tmpg[j][i] && tmpg[i][j] == 0 && i != j){
                return 0;
            }
        }
    }
    return 1;
}

struct node{
    int deg;
    char ch;
};
bool cmp(node a, node b)
{
    return a.deg > b.deg;
}

void print()
{
    //int deg[30];
    //memset(deg, 0, sizeof(deg));
    node character[30];
    for(int i = 0; i < n; i++){
        character[i].deg = 0;
        character[i].ch = 'A' + i;
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(tmpg[i][j]){
                character[i].deg++;
            }
        }
    }
    sort(character, character + n, cmp);
    for(int i = 0; i < n; i++){
        printf("%c", character[i].ch);
    }
    printf(".
");

    /*queue<int>que;
    for(int i = 0; i < n; i++){
        printf("%d
", deg[i]);
        if(!deg[i]){
            que.push(i);
            break;
        }
    }
    for(int i = 0; i < n; i++){
        int x = que.front();que.pop();
        printf("%c", x + 'A');
        for(int k = 0; k < n; k++){
            if(tmpg[k][x])deg[k]--;
            if(!deg[k])que.push(k);
        }
    }*/
}

int main()
{
    while(scanf("%d%d", &n, &m) != EOF && n || m){
        memset(g, 0, sizeof(g));
        /*for(int i = 0; i < n; i++){
            g[i][i] = 1;
        }*/

        int i;
        bool dont = false;
        for(i = 1; i <= m; i++){
            char a, b;
            getchar();
            scanf("%c<%c", &a, &b);
            g[a - 'A'][b - 'A'] = 1;
            if(!dont){
                 int flag = floyd();
                if(flag == -1){
                    printf("Inconsistency found after %d relations.
", i);
                    dont = true;
                }
                else if(flag == 1){
                    printf("Sorted sequence determined after %d relations: ", i);
                    print();
                    dont = true;
                }
            }
        }
        if(i > m && !dont){
            printf("Sorted sequence cannot be determined.
");
        }
    }
    return 0;
}