【ybt金牌导航3-3-5】【ZOJ 2587】唯一切边 / Unique Attack

唯一切边 / Unique Attack

题目链接：ybt金牌导航3-3-5 / ZOJ 2587

题目大意

给你一个带权无向图，你边权是删去它的费用。
问你是否有多种方案，使得你可以用最少的费用使 a,b 两点不连通。

思路

首先看到它删去最小费用使得两点不连通，自然想到网络流的最小割。

那最小费用就求出来了，那接着问题就是跑的是否有多重方案。
你考虑分割出来的两个集合。（就是从源点开始跑还没有流满的边，跑到的点就属于一个集合）
那我们一般是求出一个集合然后剩下的是另外一个集合。

但我们这次就从源点跑以外，还从汇点开始找反向边没有流满的边跑。
然后两个操作跑到的就是两个集合，但是你会发现它不一定覆盖完所有的点。
那是什么情况呢？

比如这样，$4$ 是不属于这两个集合的其中一个的。

为什么呢，因为从 $3$ 到 $4$ 的路流满了，从 $4$ 到 $2$ 的路也流满了。
那也就说，这个地方你可以选 $3\to 4$ 作为割边，也可以选 $4\to 2$。

那就说明有多重分隔方法。
那就根据这个判断就好了。

代码

#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;

struct node {
	int x, to, nxt, op;
}e[200001];
int n, m, S, T, x, y, z;
int le[1001], lee[1001];
int dis[1001], KK, in[1001];
queue <int> q;

void csh() {
	KK = 0;
	memset(le, 0, sizeof(le));
	memset(in, 0, sizeof(in));
}

void add(int x, int y, int z) {
	e[++KK] = (node){z, y, le[x], KK + 1}; le[x] = KK;
	e[++KK] = (node){0, x, le[y], KK - 1}; le[y] = KK;
}

bool bfs() {
	for (int i = 1; i <= n; i++) {
		dis[i] = -1;
		lee[i] = le[i];
	}
	while (!q.empty()) q.pop();
	
	q.push(S);
	dis[S] = 0;
	while (!q.empty()) {
		int now = q.front();
		q.pop();
		
		for (int i = le[now]; i; i = e[i].nxt)
			if (e[i].x > 0 && dis[e[i].to] == -1) {
				dis[e[i].to] = dis[now] + 1;
				if (e[i].to == T) return 1;
				q.push(e[i].to);
			}
	}
	
	return 0;
}

int dfs(int now, int sum) {
	if (now == T) return sum;
	
	int go = 0;
	for (int &i = lee[now]; i; i = e[i].nxt)
		if (e[i].x > 0 && dis[e[i].to] == dis[now] + 1) {
			int this_go = dfs(e[i].to, min(sum - go, e[i].x));
			if (this_go) {
				e[i].x -= this_go;
				e[e[i].op].x += this_go;
				go += this_go;
				if (go == sum) return go;
			}
		}
	
	if (go < sum) dis[now] = -1;
	return go;
}

int dinic() {
	int re = 0;
	while (bfs())
		re += dfs(S, INF);
	return re;
}

void dfs_cut(int now, int op) {
	in[now] = op;
	
	for (int i = le[now]; i; i = e[i].nxt) {
		if (op == 1) {//如果是从 S 出发跑就是找正向没有跑满的边走
			if (e[i].x && !in[e[i].to]) dfs_cut(e[i].to, op);
		}
		else {//如果是从 T 出发还是找要原来的方向的边，所以要看其 op 边没有跑满的走
			if (e[e[i].op].x && !in[e[i].to]) dfs_cut(e[i].to, op);
		}
	}
}

int main() {
	scanf("%d %d %d %d", &n, &m, &S, &T);
	while (n && m && S && T) {
		csh();
		
		for (int i = 1; i <= m; i++) {
			scanf("%d %d %d", &x, &y, &z);
			add(x, y, z);
			add(y, x, z);
		}
		
		dinic();
		
		dfs_cut(S, 1);//从 S 出发跑
		dfs_cut(T, 2);//从 T 出发跑
		
		bool no = 0;
		for (int i = 1; i <= n; i++)
			if (!in[i]) {
				no = 1;
				break;
			}
		if (no) printf("AMBIGUOUS\n");
			else printf("UNIQUE\n");
		
		scanf("%d %d %d %d", &n, &m, &S, &T);
	}
	
	return 0;
}