「SOL」网络流flow (模拟赛)
题面
给定一张分层有向图，有 \(n\) 层，每层有 \(m\) 个点。只有从第 \(i\) 层的点连向第 \(i + 1\) 层的点的连边。
记 \(A(i,j)\) 表示从第 \(i\) 层的某些点出发到第 \(j\) 层的某些点的点不相交路径集合的最大大小。求
其中，\(n\le 4\times10^4,m\le10\)。
解析
注意到 \(m\) 很小，于是首先有一个暴力状压的思路。\(f(i,S)\) 表示从第 \(i\) 层的 \(S\) 点集出发，要求这 \(|S|\) 条路径都能到达第 \(j\) 层，\(j\) 最大是多少。
可以 DFS 出所有第 \(i\) 层和第 \(i + 1\) 层之间的转移，总复杂度 \(\mathcal{O}(2^{2m}n)\)。统计答案则可以记 \(g(i,k)\)：
则 \(A(i, j) = k\)（\(g(i, k) \le j \le g(i, k + 1)\)），可以快速统计答案。
考虑这样 DP 的本质是什么。假如把原问题建网络流，只需要把每个点拆点限制流量，就相当于求两层之间的最大流。
而状压 DP 反映的是这样一个结论：从第 \(i\) 层出发，可以在任意位置结束，尽可能流到较大的层；在这样的前提下流最大流，则 \(A(i,j)\) 为流经第 \(j\) 层的流量。
相当于一个费用流，两层之间费用为 \(1\)。（实际上也没有这样去实现代码，只是方便理解）
考虑到这个流网络非常特殊，可以模拟流的过程。
- 由于可以在任何位置结束，所以一定是满流的，只需要每次找到残留网络的最长路——即能够到达的最深的层。
- 可以直接 BFS，由于费用只和点的层数有关，所以一个点不需要多次更新，过程中维护点的访问标记。
- 记录增广路的前驱，在找到层数最大的增广路后逆序还原增广路，更新残留网络。
- 由于流网络分层，不可能从较大的层流向较小的层，于是将源点从第 \(i\) 层换到第 \(i + 1\) 层时，可以直接继承残留网络，删去 \(i\) 和 \(i + 1\) 层之间的连边。
最后就是时间复杂度的问题了。注意到假如在一次增广时，找到的增广路层数为 \(p\)，则最多访问 \(pk\) 个点，每个点转移复杂度 \(\mathcal{O}(k)\)，则该次增广复杂度为 \(\mathcal{O}(pk^2)\)。
该次增广后，流网络的总流量增加 \(\mathcal{O}(p)\)（手动模拟一下，可以发现即使发生退流，由于我们取层数最大的增广路，退掉的流也会补回来，该次增广仍会使流网络总流量增加 \(p\)），而流网络总流量 \(\mathcal{O(nk)}\)，所以 \(\mathcal{O}(\sum pk^2)=\mathcal{nk^3}\)。
模拟细节见代码。
源代码
/* Lucky_Glass */
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
typedef long long llong;
typedef std::pair<int, int> pii;
int rin(int &r) {
int c = getchar(); r = 0;
while (c < '0' || '9' < c) c = getchar();
while ('0' <= c && c <= '9') r = r * 10 + (c ^ '0'), c = getchar();
return r;
}
const int N = 4e4 + 10, K = 10;
int n, m, nw, tot_flw;
int lnk[N << 1][K], lnk_i[N << 1][K], vis[N << 1];
int elg2[(1 << K) + 10], flw_cnt[N];
pii las_pnt[N << 1][K];
void extend(const int &sx, const int &sy) {
int ed_x = sx, ed_y = sy;
int clear_vis_pos = sx;
vis[sx] = 1 << sy;
/* 此次增广经过的第 i 层点（防止环流？） */
std::queue<pii> que;
que.emplace(sx, sy);
while (!que.empty()) {
int ux = que.front().first, uy = que.front().second;
que.pop();
if ((ux & 1) && (ux >> 1) > (ed_x >> 1))
ed_x = ux, ed_y = uy;
/* 向下一层 */
if (ux < nw) {
if (clear_vis_pos == ux) vis[++clear_vis_pos] = 0;
int rem = lnk[ux][uy] ^ (lnk[ux][uy] & vis[ux + 1]);
while (rem) {
int vy = elg2[rem & -rem];
vis[ux + 1] |= 1 << vy;
/* las_pnt 记录转移点，便于还原增广路 */
las_pnt[ux + 1][vy] = std::make_pair(ux, uy);
que.emplace(ux + 1, vy);
rem ^= rem & -rem;
}
}
/* 经过逆向边返回上一层，lnk_i 存储反向边 */
if (ux > sx) {
int rem = lnk_i[ux][uy] ^ (lnk_i[ux][uy] & vis[ux - 1]);
while (rem) {
int vy = elg2[rem & -rem];
vis[ux - 1] |= 1 << vy;
las_pnt[ux - 1][vy] = std::make_pair(ux, uy);
que.emplace(ux - 1, vy);
rem ^= rem & -rem;
}
}
}
/* 更新每一层的流量，更新答案 */
for (int i = sx >> 1, lmt_i = ed_x >> 1; i <= lmt_i; ++i)
++flw_cnt[i], ++tot_flw;
/* 还原增广路，更新残留网络 */
while (ed_x != sx || ed_y != sy) {
// printf("(%d, %d) <- ", ed_x, ed_y);
int lasx = las_pnt[ed_x][ed_y].first,
lasy = las_pnt[ed_x][ed_y].second;
if (ed_x == lasx + 1) {
lnk[lasx][lasy] ^= 1 << ed_y;
lnk_i[ed_x][ed_y] ^= 1 << lasy;
} else {
lnk[ed_x][ed_y] ^= 1 << lasy;
lnk_i[lasx][lasy] ^= 1 << ed_y;
}
ed_x = lasx, ed_y = lasy;
}
// printf("(%d, %d)\n", sx, sy);
}
void init() {
for (int i = 0; i <= K; ++i)
elg2[1 << i] = i;
}
int main() {
freopen("flow.in", "r", stdin);
freopen("flow.out", "w", stdout);
// freopen(".\\input\\input.in", "r", stdin);
init();
rin(n), rin(m);
nw = (n << 1) - 1;
for (int i = 1; i < nw; ++i)
if (i & 1) {
static char inp[K << 1];
for (int j = 0; j < m; ++j) {
scanf("%s", inp);
for (int k = 0; k < m; ++k)
lnk[i][j] |= (inp[k] ^ '0') << k;
}
} else {
for (int j = 0; j < m; ++j)
lnk[i][j] = 1 << j;
}
llong ans = 0;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < m; ++j)
extend(std::max(1, (i - 1) << 1), j);
/*
* 注意一定是从 (i - 1) << 1 开始
* 通过 ((i - 1) << 1) -> (((i - 1) << 1) - 1) 是否有边
* 限制每个点只能用一次
* 因为第一层不存在访问多次，可以直接从 1 开始跑
*/
ans += (tot_flw -= flw_cnt[i - 1]);
}
printf("%lld\n", ans);
return 0;
}
