poj 2112

 #include <cstdio>
 #include <cstring>
 const int MAXN=;//点数的最大值
 const int MAXM=;//边数的最大值
 const int INF=0x3fffffff;

 struct Node
 {
     int from,to,next;
     int cap;
 }edge[MAXM];

 int tol;
 int head[MAXN];
 int dep[MAXN];
 int gap[MAXN];//gap[x]=y :说明残留网络中dep[i]==x的个数为y
 int matrix[][];
 int n;//n是总的点的个数，包括源点和汇点

 void init()
 {
     tol=;
     memset(head,-,sizeof(head));
 }

 void addedge(int u,int v,int w)
 {
     edge[tol].from=u;
     edge[tol].to=v;
     edge[tol].cap=w;
     edge[tol].next=head[u];
     head[u]=tol++;
     edge[tol].from=v;
     edge[tol].to=u;
     edge[tol].cap=;
     edge[tol].next=head[v];
     head[v]=tol++;
 }
 void BFS(int start,int end)
 {
     memset(dep,-,sizeof(dep));
     memset(gap,,sizeof(gap));
     gap[]=;
     int que[MAXN];
     int front,rear;
     front=rear=;
     dep[end]=;
     que[rear++]=end;
     while(front!=rear)
     {
         int u=que[front++];
         if(front==MAXN)front=;
         for(int i=head[u];i!=-;i=edge[i].next)
         {
             int v=edge[i].to;
             if(dep[v]!=-)continue;
             que[rear++]=v;
             if(rear==MAXN)rear=;
             dep[v]=dep[u]+;
             ++gap[dep[v]];
         }
     }
 }
 int SAP(int start,int end)
 {
     int res=;
     BFS(start,end);
     int cur[MAXN];
     int S[MAXN];
     int top=;
     memcpy(cur,head,sizeof(head));
     int u=start;
     int i;
     while(dep[start]<n)
     {
         if(u==end)
         {
             int temp=INF;
             int inser;
             for(i=;i<top;i++)
                if(temp>edge[S[i]].cap)
                {
                    temp=edge[S[i]].cap;
                    inser=i;
                }
             for(i=;i<top;i++)
             {
                 edge[S[i]].cap-=temp;
                 edge[S[i]^].cap+=temp;
             }
             res+=temp;
             top=inser;
             u=edge[S[top]].from;
         }
         if(u!=end&&gap[dep[u]-]==)//出现断层，无增广路
           break;
         for(i=cur[u];i!=-;i=edge[i].next)
            if(edge[i].cap!=&&dep[u]==dep[edge[i].to]+)
              break;
         if(i!=-)
         {
             cur[u]=i;
             S[top++]=i;
             u=edge[i].to;
         }
         else
         {
             int min=n;
             for(i=head[u];i!=-;i=edge[i].next)
             {
                 if(edge[i].cap==)continue;
                 if(min>dep[edge[i].to])
                 {
                     min=dep[edge[i].to];
                     cur[u]=i;
                 }
             }
             --gap[dep[u]];
             dep[u]=min+;
             ++gap[dep[u]];
             if(u!=start)u=edge[S[--top]].from;
         }
     }
     return res;
 }
 void floyd(int matrix[][],int n)
 {
     for(int k = ;k <= n;k++)
     {
         for(int i = ;i <= n;i++)
         {
             for(int j = ;j <= n;j++)
             {
                 if(matrix[i][j] > matrix[i][k] + matrix[k][j])
                 {
                     matrix[i][j] = matrix[i][k] + matrix[k][j];
                 }
             }
         }
     }
 }
 int main()
 {
     int k,c,m;
     while(~scanf("%d%d%d",&k,&c,&m))
     {
         for(int i = ;i <= k + c;i++)
         {
             for(int j = ;j <= k + c;j++)
             {
                 scanf("%d",&matrix[i][j]);
                 if(matrix[i][j] ==  && i != j)
                 {
                     matrix[i][j] =INF;
                 }
             }
         }
         floyd(matrix,k + c);
         int ans = ;
         for(int i = k + ;i <= k + c;i++)
         {
             for(int j = ;j <= k;j++)
             {
                 if(matrix[i][j] > ans)
                 {
                     ans = matrix[i][j];
                 }
             }
         }
         int s = ,t = k + c + ;
         n = k + c + ;
         int right = ans,left = ;
         while(left +  < right)
         {
             int mid = (left + right) / ;
             init();
             for(int i = k + ;i <= k + c;i++)
             {
                 addedge(s,i,);
                 for(int j = ;j <= k;j++)
                 {
                     if(matrix[i][j] <= mid)
                     {
                         addedge(i,j,);
                     }
                 }
             }
             for(int j = ;j <= k;j++)
             {
                 addedge(j,t,m);
             }
             if(SAP(s,t) == c)
             {
                 right = mid;
             }
             else
             {
                 left = mid;
             }
         }
         printf("%d\n",right);
     }
     return ;
 }

题意:给出奶牛、机器之间的距离（包括奶牛-奶牛距离，机器-机器距离，奶牛-机器距离），以及机器的处理奶牛的最大数量，求走得最远的奶牛可以走的最近距离。

分析：源点构造边，指向每一个奶牛顶点，容量为1（因为每个顶点的奶牛数量都是1），然后二分法枚举最短的距离，奶牛-机器距离不大于限定的距离的建一条由奶牛指向机器的边，容量为1，每个机器都建一条指向汇点的边，容量为m.