poj 2125 Destroying The Graph 最小割+方案输出

构图思路: 

1.将所有顶点v拆成两个点， v1,v2

2.源点S与v1连边，容量为 W-

3.v2与汇点连边，容量为 W+

4.对图中原边( a, b ), 连边 (a1,b2)，容量为正无穷大

则该图的最小割(最大流)即为最小花费。

简单证明： 根据ST割集的定义，将顶点分成两个点集。所以对于原图中的边(a,b),转换成 S->a1->b2->T. 则此时路径必定存在

一条割边，因为a1->b2为无穷大，所以割边必定是 S->a1 or b2->T,  若为前者则意味着删除a顶点的W-，后者则是b顶点的W+.

所以该图最小割即为最小花费。

计算方案： 对于构图后跑一次最大流，然后对于残留网络进行处理，首先从源点S出发，标记所有能访问到的顶点，这些顶点即为S割点集中

的顶点。 其他则为T集合中顶点， 然后从所有边中筛选出( A属于S,B属于T,且（A,B)容量为0 )的边，即为割边。因为我们的W+/W-边都只有一条，

且都分开了。比较容易处理。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

const int MAXN = 220;
const int MAXM = 5050;
const int inf = 0x3f3f3f3f;
int A[MAXN], B[MAXN];
struct Edge{
    int u, v, f, nxt;
}edge[250000];
int head[MAXN], idx;
int n, m;
int S, T, N;

void AddEdge(int u,int v,int f){
    edge[idx].u = u, edge[idx].v = v, edge[idx].f = f;
    edge[idx].nxt = head[u]; head[u] = idx++;
    edge[idx].u = v, edge[idx].v = u, edge[idx].f = 0;
    edge[idx].nxt = head[v]; head[v] = idx++;
}

int h[MAXN], vh[MAXN];
int dfs(int u,int flow){
    if(u == T) return flow;
    int tmp = h[u]+1, sum = flow;
    for(int i = head[u]; ~i; i = edge[i].nxt){
        if( edge[i].f && (h[edge[i].v]+1 == h[u]) ){
            int p = dfs( edge[i].v, min(sum,edge[i].f));
            edge[i].f-=p, edge[i^1].f+=p, sum-=p;
            if( sum==0 || h[S]==N ) return flow-sum;
        }
    }
    for(int i = head[u]; ~i; i = edge[i].nxt)
        if( edge[i].f ) tmp = min( tmp, h[edge[i].v] );
    if( --vh[ h[u] ] == 0 ) h[S] = N;
    else ++vh[ h[u]=tmp+1 ];
    return flow-sum;
}
int sap(){
    int maxflow = 0;
    memset(h,0,sizeof(h));
    memset(vh,0,sizeof(vh));
    vh[0] = N;
    while( h[S] < N ) maxflow += dfs( S, inf );
    return maxflow;
}

bool vis[MAXN];
int res[MAXM];

void DFS(int u ){
    vis[u] = true;
    for(int i = head[u]; ~i; i = edge[i].nxt ){
        int v = edge[i].v;
        if( !vis[v] && edge[i].f )
            DFS( v );
    }
}
void solve(){
    int maxflow = sap();
    printf("%d\n", maxflow );
    memset( vis,0,sizeof(vis));
    DFS( S );

    int cnt = 0;
    for(int i = 0; i < idx; i += 2){
        int u = edge[i].u, v = edge[i].v;
        if( vis[u] && !vis[v] && (edge[i].f == 0) )
            res[cnt++] = i;
    }
    printf("%d\n", cnt );
    for(int i = 0; i < cnt; i++ ){
        int u = edge[ res[i] ].u, v = edge[ res[i] ].v;
        if( u == S ) printf("%d -\n", v);
        else printf("%d +\n", u-n );
    }
}

int main(){
    while( scanf("%d%d",&n,&m) != EOF ){
        S = 0, T = 2*n+1, N = 2*n+2; idx = 0;
        memset( head, -1, sizeof(head));

        for(int i = 1; i <= n; i++ )
            scanf("%d", &A[i]);
        for(int i = 1; i <= n; i++ )
            scanf("%d", &B[i]);
        int a, b;
        for(int i = 0; i < m; i++ ){
            scanf("%d%d", &a,&b);
            AddEdge( a, n+b, inf );
        }
        for(int i = 1; i <= n; i++){
            AddEdge( S, i, B[i] ); // - out
            AddEdge( n+i, T, A[i] );// + in
        }
        solve();
    }
    return 0;
}