2-SAT ( Tarjan )——Get Luffy out ( POJ 2723 )

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

• 分析：
  给出2N把钥匙，一共分成 N 对，每一对钥匙只能用其中一把，再出M扇门，每扇门有两把锁，每把锁单独对应一把钥匙，打开一把锁就能打开一扇门，除开第一扇门外，想打开某扇门，必须先打开它前面那一扇。求在给定的条件下，最多能打开多少扇门。

• 题解：
  对立关系：一个组里的钥匙用了其中一把，另一把就肯定不能用（前提是一个钥匙只能出现在一个组里）

  矛盾关系：如果一个门的一把锁不能被打开，那么另一把锁一定能被打开。

  根据矛盾关系建边，根据对立关系判断解

  然后问题是能打开多少扇门，我们就二分搜索开到第几扇门，再建边建到第几扇，接着用Tarjan求连通块，然后判断所有的钥匙，有没有某一对钥匙在一个连通块里。最后输出解即可。

• 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 2333
#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)

int N, M;
int key[MaxN];
int dl[MaxM];
int dr[MaxM];

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) && (N+M) )
    {
        int a,b;
        for(int i=1;i<=N;i++)
        {
            scanf("%d%d", &a, &b);
            key[a] = b;
            key[b] = a;
        } 
        for(int i=1;i<=M;i++) 
        {
            scanf("%d%d", &dl[i], &dr[i]);
        }

        int low = 0, high = M;
        int mid = (low+high)>>1, ans = mid;
        while(low <= high)
        {
            init();
            for(int i=1;i<=mid;i++)
            {
                add(dl[i], key[dr[i]]);
                add(dr[i], key[dl[i]]);
            }
             for(int i=0;i<2*N;i++)
                if(dfn[i]==-1)
                    Tarjan(i);
            int flag = 0;
            for(int i=0;i<2*N;i++)
            {
                if(belong[i] == belong[key[i]])
                {
                    flag = 1;
                    break;
                }
            }
            if(flag) high = mid-1;
            else low = (ans = mid)+1;
            mid = (low+high)>>1;
        }
        cout << ans << endl;
    }
    system("pause");
}