「网络流浅谈」最小割的模型

于 2024-05-28 09:21:35 发布
阅读量965 收藏 24
点赞数 44
分类专栏： 网络流 文章标签： 算法 c++ 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66946161/article/details/139253674
版权

更好的阅读体验

最大权闭合子图

引入 Introduction

闭合子图指对于子图 G = ( V , E ) G=(V,E) G=(V,E)， ∀ u ∈ V , ( u , v ) ∈ E \forall u \in V, (u,v)\in E ∀u∈V,(u,v)∈E，都有 v ∈ V v\in V v∈V。

最大权闭合子图无非就是对于所有的闭合子图 G G G 中 ∑ u ∈ V w u \sum_{u\in V} w_u ∑u∈V​wu​ 最大的闭合子图。

对于这个图中，闭合子图有哪些呢？

红色框圈画出的即为 1 1 1 个闭合子图，因为对于任意一个点所连向的点都在该子图内。

主算法 Main Algorithm

不难发现任意一个割所划分成的 2 2 2 个集合均为闭合子图，而我们要求最大权闭合子图，故考虑如何求解。

建立一个流网络，将源点向所有权值为正的点连一条长度为该点权值的边，将所有权值为负数的点向汇点连一条长度为该点权值的绝对值的边。对于原图中的边，在流网络中均为 + ∞ +\infty +∞。

对于割 [ S , T ] [S,T] [S,T]， c ( S , T ) = ∑ ( u , v ) ∈ E , u ∈ S , v ∈ T c ( u , v ) c(S,T)=\sum_{(u,v)\in E,u\in S,v\in T}c(u,v) c(S,T)=∑(u,v)∈E,u∈S,v∈T​c(u,v)，由于中间的边权均为 + ∞ +\infty +∞，所以只会割两边的边，即 c ( S , T ) = ∑ ( s , v ) ∈ E , v ∈ T c ( s , v ) + ∑ ( u , t ) ∈ E , u ∈ S c ( u , t ) c(S,T)=\sum_{(s,v)\in E,v\in T}c(s,v)+\sum_{(u,t)\in E,u\in S}c(u,t) c(S,T)=∑(s,v)∈E,v∈T​c(s,v)+∑(u,t)∈E,u∈S​c(u,t)。

又因为建图的时候 s s s 所连向的边，均为连向点的边权；而连向 t t t 的边的边权均为连向他点的权值。故， c ( S , T ) = ∑ ( s , v ) ∈ E , v ∈ T c ( s , v ) + ∑ ( u , t ) ∈ E , u ∈ S c ( u , t ) = ∑ ( s , v ) ∈ E , v ∈ T w v − ∑ ( u , t ) ∈ E , u ∈ S w u c(S,T)=\sum_{(s,v)\in E,v\in T}c(s,v)+\sum_{(u,t)\in E,u\in S}c(u,t)=\sum_{(s,v)\in E,v\in T}w_v-\sum_{(u,t)\in E,u\in S}w_u c(S,T)=∑(s,v)∈E,v∈T​c(s,v)+∑(u,t)∈E,u∈S​c(u,t)=∑(s,v)∈E,v∈T​wv​−∑(u,t)∈E,u∈S​wu​

考虑最大权闭合子图的权值为什么？ v a l = ∑ ( s , v ) ∈ E , v ∈ S w v + ∑ ( u , t ) ∈ E , u ∈ S w u val=\sum_{(s,v)\in E,v\in S}w_v+\sum_{(u,t)\in E,u\in S}w_u val=∑(s,v)∈E,v∈S​wv​+∑(u,t)∈E,u∈S​wu​。

不难发现第二项是完全一样的：所以将 c ( S , T ) c(S,T) c(S,T) 与 v a l val val 相加得， c ( S , T ) + v a l = ∑ ( s , v ) ∈ E , v ∈ T w v + ∑ ( s , v ) ∈ E , v ∈ S w v c(S,T)+val=\sum_{(s,v)\in E,v\in T}w_v+\sum_{(s,v)\in E,v\in S}w_v c(S,T)+val=∑(s,v)∈E,v∈T​wv​+∑(s,v)∈E,v∈S​wv​

由于 S S S 与 T T T 共同构成了点集 V V V，故 ∑ ( s , v ) ∈ E , v ∈ T w v + ∑ ( s , v ) ∈ E , v ∈ S w v = ∑ ( s , v ) ∈ E w v = ∑ w v > 0 w v \sum_{(s,v)\in E,v\in T}w_v+\sum_{(s,v)\in E,v\in S}w_v=\sum_{(s,v)\in E}w_v=\sum_{w_v>0}w_v ∑(s,v)∈E,v∈T​wv​+∑(s,v)∈E,v∈S​wv​=∑(s,v)∈E​wv​=∑wv​>0​wv​

综上所述， v a l = ∑ w v > 0 w v − c ( S , T ) val=\sum_{w_v>0}w_v-c(S,T) val=∑wv​>0​wv​−c(S,T)，通过数学知识推理得 c ( S , T ) c(S,T) c(S,T) 应最小，即求最小割。

P4174 [NOI2006] 最大获利

模版题，按照上述做法建图即可。

#include <bits/stdc++.h>
#define fi first
#define se second
#define int long long

using namespace std;

typedef pair<int, int> PII;
typedef long long LL;

const int N = 6e4 + 10, M = 4e5 + 10, INF = 1e18;

int n, m, s, t;
int a[N], b[N];
int h[N], e[M], ne[M], f[M], idx;
int dist[N], cur[N];

void add(int a, int b, int c) {
	e[idx] = b, ne[idx] = h[a], f[idx] = c, h[a] = idx ++;
	e[idx] = a, ne[idx] = h[b], f[idx] = 0, h[b] = idx ++;
}
bool bfs() {
	memset(dist, -1, sizeof dist);
	queue<int> q;
	q.emplace(s), dist[s] = 0, cur[s] = h[s];
	while (q.size()) {
		auto u = q.front();
		q.pop();

		for (int i = h[u]; ~i; i = ne[i]) {
			int v = e[i];
			if (dist[v] == -1 && f[i]) {
				dist[v] = dist[u] + 1, cur[v] = h[v];
				if (v == t) return 1;
				q.emplace(v);
			}
		}
	}
	return 0;
}
int find(int u, int lim) {
	if (u == t) return lim;

	int flow = 0;
	for (int i = cur[u]; ~i && flow < lim; i = ne[i]) {
		cur[u] = i;
		int v = e[i];
		if (dist[v] == dist[u] + 1 && f[i]) {
			int tmp = find(v, min(f[i], lim - flow));
			if (!tmp) dist[v] = -1;
			flow += tmp, f[i] -= tmp, f[i ^ 1] += tmp;
		}
	}

	return flow;
}
int dinic() {
	int res = 0, flow;
	while (bfs()) while (flow = find(s, INF)) res += flow;
	return res;
}

signed main() {
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	cin >> n >> m;
	memset(h, -1, sizeof h);

	s = 0, t = n + m + 1;
	for (int i = 1; i <= n; i ++)
		cin >> a[i];
	for (int i = 1; i <= m; i ++) {
		int u, v;
		cin >> u >> v >> b[i];
		add(i + n, u, INF), add(i + n, v, INF);
	}

	int tot = 0;
	for (int i = 1; i <= m; i ++)
		add(s, i + n, b[i]), tot += b[i];
	for (int i = 1; i <= n; i ++)
		add(i, t, a[i]);

	cout << tot - dinic() << endl;

	return 0;
}

最大密度子图

引入 Introduction

定义无向图 G = ( V , E ) G=(V,E) G=(V,E) 的密度为 ∣ E ∣ ∣ V ∣ \frac{|E|}{|V|} ∣V∣∣E∣​。则，对于一个无向图 G = ( V , E ) G=(V,E) G=(V,E)，令 G G G 的子图 G ′ = ( V ′ , E ′ ) G'=(V',E') G′=(V′,E′)，满足 ∀ ( u , v ) ∈ E ′ , u ∈ V ′ , v ∈ V ′ \forall (u,v)\in E', u\in V',v\in V' ∀(u,v)∈E′,u∈V′,v∈V′。对于所有满足条件的子图 G G G 中，密度最大的即为最大密度子图。

主算法 Main Algorithm

对于形式 ∣ E ∣ ∣ V ∣ \frac{|E|}{|V|} ∣V∣∣E∣​，不难想到通过分数规划求解，即二分 g g g，如果 ∣ E ∣ ∣ V ∣ ≥ g \frac{|E|}{|V|}\ge g ∣V∣∣E∣​≥g，则说明 g g g 还可以更大，调整二分左端点；反之，调整二分右端点。

将式子继续化简可以得到： ∣ E ∣ − g ∣ V ∣ ≥ 0 |E|-g|V|\ge 0 ∣E∣−g∣V∣≥0，也就是求 ∣ E ∣ − g ∣ V ∣ |E|-g|V| ∣E∣−g∣V∣ 的最大值，即 g ∣ V ∣ − ∣ E ∣ g|V|-|E| g∣V∣−∣E∣ 的最小值。

最小割是可以解决点集的，但是难以算出边数的多少。所以，考虑如何将边数加入割。

考虑红色圈出的子图，如何计算边数呢？可以考虑使用度数，某个点度数减去该点连向集合外部的边的个数再除 2 2 2，即可得到集合内边的个数，即 ∑ u ∈ V d u − c ( V , V ˉ ) 2 \frac{\sum_{u\in V}d_u-c(V,\bar V)}{2} 2∑u∈V​du​−c(V,Vˉ)​。这样，就与割产生了关系。

继续推式子： g ∣ V ∣ − ∣ E ∣ = ∑ u ∈ V g − ∑ u ∈ V d u − c ( V , V ˉ ) 2 = ∑ u ∈ V ( g − d u 2 ) + c ( V , V ˉ ) 2 g|V|-|E|=\sum_{u\in V}g-\frac{\sum_{u\in V}d_u-c(V,\bar V)}{2}=\sum_{u\in V}(g-\frac{d_u}{2})+\frac{c(V,\bar V)}{2} g∣V∣−∣E∣=∑u∈V​g−2∑u∈V​du​−c(V,Vˉ)​=∑u∈V​(g−2du​​)+2c(V,Vˉ)​

为了使与最小割有单调关系，将割 c ( V , V ˉ ) c(V,\bar V) c(V,Vˉ) 的系数提出得 ∑ u ∈ V ( 2 g − d u ) + c ( V , V ˉ ) 2 \frac{\sum_{u\in V}(2g-d_u)+c(V,\bar V)}{2} 2∑u∈V​(2g−du​)+c(V,Vˉ)​

那么，就可以建图了。对于任意一个点 u u u 均向汇点 t t t 连一条边权为 2 g − d u 2g-d_u 2g−du​ 的边，不过由于 2 g − d u 2g-d_u 2g−du​ 可能会小于 0 0 0，所以边权应为 2 g − d u + U 2g-d_u+U 2g−du​+U，其中 U U U 为常数。对于点之间的边，即为原图的边，为了算边数所以边权均为 1 1 1。源点 s s s 向任意一个点连一条边权为 U U U 的边即可。 U U U 取 ∣ E ∣ |E| ∣E∣ 即可，因为 d u d_u du​ 不可能超过 ∣ E ∣ |E| ∣E∣。下图为一个例子。

建完图后，由于部分边权多加了 U U U，所以考虑新图最小割 c ′ ( S , T ) c'(S,T) c′(S,T) 与 ∣ E ∣ − g ∣ V ∣ |E|-g|V| ∣E∣−g∣V∣ 的关系。令 P = S − { s } , P ′ = P ˉ − { t } P=S-\{s\},P'=\bar P - \{t\} P=S−{s},P′=Pˉ−{t}，则最小割的边集分为 4 4 4 种情况： P → { t } , { s } → P ′ , P → P ′ , { s } → { t } P\rightarrow \{t\},\{s\}\rightarrow P',P\rightarrow P',\{s\}\rightarrow \{t\} P→{t},{s}→P′,P→P′,{s}→{t}。不过，最后一种边不存在舍去。
c ′ ( S , T ) = ∑ u ∈ P ( U + 2 g − d u ) + ∑ v ∈ P ′ U + ∑ u ∈ P ∑ v ∈ P ′ c ( u , v ) = ∑ u ∈ P ( U + 2 g − d u + ∑ v ∈ P ′ c ( u , v ) ) + ∑ v ∈ P ′ U = ∑ u ∈ P ( U + 2 g − ( d u − ∑ v ∈ P ′ c ( u , v ) ) ) + ∑ v ∈ P ′ U = ∑ u ∈ P ( U + 2 g − ∑ v ∈ P c ( u , v ) ) + ∑ v ∈ P ′ U ← u  所有出边 − 向集合外边 = 向集合内边 = ∑ u ∈ P 2 g − ∑ u ∈ P ∑ v ∈ P c ( u , v ) + ∑ v ∈ P ′ U + ∑ v ∈ P U = ∣ P ∣ 2 g + 2 ∣ E ∣ + U ⋅ n \begin{aligned} c'(S,T)=&\sum_{u\in P} (U+2g-d_u)+\sum_{v\in P'}U+\sum_{u\in P}\sum_{v\in P'}c(u,v)\\ =&\sum_{u\in P}(U+2g-d_u+\sum_{v\in P'}c(u,v))+\sum_{v\in P'}U\\ =&\sum_{u\in P}(U+2g-(d_u-\sum_{v\in P'}c(u,v)))+\sum_{v\in P'}U\\ =&\sum_{u\in P}(U+2g-\sum_{v\in P}c(u,v))+\sum_{v\in P'}U\leftarrow u\ 所有出边-向集合外边=向集合内边\\ =&\sum_{u\in P}2g-\sum_{u\in P}\sum_{v\in P}c(u,v)+\sum_{v\in P'}U+\sum_{v\in P}U\\ =&|P|2g+ 2|E|+U\cdot n\\ \end{aligned} c′(S,T)======​u∈P∑​(U+2g−du​)+v∈P′∑​U+u∈P∑​v∈P′∑​c(u,v)u∈P∑​(U+2g−du​+v∈P′∑​c(u,v))+v∈P′∑​Uu∈P∑​(U+2g−(du​−v∈P′∑​c(u,v)))+v∈P′∑​Uu∈P∑​(U+2g−v∈P∑​c(u,v))+v∈P′∑​U←u 所有出边−向集合外边=向集合内边u∈P∑​2g−u∈P∑​v∈P∑​c(u,v)+v∈P′∑​U+v∈P∑​U∣P∣2g+2∣E∣+U⋅n​
故， ∣ E ∣ − g ∣ V ∣ = U ⋅ n − c ′ ( S , T ) 2 |E|-g|V|=\frac{U\cdot n-c'(S,T)}{2} ∣E∣−g∣V∣=2U⋅n−c′(S,T)​，这里 V V V 与 P P P 等价，都是我们选出的点。到此，该问题得以解决。

POJ3155 - Hard Life

模版题，使用上述做法建图计算即可。

对于输出方案，选择的集合其实就是最小割中 S S S 集合，那么怎么找出呢？只需要从 s s s 每次走 > 0 >0 >0 的边所能到达的点的集合，便是答案（注意：不能包含 s s s）。

#include <bits/stdc++.h>
#define fi first
#define se second
#define int long long

using namespace std;

typedef pair<int, int> PII;
typedef long long LL;

const int N = 1e2 + 10, M = 3e3 + 10;
const double eps = 1e-6;

int n, m, s, t;
int h[N], e[M], ne[M], idx;
double f[M];
int d[N], cur[N], dg[N], st[N];
vector<int> res;
std::vector<PII> E;

void add(int a, int b, double c1, double c2) {
	e[idx] = b, ne[idx] = h[a], f[idx] = c1, h[a] = idx ++;
	e[idx] = a, ne[idx] = h[b], f[idx] = c2, h[b] = idx ++;
}
bool bfs() {
	memset(d, -1, sizeof d);
	queue<int> q;
	q.emplace(s), d[s] = 0, cur[s] = h[s];
	while (q.size()) {
		int u = q.front();
		q.pop();

		for (int i = h[u]; ~i; i = ne[i]) {
			int v = e[i];
			if (d[v] == -1 && f[i] > 0) {
				d[v] = d[u] + 1, cur[v] = h[v];
				if (v == t) return 1;
				q.emplace(v);
			}
		}
	}
	return 0;
}
double find(int u, double lim) {
	if (u == t) return lim;

	double flow = 0;
	for (int i = cur[u]; ~i && flow < lim; i = ne[i]) {
		cur[u] = i;
		int v = e[i];
		if (d[v] == d[u] + 1 && f[i] > 0) {
			double tmp = find(v, min(lim - flow, f[i]));
			if (tmp <= 0) d[v] = -1;
			f[i] -= tmp, f[i ^ 1] += tmp, flow += tmp;
		}
	}

	return flow;
}
void build(double g) {
	memset(h, -1, sizeof h);
	idx = 0;
	for (auto v : E) add(v.fi, v.se, 1, 1);
	for (int i = 1; i <= n; i ++) add(s, i, m, 0);
	for (int i = 1; i <= n; i ++) add(i, t, 2.0 * g - dg[i] + m, 0);
}
bool dinic(double g) {
	build(g);
	double res = 0, flow;
	while (bfs()) while (flow = find(s, 1e18)) res += flow;
	return res < m * n * 1.0;
}
void dfs(int u) {
	if (u != s) res.emplace_back(u);
	st[u] = 1;
	for (int i = h[u]; ~i; i = ne[i]) {
		int v = e[i];
		if (!st[v] && f[i] > 0) dfs(v);
	}
}

signed main() {
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	cin >> n >> m;

	s = 0, t = n + 1;
	for (int i = 1; i <= m; i ++) {
		int u, v;
		cin >> u >> v;
		E.emplace_back(u, v), dg[u] ++, dg[v] ++;
	}

	double l = 0, r = m;
	while (r - l > eps) {
		double mid = (l + r) * 0.5;
		if (dinic(mid)) l = mid;
		else r = mid;
	}

	dinic(l), dfs(s);
	if (!res.size()) {
		cout << "1\n1";
		return 0;
	}
	cout << res.size() << endl;
	sort(res.begin(), res.end());
	for (auto v : res)
		cout << v << endl;
	cout << endl;

	return 0;
}

最小权点覆盖集

引入 Introduction

点覆盖集指选择点集 V V V，使得对于边集 E E E 中的每一条边，至少有一个端点在点集 V V V 中。

最小权点覆盖集指在所有点覆盖集中，点的权值和最小的点集。

主算法 Main Algorithm

最小权点覆盖集只有在二分图的情况下才存在高效解，否则为 NPC 问题。

考虑如何将点覆盖集与割建立联系。对于一个点，如果割集中存在，那么说明点覆盖集中选择该点，同时在原图中与该点相连的点应不被割才符合题意，否则该边不存在任何点覆盖。

所以，网络流中的原图的边不能被割掉，故边权均为正无穷。不过，点是可以被割掉的，所以源点流向二分图一侧的每一个点，边权为该点的权值。从二分图的另一侧流向汇点，边权为该点的权值。（下图为示例）

不难发现，这样建立边权与原问题是等价的。考虑反证法，若存在一条边 ( u , v ) (u,v) (u,v)，点 u u u 和点 v v v 都没有被选择，那么说明源点连向 u u u 的边与 v v v 连向汇点的边均未被割，这说明残留网络中必然存在增广路（因为网络流中的 ( u , v ) (u,v) (u,v) 边权为正无穷），与假设矛盾，证毕。

所以，在该网络流上跑最小割，即可求出原二分图的最小点全覆盖集。

代码 Code

#include <bits/stdc++.h>
#define fi first
#define se second
#define int long long

using namespace std;

typedef pair<int, int> PII;
typedef long long LL;

const int N = 点数, M = 边数;

int n, m, s, t;
int h[N], e[M], ne[M], f[M], idx;
int d[N], cur[N], st[N];

void add(int a, int b, int c) {
	e[idx] = b, ne[idx] = h[a], f[idx] = c, h[a] = idx ++;
	e[idx] = a, ne[idx] = h[b], f[idx] = 0, h[b] = idx ++;
}
bool bfs() {
	memset(d, -1, sizeof d);
	queue<int> q;
	q.emplace(s), d[s] = 0, cur[s] = h[s];
	while (q.size()) {
		int u = q.front();
		q.pop();

		for (int i = h[u]; ~i; i = ne[i]) {
			int v = e[i];
			if (d[v] == -1 && f[i]) {
				d[v] = d[u] + 1, cur[v] = h[v];
				if (v == t) return 1;
				q.emplace(v);
			}
		}
	}
	return 0;
}
int find(int u, int lim) {
	if (u == t) return lim;

	int flow = 0;
	for (int i = cur[u]; ~i && flow < lim; i = ne[i]) {
		cur[u] = i;
		int v = e[i];
		if (d[v] == d[u] + 1 && f[i]) {
			int tmp = find(v, min(lim - flow, f[i]));
			if (!tmp) d[v] = -1;
			f[i] -= tmp, f[i ^ 1] += tmp, flow += tmp;
		}
	}
	return flow;
}
int dinic() {
	int res = 0, flow;
	while (bfs()) while (flow = find(s, 1e18)) res += flow;
	return res;
}
void dfs(int u) {
	st[u] = 1;
	for (int i = h[u]; ~i; i = ne[i]) {
		int v = e[i];
		if (!st[v] && f[i]) dfs(v);
	}
}

signed main() {
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	memset(h, -1, sizeof h);
	cin >> n >> m;

	s = 0, t = 2 * n + 1;
	int w;
	for (int i = 1; i <= n; i ++)
		cin >> w, add(s, i, w);
	for (int i = n + 1; i <= n * 2; i ++)
		cin >> w, add(i, t, w);
	while (m -- ) {
		int a, b;
		cin >> a >> b;
		add(a, b + n, 1e18);
	}

	cout << dinic() << endl;
    
    return 0;
}

习题

POJ2125 - Destroying The Graph

最大权独立集

引入 Introduction

独立集指对于图 G ( V , E ) G(V,E) G(V,E)，选出点集 V ′ V' V′，使得对于 V ′ V' V′ 中的任意 2 2 2 个点， 2 2 2 点间都不存在一条边。

最大权独立集指对于所有独立集中点的权值和最大的独立集为最大权独立集。

主算法 Main Algorithm

最大权独立集 = 所有点权和 - 最小权点覆盖集

证明：

对于任意的点覆盖集 V 1 V_1 V1​， V 1 V_1 V1​ 在 V V V 中的补集 V 2 V_2 V2​ 恒为独立集。

证明：反证法。若不是独立集，说明存在边 ( u , v ) (u,v) (u,v) 使得 u , v ∈ V 2 u,v\in V_2 u,v∈V2​，那么由于 V 2 V_2 V2​ 为 V 1 V_1 V1​ 的补集，所以 u , v ∉ V 1 u,v\not\in V_1 u,v∈V1​，故 V 1 V_1 V1​ 不是点覆盖集。与假设矛盾，证毕。

所以， ∑ i ∈ V 1 w i + ∑ i ∈ V 2 w i = ∑ i = 1 n w i \sum_{i\in V_1}w_i+\sum_{i\in V_2}w_i=\sum_{i=1}^n w_i ∑i∈V1​​wi​+∑i∈V2​​wi​=∑i=1n​wi​。

故，当前项（最小权点覆盖集）取最小时，后项（最大权独立集）取最大。

综上所述，只需要沿用最小权点覆盖集的求解方法，并用总和减去其权值即可。

代码 Code

#include <bits/stdc++.h>
#define fi first
#define se second
#define int long long

using namespace std;

typedef pair<int, int> PII;
typedef long long LL;

const int N = 点数, M = 边数;

int n, m, s, t;
int h[N], e[M], ne[M], f[M], idx;
int d[N], cur[N], st[N];

void add(int a, int b, int c) {
	e[idx] = b, ne[idx] = h[a], f[idx] = c, h[a] = idx ++;
	e[idx] = a, ne[idx] = h[b], f[idx] = 0, h[b] = idx ++;
}
bool bfs() {
	memset(d, -1, sizeof d);
	queue<int> q;
	q.emplace(s), d[s] = 0, cur[s] = h[s];
	while (q.size()) {
		int u = q.front();
		q.pop();

		for (int i = h[u]; ~i; i = ne[i]) {
			int v = e[i];
			if (d[v] == -1 && f[i]) {
				d[v] = d[u] + 1, cur[v] = h[v];
				if (v == t) return 1;
				q.emplace(v);
			}
		}
	}
	return 0;
}
int find(int u, int lim) {
	if (u == t) return lim;

	int flow = 0;
	for (int i = cur[u]; ~i && flow < lim; i = ne[i]) {
		cur[u] = i;
		int v = e[i];
		if (d[v] == d[u] + 1 && f[i]) {
			int tmp = find(v, min(lim - flow, f[i]));
			if (!tmp) d[v] = -1;
			f[i] -= tmp, f[i ^ 1] += tmp, flow += tmp;
		}
	}
	return flow;
}
int dinic() {
	int res = 0, flow;
	while (bfs()) while (flow = find(s, 1e18)) res += flow;
	return res;
}
void dfs(int u) {
	st[u] = 1;
	for (int i = h[u]; ~i; i = ne[i]) {
		int v = e[i];
		if (!st[v] && f[i]) dfs(v);
	}
}

signed main() {
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	memset(h, -1, sizeof h);
	cin >> n >> m;

	s = 0, t = 2 * n + 1;
	int w, tot = 0;
	for (int i = 1; i <= n; i ++)
		cin >> w, add(s, i, w), tot += w;
	for (int i = n + 1; i <= n * 2; i ++)
		cin >> w, add(i, t, w), tot += w;
	while (m -- ) {
		int a, b;
		cin >> a >> b;
		add(a, b + n, 1e18);
	}

	cout << tot - dinic() << endl;
    
    return 0;
}

习题

  1. P4474 王者之剑
  2. ABC354 G - Select Strings
阿史大杯茶
关注
  • 44
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈神经网络算法
01-27
神经网络是一种模仿人脑工作原理的计算模型，广泛应用于机器学习和人工智能领域，尤其是解决分类问题。本文将简要探讨神经网络的基本概念，包括最简单的线性分类、多层级神经网络以及训练神经网络的方法。 首先，...
浅谈逆TDNN模型线性化功率放大器
08-12
具体来说，TDNN模型包含输入层、隐藏层、输出层和多个延迟抽头，通过反向传播算法进行训练，以最小化训练数据的均方误差。 在实验中，通过调整延迟抽头的数量、输入神经元和输出神经元的数量，找到了最佳的模型参数...
最大权闭合图
不来也不去的一只失忆蝴蝶
02-23 635
现在有一个有向图，每个点有点权，点权可正可负。对于任意一条有向边i和j，选择了点i就必须选择点j，你需要选择一些点使得得到权值最大。 这个问题可以用网络流解决。 建图方法：对于任意点i，如果i权值为正，s向i连容量为其权值的边，否则i向t连容量为其权值的绝对值德尔边。原图所有边容量为正无穷。则最大权=正权和-最大流。 如何证明呢？我们把最大流理解成最小割，那么割掉的边一定不可能是正无穷的边。
最大权闭合子图
weixin_30701521的博客
10-07 81
最大权闭合子图要解决的就是在一张图中的有附属的选点问题： 有一张有向图，点权有正有负，如果点u被选中，那么从点u出发所有能到达的点【u的附属点】都要被选，求最大选点方案。 网络流： 建立源汇点S，T， 1、对于所有权值w非负的点，从S向该点连一条容量为w的边 2、对于所有权值w为负的点，从该点向T连一条容量为-w的边 3、对于原图的所有边，容量改为INF 最终答案 = 原图正权值和 -...
【最大流】【NOI2009】植物大战僵尸
void* ptr = &OI;
05-16 2073
【问题描述】 Plants vs. Zombies（PVZ）是最近十分风靡的一款小游戏。Plants（植物）和Zombies（僵尸）是游戏的主角，其中Plants防守，而Zombies进攻。该款游戏包含多种不同的挑战系列，比如Protect Your Brain、Bowling等等。其中最为经典的，莫过于玩家通过控制Plants来防守Zombies的进攻，或者相反地由玩家通过控制Zombies对P
浅谈人工神经网络的学习算法.pdf
09-26
浅谈人工神经网络的学习算法 人工神经网络（Artificial Neural Network，ANN）是一种数学模型，模拟人脑的生物结构，具有学习、记忆、概括、归纳等基本特征。神经网络是由大量节点（或神经元）以某种特定拓扑结构...
9.王欣上《浅谈基于分层思想的网络流算法》1
08-03
在信息学竞赛中，这类问题常以各种形式出现，如最大流、最小割等。通过分层思想，可以更有效地解决这些问题，提高算法的效率。 二、预备概念 1. **剩余图**：在网络流算法中，剩余图是原图的基础上更新边的容量，...
浅谈分布式电源的配电网规划与优化运行-论文
05-21
传统的配电网主要依赖中央电源，而分布式电源的并网使得电网结构更为复杂，需要采取双层规划方法，以最小化成本为目标，优化电源和负荷的运行时间，合理配置分布式电源和网络架构。 在优化运行方面，由于分布式电源...
最大权闭合子图 分类： bzoj poj ...
aa288288的博客
08-06 142
参考论文：胡伯涛《最小割模型在信息学竞赛中的应用》 闭合子图的定义： 定义一个有向图 G=(V,E) 的闭合图是该有向图的一个点集，且该点集的所有出边指向的点属于该点集，即闭合图内的任意点的任意后继也一定在闭合图中。 如何求解最大权闭合子图？ 用最小割来解决。 题目：poj2987bzoj1497hdu3879 poj29...
网络流五·最大权闭合子图
Renaissancer的专栏
10-13 889
某班级决定举行一些班级建设活动。 根据周内的调查结果，共列出了N项不同的活动(编号1..N)，第i项活动能够产生a[i]的活跃值。 班级一共有M名学生(编号1..M)，邀请编号为i的同学来参加班级建设活动需要消耗b[i]的活跃值。 每项活动都需要某些学生在场才能够进行，若其中有任意一个学生没有被邀请，这项活动就没有办法进行。 班级建设的活跃值是活动产生的总活跃值减去邀请学生所花费的活跃值。
从理论到应用浅谈lasso
最新发布
01-05
Lasso算法的目标函数是通过最小化均方误差和L1正则化项的和来实现的。 Lasso算法在实际应用中具有广泛的应用。首先，由于Lasso能够进行特征选择，它在特征工程中非常有用。在处理具有大量特征的数据时，Lasso能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值