题目描述

不等式排序

给定$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.。

样例 #1

样例输入 #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\le n\le 26$，变量只可能为大写字母 $A\sim Z$。

算法思想

根据题目描述，有$m$个不等式，每个不等式均为小于关系，问最终能否确定$n$个变量从小到大的次序。例如，每个关系是 $A$ 的成绩排名高于 $B$ 的排名，问最终能否确定班级排名？如下图所示：

在交际网络中，给定若干个元素和若干对二元关系，且关系具有传递性。通过传递性推导出尽量多的元素之间的关系，这类问题被称为传递闭包。

使用「Floyd」算法可以解决传递闭包问题，其基本思想是：

• 建立邻接矩阵$d$，其中
  • $d[i,j]=1$表示$i<j$
  • 除了$i<j$之外的情况，$d[i,j]=0$
• 每输入一对关系时，使用Floyd算法对$d$进行传递闭包：
  • d[i][j] |= d[i][k] & d[k][j]
• 传递闭包完成后，若存在变量$i,j$使得
  • $d[i,j]$和$d[j,i]$均为$1$，则说明题目中给出的$m$个不等式矛盾。
  • $d[i,j]$和$d[j,i]$均为$0$，则说明题目中给出的$m$个不等式不能确定每一对变量之间的大小关系。
• 对于每一对$i,j$，$d[i,j]$和$d[j,i]$有且仅有一个为$1$，则说明能确定每对变量之间的大小关系。

当变量之间的大小关系确定后，如何输出排好序的序列呢？

• 建立一个状态数组$st$，其中
  • $st[i]=0$表示当前变量还未输出
  • $st[i]=1$表示当前变量已经输出
• 从小到大遍历所有尚未输出的变量$i$，即$st[i]=0$，并且对于其它尚未输出的变量$j$，使得$d[j,i]$均为$0$，那么$i$就是尚未输出的最小的变量。

算法时间复杂度

「Floyd」算法解决传递闭包问题的时间复杂度为$O(n^3)$。

代码实现

#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int n, m, d[N][N]; //传递闭包矩阵
bool st[N];
void floyd()
{
    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 = i + 1 ; j < n; j ++)
            if(d[i][j] == 0 && d[j][i] == 0) //双向都无法确定
                return 0;
    return 1;
}
char get_min()
{
    for(int i = 0; i < n; i ++) //从小到大遍历
    {
        if(st[i]) continue; //如果已经输出
        bool flag = true;
        for(int j = 0; j < n; j ++) //枚举其它尚未输出的变量
        {
            if(!st[j] && d[j][i] != 0)
            {
                flag = false;
                break;
            }
        }
        if(flag) 
        {
            st[i] = true;
            return 'A' + i;
        }
    }
}
int main()
{
    
    while(cin >> n >> m, n || m)
    {
        memset(d, 0, sizeof d); //将矩阵初始化为0，表示关系不确定
        int type = 0, p; //type表示当前变量关系是否已经确定，p表示在输入第几个不等式时确定关系的
        for(int i = 1; i <= m; i ++)
        {
            char s[5];
            cin >> s;
            int a = s[0] - 'A', b = s[2] - 'A';
            if(type == 0) //关系尚未确定
            {
                d[a][b] = 1;
                floyd(); //传递闭包
                type = check(); //检查当前所有不等式的关系
                if(type) p = i; //如果关系已确定，或者矛盾
            }
        }
        if(type == 0) puts("Sorted sequence cannot be determined."); 
        else if(type == 2) printf("Inconsistency found after %d relations.\n", p);
        else
        {
            memset(st, 0, sizeof st);
            printf("Sorted sequence determined after %d relations: ", p);
            for(int i = 0; i < n; i ++) printf("%c", get_min()); //每次输出最小的
            printf(".\n");
        }
    }
    return 0;
}