2-SAT
算法思想
SAT问题：有一个有N个布尔值组成的序列A，给出一些限制关系，比如 A [ x ] & A [ y ] = 0 , A [ x ] ∣ A [ y ] ∣ A [ z ] = 1 A[x] \& A[y]=0,A[x] | A[y]|A[z]=1 A[x]&A[y]=0,A[x]∣A[y]∣A[z]=1等，确定 A [ 0 … N − 1 ] A[0\dots N-1] A[0…N−1]的值，使其满足所有限制关系
特别的，若每种限制关系中最多只有两个元素进行限制，则是2-SAT问题
判断有解
判断2-SAT是否有解，首先建立2N个点的图，设i点表示 x i = 0 x_i=0 xi=0，i’点表示 x i = 1 x_i=1 xi=1，一条有向边u->v表示选了u则必选v，2-SAT有解当且仅当对于任意一个 i ( 1 ≤ i ≤ N ) i(1\le i\le N) i(1≤i≤N)不能出现：在这个有向图中从i点出发可以到达i’点，且从i’点出发可以到达i点
实现判断i与i’是否可以互达，只需要判断i和i’是否处于同一强连通分量即可
输出可行方案
如果从i点出发可以到达i’，则表示选了i会导致选i’矛盾，因此只能选i’
使用Kosaraju求解强连通分量，求解过程中顺带求出了一个遍历悬系，只需要比较i和i’所属强连通分量在遍历顺序中的前后关系即可构造出可行方案
构图
一元限制：
x
i
=
1
x_i=1
xi=1，连边i->i’，表示如果i为0，则必须为1
二元限制：一条边u->v表示，若u则v，等价于其逆否命题，若非v则非u，建双边，对于每条二元限制，将其对应的命题与逆否命题的边连上，缺一不可
关于二元限制构图
-
u or v=1
u=0,v=1:u->v’
v=0,u=1:v->u’ -
u or v=0
u=0,v=0:u’->u,v’->v -
u and v=0
u=0,v=1:v’->u
u=1,v=0:u’->v -
u and v=1
u=1,v=1:u->u’,v->v’ -
u!=v
u=0,v=1:u’->v
u=1,v=0:u->v’
v=1,u=0:v’->u
v=0,u=1,v->u’ -
u==v
u=1,v=0:u’->v’
u=0,v=0:u->v
v=1,u=0:v’->u’
v=0,u=0:v->u
训练
HDU3062
题目大意：略
思路：2-SAT模板题，注意如何建边以及建什么样的边，题目未指明多组输入， 1 … n 1 \dots n 1…n是男， n + 1 … 2 n n+1 \dots 2n n+1…2n是女， 2 n + 1 … 3 n 2n+1\dots 3n 2n+1…3n是男， 3 n + 1 … 4 n 3n+1 \dots 4n 3n+1…4n是女，类似于并查集的方式
代码
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <stack>
using namespace std;
const int maxn=4e3+10;
int n,m,cnt,head[maxn];
int low[maxn],dfn[maxn],ans,vis[maxn],acc,belong[maxn];
stack<int>S;
struct node {
int next,to;
} e[maxn*2000];//注意边的数量
void tarjan(int id) {
vis[id]=1;//标记访问
dfn[id]=++ans;//时间戳
low[id]=ans;//初始化
S.push(id);//压入栈中
for(int i=head[id]; ~i; i=e[i].next) {
int v=e[i].to;//dfs下一个节点
if(!dfn[v]) {//如果没访问过{
tarjan(v);//下一节点
low[id]=min(low[id],low[v]);//必须在这里也加一个
}
if(vis[v])
low[id]=min(low[id],low[v]);
//如果已经dfs过了，而且还在栈里，代表节点v的子节点也已经dfs过了
//更新链接关系
}
if(low[id]==dfn[id]) {
acc++;
int v;
do {
v=S.top();
S.pop();
belong[v]=acc;
vis[v]=0;
} while(id!=v);
}
}
void Add(int from,int to) {
e[++cnt].next=head[from];
e[cnt].to=to;
head[from]=cnt;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
while(cin >>n>>m) {
memset(head,-1,sizeof(head));
memset(belong,0,sizeof(belong));
memset(vis,0,sizeof(vis));
memset(dfn,0,sizeof(dfn));
cnt=acc=ans=0;
while(m--) {
int a,b,c,d;
cin >>a>>b>>c>>d;
a=(a<<1)+c;//获取编号
b=(b<<1)+d;//获取编号
Add(a,b^1);//b为2x+1，变成2n,b为2n，变成2x+1，即取相邻的奇/偶数
Add(b,a^1);
}
for(int i=0; i<2*n; i++)//遍历所有的编号
if(!dfn[i])tarjan(i);
bool flag=0;
for(int i=0; i<n; i++)//如果在同一个强连通分量中
if(belong[i*2]==belong[i*2+1]) {
flag=1;
break;
}
flag?cout <<"NO\n":cout <<"YES\n";
}
return 0;
}
HDU1824
题目大意：略
思路：2-SAT模板，注意建边方法
代码
#include <bits/stdc++.h>
using namespace std;
const int maxn=3e3+10;
int t,m,ans,acc,cnt,head[maxn];
int low[maxn],dfn[maxn],vis[maxn],belong[maxn],in[maxn];
stack<int>S;
struct node {
int next,to;
} e[maxn*10];
void Add(int from,int to) {
e[++cnt].next=head[from];
e[cnt].to=to;
head[from]=cnt;
}
void tarjan(int id) {
vis[id]=1;//标记访问
dfn[id]=++ans;//时间戳
low[id]=ans;//初始化
S.push(id);//压入栈中
for(int i=head[id]; i; i=e[i].next) {
int v=e[i].to;//dfs下一个节点
if(!dfn[v]) {//如果没访问过{
tarjan(v);//下一节点
low[id]=min(low[id],low[v]);//必须在这里也加一个
}
if(vis[v])
low[id]=min(low[id],low[v]);
//如果已经dfs过了，而且还在栈里，代表节点v的子节点也已经dfs过了
//更新链接关系
}
if(low[id]==dfn[id]) {//找到一个根
belong[id]=++acc;//建立强连通分量索引
vis[id]=0;
while(1) {//清除栈中的强连通分量
int t=S.top();
belong[t]=acc;
vis[t]=0;
S.pop();
if(t==id)
break;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
while(cin >>t>>m) {
memset(head,0,sizeof(head));
memset(dfn,0,sizeof(dfn));
memset(vis,0,sizeof(vis));
memset(belong,0,sizeof(belong));
memset(in,0,sizeof(in));
cnt=ans=acc=0;
for(int i=0; i<t; i++) {
int a,b,c;
cin >>a>>b>>c;
in[a]=i*2,in[b]=in[c]=i*2+1;
/*将队员视为一种,队长与队员为彼此的互逆
进行映射，乘以2是因为0~n-1的值会被用,i*2对应
回家，i*2+1对应不回家(针对队长)
*/
}
while(m--) {
int a,b;
cin >>a>>b;
Add(in[a],in[b]^1);//互逆建边
Add(in[b],in[a]^1);
}
bool flag=1;
for(int i=0; i<2*t; i++)if(!dfn[i])tarjan(i);
//遍历所有的点
for(int i=0; i<t; i++)
if(belong[i*2]==belong[i*2+1]) {
flag=0;
break;
}
flag?cout <<"yes\n":cout <<"no\n";
}
return 0;
}
NowCoder NC19883
题目大意：略
思路：可以用树状数组统计逆序对，也可以直接统计，值比较少，对于每个未知的位置，一共有k种选择，并且这些位置从前到后必然是单调不减序列，证明见参考文献，对于每个未知位置进行尝试，并且动态更新获得的逆序对，详见代码
PS:这和2-sat有毛关系
代码
#include <bits/stdc++.h>
using namespace std;
const int maxn=2e4;
int n,k,a[maxn],dp[2][maxn],ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >>n>>k;
for(int i=1; i<=n; i++) {
cin >>a[i];
if(a[i]!=-1)dp[1][a[i]]++;//记录每个值的个数
}
for(int i=1; i<=k; i++)dp[1][i]+=dp[1][i-1]; //记录比当前值小的个数
for(int i=1; i<=n; i++) {
if(a[i]==-1) { //选择放的值
int mx=0x3f3f3f3f,pos;
for(int j=1; j<=k; j++)//尝试所有的取值
if(dp[0][j+1]+dp[1][j-1]<mx) {//创造出来的逆序对数
mx=dp[0][j+1]+dp[1][j-1];
//dp[0][x]记录已经遍历过的大于等于x的个数，dp[1][x]记录未遍历过的小于x的个数
pos=j;
}
a[i]=pos;
} else
for(int j=a[i]; j<=k; j++)dp[1][j]--;//经过的值
ans+=dp[0][a[i]+1];//统计逆序对,在当前位置比a[i]大的数有多少个
for(int j=1; j<=a[i]; j++)dp[0][j]++;//更新已经出现的比当前值大的个数
}
cout <<ans;
return 0;
}
NowCoder NC20184
题目大意：略
思路：依然是建图的问题，详见代码
代码
#include <bits/stdc++.h>
using namespace std;
const int maxn=2e3+10;
int k,n,m,cnt,ans,acc;
int low[maxn],dfn[maxn],vis[maxn],head[maxn],belong[maxn];
stack<int>S;
struct node {
int next,to;
} e[maxn*10];
void Add(int from,int to) {
e[++cnt].next=head[from];
e[cnt].to=to;
head[from]=cnt;
}
void tarjan(int id) {
vis[id]=1;//标记访问
dfn[id]=++ans;//时间戳
low[id]=ans;//初始化
S.push(id);//压入栈中
for(int i=head[id]; i; i=e[i].next) {
int v=e[i].to;//dfs下一个节点
if(!dfn[v]) {//如果没访问过{
tarjan(v);//下一节点
low[id]=min(low[id],low[v]);//必须在这里也加一个
}
if(vis[v])
low[id]=min(low[id],low[v]);
//如果已经dfs过了，而且还在栈里，代表节点v的子节点也已经dfs过了
//更新链接关系
}
if(low[id]==dfn[id]) {//找到一个根
belong[id]=++acc;//建立强连通分量索引
vis[id]=0;
while(1) {//清除栈中的强连通分量
int t=S.top();
belong[t]=acc;
vis[t]=0;
S.pop();
if(t==id)
break;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >>k;
while(k--) {
cin >>n>>m;
while(m--) {
char a,b;
int x,y;
cin >>a>>x;
cin >>b>>y;
switch(a) {
case 'm':
switch(b) {
case 'm':
Add(x+n,y);
Add(y+n,x);
break;
case 'h':
Add(x+n,y+n);
Add(y,x);
break;
}
break;
case 'h':
switch(b) {
case 'm':
Add(x,y);
Add(y+n,x+n);
break;
case 'h':
Add(x,y+n);
Add(y,x+n);
break;
}
break;
}
}
for(int i=1; i<=2*n; i++)if(!dfn[i])tarjan(i);
bool flag=1;
for(int i=1; i<=n; i++)
if(belong[i]==belong[i+n]) {
flag=0;
break;
}
flag?cout <<"GOOD\n":cout <<"BAD\n";
memset(head,0,sizeof(head));
memset(low,0,sizeof(low));
memset(dfn,0,sizeof(dfn));
memset(vis,0,sizeof(vis));
memset(belong,0,sizeof(belong));
}
return 0;
}
NowCoder NC20802
题目大意：略
思路：除了x地图，其余地图只能选两种赛车，假设所有的地图都适合且只有两种赛车可选，这样就可以直接用2-SAT处理，对于每个地图编号，用 i , i ′ i,i' i,i′表示选择第一种赛车和第二种赛车(不能用A，即用剩下的BC，其余同理)
对于约束条件，设车型号为
i
,
j
i,j
i,j，地图编号为
u
,
v
u,v
u,v，如果
u
u
u可用
i
i
i，
v
v
v不可用
j
j
j，连边
u
−
>
u
′
u->u'
u−>u′，代表u用了i就无解
否则按照2-SAT的思路加上
u
−
>
v
u->v
u−>v和
v
′
−
>
u
′
v'->u'
v′−>u′即可
对于输出方案，2-SAT的一般思路是：把缩点后的新图拓扑排序，判断每个点i，如果i的强连通分量的拓扑序在i’之后，那么i用第一种，否则第二种，但是tarjan求解是按照拓扑序的逆序给出的，所以直接用强连通分量编号判断即可，如果 b e l o n g [ i ] < b e l o n g [ i ′ ] belong[i]<belong[i'] belong[i]<belong[i′]，使用第一种，否则第二种
对于x地图，暴力枚举所有位置不适合A或不适合B即可，这样就已经包括了所有的情况
代码（洛谷题解）
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
inline int read() {//快读数字
int res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
return bo ? ~res + 1 : res;
}
inline char get() {//快读字符
char c; while ((c = getchar()) != 'A' && c != 'B' && c != 'C');
return c;
}
const int N = 2e5 + 5;
int n, d, m, a1[N], b1[N], ecnt, nxt[N], adj[N], go[N], dfn[N], low[N],
times, num, bel[N], top, stk[N], cyx[N];
char s[N], a2[N], b2[N], orz[N];
bool ins[N], flag;
void add_edge(int u, int v) {
nxt[++ecnt] = adj[u]; adj[u] = ecnt; go[ecnt] = v;
}
int neg(int x) {return x > n ? x - n : x + n;}
int tran(int x, char c) {
if (s[x] == 'a') return c == 'B' ? x : x + n;//如果A不能用，设置区间内选B和C，B低C高
if (s[x] == 'b' || s[x] == 'c') return c == 'A' ? x : x + n;//如果B或C不能用，设置区间内选A和另一个，A低
if (c == 'C') return x + n; return x;//如果都能用，因搜索的时候前面已经规定了x选什么，所以C的编号为另一个
}
void Tarjan(int u) {
dfn[u] = low[u] = ++times; ins[stk[++top] = u] = 1;
for (int e = adj[u], v; e; e = nxt[e])
if (!dfn[v = go[e]]) {
Tarjan(v);
low[u] = min(low[u], low[v]);
}
else if (ins[v]) low[u] = min(low[u], dfn[v]);
if (dfn[u] == low[u]) {
int v; bel[u] = ++num; ins[u] = 0;
while (v = stk[top--], v != u) bel[v] = num, ins[v] = 0;
}
}
bool solve() {
int i; ecnt = times = num = 0;
for (i = 1; i <= (n << 1); i++) bel[i] = adj[i] = dfn[i] = 0;//清空
for (i = 1; i <= m; i++) if (s[a1[i]] != 'x' && s[b1[i]] != 'x') {//遍历约束条件,如果涉及到的都不是x
if (a2[i] == s[a1[i]] - 32) continue;//如果约束条件对应的正好是该场不能用的
int u = tran(a1[i], a2[i]), v;//获得u的编号
if (b2[i] == s[b1[i]] - 32) {add_edge(u, neg(u)); continue;}/*如果约束条件对应的正好是该场不能用的，代表有矛盾，如果这里用了u就一定无解*/
v = tran(b1[i], b2[i]); add_edge(u, v);//命题
add_edge(neg(v), neg(u));//逆否命题
}
else {
char o = s[a1[i]], p = s[b1[i]];//获得对应约束条件的赛场
int u, v, x = cyx[a1[i]], y = cyx[b1[i]];
//x和y得到的是当前编号是否为'x'，如果是，则是第几个'x'
if (o == 'x' && p == 'x') {//如果都是x
if (a2[i] == orz[x]) continue;//如果约束条件对应的正好是该场不能用的
u = tran(a1[i], a2[i]), v;
if (b2[i] == orz[y]) {add_edge(u, neg(u)); continue;}/*如果约束条件对应的正好是该场不能用的，代表有矛盾，如果这里用了u就一定无解*/
v = tran(b1[i], b2[i]); add_edge(u, v);
add_edge(neg(v), neg(u));
}
else if (o == 'x' && p != 'x') {
if (a2[i] == orz[x]) continue;
u = tran(a1[i], a2[i]), v;
if (b2[i] == s[b1[i]] - 32) {add_edge(u, neg(u)); continue;}
v = tran(b1[i], b2[i]); add_edge(u, v);
add_edge(neg(v), neg(u));
}
else {
if (a2[i] == s[a1[i]] - 32) continue;
u = tran(a1[i], a2[i]), v;
if (b2[i] == orz[y]) {add_edge(u, neg(u)); continue;}
v = tran(b1[i], b2[i]); add_edge(u, v);
add_edge(neg(v), neg(u));
}
}
for (i = 1; i <= (n << 1); i++) if (!dfn[i]) Tarjan(i);//求强连通分量
for (i = 1; i <= n; i++) if (bel[i] == bel[i + n]) return 0;//判断是否有解
for (i = 1; i <= n; i++) {//构造解
if (bel[i] < bel[i + n]) {
if (s[i] == 'a') putchar('B');
else if (s[i] == 'b' || s[i] == 'C') putchar('A');
else if (orz[cyx[i]] == 'A') putchar('B');
else putchar('A');
}
else {
if (s[i] == 'a' || s[i] == 'b') putchar('C');
else if (s[i] == 'c') putchar('B');
else if (orz[cyx[i]] == 'A') putchar('C');
else putchar('B');
}
}
return 1;
}
void dfs(int dep) {
if (dep > d) {
if (!flag) flag = solve();
if (flag) exit(0);//表示已经构造出来了
return;
}
orz[dep] = 'A'; dfs(dep + 1);//尝试第dep个x是A
orz[dep] = 'B'; dfs(dep + 1);//尝试第dep个x是B
}
int main() {
int i; n = read(); read();
scanf("%s", s + 1); m = read();
for (i = 1; i <= n; i++) if (s[i] == 'x') cyx[i] = ++d;//记录哪些位置是x与编号
for (i = 1; i <= m; i++) a1[i] = read(), a2[i] = get(),
b1[i] = read(), b2[i] = get(); dfs(1);//开始尝试构造
if (!flag) puts("-1");
return 0;
}
NowCoder NC24610
题目大意：N个事项需要投票，有M个投票结果，每个投票结果会指定两个事项0或1（各自的值），试求在满足每个投票结果至少有一个事项满足条件的解，需要输出解
思路：基本上是2-SAT，但是输出可行解需要考虑一下，在得到有解之后，可以尝试对每个点进行0或1的尝试，每次将0或1的值带入进行DFS，判断当前值是否能够搜索到整个图，如果可以，则代表当前值可取
代码
#include <bits/stdc++.h>
using namespace std;
const int maxn=2e4;
int n,m,head[maxn],cnt,low[maxn],dfn[maxn],vis[maxn],ans,acc,belong[maxn];
stack<int>S;
//节点数，边数，链式前向星头，边计数，追溯值，时间戳
//访问标记，tarjan计数，分量计数，索引，栈
struct node {
int to,next;
} e[maxn];
struct nd {
int to,next;
} ed[maxn];
int h[maxn];
void add(int from,int to) {
ed[++cnt].next=h[from];
ed[cnt].to=to;
h[from]=cnt;
}
void Add(int from,int to) {
e[++cnt].next=head[from];
e[cnt].to=to;
head[from]=cnt;
}
void DFS(int u) {
vis[u]=1;
for(int i=h[u]; i; i=ed[i].next)
if(!vis[ed[i].to])DFS(ed[i].to);
}
bool check(int u) {
memset(vis,0,sizeof(vis));
DFS(u);
for(int i=1; i<=n; i++)
if(vis[belong[i]]&&vis[belong[i+n]])return 0;
return 1;
}
void tarjan(int id) {
vis[id]=1;//标记访问
dfn[id]=++ans;//时间戳
low[id]=ans;//初始化
S.push(id);//压入栈中
for(int i=head[id]; i; i=e[i].next) {
int v=e[i].to;//dfs下一个节点
if(!dfn[v]) {//如果没访问过{
tarjan(v);//下一节点
low[id]=min(low[id],low[v]);//必须在这里也加一个
}
if(vis[v])
low[id]=min(low[id],low[v]);
//如果已经dfs过了，而且还在栈里，代表节点v的子节点也已经dfs过了
//更新链接关系
}
if(low[id]==dfn[id]) {//找到一个根
belong[id]=++acc;//建立强连通分量索引
vis[id]=0;
while(1) {//清除栈中的强连通分量
int t=S.top();
belong[t]=acc;
vis[t]=0;
S.pop();
if(t==id)
break;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >>n>>m;
while(m--) {
int x,y;
char a,b;
cin >>x>>a>>y>>b;
switch(a) {
case 'Y':
switch(b) {
case'Y':
Add(x+n,y);
Add(y+n,x);
break;
case'N':
Add(x+n,y+n);
Add(y,x);
break;
}
break;
case 'N':
switch(b) {
case'Y':
Add(x,y);
Add(y+n,x+n);
break;
case'N':
Add(y,x+n);
Add(x,y+n);
break;
}
break;
}
}
for(int i=1; i<=2*n; i++)if(!dfn[i])tarjan(i);
for(int i=1; i<=n; i++)//判断是否有解
if(belong[i]==belong[i+n]) {
cout <<"IMPOSSIBLE";
return 0;
}
cnt=0;
for(int i=1; i<=2*n; i++)//缩点重新建图
for(int j=head[i]; j; j=e[j].next) {
int v=e[j].to;
if(belong[i]==belong[v])continue;
add(belong[i],belong[v]);
}
for(int i=1; i<=n; i++) {//尝试两种值的搜索，判断是否能搜到全部的点
bool a=check(belong[i]),b=check(belong[i+n]);
if(a&&b)cout <<"?";
else if(a&&!b)cout <<"Y";
else cout <<"N";
}
return 0;
}
总结
2-SAT的基本思路是找出题目中的逻辑关系并进行建边，最关键的点就是如何建图以及输出最后的可行解，大多数题目均是天然具有逆否命题的情况，某些题目需要额外建立逆否命题的边
1994
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
