AcWing343.排序（floyd传递闭包）

题目：https://www.acwing.com/problem/content/345/

给定 n 个变量和 m 个不等式。其中 n 小于等于26，变量分别用前 n 的大写英文字母表示。

不等式之间具有传递性，即若 A>B 且 B>C ，则 A>C。

请从前往后遍历每对关系，每次遍历时判断：

• 如果能够确定全部关系且无矛盾，则结束循环，输出确定的次序；
• 如果发生矛盾，则结束循环，输出有矛盾；
• 如果循环结束时没有发生上述两种情况，则输出无定解。

输入格式

输入包含多组测试数据。

每组测试数据，第一行包含两个整数n和m。

接下来m行，每行包含一个不等式，不等式全部为小于关系。

当输入一行0 0时，表示输入终止。

输出格式

每组数据输出一个占一行的结果。

结果可能为下列三种之一：

1. 如果可以确定两两之间的关系，则输出 "Sorted sequence determined after t relations: yyy...y.",其中't'指迭代次数，'yyy...y'是指升序排列的所有变量。
2. 如果有矛盾，则输出： "Inconsistency found after t relations."，其中't'指迭代次数。
3. 如果没有矛盾，且不能确定两两之间的关系，则输出 "Sorted sequence cannot be determined."。

数据范围

2≤n≤26，变量只可能为大写字母A~Z。

输入样例1：

4 6
A

输出样例1：

Sorted sequence determined after 4 relations: ABCD.
Inconsistency found after 2 relations.
Sorted sequence cannot be determined.

输入样例2：

6 6
A

输出样例2：

Inconsistency found after 6 relations.

输入样例3：

5 5
A

输出样例3：

Sorted sequence determined after 4 relations: ABCDE.

 题解：这是个标准的传递闭包问题，我们可以使用floyd解决，若存在矛盾，则存在某个d[i][i]会有边，若还有关系还未确立，则存在d[i][j]和d[j][i]都为0的情况，最后只需要注意一下输出关系的优先级就行，存在矛盾的话就输出，然后才是还有未确立的关系。

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast","inline")
#include
using namespace std;
#define ll long long 
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
#define Mst(a,b) memset(a,b,sizeof(a))
#define fir first
#define se second
#define PII pair 
#define lowbit(x) x&-x
const int N = 30;
int n,m,e[N][N],d[N][N];
bool st[N];
void floyd() {
    memcpy(d,e,sizeof(e));
    rep(k,0,n-1) {
      rep(i,0,n-1) {
        rep(j,0,n-1) {
            d[i][j] |= d[i][k] & d[k][j];
         }
      }
    }
}
int check() {
    rep(i,0,n-1) if(d[i][i]) return 0;
    rep(i,0,n-1) {
        rep(j,0,i-1) {
            if(!d[i][j] && !d[j][i]) return 1;
        }
    }
    return 2;
}
char getans() {
    bool flag = true;
    rep(i,0,n-1) {
        flag = true;
        if(!st[i]) {
            rep(j,0,n-1) {
              if(st[j]) continue;
                if(d[j][i]) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                st[i] = true;
                return (char)(i + 'A');
            }
        }
    }
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    while(cin >> n >> m && (n || m)) {
        Mst(e,0);Mst(st,0);
        int type = 1,t;
        rep(i,1,m) {
            string str;
            cin >> str;
            int a = str[0]-'A',b = str[2] - 'A';
            e[a][b] = 1;
            if(type == 1) {
                 t = i;
                 floyd();
               type = check();
            }
        }
        if(type == 0) cout << "Inconsistency found after "<< t << " relations." << endl;
        else if(type == 1) cout << "Sorted sequence cannot be determined." << endl;
        else {
            cout << "Sorted sequence determined after "<< t << " relations: ";
            rep(i,0,n-1) cout << getans();
            cout << "." << endl;
        }
    }
    return 0;
}