poj 2723 Get Luffy Out（2-sat）

Description

Ratish is a young man who always dreams of being a hero. One day his friend Luffy was caught by Pirate Arlong. Ratish set off at once to Arlong's island. When he got there, he found the secret place where his friend was kept, but he could not go straight in. He saw a large door in front of him and two locks in the door. Beside the large door, he found a strange rock, on which there were some odd words. The sentences were encrypted. But that was easy for Ratish, an amateur cryptographer. After decrypting all the sentences, Ratish knew the following facts: 

Behind the large door, there is a nesting prison, which consists of M floors. Each floor except the deepest one has a door leading to the next floor, and there are two locks in each of these doors. Ratish can pass through a door if he opens either of the two locks in it. There are 2N different types of locks in all. The same type of locks may appear in different doors, and a door may have two locks of the same type. There is only one key that can unlock one type of lock, so there are 2N keys for all the 2N types of locks. These 2N keys were divided into N pairs, and once one key in a pair is used, the other key will disappear and never show up again. 

Later, Ratish found N pairs of keys under the rock and a piece of paper recording exactly what kinds of locks are in the M doors. But Ratish doesn't know which floor Luffy is held, so he has to open as many doors as possible. Can you help him to choose N keys to open the maximum number of doors?

Input

There are several test cases. Every test case starts with a line containing two positive integers N (1 <= N <= 210) and M (1 <= M <= 211) separated by a space, the first integer represents the number of types of keys and the second integer represents the number of doors. The 2N keys are numbered 0, 1, 2, ..., 2N - 1. Each of the following N lines contains two different integers, which are the numbers of two keys in a pair. After that, each of the following M lines contains two integers, which are the numbers of two keys corresponding to the two locks in a door. You should note that the doors are given in the same order that Ratish will meet. A test case with N = M = 0 ends the input, and should not be processed.

Output

For each test case, output one line containing an integer, which is the maximum number of doors Ratish can open.

Sample Input

3 6
0 3
1 2
4 5
0 1
0 2
4 1
4 2
3 5
2 2
0 0

Sample Output

4

Source

Beijing 2005

 

题意：m个门，每个门上有两把锁，打开一个就可以通过，2n个钥匙，每两个绑在一起，只能选用一个 ，选了一个，另一个就被废弃。问最多可以通过几扇门？
2-sat问题关键在建图，2-sat对每个事物都有两个选项 ,选和不选.  可以这么建：
每把钥匙有两个状态(用或不用)，把这作为2-sat的两个选项
然后是加条件，a、b绑在一起，则选a就不选b，选b就不选a，建边a->!b,b->!a
c、d在同一个门上，则不开c就开d，不开d就开c，建边!c->d,!d->c
然后二分答案都可以了

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<math.h>
#include<algorithm>
#include<queue>
#include<set>
#include<bitset>
#include<map>
#include<vector>
#include<stdlib.h>
#include <stack>
using namespace std;
#define PI acos(-1.0)
#define max(a,b) (a) > (b) ? (a) : (b)  
#define min(a,b) (a) < (b) ? (a) : (b)
#define ll long long
#define eps 1e-10
#define MOD 1000000007
#define N 1<<16
#define M 1<<16
#define inf 1<<26
int n,m;

////////////////////////////////////////////////////////
int tot;
int head[N];
int vis[N];
int tt;
int scc;
stack<int>s;
int dfn[N],low[N];
int col[N];
struct Node
{
    int from;
    int to;
    int next;
}edge[N];
void init()
{
    tot=0;
    scc=0;
    tt=0;
    memset(head,-1,sizeof(head));
    memset(dfn,-1,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(vis,0,sizeof(vis));
    memset(col,0,sizeof(col));
    while(!s.empty()){
          s.pop();
    }
}
void add(int s,int u)//邻接矩阵函数
{
    edge[tot].from=s;
    edge[tot].to=u;
    edge[tot].next=head[s];
    head[s]=tot++;
}
void tarjan(int u)//tarjan算法找出图中的所有强连通分支
{
    dfn[u] = low[u]= ++tt;
    vis[u]=1;
    s.push(u);
    int cnt=0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        if(dfn[v]==-1)
        {
        //    sum++;
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(vis[v]==1)
          low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        int x;
        scc++;
        do{
            x=s.top();
            s.pop();
            col[x]=scc;
            vis[x]=0;
        }while(x!=u);
    }
}
bool two_sat(){
    
    for(int i=0;i<2*n*2;i++){
        if(dfn[i]==-1){
            tarjan(i);
        }
    }
    for(int i=0;i<n*2;i++){
        if(col[2*i]==col[2*i+1]){
            return false;
        }
    }
    return true;
}
////////////////////////////////////////
int key1[N],key2[N];
int door1[M],door2[M];

bool solve(int mid){
    init();
    for(int i=1;i<=n;i++){
        add(2*key1[i],2*key2[i]+1);
        add(2*key2[i],2*key1[i]+1);
    }
    
    for(int i=1;i<=mid;i++){
        add(2*door1[i]+1,2*door2[i]);
        add(2*door2[i]+1,2*door1[i]);
    }
    if(two_sat()) return true;
    return false;
}

int main()
{
    while(scanf("%d%d",&n,&m)==2){
         if(n==0 && m==0){
               break;
         }
         
         
         
         for(int i=1;i<=n;i++){
                scanf("%d%d",&key1[i],&key2[i]);
         }
         for(int i=1;i<=m;i++){
                scanf("%d%d",&door1[i],&door2[i]);
         }
         
         
         int low=0;
         int high=m+1;
        // int ans;
         while(low<high){
                 int mid=(low+high)>>1;
                 if(solve(mid)){
                        //ans=mid;
                        low=mid+1;
                 }
                 else{
                        high=mid;
                 }
         }
         printf("%d
",low-1);
         
      
    }
    return 0;
}