Floyd判联通(传递闭包) & poj1049 sorting it all out

Floyd判联通(传递闭包)

Floyd传递闭包顾名思义就是把判最短路的代码替换成了判是否连通的代码，它可以用来判断图中两点是否连通。板子大概是这个样的：

for(int k=1; k<=n; k++){
	for(int i=1; i<=n; i++){
		for(int j=1; j<=n; j++){
			// 把数值计算替换成逻辑运算——就一行，非常简便
			e[i][j] = e[i][j] || (e[i][k] && e[k][j]);
		}
	}
}

---

题目描述

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

---

那么我们可以分析题目：题目说要“从前往后遍历每对关系” 那么就不是一次性导入所有数据了，而是每输入一个就计算一遍。

graph TB
Begin(开始) --> A[输入不等式]
A -->E{是否存在矛盾}
E -->|存在|B[输出矛盾信息]
E -->|不存在|C
C{是否能确定两两关系}
C -->|能确定|D[输出升序排列]
C -->|不能确定|A
F{全部不等式输入完成且未发生以上情况} -->G[输出]
A -->F

那么怎么判断是否存在矛盾呢？想想看，不就是既有\(A>B\) 又有\(B>A\)吗。那么就可以在floyd的同时加入判断。

for(int k=1; k<=n; k++){
	for(int i=1; i<=n; i++){
		for(int j=1; j<=n; j++){
			e[i][j] = e[i][j] || (e[i][k] && e[k][j]);
			// 注意要i!=j
			// 如果e[i][j]和e[j][i]都联通肯定存在矛盾
			if(e[i][j] && e[j][i] && i!=j){
				data = 0;
			}
		}
	}
}

那怎么判断能否确定两两关系呢？那就是在没有矛盾的前提下，两两首尾相连。如果存在两个点没有首尾相连的情况，那肯定不行的。我这里把判断它的代码单独拿了出来放在一个函数里，因为如果在floyd中写的话它是会变化的，可能在某次循环时它不连通，但循环几次后它又联通了。所以还不如拿出去.

bool check(){
	for(int i=1; i<=n; i++){
		for(int j=1; j<=n; j++){
			if(!e[i][j] && !e[j][i] && i!=j) return 0;
		}
	}
	return 1;
}

可以判断两两关系了，那怎么打印出次序呢？我在某个大佬那里受到启发——观察矩阵。试想一下，如果\(A<B<C<D\)，那么A联通的点有3个，B联通的点有2个，C联通的点有…… 也就是这个样子的:

A[1][n] 0 1 1 1
B[2][n] 0 0 1 1
C[3][n] 0 0 0 1
D[4][n] 0 0 0 0

那么就只用依次取出“1”最多的打印出来就好。

inline void out(){
	// #define p pair<int, char>
	priority_queue<p, vector<p>, less<p> > q;
	int t;
	for(int i=1; i<=n; i++){
		t = 0;
		for(int j=1; j<=n; j++){
			if(i != j) t += e[i][j];
		}
		q.push( (p){t, i-1+'A'} );
	}
	while(!q.empty()){
		printf("%c",q.top().second);
		q.pop();
	}
	printf(".\n");
}

这道题个人感觉非常nice，他开拓了我们的新思路：观察矩阵(找规律)。好了，以上是我的全部理解。博客freshman，如有错误，还请指点！

AC代码：仅供参考

点击查看代码

#include<bits/stdc++.h>
using namespace std;
#define p pair<int, char>
int n,m,data;
bool e[27][27],node[27];
string s;
inline void floyd(){
	for(int k=1; k<=n; k++){
		for(int i=1; i<=n; i++){
			for(int j=1; j<=n; j++){
				e[i][j] = e[i][j] || (e[i][k] && e[k][j]);
				if(e[i][j] && e[j][i] && i!=j){
					data = 0;
				}
			}
		}
	}
}
bool check(){
	for(int i=1; i<=n; i++){
		for(int j=1; j<=n; j++){
			if(!e[i][j] && !e[j][i] && i!=j) return 0;
		}
	}
	return 1;
}
inline void out(){
	priority_queue<p, vector<p>, less<p> > q;
	int t;
	for(int i=1; i<=n; i++){
		t = 0;
		for(int j=1; j<=n; j++){
			if(i != j) t += e[i][j];
		}
		q.push( (p){t, i-1+'A'} );
	}
	while(!q.empty()){
		printf("%c",q.top().second);
		q.pop();
	}
	printf(".\n");
}
int main(){
	while(scanf("%d%d",&n,&m) && n){
		memset(e, 0, sizeof(e));
		memset(node, 0, sizeof(node));
		data = 1;
		for(int i=1; i<=m; i++){
			cin>>s;
			e[s[0]-'A'+1][s[2]-'A'+1] = 1;
			node[s[0]-'A'+1] = node[s[2]-'A'+1] = 1;
			if(data == 1){
				floyd();
				if(data == 0){
					printf("Inconsistency found after %d relations.\n",i);
					//break;
				}
				else if(check()){
					printf("Sorted sequence determined after %d relations: ",i);
					out();
					data = 2;
					//break;
				}
			}
		}
		if(data == 1){
			printf("Sorted sequence cannot be determined.\n");
		}
	}
}