POJ 2723 - Get Luffy Out(2-SAT)

#题目:

http://poj.org/problem?id=2723

#题意:

2*n把钥匙, 两两配对成n对,用其中一把另一把就会消失.

m个门, 每个门上有两把锁, 打开其中一把就可以打开门. 门打开的顺序应该按照输入的顺序.

求出最多能打开几扇门.

#思路:

每对钥匙只能用其中一把,每个门至少打开一把锁, 符合2-SAT...

1.对于N个点(A,B)表示钥匙,只能用其中的一把, 建边 <A, !B>表示用A不用B, <B,!A>表示用B不用A.

2.对于M个点(A,B)表示锁, 至少打开其中的一把,建边 <!A,B>表示一定打开B, <!B,A>表示一定打开A.

(注意钥匙和锁的连边方式不同)

最后二分求值.

AC.

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

using namespace std;
const int MAXN = 8000;
const int MAXM = 8000;
struct Key {
    int u, v;
}key[MAXN];
struct Door{
    int x, y;
}door[MAXN];

int n, m;
struct edge {
    int to, next;
}edge[MAXM];
int head[MAXN], tot;


void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
}

void addedge(int u, int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void build(int mmid)
{
    init();

    for(int i = 0; i < n/2; ++i) {
        addedge(key[i].u, key[i].v+n);
        addedge(key[i].v, key[i].u+n);
    }

    for(int i = 0; i < mmid; ++i) {
        addedge(n+door[i].x, door[i].y);
        addedge(n+door[i].y, door[i].x);
    }
}

int low[MAXN], dfn[MAXN], belong[MAXN];
int scc, Index;
stack<int> S;

void tarjan(int u)
{
    int v;
    low[u] = dfn[u] = ++Index;
    S.push(u);
    for(int i = head[u]; i != -1; i = edge[i].next) {
        v = edge[i].to;
        if(!dfn[v]) {
            tarjan(v);
            if(low[u] > low[v]) low[u] = low[v];
        }
        else if(!belong[v] && low[u] > dfn[v]) {
            low[u] = dfn[v];
        }
    }
    if(low[u] == dfn[u]) {
        scc++;
        do {
            v = S.top(); S.pop();
            belong[v] = scc;
        }while(v != u);
    }
}

bool solve(int mid)
{
//printf("%d\n", mid);
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(belong, 0, sizeof(belong));

    build(mid);

    Index = scc = 0;
    for(int i = 0; i < 2*n; ++i) {
        if(!dfn[i]) tarjan(i);
    }

    for(int i = 0; i < n; ++i) {
        if(belong[i] == belong[n+i]) {
            return false;
        }
    }
    return true;
}

int main()
{
//freopen("in", "r", stdin);

    while(~scanf("%d %d", &n, &m)) {
        if(n == 0 && m == 0) break;

        for(int i = 0; i < n; ++i) {
            scanf("%d %d", &key[i].u, &key[i].v);
        }

        for(int i = 0; i < m; ++i) {
            scanf("%d %d", &door[i].x, &door[i].y);
        }

        n = n*2;
        int l = 0, r = m;
        while(r-l > 1) {
            int mid = (l+r)/2;

            if(solve(mid)) {
                l = mid;
            }
            else r = mid;
        }
        if(solve(r)) l = r;
        
        printf("%d\n", l);
    }
    return 0;
}