2 -- sat 整理

最新推荐文章于 2024-03-07 15:15:07 发布
原创 最新推荐文章于 2024-03-07 15:15:07 发布 · 600 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#struct #c #im

HDU 3062

简单的判断，裸的2SAT

#include <cstdio>
#include <cstring>
const int N = 2100;
const int M = 1100 * 1000 * 2;
struct Node
{
    int adj,next;
} node[M];
struct TT
{
    int DFN,LOW,belongs;
} num[N];
int first[N],n,e;
bool instack[N];
int stack[N],b_cnt,idx,top;
void init()
{
    e=0;
    for(int i=0; i<=2*n; i++)
    {
        first[i]=-1;
        num[i].DFN=num[i].LOW=0;
        num[i].belongs=0;
        instack[i]=false;
    }
}
void insertEdge(int u,int v)
{
    node[e].adj=v;
    node[e].next=first[u];
    first[u]=e++;;
}
void Tarjan(int u)
{
    int v;
    num[u].DFN=num[u].LOW=(++idx);
    instack[u]=true;
    stack[++top]=u;
    for(int p=first[u]; p!=-1; p=node[p].next)
    {
        v=node[p].adj;
        if(!num[v].DFN)
        {
            Tarjan(v);
            if(num[v].LOW<num[u].LOW)
                num[u].LOW=num[v].LOW;
        }
        else if(instack[v]&&num[v].DFN<num[u].LOW)
            num[u].LOW=num[v].DFN;
    }
    if(num[u].DFN==num[u].LOW)
    {
        b_cnt++;
        do
        {
            v=stack[top--];
            instack[v]=false;
            num[v].belongs=b_cnt;
        }
        while(u!=v);
    }
}
bool Tarjan_SCC()
{
    b_cnt=top=idx=0;
    for(int i=0; i<2*n; i++)
        if(!num[i].DFN) Tarjan(i);
    for(int i=0; i<2*n; i+=2)
        if(num[i].belongs==num[i^1].belongs)
            return false;
    return true;
}
int main()
{
    int m;
    while (scanf("%d%d",&n,&m)==2)
    {
        init();
        int a,b,c,d;
        for (int i=0; i<m; ++i)
        {
            scanf("%d%d%d%d",&a,&b,&c,&d);
            if(c)  a= 2 * a + 1;
            else a = 2 * a;
            if(d) b= 2 * b + 1;
            else b = 2 * b;
            insertEdge(a, b^1);
            insertEdge(b, a^1);
        }
        if (!Tarjan_SCC())
        {
            printf("NO\n");
        }
        else
            printf("YES\n");
    }
    return 0;
}



hdu  1824  题目描述不是特别清楚吧

#include <cstdio>
#include <cstring>
const int N = 1010 * 6;
const int M = 100000;
struct Node
{
    int adj,next;
} node[M];
struct TT
{
    int DFN,LOW,belongs;
} num[N];
int first[N],n,e;
bool instack[N];
int stack[N],b_cnt,idx,top;
void init()
{
    e=0;
    for(int i=0; i<=6*n; i++)
    {
        first[i]=-1;
        num[i].DFN=num[i].LOW=0;
        num[i].belongs=0;
        instack[i]=false;
    }
}
void insertEdge(int u,int v)
{
    node[e].adj=v;
    node[e].next=first[u];
    first[u]=e++;;
}
void Tarjan(int u)
{
    int v;
    num[u].DFN=num[u].LOW=(++idx);
    instack[u]=true;
    stack[++top]=u;
    for(int p=first[u]; p!=-1; p=node[p].next)
    {
        v=node[p].adj;
        if(!num[v].DFN)
        {
            Tarjan(v);
            if(num[v].LOW<num[u].LOW)
                num[u].LOW=num[v].LOW;
        }
        else if(instack[v]&&num[v].DFN<num[u].LOW)
            num[u].LOW=num[v].DFN;
    }
    if(num[u].DFN==num[u].LOW)
    {
        b_cnt++;
        do
        {
            v=stack[top--];
            instack[v]=false;
            num[v].belongs=b_cnt;
        }
        while(u!=v);
    }
}
bool Tarjan_SCC()
{
    b_cnt=top=idx=0;
    for(int i=0; i<6*n; i++)
        if(!num[i].DFN) Tarjan(i);
    for(int i=0; i<3*n; i++)
        if(num[i].belongs==num[i+3*n].belongs)
            return false;
    return true;
}
int main()
{
    int m;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        init();
        int te = n * 3;
        int a, b, c;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d%d%d", &a, &b, &c);
            insertEdge(a, b + te);//a和b，c之间的互斥关系
            insertEdge(a, c + te);
            insertEdge(b, a + te);
            insertEdge(c, a + te);
            insertEdge(a + te, b);
            insertEdge(a + te, c);
            insertEdge(b + te, a);
            insertEdge(c + te, a);

            insertEdge(b, c);
            insertEdge(c, b);
            insertEdge(b + te, c + te);
            insertEdge(c + te, b + te);
            //
        }

        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d", &a, &b);
            insertEdge(a, b + te);
            insertEdge(b, a + te);//注意a+te和b+te是没有影响的
        }

        if(Tarjan_SCC())  printf("yes\n");
        else printf("no\n");

    }
    return 0;
}


hdu 3715  去年成都赛区的一道题目，二分一下就行了

#include <cstdio>
#include <cstring>
const int N = 210 * 3;
const int M = 210 * 210 * 3;
struct Node
{
    int adj,next;
} node[M];
struct TT
{
    int DFN,LOW,belongs;
} num[N];
int first[N],n,e,m;
bool instack[N];
int stack[N],b_cnt,idx,top;
int a[10010], b[10010], c[10010];
void init()
{
    e=0;
    memset(first, -1, sizeof(first));
    memset(instack, 0, sizeof(instack));
    for(int i=0; i<=2*n; i++)
    {
        num[i].DFN=num[i].LOW=0;
        num[i].belongs=0;
    }
}
void insertEdge(int u,int v)
{
    node[e].adj=v;
    node[e].next=first[u];
    first[u]=e++;;
}
void Tarjan(int u)
{
    int v;
    num[u].DFN=num[u].LOW=(++idx);
    instack[u]=true;
    stack[++top]=u;
    for(int p=first[u]; p!=-1; p=node[p].next)
    {
        v=node[p].adj;
        if(!num[v].DFN)
        {
            Tarjan(v);
            if(num[v].LOW<num[u].LOW)
                num[u].LOW=num[v].LOW;
        }
        else if(instack[v]&&num[v].DFN<num[u].LOW)
            num[u].LOW=num[v].DFN;
    }
    if(num[u].DFN==num[u].LOW)
    {
        b_cnt++;
        do
        {
            v=stack[top--];
            instack[v]=false;
            num[v].belongs=b_cnt;
        }
        while(u!=v);
    }
}
bool Tarjan_SCC()
{
    b_cnt=top=idx=0;
    for(int i=0; i<2*n; i++)
        if(!num[i].DFN) Tarjan(i);
    for(int i=0; i<2*n; i+=2)
        if(num[i].belongs==num[i^1].belongs)
            return false;
    return true;
}
bool  check(int dep)
{
    init();
    for(int i = 0; i < dep; i++)
    {
        int x = a[i];// 0..2*x   1..2*x+1
        int y = b[i];
        if(c[i] == 2)
        {
            //x[a] + y[b] != 2
            insertEdge(x * 2 + 1, y * 2);
            insertEdge(y * 2 + 1, x * 2);
        }
        else if(c[i] == 1)
        {
            insertEdge(x * 2 + 1, y * 2 + 1);
            insertEdge(y * 2 + 1, x * 2 + 1);
            insertEdge(x * 2, y * 2);
            insertEdge(y * 2, x * 2);
        }
        else
        {
            insertEdge(x * 2, y * 2 + 1);
            insertEdge(y * 2, x * 2 + 1);
        }
    }
    if(Tarjan_SCC())  return true;
    else return false;
}
void solve(int m)
{
    int l = 0, r = m;
    int ans = l;
    while(l <= r)
    {
        int mid = (l + r) / 2;
        //printf("mid = %d\n", mid);
        if(check(mid))
        {
            if(mid > ans)  ans = mid;
            l = mid + 1;
        }
        else
        r = mid - 1;
    }
    printf("%d\n", ans);
}
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &m);
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &a[i], &b[i], &c[i]);
        }
        solve(m);
    }
    return 0;
}



HDU 3622  去年天津赛区的一道预选赛的题目

#include <cstdio>
#include <cstring>
#include <cmath>
const double eps=1e-10;//注意这个要开大
struct T_T
{
    int x,y;
} q[505];
struct Node
{
    int adj,next;
} node[505*505];
struct TT
{
    int DFN,LOW,belongs;
} num[505];
int first[550],n,e;
double map[505][505];
double min,max;
bool instack[550];
int stack[550],b_cnt,idx,top;
double len(int i,int j)
{
    return sqrt(1.0*(q[i].x-q[j].x)*(q[i].x-q[j].x)+1.0*(q[i].y-q[j].y)*(q[i].y-q[j].y));
}
void init()
{
    e=0;
    for(int i=1; i<=2*n; i++)
    {
        first[i]=-1;
        num[i].DFN=num[i].LOW=0;
        num[i].belongs=0;
        instack[i]=false;
    }
}
void insertEdge(int u,int v)
{
    node[e].adj=v;
    node[e].next=first[u];
    first[u]=e++;;
}
void Tarjan(int u)
{
    int v;
    num[u].DFN=num[u].LOW=(++idx);
    instack[u]=true;
    stack[++top]=u;
    for(int p=first[u]; p!=-1; p=node[p].next)
    {
        v=node[p].adj;
        if(!num[v].DFN)
        {
            Tarjan(v);
            if(num[v].LOW<num[u].LOW)
                num[u].LOW=num[v].LOW;
        }
        else if(instack[v]&&num[v].DFN<num[u].LOW)
            num[u].LOW=num[v].DFN;
    }
    if(num[u].DFN==num[u].LOW)
    {
        b_cnt++;
        do
        {
            v=stack[top--];
            instack[v]=false;
            num[v].belongs=b_cnt;
        }
        while(u!=v);
    }
}
bool Tarjan_SCC()
{
    b_cnt=top=idx=0;
    for(int i=1; i<=2*n; i++)
        if(!num[i].DFN) Tarjan(i);
    for(int i=1; i<=n; i++)
        if(num[i].belongs==num[i+n].belongs)
            return false;
    return true;
}
bool check(double d)
{
    init();
    for(int i=1; i<=n; i++)
        for(int j=i+1; j<=n; j++)
        {
            if(map[i][j]<d) insertEdge(i,j+n),insertEdge(j,i+n);
            if(map[i][j+n]<d) insertEdge(i,j),insertEdge(j+n,i+n);
            if(map[i+n][j]<d) insertEdge(i+n,j+n),insertEdge(j,i);
            if(map[i+n][j+n]<d) insertEdge(i+n,j),insertEdge(j+n,i);
        }
    return Tarjan_SCC();
}
double solve()
{
    double ans=min;
    while(fabs(max-min)>=eps)
    {
        double mid=(min+max)/2;
        if(check(mid))
        {
            if(ans<mid) ans=mid;
            min=mid;
        }
        else max=mid;
    }
    return ans;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1; i<=n; i++)
        {
            scanf("%d%d",&q[i].x,&q[i].y);
            scanf("%d%d",&q[i+n].x,&q[i+n].y);
        }
        min=1000000.00,max=-1.0;
        for(int i=1; i<=2*n; i++)
            for(int j=1; j<=2*n; j++)
            {
                double l=len(i,j);
                if(l>max) max=l;
                if(l<min) min=l;
                map[i][j]=l;
            }
        printf("%0.2lf\n",solve()/2);
    }
    return 0;
}



52、高度可满足随机 2 - SAT 问题的研究与算法实现
carrot的博客
08-10 38
本文围绕高度可满足的随机2-SAT问题，从核心（core）与连通分量的理论分析入手，结合植入赋值与多数表决策略，研究了公式的结构性质，并设计了高效的算法1，通过逐步取消赋值与穷举搜索相结合的方式求解。同时，深入分析了多数表决在不同分布下的性能表现，并结合泊松分布模型对不满足子句数量进行了量化估计。最后，基于理论推导给出了随机Max-2-SAT问题中最大可满足子句数的估计区间，为算法评估和问题复杂度分析提供了依据。研究结果为随机2-SAT问题的求解提供了坚实的理论支撑和实用的算法框架。
【ortools 源码系列7】Ortools CP-SAT 用法示例源码实战详解
wang2leee的博客
12-03 2430
本文笔者根据实战整理的它的全面用法，作为工具文档，看此一篇就够了。希望大家受用
【算法/图论】2-SAT问题详解
qaqwqaqwq的博客
08-02 9031
要求出强连通分量，就需要对原图进行缩点，顺便可以求出得到的有向无环图的拓扑序。数组存储每个节点的染色，实际上就是有向无环图的逆拓扑序（因为在DFS树中越深的节点越先被染色）。没有出现某个变量及其否定在同一个强连通分量的情况，所以是可满足的。...
2-SAT问题相关理论和算法
wanglianda2007的博客
01-23 2113
2-SAT算法相关原理。
【算法学习】2-SAT
Pengwill's Blog
08-26 4066
2-SAT 2-SAT一般给出nnn个布尔变量（取0或者取1），再给出mmm个关于这些布尔变量的约束条件（见下文），求出是否能找到解满足这些约束条件。 2-SAT可以建图，转换成强连通分量进而判断矛盾问题。对于布尔变量，只有2个取值，取0或者取1，所以对于任意一个布尔变量xixix_i，我们可用其原变量iii（即取1值）和其反变量i′i′i'（即取0值）依据约束条件来构建图。 约束条件 ...
图论 —— 2-SAT 问题
Alex_McAvoy的博客
03-15 8877
【问题概述】 2-SAT问题是这样的：有n个布尔变量xi，另有m个需要满足的条件，每个条件的形式都是“xi为真/假或者xj为真/假“ SAT 是适定性(Satisfiability)问题的简称，一般形式为：k-适定性问题，简称：k-SAT。 当 k>2 时，k-SAT 是 NP 完全的，因此一般讨论的是 k=2 的情况，即：2-SAT 问题。 关于 2-SAT 问题，简单的来说就是给...
【总结】2-SAT
慢慢前行，跨越预言
09-09 1579
一、2-SAT 简介：    SAT是适定性(Satisfiability)问题的简称 。一般形式为k-适定性问题，简称 k-SAT。 当k>2时，k-SAT是NP完全的。因此一般讨论的是k=2的情况，即2-SAT问题。 2-SAT就是2判定性问题（条件只有一个，不是这个就
2-SAT算法学习资料整理分享
标题“2-SAT学习资料”指的是有关二元可满足性问题（2-Satisfiability，简称2-SAT）的学习材料集合。2-SAT是一种计算复杂性理论中的问题，主要研究是否可以在一组逻辑公式中找到变量的真值赋值，使得整个公式为真。...
基于streamlit库的CP-SAT求解日志分析器
最新发布
Linshaodan520的博客
03-07 1400
介绍了能够自动分析CP-SAT求解日志的工具
模板 - 2 - SAT问题
繁凡さん的博客
09-21 702
有 n 个布尔变量 x1∼xnx_1\sim x_nx1​∼xn​​，另有 m 个需要满足的条件，每个条件的形式都是 「x_i为 true / false 或 x_j​为 true / false」。比如 「x_1为真或 x_3为假」、「x_7​为假或 x_2为假」。2-SAT 问题的目标是给每个变量赋值使得所有条件得到满足。 //时间复杂度O(n+m) //当 x 所在的强连通分量的拓扑序在 ¬x 所在的强连通分量的拓扑序之后取 x //为真 ,注意我们得到的是拓扑逆序，所以要写成color[x] &lt
基于寻找2-SAT子问题的SAT算法
09-04
将SAT问题化为2-SAT子问题进行求解，算法效果比UnitWalk算法高效
2-SAT图解法
07-18
有2-SAT图的介绍与解法，有详细的例题讲解。仙人掌图的判断方法与其3个性质，最后还附上模板。
2-SAT算法
Saber
08-27 2340
SAT：布尔方程的可满足性问题。 2—SAT：合取范式中的每个子句中的文字个数都不超过两个 2-SAT一般解决的是一类比较固定的问题，即类似于模板题，对这类题的描述为： 现有n个人，并且每个人都只能够从各自的两个选项中选择一个，然后两两的选择都会相互影响，问是否每个人选择一个之后，能够满足条件。 解决这类问题关键是建边，一般对第一个选项记为xi，对第二个选项记为非x
【研究总结】2-sat问题
热门推荐
JarjingX
01-20 2万+
序言 　　         最近花了一点心思研究2-sat模型，看了很多论文博客等等，也在POJ上做了一点题。其实这个东西也还挺好玩的，当然，前提是每道题你都有认真分析，认真想清楚模型的意义，搞明白为什么可以这样，而不是简单的知道怎样做，就套上一个模板了事，那样，是不是也太糟蹋这门科学了。 　　关于2-sat，基本上所有人都会推荐两个资料：         伍昱 由对称性解2-sat问
2-SAT问题相关算法与题目讲解（O(n*m)与O(m)）
ztx
02-14 4778
2-SAT问题 信息学竞赛 OI ACM O(m) O(nm) 2-SAT问题张天翔blog.youkuaiyun.com/hzoi_ztxztx97@qq.com 前置技能 拓扑排序 基本逻辑运算 强联通分量 问题模型给出n个布尔值组成的序列{Ai}\{A_i\}，给出一些限制，每个限制最多针对两个元素（故称为“2-SAT”），先要求确定AA序列的值以满足所有限制关系。问题分析首先列出7种有意义的限制（其
【原创】2-SAT算法 入门（上） 未完成
致上
11-17 305
2-SAT算法 2-SAT问题的定义 SAT是适定性(Satisfiability)问题的简称 。一般形式为k-适定性 问题，简称 k-SAT。 当k&gt;2时，k-SAT是NP完全的。因此一般 讨论的是k=2的情况，即2-SAT问题。 适定性问题？What the Huak? 什么意思呢？ 就2-SAT问题而言。给定N个元素，每个元素有两种取值，要么为真，要么为...
2SAT总结
Cabinfever的专栏
03-18 637
做完了POJ的6道2SAT，总结一下 2SAT算法流程      1.构图      2.求SCC      3.判断有无解      4.缩点反向建图      5.拓扑排序      6.染色并输出 构图模型：     模型一：两者（A，B）不能同时取 　　    那么选择了A就只能选择B’，选择了B就只能选择A’ 　　    连边A→B’，B→A’   
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 1万+
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值