[BZOJ 1797][BZOJ 3258]最小割的唯一性判定

问题一：是否存在一个最小代价路径切断方案，其中该道路被切断？ 问题二：是否对任何一个最小代价路径切断方案，都有该道路被切断？ 现在请你回答这两个问题。

最小割唯一性判定

jcvb:

在残余网络上跑tarjan求出所有SCC，记id[u]为点u所在SCC的编号。显然有id[s]!=id[t]（否则s到t有通路，能继续增广）。

①对于任意一条满流边(u,v)，(u,v)能够出现在某个最小割集中，当且仅当id[u]!=id[v]；
②对于任意一条满流边(u,v)，(u,v)必定出现在最小割集中，当且仅当id[u]==id[s]且id[v]==id[t]。

①

<==将每个SCC缩成一个点，得到的新图就只含有满流边了。那么新图的任一s-t割都对应原图的某个最小割，从中任取一个把id[u]和id[v]割开的割即可证明。

②
<==：假设将(u,v)的边权增大，那么残余网络中会出现s->u->v->t的通路，从而能继续增广，于是最大流流量（也就是最小割容量）会增大。这即说明(u,v)是最小割集中必须出现的边。

#include 
#include 
#include 
#include 
#include 
#include 
#define maxn 200000
using namespace std;

const int inf = 0x7fffffff;

struct Edge{
	int to, next, w;
}edge[maxn];

int from[maxn], to[maxn];

int h[maxn], cnt = 1;

void add(int u, int v, int w){
	cnt ++;
	edge[cnt].to = v;
	edge[cnt].next = h[u];
	edge[cnt].w = w;
	h[u] = cnt;
	swap(u, v);w = 0;
	cnt ++;
	edge[cnt].to = v;
	edge[cnt].next = h[u];
	edge[cnt].w = w;
	h[u] = cnt;
}

int n, m, S, T;

queueQ;

int d[4010];

bool BFS(){
	Q.push(S);
	memset(d, -1, sizeof d);
	d[S] = 0;
	while(!Q.empty()){
		int u = Q.front();Q.pop();
		for(int i = h[u]; i; i = edge[i].next){
			if(!edge[i].w)continue;
			int v = edge[i].to;
			if(d[v] == -1){
				d[v] = d[u] + 1;
				Q.push(v);
			}
		}
	}return d[T] != -1;
}

int DFS(int x, int a){
	if(a == 0 || x == T)return a;
	int used = 0, f;
	for(int i = h[x]; i; i = edge[i].next){
		int v = edge[i].to;
		if(d[v] == d[x] + 1){
			f = DFS(v, min(edge[i].w, a - used));
			edge[i].w -= f;
			edge[i ^ 1].w += f;
			used += f;
			if(used == a)return used;
		}
	}
	if(!used)d[x] = -1;
	return used;
}

void Dinic(){
	int ans = 0;
	while(BFS())
		ans += DFS(S, inf);
}

int low[maxn], pre[maxn], dfs_clock, sccno[maxn], scc_cnt;

stacks;

void Tarjan(int u){
	low[u] = pre[u] = ++ dfs_clock;
	s.push(u);
	for(int i = h[u]; i; i = edge[i].next){
		if(!edge[i].w)continue;
		int v = edge[i].to;
		if(!pre[v])Tarjan(v), low[u] = min(low[u], low[v]);
		else if(!sccno[v])low[u] = min(low[u], pre[v]);
	}
	if(low[u] == pre[u]){
		++ scc_cnt;
		for(;;){
			int v = s.top();s.pop();
			sccno[v] = scc_cnt;
			if(v == u)break;
		}
	}
}

int main(){
    freopen("mincut.in" ,"r",stdin );
	freopen("mincut.out","w",stdout);
	scanf("%d%d%d%d", &n, &m, &S, &T);
	int w;
	for(int i = 1; i <= m; i ++){
		scanf("%d%d%d", &from[i], &to[i], &w);
		add(from[i], to[i], w);
	}
	Dinic();
	for(int i = 1; i <= n; i ++)
	    if(!pre[i])Tarjan(i);
	for(int i = 1; i <= m; i ++){
		int u = from[i], v = to[i];
		if(edge[i << 1].w){
			printf("0 0\n");
			continue;
		}
		if(sccno[u] == sccno[v])
		    printf("0 0\n");
		else if(sccno[u] == sccno[S] && sccno[v] == sccno[T])
		    printf("1 1\n");
		else printf("1 0\n");
	}
	return 0;
}

3258: 秘密任务
Description


Alice听说在一片神奇的大陆MagicLand，有一个古老的传说…… 
 很久很久以前，那个时候 MagicStates共和国刚刚成立。 反对新政府的势力虽已被镇压，但仍然在暗地活动。这一次，情报局得到了一个令人震惊的消息，被软禁在首都府邸中的Frank ——著名的反对派领袖，秘密逃出首都，去往反对派的大本营。根据相关的情报，Frank计划通过城市之间 发达的高速公路，经过最短的路程抵达目的地。不妨将 MagicStates共和国简化为由N个城市,M条高速公路构成的连通的无向图，首都为城市1，反对派的大本营为城市N。 
每条高速公路连接两个不同的城市，且路程是已知的。而Frank选择了一条从城市1到城市N的最短路径作为他的逃跑路线。为了阻止Frank，共和国总统决定在某些城市的高速公路的出入口设立检查 点，在Frank经过检查点时将他逮捕。 
举例来说，如果有一条高速公路连接城市u和城市v，在这条公路的城市u或城市v的出入口设立检查点，那么Frank经过高速公路时就会被发现。特别的是，由于城市N实际上处在反对派的控制下，所以不能在城市N设立检查点。


然而在任何城市设立检查点都需要一定的费用。更具体的，若在城市 u设立k个检查点，就要花费 Au乘以k的代价，其中Au是城市u的相关参数。值得注意的是，这个代价与这k个检查点具体设在哪些公路的出入口无关,于是，总统责令情报局拟定一个方案，花费最小的代价使得无论Frank选择哪条最短路线，都会在（除城市N以外）某个城市的高速公路出入口被发现。读到这里，Alice很想知道阻止Frank所需要花费的最小代价，并且她还希 望知道最优方案是否是唯一的。只好再请你帮助她了。 
注意，我们称两个方案不同当且仅当存在某城市k，两种方案中在城市 k的检查点的设置（而不仅是数目）是不同的。 
注意，输入文件包含多组测试数据。

BZOJ3258秘密任务

最小割唯一性判定

这才是真正的最小割唯一性判定

注意一个二元组不能随便建。

要解方程。

此题要拆边，对应两条边两个点的属性

不要任性T^T

#include 
#include 
#include 
#include 
#include 
#include 
#define maxn 10010
using namespace std;

typedef long long ll;

int n, m, S, T, size;
struct Edge{int to, next, w;}edge[100010];

int h[maxn], cnt, val[maxn], fr[100010], to[100010], C;
void add(int u, int v, int w){
	C ++, fr[C] = u, to[C] = v;
	cnt ++;
	edge[cnt].to = v;
	edge[cnt].next = h[u];
	edge[cnt].w = w;
	h[u] = cnt;
	swap(u, v);w = 0;
	cnt ++;
	edge[cnt].to = v;
	edge[cnt].next = h[u];
	edge[cnt].w = w;
	h[u] = cnt;
}
queueQ;
namespace spfa{
	struct Edge_{int to, next, dis;}G[100010];
	int cnt, h[maxn];
	ll dis[maxn], disT[maxn];
	bool vis[maxn];
	void addG(int u, int v, int d){
		cnt ++;
		G[cnt].to = v;
		G[cnt].next = h[u];
		G[cnt].dis = d;
		h[u] = cnt;
	}
	void work(){
		cnt = 0;
		memset(h, 0, sizeof h);
		int u, v, d;
		for(int i = 1; i <= m; i ++){
			scanf("%d%d%d", &u, &v, &d);
			addG(u, v, d);
			addG(v, u, d);
		}
		memset(dis, 0x7f, sizeof dis);
		memset(vis, 0, sizeof vis);
		dis[S] = 0;Q.push(S);
		while(!Q.empty()){
			int u = Q.front();Q.pop();
			for(int i = h[u]; i; i = G[i].next){
				int v = G[i].to;
				if(dis[v] > dis[u] + G[i].dis){
					dis[v] = dis[u] + G[i].dis;
					if(!vis[v])vis[v] = true, Q.push(v);
				}
			}
			vis[u] = false;
		}
		memset(disT, 0x7f, sizeof disT);
		memset(vis, 0, sizeof vis);
		disT[T] = 0;Q.push(T);
		while(!Q.empty()){
			int u = Q.front();Q.pop();
			for(int i = h[u]; i; i = G[i].next){
				int v = G[i].to;
				if(disT[v] > disT[u] + G[i].dis){
					disT[v] = disT[u] + G[i].dis;
					if(!vis[v])vis[v] = true, Q.push(v);
				}
			}
			vis[u] = false;
		}
		size = n;
		for(int i = 1; i < n; i ++)
			for(int j = h[i]; j; j = G[j].next){
				int v = G[j].to;
				if(dis[T] == dis[i] + G[j].dis + disT[v]){
					++ size;
					add(i, size, val[i]);
					add(size, v, val[v]);
					//add(i, v, min(val[i], val[v]));
				}
		}
	}
}

const int inf = 0x7fffffff;

int d[maxn];
bool BFS(){
	memset(d, -1, sizeof d);
	d[S] = 0;
	Q.push(S);
	while(!Q.empty()){
		int u = Q.front();Q.pop();
		for(int i = h[u]; i; i = edge[i].next){
			if(!edge[i].w)continue;
			int v = edge[i].to;
			if(d[v] == -1){
				d[v] = d[u] + 1;
				Q.push(v);
			}
		}
	}return d[T] != -1;
}

ll DFS(int x, ll a){
	if(a == 0 || x == T)return a;
	ll used = 0, f;
	for(int i = h[x]; i; i = edge[i].next){
		int v = edge[i].to;
		if(d[v] == d[x] + 1){
			f = DFS(v, min(a - used, (ll)edge[i].w));
			edge[i].w -= f;
			edge[i ^ 1].w += f;
			used += f;
			if(used == a)return used;
		}
	}
	if(!used)d[x] = -1;
	return used;
}

ll Dinic(){
	ll ans = 0;
	while(BFS())
		ans += DFS(S, inf);
	return ans;
}

int sccno[maxn], pre[maxn], low[maxn], dfs_clock, scc_cnt;
stacks;
void Tarjan(int u){
	pre[u] = low[u] = ++ dfs_clock;
	s.push(u);
	for(int i = h[u]; i; i = edge[i].next){
		if(!edge[i].w)continue;
		int v = edge[i].to;
		if(!pre[v])Tarjan(v), low[u] = min(low[u], low[v]);
		else if(!sccno[v])low[u] = min(low[u], pre[v]);
	}
	if(low[u] == pre[u]){
		++ scc_cnt;
		for(;;){
			int v = s.top();s.pop();
			sccno[v] = scc_cnt;
			if(v == u)break;
		}
	}
}

int main(){
	//freopen("secret.in", "r", stdin);
	//freopen("secret.out", "w", stdout);
	int test;
	scanf("%d", &test);
	while(test --){
		C = 0;
		scanf("%d%d", &n, &m);
		for(int i = 1; i < n; i ++)
			scanf("%d", &val[i]);
		val[n] = 0x7fffffff;
		memset(h, 0, sizeof h);
  		cnt = 1;
		S = 1, T = n;
		spfa::work();
		ll ans = Dinic();
		
		memset(pre, 0, sizeof pre);
		memset(low, 0, sizeof low);
		memset(sccno, 0, sizeof sccno);
		scc_cnt = dfs_clock = 0;

		for(int i = 1; i <= size; i ++)
		    if(!pre[i])Tarjan(i);
	    for(int i = 1; i <= C; i ++){
			int u = fr[i], v = to[i];
			if(edge[i << 1].w || sccno[u] == sccno[v])continue;
			if(sccno[u] == sccno[S] && sccno[v] == sccno[T])
			    continue;
			printf("No %lld\n", ans);
			goto Mark;
	   }
	   printf("Yes %lld\n", ans);
	   Mark:;
	}

	return 0;
}

重点是看S和T是否联通

我们的思想是Tarjan找桥边。

如果存在可能不是最小割上的边

那么就不唯一。