最大流

最大流的含義，就是說從源點到通過的全部路徑的最終到達匯點的全部流量和

殘餘網絡 增廣路徑 反向弧

  觀察下圖-4，這種狀態下它的殘餘網絡如圖-5所示：

   

  也許如今你已經知道什麼是殘餘網絡了，對於已經找到一條從S 到T的路徑的網絡中，只要在這條路徑上，把C(u,v)的值更新爲C(u,v)-P(u,v)，而且添加反向弧C(v,u)。對應的增廣路徑Path爲殘留網絡上從S到T的一條簡單路徑。圖-4中S，A，C，T就是一條增廣路徑，固然還有S，B，C，T。

  此外在未作任何操做以前，原始的有向圖也是一個殘餘網絡，它僅僅是未作任何更新而已。

 

 Edmonds-Karp算法。

  算法流程以下：

  設隊列Q：存儲當前未訪問的節點，隊首節點出隊後，成爲已檢查的標點；

  Path數組：存儲當前已訪問過的節點的增廣路徑；

  Flow數組：存儲一次BFS遍歷以後流的可改進量；

  Repeat:

    Path清空；

    源點S進入Path和Q，Path[S]<-0，Flow[S]<-+∞；

    While Q非空 and 匯點T未訪問 do

        Begin

            隊首頂點u出對；

            For每一條從u出發的弧(u,v) do

                If v未訪問 and 弧(u,v) 的流量可改進；

                Then Flow[v]<-min(Flow[u],c[u][v]) and v入隊 and Path[v]<-u；

    End while

    If(匯點T已訪問)

    Then 從匯點T沿着Path構造殘餘網絡；

  Until 匯點T未被訪問

 

EK算法的核心
反覆尋找源點s到匯點t之間的增廣路徑，如有，找出增廣路徑上每一段[容量-流量]的最小值delta，若無，則結束。
在尋找增廣路徑時，能夠用BFS來找，而且更新殘留網絡的值(涉及到反向邊)。
而找到delta後，則使最大流值加上delta，更新爲當前的最大流值。

 

白書上的圖

b圖表示了一條增廣路，改變流量爲4

 

只要殘量網絡中存在增廣路，流量就能夠增大。若是增廣路不存在，則當前流就是最大流。

 

案例：

這麼一個圖，求源點1，到匯點4的最大流

代碼：

#include <iostream>
#include <queue>
#include<string.h>
using namespace std;
#define arraysize 201
int maxData = 0x7fffffff;
int capacity[arraysize][arraysize]; //記錄殘留網絡的容量
int flow[arraysize];                //標記從源點到當前節點實際還剩多少流量可用
int pre[arraysize];                 //標記在這條路徑上當前節點的前驅,同時標記該節點是否在隊列中
int n,m;
queue<int> myqueue;
int BFS(int src,int des)
{
    int i,j;
    while(!myqueue.empty())       //隊列清空
        myqueue.pop();
    for(i=1;i<m+1;++i)
    {
        pre[i]=-1;
    }
    pre[src]=0;
    flow[src]= maxData;
    myqueue.push(src);
    while(!myqueue.empty())
    {
        int index = myqueue.front();
        myqueue.pop();
        if(index == des)            //找到了增廣路徑
            break;
        for(i=1;i<m+1;++i)
        {
            if(i!=src && capacity[index][i]>0 && pre[i]==-1)
            {
                 pre[i] = index; //記錄前驅
                 flow[i] = min(capacity[index][i],flow[index]);   //關鍵：迭代的找到增量
                 myqueue.push(i);
            }
        }
    }
    if(pre[des]==-1)      //殘留圖中再也不存在增廣路徑
        return -1;
    else
        return flow[des];
}
int maxFlow(int src,int des)
{
    int increasement= 0;
    int sumflow = 0;
    while((increasement=BFS(src,des))!=-1)
    {
         int k = des;          //利用前驅尋找路徑
         while(k!=src)
         {
              int last = pre[k];
              capacity[last][k] -= increasement; //改變正向邊的容量
              capacity[k][last] += increasement; //改變反向邊的容量
              k = last;
         }
         sumflow += increasement;
    }
    return sumflow;
}
int main()
{
    int i,j;
    int start,end,ci;
    while(cin>>n>>m)
    {
        memset(capacity,0,sizeof(capacity));
        memset(flow,0,sizeof(flow));
        for(i=0;i<n;++i)
        {
            cin>>start>>end>>ci;
            if(start == end)               //考慮起點終點相同的狀況
               continue;
            capacity[start][end] +=ci;     //此處注意可能出現多條同一塊兒點終點的狀況
        }
        cout<<maxFlow(1,m)<<endl;
    }
    return 0;
}

View Code

顯而易見capacity存變的流量，進行ek求解

對於BFS找增廣路：

1.         flow[1]=INF，pre[1]=0;

        源點1進隊列，開始找增廣路，capacity[1][2]=40>0，則flow[2]=min(flow[1],40)=40;

        capacity[1][4]=20>0,則flow[4]=min(flow[1],20)=20;

        capacity[2][3]=30>0,則flow[3]=min(folw[2]=40，30)=30；

        capacity[2][4]=30,可是pre[4]=1(已經在capacity[1][4]這遍歷過4號點了)

        capacity[3][4].....

        當index=4（匯點），結束增廣路的尋找

        傳遞迴increasement（該路徑的流），利用前驅pre尋找路徑

路徑也天然變成了這樣：

2.flow[1]=INF，pre[1]=0;

 源點1進隊列，開始找增廣路，capacity[1][2]=40>0，則flow[2]=min(flow[1],40)=40;

        capacity[1][4]=0!>0,跳過

        capacity[2][3]=30>0,則flow[3]=min(folw[2]=40，30)=30；

        capacity[2][4]=30,pre[4]=2，則flow[2][4]=min(flow[2]=40,20)=20;

        capacity[3][4].....

        當index=4（匯點），結束增廣路的尋找

        傳遞迴increasement（該路徑的流），利用前驅pre尋找路徑

 圖也被改爲

  

接下來同理

這就是最終完成的圖，最終sumflow=20+20+10=50（這個就是最大流的值）

 

PS，爲何要有反向邊呢？

 

咱們第一次找到了1-2-3-4這條增廣路，這條路上的delta值顯然是1。因而咱們修改後獲得了下面這個流。（圖中的數字是容量）

 

這時候(1,2)和(3,4)邊上的流量都等於容量了，咱們再也找不到其餘的增廣路了，當前的流量是1。

但這個答案明顯不是最大流，由於咱們能夠同時走1-2-4和1-3-4，這樣能夠獲得流量爲2的流。

那麼咱們剛剛的算法問題在哪裏呢？問題就在於咱們沒有給程序一個」後悔」的機會，應該有一個不走(2-3-4)而改走(2-4)的機制。那麼如何解決這個問題呢？回溯搜索嗎？那麼咱們的效率就上升到指數級了。

而這個算法神奇的利用了一個叫作反向邊的概念來解決這個問題。即每條邊(I,j)都有一條反向邊(j,i)，反向邊也一樣有它的容量。

咱們直接來看它是如何解決的：

在第一次找到增廣路以後，在把路上每一段的容量減小delta的同時，也把每一段上的反方向的容量增長delta。即在Dec(c[x,y],delta)的同時，inc(c[y,x],delta)

咱們來看剛纔的例子，在找到1-2-3-4這條增廣路以後，把容量修改爲以下

這時再找增廣路的時候，就會找到1-3-2-4這條可增廣量，即delta值爲1的可增廣路。將這條路增廣以後，獲得了最大流2。

 

那麼，這麼作爲何會是對的呢？我來通俗的解釋一下吧。

事實上，當咱們第二次的增廣路走3-2這條反向邊的時候，就至關於把2-3這條正向邊已是用了的流量給」退」了回去，不走2-3這條路，而改走從2點出發的其餘的路也就是2-4。（有人問若是這裏沒有2-4怎麼辦，這時假如沒有2-4這條路的話，最終這條增廣路也不會存在，由於他根本不能走到匯點）同時原本在3-4上的流量由1-3-4這條路來」接管」。而最終2-3這條路正向流量1，反向流量1，等於沒有流量。

這就是這個算法的精華部分，利用反向邊，使程序有了一個後悔和改正的機會。而這個算法和我剛纔給出的代碼相比只多了一句話而已。

至此，最大流Edmond-Karp算法介紹完畢。

 

部分轉載自http://www.cnblogs.com/zsboy/archive/2013/01/27/2878810.html

 

另外注意最大流的題目中兩點之間的路徑每每是不惟一的

 

HDU1532

有個水池點1，一條溪流點n，n個節點，m條路徑，問溪流到水池的最大流

最大流模板題

DFS寫法

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int maxn = 220;
const int maxm = 220;
const int inf = 0x7fffffff;
struct edge
{
    int to,cap,rev;
};
vector<edge>v[maxm];
bool used[maxn];
void addedge(int from,int to,int cap)
{
    v[from].push_back((edge){to,cap,v[to].size()});
    v[to].push_back((edge){from,0,v[from].size()-1});
}
int dfs(int s,int t,int f)
{
    if(s==t)
        return f;
    used[s]=true;
    for(int i=0;i<v[s].size();i++)
    {
        edge &tmp = v[s][i];
        if(!used[tmp.to] && tmp.cap>0)
        {
            int d=dfs(tmp.to,t,min(f,tmp.cap));
            if(d>0)
            {
                tmp.cap-=d;
                v[tmp.to][tmp.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s,int t)
{
    int flow=0;
    for(;;)
    {
        memset(used,false,sizeof(used));
        int f=dfs(s,t,inf);
        if(f==0)
            return flow;
        flow+=f;
    }
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<=n;i++)v[i].clear();
        for(int i=0;i<n;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            addedge(x,y,z);
        }
        printf("%d\n",max_flow(1,m));
    }
}

 

BFS標準寫法

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
#define maxn 220
#define inf 0x7fffffff
int cap[maxn][maxn];
int path[maxn];
bool vis[maxn];
int flow[maxn];
queue<int>q;
int bfs(int n)
{
    int st=1,en=n;
    memset(path,-1,sizeof(path));
    memset(vis,false,sizeof(vis));
    while(!q.empty())q.pop();
    q.push(st);
    path[st]=0;
    vis[st]=true;
    flow[st]=inf;
    while(!q.empty())
    {
        int index=q.front();
        q.pop();
        if(index==en)
        {
            return flow[en];
        }

        for(int i=1;i<=n;i++)
        {
            if(!vis[i]&&cap[index][i]>0)
            {
                vis[i]=true;
                path[i]=index;
                flow[i]=min(flow[index],cap[index][i]);
                q.push(i);
            }
        }
    }
    return -1;
}
int max_flow(int n)
{
    int sum=0;
    for(;;)
    {
        int tmp=bfs(n);
        if(tmp==-1)return sum;
        int en=n;
        while(path[en])
        {
            int last=path[en];
            cap[last][en]-=tmp;//正向
            cap[en][last]+=tmp;//反向
            en=path[en];
        }
        sum+=tmp;
    }
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&m,&n))
    {
        memset(cap,0,sizeof(cap));
        int st,en,c;
        while(m--)
        {
            scanf("%d%d%d",&st,&en,&c);
            cap[st][en]+=c;
        }
        printf("%d\n",max_flow(n));
    }

    return 0;
}

 

最小割

http://www.cnblogs.com/kane0526/archive/2013/02/27/2935502.html