LightOJ - 1407 Explosion（2-SAT）

题目大意：有N个人，M种条件，K个限制
条件如下
1 x y：x或y至少一个要到
2 x y：x到的话，y可以随意。x不到的话，y也不到。(隐藏条件，y到的话，x必须得到)
3 x y：x或y至少一个缺席
4 x y：x或y其中一个要到，但不能同时到

限制如下
1 x y z：至少一个要到
2 x y z：至少一个不能到

解题思路：2-SAT判断的时候，多加一个判断，判断限制是否符合即可

#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;

const int MAXNODE = 5010 * 2;
int n, m, k, cas = 1;

struct Node {
    int type, a, b, c;
}node[10];

struct TwoSat{
    int n, top;
    vector<int> G[MAXNODE];
    bool mark[MAXNODE];
    int Stack[MAXNODE];

    void init(int n) {
        this->n = n;
        for (int i = 2; i <= 2 * n + 1; i++)
            G[i].clear();
        memset(mark, 0, sizeof(mark));
    }

    //x = xval或者y = yval，这个表示或的关系
    void AddClause(int x, int xval, int y, int yval) {
        x = x * 2 + xval;
        y = y * 2 + yval;
        G[x ^ 1].push_back(y);
        G[y ^ 1].push_back(x);
    }

    //x = xval的时候，y必须等于yval,这个表示且的关系
    void AddLimit(int x, int xval, int y, int yval) {
        x = x * 2 + xval;
        y = y * 2 + yval;
        G[x].push_back(y);
    }

    bool judge() {
        for (int i = 0; i < k; i++) {
            if (node[i].type == 2) {
                int x = 2 * node[i].a, y = 2 * node[i].b, z = 2 * node[i].c;
                if (mark[x] && mark[y] && mark[z]) return true;
            }
            else {
                int x = 2 * node[i].a + 1;
                int y = 2 * node[i].b + 1;
                int z = 2 * node[i].c + 1;
                if (mark[x] && mark[y] && mark[z]) return true;
            }
        }
        return false;
    }

    bool dfs(int u) {
        //当前需要标记的结点是u，如果u ^ 1这个结点已经被标记过了，就表示两个结点都要被标记掉，明显冲突了
        if (mark[u ^ 1]) return false;

        if (mark[u]) return true;
        mark[u] = true;
        //模拟栈
        Stack[++top] = u;
        if (judge()) return false;
        //和u相邻的点都进行标记，以判断是否出错
        for (int i = 0; i < G[u].size(); i++) 
            if (!dfs(G[u][i])) return false;
        return true;
    }

    bool solve() {
        for (int i = 2; i < 2 * (n + 1); i += 2) 
            //如果在其他点的标志过程中，其中一个点被标记了，就无需在枚举了，因为在dfs的过程中，和其相连的点也被标记了，较少了重复枚举
            if (!mark[i] && !mark[i ^ 1]) {
                top = 0;
                //假设xi为假是错误的，这时候就要进行回溯，将dfs过程中标记过的点还原，再判断对错 
                if (!dfs(i)) {
                    while (top) mark[Stack[top--]] = false;
                    if (!dfs(i ^ 1)) return false;
                }
            }
        return true;
    }

    void print() {
        int ans = 0;
        vector<int> members;
        for (int i = 2; i < 2 * (n + 1); i += 2) {
            if (mark[i]) { 
                ans++;
                members.push_back(i / 2);
            }
        }
        printf("%d", ans);
        for (int i = 0; i < members.size(); i++)
            printf(" %d", members[i]);
        printf(".\n");
    }
}Two;

//0表示到，1表示不到
void init() {
    scanf("%d%d%d", &n, &m, &k);
    Two.init(n);
    int type, a, b;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &type, &a, &b);
        if (type == 1) Two.AddClause(a, 0, b, 0);
        else if (type == 3) Two.AddClause(a, 1, b, 1);
        else if (type == 2) {
            Two.AddLimit(b, 0, a, 0);
            Two.AddLimit(a, 1, b, 1);
        }
        else {
            Two.AddLimit(a, 0, b, 1);
            Two.AddLimit(b, 0, a, 1);
            Two.AddLimit(a, 1, b, 0);
            Two.AddLimit(b, 1, a, 0);
        }
    }
    for (int i = 0; i < k; i++)
        scanf("%d%d%d%d", &node[i].type, &node[i].a, &node[i].b, &node[i].c);
    if (!Two.solve()) 
        printf("Case %d: Impossible.\n", cas++);
    else {
        printf("Case %d: Possible ", cas++);
        Two.print();
    }
}

int main() {
    int test;
    scanf("%d", &test);
    while (test--) init();
    return 0;
}