BZOJ 4198: [Noi2015]荷马史诗 Huffman Tree

title

追逐影子的人，自己就是影子。 ——荷马
Allison 最近迷上了文学。她喜欢在一个慵懒的午后，细细地品上一杯卡布奇诺，静静地阅读她爱不释手的《荷马史诗》。但是由《奥德赛》和《伊利亚特》组成的鸿篇巨制《荷马史诗》实在是太长了，Allison 想通过一种编码方式使得它变得短一些。
一部《荷马史诗》中有 n 种不同的单词，从 1 到 n 进行编号。其中第 i 种单词出现的总次数为 wi。Allison 想要用 k 进制串 si 来替换第 i 种单词，使得其满足如下要求:
对于任意的 1≤i,j≤n，i≠j，都有：si 不是 sj 的前缀。
现在 Allison 想要知道，如何选择 si，才能使替换以后得到的新的《荷马史诗》长度最小。在确保总长度最小的情况下，Allison 还想知道最长的 si 的最短长度是多少？
一个字符串被称为 k 进制字符串，当且仅当它的每个字符是 0 到 k−1 之间（包括 0 和 k−1）的整数。
字符串 Str1 被称为字符串 Str2 的前缀，当且仅当：存在 1≤t≤m，使得 Str1=Str2[1…t]。其中，m 是字符串 Str2 的长度，Str2[1…t] 表示 Str2 的前 t 个字符组成的字符串。

Input

输入文件的第 1 行包含 2 个正整数 n,k，中间用单个空格隔开，表示共有 n 种单词，需要使用 k 进制字符串进行替换。
接下来 n 行，第 i+1 行包含 1 个非负整数 wi，表示第 i 种单词的出现次数。

Output

输出文件包括 2 行。
第 1 行输出 1 个整数，为《荷马史诗》经过重新编码以后的最短长度。
第 2 行输出 1 个整数，为保证最短总长度的情况下，最长字符串 si 的最短长度。

Sample Input

4 2
1
1
2
2

Sample Output

12
2

HINT

用 X(k) 表示 X 是以 k 进制表示的字符串。
一种最优方案：令 00(2) 替换第 1 种单词，01(2) 替换第 2 种单词，10(2) 替换第 3 种单词，11(2) 替换第 4 种单词。在这种方案下，编码以后的最短长度为：
1×2+1×2+2×2+2×2=12
最长字符串 si 的长度为 2。
一种非最优方案：令 000(2) 替换第 1 种单词，001(2) 替换第 2 种单词，01(2) 替换第 3 种单词，1(2) 替换第 4 种单词。在这种方案下，编码以后的最短长度为：
1×3+1×3+2×2+2×1=12
最长字符串 si 的长度为 3。与最优方案相比，文章的长度相同，但是最长字符串的长度更长一些。
对于所有数据，保证 2≤n≤100000，2≤k≤9。
选手请注意使用 64 位整数进行输入输出、存储和计算。

analysis

原来曾经难倒了黄学长的哈夫曼树题是荷马史诗啊。。

先来说一下什么叫哈夫曼树。

哈夫曼树一般是二叉树，建树的方法就是每次选择两个权值（即出现次数）最小的点，删除这 2 个点，加入一个权值是这两个点之和的新点进去。并且使这被删除的 2 个点的父亲成为那个新点。
编码的时候左支和右支一个是 1 一个是 0 ，从根节点到叶子节点经过的边的 1/0 序列就是叶子节点对应的编码。

想要一个简单哈夫曼树例子的童鞋，可以到Tyouchie哪里看一下。

然而这个题是 $k$ 叉树，方法和上面类似，然而每次选择 $k$ 个权值最小的点的时候容易让最后一次合并的时候的点不足 $k$ 个。假设最初有 $n$ 个点，最后有 1 个点，每次合并删除 $k$ 个点又放进 1 个点。那么易得： $（n-1）$ 是 $（k-1）$ 的倍数。如果 $（n-1）%（k-1）！=0$ ，那么就要再放入 $（k-1-（n-1）%（k-1））$ 个虚拟点，并且它们的权值为 0 ，它们也参与求最小 $k$ 个点。

然而此题还要求 $s_i$ 的最大值最小，因此我们让点代表一个二元组 $（val，dep）$ ，表示这个点的权值和点在树中的深度。在求最小 $k$ 个点时，把 $val$ 作为第一比较条件，如果 $val$ 值相等，则把 $dep$ 小的放在前面，这样在每次合并的时候，深度小的点都会被优先合并，保证了根到叶子的最长链的长度尽量小。

所以，可以得到此题的算法：

处理这 $n$ 个权值，加入虚拟点，这些点的 $val$ 值上文已经告诉， $dep$ 值为 $0$ ， $ans=0$ ；
每次取出前 $k$ 小的点，求它们的 $val$ 之和 $sum4，求它们的 $dep$ 的最大值 $d$ ，那么放入的新点应该是 $（sum，d+1）$ ，把它放入原来的容器里面并要求有序，且 $ans+=sum$ （画一棵哈夫曼树，想想求文章长度的过程能这么实现的原理）；
当容器内只有一个点时，输出 $ans$ 和这个点的 $dep$ 值。

这样的话正确性可以保证，但是注意容器的选择，不能直接数组模拟，会超时，可以用堆优化，用的优先队列，和堆差不多，这样维护点的有序性变成 $O（log n）$ 。求前 $k$ 大的数也不用什么高级的数据结构，考虑 $k$ 不大，就优先队列一个一个弹出，弹 $k$ 次就可以了。

最终时间复杂度是 $O（nlogn）$ 。

参考资料：
morestep。
SaltyFishWei。

code

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pii;

char buf[1<<15],*fs,*ft;
inline char getc() { return (ft==fs&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),ft==fs))?0:*fs++; }
template<typename T>inline void read(T &x)
{
    x=0;
    T f=1, ch=getchar();
    while (!isdigit(ch) && ch^'-') ch=getchar();
    if (ch=='-') f=-1, ch=getchar();
    while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
    x*=f;
}

template<typename T>inline void write(T x)
{
    if (!x) { putchar('0'); return ; }
    if (x<0) putchar('-'), x=-x;
    T num=0, ch[20];
    while (x) ch[++num]=x%10+48,x/=10;
    while (num) putchar(ch[num--]);
}

priority_queue<pii,vector<pii>,greater<pii> >q;
int main()
{
    int n,k; ll x;
    read(n);read(k);
    for (int i=1; i<=n; ++i) read(x),q.push(make_pair(x,0));
    while ((n-1)%(k-1)) q.push(make_pair(0,0)),++n;

    ll ans=0;
    while (q.size()>1)
    {
        int dep=0;
        ll s=0;
        for (int i=1; i<=k; ++i)
        {
            pii t=q.top();
            q.pop();
            s+=t.first;
            dep=max(dep,t.second);
        }
        ans+=s;
        q.push(make_pair(s,dep+1));
    }
    
    write(ans),puts("");
    write(q.top().second);
    return 0;
}