2-sat:

最新推荐文章于 2022-07-07 12:06:28 发布
最新推荐文章于 2022-07-07 12:06:28 发布
阅读量133 收藏
点赞数
分类专栏： 图论基本算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoxinxin1234/article/details/98723484
版权

一、染色法，暴力染色，求解字典序最小解：
HDU1814
有n对人，每对有两个，有m对相互讨厌的关系，相互讨厌的两个人不能同时出现，每对人中出现且只能出现一个，判断能否成立，若成立，输出字典序最小的解。
2-sat水题：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=21000;
const int maxm=110000;
int head[maxn],ver[maxm],nt[maxm];
bool ha[maxn];
int st[maxn];
int tot=1,top=0;

void add(int x,int y)
{
    ver[++tot]=y,nt[tot]=head[x],head[x]=tot;
}

bool dfs(int x)
{
    if(ha[x^1]) return false;
    if(ha[x]) return true;
    ha[x]=true;
    st[++top]=x;
    for(int i=head[x];i;i=nt[i])
    {
        if(!dfs(ver[i]))
            return false;
    }
    return true;
}

bool is_can(int n)
{
    memset(ha,0,sizeof(ha));
    for(int i=2;i<=n;i+=2)
    {
        if(ha[i]||ha[i^1]) continue;
        top=0;
        if(!dfs(i))
        {
            while(top) ha[st[top--]]=false;
            if(!dfs(i^1)) return false;
        }
    }
    return true;
}

int main(void)
{
    int n,m;
    int x,y;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(head,0,sizeof(head));
        tot=1;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&x,&y);
            x++,y++;
            add(x,y^1);
            add(y,x^1);
        }
        if(is_can(n*2+1))
        {
            for(int i=2;i<=2*n+1;i++)
            {
                if(ha[i])
                    printf("%d\n",i-1);
            }
        }
        else printf("NIE\n");
    }
    return 0;
}

二、Priest John’s Busiest Day POJ - 3683 ：
本题中，每场婚礼是一个变量，有开始时举行仪式和结束前举行仪式两种取值。
然后，就是一个2-sat问题了，本题不要求字典序最小的解，拓扑排序即可实现：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=2100;
const int maxm=4010000;
int head[maxn],ver[maxm],nt[maxm],dfn[maxn],low[maxn],c[maxn];
int head2[maxn],ver2[maxm],nt2[maxm],d[maxn],opp[maxn];
int st[maxn],s[maxn],t[maxn],dd[maxn],val[maxn];
bool ha[maxn];
int n,m,tot,tot2,top,cnt,sum;
void init(void)
{
    memset(head,0,sizeof(head));
    memset(head2,0,sizeof(head2));
    memset(ha,0,sizeof(ha));
    memset(d,0,sizeof(d));
    memset(dfn,0,sizeof(dfn));
    tot=tot2=1;
    top=cnt=sum=0;
}

void add(int x,int y)
{
    ver[++tot]=y,nt[tot]=head[x],head[x]=tot;
}
void add_c(int x,int y)
{
    ver2[++tot2]=y,nt2[tot2]=head2[x],head2[x]=tot2;
}

bool is_can(int b1,int e1,int b2,int e2)
{
    if(b1>=b2&&b1<e2||e1>b2&&e1<=e2||b1<=b2&&e1>=e2) return true;
    if(b2>=b1&&b2<e1||e2>b1&&e2<=e1||b2<=b1&&e2>=e1) return true;
    return false;
}

void tarjan(int x)
{
    dfn[x]=low[x]=++sum;
    st[++top]=x,ha[x]=true;

    for(int i=head[x];i;i=nt[i])
    {
        if(!dfn[ver[i]])
        {
            tarjan(ver[i]);
            low[x]=min(low[x],low[ver[i]]);
        }
        else if(ha[ver[i]])
            low[x]=min(low[x],low[ver[i]]);
    }

    if(dfn[x]==low[x])
    {
        cnt++;
        int y;
        do
        {
            y=st[top--];
            ha[y]=false;
            c[y]=cnt;
        }while(x!=y);
    }
}


void tp(void)
{
    memset(val,-1,sizeof(val));
    for(int x=1;x<=n*2;x++)
        for(int i=head[x];i;i=nt[i])
        {
            int y=ver[i];
            if(c[x]==c[y]) continue;
            add_c(c[y],c[x]);
            d[c[x]]++;
        }
    queue<int>q;
    for(int i=1;i<=cnt;i++)
    {
        if(!d[i]) q.push(i);
    }

    while(q.size())
    {
        int x=q.front();
        q.pop();
        if(val[x]==-1) val[x]=0,val[opp[x]]=1;
        for(int i=head2[x];i;i=nt2[i])
        {
            d[ver2[i]]--;
            if(d[ver2[i]]==0) q.push(ver2[i]);
        }
    }
    return ;
}






int main(void)
{
    while(scanf("%d",&n)!=EOF)
    {
        init();
        int sh,sm,th,tm;
        for(int i=1;i<=n;i++)
        {
            scanf("%d:%d%d:%d%d",&sh,&sm,&th,&tm,&dd[i]);
            s[i]=sh*60+sm,t[i]=th*60+tm;
        }

        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<i;j++)
            {
                if(is_can(s[i],s[i]+dd[i],s[j],s[j]+dd[j]))
                    add(i,n+j),add(j,n+i);
                if(is_can(s[i],s[i]+dd[i],t[j]-dd[j],t[j]))
                    add(i,j),add(n+j,n+i);
                if(is_can(t[i]-dd[i],t[i],s[j],s[j]+dd[j]))
                    add(n+i,n+j),add(j,i);
                if(is_can(t[i]-dd[i],t[i],t[j]-dd[j],t[j]))
                    add(n+i,j),add(n+j,i);
            }
        }

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

        bool flag=false;
        for(int i=1;i<=n;i++)
        {
            if(c[i]==c[i+n])
            {
                flag=true;
                printf("NO\n");
                break;
            }
            opp[c[i]]=c[n+i],opp[c[n+i]]=c[i];
        }

        if(flag) continue;

        printf("YES\n");
        tp();
        for(int i=1;i<=n;i++)
        {
            if(val[c[i]]==0)
            {
                printf("%02d:%02d %02d:%02d\n",s[i]/60,s[i]%60,(s[i]+dd[i])/60,(s[i]+dd[i])%60);
            }
            else
            {
                printf("%02d:%02d %02d:%02d\n",(t[i]-dd[i])/60,(t[i]-dd[i])%60,t[i]/60,t[i]%60);
            }
        }
    }

    return 0;
}

还可以利用有向图求强连通分量的性质，直接获得拓扑序：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#define ll long long
#define llu unsigned ll
using namespace std;
const int maxn=2100;
const int maxm=4010000;
int head[maxn],ver[maxm],nt[maxm],dfn[maxn],low[maxn],c[maxn];
int d[maxn],opp[maxn];
int st[maxn],s[maxn],t[maxn],dd[maxn],val[maxn];
bool ha[maxn];
int n,m,tot,tot2,top,cnt,sum;
void init(void)
{
    memset(head,0,sizeof(head));
    memset(ha,0,sizeof(ha));
    memset(d,0,sizeof(d));
    memset(dfn,0,sizeof(dfn));
    tot=tot2=1;
    top=cnt=sum=0;
}

void add(int x,int y)
{
    ver[++tot]=y,nt[tot]=head[x],head[x]=tot;
}


bool is_can(int b1,int e1,int b2,int e2)
{
    if(b1>=b2&&b1<e2||e1>b2&&e1<=e2||b1<=b2&&e1>=e2) return true;
    if(b2>=b1&&b2<e1||e2>b1&&e2<=e1||b2<=b1&&e2>=e1) return true;
    return false;
}

void tarjan(int x)
{
    dfn[x]=low[x]=++sum;
    st[++top]=x,ha[x]=true;

    for(int i=head[x];i;i=nt[i])
    {
        if(!dfn[ver[i]])
        {
            tarjan(ver[i]);
            low[x]=min(low[x],low[ver[i]]);
        }
        else if(ha[ver[i]])
            low[x]=min(low[x],low[ver[i]]);
    }

    if(dfn[x]==low[x])
    {
        cnt++;
        int y;
        do
        {
            y=st[top--];
            ha[y]=false;
            c[y]=cnt;
        }while(x!=y);
    }
}


int main(void)
{
    while(scanf("%d",&n)!=EOF)
    {
        init();
        int sh,sm,th,tm;
        for(int i=1;i<=n;i++)
        {
            scanf("%d:%d%d:%d%d",&sh,&sm,&th,&tm,&dd[i]);
            s[i]=sh*60+sm,t[i]=th*60+tm;
        }

        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<i;j++)
            {
                if(is_can(s[i],s[i]+dd[i],s[j],s[j]+dd[j]))
                    add(i,n+j),add(j,n+i);
                if(is_can(s[i],s[i]+dd[i],t[j]-dd[j],t[j]))
                    add(i,j),add(n+j,n+i);
                if(is_can(t[i]-dd[i],t[i],s[j],s[j]+dd[j]))
                    add(n+i,n+j),add(j,i);
                if(is_can(t[i]-dd[i],t[i],t[j]-dd[j],t[j]))
                    add(n+i,j),add(n+j,i);
            }
        }

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

        bool flag=false;
        for(int i=1;i<=n;i++)
        {
            if(c[i]==c[i+n])
            {
                flag=true;
                printf("NO\n");
                break;
            }
            opp[i]=n+i,opp[n+i]=i;
        }

        if(flag) continue;

        printf("YES\n");
        for(int i=1;i<=n*2;i++)
        {
            val[i]=c[i]>c[opp[i]];
        }

        for(int i=1;i<=n;i++)
        {
            if(val[i]==0)
            {
                printf("%02d:%02d %02d:%02d\n",s[i]/60,s[i]%60,(s[i]+dd[i])/60,(s[i]+dd[i])%60);
            }
            else
            {
                printf("%02d:%02d %02d:%02d\n",(t[i]-dd[i])/60,(t[i]-dd[i])%60,t[i]/60,t[i]%60);
            }
        }
    }

    return 0;
}
_Shmily
关注
专栏目录
C++基础：2-SAT问题
Keven_11的博客
01-30 1605
概述 现有一个由 N 个布尔值组成的序列 A ，给出一些限制关系，比如 A[x] AND A[y]=0、A[x] OR A[y] OR A[z]=1等，要确定A[0⋯N−1]的值，使得其满足所有限制关系。这个称为SAT问题（已确定非2-SAT的SAT问题为NP完全问题），特别的，若每种限制关系中最多只对两个元素进行限制，则称为 2-SAT 问题。 算法 我们可以把每个点拆成两个点，一个代表取值为 true ，另一个代表取值为 false ，对点对进行遍历，如果两个点都没被选，则先假设选 false ，
2-sat思想及入门
qq_43041641的博客
07-14 1198
2-sat思想及入门什么是2-sat例题分析建边判断有解输出方案完整代码 什么是2-sat 要知道2-sat是什么，我们先要知道什么是适定性（Satisfiability）问题，适，就是合适，定，就是确定，适定性问题通俗的说就是确定是否可以满足所有的条件？或者说就是确定一个满足所有条件的方案。取英文的前三个字母，简称sat问题。 通俗的sat问题表述一般是这样的： 有很多个集合，每个集合里面有若...
hdu1814 Peaceful Commission (2-SAT 输出字典序最小解，模板题)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
08-26 228
题意： 给n，表示有n对人，其中编号为2i-1的人和编号为2i的人是一对(例如1和2，3和4) 给m，表示有m对人互相讨厌， 现在要从这n对人中每对挑出一个人，同时满足挑出的所有人两两不互相厌恶， 输出编号字典序最小的解 分析: 模板题， 2-SAT输出字典序最小好像只能用dfs求解。 另外，题目给的n是对数，因此总编号数量为2n，注意数组大小 #include<cstdio> #in...
浅析2-sat
Caristra的博客
08-11 727
2-sat 简介： sat问题(适定性(Sat**isfiability)问题)——给定一个布尔方程,求出这个方程的解**. 若有KKK个变量,则称为K-sat问题,故K=2K=2K=2时,即为2-sat问题… 关于它的解法,常用的有两种——(dfs,tarjan+拓扑). 常规操作： 在满足布尔方程的性质——一个变量为1或0——下,我们可以建出一个满足对称性的类似于二分图的图...
图论--2-SAT--详解
日拱一卒,功不唐捐
11-13 3590
问题描述： 现有一个由N个布尔值组成的序列A，给出一些限制关系，比如A[x]AND A[y]=0、A[x] OR A[y] OR A[z]=1等，要确定A[0..N-1]的值，使得其满足所有限制关系。这个称为SAT问题，特别的，若每种限制关系中最多只对两个元素进行限制，则称为2-SAT问题。 由于在2-SAT问题中，最多只对两个元素进行限制，所以可能的限制关系共有11种： A...
2-SAT问题
KaiserWilheim的博客
07-07 3303
2-SAT问题
图论专题-学习笔记：2 - SAT 问题
Plozia 的小窝
08-12 950
图论专题-学习笔记：2 - SAT 问题1. 前言2. 详解3. 总结 1. 前言 本篇文章将会对 2 - SAT 问题做一个讲解。 前置知识：强连通分量/缩点（我的博客链接/强连通分量 - OI Wiki）。 2. 详解 首先我们需要知道 2 - SAT 是什么。 实际上 2 - SAT 是 k - SAT 的一种特殊情况。 k - SAT 问题的一般描述就是有一些物品，每个物品均有 kkk 个状态，给出一些限制条件，诸如 A 为 a 状态则 B 为 b 状态之类的，问有无可行解，有时还会让你求解。 目前
2-SAT问题详解
qq_42376883的博客
05-14 2011
2-sat问题详解
2-SAT问题合集-ybtoj
Mint_hexagram的博客
02-24 2243
2-SAT的合集
oracle报错ora-12162,【故障处理】ORA-12162: TNS:net service name is incorrectly specified
weixin_28715081的博客
04-03 5842
【故障处理】ORA-12162: TNS:net service name is incorrectly specified本文将给大家阐述一个因未设置系统环境变量ORACLE_SID导致ORA-12162错误的案例。希望大家有所思考。1.获得有关ORA-12162报错信息的通用表述信息[oracle@asdlabdb01 ~]$ oerr ora 1216212162, 00000, "TNS:...
java-sat:交互式SAT解算器
05-11
在Java-SAT-master文件夹中，可能包含源代码、编译脚本、测试用例、配置文件以及用户手册等相关文件。用户可以编译源代码并运行程序，或者查看源码学习解算器的实现细节。对于学习和理解SAT问题的求解过程，以及如何...
knapsack-and-max-sat:MIE-PAA问题和算法。 背包问题解决方案
05-24
在"knapsack-and-max-sat-master"压缩包中，可能包含了上述算法的Python实现代码，供研究者参考和学习。 总结，背包问题和最大满足度问题在理论和应用上都具有重要价值。通过不同算法的运用，我们可以找到这些问题...
sat-solver:C++ 中的简单随机 3-SAT 求解器。 2015年
06-20
"sat-solver" 是一个项目名称，暗示了它是一个用于解决特定问题的工具，这里的“SAT”通常指的是“满足性问题”（Satisfiability Problem），特别是3-SAT，这是一个著名的NP完全问题。3-SAT是将逻辑公式转化为3个...
reduction-to-CNF-SAT:将单色三角形问题减少到CNF
04-07
例如{{1“：[2,3,4]，” 2“：[3,4] ...，} 注意：键是str，值数组是ints GraphGenerator.py返回随机创建的邻接矩阵•其中[i] [j] = 1 v 0指示是否存在连接顶点i和j的边。 笔记 逻辑设置矩阵，以便不允许循环。 ...
sat-search:适用于sat-api的python客户端
05-15
Sat-search是一个Python 3库和一个命令行工具，用于使用兼容STAC的API查找和下载可公开获得的卫星图像。 STAC API 从v0.3.0开始，卫星搜索没有默认的STAC端点。 使用库时，可以将其作为参数传递，也可以定义环境...
图的类型与性质——欧拉图、（竞赛图、哈密顿图）
_Griefs
08-24 3697
一、欧拉图：   无向图连通性的小问题——欧拉路问题，俗称一笔画问题。   给定一张无向图，若存在一条从节点S到节点T的路径，恰好不重不漏的经过每条边一次（可以重复经过图中的顶点），则称该路径为S到T的欧拉路。   特别的，若存在一条从节点S出发的路径，敲好不重不漏的经过每条边一次（可以重复经过图中的节点），最终回到起点S，则称该路径为欧拉回路。存在欧拉回路的无向图被称为欧拉图。   欧拉图的判定...
P6699 【模板】一般图最大权匹配
_Griefs
08-25 2757
题目链接 题面： 这个是真不会。。。。。。 代码： #include<iostream> #include<cstdlib> #include<cstdio> #include<algorithm> #include<cstring> #include<string> #include<cmath> #include<queue> #include<map> #include<vector&g
二分图的匹配
_Griefs
08-24 1570
一、二分图的判定：    如果一张图的N个节点可以分成A，B两个非空集合，其中A∩B＝空集，并且在同一集合内的点之间都没有边相连，那么称这张无向图为一张二分图。A，B分别称为二分图的左部和右部。    定理： 一张无向图是二分图，当且仅当图中不存在奇环（长度为奇数的环）。        根据该定理，我们可以用染色法进行二分图的判定。大致思想为：尝试用黑白两种...
Tarjan算法与无向图连通性
_Griefs
08-24 1337
一、无向图的割点与桥的基本概念：     给定无向连通图G = (V, E) 割点： 对于x∈V，从图中删去节点x以及所有与x关联的边之后，G分裂为两个或两个以上不相连的子图，则称x为割点 割边（桥）： 若对于e∈E，从图中删去边e之后，G分裂成两个不相连的子图，则称e为G的桥或割边 一般无向图（不一定连通）的割点与桥就是它的各个连通块的各点和桥 Tarjan算法基于无向图的深度优先遍历...
解2-SAT问题：从对称性出发
"本文将探讨2-SAT问题及其对称性解法，主要涉及如何解决一个特定类型的2-SAT问题，以及如何通过构建和分析图来寻找解决方案。" 2-SAT（二元满足问题）是计算机科学中的一个基础概念，属于逻辑满足问题的一种。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值