題目連結：http://hihocoder.com/problemset/problem/1378

思路：

描述

小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+14=26

小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為最大流。

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

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <cmath>
#include <stack>
#include <queue>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <stdlib.h>
#include <iomanip>
#include <fstream>

using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
#define maxn 505
#define MOD 1000000007
#define mod 2147493647
#define mem(a , b) memset(a , b , sizeof(a))
#define LL long long
#define ULL unsigned long long
#define FOR(i , n) for(int i = 1 ;  i<= n ; i ++)
typedef pair<int , int> pii;
int n , m , t;
vector<int>V[maxn];
int a[maxn][maxn] , path[maxn];
bool vis[maxn] ;
int flow[maxn];

bool GetAugmentPath()
{
    queue<int>q;
    while(!q.empty()) q.pop();
    q.push(1);vis[1] = 1;
    flow[1] = MOD;
    while(!q.empty())
    {
        int cur = q.front();
        q.pop();
        if(cur == n)
        {
            return 1;
        }
        for(int i = 0 ; i < V[cur].size() ; i ++)
        {
            if(!vis[V[cur][i]] && a[cur][V[cur][i]] > 0)
            {
                vis[V[cur][i]] = 1;
                path[V[cur][i]] = cur;
                flow[V[cur][i]] = min(a[cur][V[cur][i]] , flow[cur]);
                q.push(V[cur][i]);

            }
        }
    }
    return 0;
}

void Update(int num)
{
    int u = n , v = path[u];
    while(v != -1)
    {
        a[v][u] -= num;
        a[u][v] += num;
        u = v;
        v = path[u];
    }
    return ;
}

int main()
{
    //scanf("%d" , &t);
    int ncase = 1;
    while(scanf("%d %d" , &n , &m) != EOF)
    {

        for(int i = 0 ; i <= n ; i ++) V[i].clear();
        mem(a , 0);mem(vis , 0);mem(path , -1);mem(flow , 0);
        int u , v , c ;
        for(int i = 0 ; i < m ; i ++)
        {
            scanf("%d %d %d" , &u , &v , &c);
            a[u][v] += c ;
          //  a[v][u] = max(0 , a[v][u]);
            V[u].push_back(v);
            V[v].push_back(u);
        }
        int ans = 0;
        while(GetAugmentPath())
        {
            ans += flow[n];
            Update(flow[n]);
            mem(vis , 0);mem(path , -1);mem(flow , 0);
        }
        int Node[maxn] , id = 0;
        for(int i = 1 ; i <= n ; i ++)
        {
            if(vis[i])
            {
                Node[id++] = i;
            }
        }
        printf("%d %d\n" , ans , id);
        for(int i = 0 ; i < id; i ++)
        {
            printf("%d" , Node[i]);
            if(i != id - 1) printf(" ");
          //  else printf("%d\n");
        }
        cout << endl;
    }
    return 0;
}