排序 floyd 拓扑排序

// 排序.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

/*
* https://www.acwing.com/problem/content/345/
给定 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。

4 6
D<B
D<A
D<C
C<A
C<B
A<B

Sorted sequence determined after 6 relations: DCAB.
输入样例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.
*/


#include <iostream>
#include <algorithm>
#include <cstring>
#include <map>
#include <queue>

using  namespace std;


int n, m;
const int N = 30;
int g[N][N];
int dict[N];
int cnt;


int check(int x) {
	for (int k = 0; k < n; k++) {
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
				if (i == j && g[i][j] != 0x3f3f3f3f) {
					return -1;
				}
			}
		}
	}

	if (cnt == n) {	
		string ret;
		int degree[N]; memset(degree, 0, sizeof degree);
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				if (g[i][j] != 0x3f3f3f3f) {
					degree[j]++;
				}
			}
		}
		queue<int> q;
		for (int i = 0; i < n; i++) {
			if (degree[i] == 0) { q.push(i); }
		}
		if (q.size() > 1) return 0;

		while (!q.empty()) {
			int curr = q.front(); q.pop();
			ret += curr + 'A';
			for (int i = 0; i < n; i++) {
				if (g[curr][i] != 0 && degree[i] != 0) {
					degree[i]--;
					if (degree[i] == 0) {
						q.push(i);
					}
				}
			}
			if (q.size() > 1) return 0;
		}

		printf("Sorted sequence determined after %d relations: %s.\n", x, ret.c_str());
		return 1;
	}

	return 0;
}

//string sort() {
//	string ret;
//	int degree[N]; memset(degree, 0, sizeof degree);
//	for (int i = 0; i < n; i++) {
//		for (int j = 0; j < n; j++) {
//			if (g[i][j] != 0x3f3f3f3f) {
//				degree[j]++;
//			}
//		}
//	}
//	queue<int> q; 
//	for (int i = 0; i < n; i++) {
//		if (degree[i] == 0) { q.push(i); }
//	}
//
//	while (!q.empty()) {
//		int curr = q.front(); q.pop();
//		ret += curr + 'A';
//		for (int i = 0; i < n; i++) {
//			if (g[curr][i] != 0 && degree[i] !=0) {
//				degree[i]--;
//				if (degree[i] == 0) {
//					q.push(i);
//				}
//			}
//		}
//	}
//	 
//	return ret;
//}

void solve() {
	vector<string> v;
	for (int i = 1; i <= m; i++) {
		string t; cin >> t;
		v.push_back(t);
	}

	for (int i = 1; i <= m; i++) {
		string str = v[i-1];
		int a = str[0] - 'A';
		int b = str[2] - 'A';
		g[a][b] = 1;
		if (dict[a] == 0) {
			dict[a] += 1; cnt += 1;
		}
		if (dict[b] == 0) {
			dict[b] += 1; cnt += 1;
		}
		int res = check(i);
		if (1 == res) {
			return;
		}
		else if (-1 == res) {
			printf("Inconsistency found after %d relations.\n", i);
			return;
		}
	}

	cout << "Sorted sequence cannot be determined." << endl;
	return;
}

int main()
{
	while (cin >> n >> m) {
		if (n == 0 && m == 0) break;
		memset(g, 0x3f, sizeof g);
		memset(dict, 0, sizeof dict);
		cnt = 0;
		solve();
	}


	return 0;
}