UVA 10480 Sabotage ( 最小割）

题目连接

题意：

现在有n个城市，m条路，现在要把整个图分成2部分，编号1，2的城市分成在一部分中，拆开每条路都需要花费，现在问达成目标的花费最少要隔开那几条路。

思路：

1）求最小割

2）然后输出割的哪个边

3）记录哪个城市之间有连线，然后跑完最大流后（源点S 和 汇点E 分成了两集合），从源点S DFS 找出在S集合中的所有点，然后标记，然后判断S集合中的点 和 E 集合中的点是否有连线，如果有连线，则输出。

AC代码：

#include<cstring>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stdio.h>
using namespace std;
const int maxn = 2010;
const int maxm = 1e5 + 10;
const int inf = 0x3f3f3f3f;
int M, N;
int s, e;
struct ac{
    int v, c, nex;
}edge[maxm];

int head[maxn], dis[maxn], curedge[maxn], cnt;
void init() {
    cnt = 0;
    memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int c) {
	// 正向建边
    edge[cnt] = {v, c, head[u]};
    head[u] = cnt++;
    // 反向建边, 流量为0
    edge[cnt] = {u, 0, head[v]};
    head[v] = cnt++;
}
bool bfs() {
    queue<int> que;
    que.push(s);
    memset(dis, 0, sizeof(dis)); // 对图进行分层
    dis[s] = 1;
    while (!que.empty()) {
        int u = que.front();
        que.pop();
        for (int i = head[u]; i != -1; i = edge[i].nex) {
        	int v = edge[i].v;
        	int c = edge[i].c;
        	// 如果节点v已经分过层或者u->v流量为0, continue
            if (dis[v] || c == 0) continue;
            dis[v] = dis[u] + 1; // 对v进行标记并加入队列
            que.push(v);
        }
    }
    return dis[e] > 0;  // 判断是否存在增广路，s是否能到达e
}
 
int dfs(int u, int flow) { // 增广路走到u点的最小流量为flow
    if (u == e || flow == 0) return flow;
    // 遍历u的所有出边
    for (int &i = curedge[u]; i != -1; i = edge[i].nex) { // 当前弧优化
    	int v = edge[i].v;
    	int c = edge[i].c;
    	// 判断能否u->v增广
        if (dis[v] != dis[u] + 1 || c == 0) continue;
        int d = dfs(v, min(flow, c));
        if (d > 0) { // 找到一条增广路，修改增广路上的正反向边
            edge[i].c -= d;
            edge[i^1].c += d;
            return d;
        }            
    }
    dis[u] = -1; // // 炸点优化
    return 0;
}
 
int Dinic() {
    int sum = 0, d;
    while (bfs()) { // 判读是否存在增广路
        for (int i = 0; i <= N * 2; ++i) curedge[i] = head[i]; // copy head数组，在dfs中可以直接得到下一条没有被增广过的边
        while ((d = dfs(s, inf)) > 0) sum += d; // 多次dfs找增广路
	}
    return sum;
}
struct node{
	int u, v;
}G[550];
bool vis[55];
int Cnt = 0;
void Dfs(int u){
	vis[u] = 1;
	for(int i = head[u]; i != -1; i = edge[i].nex){
		int v = edge[i].v;
		if(vis[v] || edge[i].c == 0) continue;
		Dfs(v);
	}
}
int main(){
	int u, v, c;
	while(scanf("%d%d", &N, &M) && N && M) {
		init(); 
		s = 1;
		e = 2;
		Cnt = 0;
		for(int i = 1; i <= M; ++i) {
			scanf("%d%d%d", &u, &v, &c);
			addedge(u, v, c);
			addedge(v, u, c);
			G[Cnt].u = u;
			G[Cnt++].v = v;
		}
		Dinic();
		memset(vis, 0, sizeof(vis));
		Dfs(s);
		for(int i = 0; i < Cnt; ++i) {
			u = G[i].u;
			v = G[i].v;
			if( (vis[u] && !vis[v] )|| (vis[v] && !vis[u] )) {
				printf("%d %d\n", u, v);
			}
		} 
		
        printf("\n");
	}
	return 0;
}