hiho 第116周,最大流最小割定理,求最小割集S,T


小Hi:在上一周的Hiho一下中我們初步講解了網絡流的概念以及常規解法,小Ho你還記得內容么?

小Ho:我記得!網絡流就是給定了一張圖G=(V,E),以及源點s和匯點t。每一條邊e(u,v)具有容量c(u,v)。網絡流的最大流問題求解的就是從s到t最多能有多少流量。

小Hi:那這個問題解決辦法呢?

小Ho:解決網絡流的基本思路就是尋找增廣路,不斷更新殘留網絡。直到找不到新的增廣路,此時得到的流就是該網絡的最大流。

小Hi:沒錯,看來你記得很牢嘛。

小Ho:哎嘿嘿,不過這里我有一個問題,為什么找不到增廣路時就已經找到了最大流呢?

小Hi:這一次我就來解決你的疑惑,首先我們要從網絡流的割開始講起。

對於一個網絡流圖G=(V,E),其割的定義為一種點的划分方式:將所有的點划分為S和T=V-S兩個部分,其中源點s∈S,匯點t∈T。

對於一個割(S,T),我們定義凈流f(S,T)表示穿過割(S,T)的流量之和,即:

f(S,T) = Σf(u,v) | u∈S,v∈T

舉個例子(該例子選自算法導論):

凈流f = f(2,4)+f(3,4)+f(3,5) = 12+(-4)+11 = 19

同時我們定義割的容量C(S,T)為所有從S到T的邊容量之和,即:

C(S,T) = Σc(u,v) | u∈S,v∈T

同樣在上面的例子中,其割的容量為:

c(2,4)+c(3,5)=12+11=23

小Ho:也就是說在計算割(S,T)的凈流f(S,T)時可能存在反向的流使得f(u,v)<0,而容量C(S,T)一定是非負數。

小Hi:你這么說也沒錯。實際上對於任意一個割的凈流f(S,T)總是和網絡流的流量f相等。比如上面例子中我們改變一下割的方式:

可以計算出對於這兩種情況凈流f(S,T)仍然等於19。

一個直觀的解釋是:根據網絡流的定義,只有源點s會產生流量,匯點t會接收流量。因此任意非s和t的點u,其凈流量一定為0,也即是Σ(f(u,v))=0。而源點s的流量最終都會通過割(S,T)的邊到達匯點t,所以網絡流的流f等於割的靜流f(S,T)。

嚴格的證明如下:

f(S,T) = f(S,V) - f(S,S)
從S到T的流等於從S到所有節點的流減去從S到S內部節點的流
f(S,T) = f(S,V)
由於S內部的節點之間存在的流一定有對應的反向流,因此f(S,S)=0
f(S,T) = f(s,V) + f(S-s,V)
再將S集合分成源點s和其他屬於S的節點
f(S,T) = f(s,V)
由於除了源點s以外其他節點不會產生流,因此f(S-s,V)=0
f(S,T) = f(s,V) = f

所以f(S,T)等於從源點s出來的流,也就是網絡的流f。

小Ho:簡單理解的話,也就是說任意一個割的凈流f(S,T)都等於當前網絡的流量f。

小Hi:是這樣的。而對於任意一個割的凈流f(S,T)一定是小於等於割的容量C(S,T)。那也即是,對於網絡的任意一個流f一定是小於等於任意一個割的容量C(S,T)。

而在所有可能的割中,存在一個容量最小的割,我們稱其為最小割。

這個最小割限制了一個網絡的流f上界,所以有:

對於任一個網絡流圖來說,其最大流一定是小於等於最小割的。

小Ho:但是這和增廣路又有什么關系呢?

小Hi:接下來就是重點了。利用上面講的知識,我們可以推出一個最大流最小割定理:

對於一個網絡流圖G=(V,E),其中有源點s和匯點t,那么下面三個條件是等價的:
1. 流f是圖G的最大流
2. 殘留網絡Gf不存在增廣路
3. 對於G的某一個割(S,T),此時f = C(S,T)

首先證明1 => 2:

我們利用反證法,假設流f是圖G的最大流,但是殘留網絡中還存在有增廣路p,其流量為fp。則我們有流f'=f+fp>f。這與f是最大流產生矛盾。

接着證明2 => 3:

假設殘留網絡Gf不存在增廣路,所以在殘留網絡Gf中不存在路徑從s到達t。我們定義S集合為:當前殘留網絡中s能夠到達的點。同時定義T=V-S。
此時(S,T)構成一個割(S,T)。且對於任意的u∈S,v∈T,有f(u,v)=c(u,v)。若f(u,v)<c(u,v),則有Gf(u,v)>0,s可以到達v,與v屬於T矛盾。
因此有f(S,T)=Σf(u,v)=Σc(u,v)=C(S,T)。

最后證明3 => 1:

由於f的上界為最小割,當f到達割的容量時,顯然就已經到達最大值,因此f為最大流。

這樣就說明了為什么找不到增廣路時,所求得的一定是最大流。

小Ho:原來是這樣,我明白了。

輸入

第1行:2個正整數N,M。2≤N≤500,1≤M≤20,000。

第2..M+1行:每行3個整數u,v,c(u,v),表示一條邊(u,v)及其容量c(u,v)。1≤u,v≤N,0≤c(u,v)≤100。

給定的圖中默認源點為1,匯點為N。可能有重復的邊。

輸出

第1行:2個整數A B,A表示最小割的容量,B表示給定圖G最小割S集合的點數。

第2行:B個空格隔開的整數,表示S集合的點編號。

若存在多個最小割可以輸出任意一個的解。

#include <bits/stdc++.h>

using namespace std;

#define maxn 505
#define INF 0x3f3f3f3f

struct Edge
{
    int from,to,cap,flow;
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge> edge;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];
    void addEdge (int from,int to,int cap)
    {
        edge.push_back((Edge){from,to,cap,0});
        edge.push_back((Edge){to,from,0,0});
        m = edge.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        memset(vis,0,sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while(!Q.empty())
        {
            int x = Q.front();
            Q.pop();
            for(int i=0; i<G[x].size(); i++)
            {
                Edge & e = edge[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a)
    {
        if(x==t||a==0) return a;
        int flow = 0,f;
        for(int & i = cur[x]; i<G[x].size(); i++)
        {
            Edge & e = edge[G[x][i]];
            if(d[x] + 1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow +=f;
                edge[G[x][i]^1].flow -=f;
                flow +=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    int Maxflow (int s,int t) {
        this->s = s;this->t = t;
        int flow = 0;
        while(BFS()) {
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }

    //求最小割S,T;
    void new_BFS(int s,int n)
    {
        memset(vis,0,sizeof(vis));
        d[s] = 0;
        vis[s] = 1;
        queue<int> Q;
        Q.push(s);
        while(!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            for(int i=0;i<G[u].size();i++)
            {
                Edge & e = edge[G[u][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[u] + 1;
                    Q.push(e.to);
                }
            }
        }

        int cnt = 0;
        for(int i=1;i<=n;i++)
        {
            if(vis[i]) cnt++;
        }
        printf("%d\n",cnt);
        for(int i=1;i<=n;i++)
            if(vis[i]) printf("%d ",i);
        puts("");
    }

}sol;


int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++) {
        int u,v,cap;
        scanf("%d%d%d",&u,&v,&cap);
        sol.addEdge(u,v,cap);
    }
    printf("%d ",sol.Maxflow(1,n));
    sol.new_BFS(1,n);
    return 0;
}
View Code

 我的理解:

首先一個任意的凈流f(s,t)都等於當前網絡的流量f.

割的容量C(s,t),為所有從s到t的邊容量之和。就有c(s,t)>=f(s,t),那么改變割的定義就會產生一個最小割。

而這個最小割限制了整個網絡的流f的上界,所以有:

最大流=最小割。

 

然后就是求最小割集:

Dinic算法,不停分層,按層增廣。求的最大流最小割。

然后就是求最小割集,一遍分層,標記分割s,t;

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM