UVa 10480 Sabotage ( 最小割最大流定理）

这是一道很典型的最小割最大流定理，通过这道题，我再一次学习了最小割的定义

最小割，就是在所有割中，容量之和最小的割，这就是我的理解，而最小割的值就是最大流的值，因为很容易想到，从源点s到汇点t的最大流必然会经过割边，那么就有最大流f<=c(割边的值），那么也就是说，当c==f的时候，就是c为小割，即最大流==最小割

第二点，怎么求出最小割的边：在求出最大流之后，残余网络会分成两个部分，和源点相连的是一个集合，和汇点相连的是另一个集合，然后用a表示从源点到其他各点的最大流，在求出最大流之后，a>0 的就在源点集合中，反之为0的就在汇点集合中

代码：

#include 
#include 
#include 
#include 
using namespace std;

const int N = 55;
const int M = 550;
const int INF = 100000000;
int n, m, g[N][N],flow[N][N];
int p[N], a[N], x[M], y[M], f;
int maxflow() {
    queue  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 ( scanf("%d%d", &n, &m) != EOF && !( !m && !n ) ) {
        memset( g, 0, sizeof(g) );
        for ( int i = 0; i < m; ++i ) {
            int s, e, c;
            scanf("%d%d%d", &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]] ) ) printf("%d %d\n", x[i], y[i]);
        }
        printf("\n");
    }
}