最大流的基本概念有以下幾點：

              1.殘存網路：即為一條管道被佔用了一部分流量之後所剩下的流量。在網路流中，圖被看為一個有向圖，殘存流量向量相加後永遠不變。這一點有點像基爾霍夫定律。

              2.在找到一個流之後，仍然存在的從源點到匯點的路徑。這叫做增廣路徑。加入增廣路徑後，流的容量一定能夠提升。尋找增廣路徑一般使用DFS或BFS。

ford-fulkerson演算法就是這樣，當有向圖中存在增廣路徑，即將這條增廣路徑加入流當中。當有向圖中無法再找到增廣路徑的時候，此時的流即為我們所要求的最大流。(依據為最大流最小割定理)。

題目地址：http://poj.org/problem?id=1273

這一題要求我們求這條排水系統最大的負載，是一個明顯的網路流問題。我們構造一個有向圖，然後求由1-n的最大流。並直到系統內無法再加入增廣路徑為止。

第一中演算法：Ford-Fulkerson演算法

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f3f
using namespace std;
int maper[205][205],pre[205];
int e_num,v_num;
queue<int>fp;
bool bfs(int src,int des)
{
         int index,i;
         memset(pre,-1,sizeof(pre));
         while(!fp.empty())fp.pop();
         pre[src]=src;
         fp.push(src);
         while(!fp.empty())
         {
                  index=fp.front();
                  fp.pop();
                  for(i=1;i<=v_num;i++)
                  {
                         if(pre[i]==-1&&maper[index][i]>0)
                         {
                                   pre[i]=index;
                                   fp.push(i);
                                   if(i==des)return true;
                         }
                  }
         }                                              //尋找增廣路徑
         return false;
}
int maxflow(int src,int des)
{
        int i,jieguo=0,minflow;
        while(bfs(src,des))
        {
                minflow=INF;
                for(i=des;i!=src;i=pre[i])
                       minflow=min(minflow,maper[pre[i]][i]);
                for(i=des;i!=src;i=pre[i])
                {
                        maper[pre[i]][i]-=minflow;
                        maper[i][pre[i]]+=minflow;
                }
                jieguo+=minflow;
        }
        return jieguo;
}
int main()
{
        //freopen("input","r",stdin);
        int i;
        int u,v,w;
        while(scanf("%d %d",&e_num,&v_num)!=EOF)
        {
                  memset(maper,0,sizeof(maper));
                  for(i=1;i<=e_num;i++)
                  {
                           cin >> u >> v >> w;
                           maper[u][v]+=w;
                  }
                  int ans=maxflow(1,v_num);
                  cout << ans << endl;
        }
        return 0;
}
 

第二種演算法:Dinic演算法:首先用BFS對整個圖中的節點進行分層(按照搜尋到達的前後順序)。然後利用DFS對找到過的增廣路徑進行擴充套件並更新網路流。然後再次進行分層，增廣。進過迭代後，如果BFS無法到底匯點，則說明不存在從源點到匯點的增廣路徑。搜尋即告結束。此時我們得到的流一定為最大流。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f3f
#define V 205
using namespace std;
int matcher[V][V], e_num, v_num;
int src,des,height[V];
queue<int>myrode;
bool bfs(int src, int des)
{
         int i;
         for(i=1;i<=v_num;i++)height[i] = -1;
         while(!myrode.empty())myrode.pop();
         myrode.push(src);height[src]=0;
         while(!myrode.empty())
         {
                  int index = myrode.front();
                  myrode.pop();
                  for(i = 1;i <= v_num; i++)
                  {
                            if(height[i] == -1&& matcher[index][i] > 0)
                            {
                                      height[i]=height[index] + 1;
                                      myrode.push(i);
                            }
                  }
         }
         if(height[des] == -1)return false;
         else return true;
}                        //利用廣度搜索將整個圖分層

int dinic( int n, int contain)
{
        if(n==des)return contain;//廣度搜索達到了匯點，直接返回
        int  i , temp, last;
        temp = contain;
        for(i=1;i<=v_num;i++)
        {
               if(height[i] == height[n]+1&&matcher[n][i]>0)
               {
                       last = dinic(i,min(contain, matcher[n][i]));
                       contain -= last;
                       matcher[n][i]-=last;
                       matcher[i][n]+=last;
               }
               if(contain<=0)break;//優化:當正向流量用盡時，不再繼續搜尋
        }
        return temp-contain;//返回所用的最大流
}

int main()
{
        freopen("input","r",stdin);
        int  i,  u, v, w, ans;
        while(scanf("%d %d",&e_num,&v_num)!=EOF)
        {
                  memset(matcher,0,sizeof(matcher));
                  ans = 0;
                  for(i = 1;i <= e_num; i++)
                  {
                          cin >> u >> v >> w;
                          matcher[u][v] += w;
                  }
                  src = 1;des =  v_num;
                  while(bfs(src , des))
                  {
                            ans += dinic(src, INF);
                  }
                  cout << ans << endl;
        }
        return 0;
}
 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f3f
#define V 205
using namespace std;
int height[V],over[V];
int matcher[V][V], e_num, v_num;
int src,des;
queue<int>lister;
int push_rebel(int s,int t)
{
       int jieguo=0;

       while(!lister.empty())lister.pop();
       memset(height,0,sizeof(height));
       memset(over,0,sizeof(over));
       over[s]=INF;over[t]=-INF;
       height[s]=v_num;
       lister.push(s);

       int index,temp,i;
       while(!lister.empty())
       {
               index = lister.front();
               lister.pop();
               for(i=1;i<=v_num;i++)
               {
                        temp = min(over[index],matcher[index][i]);
                        if(temp>0&&(height[index]==height[i]+1|| index == s))//檢查是否滿足push操作
                        {
                                 matcher[index][i] -= temp;
                                 matcher[i][index] += temp;
                                 if(i==t)jieguo += temp;
                                 over[index] -= temp;over[i] += temp;
                                 if(i!=s&&i!=t)lister.push(i);//若i非源點和匯點，則壓入佇列
                        }
                        if(over[index]<=0)break;
               }
               if(index!=s&&index!=t&&over[index]>0)
               {
                       lister.push(index);
                       height[index]++;
               }//若index依然滿溢，則增加index點的高度
       }
       return jieguo;
}
int main()
{
        freopen("input","r",stdin);
        int  i,  u, v, w, ans;
        while(scanf("%d %d",&e_num,&v_num)!=EOF)
        {
                  memset(matcher,0,sizeof(matcher));
                  ans = 0;
                  for(i = 1;i <= e_num; i++)
                  {
                          cin >> u >> v >> w;
                          matcher[u][v] += w;
                  }
                  src = 1;des =  v_num;
                  ans = push_rebel(src, des);
                  cout << ans << endl;

        }
        return 0;
}