UVA - 10480 Sabotage【最小割最大流定理】

题意：

把一个图分成两部分，要把点1和点2分开。隔断每条边都有一个花费，求最小花费的情况下，应该切断那些边。这题很明显是最小割，也就是最大流。把1当成源点，2当成汇点，问题是要求最小割应该隔断那条边。

思路：

最小割，就是在所有割中，容量之和最小的割，这就是我的理解，而最小割的值就是最大流的值，因为很容易想到，从源点s到汇点t的最大流必然会经过割边，那么就有最大流f<=c(割边的值），那么也就是说，当c==f的时候，就是c为小割，即最大流==最小割。第二点，怎么求出最小割的边：在求出最大流之后，残余网络会分成两个部分，和源点相连的是一个集合，和汇点相连的是另一个集合，然后用a表示从源点到其他各点的最大流，在求出最大流之后，a>0 的就在源点集合中，反之为0的就在汇点集合中。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int N = 55;
const int M = 505;
const int inf = 0x3f3f3f3f;

int n, m, g[N][N],flow[N][N];
int p[N], a[N], x[M], y[M], f;

int maxflow()
{
    queue <int> q;
    memset( flow, 0, sizeof(flow));
    f = 0;
    while ( 1 )
    {
        memset( a, 0, sizeof(a) );
        a[1] = inf;
        q.push(1);
        while ( !q.empty() )
        {
            int u = q.front(); q.pop();
            for ( int v = 1; v <= n; ++v )
            if ( !a[v] && flow[u][v] < g[u][v] )
            {
                p[v] = u;
                a[v] = min( a[u], g[u][v] - flow[u][v] );
                q.push(v);
            }
        }
        if ( a[2] == 0 ) break;
        for ( int u = 2; u != 1; u = p[u] )
        {
            flow[p[u]][u] += a[2];
            flow[u][p[u]] -= a[2];
        }
        f += a[2];
    }
    return f;
}

int main()
{
    while(cin>>n>>m,n,m)
    {
        memset( g, 0, sizeof(g) );
        for ( int i = 0; i < m; ++i )
        {
            int s, e, c;
            cin>>s>>e>>c;
            x[i] = s, y[i] = e;
            g[s][e] = g[e][s] = c;
        }
        maxflow();
        for ( int i = 0; i < m; ++i )
        {
            if( ( !a[x[i]] && a[y[i]] ) || ( a[x[i]] && !a[y[i]] ) )
            cout<<x[i]<<" "<<y[i]<<endl;
        }
        cout<<endl;
    }
    return 0;
}