《算法竞赛进阶指南》蚯蚓

蛐蛐国最近蚯蚓成灾了！

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

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

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

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

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

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

特殊地，如果这两个数的其中一个等于 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,…,ana1,a2,…,an，即初始时 nn 只蚯蚓的长度。

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

输出格式

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

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

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

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

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

数据范围

1≤n≤1051≤n≤105,
0≤ai≤1080≤ai≤108,
0<p<10<p<1,
0≤q≤2000≤q≤200,
0≤m≤7∗1060≤m≤7∗106,
0<u<v≤1090<u<v≤109,
1≤t≤711≤t≤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。

解题思路：

1：记录一个偏移量
{
    因为每隔特定的时间每个蚯蚓的长度都发生相同的变化，
    所以每次蚯蚓成长后的长度大小不变
    因此我们不需要记录每次蚯蚓的长度只需要记录其原始长度，
    每次从原始长度以及被切成两段的蚯蚓中选择一个最大值即可
} 

2：证明左右端最大性
{
    1：建立三个队列q1, q2, q3；
    {
        1：q1为所有蚯蚓的原始长度；
        2：q2为每次蚯蚓被切之后的左半段；
        3：q3为每次蚯蚓被切之后的右半段；
    }
    2：将q1从大到小排列：
    {
        先证明一个性质:若x1 >= x2则在后面不管何时x1被切成的左右端，大于x2被切成的左右端
        先证明左半段：
        {
            假设x1在第一秒被切则x1的左半段为[x1 * p](方括号表示下取整)
            假设t秒后x2的偏移量为c则在第t秒后x2的左半段为[p * x2 + c]然后减去偏移量c
            即x2的左半段长度为[p * x2 + c] - c;
            所以现在只需要证明[x1 * p] >= [p * x2 + c] - c;
            即[x1 * p] + c >= [p * x2 + c](这里有一个性质：若c是整数则[x1 * p] + c可以写为[x1 * p + c])
            即[x1 * p + c] >= [p * x2 + c];(由于下取整具有单调性，所以下取整可以去掉)
            即x1 * p + c >= p * x2 + c;
            即x1 * p >= x2 * p
            因为x1 >= x2所以得出结论：
            若x1 >= x2则在后面不管何时x1被切成的左端，大于x2被切成的左端
        }
        再证明右端：
        {
            假设x1在第一秒被切则x1的右半段为x1 - [x1 * p](方括号表示下取整)
            假设t秒后x2的偏移量为c则在第t秒后x2的右半段为x2 + c - [p * x2 + c]然后减去偏移量c
            即为x2 + c - [p * x2 + c] - c;
            所以现在只需要证明x1 - [x1 * p] >= x2 + c - [p * x2 + c] - c即可
            将不等式整理得：x1 - [x1 * p] >= x2 - [p * x2 + c]
            将不等式左边放缩：x1 - [x1 * p] >= x1 - [x1 * p + c];
            所以不等式可变为：x1 - [x1 * p + c] >= x2 - [p * x2 + c]（由于下取整具有单调性，所以下取整可以直接去掉）
            整理后即：p <= 0
            又因为0 < p < 1所以：
            若x1 >= x2则在后面不管何时x1被切成的右端，大于x2被切成的右端
        }
        
        结论：只要先将q1从大到小排序那么他的左右端也是在整个左右端得序列中最大的
    } 

3：合并
{
    由上述证明可知依次找出左端，右端，原序列中三个队列中最大的蚯蚓将他按比例切为两段
    切出的左半段放入q2的队尾，右半段放入q3的队尾
    为何放入队尾？？？
    因为每次都是从大到小枚举的蚯蚓长度由上述证明可知若x1 >= x2的x1切出的的左右端大于x2切出的左右端
    然后因为共有n只蚯蚓，共切了m次每切一次蚯蚓数加一所以最后有n + m只蚯蚓
} 

代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
const int N = 100010, M = 7000010;//共有n只蚯蚓共切m次
 
typedef long long LL;
 
int offset;//偏移量
int q1[N], q2[M], q3[M];
int hh1, hh2, hh3, tt1, tt2 = -1, tt3 = -1;
 
int get_max()//找出长度最大的蚯蚓，并将其删掉
{
    int x = -0x3f3f3f3f;
    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 if (hh3 <= tt3 && x == q3[hh3]) hh3 ++ ;
    
    return x;
}
 
int main()
{
    int n, m, q, u, v, t;
    cin >> n >> m >> q >> u >> v >> t;
    for (int i = 0; i < n; i ++ ) scanf("%d", &q1[i]);
    tt1 = n - 1;//共读入了n个数
    sort(q1, q1 + n);//先从小到大排序
    reverse(q1, q1 + n);//然后翻转即为从大到小排序
    
    for (int i = 1; i <= m; i ++ )
    {
        int x = get_max() + offset;
        
        if (i % t == 0) printf("%d ", x);//每隔t秒输出最大的蚯蚓长度
        
        int left = (LL)x * u / v, right = x - left;
        
        offset += q;//被切的这次蚯蚓长度不增长，所以要减去第i秒生长的长度q;
        left -= offset, right -= offset;
        q2[++ tt2] = left, q3[++ tt3] = right;
    }
    
    puts("");
    
    for (int i = 1; i <= m + n; i ++ )
    {
        int x = get_max();
        if (i % t == 0) printf("%d ", x + offset);//加上偏移量
    }
    
    puts("");
    
    return 0;
}