[USACO25OPEN] Election Queries G 题解

题目传送门

洛谷P12029

题面：P12029 [USACO25OPEN] Election Queries G

题目描述

注意：本题时间限制为 3 秒，是默认时间的 1.5 倍。

农夫约翰有 $N$ 头（$2\le N\le 2\cdot 10^5$）编号从 $1$ 到 $N$ 的奶牛。农场正在举行选举，将选出两头新的领头牛。初始时，已知第 $i$ 头奶牛会投票给第 $a_i$ 头奶牛（$1\le a_i\le N$）。

选举过程如下：

1. 农夫约翰任意选择一个非空真子集 $S$（即至少包含一头牛但不包含所有牛）。
2. 在 $S$ 集合中，得票数最多的候选牛将被选为第一头领头牛 $x$。
3. 在剩余奶牛组成的集合中，得票数最多的候选牛将被选为第二头领头牛 $y$。
4. 定义两头领头牛的差异度为 $|x-y|$。若无法选出两头不同的领头牛，则差异度为 $0$。

由于奶牛们经常改变主意，农夫约翰需要进行 $Q$ 次（$1\le Q\le 10^5$）查询。每次查询会修改一头奶牛的投票对象，你需要回答当前状态下可能获得的最大差异度。

输入格式

第一行包含 $N$ 和 $Q$。

第二行包含初始投票数组 $a_1,a_2,\dots ,a_N$。

接下来 $Q$ 行，每行两个整数 $i$ 和 $x$，表示将 $a_i$ 修改为 $x$。

输出格式

输出 $Q$ 行，第 $i$ 行表示前 $i$ 次查询后的最大可能差异度。

输入输出样例 #1

输入 #1

5 3
1 2 3 4 5
3 4
1 2
5 2

输出 #1

4
3
2

输入输出样例 #2

输入 #2

8 5
8 1 4 2 5 4 2 3
7 4
8 4
4 1
5 8
8 4

输出 #2

4
4
4
7
7

说明/提示

样例一解释：

第一次查询后，$a=[1,2,4,4,5]$。选择 S = { 1 , 3 } S = \{1,3\} S={1,3} 时：

• $S$ 中：牛 $1$ 得 $1$ 票，牛 $4$ 得 $1$ 票 $\to$ 可选择牛 $1$ 或牛 $4$ 作为第一头领头牛。
• 剩余牛中：牛 $2,4,5$ 各得 $1$ 票 $\to$ 可选择牛 $2,4,5$ 作为第二头领头牛。

最大差异度为 $|1-5|=4$。

第二次查询后，$a=[2,2,4,4,5]$。选择 S = { 4 , 5 } S = \{4,5\} S={4,5} 时：

• $S$ 中：牛 $4$ 得 $1$ 票，牛 $5$ 得 $1$ 票。
• 剩余牛中：牛 $2$ 得 $2$ 票。

最大差异度为 $|5-2|=3$。

• 测试点 $3\sim 4$：$N,Q\le 100$。
• 测试点 $5\sim 7$：$N,Q\le 3000$。
• 测试点 $8\sim 15$：无额外限制。

题解

问题核心

记${\text{cnt}}_{\text{i}}$为奶牛$i$获得的票数，则若可以使奶牛$x$,$y$当选，显然应当将所有投票给$x$的奶牛放入集合$\text{S}$中，将投票给$y$的奶牛归到“剩余牛”中。
那么，为了保证奶牛$x$的票数${\text{cnt}}_{\text{x}}$为集合$\text{S}$的众数，显然在$\text{S}$里投给奶牛$z$的票数${\text{cnt}}_{{\text{z}}_{\text{S}}}$不可以超过${\text{cnt}}_{\text{x}}$。同理该奶牛$z$在剩余奶牛中获得的票数不能超过${\text{cnt}}_{\text{y}}$。
因此，对于任意奶牛$z$，其票数${\text{cnt}}_{\text{z}}={\text{cnt}}_{{\text{z}}_{\text{S}}}+{\text{cnt}}_{{\text{z}}_{\text{S在全体奶牛中的补集}}}\le {\text{cnt}}_{\text{x}}+{\text{cnt}}_{\text{y}}$
由此推广到全体奶牛，即 ∀ z ∈ { 1 , 2 , ⋯   , n } , \forall z\in\lbrace 1,2,\cdots,n\rbrace, ∀z∈{1,2,⋯,n},我们都有上式，所以可得
$$\Rightarrow {\text{cnt}}_{\text{x}}+{\text{cnt}}_{\text{y}}\ge \underset{k=1}{\overset{n}{\max }}{\text{cnt}}_{\text{k}}$$

思路

枚举候选对：

直接枚举所有 $(x,y)$ 对不可行（$O(N^2)$）。利用性质：

不同 $\text{cnt}$ 值的种类数 $d=O(\sqrt{N})$（因为 $\sum \text{cnt}[i]=N$，最坏情况 $\text{cnt}$ 值互异时 $d\approx \sqrt{2N}$）。

只需考虑不同的 $\text{cnt}$ 值，而非每个奶牛索引。

维护数据结构：

$\text{st}[v]$：set 存储得票数为 $v$ 的奶牛索引。

$\text{mxi}[v]$ 和 $\text{mni}[v]$：得票数为 $v$ 的奶牛索引的最大值和最小值。

$S$：全局 set 存储存在的非零票数值（用于快速访问不同 $\text{cnt}$）。

更新投票：

修改投票时，更新 $\text{cnt}$ 数组和上述数据结构（删除旧票数对应索引，添加新票数对应索引）。

计算最大差异度：

特判：

若最小票数 $v_{\min }$ 满足 $2v_{\min }\ge \text{mx}$（$\text{mx}={\max }_k\text{cnt}[k]$），则用 $\text{mxi}[v_{\min }]-\text{mni}[v_{\min }]$ 更新答案（同票数奶牛索引差）。

双指针遍历 $S$：

指针 itl 从小到大遍历 $S$（小票数）。

指针 itr 从大到小移动（大票数），维护累积变量 mxp（满足 $\text{cnt}[x]+\text{cnt}[y]\ge \text{mx}$ 的奶牛索引最大值）和 mnp（索引最小值）。

对于每个 itl，更新答案 $\max (\text{mxp}-\text{mni}[\text{itl}],\text{mxi}[\text{itl}]-\text{mnp})$，覆盖 $x$ 小 $y$ 大或 $x$ 大 $y$ 小的情况。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, q;
int a[N];           // a[i]:    奶牛i投给的奶牛的编号
int cnt[N];         // cnt[i]:  奶牛i获得的票数
int mni[N];         // mni[x]:  票数为x的奶牛编号最小值
int mxi[N];         // mxi[x]:  票数为x的奶牛编号最大值
set<int> id[N];     // id[x]:   统计所有票数为x的奶牛编号
set<int> S;         // S:       维护所有存在的票数值

// i 的得票变成 x 了
void addc(int i, int x)
{
    if (!x) return; // 若此奶牛无票则不用处理
    id[x].insert(i); // 票数为x的奶牛多了奶牛i这头
    // 更新票数为x的奶牛坐标最值
    mxi[x] = max(mxi[x], i);
    mni[x] = min(mni[x], i);
    // 若x为此票数第一个，则还需更新S
    if (id[x].size() == 1) S.insert(x);
}
// i 的得票不再是 x 了
void delc(int i, int x)
{
    if (!x) return; // 若此奶牛无票则不需要处理
    // 票数为x的奶牛里不再有奶牛i了
    id[x].erase(i);
    // 如果这种票数的奶牛没了
    if (id[x].empty()) {
        S.erase(x); // 维护 S
        mxi[x] = 0; // 重置最大值至0
        mni[x] = n + 1; // 重置最小值至无限大
    }
    // 如果这种奶牛的票数还有，则根据set更新最大最小
    else {
        mxi[x] = *(--id[x].end());
        mni[x] = *id[x].begin();
    }
}
signed main()
{
    freopen("election.in", "r", stdin);
    freopen("election.out", "w", stdout);
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> q;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        ++cnt[a[i]];
        mxi[i] = 0;
        mni[i] = n + 1;
    }
    for (int i = 1; i <= n; ++i) addc(i, cnt[i]);
    while (q--) {
        int i;
        cin >> i;
        /*
        修改过程分为2×2步：
        I: 处理a[i]->a[i]-1的过程(奶牛i原来投给的奶牛)
        I.1 把a[i]的信息删除
        I.2 添加a[i]-1的信息
        II: 处理a[i]'->a[i]'+1的过程(奶牛i更改后投给的奶牛)
        II.1 把a[i]'的信息删除
        II.2 添加a[i]'+1的信息
        */
        delc(a[i], cnt[a[i]]--);
        addc(a[i], cnt[a[i]]);
        cin >> a[i];
        delc(a[i], cnt[a[i]]++);
        addc(a[i], cnt[a[i]]);


        // 最难懂的，也是题解描述最含糊的滑动数组原理
        int maxvote = *(--S.end());   // 最大票数值
        int mxidx = 0, mnidx = n + 1;   // 可以与当前奶牛匹配的最大与最小奶牛编号
        int ans = 0;                // 最大差异
        /* 入选要求：cnt[x]+cnt[y]>=最大票数值 */

        // 特判最小票数值满足入选要求
        if (*S.begin() + *S.begin() >= maxvote)
            ans = mxi[*S.begin()] - mni[*S.begin()]; // 注意这里后式不可能是负的，不需要max

        // 双指针
        set<int>::iterator itl = S.begin(); // 从小到大遍历票数值
        set<int>::iterator itr = --S.end(); // 从大到小遍历票数值
        for (; itl != S.end(); ++itl) {
            /*
            FAQ: itr会不断减小，每种票数值只遍历一次，会不会影响后续？
            ANS: 不会。因为随着itl变大，必然保证它能与前面的itl'符合入选条件的itr匹配，
                 因此可以直接不断更新mx/mn idx
            */
            while (itr != S.begin() && (*itr) + (*itl) >= maxvote) { // 符合入选条件
                // 更新可以和票数值为itl的奶牛匹配的奶牛的编号最值
                mxidx = max(mxidx, mxi[*itr]);
                mnidx = min(mnidx, mni[*itr]);
                --itr;
            }
            ans = max(ans, max(mxidx - mni[*itl], mxi[*itl] - mnidx));
        }

        // 输出最大差值
        cout << ans << '\n';
    }
    return 0;
}