2-SAT

2-SAT

引子

有 \(2n\) 种药物，分成 \(n\) 对，每种药物恰好属于一对。现有一种治疗方法，每一对药至少吃一种，但有某些药不可以两个一起吃，求任意一种合法的吃药方案。

这样的现实问题可以转换为一个布尔方程组表示，设 \(a\)，\(a=1\) 表示吃 \(a\) 种药，\(a=0\) 表示不吃 \(a\) 种药。

在大多数问题中，用 \(a\) 表示 \(a=1\)，用 \(\neg a\) 来表示 \(a=0\)。

对于同一对的药，有： \(a=1\) 或 \(a'=1\)。

对于不可以一起吃的药，有：\(a=0\) 或 \(a^{''}=0\)。

即 \(a\) 或 \(a'\) ；\(\neg a\) 或 \(\neg a^{''}\)。

每一个这样的方程都需要成立至少一项。

求解这样的问题便可以使用 2-SAT。

思路

对于一个方程，我们考虑：如果前一项不成立，那么后一项必须成立；后一项不成立，那么前一项必须成立。

把每一个 \(a\) 和 \(\neg a\) 抽象成一个点。

于是对于一个方程 \(a\) 或 \(b\)，我们将 \(\neg a\) 到 \(b\) 和 \(\neg b\) 到 \(a\) 连有向边。

这条有向边的含义为：如果取 \(\neg a\) 那么必须取 \(b\)；如果取 \(\neg b\) 那么必须取 \(a\)。

对于一张图而言，如果形成了强联通分量，这个强联通分量上的点可以的取值构成一种合法的方案。

强连通的定义是：有向图 G 强连通是指，G 中任意两个结点连通。

强连通分量（SCC）的定义是：极大的强连通子图。

如果 \(a\) 和 \(\neg a\) 在同一个强联通分量内，方程无解。

因为不可以既取 \(a\) 又取 \(\neg a\)。

这里可以使用 Tarjan SCC 缩点（将一个分量缩成一个点），缩完点后，根据拓扑序求取值，如果 \(a\) 在 \(\neg a\) 之后，取 \(a\)；反之取 \(\neg a\)。如果一个点的两个状态都在一个联通分量内，那么问题无解。

否则优先取拓扑序大的状态，因为如果取拓扑序小的点，那么这个小的状态可能会顺着有向边取到拓扑序大的状态。

思考一下，取拓扑序小的状态，会不会因为其他状态的依赖关系取到拓扑序大的状态？

假设 \(\neg a\to b\) 是拓扑序大的状态，如果 \(b\) 需要取到 \(a\) 联通分量的状态，那么一定存在边 \(b\to a 所在的分量\)，假设不成立。

还有一个问题，设 \(a\) 的两个状态所在的联通分量为 \(T_1,T_2\)，较大的分量为 \(T_1\)，但对 \(b\) 来说是 \(T_2\) 怎么办？

如果这样，那么 \(b\) 的另外一个状态肯定在 \(T_1\)（考虑从 \(T_1\) 中 \(a\) 通过反点的边走）。这个问题困扰了我一年。

例题

例一 P4782 【模板】2-SAT

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

const int maxn=2e6+5;

struct node
{
    int to,nxt;
}edge[maxn*2];

int n,m,tot,dfntot,num;
int head[maxn],dfn[maxn],low[maxn],id[maxn];

bool vis[maxn];

stack<int>stk;

void add(int x,int y)
{
    tot++;
    edge[tot].to=y;
    edge[tot].nxt=head[x];
    head[x]=tot;
}

void dfs(int u)
{
    dfn[u]=low[u]=++dfntot,vis[u]=true,stk.push(u);
    for(int i=head[u];i;i=edge[i].nxt)
    {
        int v=edge[i].to;
        if(!dfn[v]) dfs(v),low[u]=min(low[u],low[v]);
        else if(vis[v]) low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        num++;
        while(stk.top()!=u) vis[stk.top()]=0,id[stk.top()]=num,stk.pop();
        vis[stk.top()]=0,id[stk.top()]=num;
        stk.pop();
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x,a,y,b;
        scanf("%d%d%d%d",&x,&a,&y,&b);
        if(a==0&&b==1) swap(x,y),swap(a,b);
        if(a==0&&b==0) add(x,y+n),add(y,x+n);
        else if(a==1&&b==0) add(x+n,y+n),add(y,x);
        else if(a==1&&b==1) add(x+n,y),add(y+n,x);
    }

    for(int i=1;i<=n*2;i++) if(!dfn[i]) dfs(i);

    for(int i=1;i<=n;i++) if(id[i]==id[i+n]) printf("IMPOSSIBLE"),exit(0);
    printf("POSSIBLE\n");
    for(int i=1;i<=n;i++) cout<<(id[i]<id[i+n])<<" ";
}

例二 P6378 PA2010 Riddle

图论优化建边，可以更加深刻的理解连边的真实含义。

推荐阅读：P6378 PA2010 Riddle 题解 from 阴阳八卦

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

const int maxn=4e6+5;

struct Edge
{
    int tot;
    int head[maxn];
    struct edgenode{int to,nxt;}edge[maxn*5];
    inline void add(int x,int y)
    {
        tot++;
        edge[tot].to=y;
        edge[tot].nxt=head[x];
        head[x]=tot;
    }
}G;

int n,m,k,cnt;
int pre[maxn][2],a[maxn];

int dfncok,num;
int dfn[maxn],low[maxn],id[maxn];
bool vis[maxn];
stack<int>stk;

inline void dfs(int u)
{
    dfn[u]=low[u]=++dfncok;vis[u]=1;stk.push(u);
    for(int i=G.head[u];i;i=G.edge[i].nxt)
    {
        int v=G.edge[i].to;
        if(!dfn[v]) dfs(v),low[u]=min(low[u],low[v]);
        else if(vis[v]) low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        num++;
        while(stk.top()!=u) vis[stk.top()]=false,id[stk.top()]=num,stk.pop();
        vis[stk.top()]=false,id[stk.top()]=num;
        stk.pop();
    }
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        G.add((x-1)*2+1,(y-1)*2);
        G.add((y-1)*2+1,(x-1)*2);
    }
    cnt=2*n;
    for(int j=1;j<=k;j++)
    {
        int t;
        scanf("%d",&t);
        for(int i=1;i<=t;i++)
        {
            scanf("%d",&a[i]);
            pre[a[i]][0]=++cnt,pre[a[i]][1]=++cnt;
            G.add((a[i]-1)*2,pre[a[i]][0]);G.add(pre[a[i]][1],(a[i]-1)*2+1);
        }
        for(int i=2;i<=t;i++)
        {
            int d1=a[i-1],d2=a[i];
            G.add(pre[d1][0],pre[d2][0]);
            G.add(pre[d2][1],pre[d1][1]);
            G.add(pre[d1][0],(d2-1)*2+1);
            G.add((d2-1)*2,pre[d1][1]);
        }
    }
    for(int i=0;i<=cnt;i++) if(!dfn[i]) dfs(i);
    for(int i=1;i<=n;i++) if(id[(i-1)*2]==id[(i-1)*2+1]) puts("NIE"),exit(0);
    puts("TAK");
}