2-SAT （Tarjan）—— Katu Puzzle ( POJ 3678 )

• 题目链接：
  http://poj.org/problem?id=3678

• 分析：
  给出N个数字，值可以为0或者1，然后给出M个操作，每个操作对第a个数和第b个数进行 AND/OR/XOR 操作，并且结果要等于c。问这M个操作能否成功进行。

• 题解：
  N个数，每个数可以为0（x）或者1（~x），这是一道很明显的2-SAT，但是怎么建边呢。 题中给出了M个操作，我们一一分析一下。

  • AND：若值为1，则a, b都必须为1，那么我们建边 a->~a，b->~b。这样的目的是，把这两个数的0值都指向1值，下次如果有操作，需要这两个数为0的时候，就会进一步找到1，进而得出矛盾；
    若值为0，则a,b不能全为1，即挑选a为1时，b必须为0：~a->b; 挑选b为1时，a必须为0：~b->a。

  • OR：若值为0，则a, b都必须为0，那么我们建边 ~a->a，~b->b。这样的目的是，把这两个数的1值都指向0值，下次如果有操作，需要这两个数为1的时候，就会进一步找到0，进而得出矛盾；
    若值为1，则a,b不能全为0，即挑选a为0时，b必须为1：a->~b; 挑选b为0时，a必须为1：b->~a。

  • XOR：若值为1的时候，则a,b值必须不同，那么建边~a->b,a->~b,b->~a,~b->a;
    若值为0的时候，则a,b值必须相同，那么建边a->b,~a->~b,b->a,~b->~a。

• AC代码：
  

/*************************************************************************
    > File Name: test.cpp
    > Author: Akira 
    > Mail: qaq.febr2.qaq@gmail.com 
 ************************************************************************/

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <set>
#include <list>
#include <ctime>
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))
using namespace std;

#define MaxN 100000
#define MaxM MaxN*10
#define INF 0x3f3f3f3f
#define bug cout<<88888888<<endl;
#define MIN(x,y) (x<y?x:y)
#define MAX(x,y) (x>y?x:y)

// and 1 : 同侧都为1    ;  0 : 异侧或者同0
// or  1 : 异侧或者同1  ;  0 : 同侧都为0
// xor 1 : 异侧        ;   0 :  同侧

int N, M;
int A[MaxN];

struct Edge
{
    int from,to,next;
}edge[MaxM];
int head[MaxN],cont;

int low[MaxN];
int dfn[MaxN];

int Stack[MaxN], top;
int belong[MaxN];
int inStack[MaxN];
int Index, cnt;


void init()
{
    MST(head,-1);
    MST(dfn,-1);
    CLR(low);
    CLR(inStack);
    cont=0;
    Index = cnt = 1;
    top=0;
}

void add(int u,int v)
{
    edge[cont].from = u;
    edge[cont].to=v;
    edge[cont].next=head[u];
    head[u]=cont++;
}

void Tarjan(int x)
{
    low[x] = dfn[x] = Index;                // 刚搜到一个节点时low = dfn
    Index++;
    Stack[++top] = x;                       // 将该节点入栈
    inStack[x] = 1;                         // 将入栈标记设置为1
    for(int i=head[x];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        if(dfn[v ]== -1)
        {
            Tarjan(v);
            low[x]=MIN(low[x], low[v]);     // 回溯的时候改变当前节点的low值
        }
        else if(inStack[v])
        {
            low[x] = MIN(low[x], dfn[v]);   // 更新当前节点的low值，这里的意思是两个节点之间有一条可达边，
        }
    }
    if(low[x] == dfn[x])
    {
        for(int v=-1;v!=x;top--)
        {
            v = Stack[top];
            inStack[v] = false;
            belong[v] = cnt;
        }
        cnt++;
    }
}

int main()
{
    while(~scanf("%d%d", &N, &M))
    {
        init();
        int a, b , c;
        string op;
        while(M--)
        {
            scanf("%d%d%d", &a, &b, &c);
            cin >> op;
            if(op == "AND")
            {
                if(c == 1)
                {
                    add(a, a+N);
                    add(b, b+N);
                }
                else
                {
                    add(a+N, b);
                    add(b+N, a);
                }
            }
            if(op == "OR")
            {
                if(c == 0)
                {
                    add(a+N, a);
                    add(b+N, b);
                }
                else
                {
                    add(a, b+N);
                    add(b, a+N);
                }
            }
            if(op == "XOR")
            {
                if(c == 1)
                {
                    add(a, b+N);
                    add(a+N, b);
                    add(b, a+N);
                    add(b+N, a);
                }
                else
                {
                    add(a, b);
                    add(a+N, b+N);
                    add(b, a);
                    add(b+N, a+N);
                }
            }
        }
        for(int i=0;i<N;i++)
            if(dfn[i] == -1)
                Tarjan(i);
        int flag = 0;
        for(int i=0;i<N;i++)             // 遍历每条边，找到缩点之后的边
        {
            if(belong[i] == belong[i+N])       // 两点之间有边，但不是属于一个强联通分量的边
            {
                flag = 1;
                break;
            }
        }
        if(flag) puts("NO");
        else puts("YES");
    }
}