2-Sat小结

关于2-sat，其实就是一些对于每个问题只有两种解，一般会给出问题间的关系，比如and，or，not等关系，判定是否存在解的问题。。

具体看http://blog.csdn.net/jarjingx/article/details/8521690，该博客写得很不错的。

下面是LRJ白书上给的2-sat，个人觉得写的很不错。。效率也很高。

#define maxn 500
struct TwoSat{
     int n;
     vector<int> G[maxn * 2];
     bool mark[maxn * 2];
     int S[maxn * 2], c;
     bool dfs(int x){ // 搜索一组解 
          if (mark[x^1]) return false; //出现冲突 
          if (mark[x]) return true;
          mark[x] = true;
          S[c++] = x;
          for (int i = 0; i < G[x].size(); ++i)
              if (!dfs(G[x][i])) return false;
          return true;
     }

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

     void add_clause(int x, int xv, int y, int yv){
           x = x * 2 + xv;
           y = y * 2 + yv; //x,y不能同时存在，那么如果选了y，合法解必定要选x^1
           G[x].push_back(y^1); 
           G[y].push_back(x^1); 
     }

     bool solve(){
           for (int i = 0; i < n * 2; i += 2)
               if (!mark[i] && !mark[i+1]){
                    c = 0;
                    if (!dfs(i)){ //枚举2种取值都无解 
                          while (c > 0) mark[S[--c]] = false;
                          if (!dfs(i+1)) return false;
                    }
               }
           return true;
     }
};

下面是poj上经典2-sat题目：

Poj2296：http://www.cnblogs.com/yzcstc/p/3588099.html

PoJ2723：

题意：

       有m道门,每到门上有两把锁,打开其中的一把锁就能打开这道门,有2n把不同的钥匙,每把对应一种锁,这些钥匙被分成n对,每队钥匙只能取其中的一把,取了一把之后另一把就会消失,然后给出每一道门对应的钥匙,求解能打开的门的最大数量.注意，必须打开这一道门才能通往下一个门

思路：

      二分一下答案，那么就转化为判定问题。接下去就是2-sat问题了

      对于同一对钥匙a和b，属于互斥关系，添加a->~b, b->~a边

      对于同一个门的两个钥匙，属于or的 关系，即~a与~b互斥，添加~a->b, ~b->a的边

     Code：

     

/*
 * Author:  Yzcstc
 * Created Time:  2014/3/8 17:14:52
 * File Name: Poj2723.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#define M0(x) memset(x, 0, sizeof(x))
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define PB push_back
#define Inf 0x3fffffff
#define eps 1e-8
typedef long long LL;
using namespace std;
#define maxn 40000
int p[maxn];
int X[maxn], Y[maxn], n, m, a[maxn], b[maxn];
struct TwoSat{
     int n;
     vector<int> G[maxn * 2];
     bool mark[maxn * 2];
     int S[maxn * 2], c;
     bool dfs(int x){ // 搜索一组解 
          if (mark[x^1]) return false; //出现冲突 
          if (mark[x]) return true;
          mark[x] = true;
          S[c++] = x;
          for (int i = 0; i < G[x].size(); ++i)
              if (!dfs(G[x][i])) return false;
          return true;
     }

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

     void add_clause(int x, int xv, int y, int yv){
           x = x * 2 + xv;
           y = y * 2 + yv; //x,y不能同时存在，那么如果选了y，合法解必定要选x^1
           G[x^1].push_back(y);  
           G[y^1].push_back(x);
     }

     bool solve(){
           for (int i = 0; i < n * 2; i += 2)
               if (!mark[i] && !mark[i+1]){
                    c = 0;
                    if (!dfs(i)){ //枚举2种取值都无解 
                          while (c > 0) mark[S[--c]] = false;
                          if (!dfs(i+1)) return false;
                    }
               }
           return true;
     }
} S;

void init(){
     int x, y;
     for (int i = 0; i < n; ++i){
           scanf("%d%d", &x, &y);
           X[i] = x;
           Y[i] = y;
     }
     n *= 2; 
     for (int i = 1; i <= m; ++i)
          scanf("%d%d", &a[i], &b[i]);
}

bool check(int floor){
     S.init(n);
     for (int i = 0; i < n / 2; ++i){
           S.add_clause(X[i], 0, Y[i], 0); 
         //  S.add_clause(Y[i], 1, X[i], 1);
     }
     for (int i = 1; i <= floor; ++i){
           S.add_clause(a[i], 1, b[i], 1); 
          // S.add_clause(b[i], 0, a[i], 0);  
     }    
     return S.solve();
}

void solve(){
     int l = 1, r = m, ans = 0, mid;
     while (l <= r){
          mid = (l + r) >> 1;
          if (check(mid)){ans = mid; l = mid + 1; }
          else r =  mid - 1;
     }
     printf("%d
", ans);
}

int main(){
   // freopen("a.in", "r", stdin);
  //  freopen("a.out", "w", stdout);
    while (scanf("%d%d", &n, &m) == 2 && n){
         init();
         solve();
    }
    fclose(stdin);  fclose(stdout);
    return 0;
}

Poj2749

题意：

       N 个牛栏，现在通过一条通道（s1,s2）把他们连起来，他们之间有一些约束关系，一些牛栏不能连在同一个点，一些牛栏必须连在同一个点，现在问有没有可能把他们都连好，而且满足所有的约束关系，如果可以，输出两个牛栏之间距离最大值的最小情况。

思路：

      同样的二分答案。

      至于建图：假定对于某个点a，连S1，为事件a，连S2，为事件~a

                    那么，对于不能连在一起的a, b两点，显然a与b，~a与~b互斥

                    另外一种情况则反过来。。

                    还有对于任意a与b，枚举他们的连接情况，一有矛盾同样建边。具体看代码吧

    code：

   

/*
 * Author:  Yzcstc
 * Created Time:  2014/3/12 14:56:50
 * File Name: Poj2749.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#define M0(x) memset(x, 0, sizeof(x))
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define PB push_back
#define Inf 0x3fffffff
#define eps 1e-8
#define maxn 2000
typedef long long LL;
using namespace std;
struct TwoSat{
       int n;
       bool mark[maxn];
       vector<int> G[maxn];
       int S[maxn], c;
       bool dfs(int x){
            if (mark[x^1]) return false;
            if (mark[x]) return true;
            mark[x] = true;
            S[c++] = x;
            for (int i = 0; i < G[x].size(); ++i)
                 if (!dfs(G[x][i])) return false;
            return true;
       }

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

       void add_clause(int x, int xv, int y, int yv){
            x = x * 2 + xv;
            y = y * 2 + yv;
            G[x].push_back(y^1);
            G[y].push_back(x^1);
       }

       bool solve(){
            for (int i = 0; i < n * 2; i += 2)
                if (!mark[i] && !mark[i+1]){
                      c = 0;
                      if (!dfs(i)){
                           while (c > 0) mark[S[--c]] = false;
                           if (!dfs(i+1)) return false;
                      }
                }
            return true;
       }
} S;
int X[1200], Y[1200], F[1200][2], H[1200][2], n, A, B, d[1000][2], dst;
int Sx1, Sx2, Sy1, Sy2;

void init(){
     scanf("%d%d%d%d", &Sx1, &Sy1, &Sx2, &Sy2);
     for (int i = 0; i < n; ++i)
         scanf("%d%d", &X[i], &Y[i]);
     for (int i = 0; i < A; ++i)
         scanf("%d%d", &H[i][0], &H[i][1]), --H[i][0], --H[i][1];
     for (int i = 0; i < B; ++i)
         scanf("%d%d", &F[i][0], &F[i][1]), --F[i][0], --F[i][1];
}

int dist(int x1, int y1, int x2, int y2){
    return abs(x1 - x2) + abs(y1 - y2);
}

void get_dist(){
     dst = dist(Sx1, Sy1, Sx2, Sy2);
     for (int i = 0; i < n; ++i){
         d[i][0] = dist(X[i], Y[i], Sx1, Sy1);
         d[i][1] = dist(X[i], Y[i], Sx2, Sy2);
     }
}

bool check(int limit){
     S.init(n);
     for (int i = 0; i < A; ++i){
           S.add_clause(H[i][0], 0, H[i][1], 0);
           S.add_clause(H[i][0], 1, H[i][1], 1);
     }
     for (int i = 0; i < B; ++i){
           S.add_clause(F[i][0], 0, F[i][1], 1);
           S.add_clause(F[i][0], 1, F[i][1], 0);
     }
     int flag = 0;
     for (int i = 0; i < n; ++i)
         for (int j = i+1; j < n; ++j){
              flag = 0;
              if (d[i][0] + d[j][0] > limit) { S.add_clause(i, 0, j, 0); flag++; }
              if (d[i][0] + d[j][1] + dst > limit) { S.add_clause(i, 0, j, 1); flag++; }
              if (d[i][1] + d[j][0] + dst > limit) { S.add_clause(i, 1, j, 0); flag++; }
              if (d[i][1] + d[j][1] > limit) { S.add_clause(i, 1, j, 1); flag++; }
              if (flag == 4) return false;
         }
     return S.solve();
}

void solve(){
     get_dist();
     int ans = -1;
     int l = 0, r = 4000000, mid;
     while (l <= r){
          mid = (l + r) >> 1;
          if (check(mid)){ans = mid; r = mid - 1; }
          else l = mid + 1;
     }
     cout << ans << endl;
}

int main(){
  //  freopen("a.in", "r", stdin);
   // freopen("a.out", "w", stdout);
    while (scanf("%d%d%d", &n, &A, &B) == 3){
          init();
          solve();
    }
    fclose(stdin);  fclose(stdout);
    return 0;
}

Poj3207：

题意：

       一个圆上有n个点，依次从0到n-1，现在给出m条线段，每条连接两个点，线段可以在圆内也可以在圆外，问能否使得所有线段都不相交。

思路：

     简单2-sat。对于两条相交的线段建边。。

  code：

   

/*
 * Author:  Yzcstc
 * Created Time:  2014/3/12 19:09:31
 * File Name: poj3207.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#define M0(x) memset(x, 0, sizeof(x))
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define PB push_back
#define Inf 0x3fffffff
#define eps 1e-8
#define maxn 2014
typedef long long LL;
using namespace std;
struct TwoSat{
       int n;
       int S[maxn], c;
       bool mark[maxn];
       vector<int> G[maxn];
       bool dfs(int x){
             if (mark[x^1]) return false;
             if (mark[x]) return true;
             mark[x] = true;
             S[c++] = x;
             for (int i = 0; i < G[x].size(); ++i)
                 if (!dfs(G[x][i])) return false;
             return true;
       }

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

       void add_clause(int x, int y){
            G[x].push_back(y^1);
            G[y].push_back(x^1);
       }
       bool solve(){
           for (int i = 0; i < n * 2; i += 2)
           if (!mark[i] && !mark[i+1]){
                  c = 0;
                  if (!dfs(i)){
                       while (c > 0) mark[S[--c]] = false;
                       if (!dfs(i+1)) return false;
                  }
           }
           return true;
       }
} S;
int m, n, X[2014], Y[2014];

bool In(int a, int b, int c){
     if (a < b && a < c && c < b) return true;
     if (a > b && (c > a || c < b)) return true;
     return false;
}
void solve(){
     for (int i = 0; i < n; ++i)
        scanf("%d%d", &X[i], &Y[i]);
     S.init(n);
     for (int i = 0; i < n; ++i)
        for (int j = i+1; j < n; ++j)
             if (In(X[i], Y[i], X[j]) && In(Y[i], X[i], Y[j])
                 || In(X[i], Y[i], Y[j]) && In(Y[i], X[i], X[j])){
                     S.add_clause(i*2, j*2);
                     S.add_clause(i*2+1, j*2+1);
                 }
     bool ans = S.solve();
     if (ans) puts("panda is telling the truth...");
     else puts("the evil panda is lying again");
}

int main(){
   // freopen("a.in", "r", stdin);
  //  freopen("a.out", "w", stdout);
    while (scanf("%d%d", &m, &n) == 2)  solve();
    fclose(stdin);  fclose(stdout);
    return 0;
}

Poj3648：

  题意：

         有一对新人结婚，邀请n对夫妇去参加婚礼。有一张很长的桌子，人只能坐在桌子的两边，还要满足下面的要求：1.每对夫妇不能坐在同一侧 2.n对夫妇之中可能有通奸关系（包括男男，男女，女女），有通奸关系的不能同时坐在新娘的对面，可以分开坐，可以同时坐在新娘这一侧。如果存在一种可行的方案，输出与新娘同侧的人。

  思路：

       算是这几道题比较容易错的了 。

       对于x与y通奸，则建x->~y, y->~x的边

       而特殊的是新娘要与新郎连一条边，表示坐在对面

code：

   

/*
 * Author:  Yzcstc
 * Created Time:  2014/3/12 20:08:13
 * File Name: poj3468.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#define M0(x) memset(x, 0, sizeof(x))
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define PB push_back
#define Inf 0x3fffffff
#define eps 1e-8
#define maxn 50014
typedef long long LL;
using namespace std;
struct TwoSat{
       int n;
       int S[maxn], c;
       bool mark[maxn];
       vector<int> G[maxn];
       bool dfs(int x){
             if (mark[x^1]) return false;
             if (mark[x]) return true;
             mark[x] = true;
             S[c++] = x;
             for (int i = 0; i < (int)G[x].size(); ++i)
                 if (!dfs(G[x][i])) return false;
             return true;
       }

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

       void add_clause(int x, int y){
            G[x^1].push_back(y);
            G[y^1].push_back(x);
       }
       bool solve(){
           for (int i = 0; i < n * 2; i += 2)
           if (!mark[i] && !mark[i+1]){
                  c = 0;
                  if (!dfs(i)){
                       while (c > 0) mark[S[--c]] = false;
                       if (!dfs(i+1)) return false;
                  }
           }
           return true;
       }
} S;
int n, m;

void solve(){
     int x, y;
     char c1, c2;
     S.init(n);
     for (int i = 0; i < m; ++i){
          scanf("%d%c%d%c", &x, &c1, &y, &c2);
          x = x * 2;
          y = y * 2;
          if (c1 == 'h') ++x;
          if (c2 == 'h') ++y;
          S.add_clause(x, y);
     }
     S.G[1].push_back(0);
     if (!S.solve()){
            puts("bad luck");
            return;
     }
     for (int i = 1; i < n; ++i){
           if (S.mark[2*i]) printf("%dw", i);
           else printf("%dh", i);
           if (i == n-1) puts("");
           printf(" ");
     }
}

int main(){
   // freopen("a.in", "r", stdin);
  //  freopen("a.out", "w", stdout);
    while (scanf("%d%d", &n, &m) == 2 && n){
        // init();
         solve();
    }
    fclose(stdin);  fclose(stdout);
    return 0;
}

poj3678：

题意：

     有一个有向图G（V，E），每条边e（a,b）上有一个位运算符op（AND， OR或XOR）和一个值c（0或1）。

    问能不能在这个图上的每个点分配一个值X（0或1），使得每一条边e(a,b)满足  Xa op Xb =  c

思路：

           a and b ==1 , !a->a , !b -> b

        a and b ==0 , a->!b , b->!a

        a or b ==1   ,  !a->b , !b->a

        a or b ==0   ,  a->!a , b->!b

        a xor b ==1 , a->!b,!b->a,!a->b,b->!a

        a xor b ==0 , a->b,b->a,!a->!b,!b->!a

       至于为什对于a && b == 1 要建立本身到本身反的边，是要推出矛盾。。

code：

     

/*
 * Author:  Yzcstc
 * Created Time:  2014/3/16 21:06:08
 * File Name: poj3678.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#define M0(x) memset(x, 0, sizeof(x))
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define PB push_back
#define Inf 0x3fffffff
#define eps 1e-8
#define maxn 4200
typedef long long LL;
using namespace std;
struct TwoSat{
       int n;
       vector<int> G[maxn];
       bool mark[maxn];
       int c, S[maxn];
       bool dfs(int x){
             if (mark[x^1]) return false;
             if (mark[x]) return true;
             mark[x] = true;
             S[c++] = x;
             for (int i = 0; i < G[x].size(); ++i)
                   if (!dfs(G[x][i])) return false;
             return true;
       }

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

       void add_clause(int x, int y){ G[x].push_back(y); }

       bool solve(){
             for (int i = 0; i < 2*n; i += 2)
                if (!mark[i] && !mark[i+1]){
                     c = 0;
                     if (!dfs(i)){
                           while (c > 0) mark[S[--c]] = false;
                           if (!dfs(i+1)) return false;
                     }
                }
             return true;
       }

} S;
int n, m;

void solve(){
     char s[10];
     int a, b, c;
     S.init(n);
     for (int i = 0; i < m; ++i){
            scanf("%d%d%d%s", &a, &b, &c, &s);
            if (s[0] == 'A'){
                if (c == 1) {  S.add_clause(a * 2, a * 2 + 1); S.add_clause(b * 2, b * 2 + 1); }
                if (c == 0) {  S.add_clause(b * 2 + 1, a * 2); S.add_clause(a * 2 + 1, b * 2); }
            }
            if (s[0] == 'O'){
                if (c == 1) {  S.add_clause(b * 2, a * 2 + 1); S.add_clause(a * 2, b * 2 + 1); }
                if (c == 0) {  S.add_clause(a * 2 + 1, a * 2); S.add_clause(b * 2 + 1, b * 2); }
            }
            if (s[0] == 'X'){
                 if (c == 1) {  S.add_clause(b * 2, a * 2 + 1); S.add_clause(a * 2, b * 2 + 1);
                                S.add_clause(b * 2 + 1, a * 2); S.add_clause(a * 2 + 1, b * 2);
                             }
                 if (c == 0) {  S.add_clause(b * 2, a * 2); S.add_clause(a * 2, b * 2);
                                S.add_clause(b * 2 + 1, a * 2 + 1); S.add_clause(a * 2 + 1, b * 2 + 1);
                             }
            }
     }
     if (S.solve()) puts("YES");
     else puts("NO");
}

int main(){
   // freopen("a.in", "r", stdin);
   // freopen("a.out", "w", stdout);
    while (scanf("%d%d", &n, &m) == 2) solve();
    fclose(stdin);  fclose(stdout);
    return 0;
}

Poj3683：

题意：

　  有一个牧师要给好几对新婚夫妇准备婚礼.，已知每对新婚夫妇的有空的时间以及婚礼持续时间..

　  问是否可以让每对新婚夫妇都得到该牧师的祝福。如果可以就输出YES以及可行解 不可以就输出NO

思路：

    典型的2-sat。只不过多了输出解。

code：

/*
 * Author:  Yzcstc
 * Created Time:  2014/3/18 18:06:09
 * File Name: poj3683.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#define M0(x) memset(x, 0, sizeof(x))
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define PB push_back
#define Inf 0x3fffffff
#define maxn 8000
#define eps 1e-8
typedef long long LL;
using namespace std;
struct TwoSat{
       int n;
       vector<int> G[maxn];
       int c, S[maxn];
       bool mark[maxn];
       bool dfs(int x){
             if (mark[x^1]) return false;
             if (mark[x]) return true;
             mark[x] = true;
             S[c++] = x;
             for (int i = 0; i < G[x].size(); ++i)
                  if (!dfs(G[x][i])) return false;
             return true;
       }

       void init(int n){
             this->n = n;
             memset(mark, 0, sizeof(mark));
             for (int i = 0; i < 2*n; ++i)
                  G[i].clear();
       }
       void add_clause(int x, int y){
             G[x^1].push_back(y);
             G[y^1].push_back(x);
       }
       bool solve(){
             for (int i = 0; i < 2*n; i += 2)
                if (!mark[i] && !mark[i+1]){
                       c = 0;
                       if (!dfs(i)){
                             while (c > 0) mark[S[--c]] = false;
                             if (!dfs(i+1)) return false;
                       }
                }
             return true;
       }
} S;
int n;
int St[2048], En[2048], D[2048];
bool g[2048][2048];

void init(){
     int x, y, x2, y2, z;
     for (int i = 0; i < n; ++i){
         scanf("%d:%d %d:%d %d", &x, &y, &x2, &y2, &z);
         D[i] = z;
         St[i] = x * 60 + y;
         En[i] = x2 * 60 + y2;
     }
}

bool check(int S1, int T1, int S2, int T2){
     if (S1 < T2 && S2 < T1) return true;
     return false;
}

void solve(){
     S.init(n);
     int S1, T1, S2, T2;
     M0(g);
     for (int i = 0; i < n; ++i)
       for (int j = i + 1; j < n; ++j){
             S1 = St[i],  T1 = St[i] + D[i];
             S2 = St[j],  T2 = St[j] + D[j];
             if (check(S1, T1, S2, T2)){ g[i*2][j * 2] = true; S.add_clause(i * 2, j * 2); }
             S1 = St[i],  T1 = St[i] + D[i];
             S2 = En[j] - D[j],  T2 = En[j];
             if (check(S1, T1, S2, T2)) { g[i*2][j*2+1] = true; S.add_clause(i * 2, j * 2 + 1);}
             S1 = En[i] - D[i],  T1 = En[i];
             S2 = St[j],  T2 = St[j] + D[j];
             if (check(S1, T1, S2, T2)) { g[i*2+1][j*2] = true; S.add_clause(i * 2 + 1, j * 2);}
             S1 = En[i] - D[i],  T1 = En[i];
             S2 = En[j] - D[j],  T2 = En[j];
             if (check(S1, T1, S2, T2)) { g[i*2+1][j*2+1] = true; S.add_clause(i * 2 + 1, j * 2 + 1);}
       }
     if (!S.solve()){puts("NO"); return;}
     puts("YES");
     vector<int> V;
     for (int i = 0; i < n; ++i)
        if (S.mark[i*2]) V.PB(i*2);
        else V.PB(i*2+1);
     bool flag = true;
     for (int i = 0; i < V.size(); ++i)
         for (int j = i+1; j < V.size(); ++j)
            if (g[V[i]][V[j]] || g[V[j]][V[i]]) flag = false;
     for (int i = 0; i < n; ++i){
         if (S.mark[i*2] == flag){
               printf("%02d:%02d %02d:%02d
", St[i] / 60, St[i] % 60, (St[i] + D[i]) / 60, (St[i] + D[i]) % 60);
               continue;
         }
         printf("%02d:%02d %02d:%02d
", (En[i] - D[i]) / 60, (En[i] - D[i]) % 60, En[i] / 60, En[i] % 60);
     }
}

int main(){
   // freopen("a.in", "r", stdin);
  //  freopen("a.out", "w", stdout);
    while (scanf("%d", &n) != EOF){
         init();
         solve();
    }
    fclose(stdin);  fclose(stdout);
    return 0;
}

Poj3905

题意：

    有n个候选人，m组要求，每组要求关系到候选人中的两个人，“+i +j”代表i和j中至少有一人被选中，“-i -j”代表i和j中至少有一人不被选中。“+i -j”代表i被选中和j不被选中这两个事件至少发生一个，“-i +j”代表i不被选中和j被选中这两个事件至少发生一个。问是否存在符合所有m项要求的方案存在。

 思路：

    简单的2-sat

code：

/*
 * Author:  Yzcstc
 * Created Time:  2014/3/19 0:06:34
 * File Name: poj3905.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#define M0(x) memset(x, 0, sizeof(x))
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define red(i, a, b) for (int i = (a); i >= (b); --i)
#define PB push_back
#define Inf 0x3fffffff
#define eps 1e-8
#define maxn 4000
typedef long long LL;
using namespace std;
struct Twosat{
       int n;
       int S[maxn], c;
       vector<int> G[maxn];
       bool mark[maxn];
       bool dfs(int x){
            if (mark[x^1]) return false;
            if (mark[x]) return  true;
            mark[x] = true;
            S[c++] = x;
            for (int i = 0; i < G[x].size(); ++i)
                if (!dfs(G[x][i])) return false;
            return true;
       }
       void init(int n){
            this->n = n;
            memset(mark, 0, sizeof(mark));
            for (int i = 0; i < 2 * n; ++i)
                 G[i].clear();
       }
       void add_clause(int x, int y){
            G[x^1].PB(y);
            G[y^1].PB(x);
       }
       bool solve(){
             for (int i = 0; i < 2*n; i += 2)
                  if (!mark[i] && !mark[i+1]){
                        c = 0;
                        if (!dfs(i)){
                              while (c > 0) mark[S[--c]] = false;
                              if (!dfs(i+1)) return false;
                        }
                  }
             return true;
       }
} S;
int n, m;

int change(char s[], int n){
     int ret = 0;
     for (int i = 0; i < n; ++i)
         if(s[i] <= '9' && s[i] >= '0') ret = ret * 10 + s[i] - 48;
     return ret;
}

void solve(){
     int x, y;
     char s[20], s1[20];
     S.init(n);
     for (int i = 0; i < m; ++i){
           scanf("%s%s", &s, &s1);
           x = change(s, strlen(s)) - 1;
           y = change(s1, strlen(s1)) - 1;
           if (s[0] == '+' && s1[0] == '+') S.add_clause(x * 2 + 1, y * 2 + 1);
           if (s[0] == '+' && s1[0] == '-') S.add_clause(x * 2 + 1, y * 2);
           if (s[0] == '-' && s1[0] == '+') S.add_clause(x * 2, y * 2 + 1);
           if (s[0] == '-' && s1[0] == '-') S.add_clause(x * 2, y * 2);
     }
     if (S.solve()) puts("1");
     else puts("0");
}

int main(){
  //  freopen("a.in", "r", stdin);
  //  freopen("a.out", "w", stdout);
    while (scanf("%d%d", &n, &m) == 2) solve();
    fclose(stdin);  fclose(stdout);
    return 0;
}