POJ2112解题报告【网络流-初级-isap+floyd_warshall+二分】

题目连接：http://poj.org/problem?id=2112

题意：有C头牛和K个挤奶机，每个挤奶机最多能为M头牛挤奶，他们在农场的不同位置。牛和牛、牛和机器之间可能有路，牛只能沿着路移动。给出路的长度，问要让这些牛都挤完奶，所有牛中走得最远的牛的行走路程最短是多少？

解题思路：首先要建图，把每个牛和挤奶机都看成节点，节点间的边既是他们之间的路的长度。然后用floyd算法，求出每个点之间的最短距离。记录最长的距离，然后二分该距离。再建一个网络流的图，图中包括一个源点、一个汇点、挤奶机的点、牛的点，源点和牛之间都连上容量为1的边，牛和挤奶机之间的距离如果小于mid(之前二分的距离)，那么就建立一条容量为1的边，每个挤奶机和汇点之间都建立一条容量为K的边。然后ISAP算法求最大流，如果最大流等于C，向下二分否则向上二分。

算法：ISAP+floyd_walshall+二分

#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdlib>
#include<algorithm>
#include<iostream>
#include<map>
#include<string>


//#define r(x,date) (*((STRUCT*)x).date)
//#define dp(i,j) dp[i][j]
//#define dp(i,j,k) dp[i][j][k]
#define INF 0x7ffffff
#define ff(i,from,to) for(i=from;i<=to;i++)
#define rff(i,from,to) for(i=from;i>=to;i--)
#define ll long long
#define MAX_SIDE 110000
#define MAX_NODE 300
#define mset(a,num) memset(a,num,sizeof(a))
using namespace std;

template<class T>bool myfun_upmax(T &a,const T&b){return b>a?a=b,1:0;}
template<class T>bool myfun_upmin(T &a,const T&b){return b<a?a=b,1:0;}
template<class T>void myfun_swap(T &a,T &b){T temp;temp=a;a=b;b=temp;}
template<class T>T myfun_max(const T a,const T b){return a>b?a:b;}
template<class T>T myfun_min(const T a,const T b){return a<b?a:b;}


int cmp(const void *a,const void *b){
    return 0;
}

inline void readint(int &ret) {
	char c;
	do {	c = getchar();
	} while(c < '0' || c > '9');
	ret = c - '0';
	while((c=getchar()) >= '0' && c <= '9')
		ret = ret * 10 + ( c - '0' );
}

int node[MAX_NODE];
struct SIDE{
    int to,next,c;
    SIDE(){}
    SIDE(int to,int next,int c):to(to),next(next),c(c){}
}side[MAX_SIDE];

int top;
void add_side(int u,int v,int c){
    side[top]=SIDE(v,node[u],c);
    node[u]=top++;
    side[top]=SIDE(u,node[v],0);
    node[v]=top++;
}

int START,END,SIZE;
int gap[MAX_NODE],pre[MAX_NODE],dis[MAX_NODE],cur[MAX_NODE];
int sap(){
    int maxflow=0;
    int aug=INF;
    int u=START,v;
    for(int i=0;i<SIZE;i++){
        gap[i]=dis[i]=0;
        cur[i]=node[i];
    }

    gap[START]=SIZE;
    pre[START]=START;
    while(dis[u]<SIZE){
        for(int &i=cur[u];i!=-1;i=side[i].next){
            v=side[i].to;
            if( side[i].c && dis[u]==dis[v]+1)break;
        }

        if(cur[u]!=-1){
            myfun_upmin(aug,side[cur[u]].c);
            pre[v]=u;u=v;
            if(u==END){
                maxflow+=aug;
                while(u!=START){
                    u=pre[u];
                    side[cur[u]].c-=aug;
                    side[cur[u]^1].c+=aug;
                }
                aug=INF;
            }
        }else{
            int min_dis=SIZE;
            for(int i=node[u];i!=-1;i=side[i].next){
                v=side[i].to;
                if(side[i].c && myfun_upmin(min_dis,dis[v]))
                    cur[u]=i;
            }
            if(--gap[dis[u]]==0)break;
            ++gap[dis[u]=min_dis+1];
            u=pre[u];
        }
    }
    return maxflow;
}

int K,C;
int N;
int matrix[MAX_NODE][MAX_NODE];
int floyd_warshall(){
    int MAX=0;
    for(int k=0;k<N;k++){
        for(int i=0;i<N;i++)
        for(int j=0;j<N;j++){
            if(i!=j && matrix[i][k]+matrix[k][j]<matrix[i][j]){
                matrix[i][j]=matrix[i][k]+matrix[k][j];
                if(matrix[i][j]<INF && matrix[i][j]>MAX)
                    MAX=matrix[i][j];
            }
        }
    }
    return MAX;
}

int M;
void build(int limit){
    //length not less than the limit
    top=0;
    for(int i=0;i<N+2;i++)node[i]=-1;
    for(int i=0;i<K;i++){
        for(int j=K;j<N;j++){
            if(matrix[i][j]<=limit)
                add_side(j,i,1);
        }
    }
    int i;
    for(i=0;i<K;i++){
        add_side(i,END,M);
    }
    for(;i<N;i++){
        add_side(START,i,1);
    }
}

int solve(int low,int high){
    while(low<=high){
        int mid=low+(high-low)/2;
        build(mid);
        int r=sap();
        if(r==C)high=mid-1;
        else low=mid+1;
    }
    return low;
}

int main()
{
    readint(K);
    readint(C);
    readint(M);
    N=K+C;
    START=N;
    END=N+1;
    SIZE=N+2;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++){
            readint(matrix[i][j]);
            if(matrix[i][j]==0)matrix[i][j]=INF;
        }
    }

    int max_path=floyd_warshall();
    int r=solve(1,max_path);
    printf("%d\n",r);
    return 0;
}