拓扑排序-POJ1094-Sorting It All Out

最新推荐文章于 2021-05-29 22:17:56 发布

静。弦

最新推荐文章于 2021-05-29 22:17:56 发布

阅读量147

点赞数 1

分类专栏：图算法文章标签：拓扑排序 POJ1094

图算法专栏收录该内容

7 篇文章

订阅专栏

博客介绍了在每次读入一对关系后，通过floyd计算传递闭包，判断是否有环（看是否存在map[i][i]=1），若有环则矛盾。无环时判断能否确定关系，计算各点出度与入度和是否为n - 1，若满足则可通过拓扑排序找出唯一关系。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转载于：http://www.cppblog.com/infinity/archive/2008/11/06/66086.html

每次读入一对关后，做一次floyd, 计算传递闭包.
然后判环,其实很简单，就是看有没有点i的map[i][i]=1;
有就证明有环！如果有环就矛盾了。
如果无环再判断是否能确定关系，(注意每次都把出入度数组清零!)计算每个点的出度+入度是否=n-1；
如果所有点都有这个关系，那么唯一的关系就确定了，接下来拓扑排序就能找出这个关系.（找到入度为0的节点，作为起点，然后，以该点为起点，找到与之有通路的其他点（map[i][j]=1)，并将它们的入度-1，重复这个过程）

#include <iostream>
#include <string>
using namespace std;


int n, m, map[27][27], indegree[27], outdegree[27], mem[27], s[27];
int top;
char str[27], buf[10];

int floyd() {
	int i, j, k;
	for (k = 0; k < n; ++k) {
		for (i = 0; i < n; ++i) {
			for (j = 0; j < n; ++j) {
				if (map[i][k] && map[k][j])
                    //如果有环，那么点i必定可以和自己联通
					map[i][j] = 1;
			}
		}
	}
	for (int i = 0; i < n; ++i)
		if (map[i][i])
			return 0;
	return 1;
}

int calc() {
	int i, j;
	memset(indegree, 0, sizeof(indegree));
	memset(outdegree, 0, sizeof(outdegree));
	for (i = 0; i < n; ++i) {
		for (j = 0; j < n; ++j) {
			if (map[i][j]) {
                //统计每个点的出度和入度
				indegree[j]++;
				outdegree[i]++;
			}
		}
	}

	for (i = 0; i < n; ++i) 
		if (indegree[i] + outdegree[i] != n - 1)
			return 0;
	return 1;
}

void toplogical_sort() {
	int i, j = 0;
	top = 0;
	for (i = 0; i < n && top <= 1; ++i) {
        //找到入度为0的点
		if (!indegree[i])
			mem[++top] = i;
	}
	memset(s, 0, sizeof(s));
	while (top) {
		int cnt = mem[top--];
		s[cnt] = 1;
		str[j++] = cnt + 'A';
		for (int i = 0; i < n; ++i) {
            //上一个点的联通点，入度减1
			if (!s[i] && map[cnt][i])
				indegree[i]--;
			if (i != cnt && !s[i] && indegree[i] == 0)
				mem[++top] = i;
		}
	}
	str[j] = '\0';
}
int main() {
	
	while (cin >> n >> m && (m + n)) {
		memset(map, 0, sizeof(map));
		int i, flag1 = 0, flag2 = 0;
		for (i = 1; i <= m; ++i) {
			cin >> buf;
			map[buf[0] - 'A'][buf[2] - 'A'] = 1;
			if (flag1 || flag2)
				continue;
			else if (!floyd()) {
				flag1 = i;
				continue;
			}
			else if (calc()) {
				toplogical_sort();
				flag2 = i;
			}
		}
		if (flag1) 
			printf("Inconsistency found after %d relations.\n", flag1);
		else if (flag2) 
			printf("Sorted sequence determined after %d relations: %s.\n", flag2, str);
		else 
			printf("Sorted sequence cannot be determined.\n");
	}
	system("pause");
	return 0;
}