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

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

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

题意:

       给定一个有n个顶点和m条边的无向图，点i 处有Ai头牛，点i 处的牛棚能容纳Bi头牛，每条边有一个时间花费ti(表示从一个端点走到另一个端点所需要的时间)，求一个最短时间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’’,  ∞)。每次根据最大流调整二分的上下界即可。

       但是要注意算最短距离的时候要用long long.(流量用int表示就行)

       其实我认为还有另外一种不拆点的方法,但是代码一直WA,可能是我考虑不周.下面说说我的想法：

       就是每个节点中需要被移动的牛一定是那些超过该节点容纳量的牛,比如该节点有4头牛,但是雨棚只能放2头牛,那么该节点只有2头牛需要被移走.

       那么我们把所有的节点分成两类,一类放左边是那些原始牛数>该点能容纳牛数的节点.另一类放右边是那些容纳牛数>原始牛数的节点.

       当然我们依然先算最短距离,然后二分距离来建图.

       首先对于左边的所有节点,源点s到其中的每个节点有一条边,边的容量为该节点的原始牛数-容纳牛数. 然后对于右边的所有节点,每个节点到t汇点有一条边,该边的容量是 容纳牛数-原始牛数.

       且只要左边点集指定节点到右边点集指定节点的边长<=二分的距离,那么左边点集的指定节点到右边点集的指定节点有一条容量为INF的边.(表示牛可以在规定时间内从左边的特定牛棚转移到右边的特定牛棚去)

       但是上面这种建图方法不会出现下面的BUG:比如二分了距离为40,1点属于左点集, 2和3属于右点集,所以只能1到2,(2与3同属于一边,没有2->3的边,自然1就不能通过2间接的以超过40的距离到达3了)

AC代码: (用的是拆点建图,注意long long 的无穷大和int的无穷大的表示)

#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];
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);
    return DC.Max_Flow() == full_flow;//判断是否满流
}

int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        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;
}