2 - sat 原理和简单例题

问题

有$n$个布尔变量，其中一些布尔变量之间有限制关系，用所有$n$个布尔变量组成序列，使得其满足所有限制关系；判断序列是否存在，这就是$SAT(Satisfiability)$问题，如果每个限制关系只涉及两个变量，则是$2-SAT$问题

• 因为方案的数量是$O(2^n)$的，所以一般只输出有无方案或者输出一组方案（字典序最小）等等

原理

• 就只用语言描述了，不懂可以看oi-wiki或者知乎或者洛谷日报
• 首先基础的tarjan求SCC和缩点要理解，然后来看这个问题，比如说有这么一个逻辑：若$a$成立，则$b$成立，学过离散数学，我们知道这句话的意思是如果$a$为真，那么$b$一定为真；如果$b$为假，则$a$一定为假，这个原因应该是显而易见的，那么这个时候我们利用这两个结论建图，设$i$为$a$为真，$i+n$为$a$为假（$n$表示总共有多少个元素）,$j$为$b$为真，$j+n$为$b$为假，这样我们连边如下$$\begin{gathered} i->j \\ j+n->i+n \end{gathered}$$按照这样的规则我们就能建立一个有向图
• 所以有这样几种关系$$a\vee b,a\wedge b,\neg a\vee b...$$
  我们应该都能够容易写出来对应的建图方式了

刘汝佳白书中提到用$2i,2i+1$分别表示假和真，感觉效果一样吧。。。

• 这样建好一个图之后，因为是一个有向图，我们使用$tarjan$可以求$SCC$并缩点等等，如果发现竟然有一个$i,i+n$在同一个$SCC$中，那么说明无解
• 之前在$tarjan$那篇文章里提到它给出的$SCC$编号实际上是一个逆拓扑序，那么如果要求我们输出方案，我们应该选择拓扑序较小的，因为这是一个逆拓扑，最后的点的依赖性是最大的，因为如果后面的不成立，前面的自然也就不成立；如果后面的成立，也没法说明前面的成立，这就是说后面的依赖性更大，所以应该先满足后面，再满足前面，这样应该先输出拓扑序更小的

例题 1

https://www.luogu.com.cn/problem/P4782

• 给出了若干组布尔变量的限制关系，让你构造一组可行解
• $2-sat$模板题，缩点之后判断是否在一个$SCC$中确定是否无解，根据拓扑序前后关系判断选$true$还是$false$

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int n, m;
  cin >> n >> m;
  vector<vector<int> > g(2 * n + 1);
  for(int k=0;k<m;k++){
    int i, a, j, b;
    cin >> i >> a >> j >> b;
    if(a == 0 && b == 0){// xi 假, yi 假
      g[i].push_back(j + n);
      g[j].push_back(i + n);
    }else if(a == 0 && b == 1){// xi 假, yi 真
      g[i].push_back(j);
      g[j + n].push_back(i + n);
    }else if(a == 1 && b == 0){// xi 真, yi 假
      g[i + n].push_back(j + n);
      g[j].push_back(i);
    }else{// xi 真, yi 真
      g[i + n].push_back(j);
      g[j + n].push_back(i);
    }
  }
  vector<int> low(n << 1 | 1), num(n << 1 | 1), sccno(n << 1 | 1);
  int dfn = 0;
  int cnt = 0;
  stack<int> st;
  function<void(int)> Dfs = [&](int u){
    low[u] = num[u] = ++dfn;
    st.push(u);
    for(auto v : g[u]){
      if(!num[v]){
        Dfs(v);
        low[u] = min(low[u], low[v]);
      }else if(!sccno[v]){
        low[u] = min(low[u], num[v]); 
      }
    }
    if(low[u] == num[u]){
      cnt += 1;
      while(1){
        auto v = st.top();
        st.pop();
        sccno[v] = cnt;
        if(u == v) break;
      }
    }
  };
  for(int i=1;i<=2*n;i++){
    if(!num[i]){
      Dfs(i);
    }
  }
  for(int i=1;i<=n;i++){
    if(sccno[i] == sccno[i + n]){
      cout << "IMPOSSIBLE\n";
      return 0;
    }
  }
  cout << "POSSIBLE\n";
  for(int i=1;i<=n;i++){
    cout << (sccno[i] > sccno[i + n]) << ' ';
  }
  return 0;
}

例题 2

https://www.luogu.com.cn/problem/P6378

• 这个题如果看作一道$2-sat$的裸题，那么暴力写下来没办法通过，因为在每个部分中的点连边将达到$n^2$，需要优化建图方案
• 前缀优化建图，我们正常是要用$i,i+n$这两个值分别表示选或者不选第$i$个点，再加上两个$i+2n,i+3n$分别表示它的前缀有没有关键点，这个前缀不包括它本身，那么如果选了$i$,那么前缀必然没有关键点，如果前缀有关键点$i$，那么必没选$i$；然后再建立前缀之间的关系，前$i-1$个点如果有关键点，那么前$i$个点必然有关键点，前$i$个点没有关键点，那么前$i-1$个点必然也没有关键点

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 4e6 + 100;
struct Edge{
  int next;
  int to;
  int val;
}edge[N * 2];
int head[N];
int tot = 0;
void Add_Edge(int u, int v, int w){
  edge[tot].to = v;
  edge[tot].next = head[u];
  edge[tot].val = w;
  head[u] = tot++;
}
int vs[N];
int dfn = 0;
int cnt = 0;
stack<int> st;
int low[N], num[N], sccno[N];
void tarjan(int u){
  st.push(u);
  low[u] = num[u] = ++dfn;
  for(int i=head[u];~i;i=edge[i].next){
    int v = edge[i].to;
    if(!num[v]){
      tarjan(v);
      low[u] = min(low[u], low[v]);
    }else if(!sccno[v]){
      low[u] = min(low[u], num[v]);
    }
  }
  if(low[u] == num[u]){
    cnt += 1;
    while(1){
      auto v = st.top();
      st.pop();
      sccno[v] = cnt;
      if(v == u) break;
    }
  }
}
int main(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int n, m, k;
  cin >> n >> m >> k;
  memset(head, -1, sizeof head);
  for(int i=0;i<m;i++){
    int a, b;
    cin >> a >> b;
    Add_Edge(a + n, b, 1);
    Add_Edge(b + n, a, 1);
  }
  for(int i=0;i<k;i++){
    int w;
    cin >> w;
    for(int j=0;j<w;j++){
      cin >> vs[j];
    }
    for(int j=0;j<w;j++){//建立前缀和当前节点之间的关系
      Add_Edge(vs[j], vs[j] + 2 * n, 1);
      Add_Edge(vs[j] + 3 * n, vs[j] + n, 1);
    }
    for(int j=1;j<w;j++){//建立前缀之间的关系
      Add_Edge(vs[j - 1] + 2 * n, vs[j] + 2 * n, 1);//前j-1个点有关键点
      Add_Edge(vs[j] + 3 * n, vs[j - 1] + 3 * n, 1);//前j个点没有关键点
      Add_Edge(vs[j - 1] + 2 * n, vs[j] + n, 1);//前j-1个点有关键点
      Add_Edge(vs[j], vs[j - 1] + 3 * n, 1);//第j个点是关键点
    }
  }
  for(int i=1;i<=4 * n;i++){
    if(!num[i]){
      tarjan(i);
    }
  }
  bool ok = true;
  for(int i=1;i<=n;i++){
    if(sccno[i] == sccno[i + n] || sccno[i + 2 * n] == sccno[i + 3 * n]){
      ok = false;
    }
  }
  cout << (ok ? "TAK" : "NIE") << '\n';
  return 0;
}