守卫

题目链接：PR #1 B

题目大意

给你一个无向图，然后每个边有建的费用。
然后有若干个人，每个人有一些存在的点可以选择。
要你每个人分配一个对应的位置存在，然后建一些边，使得每个点恰好可以被一个人通过边得到，而且选的边的边权和最小。

思路

首先是一个性质就是其实你可以根本不用管“恰好”这个性质。
然后这个性质挺显然的，就如果你可以连通块里面有两个人的话你完全可以选它们路径上的费用最大的边断开来优化费用。

然后接着有一个性质是你可以直接用最小生成森林来搞。
因为你考虑 \(x-y-z\) 这个东西，有一条 \(x-z\) 不选，那如果它会用到的话（比如 \(z\) 要到 \(x\)），那你完全可以从 \(z-y-x\) 到，因为你 \(y\) 也要到啊。
而且如果 \(y\) 有别的地方可以到的话，那你就没有必要 \(z\) 到 \(z\) 了，直接从 \(y\) 到 \(x\) 就可以了，怎么看费用都是优的。

然后我们其实可以考虑反着来，考虑能不能删去一条边。
然后如果每个人的点固定不难得到一个树形 DP，就是当前点的子树，然后当前点的连通块是否有人。
然后你会发现一个人的作用就是处理最上面的一部分或者让它祖先上的某条边可以断开。
那我们就是要找一些边（不能重复）使得减去的费用最多。

那不难想到一个网络流的方法，每个人有一个点，向可以走的地方连边。
然后我们并查集记录连通块之类的话我们就可以把边连起来的时候开一个新点表示这条边，然后用这个点作为它们它们两个的父亲，然后这个父亲向汇点连边（有费用的，费用就是边权）表示这条边被割了。
然后最后并查集的根的位置我们就要处理它的连通块，所以我们就也向汇点邻边，就没有费用了
然后上面边的流量为 \(1\)，然后就跑最大费用最大流。

当然我们要保证流量就是 \(k\)，也就是每个点都会起作用。
然后我们这个最大费用可以把有费用的地方 \(x\) 变成 \(inf-x\) 然后就正常最小费用最大流做。

然后优化的值可能是负的是因为没有每个连通块都有点，那直接判 \(-1\) 就可以了。

然后这题可以继续找一个性质（就是按边权从大到小依次尝试删除能删就删是最优的），然后就可以用类似匈牙利的算法来搞，但是感觉不如网络流好写。

代码

#include<queue>
#include<cstdio>
#include<iostream>
#include<algorithm>
#define ll long long
#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;

const int N = 300 + 10;
struct Line {
	int x, y, w;
}E[N * N];
int n, m, k, fa[N << 1], sn, x;
const ll inf = 1e9;
ll ans;

bool cmp(Line x, Line y) {
	return x.w < y.w;
}

int find(int now) {
	if (fa[now] == now) return now;
	return fa[now] = find(fa[now]);
}

struct WLL {
	struct node {
		ll x, val; int to, nxt, op;
	}e[(N * N) << 2];
	int tot, S, T, deg[N << 2], le[N << 2], KK, lee[N << 2];
	ll dis[N << 2];
	bool in[N << 2];
	queue <int> q;
	
	void add(int x, int y, ll z, ll va) {
		e[++KK] = (node){z, va, y, le[x], KK + 1}; le[x] = KK;
		e[++KK] = (node){0, -va, x, le[y], KK - 1}; le[y] = KK;
	}
	
	bool SPFA() {
		while (!q.empty()) q.pop();
		for (int i = 1; i <= tot; i++) deg[i] = 0, dis[i] = INF, in[i] = 0, lee[i] = le[i];
		q.push(S); deg[S] = 1; dis[S] = 0; in[S] = 0;
		while (!q.empty()) {
			int now = q.front(); q.pop();
			for (int i = le[now]; i; i = e[i].nxt)
				if (dis[e[i].to] > dis[now] + e[i].val && e[i].x) {
					deg[e[i].to] = deg[now] + 1; dis[e[i].to] = dis[now] + e[i].val;
					if (!in[e[i].to]) {
						in[e[i].to] = 1; q.push(e[i].to);
					}
				}
			in[now] = 0;
		}
		ll tmp = INF;
		return dis[T] < tmp;
	}
	
	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 (deg[e[i].to] == deg[now] + 1 && dis[e[i].to] == dis[now] + e[i].val && e[i].x) {
				int this_go = dfs(e[i].to, min(1ll * 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) deg[now] = -1;
		return go;
	}
	
	pair <ll, int> dinic() {
		pair <ll, int> re = make_pair(0ll, 0);
		while (SPFA()) {
			int x = dfs(S, INF);
			re.first += dis[T] * x; re.second += x;
		}
		return re;
	}
}W;

int main() {
	scanf("%d %d %d", &n, &m, &k);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &E[i].x, &E[i].y, &E[i].w);
	}
	sort(E + 1, E + m + 1, cmp);
	
	W.tot = 2 * n + k; W.S = ++W.tot; W.T = ++W.tot;
	int tot = n;
	for (int i = 1; i < 2 * n; i++) fa[i] = i;
	for (int i = 1; i <= m; i++) {
		int x = find(E[i].x), y = find(E[i].y);
		if (x != y) {
			fa[x] = fa[y] = ++tot;
			W.add(x, tot, 1, 0); W.add(y, tot, 1, 0);
			W.add(tot, W.T, 1, inf - E[i].w); ans += E[i].w;
		}
	}
	int num = k;
	for (int i = 1; i <= tot; i++) if (find(i) == i)
		W.add(i, W.T, 1, 0), num--;
	
	for (int i = 1; i <= k; i++) {
		scanf("%d", &sn); W.add(W.S, 2 * n + i, 1, 0);
		for (int j = 1; j <= sn; j++) {
			scanf("%d", &x); W.add(2 * n + i, x, 1, 0);
		}
	}
	
	pair <ll, int> re = W.dinic();
	if (re.second != k) {printf("-1"); return 0;}
	ll va = inf * num - re.first;
	if (va < 0) {printf("-1"); return 0;//这个会成立是因为可能一个连通块里面没有人可以到
	ans -= va; printf("%lld", ans);
	
	return 0;
} 

标签：PR,return,re,int,网络,然后,守卫,go,now
来源： https://www.cnblogs.com/Sakura-TJH/p/16123324.html