【队列】Luogu P2827 [NOIP2016 提高组] 蚯蚓

最新推荐文章于 2024-09-23 20:41:21 发布

o_Invincible_o

最新推荐文章于 2024-09-23 20:41:21 发布

阅读量119

点赞数

分类专栏：数据结构队列文章标签： c++ 算法数据结构

本文链接：https://blog.csdn.net/o_Invincible_o/article/details/125874823

版权

数据结构同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

队列

1 篇文章 0 订阅

订阅专栏

题目描述

本题中，我们将用符号 $\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,\dots,n$ )，并保证所有的长度都是非负整数（即：可能存在长度为 $0$ 的蚯蚓）。

每一秒，神刀手会在所有的蚯蚓中，准确地找到最长的那一只（如有多个则任选一个）将其切成两半。神刀手切开蚯蚓的位置由常数 $p$ （是满足 $0 < p < 1$ 的有理数）决定，设这只蚯蚓长度为 $x$ ，神刀手会将其切成两只长度分别为 $\lfloor px \rfloor$ 和 $\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 = u / v$ （保证 $0 < u < v$ ）； $t$ 是输出参数，其含义将会在【输出格式】中解释。

第二行包含 $n$ 个非负整数，为 $a_1, a_2, \dots, a_n$ ，即初始时 $n$ 只蚯蚓的长度。

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

保证 $\leq n \leq 10^5$ ， $\leq m \leq 7 \times 10^6$ ， $\leq 10^9$ ， $\leq q \leq 200$ ， $\leq t \leq 71$ ， $\leq a_i \leq 10^8$ 。

输出格式

第一行输出 $\left \lfloor \frac{m}{t} \right \rfloor$ 个整数，按时间顺序，依次输出第 $t$ 秒，第 $2 t$ 秒，第 $3 t$ 秒，……被切断蚯蚓（在被切断前）的长度。

第二行输出 $\left \lfloor \frac{n+m}{t} \right \rfloor$ 个整数，输出 $m$ 秒后蚯蚓的长度；需要按从大到小的顺序，依次输出排名第 $t$ ，第 $2 t$ ，第 $3 t$ ，……的长度。

同一行中相邻的两个数之间，恰好用一个空格隔开。即使某一行没有任何数需要输出，你也应输出一个空行。

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

样例 #1

样例输入 #1

3 7 1 1 3 1
3 3 2

样例输出 #1

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

样例 #2

样例输入 #2

3 7 1 1 3 2
3 3 2

样例输出 #2

4 4 5
6 5 4 3 2

样例 #3

样例输入 #3

3 7 1 1 3 9
3 3 2

样例输出 #3

//空行
2

提示

【样例解释1】

在神刀手到来前： $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】

这个数据中只有 $t = 2$ 与上个数据不同。只需在每行都改为每两个数输出一个数即可。

虽然第一行最后有一个 $6$ 没有被输出，但是第二行仍然要重新从第二个数再开始输出。

【样例解释3】

这个数据中只有 $t = 9$ 与上个数据不同。

注意第一行没有数要输出，但也要输出一个空行。

【数据范围】

Solution

容易想到一种做法，每次产生了两个数 $\lfloor px\rfloor$ 和 $x-\lfloor px \rfloor$ 不作 $+ q$ 处理，可看作产生了两个值为 $\lfloor px \rfloor - q$ 和 $\lfloor px \rfloor -q$ 的数，并把整个集合 $+ q$ 。

所以我们用一个变量 $d e lt a$ 存储整个集合的变化量，利用大根堆，每一秒的操作为：

取出堆顶最大值 $x$ ，加上变化量 $d e lt a$
将新增的两个数值 $\lfloor px \rfloor-delta-q$ 和 $x-\lfloor px\rfloor-delta-q$ 加入堆中
将变化量更新， $d e lt a = d e lt a + q$

算法时间复杂度 $O(m\log n)$ ，但 $\le 7*10^6$ 可能会超时，因此进行优化：

考虑被先后取出的两个数 $x_1, x_2$ ，可知 $x_1\ge x_2$ ，又 $0 < p < 1$ ，则在 $x_2$ 被取出时有

$\lfloor px_1\rfloor+q=\lfloor px_1+q\rfloor\ge\lfloor px_2+pq\rfloor=\lfloor p(x_2+q)\rfloor$
又有 $x_1-x_2 \ge p(x_1-x_2)$ ，即 $x_1-px_1\ge x_2-px_2\ge x_2-p(x_2+q)$ ，则有

$x_1-\lfloor px_1\rfloor+q=\lfloor x_1-px_1+q\rfloor\ge\lfloor x_2-p(x_2+q)+q\rfloor=x_2+q-\lfloor p(x_2+q)\rfloor$

所以，每次取出一个数分割成的两个数分别是递减的，而我们从原来的集合中取出的数也应是递减的，因此就有了如下算法：

构造三个队列 $A, B, C$ ，分别存储原集合（降序排列），每次产生的 $\lfloor px\rfloor$ 的值，每次产生的 $x-\lfloor px\rfloor$ 的值，则由于刚才证明的降序的性质，每一秒的最大值就是 $A, B, C$ 的队头的最大值，之后再将本次新增的两个值加入 $B, C$ 队列。

再结合开头提到的 $d e lt a$ ，故每次加入队列 $B, C$ 的数要换为 $\lfloor px \rfloor - q$ 和 $\lfloor px \rfloor -q$ ，取出时再加上 $d e lt a$ 即可。

Code

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int N = 1e5 + 5, M = 7e6 + 5;

int n, m, q, u, v, t;
int A[N], B[M], C[M];
int ha, hb, hc, ta, tb, tc;
int delta;

int get_max()
{
	int x = -1e9;
	if(ha <= ta) x = max(x, A[ha]);
	if(hb <= tb) x = max(x, B[hb]);
	if(hc <= tc) x = max(x, C[hc]);
	if(ha <= ta && x == A[ha]) ha ++ ;
	else if(hb <= tb && x == B[hb]) hb ++ ;
	else if(hc <= tc && x == C[hc]) hc ++ ;
	return x;
} 

int main()
{
	scanf("%d%d%d%d%d%d", &n, &m, &q, &u, &v, &t);
	for(register int i = 1; i <= n; i ++ ) scanf("%d", &A[i]);
	sort(A + 1, A + 1 + n, greater<int>());
	ha = hb = hc = 1; ta = n;
	for(register int i = 1; i <= m; i ++ )
	{
		int x = get_max() + delta;
		if(i % t == 0) printf("%d ", x);
		int k = (long long) x * u / v;
		delta += q;
		B[++tb] = k - delta;
		C[++tc] = x - k - delta; 
	}
	puts(""); 
	for(register int i = 1; i <= n + m; i ++ )
	{
		int x = get_max() + delta;
		if(i % t == 0) printf("%d ", x);
	}
	puts("");
	return 0;
}