2-sat学习小结

最新推荐文章于 2024-04-02 20:46:23 发布
最新推荐文章于 2024-04-02 20:46:23 发布
阅读量213 收藏
点赞数 2
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35541672/article/details/79320061
版权

To be continued…

你问我2-sat的定义？？？
一口血喷出来
这里写图片描述
这里写图片描述
总之我们就开始做吧
其实我们只需要把能推出的关系连边
比如a存在时b一定存在，则连边a->b
a存在时b一定不存在，则连边a->┐b
然后强连通分量缩点，拓扑排序
这个时候呢我们就要安利一波Korasaju算法了
http://blog.csdn.net/qq_35541672/article/details/79318738
因为我们可以发现，这样求出的强连通分量中，我们产生的顺序倒过来就必然是拓扑序了

例题1 poj 3678

我也不知道第一道例题放什么好，干脆就直接放大版题好了
故事背景？不存在的，这是道裸题
告诉你类似a or/xor/and b=0/1的关系，让你求能否有满足这一条件的取值

题解

那我们就来退吧
设a表示取1，a’表示取0
和为1 a<->b
和为0 a->b’,b->a’
或为1 a’->b,b’->a
或为0 a’<->b’
异或为1 a<->b’ a’<->b
异或为0 a<->b a’<->b’
就这样构图，然后跑Korasaju，检查一下a和a’是否在同一个强连通分量中
代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
int head[2005],cnt;
int n,m;
struct node{
    int u,v,next,rev;
    bool ban;
}edge[10000005];
char op[4];
void add_edge(int u,int v,int rev,bool ban){
    cnt++;
    edge[cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].rev=rev;
    edge[cnt].ban=ban;
    edge[cnt].next=head[u];
    head[u]=cnt;
}
void add(int u,int v){
    add_edge(u,v,cnt+2,0);
    add_edge(v,u,cnt,1);
}
bool vis[2005];
int scc[2005],sccc;
stack<int> S;
void dfs1(int u){
    vis[u]=1;
    for(int i=head[u];i;i=edge[i].next){
        int v=edge[i].v;
        if(edge[i].ban||vis[v])
            continue ;
        dfs1(v);
    }
    S.push(u);
}
void dfs2(int u,int num){
    scc[u]=num;
    for(int i=head[u];i;i=edge[i].next){
        int v=edge[i].v;
        if(edge[i].ban||scc[v])
            continue;
        dfs2(v,num);
    }
}
void find_scc(){
    for(int i=0;i<2*n;i++){
        if(!vis[i])
            dfs1(i);
    }
    for(int i=1;i<=cnt;i+=2){
        edge[i].ban=1;
        edge[i+1].ban=0;
    }
    while(!S.empty()){
        int x=S.top();
        S.pop();
        if(scc[x])
            continue ;
        sccc++;
        dfs2(x,sccc);
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int a,b,c;
        scanf("%d%d%d %s",&a,&b,&c,op);
        if(op[0]=='A'){
            if(c==1){
                add(a+n,a);
                add(b+n,b);
                add(a,b);
                add(b,a);
            }
            else{
                add(a,b+n);
                add(b,a+n);
            }
        }
        if(op[0]=='O'){
            if(c==1){
                add(a+n,b);
                add(b+n,a);
            }
            else{
                add(a,a+n);
                add(b,b+n);
                add(a+n,b+n);
                add(b+n,a+n);
            }
        }
        if(op[0]=='X'){
            if(c==1){
                add(a,b+n);
                add(b+n,a);
                add(b,a+n);
                add(a+n,b);
            }
            else{
                add(a,b);
                add(b,a);
                add(a+n,b+n);
                add(b+n,a+n);
            }
        }
    }
    find_scc();
    for(int i=0;i<n;i++)
        if(scc[i]==scc[i+n]){
            printf("NO\n");
            return 0;
        }
    printf("YES\n");
}

例题2 POJ 2723 Get Luffy Out

有2n把钥匙（编号从0开始），分成了n对，每队你只能选择一个，在你选择钥匙后，你会去开门，每个门有两个数字，你只要有跟其中一个数字相同的钥匙就能打开它（有时这两个数字是相同的），你只有打开前面的门后才能打开后面的。请问最多开多少门

题解

N对钥匙我们可以看成是N对点，门的关系可以看成or=1
那么问题来了，开多少门应该怎么计算呢？
显然是满足单调性的，所以可以二分
然而当时我是倒着计算...好像数据水，卡在1954ms过去了
代码（之前1954ms的代码就不拿出来献丑了）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
const int N=2105,M=20005;
struct node{
    int v,nxt;
    bool ban;
}edge[M];
int head[N],mcnt;
void add_edge(int u,int v,bool ban){
    mcnt++;
    edge[mcnt].v=v;
    edge[mcnt].nxt=head[u];
    edge[mcnt].ban=ban;
    head[u]=mcnt;
}
void add(int u,int v){
    add_edge(u,v,0);
    add_edge(v,u,1);
}
stack<int>s;
bool vis[N];
void dfs1(int u){
    vis[u]=1;
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].v;
        if(edge[i].ban||vis[v])
            continue ;
        dfs1(v);
    }
    s.push(u);
}
int scc[N],scccnt;
void dfs2(int u){
    scc[u]=scccnt;
    vis[u]=1;
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].v;
        if(edge[i].ban||vis[v])
            continue ;
        dfs2(v);
    }
}
int n,m;
void find_scc(){
    scccnt=0;
    memset(vis,0,sizeof vis);
    for(int i=0;i<2*n;i++){
        if(!vis[i])
            dfs1(i);
    }
    for(int i=1;i<=mcnt;i+=2){
        edge[i].ban=1;
        edge[i+1].ban=0;
    }
    memset(vis,0,sizeof vis);
    while(!s.empty()){
        int u=s.top();
        s.pop();
        if(!vis[u]){
            scccnt++;
            dfs2(u);
        }
    }
}
int opp[N];
int f[M][2];
bool check(int x){
    memset(head,0,sizeof head);
    mcnt=0;
    for(int i=1;i<=x;i++){
        add(opp[f[i][0]],f[i][1]);
        add(opp[f[i][1]],f[i][0]);
    }
    find_scc();
    for(int i=0;i<n;i++)
        if(scc[i]==scc[opp[i]])
            return false;
    return true;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2){
        if(n==0&&m==0)
            return 0;
        for(int i=1;i<=n;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            opp[a]=b,opp[b]=a;
        }
        for(int i=1;i<=m;i++){
            scanf("%d%d",&f[i][0],&f[i][1]);
        }
        int l=0,r=m+1;
        while(l+1<r){
            int mid=(l+r)>>1;
            if(check(mid))
                l=mid;
            else
                r=mid;
        }
        printf("%d\n",l);
    }
}

例题3 POJ 2749 Building roads

万恶的 Farmer John 有N个牛棚 给出它们的坐标
现在给出两个中转站的坐标，每个牛棚只能和一个中转站相连
有的牛棚只能连到相同中转站，有的只能连到不同中转站
请问任两个牛棚之间的最大距离最小是多少
（连向同一个中转站的距离（设均连向s1）为a->s1+s1->b，
不同(设a连s1,b连s2)则为a->s1+s1->s2+s2->b）

题解

将每个牛棚连向哪边作为对立的点。
要求相同则xor=0，要求不同则xor=1
二分这个最大距离
预处理一下，如果经过s1的距离>d，连边b->a’,a->b’，其他的同理

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
int head[10005],cnt,bhead[10005];
int head1[10005],cnt1,bhead1[10005];
struct node{
    int u,v,next;
}edge[9000005],edge1[9000005];
inline int Abs(int x){
    if(x>0)
        return x;
    return -x;
}
inline int Max(int x,int y){
    return x>y?x:y;
}
inline int dist(int x0,int y0,int x1,int y1){
    return Abs(x0-x1)+Abs(y0-y1);
}
void add_edge(int u,int v){
    cnt++;
    edge[cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].next=head[u];
    head[u]=cnt;
}
void add_edge1(int u,int v){
    cnt1++;
    edge1[cnt1].u=u;
    edge1[cnt1].v=v;
    edge1[cnt1].next=head1[u];
    head1[u]=cnt1;
}
void add1(int u,int v){
    add_edge(u,v);
    add_edge1(v,u);
}
void add2(int u,int v){
    add_edge(u,v);
    add_edge(v,u);
    add_edge1(u,v);
    add_edge1(v,u);
}
bool vis[10005];
int scc[10005],sccc;
pair<int,int> p[10005];
int n,a,b,x1,y1,x2,y2,ddd;
stack<int> S;
void dfs1(int u){
    vis[u]=1;
    for(int i=head[u];i;i=edge[i].next){
        int v=edge[i].v;
        if(vis[v])
            continue ;
        dfs1(v);
    }
    S.push(u);
}
void dfs2(int u,int num){
    scc[u]=num;
    for(int i=head1[u];i;i=edge1[i].next){
        int v=edge1[i].v;
        if(scc[v])
            continue;
        dfs2(v,num);
    }
}
void find_scc(){
    memset(vis,0,sizeof vis);
    memset(scc,0,sizeof scc);
    sccc=0;
    for(int i=1;i<=2*n;i++){
        if(!vis[i])
            dfs1(i);
    }
    while(!S.empty()){
        int x=S.top();
        S.pop();
        if(scc[x])
            continue ;
        sccc++;
        dfs2(x,sccc);
    }
}
bool check(int cap){
    int cntt=cnt;
    memcpy(bhead,head,sizeof head);
    memcpy(bhead1,head1,sizeof head1);
    for(int i=1;i<=2*n;i++){
        int d1,d11,d2,d22;
            d1=d2=0;
        if(i<=n)
            d1=dist(x1,y1,p[i].first,p[i].second);
        else
            d2=dist(x2,y2,p[i-n].first,p[i-n].second);
        if(d1>cap){
            add1(i,i+n);
            continue ;
        }
        if(d2>cap){
            add1(i,i-n);
            continue ;
        }
        for(int j=i+1;j<=2*n;j++){
            d11=d22=0;
            if(j<=n)
                d11=dist(x1,y1,p[j].first,p[j].second);
            else
                d22=dist(x2,y2,p[j-n].first,p[j-n].second);
            if(d11>cap){
                add1(j,j+n);
                continue ;
            }
            if(d22>cap){
                add1(j,j-n);
                continue ;
            }
            if(i<=n&&j<=n&&d1+d11>cap){
                add1(i,j+n);
                add1(j,i+n);
            }
            if(i<=n&&j>n&&d1+ddd+d22>cap){
                add1(i,j-n);
                add1(j,i+n);
            }
            if(i>n&&j>n&&d2+d22>cap){
                add1(i,j-n);
                add1(j,i-n);
            }
            if(i>n&&j<=n&&d2+ddd+d11>cap){
                add1(i,j+n);
                add1(j,i-n);
            }
        }
    }
    find_scc();
    cnt=cntt;
    cnt1=cntt;
    memcpy(head,bhead,sizeof head);
    memcpy(head1,bhead1,sizeof head1);
    for(int i=1;i<=n;i++)
        if(scc[i]==scc[i+n])
            return false;
    return true;
}
int main()
{
    scanf("%d%d%d%d%d%d%d",&n,&a,&b,&x1,&y1,&x2,&y2);
    for(int i=1;i<=n;i++)
        scanf("%d%d",&p[i].first,&p[i].second);
    for(int i=1;i<=a;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        add2(x,y+n);
        add2(y,x+n);
    }
    for(int i=1;i<=b;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        add2(x,y);
        add2(x+n,y+n);
    }
    ddd=dist(x1,y1,x2,y2);
    if(!check(99999999)){
        printf("-1\n");
        return 0;
    }
    int l=0,r=10000000;
    while(l<r){
        int mid=(l+r)/2;
        if(check(mid)){
            r=mid;
        }
        else
            l=mid+1;
    }
    printf("%d",r);
}

杂谈

另：在关系只有xor的时候，我们可以用并查集来代替求强连通分量。

关于输出方案的问题
如前所说，使用Korasaju算法的话，scc编号倒过来就是拓扑序，然后我们就能快速出解了

find_scc();
for(int i=1;i<=n;i++)
    if(scc[i]==scc[i+n]){
        printf("no solution\n");
        return 0;
    }
for(int i=1;i<=n;i++)
    if(scc[i]>scc[i+n])
        printf("%d ",i);
lcc_cat
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【总结】2-SAT
慢慢前行，跨越预言
09-09 1390
一、2-SAT 简介：    SAT是适定性(Satisfiability)问题的简称 。一般形式为k-适定性问题，简称 k-SAT。 当k>2时，k-SAT是NP完全的。因此一般讨论的是k=2的情况，即2-SAT问题。 2-SAT就是2判定性问题（条件只有一个，不是这个就
2-SAT学习资料
09-07
总的来说，这个压缩包提供了关于2-SAT问题的多角度学习资源，从理论到实践，从算法到具体应用，可以帮助学习者全面掌握这一主题。通过阅读这些资料，你可以了解到如何定义和表示2-SAT问题，如何构建和理解2-SAT图，...
2-SAT(小结)
qq_43653111的博客
09-02 119
学习目标： 2-SAT(小结) 这个人讲的很好，我就不详细讲了 学习内容： 注意点 1.适用范围：x1&x2=0,问给出 m 个关系表达式后，能否给这 n 个变量找出一个赋值的方法，使得满足所有的表达式； 2.对于每个变量都只有两种取值：0 / 1，那么对于每个点，我们把每个变量拆成 true 点和 false 点； 3.要注意只有关系明确的时候才能建边； 其中一个不成立则另一个一定成立（这是明确的关系）； 4.无解的情况：某一个变量的 false 能走到 true，从 true 也能走到 fals
【ACM图论模板】2-SAT问题
nefu_ljw的博客
10-01 320
前置知识：Tarjan算法 （详见此文） 参考文章： 1. 博客园 2-SAT 知识小结 2. 洛谷 2-SAT学习笔记 总结： 我们将一个元素拆成两个点表示bool元素的两种情况，有向边表示若起点成立，则终点一定成立。 当拆点建图后，如果一个元素拆出的两个点u,v。存在有向图上的路径u->v，则代表点u可以推出点v，点u非法，则点v合法。 有向无环图的情况下，合法点的拓扑序比非法点大。 Tarjan后，同一元素拆成的两个点中强连通分量编号小的点是合法点。 如果一个元素拆成的两
[学习笔记]2-SAT 小结
aigongshi8561的博客
02-04 118
目录 2-SAT 小结 2-SAT 小结 从SAT说起 布尔可满足性问题（Boolean satisfiability problem；SAT)）属于决定性问题，也是第一个被证明属于NP完全的问题。 此问题在计算机科学上许多领域的皆相当重要，包括计算机科学基础理论、算法、人工智能、硬件设计等等。---摘...
2-SAT 小结
weixin_30363817的博客
09-11 86
　　PS：今天（2014.10.27）准备PPT，明天在组合数学课上与大家一起分享一下2-SAT。我以为是一件简单的事情。但是，当我看了自己这篇博客以后，发现居然还是不懂。很多资料不全，也没仔细讲。整理了一下，又修改了。尽量让自己下次再看到这博客的时候，一遍下来就能懂。虽然引用了别人的博客，我尽量讲得不需要进入别人的博客就能看懂。 　　一些这方面的内容写得很好的博客。（排列是随机的。可...
【2-SAT】学习小结
weixin_30772105的博客
02-18 79
　　这两天学习了一下2-SAT，主要参考了以下两个资料： 　　　　　《由对称性解2-SAT问题》 　　　　　《2-SAT解法浅析》 　　另外还有这个博客我觉得讲得挺白话的。 建图： 　　2-SAT问题远没有网络流那样复杂，只要抓住关系建好图基本就直接可以解了，在这类问题中建边的规则就是“必须”，对于边<i，j>，它的意义就是选择了i就必须选j。 　　对于题目中给出的每对关系...
算法进阶-2sat-cf-1657F
闪电彬彬的博客
06-30 162
2sat-cf 练习
Java学习第五周小结
qq_70223124的博客
06-05 157
Date类
云计算第六天学习小结
最新发布
MEMORY_SUMMER的博客
04-02 266
计划执行，发送邮件和邮箱配置
2-sat学习笔记
01-08
vector G[N*2]; bool mark[N*2]; int S[N*2],c; int dfs(int x) { if (mark[x^1]) return 0; if (mark[x]) return 1; //和假设的值一样 mark[x]=1; S[c++]=x; for (int i=0;in=n; for (int i=0;i<2*n;...
Tarjan及2-SAT讲课PPT
10-20
信息学竞赛，图论算法，Tarjan，缩点，2-SAT 寒假期间的集训讲课 PPT，主要详细讲解了 Tarjan 算法的思想及应用，同时对于 Tarjan 算法的一个扩展——2-SAT 问题进行了详细的讲解，是图论讲课非常好的课件和资料。
2-sat.rar_2sat
09-21
《2-SAT问题详解与解决方案》 在计算机科学领域，特别是在图论和逻辑满足问题中，2-SAT（2-CNF-SAT）是一个基础且重要的问题。2-SAT问题源于布尔逻辑中的二元约束满足问题（CNF-SAT），但其简化了原问题的复杂性，...
planar
LazyCrazyCat的博客
09-16 1444
题目描述给出一个无向图（保证存在哈密顿回路），问能否把它画在一个平面上且任意两条无重合顶点的边不相交（称为平面图）。 最大数据：T=100 N=500 M=10000样例2 6 9 1 4 1 5 1 6 2 4 2 5 2 6 3 4 3 5 3 6 1 4 2 5 3 6 5 5 1 2 2 3 3 4 4 5 5 1 1 2 3 4 5 输出NO YES 解题思路由于最近学2sat学得疯狂，
最小生成树学习小结
LazyCrazyCat的博客
02-12 832
To be continued… 一个图的生成树，即找出这个无向连通图的某个边集为一棵树 最小生成树，即使边权和最小（最大生成树同理） Prim算法 设已加入最小生成树的点集为T 算法思路：每次寻找T所连向的不在T中的点的边中最小的边，将此边和点加入T 实现 int Prim(){ memset(cost,-1,sizeof cost); cost[1]=0;//...
Codeforces 804F Fake bullions
LazyCrazyCat的博客
12-27 411
题意 有N个帮派，每个帮派有Si个人，其中一些人有真金条 给出一张竞赛图，若图上存在一条边u-&gt;v,那么如果u中一人i，v中一人j，满足i&nbsp;mod&nbsp;Su=j&nbsp;mod&nbsp;Svi\ mod \ S_u=j\ mod \ S_vi&nbsp;mod&nbsp;Su​=j&nbsp;mod&nbsp;Sv​且i有金条（无论真假）且j无金条，i就会给j一个假金条 ...
CEOI2012 Network
LazyCrazyCat的博客
09-15 342
题目大意：给出一个有向图，有N个结点，M条边。 如果从p到q有一条有向边组成的路径，则称结点p可以到达结点q。 输入数据保证初始状态时，每对可达结点之间存在唯一路径。 图中有一个中心点R，它可以到达所有结点。 任务： (1)求出每个顶点能够到达的顶点数量(包括自身) (2)最少加多少条边，使得所有顶点之间均可以相互到达，且是唯一路径。 样例11 12 3 3 2 2 1 2 4
AGC001 C Shorten Diameter
LazyCrazyCat的博客
09-18 334
题意 给出一棵树，你可以删掉一些点，保证剩下的仍是棵树。然后询问使这棵树直径小于等于K最少要删掉多少点 题解 由于N&amp;lt;=2000，所以我们大体上可以往O(N2)O(N^2)O(N2)的角度上想 考虑K的奇偶性 若K为偶数，我们可以枚举每一个点作为新树的重心，那么深度大于k/2的就是要被删的 若K为奇数，我们可以枚举每一条边作为直径的中间那条边，然后分别以两个端点为根找深度，深度大于k/2的就...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值