POJ 2391 Ombrophobic Bovines(二分+floyd+最大流)

题目链接：poj2391

【题目大意】

给定一个无向图，点 i 处有 Ai 头牛，点 i 处的牛棚能容纳 Bi 头牛，求一个最短时间 T 使得在 T 时间内所有的牛都能进到某一牛棚里去。（1 <= N <= 200, 1 <= M <=1500, 0 <= Ai <= 1000, 0 <= Bi <= 1000, 1 <= Dij <= 1,000,000,000）
【建模方法】

将每个点 i 拆成两个点 i’, i’’，连边(s, i’, Ai), (i’’, t, Bi)。二分最短时间 T，若 d[i][j]<=T（d[i][j]表示点 i, j 之间的最短距离）则加边(i’, j’’, ∞)。每次根据最大流调整二分的上下界即可。

详细点说就是：

先floyd求出任意两点之间的最短距离，然后二分答案，判断是否可以在时间不超过mid的情况下完成移动：

建图：

每个点拆成两个点x和x'，源点向x连边，权值为初始的牛的数量；

x'向汇点连边，权值为可以容纳的牛的数量；

x向x'连边，权值为INF。

然后枚举任意两点i和j，如果i和j之间的最短距离dist[i][j]<=mid，则建边i->j'，权值为INF。

此时计算最大流，就是在限定mid时间内可以移动的最多的牛的数量，如果等于牛的总数则说明可行，否则不可行。继续二分。

正确的建图如下:

一种错误的建图方法，即不拆点，见下图：

其中每条无向边表示两条方向相反的有向边，容量均为∞。

当二分到 T = 70 的时候，显然我们只加入了(2, 3)和(3, 4)两条无向边，因为只有这两对点间的最短距离小于等于70。但是从图中也可以看出，由于没有拆点，点 2 也可以通过这两条边到达点 4，而实际上这是不允许的。也就是说我们所加的限制条件没有起到作用。由此可见，只有拆点才是正确的做法。

（没有拆点的话，2-3和3-4分别连了条容量为∞的边，相当于2-4也连了条∞的边）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define INF 1e9
#define INFLL 1LL<<60
using namespace std;
const int maxn=500+10;

struct Edge
{
    int from,to,cap,flow;
    Edge(){}
    Edge(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){}
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    int d[maxn];
    int cur[maxn];
    bool vis[maxn];

    void init(int n,int s,int t)
    {
        this->n=n, this->s=s, this->t=t;
        edges.clear();
        for(int i=0;i<n;i++) G[i].clear();
    }

    void AddEdge(int from,int to,int cap)
    {
        edges.push_back( Edge(from,to,cap,0) );
        edges.push_back( Edge(to,from,0,0) );
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        queue<int> Q;
        memset(vis,0,sizeof(vis));
        vis[s]=true;
        d[s]=0;
        Q.push(s);
        while(!Q.empty())
        {
            int x=Q.front(); Q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge e=edges[G[x][i]];
                if(!vis[e.to] && e.cap>e.flow)
                {
                    vis[e.to]=true;
                    d[e.to] = d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a)
    {
        if(x==t || a==0) return a;
        int flow=0,f;

        for(int& i=cur[x];i<G[x].size();++i)
        {
            Edge& e=edges[G[x][i]];
            if(d[e.to]==d[x]+1 && (f=DFS(e.to, min(a,e.cap-e.flow) ) )>0 )
            {
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    int Max_Flow()
    {
        int flow=0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            flow += DFS(s,INF);
        }
        return flow;
    }
}DC;

int n,m;
int now[maxn],can[maxn];//存放每个牛栏还能放下的牛数. 为0则不能放了,>0则还有空位,<0则需要转移
long long dist[maxn][maxn];//dist[i][j]表示从牛棚i到牛棚j所需要耗费的时间
void floyd(int n)//求最短路
{
    for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				if(dist[i][k]<INFLL && dist[k][j]<INFLL)
					dist[i][j]=min(dist[i][j], dist[i][k]+dist[k][j]);
}

bool solve(long long limit,int full_flow)//判断只走长度<=limit的路看是否有解
{
    DC.init(2*n+2,0,2*n+1);
    for(int i=1;i<=n;i++)
    {
        DC.AddEdge(0,i,now[i]);
        DC.AddEdge(i+n,2*n+1,can[i]);
    }

    for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			if(dist[i][j]<=limit)
				DC.AddEdge(i,j+n,INF);//时间在限制时间内的  可以从i到j的道路 
    return DC.Max_Flow() == full_flow;//判断是否满流
}

int main()
{
    while(scanf("%d%d",&n,&m)==2)//n个点  m条边
    {
        long long L=0,R=0;//二分的上下界
        int full_flow = 0;
        for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				dist[i][j]= i==j?0:INFLL;
        for(int i=1;i<=n;i++)
        {
            int v1,v2;
            scanf("%d%d",&now[i],&can[i]);
            full_flow +=now[i];//记录满流量
        }
        for(int i=1;i<=m;i++)
        {
            int u,v;
            long long w;
            scanf("%d%d%I64d",&u,&v,&w);
            dist[u][v]=dist[v][u]=min(dist[u][v],w);//如果有重边 取时间小的
        }
        floyd(n);//计算最短路径
        for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				if(dist[i][j]<INFLL)
					R=max(R,dist[i][j]);//求最长的边
        if(solve(R, full_flow)==false) printf("-1\n");
        else
        {
            while(R>L)
            {
                long long mid = L+(R-L)/2;
                if(solve(mid,full_flow)) R=mid;
                else L=mid+1;
            }
            printf("%I64d\n",R);
        }
    }
    return 0;
}