poj1273Drainage Ditches

 #include<iostream>
 /*
     题意：就是寻找从源点到汇点的最大流！
           要注意的是每两个点的流量可能有多个，也就是说有重边，所以要把两个点的所有的流量都加起来
           就是这两个点之间的流量了！
 
     思路：建图之后直接套用最大流算法（EK, 或者是Dinic算法） 图解Dinic算法流程！
       
 */
 #include<queue>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 #define INF 0x3f3f3f3f3f3f3f3f
 #define N 205
 using namespace std;
 typedef long long LL;
 LL cap[N][N];
 
 int m, n;
 LL maxFlow;
 int d[N];
 queue<int>q;
 
 bool bfs(){
     q.push();
     memset(d, , sizeof(d));
     d[]=;
     while(!q.empty()){
         int u=q.front();
         q.pop();
         for(int v=; v<=n; ++v)
            if(!d[v] && cap[u][v]>){
               d[v]=d[u]+;
               q.push(v);
            }
     }
     if(!d[n])  return false;
     return true;
 }
 
 LL dfs(int u, LL flow){
     if(u==n) return flow;
     for(int v=; v<=n; ++v)
        if(d[v]==d[u]+ && cap[u][v]>){
            LL a=dfs(v, min(flow, cap[u][v]));
            if(a==) continue;//如果a==0 说明没有找到从起点到汇点的增广路， 然后换其他路接着寻找！
            cap[u][v]-=a;
            cap[v][u]+=a;
            return a;
        }
     return ;
 }
 
 void Dinic(){
     LL flow;
      while(bfs()){//利用bfs构造好层次图，这样dfs在寻找阻塞流的时候，就不会盲目的寻找了！
         while(flow=dfs(, INF)) maxFlow+=flow;//利用构造好的层次图不断的寻找阻塞流！
     }
 }
 
 int main(){
     while(scanf("%d%d", &m, &n)!=EOF){
         memset(cap, , sizeof(cap));
         while(m--){
             int u, v;
             LL w;
             scanf("%d%d%lld", &u, &v, &w);
             cap[u][v]+=w;
         }
         maxFlow=;
         Dinic();
         printf("%lld\n", maxFlow);
     }
     return ;
 } 

 //EK算法同样搞定
 #include<iostream>
 #include<queue>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define INF 0x3f3f3f3f
 using namespace std;
 typedef __int64 LL;
 LL cap[][];
 int pre[];
 LL a[];
 int m, n;
 queue<int>q;
 LL maxFlow;
 bool spfa(){
    while(!q.empty()) q.pop();
    memset(a, , sizeof(a));
    q.push();
    a[]=INF;
    while(!q.empty()){
       int u=q.front();
       q.pop();
       for(int v=; v<=n; ++v)
          if(!a[v] && cap[u][v]>){
             pre[v]=u;
             a[v]=min(a[u], cap[u][v]);
             q.push(v);
          }
       if(a[n]) break;
    }
    if(!a[n]) return false;
    return true;
 }
 
 void EK(){
     maxFlow=;
     while(spfa()){
        int u=n;
        maxFlow+=a[n];
        while(u!=){
            cap[pre[u]][u]-=a[n];
            cap[u][pre[u]]+=a[n];
            u=pre[u];
        }
     }
 }
 int main(){
    while(scanf("%d%d", &m, &n)!=EOF){
          memset(cap, , sizeof(cap));
          while(m--){
             int u, v;
             LL w;
             scanf("%d%d%I64d", &u, &v, &w);
             cap[u][v]+=w;
          }
          EK();
          printf("%I64d\n", maxFlow);
    }
    return ;
 }