CCF 20161204 压缩编码

CCF 20161204 压缩编码

试题编号

201612-4

试题名称

压缩编码

时间限制

3.0s

内存限制

256.0MB

问题描述

给定一段文字，已知单词a1, a2, …, an出现的频率分别t1, t2, …, tn。可以用01串给这些单词编码，即将每个单词与一个01串对应，使得任何一个单词的编码（对应的01串）不是另一个单词编码的前缀，这种编码称为前缀码。
　　使用前缀码编码一段文字是指将这段文字中的每个单词依次对应到其编码。一段文字经过前缀编码后的长度为：
　　L=a1的编码长度×t1+a2的编码长度×t2+…+ an的编码长度×tn。
　　定义一个前缀编码为字典序编码，指对于1 ≤ i < n，ai的编码（对应的01串）的字典序在ai+1编码之前，即a1, a2, …, 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个整数，用空格分隔，分别表示a1, a2, …, an出现的频率，即t1, t2, …, tn。请注意a1, a2, …, an具体是什么单词并不影响本题的解，所以没有输入a1, a2, …, 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。

问题分析

该问题主要抓住两点：

1. 编码必须满足字典编码的性质
2. 编码长度最小

其实该问题类似于石子合并问题，用动态规划可以能好的解决。合并的时候只能是相邻合并，并且合并的和最小，最终编码长度最小。

1. 确定状态：dp[i][j]表示从第i个数到第j个数编码长度的最小值。
   最后一步：最后的结果存储在dp[1][n]中·
2. 状态转移方程：转移方程一般都是考虑dp[i][j]与dp[i-1][j]、dp[i][j-1]、dp[i-1][j-1]的递推关系
   状态转移方程为：dp[i][j] = min(dp[i][k]+dp[k+1][j] + sum[j]-sum[i-1])(i<=k<=j)
   意思是i到j的编码最短长度等于min(i到k编码的最短长度+k到j的编码最短长度+i到j的和)，k是将i和j分开，结合哈夫曼边编码体会期中意思。
   sum[k]表示前k个数的和，sum[k]-sum[t-1]表示第t到第k个数的和。

代码实现

• 方法一：动态规划

#include<iostream>
#include<algorithm>

using namespace std;

//定义最大值
const int INF = 1 << 30;
const int N = 1001;
int dp[N][N],a[N],sum[N];

//#define DEBUG

int main(){
    int n;
    cin>>n;
    sum[0] = 0;
    for(int i = 1; i <= n; i++){
        cin>>a[i];
//        定义sum[i],表示1到i单词频率和
        sum[i] = sum[i-1] + a[i];
    }

//    调试
# ifdef DEBUG
    for(int i = 0; i <= n; i++){
        cout<<sum[i]<<' ';
    }
    cout<<endl;
#endif // if_debug

//    沿斜线扫描
//    控制单词合并的个数2 to n,方便1记录中间结果
    for(int t = 2; t <= n; t++){
//        i：1 to n-t+1 j：t to n
//        沿斜线扫描,n-t+1是扫描次数
        for(int i = 1,j = t; i <= n-t+1; i++,j++){
//            先初始化dp[i][j]为最大值
            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]+sum[j]-sum[i-1]);
            }
        }
    }
    cout<<dp[1][n];
    return 0;
}

• 方法二：带备忘录的递归

#include<iostream>
#include<algorithm>

using namespace std;

const int INF = 1 << 30;
const int N = 1001;

int data[N];
int sum [N] = {0};
int dp[N][N];

int solve(int i,int j)
{
    if(dp[i][j] == INF)
    {
        for(int k = i; k < j; k++)
        {
            dp[i][j] = min(dp[i][j],solve(i,k)+solve(k+1,j)+sum[j]-sum[i-1]);
        }
    }
    return dp[i][j];
}
int main()
{
    int n;
    ios::sync_with_stdio(false);
    cin>>n;
    fill(dp[0], dp[0] + N * N, INF);
    for(int i = 1; i <= n; i++)
    {
        cin>>data[i];
        sum[i] = sum[i-1] + data[i];
        dp[i][i] = 0;
    }
    solve(1,n);
    cout<<dp[1][n];
    return 0;
}

参考文档

1. 石子合并 动态规划（直线型）
2. CCF201612-4 压缩编码（100分）
3. CCF CSP 压缩编码 动态规划