BZOJ2561 最小生成树【最小割】

题目

　给定一个边带正权的连通无向图G=(V,E)，其中N=|V|，M=|E|，N个点从1到N依次编号，给定三个正整数u，v，和L (u≠v)，假设现在加入一条边权为L的边(u,v)，那么需要删掉最少多少条边，才能够使得这条边既可能出现在最小生成树上，也可能出现在最大生成树上？

输入格式

    第一行包含用空格隔开的两个整数，分别为N和M；

　　接下来M行，每行包含三个正整数u，v和w表示图G存在一条边权为w的边(u,v)。

　　最后一行包含用空格隔开的三个整数，分别为u，v，和 L；

　　数据保证图中没有自环。

输出格式

　输出一行一个整数表示最少需要删掉的边的数量。

输入样例

3 2

3 2 1

1 2 3

1 2 2

输出样例

提示

对于20%的数据满足N ≤ 10，M ≤ 20，L ≤ 20；

　　对于50%的数据满足N ≤ 300，M ≤ 3000，L ≤ 200；

　　对于100%的数据满足N ≤ 20000，M ≤ 200000，L ≤ 20000。

题解

跪了QAQ怎么想得到是网络流，如此之大的范围

我们首先思考一下想要该边加入最小生成树，那么要使得加入这条边时u，v不连通

想想最小生成树的kruskal算法，在长度L之前如果存在一条路径使得u，v联通，那么轮到L时必定无法加入最小生成树

所以我们单独抽出所有权值<L的边，删减若干边使得u，v不连通

这就用到了最小割

最大生成树类似

可以证明，时间复杂度是$O(M^{1.5})$

#include<iostream>

#include<cstdio>

#include<cmath>

#include<queue>

#include<cstring>

#include<algorithm>

#define LL long long int

#define Redge(u) for (int k = h[u],to; k; k = ed[k].nxt)

#define REP(i,n) for (int i = 1; i <= (n); i++)

#define BUG(s,n) for (int i = 1; i <= (n); i++) cout<<s[i]<<' '; puts("");

using namespace std;

const int maxn = 20005,maxm = 1000005,INF = 1000000000;

inline int read(){

	int out = 0,flag = 1; char c = getchar();

	while (c < 48 || c > 57){if (c == '-') flag = -1; c = getchar();}

	while (c >= 48 && c <= 57){out = (out << 3) + (out << 1) + c - 48; c = getchar();}

	return out * flag;

}

int n,m;

struct EDGE{int to,nxt,f;};

struct node{int a,b,w;}e[maxm];

struct FLOW{

	EDGE ed[maxm];

	int h[maxn],ne,S,T,vis[maxn],d[maxn],cur[maxn];

	void init(){memset(h,0,sizeof(h)); ne = 2;}

	void build(int u,int v,int w){

		ed[ne] = (EDGE){v,h[u],w}; h[u] = ne++;

		ed[ne] = (EDGE){u,h[v],0}; h[v] = ne++;

	}

	bool bfs(){

		for (int i = 1; i <= n; i++) d[i] = INF,vis[i] = false;

		queue<int> q;

		q.push(S); d[S] = 0; vis[S] = true;

		int u;

		while (!q.empty()){

			u = q.front(); q.pop();

			Redge(u) if (ed[k].f && !vis[to = ed[k].to]){

				d[to] = d[u] + 1; vis[to] = true;

				q.push(to);

			}

		}

		return vis[T];

	}

	int dfs(int u,int minf){

		if (u == T || !minf) return minf;

		int f,flow = 0,to;

		if (cur[u] == -1) cur[u] = h[u];

		for (int& k = cur[u]; k; k = ed[k].nxt)

			if (d[to = ed[k].to] == d[u] + 1 && (f = dfs(to,min(minf,ed[k].f)))){

				ed[k].f -= f; ed[k ^ 1].f += f;

				flow += f; minf -= f;

				if (!minf) break;

			}

		return flow;

	}

	int maxflow(){

		int flow = 0;

		while (bfs()){

			memset(cur,-1,sizeof(cur));

			flow += dfs(S,INF);

		}

		return flow;

	}

}G;

int main(){

	n = read(); m = read();

	for (int i = 1; i <= m; i++)

		e[i].a = read(),e[i].b = read(),e[i].w = read();

	G.init();

	G.S = read(); G.T = read();

	int ans = 0,L = read();

	for (int i = 1; i <= m; i++)

		if (e[i].w < L){

			G.build(e[i].a,e[i].b,1);

			G.build(e[i].b,e[i].a,1);

		}

	ans += G.maxflow();

	G.init();

	for (int i = 1; i <= m; i++)

		if (e[i].w > L){

			G.build(e[i].a,e[i].b,1);

			G.build(e[i].b,e[i].a,1);

		}

	ans += G.maxflow();

	printf("%d\n",ans);

	return 0;

}