2-SAT

2-SAT

引子

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

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

在大多数问题中，用 $a$ 表示 $a=1$，用 $\mathrm{\neg }a$ 来表示 $a=0$。

对于同一对的药，有： $a=1$ 或 $a^{\prime }=1$。

对于不可以一起吃的药，有：$a=0$ 或 $a^{{}^{″}}=0$。

即 $a$ 或 $a^{\prime }$ ；$\mathrm{\neg }a$ 或 $\mathrm{\neg }{a}^{{}^{″}}$。

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

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

思路

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

把每一个 $a$ 和 $\mathrm{\neg }a$ 抽象成一个点。

于是对于一个方程 $a$ 或 $b$，我们将 $\mathrm{\neg }a$ 到 $b$ 和 $\mathrm{\neg }b$ 到 $a$ 连有向边。

这条有向边的含义为：如果取 $\mathrm{\neg }a$ 那么必须取 $b$；如果取 $\mathrm{\neg }b$ 那么必须取 $a$。

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

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

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

如果 $a$ 和 $\mathrm{\neg }a$ 在同一个强联通分量内，方程无解。

因为不可以既取 $a$ 又取 $\mathrm{\neg }a$。

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

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

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

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

还有一个问题，设 $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");
}