2-SAT存模板

最新推荐文章于 2024-08-04 12:23:15 发布
最新推荐文章于 2024-08-04 12:23:15 发布
阅读量361 收藏
点赞数
分类专栏： 搜索 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gyarenas/article/details/51820645
版权

只判定是否有解

例题：http://acm.hdu.edu.cn/showproblem.php?pid=3622

O(|V||E|) 方法


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
#include <cmath>
#include <set>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;

const int MAXN(201);
const int MAXE(40001);
const int MAXK(100010);
const int MAXL(10);
const int MAXC(2);
const int INF((INT_MAX - 1) / 2);
const int F(0);

template<typename T>
inline bool checkmax(T &a, const T &b) {
    return b > a ? ((a = b), true) : false;
}

template<typename T>
inline bool checkmin(T &a, const T &b) {
    return b < a ? ((a = b), true) : false;
}

template<typename T>
inline T ABS(T a) {
    return a < 0 ? -a : a;
}

double dis(double x1, double y1, double x2, double y2) {
    return sqrt((y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1));
}

double dis2(double x1, double y1, double x2, double y2) {
    return (y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1);
}

struct E {
    int u, v;
    E *next;
    E(int u_, int v_, int w_, E *n_) :u(u_), v(v_), next(n_) {}
    E(){}
};

double disArr[MAXN][MAXN];
double coor[MAXN][2];
int label[MAXN];
E *first[MAXN];
E edge[MAXE], *rear;
int st[MAXN], stn;

void init(int n) {
    memset(first, 0, sizeof(first[0])*(n + 1));
    rear = edge;
}

void addEdge(int u, int v) {
    rear->u = u;
    rear->v = v;
    rear->next = first[u];
    first[u] = rear++;
}

bool conflict(int a, int b, double m) {
    return disArr[a][b] < m;
}

bool dfs(int u) {
    int ind = u >> 1, fl = u & 1;
    if (label[ind] == -1)
        label[ind] = fl;
    else
        return label[ind] == fl;
    st[stn++] = ind;
    for (E *i = first[u]; i; i = i->next) {
        if (!dfs(i->v)) return false;
    }
    return true;
}

bool check(double m, int n) {
    init(n * 2);
    for (int i = 0; i < n; ++i) label[i] = -1;
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j) {
            int ti = i * 2, tj = j * 2;
            for (int k1 = 0; k1 < 2; ++k1)
                for (int k2 = 0; k2 < 2; ++k2) {
                    int a = ti | k1, b = tj | k2;
                    if (conflict(a, b, m)) {
                        addEdge(a, b ^ 1);
                        addEdge(b, a ^ 1);
                    }
                }
        }
    for (int i = 0; i < n; ++i) {
        if (label[i] != -1) continue;
        stn = 0;
        if (!dfs(i * 2)){
            while (stn > 0) label[st[--stn]] = -1;
            if (!dfs(i * 2 + 1)) return false;
        }
    }
    return true;
}

int main() {
    int n;
    while (~scanf("%d", &n)) {
        double low = 0, high = 0;
        init(n * 2);
        for (int i = 0; i < n; ++i) {
            int ti = i * 2;
            scanf("%lf%lf", coor[ti], coor[ti] + 1);
            scanf("%lf%lf", coor[ti+1], coor[ti+1] + 1);
        }
        for (int i = 0; i < 2 * n; ++i)
            for (int j = i + 1; j < 2 * n; ++j) {
                disArr[i][j] = disArr[j][i] = dis2(coor[i][0], coor[i][1], coor[j][0], coor[j][1]);
                checkmax(high, disArr[i][j]);
            }
        while (high - low > 1e-6) {
            double m = (high + low) / 2;
            if (check(m, n))
                low = m;
            else
                high = m;
        }
        printf("%.2f\n", sqrt((high + low) / 2)/2);
    }
    return 0;
}

O(|V|+|E|) 方法，此题题数据弱，不如上一个方法快


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
#include <cmath>
#include <set>
#include <stack>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;

const int MAXN(201);
const int MAXE(40001);
const int MAXK(100010);
const int MAXL(10);
const int MAXC(2);
const int INF((INT_MAX - 1) / 2);
const int F(0);

template<typename T>
inline bool checkmax(T &a, const T &b) {
    return b > a ? ((a = b), true) : false;
}

template<typename T>
inline bool checkmin(T &a, const T &b) {
    return b < a ? ((a = b), true) : false;
}

template<typename T>
inline T ABS(T a) {
    return a < 0 ? -a : a;
}

double dis(double x1, double y1, double x2, double y2) {
    return sqrt((y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1));
}

double dis2(double x1, double y1, double x2, double y2) {
    return (y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1);
}

struct E {
    int u, v;
    E *next;
    E(int u_, int v_, int w_, E *n_) :u(u_), v(v_), next(n_) {}
    E(){}
};

double disArr[MAXN][MAXN];
double coor[MAXN][2];
int label[MAXN];
E *first[MAXN];
E edge[MAXE], *rear;

void init(int n) {
    memset(first, 0, sizeof(first[0])*(n + 1));
    rear = edge;
}

void addEdge(int u, int v) {
    rear->u = u;
    rear->v = v;
    rear->next = first[u];
    first[u] = rear++;
}

bool conflict(int a, int b, double m) {
    return disArr[a][b] < m;
}

int dfn[MAXN], anc[MAXN];
int scc[MAXN];
int dfsClo, sccCnt;
stack<int> st;

void dfs(int u) {
    dfn[u] = anc[u] = dfsClo++;
    st.push(u);
    for (E *i = first[u]; i; i = i->next) {
        int v = i->v;
        if (dfn[v] == -1) {
            dfs(v);
            checkmin(anc[u], anc[v]);
        }
        else {
            if (scc[v] == -1) {
                checkmin(anc[u], dfn[v]);
            }
        }
    }
    if (dfn[u] == anc[u]) {
        int t;
        do {
            t = st.top();
            st.pop();
            scc[t] = sccCnt;
        } while (t != u);
        ++sccCnt;
    }
}

void findScc(int n) {
    for (int i = 0; i < n; ++i) dfn[i] = anc[i] = scc[i] = -1;
    dfsClo = sccCnt = 0;
    for (int i = 0; i < n; ++i)
        if (dfn[i] == -1)
            dfs(i);
}

bool check(double m, int n) {
    init(n * 2);
    for (int i = 0; i < n; ++i) label[i] = -1;
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j) {
            int ti = i * 2, tj = j * 2;
            for (int k1 = 0; k1 < 2; ++k1)
                for (int k2 = 0; k2 < 2; ++k2) {
                    int a = ti | k1, b = tj | k2;
                    if (conflict(a, b, m)) {
                        addEdge(a, b ^ 1);
                        addEdge(b, a ^ 1);
                    }
                }
        }
    findScc(n * 2);
    for (int i = 0; i < n; ++i)
        if (scc[i * 2] == scc[i * 2 + 1])
            return false;
    return true;
}

int main() {
    int n;
    while (~scanf("%d", &n)) {
        double low = 0, high = 0;
        init(n * 2);
        for (int i = 0; i < n; ++i) {
            int ti = i * 2;
            scanf("%lf%lf", coor[ti], coor[ti] + 1);
            scanf("%lf%lf", coor[ti+1], coor[ti+1] + 1);
        }
        for (int i = 0; i < 2 * n; ++i)
            for (int j = i + 1; j < 2 * n; ++j) {
                disArr[i][j] = disArr[j][i] = dis2(coor[i][0], coor[i][1], coor[j][0], coor[j][1]);
                checkmax(high, disArr[i][j]);
            }
        while (high - low > 1e-6) {
            double m = (high + low) / 2;
            if (check(m, n))
                low = m;
            else
                high = m;
        }
        printf("%.2f\n", sqrt((high + low) / 2)/2);
    }
    return 0;
}

增加了与操作和异或操作后

例题：http://poj.org/problem?id=3678

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
#include <cmath>
#include <set>
#include <stack>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;

const int MAXN(2010);
const int MAXE(4000010);
const int MAXK(100010);
const int MAXL(10);
const int MAXC(2);
const int INF((INT_MAX - 1) / 2);
const int F(0);

template<typename T>
inline bool checkmax(T &a, const T &b) {
    return b > a ? ((a = b), true) : false;
}

template<typename T>
inline bool checkmin(T &a, const T &b) {
    return b < a ? ((a = b), true) : false;
}

template<typename T>
inline T ABS(T a) {
    return a < 0 ? -a : a;
}

double dis(double x1, double y1, double x2, double y2) {
    return sqrt((y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1));
}

double dis2(double x1, double y1, double x2, double y2) {
    return (y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1);
}

struct E {
    int u, v;
    E *next;
    E(int u_, int v_, int w_, E *n_) :u(u_), v(v_), next(n_) {}
    E(){}
};

E *first[MAXN];
E edge[MAXE], *rear;

void init(int n) {
    memset(first, 0, sizeof(first[0])*(n + 1));
    rear = edge;
}

void addEdge(int u, int v) {
    rear->u = u;
    rear->v = v;
    rear->next = first[u];
    first[u] = rear++;
}


int dfn[MAXN], anc[MAXN];
int scc[MAXN];
int dfsClo, sccCnt;
stack<int> st;

void dfs(int u) {
    dfn[u] = anc[u] = dfsClo++;
    st.push(u);
    for (E *i = first[u]; i; i = i->next) {
        int v = i->v;
        if (dfn[v] == -1) {
            dfs(v);
            checkmin(anc[u], anc[v]);
        }
        else {
            if (scc[v] == -1) {
                checkmin(anc[u], dfn[v]);
            }
        }
    }
    if (dfn[u] == anc[u]) {
        int t;
        do {
            t = st.top();
            st.pop();
            scc[t] = sccCnt;
        } while (t != u);
        ++sccCnt;
    }
}

void findScc(int n) {
    for (int i = 0; i < n; ++i) dfn[i] = anc[i] = scc[i] = -1;
    dfsClo = sccCnt = 0;
    for (int i = 0; i < n; ++i)
        if (dfn[i] == -1)
            dfs(i);
}

int label[MAXN];

bool check(int n) {
    findScc(n * 2);
    for (int i = 0; i < n; ++i)
        if (scc[i * 2] == scc[i * 2 + 1])
            return false;
    for (int i = 0; i < n; ++i) {
        label[i] = scc[i * 2] < scc[i * 2 + 1] ? 1 : 0;
    }
    return true;
}

int rec[MAXN][2];

void AND(int a, int b) {
    addEdge(a ^ 1, a);
    addEdge(b ^ 1, b);
}
void OR(int a, int b) {
    addEdge(a ^ 1, b);
    addEdge(b ^ 1, a);
}
void XOR(int a, int b) {
    addEdge(a ^ 1, b);
    addEdge(b, a ^ 1);
    addEdge(b ^ 1, a);
    addEdge(a, b ^ 1);
}
void EOR(int a, int b) {
    addEdge(a,b);
    addEdge(a^1, b^1);
    addEdge(b, a);
    addEdge(b^1, a^1);
}

int main() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        init(2 * n);
        int a, b, c;
        char op[5];
        for (int i = 0; i < m; ++i) {
            scanf("%d%d%d%s", &a, &b, &c, op);
            switch (op[0]) {
            case 'A':
                if (c) AND(a*2, b*2);
                else OR(a * 2 + 1, b * 2 + 1);
                break;
            case 'O':
                if (c) OR(a * 2, b * 2);
                else AND(a * 2 + 1, b * 2 + 1);
                break;
            case 'X':
                if (c) XOR(a * 2, b * 2);
                else EOR(a * 2 , b * 2 );
                break;
            }
        }
        printf("%s\n", check(n) ? "YES" : "NO");
    }
    return 0;
}

输出最小字典序方案

例题：http://acm.hdu.edu.cn/showproblem.php?pid=1814
只能用 O(|V||E|) 方法


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
#include <cmath>
#include <set>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;

const int MAXN(16010);
const int MAXE(40010);
const int MAXK(100010);
const int MAXL(10);
const int MAXC(2);
const int INF((INT_MAX - 1) / 2);
const int F(0);

template<typename T>
inline bool checkmax(T &a, const T &b) {
    return b > a ? ((a = b), true) : false;
}

template<typename T>
inline bool checkmin(T &a, const T &b) {
    return b < a ? ((a = b), true) : false;
}

template<typename T>
inline T ABS(T a) {
    return a < 0 ? -a : a;
}

double dis(double x1, double y1, double x2, double y2) {
    return sqrt((y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1));
}

double dis2(double x1, double y1, double x2, double y2) {
    return (y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1);
}

struct E {
    int u, v;
    E *next;
    E(int u_, int v_, int w_, E *n_) :u(u_), v(v_), next(n_) {}
    E() {}
};

int label[MAXN];
E *first[MAXN];
E edge[MAXE], *rear;
int st[MAXN], stn;

void init(int n) {
    memset(first, 0, sizeof(first[0])*(n + 1));
    rear = edge;
}

void addEdge(int u, int v) {
    rear->u = u;
    rear->v = v;
    rear->next = first[u];
    first[u] = rear++;
}

bool dfs(int u) {
    int ind = u >> 1, fl = u & 1;
    if (label[ind] == -1)
        label[ind] = fl;
    else
        return label[ind] == fl;
    st[stn++] = ind;
    for (E *i = first[u]; i; i = i->next) {
        if (!dfs(i->v)) return false;
    }
    return true;
}

bool check(int n) {
    for (int i = 0; i < n; ++i) label[i] = -1;
    for (int i = 0; i < n; ++i) {
        if (label[i] != -1) continue;
        stn = 0;
        if (!dfs(i * 2)) {
            while (stn > 0) label[st[--stn]] = -1;
            if (!dfs(i * 2 + 1)) return false;
        }
    }
    return true;
}

int main() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        init(2 * n);
        int a, b;
        for (int i = 0; i < m; ++i) {
            scanf("%d%d", &a, &b);
            --a;
            --b;
            addEdge(a, b ^ 1);
            addEdge(b, a ^ 1);
        }
        if (check(n)) {
            for (int i = 0; i < n; ++i)
                printf("%d\n", (2 * i | label[i]) + 1);
        }
        else
            printf("NIE\n");
    }
    return 0;
}

输出任意一组方案

例题：http://poj.org/problem?id=3648
需注意的是此题要输出合法赋值取反后的结果


#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
#include <cmath>
#include <set>
#include <stack>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;

const int MAXN(5000);
const int MAXE(10010);
const int MAXK(100010);
const int MAXL(10);
const int MAXC(2);
const int INF((INT_MAX - 1) / 2);
const int F(0);

template<typename T>
inline bool checkmax(T &a, const T &b) {
    return b > a ? ((a = b), true) : false;
}

template<typename T>
inline bool checkmin(T &a, const T &b) {
    return b < a ? ((a = b), true) : false;
}

template<typename T>
inline T ABS(T a) {
    return a < 0 ? -a : a;
}

double dis(double x1, double y1, double x2, double y2) {
    return sqrt((y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1));
}

double dis2(double x1, double y1, double x2, double y2) {
    return (y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1);
}

struct E {
    int u, v;
    E *next;
    E(int u_, int v_, int w_, E *n_) :u(u_), v(v_), next(n_) {}
    E(){}
};

E *first[MAXN];
E edge[MAXE], *rear;

void init(int n) {
    memset(first, 0, sizeof(first[0])*(n + 1));
    rear = edge;
}

void addEdge(int u, int v) {
    rear->u = u;
    rear->v = v;
    rear->next = first[u];
    first[u] = rear++;
}


int dfn[MAXN], anc[MAXN];
int scc[MAXN];
int dfsClo, sccCnt;
stack<int> st;

void dfs(int u) {
    dfn[u] = anc[u] = dfsClo++;
    st.push(u);
    for (E *i = first[u]; i; i = i->next) {
        int v = i->v;
        if (dfn[v] == -1) {
            dfs(v);
            checkmin(anc[u], anc[v]);
        }
        else {
            if (scc[v] == -1) {
                checkmin(anc[u], dfn[v]);
            }
        }
    }
    if (dfn[u] == anc[u]) {
        int t;
        do {
            t = st.top();
            st.pop();
            scc[t] = sccCnt;
        } while (t != u);
        ++sccCnt;
    }
}

void findScc(int n) {
    for (int i = 0; i < n; ++i) dfn[i] = anc[i] = scc[i] = -1;
    dfsClo = sccCnt = 0;
    for (int i = 0; i < n; ++i)
        if (dfn[i] == -1)
            dfs(i);
}

int label[MAXN];

bool check(int n) {
    findScc(n * 2);
    for (int i = 0; i < n; ++i)
        if (scc[i * 2] == scc[i * 2 + 1])
            return false;
    for (int i = 0; i < n; ++i) {
        label[i] = scc[i * 2] < scc[i * 2 + 1] ? 0 : 1;
    }
    return true;
}

int main() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        init(2 * n);
        int a, b;
        char ca, cb;
        for (int i = 0; i < m; ++i) {
            scanf("%d %c %d %c", &a, &ca, &b, &cb);
            int ta = 2*a + (ca == 'h' ? 0 : 1);
            int tb = 2*b + (cb == 'h' ? 0 : 1);
            addEdge(ta, tb ^ 1);
            addEdge(tb, ta ^ 1);
        }
        addEdge(1, 0);
        if (check(n)) {
            bool pr(false);
            for (int i = 1; i < n; ++i) {
                if (pr) printf(" ");
                else
                    pr = true;
                printf("%d", i);
                printf("%c", ((label[i]^1) == 0 ? 'h' : 'w'));
            }
            printf("\n");
        }
        else
            printf("bad luck\n");
    }
    return 0;
}

算法的正确性简要分析

这里对赵爽在《2-SAT解法浅析》中的算法给出宏观的证明思路。
如果将 x 和┐x看做两个独立的符号，则一个合法方案应满足两个条件。
1. sat条件；
2. x 和┐x取值相异。

对于染色算法的正确性来说证明的思路大致如下：

假设染红色表示该点取1，染蓝色表示该点取0。首先由于我们的建图方法，只要保证不存在这样的 u→v ，使得 u 染红色，v染蓝色就可以保证条件1满足。

首先证明了存在一种染色方案，其满足条件2。

进一步证明该染色方案满足条件1。

就完成了整个证明。

添加了与操作和异(同)或操作后，可以仿照类似的思路，证明原算法仍然适用。

进一步根据对称性我们还可以证明，在原图中，按照拓扑逆序染色，被染蓝色的点，其祖先也早被染成蓝色，因此就得到了不用反向建图求具体方案的算法(对加入了与操作和异(同)或操作后的情况也成立)。

夜深人静写算法（一）- 搜索入门
英雄哪里出来
12-20 13万+
简要介绍计算机两大图论搜索算法：深度优先搜索和广度优先搜索
增加最少的边使有向图变为强连通图
霁月难逢 彩云易散
04-30 3485
http://codeforces.com/contest/22/problem/E 标题党。。。 此题是这个问题的简化版本，每个点出度至多为一。先强连通缩点，每个点出度至多为一可以保证从任一个入度为0的点出发只能到达一个出度为0的点 。按标号从第一个入度为0的点a开始，找到其对应的出度为0的点(缩后)a'，再找到第二个入度为0的点b，连边a'->b，...，直到最后一个出度为0的点z‘，连边
2-sat思想及入门
qq_43041641的博客
07-14 1255
2-sat思想及入门什么是2-sat例题分析建边判断有解输出方案完整代码 什么是2-sat 要知道2-sat是什么，我们先要知道什么是适定性（Satisfiability）问题，适，就是合适，定，就是确定，适定性问题通俗的说就是确定是否可以满足所有的条件？或者说就是确定一个满足所有条件的方案。取英文的前三个字母，简称sat问题。 通俗的sat问题表述一般是这样的： 有很多个集合，每个集合里面有若...
2-sat基础
qq_52406324的博客
04-05 1763
2-sat和一些题目
2-SAT 模板
Anxdada -- 我等风来也等你
05-15 331
// 只存求解模板, 具体证明请自行百度. 推荐一篇好博客 鉴于求解中的清晰度, 所以强连通部分选择使用Kosaraju算法实现, 可使代码清晰度提高很多. 注意这个算法比Tarjan的常数要大. 而且好像2-SAT问题关键在于建好图, 其他的貌似求求强连通即可. 然后知道强连通的序号和原始序号的关系即可. 板子: (单纯求最后的方案数以及方案的, 不要求字典序的, 复杂度O(V + E)...
P4782 【模板】2-SAT 题解
yaosichengalpha的博客
08-01 437
P4782 【模板】2-SAT 题解
2-SAT 问题 详解
繁凡さん的博客
09-20 2974
2-SAT 问题 详解
2-sat问题
weixin_43244265的博客
11-26 136
最近花了一点心思研究2-sat模型，看了很多论文博客等等，也在POJ上做了一点题。其实这个东西也还挺好玩的，当然，前提是每道题你都有认真分析，认真想清楚模型的意义，搞明白为什么可以这样，而不是简单的知道怎样做，就套上一个模板了事，那样，是不是也太糟蹋这门科学了。 关于2-sat，基本上所有人都会推荐两个资料： 伍昱 由对称性解2-sat问题（ppt） 赵爽 2-sat解...
2-sat模板
rgndao的博客
03-09 167
2-sat用于解决这样一类问题：给出n个二元组，每个二元组必选出一个元素，而这些元素间可能有互斥的情况，要求给出合理方案。我们可以知道，对于二元组，如果因为被排斥而不选择某个元素，那么意味着必定选择另一个，这就使得问题可解，3-sat及以上似乎没有多项式算法……？ tarjan方法利用tarjan算法求出每个点所属scc，如果二元组两...
2-sat-总结+例题
weixin_30502157的博客
04-02 724
https://www.cnblogs.com/31415926535x/p/10644419.html 从寒假就开始准备学2sat，，然后当时了解了一下模板就溜了，，，一直到上个星期，，三月底才好好重新的看一下，，，做了一些题，，感觉大致的了解了2sat的基本套路，，一般的题都是在建图做文章，，这题出现的频率貌似也不高，，，之后就放一放吧，，，啥时候忘记了就翻出来看一看，，嘿嘿 概述 2-sat...
2-SAT
EricQian的博客
09-08 63
主要内容 \(\operatorname{2~-~SAT}\)，简单的说就是给出 \(n\) 个集合，每个集合有两个元素，已知若干个 \(<a,b>\) ，表示 \(a\) 与 \(b\) 矛盾(其中 \(a\) 与 \(b\) 属于不同的集合)。然后从每个集合选择一个元素，判断能否一共选 \(n\) 个两两不矛盾的元素。显然可能有多种选择方案，一般题中只需要求出一种即可 。 解决方...
2-SAT备忘（codeforces 1791H）
最新发布
xiayuyang
08-04 1189
例题解法：每一列的三个式子中里至少要有两个为1。可以看成任意两个式子里要有一个为1，所以就是任意两个式子不能为0。一列等价于3条限制。建完图之后直接跑2-SAT就行。2-SAT本质上是将一些01变量间的限制关系以图的形式表现出来。在同一个SCC里则不可行。感性理解一下就是我们选了。然后判定可行解只需要对全图跑SCC，如果。并且在一长串路径后得到我们还得选。，我们会建两个点分别表示。然后我们定义一条限制。
文章总数35祭+tarjan的多种用法：求强连通分量，缩点，割点、桥，LCA，点双连通图、边双联通图、2-SAT问题
weixin_43872370的博客
02-12 515
文章总数35祭+tarjan的三种用法：求强连通分量，缩点，割点和桥 tarjan算法十分奇妙，有许多不同的运用。下面我们一起看看。 0.背景知识 先度娘一下tarjan: Robert Tarjan，计算机科学家，以LCA、强连通分量等算法闻名。他拥有丰富的商业工作经验，1985年开始任教于普林斯顿大学。 Robert Tarjan他还在多所大学担任学术职务，如：康奈尔大学（1972-1973年...
所有边权均不相同的无向图最小生成树是唯一的证明
热门推荐
霁月难逢 彩云易散
12-29 2万+
用反证法，假设G存在俩个不同的最小生成树 ①.设G的俩个不同的最小生成树T1 T2，设这俩颗生成树的并集为子图G1，G1为连通图且T1 T2显然为G1的最小生成树，将G1中两颗生成树的公共边删去，得到子图G2。G2由一个或多个连通分量组成，其中至少有一个连通分量的最小生成树不唯一（否则若所有连通分量的最小生成树唯一，则将删掉的公共边加上，则T1等于T2，这与假设相矛盾）。 ②.对其中一个最小生
关于有重边图的双连通分量
霁月难逢 彩云易散
03-24 2664
有向图的的情况比较简单只有一种强连通，重边和连向自己的边对于强连通都没有任何影响 无向图的双连通要分点双连通(biconnected)和边双连通(edge_biconnected)，连向自己的边对于俩种双连通也没有任何影响，但是重边对点双连通没有影响，但是对于边双连通有影响，因为在求边双连通时，要求对于任意俩点至少存在两条“边不重复”的路径，所以这个时候表示图我们不能用vector了，而是用邻接
关于图的m着色问题
霁月难逢 彩云易散
09-16 1391
以前一直以为图的着色问题解等于最大团的顶点数,今天发现原来是有问题的,例如5个顶点的环最大团顶点数为2，但却需要三种颜色。关于m着色问题可以用二分+DLX解决，应该会比爆搜要快。 poj 1129 #include #include #include #include #include #include #include #include #include #in
Dilworth定理与有向无圈图的链覆盖
霁月难逢 彩云易散
11-08 1272
Dilworth定理的应用条件为偏序集，定理转化为图论语言就是偏序集哈斯图的最长反链等于其最小链点覆盖数。 对于有的问题可以通过贪心分解链求最小链点覆盖或直接求其最大反链长度，从而得出解，例如：俩个全序集的笛卡尔积构成的偏序关系。 例题： http://poj.org/problem?id=1065 http://poj.org/problem?id=1548 http://poj.org
无向图中国邮路(小数据版)
霁月难逢 彩云易散
11-23 1221
http://ac.jobdu.com/problem.php?pid=1430 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #inclu
非负权无向图的全局最小割
霁月难逢 彩云易散
06-03 1213
O(n^3)的StoerWagner算法 论文：http://wenku.baidu.com/view/072209d5360cba1aa811da51
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值