NC16430 [NOIP2016]蚯蚓

题目

题目描述

本题中，我们将用符号 $\lfloor c \rfloor$ 表示对 c 向下取整，例如：$\lfloor 3.0 \rfloor = \lfloor 3.1 \rfloor = \lfloor 3.9 \rfloor = 3$ 。
蛐蛐国最近蚯蚓成灾了！隔壁跳蚤国的跳蚤也拿蚯蚓们没办法，蛐蛐国王只好去请神刀手来帮他们消灭蚯蚓。
蛐蛐国里现在共有 n 只蚯蚓（n 为正整数）。每只蚯蚓拥有长度，我们设第 i 只蚯蚓的长度为 $a_i (i = 1, 2, \ldots , n)$，并保证所有的长度都是非负整数（即：可能存在长度为 0 的蚯蚓）。
每一秒，神刀手会在所有的蚯蚓中，准确地找到最长的那一只（如有多个则任选一个）将其切成两半。神刀手切开蚯蚓的位置由常数 p（是满足 0 < p < 1 的有理数）决定，设这只蚯蚓长度为 x，神刀手会将其切成两只长度分别为 $\lfloor px \rfloor$ 和 $x - \lfloor px \rfloor$ 的蚯蚓。特殊地，如果这两个数的其中一个等于 0，则这个长度为 0 的蚯蚓也会被保留。此外，除了刚刚产生的两只新蚯蚓，其余蚯蚓的长度都会增加 q（是一个非负整常数）。
蛐蛐国王知道这样不是长久之计，因为蚯蚓不仅会越来越多，还会越来越长。蛐蛐国王决定求助于一位有着洪荒之力的神秘人物，但是救兵还需要 m 秒才能到来 ……（m 为非负整数）
蛐蛐国王希望知道这 m 秒内的战况。具体来说，他希望知道：

·m 秒内，每一秒被切断的蚯蚓被切断前的长度（有 m 个数）；

·m 秒后，所有蚯蚓的长度（有 n + m 个数）。

蛐蛐国王当然知道怎么做啦！但是他想考考你 ……

输入描述

第一行包含六个整数 n，m，q，u，v，t，其中：n，m，q 的意义见「题目描述」；u，v，t 均为正整数，你需要自己计算 $p = \frac{u}{v}$（保证 0 < u < v）；t 是输出参数，其含义将会在「输出描述」中解释。
第二行包含 n 个非负整数，为 a1, a2, ..., an，即初始时 n 只蚯蚓的长度。
同一行中相邻的两个数之间，恰好用一个空格隔开。
保证 $1 ≤ n ≤ 10^5，0 < m < 7 x 10^6，0 < u < v < 10^9，0 ≤ q ≤ 200，1 < t < 71，0 < a_i < 10^8$。

输出描述

第一行输出 $\lfloor \frac{m}{t} \rfloor$ 个整数，按时间顺序，依次输出第 t 秒，第 2t 秒，第 3t 秒 …… 被切断蚯蚓（在被切断前）的长度。
第二行输出 $\lfloor \frac{(n+m)}{t} \rfloor$个整数，输出 m 秒后蚯蚓的长度；需要按从大到小的顺序，依次输出排名第 t，第 2t，第 3t …… 的长度。
同一行中相邻的两个数之间，恰好用一个空格隔开。即使某一行没有任何数需要输出，你也应输出一个空行。
请阅读样例来更好地理解这个格式。

示例1

输入

3 7 1 1 3 1
3 3 2

输出

3 4 4 4 5 5 6
6 6 6 5 5 4 4 3 2 2

说明

在神刀手到来前：3 只蚯蚓的长度为 3, 3, 2。
1 秒后：一只长度为 3 的蚯蚓被切成了两只长度分别为 1 和 2 的蚯蚓，其余蚯蚓的长度增加了 1。最终 4 只蚯蚓的长度分别为 (1, 2), 4, 3。括号表示这个位置刚刚有一只蚯蚓被切断；
2 秒后：一只长度为 4 的蚯蚓被切成了 1 和 3。5 只蚯蚓的长度分别为：2, 3, (1, 3), 4；
3 秒后：一只长度为 4 的蚯蚓被切断。6 只蚯蚓的长度分别为：3, 4, 2, 4, (1, 3)；
4 秒后：一只长度为 4 的蚯蚓被切断。7 只蚯蚓的长度分别为：4, (1, 3), 3, 5, 2, 4；
5 秒后：一只长度为 5 的蚯蚓被切断。8 只蚯蚓的长度分别为：5, 2, 4, 4, (1, 4), 3, 5；
6 秒后：一只长度为 5 的蚯蚓被切断。9 只蚯蚓的长度分别为：(1, 4), 3, 5, 5, 2, 5, 4, 6；
7 秒后：一只长度为 6 的蚯蚓被切断。10 只蚯蚓的长度分别为：2, 5, 4, 6, 6, 3, 6, 5, (2, 4)。所以，7 秒内被切断的蚯蚓的长度依次为 3, 4, 4, 4, 5, 5, 6。7 秒后，所有蚯蚓长度从大到小排序为 6, 6, 6, 5, 5, 4, 4, 3, 2, 2。

示例2

输入

3 7 1 1 3 2
3 3 2

输出

4 4 5
6 5 4 3 2

说明

这个数据中只有 t = 2 与上个数据不同。只需在每行都改为每两个数输出一个数即可。
虽然第一行最后有一个 6 没有被输出，但是第二行仍然要重新从第二个数再开始输出。

备注

$1 ≤ n ≤ 10^5, 0 ≤ m ≤ 7 \times 10^6, 1 ≤ t ≤ 71, 0 ≤ a_i ≤ 10^8, 1 ≤ v ≤ 10^9, 0 ≤ q ≤ 200$

题解

知识点：队列。

这道题用优先队列会被卡，而用队列即可维护单调性，不需要优先队列。

首先按从大到小排序，设置一个队列存放原来的蚯蚓，两个队列分别存放分割的两部分。由于分割比例相同，而蚯蚓是从大到小选的，则分割的两部分一定能各自递减排列，只需要分别放入两个新队列的队尾即可。

每次三个队列队头找最大值，为了方便标记，一开始用队列数组创建三个队列，先从三个队列中找到任意一个非空队列标记上，然后再在三个队列中找到非空队列的队头最大值并标记，随后就得到了最大的队头所在队列的下标。

因为每次所有蚯蚓，除了这次分割的蚯蚓，都长度增加 $q$ ，一个一个加显然不合理，注意到 $q$ 和时间有关，那么如果当前时间是第 $i$ 秒蚯蚓原长是 $len$，假设蚯蚓没有切割过，那么长度就为 $len + (i-1)q$ ，$i-1$ 是因为第 $i$ 秒只长了 $i-1$ 秒，第 $i$ 秒后才是 $i$ 。

现在考虑分割的蚯蚓如何计算，因为分割需要用真实长度，因此必须先计算出真实长度 $x$ ，然后计算出新蚯蚓长度 $l = \lfloor x\cdot \frac{u}{v} \rfloor$ ，$r = l - x$ ，前者可以不用浮点运算，先计算 $xu$ 再整除 $v$ ，记得开 $long \ long$ ，如此得到新蚯蚓的真实长度。但是，真实长度是不兼容我们对新增长度的优化的，因为如此新蚯蚓的增长时间就不一样了，有两种方案：第一种，记录新蚯蚓产生时间是第 $k$ 秒，那么第 $i$ 秒长度就为 $len + (i-1-k)q$ ，并非 $k-1$ 因为新切的蚯蚓在第 $k$ 秒后也是不会增长的，因此实际增长时间要从第 $k+1$ 秒开始计算到之前第 $i$ 秒，一共 $i - k - 1$ 秒；第二种，计算新蚯蚓的假想初始长度，即假设新蚯蚓一开始就存在，求出在第 $i$ 秒后（因为第 $i$ 秒之前切完到第 $i$ 秒后长度不变）增长到这个长度的初始长度，这样就能兼容一开始用当前时间计算长度的方式了，那么假想初始长度就是 $len - i\cdot q$ ，因为增长了 $i$ 秒一共 $i\cdot q$ 的长度。最后把长度分别放入两个新队列里。

因为不是每秒都输出，用一个计数器 $tcnt$，记录下一次输出的时间是 $t$ 的几倍，$i == tcnt \cdot t$ 时输出第 $tcnt \cdot t$ 秒的切割蚯蚓的长度。

最后不用 $sort$ 排序，因为三队列都是有序的，直接归并即可，输出方式同上。

时间复杂度 $O(n \log n +m)$

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
 
using namespace std;
 
int a[100007];
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m, q, u, v, t;
    cin >> n >> m >> q >> u >> v >> t;
 
    for (int i = 0;i < n;i++) cin >> a[i];
    sort(a, a + n, [&](int a, int b) {return a > b;});
 
    queue<int> Q[3];
    for (int i = 0;i < n;i++) Q[0].push(a[i]);
 
    int tcnt = 1;///计时器
    for (int i = 1;i <= m;i++) {///用最初长度加增长长度代表真实长度
        int pos = 0;
        ///找到最大的蚯蚓
        for (int j = 0;j < 3;j++)
            if (!Q[j].empty()) pos = j;
        for (int j = 0;j < 3;j++)
            if (!Q[j].empty() && Q[pos].front() < Q[j].front()) pos = j;
 
        int x = Q[pos].front() + (i - 1) * q;///第i秒的真实长度
        if (i == tcnt * t)cout << x << ' ', tcnt++;
        Q[pos].pop();
        int l = 1LL * x * u / v;///分割后的真实长度
        int r = x - l;
        ///分割的假设最初长度，计算增长长度公式就能统一了
        Q[1].push(l - i * q);///第i秒后长度为l，因此初始长度是 l - i*q
        Q[2].push(r - i * q);///同上
    }
    cout << '\n';
    tcnt = 1;
    for (int i = 1;i <= n + m;i++) {///三路归并
        int pos = 0;
        for (int j = 0;j < 3;j++)
            if (!Q[j].empty()) pos = j;
        for (int j = 0;j < 3;j++)
            if (!Q[j].empty() && Q[pos].front() < Q[j].front()) pos = j;
        if (i == tcnt * t) cout << Q[pos].front() + m * q << ' ', tcnt++;
        Q[pos].pop();
    }
    return 0;
}