poj 3678 2-SAT

/*
题意：有n个数，要求满足XopY == c，操作的结果在表格中，尽管看不懂，但是实际上和平常的没有
区别，问是否能有n个值使得所有操作都满足

题解：2-SAT
题目中有位的操作，以及对于数字的选取只有选与不选，而且是限制条件，这样就会比较容易想到是
用2-SAT来做，关键在建图(http://blog.csdn.net/shuangde800/article/details/8876533)这个博文
我觉得说得比较容易理解，其实就是将所有的点都拆成两个点，然后分别组成一个集合和一个对立的
集合，最终我们是通过求强连通来寻找这些点是否与对立的点在同一连通分量中，如果同时出现在同
一个强连通之中，则表示从一个点的状态可以推出它的对立状态，这显然是错的(例如x=1可以推导出
x=-1)，因此当我们要满足一个限制条件时，我们要做的就是通过加边使得这个条件可以满足，而且
对于其它的状态则要通过加边来使得它不满足(即通过加边使得这些状态肯定不可能出现)，因此在加
边时有两个方向思考，一个是使限制条件满足，另一个是使其余状态不满足(两个应该等价吧，没有科
学的证明)，然后就是通过求强连通查找不可能满足的点：

例子：
(x,y)表示两个不同的点选与不选(即是正的状态还是对立状态)
状态的组合有：(0,0),(0,1),(1,0),(1,1)
要使得xANDy为1，则需要x和y都为1，亦即(1,1)成立，其余的三个组合都不成立，则通过加边使得
另外三个状态不成立，要使(0,0)不满足，则需要加边(x,opp[y])表示当x为0时，y一定为1，这样
(0,0)的状态就被否定了(注意反向(y,opp[x])也需要加边，因为要形成强连通，单向还不能保证会形
成强连通，这里只是大概的理解，说得并不透彻)，然后一直加边直至所有其它状态都矛盾。
*/
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>

#define clr(a,b) (memset(a,b,sizeof(a)))
#define cpy(a,b) (memcpy(a,b,sizeof(b)))

using namespace std;

const int NV = 4050;
const int NE = 4000010;
const int W = 0;
const int R = 1;
const int B = 2;

int opp[NV];
int in[NV];
bool ans[NV];
int col[NV];
int nn;

inline int Min(int a, int b) {return a < b ? a : b;}
struct SCC {
    int deep,scc, top, SZ, n;
    struct edge {int v, next;} E[NE];
    int pre[NV], dep[NV], low[NV], id[NV], st[NV];
    bool in[NV];
    inline void init(int _n) {
        n = _n;
        clr(pre, -1);
        clr(dep, -1);
        clr(in,false);
        deep = scc = SZ = top = 0;
    }
    void tarjan(int u) {
        int v, i;
        dep[u] = low[u] = ++ deep;
        st[top++] = u;

        in[u] = true;
        for (i = pre[u]; i != -1; i = E[i].next) {
            v = E[i].v;
            if (dep[v] == -1) {
                tarjan(v);
                low[u] = Min(low[u], low[v]);
            }
            else if (in[v]) {
                low[u] = Min(low[u], dep[v]);
            }
        }
        if (low[u] == dep[u]) {
            do {
                v = st[--top];
                in[v] = false;
                id[v] = scc;
            } while (u != v);
            scc ++;
        }
    }
    inline void insert(int u, int v) {
        E[SZ].v = v;
        E[SZ].next = pre[u];
        pre[u] = SZ ++;
    }
    inline void solve() {
        for (int i = 0; i < n; i++) {
            if (dep[i] == -1) {
                tarjan(i);
            }
        }
    }
} G;
inline void topsort() {
    int i, j, u, v;
    int now, id;
    vector<int> vec[NV], gra[NV];
    queue<int> Q, q;
    clr(in, 0);
    clr(col, 0);
    for (i = 0; i < nn; i++) {
        u = G.id[i];
        gra[u].push_back(i);

        for (j = G.pre[i]; j != -1; j = G.E[j].next) {
            v = G.id[ G.E[j].v ];
            if (u != v) {
                vec[v].push_back(u);
                in[u]++;
            }
        }
    }
    for (i = 0; i < G.scc; i++) {
        if (in[i] == 0) {
            Q.push(i);
        }
    }
    while (!Q.empty()) {
        now = Q.front(),Q.pop();
        if (col[now] != W) continue;
        col[now] = R;
        for (i = gra[now].size() - 1; i >= 0; i--) {
            while (!q.empty()) q.pop();
            q.push( G.id[ opp[ gra[now][i] ] ] );
            while (!q.empty()) {
                id = q.front(),q.pop();
                if (col[id] == B) continue;
                col[id] = B;
                for (j = vec[id].size() - 1; j >= 0; j--) {
                    q.push(vec[id][j]);
                }
            }
        }
        for (i = vec[now].size() - 1; i >= 0; i--) {
            if (--in[ vec[now][i] ] == 0) {
                Q.push(vec[now][i]);
            }
        }
    }
}
int main(void) {
    int i, j;
    int x, y, c, n, m;
    char op[10];
    while (~scanf("%d%d", &n, &m)) {
        nn = n * 2;
        for (i = 0; i < nn; i++)
            opp[i] = (i ^ 1);
        G.init(nn);
        for (i = 0; i < m; i++) {
            scanf("%d%d%d%s", &x, &y, &c, op);
            x *= 2;
            y *= 2;
            if(!strcmp(op, "AND")){  
                if(c){  
                    G.insert(x, opp[y]),    G.insert(y, opp[x]);     //0, 0   
                    G.insert(x, y),      G.insert(opp[y], opp[x]);   // 0, 1  
                    G.insert(opp[x], opp[y]),  G.insert(y, x);       // 1, 0  
                }else{  
                    G.insert(opp[x], y),    G.insert(opp[y], x);     // 1, 1   
                }  
            }else if(!strcmp(op, "OR")){  
                if(c){  
                    G.insert(x, opp[y]),    G.insert(y, opp[x]);     //0, 0   
                }else{  
                    G.insert(x, y),      G.insert(opp[y], opp[x]);   // 0, 1  
                    G.insert(opp[x], opp[y]),  G.insert(y, x);       // 1, 0  
                    G.insert(opp[x], y),    G.insert(opp[y], x);     // 1, 1   
                }    
            }else{ // XOR  
                if(c){  
                    G.insert(x, opp[y]),    G.insert(y, opp[x]);     //0, 0   
                    G.insert(opp[x], y),    G.insert(opp[y], x);     // 1, 1   
                }else{  
                    G.insert(x, y),      G.insert(opp[y], opp[x]);   // 0, 1  
                    G.insert(opp[x], opp[y]),  G.insert(y, x);       // 1, 0  
                }  
            }
        }
        G.solve();
        for (i = 0; i < nn; i += 2) {
            if (G.id[i] == G.id[opp[i]]) {
                break;
            }
        }
        if (i < nn)
            printf("NO\n");
        else
            printf("YES\n");
    }
    return 0;
}