hdu1815/poj2749 Building roads （2-SAT +二分）

题意：

有n个谷仓，每个谷仓里面都有奶牛，奶牛喜欢走到其他谷仓串门。所以约翰想修一些路把这些谷仓连接起来，但是如果他为每一对不同的谷仓都修路，那么他必须建造n(n-1)/2条路，太贵了。
因此约翰先建立了两个换乘点S1，S2，S1和S2连接。然后要把n个谷仓连接到S1或者S2，这样就能把所有路连接起来。为了不让奶牛走太久，约翰想把没对谷仓之间的最大距离距离最小化。

问题还没结束，同时，有一些谷仓的牛互相憎恨，他们所在的谷仓必须连接在不同的换乘点上。另外，还有一些谷仓的牛互相喜欢，他们所在的谷仓必须连接在同一换乘点上。
现在给出S1，S2，和n个谷仓的坐标，求没对谷仓之间的最大距离的最小值。

注意：题目中的距离指的是曼哈顿距离，即|x1 - x2| + |y1 - y2|。

分析：

(和poj3622很像都是二分+2-SAT判断，但是这题建图感觉比那个难。)

题目说最大距离最小化，很容易就想到是二分。
二分最大距离判断是否可行就行了。
这题判断方案可行与否的方法是2-sat。

谷仓看作节点，如果当前节点编号为i，用2i表示i点连接S1，用2i+1表示i点连接S2
二分距离然后建图跑tarjan缩点，如果对于每一个点，2i和2i+1不在同一个强连通分量则方案可行(不具体介绍2-SAT了)

主要麻烦就是在建图上(看代码)。

ps:一开始我把题目理解错了，题目说的是"任意一对"点的最大距离(不止是有关系的点对)

code：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int N=1e3+5;
const int M=1e6+5;
struct Point{
    int x,y;
}p[N],like[N],hate[N],s1,s2;//结构体用于记录点坐标
int d1[N],d2[N];//到s1的距离和到s2的距离
int d12;//s1和s2之间的距离
int head[N],nt[M],to[M],cnt;
int low[N],dfn[N],idx;
int belong[N],sum;
int ins[N];
stack<int>stk;
int n,a,b;
void init(){
    while(!stk.empty())stk.pop();
    memset(head,-1,sizeof head);
    memset(low,0,sizeof low);
    memset(dfn,0,sizeof dfn);
    memset(belong,0,sizeof belong);
    memset(ins,0,sizeof ins);
    cnt=1;
    sum=0;
    idx=0;
}
void add(int x,int y){
    cnt++;nt[cnt]=head[x];head[x]=cnt;to[cnt]=y;
}
void dfs(int x){
    low[x]=dfn[x]=++idx;
    stk.push(x);
    ins[x]=1;
    for(int i=head[x];i!=-1;i=nt[i]){
        int v=to[i];
        if(dfn[v]==0){
            dfs(v);
            low[x]=min(low[x],low[v]);
        }else if(ins[v]){
            low[x]=min(low[x],dfn[v]);
        }
    }
    if(low[x]==dfn[x]){
        sum++;
        while(1){
            int t=stk.top();
            stk.pop();
            ins[t]=0;
            belong[t]=sum;
            if(t==x)break;
        }
    }
}
int getd(Point aa,Point bb){//求曼哈顿距离
    return abs(aa.x-bb.x)+abs(aa.y-bb.y);
}
bool check(int mid){
    init();
    for(int i=1;i<=a;i++){//hate
        int t=hate[i].x,tt=hate[i].y;
        add(t*2,tt*2+1);
        add(tt*2,t*2+1);
        add(tt*2+1,t*2);
        add(t*2+1,tt*2);
    }
    for(int i=1;i<=b;i++){//like
        int t=like[i].x,tt=like[i].y;
        add(t*2,tt*2);
        add(tt*2,t*2);
        add(t*2+1,tt*2+1);
        add(tt*2+1,t*2+1);
    }
    for(int i=1;i<=n;i++){//判断任意两点
        for(int j=i+1;j<=n;j++){
            if(d1[i]+d1[j]>mid){//如果连接相同的距离超了，则必须连不同的
                add(i*2,j*2+1);
                add(j*2,i*2+1);
            }
            if(d2[i]+d2[j]>mid){//如果连接相同的距离超了，则必须连不同的
                add(i*2+1,j*2);
                add(j*2+1,i*2);
            }
            if(d1[i]+d12+d2[j]>mid){//如果连接不同的距离超了，则必须连相同的
                add(i*2,j*2);
                add(j*2+1,i*2+1);
            }
            if(d2[i]+d12+d1[j]>mid){//如果连接不同的距离超了，则必须连相同的
                add(i*2+1,j*2+1);
                add(j*2,i*2);
            }
        }
    }
    for(int i=2;i<=n*2+1;i++){//因为下标从1开始，所以i*2从2开始到n*2+1结束
        if(dfn[i]==0)dfs(i);
    }
    for(int i=1;i<=n;i++){
        if(belong[i*2]==belong[i*2+1]){//判断是否在同一强连通分量
            return 0;
        }
    }
    return 1;
}
void solve(){
    int ans=-1;
    int l=0,r=4e8+5;//hdu这个r如果太小了会WA,不知道为什么，poj就都可以
    while(l<=r){
        int mid=(l+r)/2;
        if(check(mid)){
            ans=mid;
            r=mid-1;
        }else{
            l=mid+1;
        }
    }
    printf("%d\n",ans);
}
int main(){
    while(scanf("%d%d%d",&n,&a,&b)!=EOF){
        scanf("%d%d%d%d",&s1.x,&s1.y,&s2.x,&s2.y);
        d12=getd(s1,s2);//S1到S2的距离
        for(int i=1;i<=n;i++){
            scanf("%d%d",&p[i].x,&p[i].y);
            d1[i]=getd(s1,p[i]);//点到S1的距离
            d2[i]=getd(s2,p[i]);//点到S2的距离
        }
        for(int i=1;i<=a;i++){
            scanf("%d%d",&hate[i].x,&hate[i].y);
        }
        for(int i=1;i<=b;i++){
            scanf("%d%d",&like[i].x,&like[i].y);
        }
        solve();
    }
    return 0;
}