算法竞赛进阶指南-47.蚯蚓

题目链接

算法竞赛进阶指南-47.蚯蚓

蛐蛐国最近蚯蚓成灾了！

隔壁跳蚤国的跳蚤也拿蚯蚓们没办法，蛐蛐国王只好去请神刀手来帮他们消灭蚯蚓。

蛐蛐国里现在共有 nn 只蚯蚓，第 ii 只蚯蚓的长度为 aia_i ，所有蚯蚓的长度都是非负整数，即可能存在长度为 00 的蚯蚓。

每一秒，神刀手会在所有的蚯蚓中，准确地找到最长的那一只，将其切成两段。

若有多只最长的，则任选一只。

神刀手切开蚯蚓的位置由有理数 pp 决定。

一只长度为 xx 的蚯蚓会被切成两只长度分别为 ⌊px⌋\lfloor px \rfloor 和 x−⌊px⌋x - \lfloor px \rfloor 的蚯蚓。

特殊地，如果这两个数的其中一个等于 00，则这个长度为 00 的蚯蚓也会被保留。

此外，除了刚刚产生的两只新蚯蚓，其余蚯蚓的长度都会增加一个非负整数 qq。

蛐蛐国王知道这样不是长久之计，因为蚯蚓不仅会越来越多，还会越来越长。

蛐蛐国王决定求助于一位有着洪荒之力的神秘人物，但是救兵还需要 mm 秒才能到来。

蛐蛐国王希望知道这 mm 秒内的战况。

具体来说，他希望知道：

  1. mm 秒内，每一秒被切断的蚯蚓被切断前的长度，共有 mm 个数。
  2. mm 秒后，所有蚯蚓的长度，共有 n+mn+m 个数。

输入格式

第一行包含六个整数 n,m,q,u,v,tn,m,q,u,v,t，其中：n,m,qn,m,q 的意义参考题目描述；u,v,tu,v,t 均为正整数；你需要自己计算 p=u/vp=u/v（保证 0<u<v0<u<v）；tt 是输出参数，其含义将会在输出格式中解释。

第二行包含 nn 个非负整数，为 a1,a2,…,ana_1,a_2,…,a_n，即初始时 nn 只蚯蚓的长度。

同一行中相邻的两个数之间，恰好用一个空格隔开。

输出格式

第一行输出 ⌊m/t⌋⌊m/t⌋ 个整数，按时间顺序，依次输出第 tt 秒，第 2t2t 秒，第 3t3t 秒，……被切断蚯蚓（在被切断前）的长度。

第二行输出 ⌊(n+m)/t⌋⌊(n+m)/t⌋ 个整数，输出 mm 秒后蚯蚓的长度；需要按从大到小的顺序，依次输出排名第 tt，第 $ 2t $，第 3t3t，……的长度。

同一行中相邻的两个数之间，恰好用一个空格隔开。

即使某一行没有任何数需要输出，你也应输出一个空行。

请阅读样例来更好地理解这个格式。

数据范围

1≤n≤1051 \le n \le 10^5,
0≤ai≤1080 \le a_i \le 10^8,
0<p<10 < p < 1,
0≤q≤2000 \le q \le 200,
0≤m≤7∗1060 \le m \le 7*10^6,
0<u<v≤1090 < u < v \le 10^9,
1≤t≤711 \le t \le 71

输入样例：

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

样例解释

样例中，在神刀手到来前：33 只蚯蚓的长度为 3,3,23,3,2。

11 秒后：一只长度为 33 的蚯蚓被切成了两只长度分别为 11 和 22 的蚯蚓，其余蚯蚓的长度增加了 11。最终 44 只蚯蚓的长度分别为 (1,2),4,3(1,2),4,3。 括号表示这个位置刚刚有一只蚯蚓被切断。

22 秒后：一只长度为 44 的蚯蚓被切成了 11 和 33。55 只蚯蚓的长度分别为：2,3,(1,3),42,3,(1,3),4。

33 秒后：一只长度为 44 的蚯蚓被切断。66 只蚯蚓的长度分别为：3,4,2,4,(1,3)3,4,2,4,(1,3)。

44 秒后：一只长度为 44 的蚯蚓被切断。77 只蚯蚓的长度分别为：4,(1,3),3,5,2,44,(1,3),3,5,2,4。

55 秒后：一只长度为 55 的蚯蚓被切断。88 只蚯蚓的长度分别为：5,2,4,4,(1,4),3,55,2,4,4,(1,4),3,5。

66 秒后：一只长度为 55 的蚯蚓被切断。99 只蚯蚓的长度分别为：(1,4),3,5,5,2,5,4,6(1,4),3,5,5,2,5,4,6。

77 秒后：一只长度为 66 的蚯蚓被切断。1010 只蚯蚓的长度分别为：2,5,4,6,6,3,6,5,(2,4)2,5,4,6,6,3,6,5,(2,4)。

所以，77 秒内被切断的蚯蚓的长度依次为 3,4,4,4,5,5,63,4,4,4,5,5,6。

77 秒后，所有蚯蚓长度从大到小排序为 6,6,6,5,5,4,4,3,2,26,6,6,5,5,4,4,3,2,2。

Method1 : 优先队列 (TLE)

一开始想着，这不就优先队列么，但是：每秒后所有蚯蚓都会+q（除了被切的蚯蚓），
这个就很难办:如何维护每秒后的将每只蚯蚓长度+q呢？

或许可以转变思路, 每次只有两只蚯蚓没被加其他的全部被加了, 根据运动是相互的, 除了那被切成的两只蚯蚓其他的都往正方向移动了一些, 等价于那两只往负方向移动了一些.

那么每次取出的时候：

  • 先把蚯蚓长度还原成当前i秒后的长度
  • 再计算切开的两段长度
  • 最后把切开的两段还原回0s时的长度，并且再-q(其它蚯蚓+q，相当于这两只蚯蚓-q)

但是这个时间复杂度是O(mlog⁡n)O(m\log n)的，(7∗106∗[log(105)∗3]7 * 10^6 * [log (10^5) * 3]，再加上其它常数级有可能超过10910^9因此会TLE)

#include <queue>
#include <vector>
#include <iostream>
#include <cmath>

using namespace std;

const int N = 1e5 + 7;

int n, m, q, u, v, t;

int main() {
    cin >> n >> m >> q >> u >> v >> t;
    double p = (double)u / v;
    
    priority_queue<int> pque;
    for (int i = 0; i < n; i ++) {
        int x;
        scanf("%d", &x);
        pque.push(x);
    }
    
    // 关键在于每秒 + q，怎么处理=> 相对处理
    for (int i = 1; i <= m; i ++) {
        auto x = pque.top(); pque.pop();
        x += (i - 1) * q;
        if(i % t == 0)printf("%d ", x);//要求输出的第一行
        int x1 = floor(p * (double)x);
        int x2 = x - x1;
        // 还原
        x1 -= (i - 1) * q; x1 -= q;
        x2 -= (i - 1) * q; x2 -= q; 
        pque.push(x1);
        pque.push(x2);
    }
    puts("");
    for (int i = 1; pque.size() > 0; i ++) {
        if (i % t == 0) {
            printf("%d ", pque.top() + m * q);
        }
        pque.pop();
    }       
    return 0;
}

复杂度分析

  • 时间复杂度：O(mlog⁡n){O(m\log n)}， 其中mm为外层循环次数，log⁡n\log n为维护优先队列的top()。

  • 空间复杂度：O(1){O(1)}。

Method2 :

复杂度分析

  • 时间复杂度：O(m+nlog⁡n){O(m + n\log n)}， 其中mm为外层循环次数，log⁡n\log n为维护优先队列的top()。

  • 空间复杂度：O(1){O(1)}。