《算法竞赛进阶指南》 荷马史诗

追逐影子的人，自己就是影子。 ——荷马

达达最近迷上了文学。

她喜欢在一个慵懒的午后，细细地品上一杯卡布奇诺，静静地阅读她爱不释手的《荷马史诗》。

但是由《奥德赛》和《伊利亚特》组成的鸿篇巨制《荷马史诗》实在是太长了，达达想通过一种编码方式使得它变得短一些。

一部《荷马史诗》中有 nn 种不同的单词，从 11 到 nn 进行编号。其中第 ii 种单词出现的总次数为 wiwi。

达达想要用 kk 进制串 sisi 来替换第 ii 种单词，使得其满足如下要求:

对于任意的 1≤i,j≤n，i≠j1≤i,j≤n，i≠j，都有：sisi 不是 sjsj 的前缀。

现在达达想要知道，如何选择 sisi，才能使替换以后得到的新的《荷马史诗》长度最小。

在确保总长度最小的情况下，达达还想知道最长的 sisi 的最短长度是多少？

一个字符串被称为 kk 进制字符串，当且仅当它的每个字符是 00 到 k−1k−1 之间（包括 00 和 k−1k−1）的整数。

字符串 Str1Str1 被称为字符串 Str2Str2 的前缀，当且仅当：存在 1≤t≤m1≤t≤m，使得 Str1=Str2[1..t]Str1=Str2[1..t]。

其中，mm 是字符串 Str2Str2 的长度，Str2[1..t]Str2[1..t] 表示 Str2Str2 的前 tt 个字符组成的字符串。

注意:请使用 6464 位整数进行输入输出、储存和计算。

输入格式

输入文件的第 11 行包含 22 个正整数 n,kn,k，中间用单个空格隔开，表示共有 nn 种单词，需要使用 kk 进制字符串进行替换。

第 2∼n+12∼n+1 行：第 i+1i+1 行包含 11 个非负整数 wiwi，表示第 ii 种单词的出现次数。

输出格式

输出文件包括 22 行。

第 11 行输出 11 个整数，为《荷马史诗》经过重新编码以后的最短长度。

第 22 行输出 11 个整数，为保证最短总长度的情况下，最长字符串 sisi 的最短长度。

数据范围

2≤n≤1000002≤n≤100000,
2≤k≤92≤k≤9
1≤wi≤10121≤wi≤1012

输入样例：

4 2
1
1
2
2

输出样例：

12
2

题意：有一个 k 叉树，每次合并k个数，不能凑齐k个数的用0补充
条件1：使得最终合并的权值最小
条件2：深度最小： 

1:若要满足第一个条件：
{
    1：将树的权值从小到大排序，先合并权值最小的节点，然后在合并权值较大的节点
    2：若根节点不满足k个数，则把深度最深的点补齐, 其他的点用0填补，这样才满足权值最小
    即需要满足n - m * (k - 1) = 1整理得:
    n - 1 = m * (k - 1)即-> (n - 1) % (k - 1) = 0; (n为总的节点个数, k为每次合并k个数, m是合并得次数)
    这个公式如何得来？？
    因为共有n个节点，合并k个数树得节点就会变为n - (k - 1), 需要合并m次，则n - m * (k - 1),
    最后的1是因为，最后如果根节点所连的数不是k个则需要用深度最深，即权值最小的补齐，所以根节点
    必需满足他的子节点有k个，他的子节点合并后只有一个节点所以n - m * (k - 1) = 1;
} 

2:若要满足第二个条件:两个节点的权值相等则最先合并权值深度最浅的数
{
    1:假设有两个权值一样的节点a, b他们的深度分别
    是x, x + 1则先合并a后的深度是x + 1, 而先合并b后的深度是x + 2我们要求的是最小深度，
    
    2:其次，因为我们是从树的最深的节点开始合并，而深度最深的点影响整个树的深度最大
    原因如图：假设a, b, c权值相等, 若合并a, b, c则树的深度将会变为4,但是若把c移动到
    如图紫色箭头的位置即根节点的下方，则树的深度为3
    
} 

 

 

代码如下：

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

using namespace std;

typedef long long LL;
typedef pair<LL, int> PLI;

int main()
{
    int n, k;
    cin >> n >> k;
    priority_queue<PLI, vector<PLI>, greater<PLI>> heap;//双关键字排序先按权值最小的排序，
                                                        //若权值相同再按深度最小的排序
    for (int i = 0; i < n; i ++ )
    {
        LL x;
        scanf("%lld", &x);
        heap.push({x, 0});//初始时的深度都为0
    }
    
    while ((n - 1) % (k - 1)) //确保根节点有k个数可配对
    {
        heap.push({0, 0});
        n ++ ;
    }
    
    LL res = 0;
    while (heap.size() > 1)
    {
        LL s = 0;
        int depth = 0;
        for (int i = 0; i < k; i ++ )//每次合并k个子节点
        {
            auto t = heap.top();
            heap.pop();
            depth = max(depth, t.second + 1);
            s += t.first;
        }
        
        res += s;//将所有子节点权值记录
        heap.push({s, depth});//将子节点的和合并构成一个根节点。
    }
    
    cout << res << endl << heap.top().second << endl;
    
    return 0;
}