【小结】2-sat

bit_line bit_line 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 800+累计阅读 877平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄12年
关注
原创 最新推荐文章于 2026-05-22 15:23:16 发布 877 阅读 AI 写同款· GEO 优化 ›
2-SAT简介 前方是2-SAT蒟蒻版（大雾） 蒟蒻不会打代码啊QAQ,代码有参考 配合洛谷食用风味更佳 2-SAT, 就是2-Satisfiability。 Satisfiability，可满足性。 背景故事 我要请大家开party！–ObliaObliaOblia ObliaObliaOblia这样想。 因为ObliaObliaOblia是萌妹子同时是OIer和MOer，所以她可以同时邀请到OI和MO的神... 阅读详情

2−sat 小结

  • 2−sat解决的是可满足性问题，并且每个合取范式中的文字个数不多于2个。
  • 形式为: (a∨¬b)∧(¬c∨¬d)∧(¬a∨d)⋯
  • 将所有a∨b改成(¬a⇒b)∧(¬b⇒a)
  • 建边，每个变量a对应两个点a和a+n
  • 如果存在cmp[a]==cmp[a+n]不成立，否则成立。且如果cmp[a]>cmp[a+n]，令a=true，否则令a=false即为原式的一组解。
#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

const int MAX = 1024;
vector<int> G[MAX];
vector<int> rG[MAX];
stack<int> S;
bool vis[MAX];
int cmp[MAX];
int V;

inline void add_edge(int u, int v)
{
    G[u].push_back(v);
    rG[v].push_back(u);
}

void dfs(int v)
{
    vis[v] = true;
    for (vector<int>::iterator it = G[v].begin(); it != G[v].end(); ++it)
    {
        if (!vis[*it])
        {
            dfs(*it);
        }
    }

    S.push(v);
}

void rdfs(int v, int k)
{
    vis[v] = true;
    cmp[v] = k;
    for (int i = 0; i < rG[v].size(); ++i)
    {
        if (!vis[rG[v][i]])
        {
            rdfs(rG[v][i], k);
        }
    }
}

int scc()
{
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= V; ++i)
    {
        if (!vis[i])
        {
            dfs(i);
        }
    }

    memset(vis, false, sizeof(vis));
    int k = 0;

    while (!S.empty())
    {
        int p = S.top();
        S.pop();

        if (!vis[p])
        {
            rdfs(p, ++k);
        }
    }

    return k;
}

int main()
{

    /*
     * add_edge(u, v)
     * N nodes --> V = 2 * N
     * ...
     */
    /*
     * EXAMPLE: solve (a V !b) ^ (b V c) ^ (!c V !a)
     */
    int N = 3;
    V = N << 1;

    add_edge(3, 4);
    add_edge(1, 0);
    add_edge(4, 2);
    add_edge(5, 1);
    add_edge(2, 3);
    add_edge(0, 5);

    scc();

    bool ok = true;
    for (int i = 1; i <= N; ++i)
    {
        if (cmp[i] == cmp[i + N])
        {
            ok = false;
            break;
        }
    }

    if (ok)
    {
        puts("YES");
        for (int i = 1; i <= N; ++i)
        {
            printf("%s ", cmp[i] > cmp[i + N] ? "true" : "false");
        }
        puts("");
    }
    else
    {
        puts("NO");
    }

    return 0;
}

POJ3683 Priest John′s Busiest Day

  • 问牧师能不能忙过来
  • 对婚礼x，记在开始举行仪式为x=true，则可根据冲突关系，得出方程，求解即可。
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

const int MAX = 2048;
vector<int> G[MAX];
vector<int> rG[MAX];
stack<int> stk;
bool vis[MAX];
int cmp[MAX];
int V;

inline void init()
{
    for (int i = 1; i <= V; ++i)
    {
        G[i].clear();
        rG[i].clear();
    }
}

inline void add_edge(int u, int v)
{
    G[u].push_back(v);
    rG[v].push_back(u);
}

void dfs(int u)
{
    vis[u] = true;
    for (int i = 0; i < G[u].size(); ++i)
    {
        if (!vis[G[u][i]])
        {
            dfs(G[u][i]);
        }
    }
    stk.push(u);
}

void rdfs(int u, int k)
{
    vis[u] = true;
    cmp[u] = k;
    for (int i = 0; i < rG[u].size(); ++i)
    {
        if (!vis[rG[u][i]])
        {
            rdfs(rG[u][i], k);
        }
    }
}

int scc()
{
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= V; ++i)
    {
        if (!vis[i])
        {
            dfs(i);
        }
    }

    memset(vis, false, sizeof(vis));
    int k = 0;
    while (!stk.empty())
    {
        int p = stk.top();
        stk.pop();

        if (!vis[p])
        {
            rdfs(p, ++k);
        }
    }

    return k;
}

int S[MAX >> 1], T[MAX >> 1], D[MAX >> 1];

inline bool error(int l1, int r1, int l2, int r2)
{
    return l1 > l2 ? r2 > l1 : r1 > l2;
}

void gao(int n)
{
    V = n << 1;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = i + 1; j <= n; ++j)
        {
            if (error(S[i], S[i] + D[i], S[j], S[j] + D[j]))
            {
                add_edge(i, j + n);
                add_edge(j, i + n);
            }
            if (error(S[i], S[i] + D[i], T[j] - D[j], T[j]))
            {
                add_edge(i, j);
                add_edge(j + n, i + n);
            }
            if (error(T[i] - D[i], T[i], S[j], S[j] + D[j]))
            {
                add_edge(i + n, j + n);
                add_edge(j, i);
            }
            if (error(T[i] - D[i], T[i], T[j] - D[j], T[j]))
            {
                add_edge(i + n, j);
                add_edge(j + n, i);
            }
        }
    }

    scc();
    //printf("%d\n", scc()); //scc();

    for (int i = 1; i <= n; ++i)
    {
        if (cmp[i] == cmp[i + n])
        {
            puts("NO");
            return;
        }
    }

    puts("YES");
    for (int i = 1; i <= n; ++i)
    {
        if (cmp[i] > cmp[i + n])
        {
            printf("%02d:%02d %02d:%02d\n", S[i] / 60, S[i] % 60, (S[i] + D[i]) / 60, (S[i] + D[i]) % 60);
        }
        else
        {
            printf("%02d:%02d %02d:%02d\n", (T[i] - D[i]) / 60, (T[i] - D[i]) % 60, T[i] / 60, T[i] % 60);
        }
    }
}

int main()
{
    int N;
    while (~scanf(" %d", &N))
    {
        int h, m;
        for (int i = 1; i <= N; ++i)
        {
            scanf(" %d:%d", &h, &m);
            S[i] = h * 60 + m;
            scanf(" %d:%d", &h, &m);
            T[i] = h * 60 + m;
            scanf(" %d", D + i);

            //printf("%d:[%d, %d]:%d\n", i, S[i], T[i], D[i]);
        }
        gao(N);
    }
    return 0;
}

HDU3062

#include <bits/stdc++.h>
using namespace std;

const int MAX = 1024;
vector<int> G[MAX << 1];
vector<int> rG[MAX << 1];
bool vis[MAX << 1];
int cmp[MAX << 1];
stack<int> stk;
int V;

inline void add_edge(int u, int v)
{
    G[u].push_back(v);
    rG[v].push_back(u);
}

void dfs(int u)
{
    vis[u] = true;
    for (int i = 0; i < G[u].size(); ++i)
    {
        if (!vis[G[u][i]])
        {
            dfs(G[u][i]);
        }
    }
    stk.push(u);
}

void dfs2(int u, int k)
{
    vis[u] = true;
    cmp[u] = k;
    for (int i = 0; i < rG[u].size(); ++i)
    {
        if (!vis[rG[u][i]])
        {
            dfs2(rG[u][i], k);
        }
    }
}

int scc()
{
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= V; ++i)
    {
        if (!vis[i])
        {
            dfs(i);
        }
    }

    memset(vis, false, sizeof(vis));
    int k = 0;
    while (!stk.empty())
    {
        int p = stk.top();
        stk.pop();

        if (!vis[p])
        {
            dfs2(p, ++k);
        }

    }
    return k;
}

bool gao(int n)
{
    scc();

    for (int i = 1; i <= n; ++i)
    {
        if (cmp[i] == cmp[i + n])
        {
            return false;
        }
    }
    return true;
}

inline void read(int& x)
{
    char ch;
    while ((ch = getchar()) < '0' || ch > '9');

    x = ch - '0';
    while ((ch = getchar()) >= '0' && ch <= '9')
    {
        x = (x << 3) + (x << 1) + ch - '0';
    }
}

int main()
{
    int n, m;
    while (~scanf(" %d %d", &n, &m))
    {
        V = n << 1;
        for (int i = 1; i <= V; ++i)
        {
            G[i].clear();
            rG[i].clear();
        }

        int a1, a2, c1, c2;
        while (m--)
        {
            //scanf(" %d %d %d %d", &a1, &a2, &c1, &c2);
            read(a1);
            read(a2);
            read(c1);
            read(c2);
            if (c1 > 0)
            {
                a1 += n;
            }
            if (c2 > 0)
            {
                a2 += n;
            }

            /* 
             * !a1 V !a2
             * <->  ((a1 -> !a2) V (a2 -> !a1))
             */
            add_edge(a1, a2 > n ? a2 - n : a2 + n);
            add_edge(a2, a1 > n ? a1 - n : a1 + n);
        }
        puts(gao(n) ? "YES" : "NO");
    }
    return 0;
}

HDU 1824

#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

const int MAX = 1024 * 3 * 2;
vector<int> G[MAX];
vector<int> rG[MAX];
stack<int> S;
bool vis[MAX];
int cmp[MAX];
int V;

inline void add_edge(int u, int v)
{
    G[u].push_back(v);
    rG[v].push_back(u);
}

void dfs(int v)
{
    vis[v] = true;
    for (vector<int>::iterator it = G[v].begin(); it != G[v].end(); ++it)
    {
        if (!vis[*it])
        {
            dfs(*it);
        }
    }

    S.push(v);
}

void rdfs(int v, int k)
{
    vis[v] = true;
    cmp[v] = k;
    for (int i = 0; i < rG[v].size(); ++i)
    {
        if (!vis[rG[v][i]])
        {
            rdfs(rG[v][i], k);
        }
    }
}

int scc()
{
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= V; ++i)
    {
        if (!vis[i])
        {
            dfs(i);
        }
    }

    memset(vis, false, sizeof(vis));
    int k = 0;

    while (!S.empty())
    {
        int p = S.top();
        S.pop();

        if (!vis[p])
        {
            rdfs(p, ++k);
        }
    }

    return k;
}

bool gao(int N)
{
    scc();

    for (int i = 1; i <= N; ++i)
    {
        if (cmp[i] == cmp[i + N])
        {
            return false;
        }
    }
    return true;
}

int main()
{
    int T, M;
    while (~scanf(" %d %d", &T, &M))
    {
        V = T * 3 * 2;
        int N = T * 3;
        for (int i = 0; i <= V; ++i)
        {
            G[i].clear();
            rG[i].clear();
        }

        int c, a, b;
        for (int i = 1; i <= T; ++i)
        {
            scanf(" %d %d %d", &c, &a, &b);
            ++c, ++a, ++b;
            add_edge(c + N, a);
            add_edge(c + N, b);

            add_edge(a + N, c);
            add_edge(b + N, c);

            add_edge(c, a + N);
            add_edge(c, b + N);
            add_edge(a, c + N);
            add_edge(b, c + N);
        }

        for (int i = 1; i <= M; ++i)
        {
            scanf(" %d %d", &a, &b);
            ++a, ++b;
            add_edge(a, b + N);
            add_edge(b, a + N);
        }

        puts(gao(N) ? "yes" : "no");
    }

    return 0;
}

POJ 3207

#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

const int MAX = 1024;
vector<int> G[MAX];
vector<int> rG[MAX];
stack<int> S;
bool vis[MAX];
int cmp[MAX];
pair<int, int> line[MAX >> 1];
int V;

inline void add_edge(int u, int v)
{
    G[u].push_back(v);
    rG[v].push_back(u);
}

void dfs(int v)
{
    vis[v] = true;
    for (vector<int>::iterator it = G[v].begin(); it != G[v].end(); ++it)
    {
        if (!vis[*it])
        {
            dfs(*it);
        }
    }

    S.push(v);
}

void rdfs(int v, int k)
{
    vis[v] = true;
    cmp[v] = k;
    for (int i = 0; i < rG[v].size(); ++i)
    {
        if (!vis[rG[v][i]])
        {
            rdfs(rG[v][i], k);
        }
    }
}

int scc()
{
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= V; ++i)
    {
        if (!vis[i])
        {
            dfs(i);
        }
    }

    memset(vis, false, sizeof(vis));
    int k = 0;

    while (!S.empty())
    {
        int p = S.top();
        S.pop();

        if (!vis[p])
        {
            rdfs(p, ++k);
        }
    }

    return k;
}

bool gao(int n)
{

    scc();

    for (int i = 1; i <= n; ++i)
    {
        if (cmp[i] == cmp[i + n])
        {
            return false;
        }
    }

    return true;
}

bool error(int x1, int y1, int x2, int y2)
{
    int xx = min(x1, y1);
    int yy = min(x1, y1);
    return (x2 > xx && x2 > yy) || (y2 > xx && y2 > yy)
        || (x2 > xx && x2 < yy) || (y2 > xx && y2 < yy)
        || (x2 < xx && x2 < yy) || (y2 < xx && y2 < yy);
}

int main()
{
    int n, m;
    while (~scanf(" %d %d", &n, &m))
    {
        V = m << 1;
        for (int i = 1; i <= V; ++i)
        {
            G[i].clear();
            rG[i].clear();
        }
        int a, b;
        for (int i = 1; i <= m; ++i)
        {
            scanf(" %d %d", &line[i].first, &line[i].second);
            ++line[i].first, ++line[i].second;
        }

        for (int i = 1; i <= m; ++i)
        {
            for (int j = i + 1; j <= m; ++j)
            {
                if (error(line[i].first, line[i].second, line[j].first, line[j].second))
                {
                    printf("error at (%d, %d)\n", i, j);
                    //add_edge
                    add_edge(i, j + m);
                    add_edge(j, i + m);
                }
            }
        }

        puts(gao(m) ? "panda is telling the truth..." : "the evil panda is lying again");
        for (int i = 1; i <= m; ++i)
        {
            if (cmp[i] > cmp[i + m])
            {
                printf("true ");
            }
            else
            {
                printf("false ");
            }
        }
        puts("");
    }
    return 0;
}
收录于
图论

当前文章被收录于：

图论
35 篇文章 0 人学习
订阅专栏 查看详情
2-sat

当前文章被收录于：

2-sat
1 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
S32DS 3.5.8离线包怎么用？保姆级教程教你手动安装S32K3开发环境（附资源下载） 本文详细介绍了S32DS 3.5.8离线包的安装方法，适用于S32K3开发环境的手动搭建。从资源获取、完整性验证到分步安装指南，提供了全面的离线部署解决方案，特别适合军工/车企内网开发等场景。文章还包含版本选择建议、常见问题排查及团队协作方案，帮助开发者高效完成环境配置。 阅读详情

相关推荐

300Kg载重履带式无人车底盘定制开发技术详解

通过精准的需求分析、科学的方案设计、严格的研发与测试以及完善的交付与培训流程，可以打造出符合客户需求的优质产品。300Kg载重履带式无人车底盘的定制开发，旨在打造一款承载能力强、行驶稳定、适应复杂地形的无人运输平台。根据应用场景选择合适的动力源，并进行性能优化，确保无人车在载重情况下仍能保持稳定的行驶速度和动力输出。根据需求分析结果，设计无人车底盘的总体方案，包括动力系统选择、结构设计、负载管理策略等。进行详细的研发工作，包括零部件的选型与采购、样机的制作与调试等。

专注多旋翼、复合翼无人机技术研究，从事低空经济行业。 958

【算法】2-SAT问题

算法

gyk038的博客 198

浮点数加法器设计

一.设计内容及其要求 内容 根据浮点数的运算规则和IEEE754标准，实现浮点数的加法运算器。 要求： 浮点数格式：符号位1位，阶码8位，尾数23位 要求该实验能完整的体现浮点数的运算的五个步骤：对阶、尾数求和、规格化、舍入（要求使用对偶舍入）、溢出判断。 二.基本要素 浮点数 浮点数即实数，实数是所有有理数和无理数的集合。它之所以被称作浮点数，是因为小数点在数中的位置并不是固定的。一个浮点数值分为两部分存储：数值以及小数点在数值中的位置。 计算机中的浮点运算的计算结果一般是不确定的，一块芯片的浮点运算

Phoenix_ZengHao的博客 1万+

2-SAT适定性(Satisfiability)问题知识点详解

首先我们考虑将2-SAT问题往图论的方向靠，我们发现每个点要么取0，要么取1。因此对于ai，我们建两个点2i−1与2i分别表示ai取0和1 然后我们考虑建边来表示这些关系，我们令一条有向边的意义：x→y表示如果选择了x就必须选y 那么我们可以举一些简单的例子来总结下连边的规律（用i′表示i的反面）： i,j不能同时选：选了i就要选j′，选j就要选i′。故i→j′,j→i′。一般操作即为aixoraj=1 i,j必须同时选：选了i就要选j，选j就要选i。故i→j,j→i。一般操作即为aixoraj=0

zeng_jun_yv的博客 2455

一文搞定3D卷积

在讨论卷积核的时候，是不把channel维加进去的 核 = 一个可以滑动的窗口 窗口内不同位置数据之间的权值共享 3D卷积，卷积核会在3个方向上运动，那么卷积核的运动需要有三个自由度（一小块立方体，在一个大面包块内3个方向上滑动 2D卷积，卷积核只在2个方向上运动，因此只有两个自由度（一小片纸，在一大张纸内2个方向上滑动 1D卷积，卷积核只在1个方向上运动，因此只有一个自由度（一条滑窗，在一大长线上1个方向上滑动 一个卷积核运算一次 得到一个输出值 以上讨论了单个卷积核，接下来考虑多通道，一个卷积核对应一

njuptalex的博客 3万+

逆向拼多多长连接：Frida+Python协议还原实战

长连接是现代移动App实现低延迟、高并发通信的核心技术，其原理在于复用TCP通道避免HTTP频繁建连开销，并通过自定义二进制协议提升传输效率与安全性。在电商场景中，长连接不仅承载业务数据，更集成了动态密钥协商、设备指纹绑定、应用层加密等多重防护机制，显著提升数据窃取与自动化采集难度。本文聚焦真实商业级长连接逆向工程，以拼多多（PDD）v12.86.0为案例，详解如何利用Frida在JNI层精准Hook encrypt/decrypt函数捕获明文，结合Python构建协议解析器与会话管理器，实现对商品详情（I

weixin_30843121的博客 1115

图论--2-SAT--详解

问题描述： 现有一个由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...

日拱一卒,功不唐捐 3978

Unity Shader实战：用Matcap给你的低模角色快速换上‘次世代’材质（附完整Shader代码）

本文详细介绍了Unity中Matcap技术的实战应用，通过Shader代码实现低模角色的次世代材质表现。Matcap技术利用预烘焙光照贴图，显著提升材质质感同时保持极低性能消耗，特别适合移动游戏和独立开发。文章包含完整Shader代码、平面模型着色优化方案及动态环境反射增强技巧，帮助开发者快速提升低模视觉效果。

weixin_28718755的博客 385

2-SAT

SAT：satisfiability，可满足性2-SAT 是说约束条件在两两元素之间一个比较典型的 2-sat 问题是聚会问题，每家夫妻二人必须去一个，给定一组关系，某两人关系不好不能同时出席，作为主办方能否请恰好 n 个人列席。

Ranye的博客 386

LabVIEW状态机实战：用STM32+DHT11搭建温湿度监测系统（附完整VI源码）

本文详细介绍了如何利用LabVIEW状态机模式与STM32微控制器、DHT11温湿度传感器构建温湿度监测系统。通过硬件选型、状态机设计、LabVIEW程序实现及系统优化等环节，提供了一套完整的解决方案，并附有VI源码，助力开发者快速实现嵌入式温湿度监测应用。

weixin_42549723的博客 518

Lm317电压源芯片制作电流源

还在找电流源芯片么？如何使用电压源芯片快速搭建电流源。

Ekko的博客 1万+

2-SAT的一些小结

///1  2-SAT问题，通俗的说就是有n对点（2n个点），从每对点中选出一个点，共选出n个点，而且要满足若干个这样的条件：某两点不能同时被选出。     设一对点为x、~x，如果a被选出则b一定要被选出，就在图中加有向弧(a,b)表示这种关系。那么如果a,b（a!=b,a!=~b）不能同时被选出，那么加两条有向弧(a,~b),(b,~a)。这样由图的对称性可以证明，2-SAT有解等价于任取

lethic的专栏 4109

YOLO26-Quantized：面向国产AI芯片的全栈量化方案，适配昇腾310P与寒武纪MLU270

在算力国产化替代的行业趋势下，昇腾310P、寒武纪MLU270已成为工业边缘视觉、智能检测场景的主流国产AI芯片选型。针对原生YOLO26模型在国产芯片上推理效率低、算子兼容性差、量化精度塌陷三大核心痛点，本文提出YOLO26-Quantized全栈量化方案，覆盖训练感知量化（QAT）、离线静态量化（PTQ）、模型编译优化、芯片专属部署全流程。

专注于Python爬虫开发，分享爬虫技巧、项目实战与反爬经验，使用Scrapy、BeautifulSoup等工具，解决数据抓取难题。 762

【2-SAT】2sat问题小结

其实2sat问题比较简单（至少我目前还没做过很难的2sat）， 而且也是很好写的一个算法，我估计即使没学过的选手（dalao）考场上遇到了自己手推都能推出来…问题描述2sat问题是一种逻辑判定问题 给出一个形如（a0∨b0）∧(a1xorb1)∧(a2∧bn)...（a_0∨b_0）∧(a_1 xor b_1)∧(a_2 ∧ b_n)...的逻辑表达式，它的特点是，由与符号连接每个部分，每个部分

氧化钠的博客 922

VC中sqlite的使用

在VC中对sqlite的使用，实现数据库大批数据的快速插入，读取数据库中的数据在ListCtrl中显示

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面，电脑运行连游戏界面都一样大小，很怀旧，很真实，（英文版）强烈推荐，很小的文件，很难才找到的。

2-sat 小结

定义 简略的说， nnn 个变量 aia_iai​，且 ai∈[0,1]a_i\in[0,1]ai​∈[0,1]。 给出一些条件，形式如下： aia_iai​ opopop aj=0/1(op∈[and,or,xor])a_j =0/1(op\in[and,or,xor])aj​=0/1(op∈[and,or,xor]) 求解 2−SAT2-SAT2−SAT 即找到一组合法的 aaa 满足所有限...

人生如戏 207

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术，以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索，主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式，计算机控制系统的数学描述与基本分析方法，以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

2-SAT算法小结

定义 SAT 是 Satisfiability 的简称，一般记作 k−SATk-SATk−SAT 即 k−k-k−适应性 问题。 由于当 k>2k>2k>2 时是个NPC问题，所以只考虑 k=2k=2k=2 ，即 2−SAT2-SAT2−SAT 问题。 一般来说，就是有若干个位置，每个位置 aia_iai​ 的状态为 0/10/10/1 中的一种，然后有若干个限制，每个限制形如 ai∗aj=0/1a_i*a_j=0/1ai​∗aj​=0/1，其中 ∗*∗ 可以是 and,or,xora

a_forever_dream的博客 966

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

2-sat小结

最近做了一些2-sat的题，

575

2-SAT问题的小结

简介 　　什么是2-SAT呢？就是有一些集合，每个集合中有且仅有两个元素，且不能同时选取两个元素，集合间的元素存在一定的选择关系，求解可行性及可行方案。 算法 1、连边 2、跑tarjan 3、判可行性，即同一集合中的两个点是否同属一个强连通块 4、缩点建新图，连反边 5、拓扑序，若当前点没有被访问过，则选择该点，不选择其另外的点 连边 2-SAT算法本身并不难，关键是...

WZZ66631的博客 199

2-SAT(小结)

学习目标： 2-SAT(小结) 这个人讲的很好，我就不详细讲了 学习内容： 注意点 1.适用范围：x1&x2=0,问给出 m 个关系表达式后，能否给这 n 个变量找出一个赋值的方法，使得满足所有的表达式； 2.对于每个变量都只有两种取值：0 / 1，那么对于每个点，我们把每个变量拆成 true 点和 false 点； 3.要注意只有关系明确的时候才能建边； 其中一个不成立则另一个一定成立（这是明确的关系）； 4.无解的情况：某一个变量的 false 能走到 true，从 true 也能走到 fals

qq_43653111的博客 224

[学习笔记]2-SAT 小结

目录 2-SAT 小结 2-SAT 小结 从SAT说起 布尔可满足性问题（Boolean satisfiability problem；SAT)）属于决定性问题，也是第一个被证明属于NP完全的问题。 此问题在计算机科学上许多领域的皆相当重要，包括计算机科学基础理论、算法、人工智能、硬件设计等等。---摘...

aigongshi8561的博客 184

2_SAT问题小结

先写写最近生活的一点感想，唉。。。今天真是失败的一天呐，算是知道了自己的一个定位，高中的时候觉得自己无所不能，现在才明白自己其实没有什么事情是能够做得好的。。。以前一直自嘲是穷屌，现在应该算是明白了自己确实是个穷屌，不能够奢望做很多事情，只希望能把目前最爱的ACM继续努力地做下去，不管别人说什么。。。 2_SAT虽然只写了两道水题，但是还是写写总结吧，加深一点理解吧。感觉2_SAT问题，讲的就是

无限大な梦のあとの 何もない世の中じゃ 713

[2-sat]小结

因为一直不怎么会这个东西，所以今天整理一下这个东西的内容。 原来这个东西这么简单的吗。2sat里面一条边x-&gt;y表示x选了之后y必须选，只要建出满足这种条件的边之后跑tarjan就可以知道到底有没有解了。因此x &amp;^| y这种布尔运算就可以试一试 x在取某个值时y会不会强制取值，会的话就连边就行了，然后tarjan一下，看一看 x和!x是否在同一个联通块里，如果都没有的话就说明有一...

Gzb1128的栖息地 237

2-SAT 小结

　　PS：今天（2014.10.27）准备PPT，明天在组合数学课上与大家一起分享一下2-SAT。我以为是一件简单的事情。但是，当我看了自己这篇博客以后，发现居然还是不懂。很多资料不全，也没仔细讲。整理了一下，又修改了。尽量让自己下次再看到这博客的时候，一遍下来就能懂。虽然引用了别人的博客，我尽量讲得不需要进入别人的博客就能看懂。 　　一些这方面的内容写得很好的博客。（排列是随机的。可...

weixin_30363817的博客 167

【2-SAT】学习小结

　　这两天学习了一下2-SAT，主要参考了以下两个资料： 　　　　　《由对称性解2-SAT问题》 　　　　　《2-SAT解法浅析》 　　另外还有这个博客我觉得讲得挺白话的。 建图： 　　2-SAT问题远没有网络流那样复杂，只要抓住关系建好图基本就直接可以解了，在这类问题中建边的规则就是“必须”，对于边<i，j>，它的意义就是选择了i就必须选j。 　　对于题目中给出的每对关系...

weixin_30772105的博客 141
上一篇： 【小结】强联通分量分解
下一篇： 【小结】SG生成函数(Grundy函数)
点赞 0
评论 0
书签 书签 0
bit_line
bit_line
博客等级 码龄12年 33粉丝 150原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值