POJ2749 Building road

传送门

这道题真是2-SAT好题啊！！卡了我两个点才做完……垃圾POJ还不告诉我哪错了……

首先我们先花一段时间把题看懂……（其实是翻译一下），之后我们发现因为每个谷仓只能向一个中转点连边，所以他就是一个布尔变量的两个取值。然后对于每个限制条件，其实就是^嘛！我们把他转换为合取范式之后建一下图。不过怎么计算最大距离最小值呢？看到这一幕想起二分答案……然后，然后就不会了……

我们再想一下，其实2-SAT里面，每个给定的限制特别要命，因为如果要没有限制随便瞎取都能合法，然后我们要限制一个最大距离……那我们不妨把连接之后距离大于当前值的两个谷仓加一个限制，使两者不能连边，这样我们再跑一遍2-SAT判断一下当前是否合法，然后改变二分的值就可以。

具体怎么加距离的限制，如果两个点通过某种连接方式之后不合法，我们就把其中一个向另一个的否定连边（一个点连接s1，s2），比如说第一个点连向s1，第二个点连向s2，如果这样是不合法的情况的话，那么我们强制性让第一个点连s2，第二个点连s1，这样建边就可以啦。

然而说着容易做着难……代码贼拉难写+忘记判断-1+不知道怎么建边……卡了两个小时。

Source Code
Problem:         User: ifvisit
Memory: 6176K        Time: 1657MS
Language: C++        Result: Accepted

    Source Code

    #include<cstdio>
    #include<algorithm>
    #include<cstring>
    #include<iostream>
    #include<cmath>
    #include<set>
    #include<queue>
    #define rep(i,a,n) for(int i = a;i <= n;i++)
    #define per(i,n,a) for(int i = n;i >= a;i--)
    #define fill(x,y) memset(x,y,sizeof(x));
    #define enter putchar('\n')

    using namespace std;
    typedef long long ll;
    const int M = ;
    const int N = ;
    const int INF = ;

    int read()
    {
        int ans = ,op = ;
        char ch = getchar();
        while(ch < '' || ch > '')
        {
        if(ch == '-') op = -;
        ch = getchar();
        }
        while(ch >= '' && ch <= '')
        {
        ans *= ;
        ans += ch - '';
        ch = getchar();
        }
        return ans * op;
    }

    struct edge
    {
        int next,to,from;
    }e[N];

    struct node
    {
        int x,y;
    }q[M];

    struct relation
    {
        int a,b;
    }ha[M],li[M];

    int n,m,g,head[M],ecnt,dfn[M],low[M],stack[M],top,scc[M],a,b,c,d,dis1[M],dis2[M],len,idx,cnt;
    int minn = ,maxn,ans;
    int s1 = ,s2 = ;
    bool vis[M];

    void add(int x,int y)
    {
        e[++ecnt].to = y;
        e[ecnt].from = x;
        e[ecnt].next = head[x];
        head[x] = ecnt;
    }
    int rev(int x)
    {
        return x > n ? x - n : x + n;
    }

    int mht(int kx,int ky)
    {
        return abs(q[kx].x - q[ky].x) + abs(q[kx].y - q[ky].y);
    }

    void clear()
    {
        memset(e,,sizeof(e));
        memset(head,,sizeof(head));
        memset(dfn,,sizeof(dfn));
        memset(low,,sizeof(low));
        memset(scc,,sizeof(scc));
        ecnt = idx = cnt = ;
    }

    void build(int x)
    {
        rep(i,,m)
        {
        int r1 = ha[i].a,r2 = ha[i].b;
        add(r1,r2+n),add(r1+n,r2),add(r2,r1+n),add(r2+n,r1);
        }
        rep(i,,g)
        {
        int r1 = li[i].a,r2 = li[i].b;
        add(r1,r2),add(r2,r1),add(r1+n,r2+n),add(r2+n,r1+n);
        }
        rep(i,,n)
        {
        rep(j,i+,n)
        {
            int l1 = dis1[i],l2 = dis2[i],r1 = dis1[j],r2 = dis2[j];
            if(l1 + r1 > x) add(i,j+n),add(j,i+n);
            if(l2 + r2 > x) add(i+n,j),add(j+n,i);
            if(l1 + r2 + len > x) add(i,j),add(j+n,i+n);
            if(l2 + r1 + len > x) add(i+n,j+n),add(j,i);
        }
        }
    }

    void tarjan(int x)
    {
        dfn[x] = low[x] = ++idx;
        stack[++top] = x,vis[x] = ;
        for(int i = head[x];i;i = e[i].next)
        {
        if(!dfn[e[i].to]) tarjan(e[i].to),low[x] = min(low[x],low[e[i].to]);
        else if(vis[e[i].to]) low[x] = min(low[x],dfn[e[i].to]);
        }
        if(low[x] == dfn[x])
        {
        int p;
        cnt++;
        while((p = stack[top--]))
        {
            scc[p] = cnt,vis[p] = ;
            if(p == x) break;
        }
        }
    }

    void solve()
    {
        int l = ,r = ;
        while(l < r)
        {
        bool flag = ;
        int mid = (l+r) >> ;
        clear(),build(mid);
        rep(i,,n<<) if(!dfn[i]) tarjan(i);
        rep(i,,n)
        {
            if(scc[i] == scc[i+n])
            {
            flag = ;
            break;
            }
        }
        if(flag) l = mid + ;
        else r = mid;
        }
        if(l ==  || l == ) printf("-1\n");
        else printf("%d\n",l);
    }

    int main()
    {
        n = read(),m = read(),g = read();
        q[s1].x = read(),q[s1].y = read(),q[s2].x = read(),q[s2].y = read();
        len = abs(q[s2].y-q[s1].y) + abs(q[s2].x-q[s1].x);
        rep(i,,n)
        {
        q[i].x = read(),q[i].y = read();
        dis1[i] = mht(i,s1),dis2[i] = mht(i,s2);
        }
        rep(i,,m) ha[i].a = read(),ha[i].b = read();
        rep(i,,g) li[i].a = read(),li[i].b = read();
        solve();
        return ;
    }