第九次CCF 压缩编码

问题描述 　　给定一段文字，已知单词 a 1,  a 2, …,  an出现的频率分别 t 1,  t 2, …,  tn。可以用01串给这些单词编码，即将每个单词与一个01串对应，使得任何一个单词的编码（对应的01串）不是另一个单词编码的前缀，这种编码称为前缀码。 　　使用前缀码编码一段文字是指将这段文字中的每个单词依次对应到其编码。一段文字经过前缀编码后的长度为： 　　 L= a 1的编码长度× t 1+ a 2的编码长度× t 2+…+  an的编码长度× tn。 　　定义一个前缀编码为字典序编码，指对于1 ≤  i <  n， ai的编码（对应的01串）的字典序在 ai +1编码之前，即 a 1, a 2, …,  an的编码是按字典序升序排列的。 　　例如，文字E A E C D E B C C E C B D B E中， 5个单词A、B、C、D、E出现的频率分别为1, 3, 4, 2, 5，则一种可行的编码方案是A:000, B:001, C:01, D:10, E:11，对应的编码后的01串为1100011011011001010111010011000111，对应的长度 L为3×1+3×3+2×4+2×2+2×5=34。 　　在这个例子中，如果使用哈夫曼(Huffman)编码，对应的编码方案是A:000, B:01, C:10, D:001, E:11，虽然最终文字编码后的总长度只有33，但是这个编码不满足字典序编码的性质，比如C的编码的字典序不在D的编码之前。 　　在这个例子中，有些人可能会想的另一个字典序编码是A:000, B:001, C:010, D:011, E:1，编码后的文字长度为35。 　　请找出一个字典序编码，使得文字经过编码后的长度 L最小。在输出时，你只需要输出最小的长度 L，而不需要输出具体的方案。在上面的例子中，最小的长度 L为34。 输入格式 　　输入的第一行包含一个整数 n，表示单词的数量。 　　第二行包含 n个整数，用空格分隔，分别表示 a 1,  a 2, …,  an出现的频率，即 t 1,  t 2, …,  tn。请注意 a 1,  a 2, …,  an具体是什么单词并不影响本题的解，所以没有输入 a 1,  a 2, …,  an。 输出格式 　　输出一个整数，表示文字经过编码后的长度 L的最小值。 样例输入 5 1 3 4 2 5 样例输出 34 样例说明 　　这个样例就是问题描述中的例子。如果你得到了35，说明你算得有问题，请自行检查自己的算法而不要怀疑是样例输出写错了。 评测用例规模与约定 　　对于30%的评测用例，1 ≤  n ≤ 10，1 ≤  ti ≤ 20； 　　对于60%的评测用例，1 ≤  n ≤ 100，1 ≤  ti ≤ 100； 　　对于100%的评测用例，1 ≤  n ≤ 1000，1 ≤  ti ≤ 10000。

试题编号：

201612-4

题解：和哈夫曼树有点关系，不过是每次选择节点建树只能选择相邻的点，这样的话就是一个石子合并问题。经典动态规划问题。（不可以贪心去解，因为在这里局部最优不一定是全局最优）

定义dp[i][j]表示从i到j合并的最优解，sum[i][j]表从i到j的所有频率的和。那么可以推导出以下状态转移方程：

（这个动态转移方程一开始一直以为是错的。。。后来想明白了，i=j的时候显然。i!=j的时候，前一部分其实迭代求得的是，i到j这个区间之间最优的内部合并策略，而后面那项sum[i][j]则是表示将本次将要合并的两项的合并的花费，这里是永远等于sum[i][j]的。）

代码：

#include<bits/stdc++.h>
#include<iostream>
#include<cstring>
#include<math.h>
#include<stdlib.h>
#include<cstring>
#include<cstdio>
#include<utility>
#include<algorithm>
#include<map>
#include<stack>
#include<set>
#include<queue>
using namespace std;
typedef long long ll;
const int maxn = 1e3+5;
const int mod = 1e9+7;
const int Hash = 10000;
const int INF = 1<<30;
const ll llINF = 1e18+999;

int in[maxn];
int dp[maxn][maxn], sum[maxn], n;
int main( )
{
    freopen("input.txt", "r", stdin);
    scanf("%d", &n);
    for(int i=1; i<=n; i++)
    {
        scanf("%d", in+i);
        dp[i][i] = 0;
        sum[i] = sum[i-1] + in[i];
    }
    //动态规划迭代的方式有点特殊，是沿着对角线斜着进行迭代的，不然不管是以行优先还是列优先的方式都会出问题。
    //dis表示距离对角线的距离，也就是i和j直接的差距，必须先计算i，j距离近的才能计算远的
    for(int dis=1; dis<n; dis++)
        for(int i=1; i<=n; i++)
        {
            int j=i+dis;
            if(j > n)
                break;
            dp[i][j] = INF;
            for(int k=i; k<=j; k++)
                dp[i][j] = min(dp[i][j], dp[i][k]+dp[k+1][j]);
            dp[i][j] += sum[j]-sum[i-1];
        }
    cout<<dp[1][n]<<endl;
    return 0;
}

这道题有一个坑就是动态规划迭代过程中，矩阵的迭代顺序，既不是行优先也不是列优先，而是从对角线开始一步一步向外扩展，其实这样也符合我们的正常思维。所以知道的信息越来越多。

虽然这个算法的复杂度是O(n^3)，但是这道题的数据范围之内已经可以解决了。但是也可以进一步优化利用平形四边行优化，下次在学习吧。。

算法者，贵在积累。