ACWING 133 蚯蚓

https://www.acwing.com/problem/content/135

题意

给定一些蚯蚓，每秒挑选一根最长的蚯蚓斩断。
斩断后，这一根长度为$x$的蚯蚓将变成两根长度分别为$\lfloor pX\rfloor$和$X-\lfloor pX\rfloor$的蚯蚓，同时其他蚯蚓的长度将会增加一个非负整数$q$。
求$m$秒内每一根被切断的蚯蚓被切断前的长度，以及$m$秒后所有蚯蚓的长度。

思路

由于每一轮未被切割的蚯蚓，其长度都要加上$p$，所以不妨记录蚯蚓的原长度以及增加的偏移量。（即真实长度为原长度+偏移量），其中每一轮都有偏移量$\Delta =\Delta +p$。

而对于被切断的蚯蚓，其长度并不增长。我们可以考虑将其长度减去$p$，然后认为对所有蚯蚓长度增加$p$即可。

因此，我们有如下流程

1. 初始情况下,$\Delta =0$，代表尚没有切割过一条蚯蚓，蚯蚓的长度也没有增长。
2. 每一秒，取出原长为$X_{original}$，真实长度为$X_{real}=X_{original}+\Delta$的一条蚯蚓，将其切分为$\lfloor p{X}_{real}\rfloor$和$X_{real}-\lfloor p{X}_{real}\rfloor$的两条。
3. $\Delta =\Delta +p$，代表其他蚯蚓的长度又增加了$p$。
   此处的顺序和算法竞赛进阶指南上略有区别，与yxc的代码一致。
4. 此时，$\lfloor p{X}_{real}\rfloor$和$X_{real}-\lfloor p{X}_{real}\rfloor$代表的是两条蚯蚓的真实长度，但是我们需要记录的是和真实长度相差$\Delta$的相对长度，所以我们将放回集合的两条蚯蚓的长度是$\lfloor p{X}_{real}\rfloor -\Delta$和$X_{real}-\lfloor p{X}_{real}\rfloor -\Delta$

基于这些结论，我们还可以进一步对算法进行改进。

接下来，我们要证明这样一个性质：
对于两条长度分别为$X_1$，$X_2$的蚯蚓，在$T$时刻$X_1$被切割，而在$T$时刻之后$X_2$被切割。则它们都被切割之后，必定有$X_1$切割产生的两条蚯蚓不短于$X_2$切割产生的两条蚯蚓。

以下较简略，详见蓝皮书和yxc的视频。

对于$\lfloor pX\rfloor$一段，有

$$\lfloor p{X}_1\rfloor +q=\lfloor p{X}_1+q\rfloor \ge \lfloor p(X_2+q)\rfloor$$
这证明了对于被切割成$pX$的一段蚯蚓，若$X_1$先于$X_2$被切割，则有$X_1$切割产生的不短于$X_2$切割产生的。

同理对于$X-\lfloor pX\rfloor$一段，有

$$X_1-\lfloor p{X}_1\rfloor +q\ge X_2+q-\lfloor p(X_2+q)\rfloor$$

因此，我们可以利用单调性维护最长的蚯蚓，也就是取单调队列的队首元素。

#include <iostream>
#include <queue>
#include <algorithm>
typedef long long ll;
using namespace std;
const int N = 100010;
const int M = 7000010;
int n;       // n只蚯蚓
int m;       // m秒时间
int q;       // 增加长度非负整数q
int u, v, t; // p=u/v,每t秒输出最长蚯蚓
int q1[N];
int q2[M], q3[M];
int delta;
int tt1;
int tt2 = -1, tt3 = -1;
int hh1, hh2, hh3;

int get_max()
{
    int x = -2e9;
    if (hh1 <= tt1)
        x = max(x, q1[hh1]);
    if (hh2 <= tt2)
        x = max(x, q2[hh2]);
    if (hh3 <= tt3)
        x = max(x, q3[hh3]);
    if (hh1 <= tt1 && x == q1[hh1])
        hh1++;
    else if (hh2 <= tt2 && x == q2[hh2])
        hh2++;
    else
        hh3++;
    return x;
}

int main()
{
    cin >> n >> m >> q >> u >> v >> t;
    for (int i = 0; i < n; i++)
        cin >> q1[i];
    sort(q1, q1 + n);
    reverse(q1, q1 + n);
    tt1 = n - 1;
    for (int i = 1; i <= m; i++)
    { // m秒，每秒一次切割
        int x = get_max();
        x += delta;
        if (i % t == 0)
            cout << x << ' ';       // 每t秒输出一次
        int left = x * 1ll * u / v; //(p=u/v)
        int right = x - left;
        delta += q;
        left -= delta;
        right -= delta;
        q2[++tt2] = left;
        q3[++tt3] = right;
    }
    cout << endl;
    for (int i = 1; i <= n + m; i++)
    {
        int x = get_max();
        if (i % t == 0)
            cout << x + delta << ' ';
    }
    cout << endl;
    return 0;
}