「JOISC 2016 Day 4」最差记者 2 题解

前言

题目链接：洛谷；AtCoder。

形式化题意

建议阅读原题面。

给定长度为 $n$ 的序列 $a,b,c,d$，求最少修改多少次 $a_i$，使得存在一个排列 $p$，满足 $a_i=c_{p_i}\wedge b_i\le d_{p_i}$。

$n\le 2\times {10}^5$，$b,d$ 单减，保证有解。

题目分析

首先你必须分析出来，这是一个最大权二分图完美匹配问题，不然连最基础的状压都不会写，然后爆零（当然说的是我自己）。

考虑把 $X_i=(a_i,b_i)$ 看做左部点，$Y_j=(c_j,d_j)$ 看做右部点，所有满足 $b_i\le d_j$ 的 $X_i,Y_j$ 之间连边，边权是 $[a_i\ne c_j]$，我们所求的就是最小花费完美匹配。

考虑状压 DP。记 $f_S$ 表示右部点匹配上的点集为 $S$，和前 $|S|$ 个左部点匹配，最小的花费是多少。初始 $f_{\varnothing }=0$，答案是 $f_Y$。转移的时候，每次选取一个点转移即可：$f_{S\cup \{Y_i\}}\leftarrow min\{f_{S\cup \{Y_i\}},f_S+[a_{|S|+1}\ne c_i]\}$。时间复杂度 $\mathcal{O}(n{2}^n)$。

以上是我没写出来的部分分。我们考虑直接跑 KM 算法求是 $\mathcal{O}(n^3)$，不太行。那么说明这个二分图一定有特殊的性质，因为如果是一般的二分图的话，我们会的算法 KM 已经最快了。（费用流显然也不太对。）

我们猜测一下算法，肯定需要贪心。我们不妨按照某一个顺序枚举右部点，尝试把它通过一条 $0$ 边和某一左部点匹配。

性质一

对于一个右部点 $Y_i$，通过一条边权为 $0$ 边，尝试和 $b_j$ 大的 $X_j$ 配对，肯定不劣。我们将这个匹配的 $X_j$ 记作 $\pi (i)$。

$b_j$ 大小关乎 $X_j$ 与多少右部点有边，显然 $b_j$ 小的连出的边更多。倘若我们选择了 $b_j$ 更小的 $X_j$，一定可以将其替换为满足 $b_{j^{\prime }}\ge b_j$ 的 $X_{j^{\prime }}$，而替换下来的 $X_j$ 留着可能和别的右部点匹配，从而不劣。

我们能匹配就让他们匹配上。这么做是对的基于所有点的贡献相同，如果我们按照一个恰当的顺序贪心，如果现在不进行匹配，之后让别的点和 $X_j$ 匹配不会让答案更优，所以这么贪心是不劣的。

接下来思考，什么时候我们发现他们不能匹配呢？倘若匹配他们后，把它们删去，剩下的图还不能形成一个完美匹配，那我们就不能让他们匹配。

是否存在完美匹配？这是一个很典的问题。

定理一：Hall's marriage theorem（霍尔定理）

wikipedia

Hall's condition is that any subset of vertices from one group has a neighbourhood of equal or greater size.

即，一张二分图是否存在完美匹配的充要条件是，对于左部点 / 右部点的任意子集的邻居点集（有边相连的右部点 / 左部点）大小不小于该子集的大小。不妨将该条件称作 Hall 判定条件。

Necessity Proof

假设二分图 $G=(X\bigsqcup Y,E)$ 存在完美匹配 $M\subseteq E$，那么 $\mathrm{\forall }S\subseteq X$，记 $T=\{y\in Y\mid x\in S\wedge (x,y)\in M\}$，记 $S$ 的邻居 $N_G(S)=\{y\in Y\mid x\in S\wedge (x,y)\in E\}$，由于 $M\subseteq E$，我们有 $T\subseteq N_G(S)$，故 $|N_G(S)|\ge |T|=|S|$。对于 $Y$ 同理。必要性证毕。

Sufficiency Proof

归纳证明。对于 $|X|=1$，显然成立。假设 $|X|<n$ 命题成立，对于 $|X|=n>1$，分如下两类讨论：

1. $\mathrm{\forall }S\subseteq X,N_G(S)\ge |S|+1$：
   将任意 $x\in X$ 与任意 $y\in N_G(\{x\})$ 匹配，剩下的子图 $G^{\prime }$ 依然满足命题条件，而 $X^{\prime }=X\setminus \{x\}$，根据归纳假设，成立。
2. $\mathrm{\exists }S\subseteq X,N_G(S)=|S|$：
   将 $S$ 与 $N_G(S)$ 组成 $|S|$ 组匹配，剩下的子图 $G^{\prime }$ 依然满足命题条件（倘若 $\mathrm{\exists }{S}^{\prime }\subseteq X^{\prime },|N_{G^{\prime }}(S^{\prime })|<|S^{\prime }|$，则 $N_G(S\cup S^{\prime })=N_G(S)\cup N_{G^{\prime }}(S^{\prime })$，从而有 $|N_G(S\cup S^{\prime })|<|S\cup S^{\prime }|$，与假设矛盾），故根据归纳假设，成立。

对于任意子集的话……难道我们要枚举子集？显然不现实。这时候，似乎需要用到这个二分图的一些性质了。

性质二

我们发现，对于一个左部点 $X_i$，它所连的右部点是一段前缀，不妨设为 $Y_1\sim Y_{p_i}$，这个可以用双指针处理。类似同理，右部点连到的左部点总是一段后缀。

证明显然，自证不难。

这个性质很自然得到，有什么用呢？

性质三

我们考虑一个右部点的子集 $S$，记 $Y_{y_0}=arg\underset{Y_i\in S}{max}{d}_i$，$S^{\prime }=\mathrm{suf}(y_0)=\{Y_i\mid d_i\le d_{y_0}\}$。

我怎么听不懂你在讲什么？

如果我们把左右部点，分别按照 $b,d$ 从小到大的顺序，从上到下排列，$Y_{y_0}$ 就是 $S$ 中最靠上的点，$S^{\prime }$ 就是 $Y_{y_0}$ 及以下的右部点构成的点集（不妨将 $Y_i$ 及以下的右部点构成的点集记作 $\mathrm{suf}(i)$）。

$S^{\prime }$ 满足 Hall 判定条件是 $S$ 满足 Hall 判定条件的充分条件。因为 $S^{\prime }$ 相比 $S$，邻居没变 $N_G(S^{\prime })=N_G(S)=N_G(\{Y_{y_0}\})$，而 $|S^{\prime }|\ge |S|$。

如此，我们把需要判定的子集个数由 $2^n$ 简化至 $n$ 个后缀。原问题似乎变得十分可做。慢着，我们还有一个问题一直没有解决，那就是按照什么顺序枚举右部点呢？

先说结论：按照 $d_i$ 从小到大枚举，即按照下标从后往前枚举右部点。

我们考虑 $c_i=c_j\wedge d_i\ge d_j$ 的右部点 $Y_i,Y_j$，且有 $\pi (i)=\pi (j)={\pi }_0$。让 $Y_j$ 和 ${\pi }_0$ 匹配，而不是 $Y_i$ 和 ${\pi }_0$ 匹配，原因是，两者唯一的差别就是考虑 $d_k\in (d_j,d_i)$ 的 $Y_k$，$\mathrm{suf}(k)$ 在 $Y_j$ 和 ${\pi }_0$ 匹配后，我们会删去 $Y_j$ 这个右部点，而无论是 $Y_i/Y_j$ 和 ${\pi }_0$ 匹配，$N_G(\mathrm{suf}(k))$ 不变。导致让 $Y_j$ 先匹配，$Y_k$ 更有可能满足 Hall 判定条件。

至于 $\pi (i)$ 的维护，对每种 $a_i/c_i$ 开一个栈，然后双指针即可。我们可以写出如下 $\mathcal{O}(n^2)$ 代码：

#include <cstdio>
#include <iostream>
#include <stack>
using namespace std;
 
const int N = 200010;
 
int n, a[N], b[N], c[N], d[N];
int p[N];
 
stack<int> st[N];
 
bool diedL[N], diedR[N];
 
bool check() {
    int pcnt = 0;  // 后缀右部点有多少
    int N_G = 0;  // 邻居左部点有多少
    for (int i = n, j = n; i >= 1; --i) {
        if (diedR[i]) continue;
        ++pcnt;
        for (; j >= 1 && p[j] >= i; --j)
            N_G += !diedL[j];
        if (N_G < pcnt)
            return false;
    }
    return true;
}
 
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &a[i], &b[i]);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &c[i], &d[i]);
    for (int i = 1; i <= n; ++i) {
        for (p[i] = p[i - 1]; p[i] + 1 <= n && d[p[i] + 1] >= b[i]; ++p[i]);
    }
    int ans = 0;
    for (int i = n, j = n; i >= 1; --i) {
        for (; j >= 1 && p[j] >= i; --j)
            st[a[j]].push(j);
        if (st[c[i]].empty()) {
            ++ans;
            continue;
        }
        int pi_i = st[c[i]].top();
        diedL[pi_i] = diedR[i] = true;
        if (check()) {
            st[c[i]].pop();
        } else {
            ++ans;
            diedL[pi_i] = diedR[i] = false;
        }
    }
    printf("%d", ans);
    return 0;
}

那么我们需要优化的部分就是 check 了。

我们考虑将判定条件 $\mathrm{\forall }i,|N_G(\mathrm{suf}(i))|\ge |\mathrm{suf}(i)|$ 移项变为 $\mathrm{\forall }i,|N_G(\mathrm{suf}(i))|-|\mathrm{suf}(i)|\ge 0$，用数据结构维护左侧式子，为了方便叙述，将式子表示为 $\mathrm{\forall }i,u_i-v_i\ge 0$。

发现我们在匹配 $\pi (i),Y_i$ 时，将 $Y_1\sim Y_{p_{\pi (i)}}$ 的 $u$ 减了一，将 $Y_1\sim Y_{i-1}$ 的 $v$ 减少了一。至于之后 check 的时候不考虑 $Y_i$，可以直接将 $u_i\leftarrow \mathrm{\infty }$。或者除了上述操作，将 $Y_i$ 的 $v$ 也减一，就不需要特殊处理 $Y_i$。

感性理解一下。由于 $Y_1\sim Y_{p_{\pi (i)}}$ 包含了 $Y_i$，再把 $v_i$ 减一相当于它 $u_i,v_i$ 都不变。考虑 $v_i=v_{i+1}+1$，我们又有 $u_i-v_i=u_i-1-v_{i+1}$，而 $u_i-1\ge u_{i+1}$，所以 $Y_i$ 和后缀里某个点等价，如果不合法，后缀某个点会出现问题。

于是，我们可以使用一棵线段树，方便地执行区间加减操作，查询全局的最小值，看看如果 $\ge 0$ 就合法，否则不合法。

时间复杂度：$\mathcal{O}(n\log n)$。瓶颈在于线段树维护区间加减一，全局最值查询，和 这题 最后瓶颈相同。

代码

$\mathcal{O}(n{2}^n)$ 状压

namespace $ya {
 
int f[1 << 17 | 736520];
 
void tomin(int &a, int b) {
    if (b < a)
        a = b;
}
 
void solve() {
    memset(f, 0x3f, sizeof(*f) << n);
    f[0] = 0;
    using uint = unsigned;
    for (uint st = 0; st < 1u << n; ++st) {
        if (f[st] == 0x3f3f3f3f)
            continue;
        int i = __builtin_popcount(st) + 1;
        for (int j = 1; j <= p[i]; ++j)
            if (!(st & 1u << (j - 1))) {
                tomin(f[st | 1u << (j - 1)], f[st] + (a[i] != c[j]));
            }
    }
    printf("%d", f[(1u << n) - 1]);
}
 
}

$\mathcal{O}(n^2)$ 暴力判断合法

#include <cstdio>
#include <iostream>
#include <stack>
using namespace std;
 
const int N = 200010;
 
int n, a[N], b[N], c[N], d[N];
int p[N];
 
stack<int> st[N];
 
bool diedL[N], diedR[N];
 
bool check() {
    int pcnt = 0;  // 后缀右部点有多少
    int N_G = 0;  // 邻居左部点有多少
    for (int i = n, j = n; i >= 1; --i) {
        if (diedR[i]) continue;
        ++pcnt;
        for (; j >= 1 && p[j] >= i; --j)
            N_G += !diedL[j];
        if (N_G < pcnt)
            return false;
    }
    return true;
}
 
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &a[i], &b[i]);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &c[i], &d[i]);
    for (int i = 1; i <= n; ++i) {
        for (p[i] = p[i - 1]; p[i] + 1 <= n && d[p[i] + 1] >= b[i]; ++p[i]);
    }
    int ans = 0;
    for (int i = n, j = n; i >= 1; --i) {
        for (; j >= 1 && p[j] >= i; --j)
            st[a[j]].push(j);
        if (st[c[i]].empty()) {
            ++ans;
            continue;
        }
        int pi_i = st[c[i]].top();
        diedL[pi_i] = diedR[i] = true;
        if (check()) {
            st[c[i]].pop();
        } else {
            ++ans;
            diedL[pi_i] = diedR[i] = false;
        }
    }
    printf("%d", ans);
    return 0;
}

$\mathcal{O}(n\log n)$ 数据结构维护

#include <cstdio>
#include <iostream>
#include <stack>
using namespace std;
 
const int N = 200010;
 
int n, a[N], b[N], c[N], d[N];
int p[N];
 
stack<int> st[N];
 
#define lson (idx << 1    )
#define rson (idx << 1 | 1)
 
int tag[N << 2], mi[N << 2];
 
inline void pushtag(int idx, int v) {
    tag[idx] += v, mi[idx] += v;
}
 
inline void pushdown(int idx) {
    if (!tag[idx]) return;
    pushtag(lson, tag[idx]);
    pushtag(rson, tag[idx]);
    tag[idx] = 0;
}
 
void modify(int idx, int trl, int trr, int l, int r, int v) {
    if (l <= trl && trr <= r) return pushtag(idx, v);
    pushdown(idx);
    int mid = (trl + trr) >> 1;
    if (l <= mid) modify(lson, trl, mid, l, r, v);
    if (r >  mid) modify(rson, mid + 1, trr, l, r, v);
    mi[idx] = min(mi[lson], mi[rson]);
}
 
#undef lson
#undef rson
 
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &a[i], &b[i]);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &c[i], &d[i]);
    for (int i = 1; i <= n; ++i) {
        for (p[i] = p[i - 1]; p[i] + 1 <= n && d[p[i] + 1] >= b[i]; ++p[i]);
    }
    for (int i = 1; i <= n; ++i) {
        modify(1, 1, n, 1, p[i], 1);
        modify(1, 1, n, 1, i, -1);
    }
    int ans = 0;
    for (int i = n, j = n; i >= 1; --i) {
        for (; j >= 1 && p[j] >= i; --j)
            st[a[j]].push(j);
        if (st[c[i]].empty()) {
            ++ans;
            continue;
        }
        int pi_i = st[c[i]].top();
        modify(1, 1, n, 1, p[pi_i], -1);
        modify(1, 1, n, 1, i, 1);
        if (mi[1] >= 0) {
            st[c[i]].pop();
        } else {
            ++ans;
            modify(1, 1, n, 1, p[pi_i], 1);
            modify(1, 1, n, 1, i, -1);
        }
    }
    printf("%d", ans);
    return 0;
}