NOI2008 志愿者招聘
文化课 + 竞赛双废物又来水题解了。
首先，对于题干中的人，很像网络流中的流量，但是他有一个每天人数的下限，我从网上借鉴（chaoxi）到了两种思路：
- 把下界限制转化为一条边的流量下界，这样就是最小费用上下界最大流。
- 加入几个新值，其条件正好为 \(\ge 0\)，将其当做一条流量，这样不等式就变成了等式，我们可以利用流量守恒，用点的流满 $\Leftrightarrow $ 等式成立，这样就变成了一个最小费用最大流，去掉了上下界的影响。
其实这两种思路本质好像是一致的...
思路一
即 \(y\) 总视频的解法，考虑到人的工作时间是一段区间，不妨差分考虑，先让 \(i\) 的人无条件免费顺延到 \(i + 1\) 的边，然后在 \(S\) 和 \(T\) 人为规定加入/去除即可，这样一类工作者只会设计常数的点边，复杂度正常。
那么建立网络 \(G\)：
- 对于一天 \(i\)，让 \(i\) 点向 \(i + 1\) 点连边。流量下界是 \(A_i\)、上界是正无穷，费用是 \(0\)，这条边的流量意味着第 \(i\) 天的工作人数，
- 对于一类志愿者 \(j\)，让 \(T_j + 1\) 向 \(S_j\) 连一条容量无界限，费用是 \(C_i\) 的边，这条边可以自由活动，意味着自由安排是志愿者。
这样，每个志愿者相当于在流网络的一单位的流量流过了一个环，这个问题变成了最小费用无源汇上下界可行流，我们都知道可行流的可行判定经过转化就是跑到最大流，所以转化完后用最小费用最大流就行了。
时间复杂度
\(O(n^2m)\) 复杂度真棒
Code
这题 Acwing 咋这么卡常啊
#include <iostream>
#include <cstdio>
#include <cstring>
#define rint register int
typedef long long LL;
using namespace std;
const int N = 1005, M = (N * 2 + 10000) * 2, INF = 0x3f3f3f3f;
int n, m, a[N], incf[N], d[N], q[N], pre[N];
int head[N], numE = 1, S, T;
bool vis[N];
LL ans;
struct E{
int next, v, w, c;
} e[M];
void inline add(int u, int v, int w, int c) {
e[++numE] = (E) { head[u], v, w, c };
head[u] = numE;
e[++numE] = (E) { head[v], u, 0, -c };
head[v] = numE;
}
bool inline spfa() {
memset(d, 0x3f, sizeof d);
rint hh = 0, tt = 1;
d[S] = 0, q[0] = S, incf[S] = INF;
while (hh != tt) {
rint u = q[hh++]; vis[u] = false;
if (hh == N) hh = 0;
for (rint i = head[u]; i; i = e[i].next) {
rint v = e[i].v;
if (d[u] + e[i].c < d[v] && e[i].w) {
d[v] = d[u] + e[i].c, pre[v] = i, incf[v] = min(incf[u], e[i].w);
if (!vis[v]) {
vis[v] = true, q[tt++] = v;
if (tt == N) tt = 0;
}
}
}
}
return d[T] != INF;
}
void inline update() {
int x = T;
while (x != S) {
int i = pre[x];
e[i].w -= incf[T], e[i ^ 1].w += incf[T];
x = e[i ^ 1].v;
}
ans += (LL)d[T] * incf[T];
}
int main() {
scanf("%d%d", &n, &m);
S = n + 2, T = n + 3;
for (rint i = 1, A; i <= n; i++) {
scanf("%d", &A);
add(i, i + 1, INF, 0);
a[i] -= A, a[i + 1] += A;
}
for (rint i = 1, s, t, c; i <= m; i++) {
scanf("%d%d%d", &s, &t, &c);
add(t + 1, s, INF, c);
}
for (rint i = 1; i <= n + 1; i++) {
if (a[i] > 0) add(S, i, a[i], 0);
else if (a[i] < 0) add(i, T, -a[i], 0);
}
while (spfa()) update();
printf("%lld\n", ans);
return 0;
}
思路二
设一些新的变量：
-
\(B_i (B_i \ge 0)\)，表示第 \(i\) 天实际招了 \(A_i + B_i\) 人。
-
\(D_i (D_i \ge 0)\)，表示实际上第 \(i\) 类志愿者招了 \(D_i\) 类人
这样我们就可以列出 \(n\) 个等式，对于第 \(i\) 个等式（针对第 \(i\) 天的匹配情况）
但是为了让每个变量在流网络中、在每个等式中都相等，所以我们得让每个变量至多出现在两个式子中，（如果出现在一个式子，就可以将其到源汇点的费用改了，这样就是费用对应上了，如果两个式子，可以从本该连向汇点的边直接连向本该从源点出的边，这样费用对应。这里本人实力还是非常菜，很可能讲了一些玄学的东西，求大佬们轻喷。）
由于每个 \(j\) 影响的 \(i\) 是连续的一段，所以我们可以将式子前后加入两个 \(0 = 0\)，然后将式子差分（这是一步等价变换）这样每个 \(D_j, B_i\) 都恰好会出现在两个式子之中。
对于第 \(i\) 个等式而言，差分后的式子：
我们把式子移项，让每一项都是正的：
这样，我们可以把等式看作一个点的流量守恒等式，等式左右两侧分别是流入该点/流出改点的流量，我们建立流网络：
- 对于常量 \(A\)，在左侧则连一条自虚拟源点出发，到 \(i\) 点，流量为 \(A_i\)，无费用的边，右侧连到汇点，即对称的。
- 对于变量 \(B\)，从 \(B_i\) 所在右侧等式的点向 \(B_i\) 所在左侧的点，即 \(i\) 连向 \(i-1\)，这条边流量无限，意味着自由选择的 \(B\)，而这条边 + 流量守恒保证了 \(B_i\) 在两个式子中不变
- 对于变量 \(D\) 同理，即 \(S_j\) 连向 \(T_j + 1\)，流量无限，费用为 \(C_j\) 的边。
这样，在流网络跑到的最大流 = 从 \(S\) 出发所有容量（满足常量的强行限制） \(\Leftrightarrow\) 差分等式成立 \(\Leftrightarrow\) 原始等式成立 \(\Leftrightarrow\) 一个满足条件的方案
所以，原问题最小费用 \(\Leftrightarrow\) 最小费用最大流
时间复杂度
\(O(n^2m)\)
Code
这个代码过不去acwing。。坑
#pragma GCC optimize("Ofast","-funroll-loops")
#include <iostream>
#include <cstdio>
#include <cstring>
#define rint register int
typedef long long LL;
using namespace std;
const int N = 1005, M = (N * 3 + 10000) * 2, INF = 0x3f3f3f3f;
int n, m, a[N], incf[N], d[N], q[N], pre[N];
int head[N], numE = 1, S, T;
bool vis[N];
LL ans;
struct E{
int next, v, w, c;
} e[M];
void inline add(int u, int v, int w, int c) {
e[++numE] = (E) { head[u], v, w, c };
head[u] = numE;
e[++numE] = (E) { head[v], u, 0, -c };
head[v] = numE;
}
bool inline spfa() {
memset(d, 0x3f, sizeof d);
rint hh = 0, tt = 1;
d[S] = 0, q[0] = S, incf[S] = INF;
while (hh != tt) {
rint u = q[hh++]; vis[u] = false;
if (hh == N) hh = 0;
for (rint i = head[u]; i; i = e[i].next) {
rint v = e[i].v;
if (d[u] + e[i].c < d[v] && e[i].w) {
d[v] = d[u] + e[i].c, pre[v] = i, incf[v] = min(incf[u], e[i].w);
if (!vis[v]) {
vis[v] = true;
q[tt++] = v;
if (tt == N) tt = 0;
}
}
}
}
return d[T] != INF;
}
void inline update() {
int x = T;
while (x != S) {
int i = pre[x];
e[i].w -= incf[T], e[i ^ 1].w += incf[T];
x = e[i ^ 1].v;
}
ans += (LL)d[T] * incf[T];
}
int main() {
scanf("%d%d", &n, &m);
S = n + 2, T = n + 3;
for (rint i = 1, A; i <= n; i++) {
scanf("%d", &A);
add(S, i, A, 0), add(i + 1, T, A, 0);
add(i + 1, i, INF, 0);
}
for (rint i = 1, s, t, c; i <= m; i++) {
scanf("%d%d%d", &s, &t, &c);
add(s, t + 1, INF, c);
}
while (spfa()) update();
printf("%lld\n", ans);
return 0;
}
