P2168 [NOI2015] 荷马史诗
题目背景
追逐影子的人，自己就是影子 ------ 荷马
题目描述
Allison 最近迷上了文学。她喜欢在一个慵懒的午后，细细地品上一杯卡布奇诺，静静地阅读她爱不释手的《荷马史诗》。但是由《奥德赛》和《伊利亚特》 组成的鸿篇巨制《荷马史诗》实在是太长了，Allison 想通过一种编码方式使得它变得短一些。
一部《荷马史诗》中有 nnn 种不同的单词，从 111 到 nnn 进行编号。其中第 iii 种单词出现的总次数为 wiw_iwi。Allison 想要用 kkk 进制串 sis_isi 来替换第 iii 种单词，使得其满足如下要求：
对于任意的 1≤i,j≤n1\leq i, j\leq n1≤i,j≤n ，i≠ji\ne ji=j ，都有：sis_isi 不是 sjs_jsj 的前缀。
现在 Allison 想要知道，如何选择 sis_isi，才能使替换以后得到的新的《荷马史诗》长度最小。在确保总长度最小的情况下，Allison 还想知道最长的 sis_isi 的最短长度是多少？
一个字符串被称为 kkk 进制字符串，当且仅当它的每个字符是 000 到 k−1k-1k−1 之间（包括 000 和 k−1k-1k−1 ）的整数。
字符串 str1str1str1 被称为字符串 str2str2str2 的前缀，当且仅当：存在 1≤t≤m1 \leq t\leq m1≤t≤m ，使得 str1=str2[1..t]str1 = str2[1..t]str1=str2[1..t]。其中，mmm 是字符串 str2str2str2 的长度，str2[1..t]str2[1..t]str2[1..t] 表示 str2str2str2 的前 ttt 个字符组成的字符串。
输入格式
输入的第 111 行包含 222 个正整数 n,kn, kn,k ，中间用单个空格隔开，表示共有 nnn 种单词，需要使用 kkk 进制字符串进行替换。
接下来 nnn 行，第 i+1i + 1i+1 行包含 111 个非负整数 wiw_iwi，表示第 iii 种单词的出现次数。
输出格式
输出包括 222 行。
第 111 行输出 111 个整数，为《荷马史诗》经过重新编码以后的最短长度。
第 222 行输出 111 个整数，为保证最短总长度的情况下，最长字符串 sis_isi 的最短长度。
输入输出样例 #1
输入 #1
4 2
1
1
2
2输出 #1
12
2输入输出样例 #2
输入 #2
6 3
1
1
3
3
9
9输出 #2
36
3说明/提示
【样例解释】
样例 1 解释
用 X(k)X(k)X(k) 表示 XXX 是以 kkk 进制表示的字符串。
一种最优方案：令 00(2)00(2)00(2) 替换第 111 种单词， 01(2)01(2)01(2) 替换第 222 种单词， 10(2)10(2)10(2) 替换第 333 种单词，11(2)11(2)11(2) 替换第 444 种单词。在这种方案下，编码以后的最短长度为：
1×2+1×2+2×2+2×2=121 × 2 + 1 × 2 + 2 × 2 + 2 × 2 = 121×2+1×2+2×2+2×2=12
最长字符串 sis_isi 的长度为 222 。
一种非最优方案：令 000(2)000(2)000(2) 替换第 111 种单词，001(2)001(2)001(2) 替换第 222 种单词，01(2)01(2)01(2) 替换第 333 种单词，1(2)1(2)1(2) 替换第 444 种单词。在这种方案下，编码以后的最短长度为：
1×3+1×3+2×2+2×1=121 × 3 + 1 × 3 + 2 × 2 + 2 × 1 = 121×3+1×3+2×2+2×1=12
最长字符串 sis_isi 的长度为 333 。与最优方案相比，文章的长度相同，但是最长字符串的长度更长一些。
样例 2 解释
一种最优方案：令 000(3)000(3)000(3) 替换第 111 种单词，001(3)001(3)001(3) 替换第 222 种单词，01(3)01(3)01(3) 替换第 333 种单词， 02(3)02(3)02(3) 替换第 444 种单词， 1(3)1(3)1(3) 替换第 555 种单词， 2(3)2(3)2(3) 替换第 666 种单词。
【数据规模与约定】
所有测试数据的范围和特点如下表所示（所有数据均满足 0<wi≤10110 < w_i \leq 10^{11}0<wi≤1011）：
::cute-table{tuack}
| 测试点编号 | nnn 的规模 | kkk 的规模 | 备注 |
|---|---|---|---|
| 111 | n=3n=3n=3 | k=2k=2k=2 | |
| 222 | n=5n=5n=5 | ^ | ^ |
| 333 | n=16n=16n=16 | ^ | 所有 wiw_iwi 均相等 |
| 444 | n=1 000n=1\,000n=1000 | ^ | wiw_iwi 在取值范围内均匀随机 |
| 555 | ^ | ^ | |
| 666 | n=100 000n=100\,000n=100000 | ^ | ^ |
| 777 | ^ | ^ | 所有 wiw_iwi 均相等 |
| 888 | ^ | ^ | |
| 999 | n=7n=7n=7 | k=3k=3k=3 | ^ |
| 101010 | n=16n=16n=16 | ^ | 所有 wiw_iwi 均相等 |
| 111111 | n=1 001n=1\,001n=1001 | ^ | ^ |
| 121212 | n=99 999n=99\,999n=99999 | k=4k=4k=4 | ^ |
| 131313 | n=100 000n=100\,000n=100000 | ^ | ^ |
| 141414 | ^ | ^ | ^ |
| 151515 | n=1 000n=1\,000n=1000 | k=5k=5k=5 | ^ |
| 161616 | n=100 000n=100\,000n=100000 | k=7k=7k=7 | wiw_iwi 在取值范围内均匀随机 |
| 171717 | ^ | ^ | |
| 181818 | ^ | k=8k=8k=8 | wiw_iwi 在取值范围内均匀随机 |
| 191919 | ^ | k=9k=9k=9 | |
| 202020 | ^ | ^ | ^ |
【提示】
选手请注意使用 64 位整数进行输入输出、存储和计算。
【评分方式】
对于每个测试点：
- 若输出文件的第 111 行正确，得到该测试点 40%40\%40% 的分数；
- 若输出文件完全正确，得到该测试点 100%100\%100% 的分数。
solution
类似于哈夫曼编码, 构造一颗 k 叉树，如果节点个数 n = 1 mod (k - 1), 则恰好每个内部节点都有 k 个子节点，否则将多余的部分先合并称一个节点,使得其恰好满足 n = 1 mod (k - 1)。 接下来按照如下方式进行合并：
- 0 初始时所有的节点都是孤立的点，加入到队列中
- 1 从队列中取出最小的 k 个节点，并给它们加一个父节点，父节点的值为它们的和，把父节点加入队列
- 2 重复执行 1 直到所有所有节点构成一颗 k 叉树即可。
代码
cpp
#include <iostream>
#include "bit"
#include "vector"
#include "unordered_set"
#include "unordered_map"
#include "set"
#include "queue"
#include "algorithm"
#include "bitset"
#include "cstring"
#include "cmath"
#include "list"
using namespace std;
/*
* P2168 [NOI2015] 荷马史诗
*
* 思路：类似于哈夫曼编码, 构造一颗 k 叉树，如果节点个数 n = 1 mod (k - 1), 则恰好每个内部节点都有 k 个子节点，
* 某则将多余的部分先合并称一个节点,使得其恰好满足 n = 1 mod (k - 1)。 接下来按照如下方式进行合并：
* 0 初始时所有的节点都是孤立的点，加入到队列中
* 1 从队列中取出最小的 k 个节点，并给它们加一个父节点，父节点的值为它们的和，把父节点加入队列
* 2 重复执行 1 直到所有所有节点构成一颗 k 叉树即可。
*/
typedef long long ll;
const int N = 1e5 + 2;
struct node {
ll x;
int d;
bool operator<(const node &y) const {
if (x != y.x) return x > y.x;
return d > y.d;
}
};
int n, k;
priority_queue<node> q;
int main() {
cin >> n >> k;
int t = (n - 1) % (k - 1) + 1, cnt = 0;
ll ans = 0, x;
for (int i = 1; i <= n; i++) cin >> x, q.push({x, 0});
if (t > 1) {
node u{0, 0};
while (t--) {
auto v = q.top();
u.x += v.x;
q.pop();
}
u.d = 1;
ans += u.x;
q.push(u);
}
while (q.size() > 1) {
node u{0, 0};
for (int i = 0; i < k; i++) {
auto v = q.top();
u.x += v.x;
u.d = max(u.d, v.d + 1);
q.pop();
}
q.push(u);
ans += u.x;
cnt = max(cnt, u.d);
}
cout << ans << endl << cnt << endl;
return 0;
}结果
