【NOI 2015】程序自动分析（水题：并查集）

第 32 届全国信息学奥林匹克竞赛 第一试 程序自动分析

程序自动分析

【问题描述】

在实现程序自动分析的过程中，常常需要判定一些约束条件是否能被同时满

足。

考虑一个约束满足问题的简化版本：假设 ?1, ?2, ?3, ⋯ 代表程序中出现的变

量，给定 ? 个形如 ?? = ?? 或 ?? ≠ ?? 的变量相等/不等的约束条件，请判定是否

可以分别为每一个变量赋予恰当的值，使得上述所有约束条件同时被满足。例如，

一个问题中的约束条件为： ?1 = ?2, ?2 = ?3, ?3 = ?4, ?1 ≠ ?4 ，这些约束条件显

然是不可能同时被满足的，因此这个问题应判定为不可被满足。

现在给出一些约束满足问题，请分别对它们进行判定。

【输入格式】

从文件 prog.in 中读入数据。

输入文件的第 1 行包含 1 个正整数 ? ，表示需要判定的问题个数。注意这些

问题之间是相互独立的。

对于每个问题，包含若干行：

第 1 行包含 1 个正整数 ? ，表示该问题中需要被满足的约束条件个数。

接下来 ? 行，每行包括 3 个整数 ?,?, ? ，描述 1 个相等/不等的约束条件，相

邻整数之间用单个空格隔开。若 ? = 1 ，则该约束条件为 ?? = ?? ；若 ? = 0 ，

则该约束条件为 ?? ≠ ?? ；

【输出格式】

输出到文件 prog.out 中。

输出文件包括 ? 行。

输出文件的第 ? 行输出一个字符串“YES”或者“NO”（不包含引号，字母

全部大写），“YES”表示输入中的第 ? 个问题判定为可以被满足，“NO”表示不

可被满足。

【样例输入 1】

2

2

1 2 1

1 2 0

2

1 2 1

2 1 1

第 32 届全国信息学奥林匹克竞赛 第一试 程序自动分析

第 3 页 共 10 页

【样例输出 1】

NO

YES

【样例说明 1】

在第一个问题中，约束条件为： ?1 = ?2, ?1 ≠ ?2 。这两个约束条件互相矛

盾，因此不可被同时满足。

在第二个问题中，约束条件为： ?1 = ?2, ?2 = ?1 。这两个约束条件是等价

的，可以被同时满足。

【样例输入 2】

2

3

1 2 1

2 3 1

3 1 1

4

1 2 1

2 3 1

3 4 1

1 4 0

【样例输出 2】

YES

NO

【样例说明 2】

在第一个问题中，约束条件有三个：?1 = ?2, ?2 = ?3, ?3 = ?1 。只需赋值使

得 ?1 = ?2 = ?3 ，即可同时满足所有的约束条件。

在第二个问题中，约束条件有四个： ?1 = ?2, ?2 = ?3, ?3 = ?4, ?1 ≠ ?4 。由

前三个约束条件可以推出 ?1 = ?2 = ?3 = ?4 ，然而最后一个约束条件却要求

?1 ≠ ?4 ，因此不可被满足。

【样例输入输出 3】

见选手目录下的 prog/prog.in 与 prog/prog.ans。

第 32 届全国信息学奥林匹克竞赛 第一试 程序自动分析

第 4 页 共 10 页

【数据规模与约定】

所有测试数据的范围和特点如下表所示

测试点编号 ? 的规模 ?,? 的规模 约定

1 1 ≤ ? ≤ 10

1 ≤ ?,? ≤ 10,000

1 ≤ ? ≤ 10

? ∈ {0,1}

2

3 1 ≤ ? ≤ 100 4

5

6 1 ≤ ? ≤ 100,000

7

8

9 1 ≤ ? ≤ 100,000 1 ≤ ?,? ≤ 1,000,000,000

10

【解题思路】

    先考虑所有“相等”类型的约束条件。相等关系有传递性，将所有相等的变量加 入同一个集合。再考虑所有“不相等”类型的约束条件，若有两个不相等的变量在同 一个集合中，则NO。若所有不相等变量都不在同一个集合，则YES。

PS：变量的编号需要离散化

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int a[N], b[N], e[N], fa[N], tmp[2 * N], n;
int get(int x) {
	return x == fa[x] ? x : fa[x] = get(fa[x]);
}
int main() {
	int t;
	scanf("%d", &t);
	while (t--) {
		int m;
		scanf("%d", &m);
		for (int i = 1; i <= m; ++i) {
			scanf("%d%d%d", &a[i], &b[i], &e[i]);
			tmp[2 * i - 1] = a[i];
			tmp[2 * i] = b[i];
		}
		sort(tmp + 1, tmp + 1 + 2 * m);
		n = unique(tmp + 1, tmp + 1 + 2 * m) - tmp - 1;
		for (int i = 1; i <= m; ++i) {
			a[i] = lower_bound(tmp + 1, tmp + 1 + n, a[i]) - tmp;
			b[i] = lower_bound(tmp + 1, tmp + 1 + n, b[i]) - tmp;
		}
		for (int i = 1; i <= n; ++i)
			fa[i] = i;
		for (int i = 1; i <= m; ++i)
			if (e[i] == 1) {
				fa[get(a[i])] = get(b[i]);
			}
		bool flag = true;
		for (int i = 1; i <= m; ++i)
			if (e[i] == 0) {
				if (get(a[i]) == get(b[i])) {
					flag = false;
					break;
			}
		}
		if (flag) puts("YES");
		else puts("NO");
	}
	return 0;
}