hihocoder 網絡流二·最大流最小割定理

網絡流二·最大流最小割定理

時間限制:10000ms

單點時限:1000ms

內存限制:256MB

描述

小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集合的點編號。

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

樣例輸入

6 7
1 2 3
1 3 5
2 4 1
3 4 2
3 5 3
4 6 4
5 6 2

樣例輸出

5 4
1 2 3 5

分析：最小割最大流，dicnic；
代碼：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <climits>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <vector>
#include <list>
#define rep(i,m,n) for(i=m;i<=n;i++)
#define rsp(it,s) for(set<int>::iterator it=s.begin();it!=s.end();it++)
#define mod 1000000007
#define inf 0x3f3f3f3f
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define ll long long
#define pi acos(-1.0)
#define pii pair<int,int>
#define Lson L, mid, rt<<1
#define Rson mid+1, R, rt<<1|1
const int maxn=5e2+10;
using namespace std;
ll gcd(ll p,ll q){return q==0?p:gcd(q,p%q);}
ll qpow(ll p,ll q){ll f=1;while(q){if(q&1)f=f*p;p=p*p;q>>=1;}return f;}
int n,m,k,t,h[maxn],tot,vis[maxn],s,cur[maxn];
bool flag;
set<int>ans;
struct node
{
    int to,nxt,cap,flow;
}e[20000<<1];
void add(int x,int y,int z)
{
    e[tot].to=y;
    e[tot].nxt=h[x];
    e[tot].cap=z;
    h[x]=tot++;
    e[tot].to=x;
    e[tot].nxt=h[y];
    h[y]=tot++;
}
bool bfs()
{
    memset(vis,0,sizeof vis);
    queue<int>p;
    p.push(s);
    vis[s]=1;
    if(flag)ans.insert(s);
    while(!p.empty())
    {
        int x=p.front();p.pop();
        for(int i=h[x];i!=-1;i=e[i].nxt)
        {
            int to=e[i].to,cap=e[i].cap,flow=e[i].flow;
            if(!vis[to]&&cap>flow)
            {
                vis[to]=vis[x]+1;
                p.push(to);
                if(flag)ans.insert(to);
            }
        }
    }
    return vis[t];
}
int dfs(int x,int a)
{
    if(x==t||a==0)return a;
    int ans=0,j;
    for(int&i=cur[x];i!=-1;i=e[i].nxt)
    {
        int to=e[i].to,cap=e[i].cap,flow=e[i].flow;
        if(vis[to]==vis[x]+1&&(j=dfs(to,min(a,cap-flow)))>0)
        {
            e[i].flow+=j;
            e[i^1].flow-=j;
            ans+=j;
            a-=j;
            if(a==0)break;
        }
    }
    return ans;
}
int max_flow(int s,int t)
{
    int flow=0,i;
    while(bfs())
    {
        rep(i,1,n)cur[i]=h[i];
        flow+=dfs(s,inf);
    }
    return flow;
}
int main()
{
    int i,j;
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    s=1,t=n;
    printf("%d",max_flow(s,t));
    flag=true;
    bfs();
    printf(" %d\n",ans.size());
    for(int x:ans)printf("%d ",x);
    printf("\n");
    //system("Pause");
    return 0;
}