「学习笔记」2-SAT问题

SAT 是适定性 (Satisfiability) 问题的简称。一般形式为 k - 适定性问题，简称 k-SAT。而当 $k>2$ 时该问题为 NP 完全的。所以我们只研究 $k=2$ 的情况。
2-SAT，简单的说就是给出 $n$ 个集合，每个集合有两个元素，已知若干个 $<a,b>$，表示 $a$ 与 $b$ 矛盾（其中 $a$ 与 $b$ 属于不同的集合）。然后从每个集合选择一个元素，判断能否一共选 $n$ 个两两不矛盾的元素。显然可能有多种选择方案，一般题中只需要求出一种即可。

建图#

我们将 $n$ 个集合拆成两个点，分别代表着 true 和 false.
当 a || b == true 时，我们可以得知：
a == false 时，b = true；
b == false 时，a = true;
这两个关系存在因果关系；
而 a == true 时，我们不能得知 b = true 还是 b = false，这两者之间不存在因果关系，b == true 同理。
因此，我们将 $a_0$ 向 $b_1$ 连边，将 $b_0$ 向 $a_1$ 连边。

含义：
当 a == false 时，b = true；
当 b == false 时，a = true。

当 a && b == false 时，我们可以得知：
a == true 时，b = false;
b == true 时，a = false;
我们将 $a_1$ 向 $b_0$ 连边，将 $b_1$ 向 $a_0$ 连边。

含义：
当 a == true 时，b = false;
当 b == true 时，a = false。

当 a && b == true 时，我们发现，a == true，b == true，除了这种情况不会再有其他情况了，即 $a$ 的值一定为 true，$b$ 的值一定为 true。
这种情况下，我们将 $a_0$ 向 $a_1$ 连边，$b_0$ 向 $b_1$ 连边。

含义：
当 a == false 时，a = true;（即 $a$ 一定不为 false）
当 b == false 时，b = true。(即 $b$ 一定不为 true)

判断是否有解#

如果 $a_0$ 可以到达 $a_1$，说明 $a$ 一定为 true；
如果 $a_1$ 可以到达 $a_0$，说明 $a$ 一定为 false。
判断是否有解即在一种情况中 $a$ 都有唯一确定的值，要么为 true，要么为 false，倘若在同一种情况中，$a_0$ 可以到达 $a_1$， $a_1$ 可以到达 $a_0$，则无法确定 $a$ 的值，此情况下无解，即 $a_0$ 与 $a_1$ 在同一个强连通分量里。
用 tarjan 算法来找强连通分量即可。

题目#

P4782 【模板】2-SAT 问题

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int N = 1e6 + 5;

int n, m, tim, scc;
vector<int> son[N << 1], sta;
int dfn[N << 1], low[N << 1], lt[N << 1];

void tarjan(int u) {
	dfn[u] = low[u] = ++ tim;
	sta.push_back(u);
	for (int v : son[u]) {
		if (!dfn[v]) {
			tarjan(v);
			low[u] = min(low[u], low[v]);
		}
		else if (!lt[v]) {
			low[u] = min(low[u], dfn[v]);
		}
	}
	if (dfn[u] == low[u]) {
		lt[u] = ++ scc;
		while (sta.back() != u) {
			lt[sta.back()] = scc;
			sta.pop_back();
		}
		sta.pop_back();
	}
}

int main() {
	scanf("%d%d", &n, &m);
	while (m --) {
		int xi, i, xj, j;
		scanf("%d%d%d%d", &xi, &i, &xj, &j);
		son[xi + n * (i & 1)].push_back(xj + (j ^ 1) * n);
		son[xj + n * (j & 1)].push_back(xi + (i ^ 1) * n);
	}
	for (int i = 1; i <= (n << 1); ++ i) {
		if (!dfn[i]) {
			tarjan(i);
		}
	}
	for (int i = 1; i <= n; ++ i) {
		if (lt[i] == lt[i + n]) {
			puts("IMPOSSIBLE");
			return 0;
		}
	}
	puts("POSSIBLE");
	for (int i = 1; i <= n; ++ i) {
		printf("%d%c", (lt[i] < lt[i + n]), " \n"[i == n]);
	}
	return 0;
}

---

CF1475F
将 $A$ 和 $B$ 两个矩阵异或，得到一个新矩阵 $C$，若 $C$ 可以通过异或行或列的操作来变成全 $0$ 矩阵，那么说明 $A$ 可以通过异或得到 $B$。
我们发现，每一行或每一列要么不异或，要么异或一次，由此可以想到 2-SAT。
对于 $C$ 中的元素，若 $C(i, j)$ 为 $1$，则要么行异或，要么列异或；若 $C(i, j)$ 为 $0$，则要么行和列都异或，要么行和列都不异或，由此建边判断是否有解。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int N = 1005;

int T, n, cnt, tim, scc;
int a[N][N], b[N][N], c[N][N], x[N][2], y[N][2];
int dfn[N << 2], low[N << 2], lt[N << 2];
vector<int> son[N << 2], Stack;

void init() {
	cnt = tim = scc = 0;
	for (int i = 1; i <= n; ++ i) {
		x[i][1] = ++ cnt;
		son[cnt].clear();
		dfn[cnt] = lt[cnt] = 0;
	}
	for (int i = 1; i <= n; ++ i) {
		x[i][0] = ++ cnt;
		son[cnt].clear();
		dfn[cnt] = lt[cnt] = 0;
	}
	for (int i = 1; i <= n; ++ i) {
		y[i][1] = ++ cnt;
		son[cnt].clear();
		dfn[cnt] = lt[cnt] = 0;
	}
	for (int i = 1; i <= n; ++ i) {
		y[i][0] = ++ cnt;
		son[cnt].clear();
		dfn[cnt] = lt[cnt] = 0;
	}
}

void tarjan(int u) {
	dfn[u] = low[u] = ++ tim;
	Stack.push_back(u);
	for (int v : son[u]) {
		if (! dfn[v]) {
			tarjan(v);
			low[u] = min(low[u], low[v]);
		}
		else if (! lt[v]) {
			low[u] = min(low[u], dfn[v]);
		}
	}
	if (dfn[u] == low[u]) {
		lt[u] = ++ scc;
		while (Stack.back() != u) {
			lt[Stack.back()] = scc;
			Stack.pop_back();
		}
		Stack.pop_back();
	}
}

int main() {
	scanf("%d", &T);
	while (T --) {
		scanf("%d", &n);
		init();
		for (int i = 1; i <= n; ++ i) {
			for (int j = 1; j <= n; ++ j) {
				scanf("%1d", &a[i][j]);
			}
		}
		for (int i = 1; i <= n; ++ i) {
			for (int j = 1; j <= n; ++ j) {
				scanf("%1d", &b[i][j]);
				c[i][j] = a[i][j] ^ b[i][j];
				if (c[i][j]) {
					son[x[i][1]].push_back(y[j][0]);
					son[y[j][0]].push_back(x[i][1]);
					son[x[i][0]].push_back(y[j][1]);
					son[y[j][1]].push_back(x[i][0]);
				}
				else {
					son[x[i][1]].push_back(y[j][1]);
					son[y[j][1]].push_back(x[i][1]);
					son[x[i][0]].push_back(y[j][0]);
					son[y[j][0]].push_back(x[i][0]);
				}
			}
		}
		for (int i = 1; i <= cnt; ++ i) {
			if (! dfn[i]) {
				tarjan(i);
			}
		}
		int fg = 0;
		for (int i = 1; i <= n; ++ i) {
			if (lt[x[i][1]] == lt[x[i][0]]) {
				puts("NO");
				fg = 1;
				break;
			}
			if (lt[y[i][1]] == lt[y[i][0]]) {
				puts("NO");
				fg = 1;
				break;
			}
		}
		if (! fg)	puts("YES");
	}
	return 0;
}