排序

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

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

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

如果能够确定全部关系且无矛盾，则结束循环，输出确定的次序；
如果发生矛盾，则结束循环，输出有矛盾；
如果循环结束时没有发生上述两种情况，则输出无定解。
输入格式
输入包含多组测试数据。

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

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

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

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

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

如果可以确定两两之间的关系，则输出 “Sorted sequence determined after t relations: yyy…y.”,其中’t’指迭代次数，'yyy…y’是指升序排列的所有变量。
如果有矛盾，则输出： “Inconsistency found after t relations.”，其中’t’指迭代次数。
如果没有矛盾，且不能确定两两之间的关系，则输出 “Sorted sequence cannot be determined.”。
数据范围
2≤n≤26，变量只可能为大写字母A~Z。

输入样例1：
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
输出样例1：
Sorted sequence determined after 4 relations: ABCD.
Inconsistency found after 2 relations.
Sorted sequence cannot be determined.
输入样例2：
6 6
A<F
B<D
C<E
F<D
D<E
E<F
0 0
输出样例2：
Inconsistency found after 6 relations.
输入样例3：
5 5
A<B
B<C
C<D
D<E
E<A
0 0
输出样例3：
Sorted sequence determined after 4 relations: ABCDE

题解：

传递闭包的问题，因为只有26个字母所以直接用floyd了，f[i][j]表示i小于j的话连一个权值为1 的边。所以如果我们出现矛盾那么f[i][i]=1，对于不能判断的情况，那么只要出现了一对点对f[i][j]和f[j][i]都等于0那么他们关系就是没办法确定的。当我们能确定关系的时候因为要从小到达输出，所以我们gei_min函数每次找出最小的数标记并输出。

#include <bits/stdc++.h>
using namespace std;
const int N = 26;
int n, m;
bool g[N][N], d[N][N];
bool st[N];
void floyd()
{
    memcpy(d, g, sizeof d);

    for (int k = 0; k < n; k ++ )
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < n; j ++ )
                d[i][j] |= d[i][k] && d[k][j];
}
int check()
{
    for (int i = 0; i < n; i ++ )
        if (d[i][i])
            return 2;

    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < i; j ++ )
            if (!d[i][j] && !d[j][i])
                return 0;

    return 1;
}
char get_min()
{
    for (int i = 0; i < n; i ++ )
        if (!st[i]) {
            bool flag = true;
            for (int j = 0; j < n; j ++ )
                if (!st[j] && d[j][i]) {
                    flag = false;
                    break;
                }
            if (flag) {
                st[i] = true;
                return 'A' + i;
            }
        }
}
int main()
{
    while (cin >> n >> m, n || m){
        memset(g, 0, sizeof g);
        int type = 0, t;
        for (int i = 1; i <= m; i ++ ) {
            char str[5];
            cin >> str;
            int a = str[0] - 'A', b = str[2] - 'A';
            if (!type) {
                g[a][b] = 1;
                floyd();
                type = check();
                if (type) t = i;
            }
        }
        if (!type) puts("Sorted sequence cannot be determined.");
        else if (type == 2) printf("Inconsistency found after %d relations.\n", t);
        else {
            memset(st, 0, sizeof st);
            printf("Sorted sequence determined after %d relations: ", t);
            for (int i = 0; i < n; i ++ ) printf("%c", get_min());
            printf(".\n");
        }
    }
    return 0;
}

来源：CSDN

作者：行走天涯的豆沙包

链接：https://blog.csdn.net/weixin_42979819/article/details/104066344

标签

int函数

闭包

floyd——排序（传递闭包）

排序

题解：