poj 3678 Katu Puzzle 2-SAT 建图入门

Description

Katu Puzzle is presented as a directed graph G(V, E) with each edge e(a, b) labeled by a boolean operator op (one of AND, OR, XOR) and an integer c (0 ≤ c ≤ 1). One Katu is solvable if one can find each vertex V_i a value X_i (0 ≤ X_i ≤ 1) such that for each edge e(a, b) labeled by op and c, the following formula holds:

X_a op X_b = c

The calculating rules are:

AND 0 1 0 0 0 1 0 1

OR 0 1 0 0 1 1 1 1

XOR 0 1 0 0 1 1 1 0

Given a Katu Puzzle, your task is to determine whether it is solvable.

Input

The first line contains two integers N (1 ≤ N ≤ 1000) and M,(0 ≤ M ≤ 1,000,000) indicating the number of vertices and edges.
The following M lines contain three integers a (0 ≤ a < N), b(0 ≤ b < N), c and an operator op each, describing the edges.

Output

Output a line containing "YES" or "NO".

Sample Input

4 4
0 1 1 AND
1 2 1 OR
3 2 0 AND
3 0 0 XOR

Sample Output

YES

Hint

X₀ = 1, X₁ = 1, X₂ = 0, X₃ = 1.

 　　根据上面直接建图

　　

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <string>
 #include <algorithm>
 #include <queue>
 #include <stack>

 using namespace std;
 const int maxn = 1e5 + ;
 const int  mod = 1e9 +  ;
 const int INF = 0x7ffffff;
 struct node {
     int v, next;
 } edge[maxn];
 int head[maxn], dfn[maxn], low[maxn];
 int s[maxn], belong[maxn], instack[maxn];
 int tot, cnt, top, flag, n, m;
 void init() {
     tot = cnt = top = flag = ;
     memset(s, , sizeof(s));
     memset(head, -, sizeof(head));
     memset(dfn, , sizeof(dfn));
     memset(instack, , sizeof(instack));
 }
 void add(int u, int v ) {
     edge[tot].v = v;
     edge[tot].next = head[u];
     head[u] = tot++;
 }
 void tarjan(int v) {
     dfn[v] = low[v] = ++flag;
     instack[v] = ;
     s[top++] = v;
     for (int i = head[v] ; ~i ; i = edge[i].next ) {
         int j = edge[i].v;
         if (!dfn[j]) {
             tarjan(j);
             low[v] = min(low[v], low[j]);
         } else if (instack[j]) low[v] = min(low[v], dfn[j]);
     }
     if (dfn[v] == low[v]) {
         cnt++;
         int t;
         do {
             t = s[--top];
             instack[t] = ;
             belong[t] = cnt;
         } while(t != v) ;
     }
 }
 int check() {
     for (int i =  ; i < n ; i++)
         if (belong[ * i] == belong[ * i + ]) return ;
     return ;
 }
 int main() {
     while(scanf("%d%d", &n, &m) != EOF) {
         if (n ==  && m == ) break;
         init();
         char op[];
         int x, y, c;
         for (int i =  ; i < m ; i++) {
             scanf("%d%d%d%s", &x, &y, &c, op);
             if (op[] == 'A') {
                 if (c) {
                     add( * x + ,  * x);
                     add( * y + ,  * y);
                 } else {
                     add( * x,  * y + );
                     add( * y,  * x + );
                 }
             }
             if (op[] == 'O') {
                 if (c) {
                     add( * x + ,  * y);
                     add( * y + ,  * x);
                 } else {
                     add( * x,  * x + );
                     add( * y,  * y + );
                 }
             }
             if (op[] == 'X') {
                 if (c) {
                     add( * x,  * y + );
                     add( * x + ,  * y);
                     add( * y,  * x + );
                     add( * y + ,  * x);
                 } else {
                     add( * x + ,  * y + );
                     add( * x,  * y);
                     add( * y + ,  * x + );
                     add( * y,  * x);
                 }
             }

         }
         for (int i =  ; i <  * n ; i++)
             if (!dfn[i]) tarjan(i);
         if (check()) printf("YES\n");
         else printf("NO\n");
     }
     return ;
 }