P1347 排序（拓扑序列 / Floyd传递闭包）

洛谷：排序

一眼看题，可以发现数据很小，暴力操作基本都被允许（所以就放松了警戒…）

结果卡题意上了：

“在这道题中，我们将给你一系列形如 A<B 的关系，并要求你判断是否能够根据这些关系确定这个数列的顺序。”

“若根据前 x 个关系即可确定这 n 个元素的顺序”

它这里的确定顺序，是

严格确定、严格确定、严格确定

重要的事说三遍，即

任意两个元素之间的大小关系都要被确定

你如果有多个入度为0的点，或者多个出度为0的点，这些点彼此之间都是没有联系的，也就是关系没有确定。加上此题的另一个限制条件：关系不能矛盾 == 无自环

所以这道题实际上是求：

在一个除去了自环的图上（拓扑图），求一条链，这条链上要包含所有的n个点

又由我们之前说的此题数据很小，所以求 是否存在自环 和 是否存在此链，都可以在随着加边随时判断。

1. 存在自环肯定优先级拉满 == 发现矛盾

2. 除此，存在链 == 发现一种顺序，根据提示：确定 n 个元素的顺序后即可结束程序，可以不用考虑确定顺序之后出现矛盾的情况

3. 最后的情况就是根据给的关系无法确定顺序了

拓扑解法：

代码 + 注释（好习惯）如下：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define cout_double(a) cout << setiosflags(ios::fixed) << setprecision(a)
#define sca scanf
#define pri printf
#define ul u << 1
#define ur u << 1 | 1
//#pragma GCC optimize(2)
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;

const int N = 30, M = 1010;
int INF = 0x3f3f3f3f, mod = 1e9 + 7;
ll LNF = 1e18;
int n, m, k, T, S;
int h[N], ne[M], e[M], idx;
int ru[N], tmp[N], cnt[N];//cnt计数，判断这个拓扑是否有一条链，链上包含所有点
int z[N];//若存在，记录答案

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

bool dfs(int x, int t) { //判断是否存在自环
    if (x == t)return true;

    bool f = false;
    for (int i = h[x]; ~i; i = ne[i]) {
        int j = e[i];
        f |= dfs(j, t);
        if (f)return f;
    }
    return f;
}

int top_sort() {
    mem(cnt, 0);//重置
    memcpy(tmp, ru, sizeof tmp);//复制一下
    k = 0;//重置

    queue<int> q;
    for (int i = 0; i < n; i++)
        if (tmp[i] == 0) { //注意，以一个点作为起点，判断链是否存在
            //如果有多个入度为 0 的点，这些点彼此之间的关系无法判定
            q.push(i);
            cnt[i] = 1;//记录点数
            break;
        }

    int mx = 1;
    while (q.size())
    {
        int t = q.front();
        q.pop();

        z[k++] = t;//记录可能的一种顺序

        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];

            cnt[j] = max(cnt[j], cnt[t] + 1);//维护一个最大点数
            mx = max(mx, cnt[j]);//这样 mx 就代表这条链上最多的点数是多少

            tmp[j]--;
            if (!tmp[j]) 
                q.push(j);
        }
    }
    return mx;
}

int main() {

    cin >> n >> m;
    mem(h, -1);

    char s[10];
    for (int i = 1; i <= m; i++)
    {
        sca("%s", s);
        int a = s[0] - 'A', b = s[2] - 'A';

        if (s[1] == '<') { //转化成路径
            add(a, b);
            ru[b]++;

            if (dfs(b, a)) { //随时判断是否为自环，即判断 b 点能否走回 a
                pri("Inconsistency found after %d relations.", i);
                return 0;
            }
        }
        else {
            add(b, a);
            ru[a]++;

            if (dfs(a, b)) { //亦同
                pri("Inconsistency found after %d relations.", i);
                return 0;
            }
        }

        if (top_sort() == n) { //这条链包含n个点才能证明找到了一种顺序
            pri("Sorted sequence determined after %d relations: ", i);
            for (int i = 0; i < k; i++)
                pri("%c", z[i] + 'A');
            pri(".");//最后有个点别漏了
            return 0;
        }
    }

    pri("Sorted sequence cannot be determined.");
    //除此之外的所有情况都是信息不足

    return 0;
}

Floyd传递闭包：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define sca scanf
#define pri printf
#define ul u << 1
#define ur u << 1 | 1
//#pragma GCC optimize(2)
//[博客地址](https://blog.csdn.net/weixin_51797626?t=1) 
using namespace std;

typedef long long ll;
typedef pair<int, pair<int, int>> PII;

const int N = 26, M = 10010, MM = 3000010;
int INF = 0x3f3f3f3f, mod = 100003;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S, D;
int w[N][N], d[N][N];
bool st[N];

int floyd() {
	memcpy(d, w, 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];
	//传递闭包，如果i到k、k到j的路径能确定存在，显然i到j这条路径也能确定存在

	//每连一条边就处理信息

	for (int i = 0; i < n; i++)
		if (d[i][i])return 1;//一旦到自己拥有自环，显然是传递回来了
			
	for (int i = 0; i < n; i++)
		for (int j = 0; j < i; j++)
			if (!d[i][j] && !d[j][i])return 0;//还有关系未确认

	return 2;//否则才能算全部排序完成
}

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]) { 
					//一旦该点未被确定顺序，且与 i 有边，i 肯定不是起点
					flag = false;
					break;
				}
			if (flag) {//任意一个点都于 i 不相连，i 肯定是起点
				st[i] = true;
				return i + 'A';
			}
		}
}

int main() {

	char s[5];
	while (~sca("%d%d", &n, &m), n, m)
	{
		int flag = 0, t = 0;
		mem(w, 0);
		
		for (int i = 1; i <= m; i++)
		{
			sca("%s", s);
			
			int a = s[0] - 'A', b = s[2] - 'A';

			if (!flag) {
				w[a][b] = 1;//连一条关系即可
				flag = floyd();
				if (flag)t = i;
			}
		}

		if (!flag)pri("Sorted sequence cannot be determined.\n");
		else if (flag == 1)pri("Inconsistency found after %d relations.\n", t);
		else {
			mem(st, 0);
			pri("Sorted sequence determined after %d relations: ", t);
			for (int i = 0; i < n; i++)pri("%c", get_min());
			puts(".");
		}
	}

    return 0;
}