[Andrew Stankevich's Contest#21] Lempel-Ziv Compression

Time Limit: 20000/10000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others)     Special Judge

Problem Description

Most modern archivers, such as WinRAR or WinZIP, use modifications of Lempel-Ziv method as their primary compression algorithm. Although decompression of LZ-compressed archives is usually easy and fast, the compression process itself is often rather complicated and slow. Therefore professional archivers use approximation methods that sometimes do not allow to achieve the best possible compression.

This situation doesn’t satisfy your chief George. He would like to create the best archiver WinGOR. The archiver will use the following modification of LZ77 algorithm.
      The text is partitioned to chunks of length not exceeding 4096. Each chunk is compressed independently. We will describe the decompression of one chunk t. Based on this description, you will have to create a compression algorithm that will create the shortest possible compressed chunk x from the given chunk t.
      The compressed chunk is written down as the sequence of plain characters and repetition blocks. Plain character is 8 bits long. When decompressing, plain character c is simply copied to output. Repetition block (r; l) consists of two parts: reference r and length l, each 12 bits long. Reference r is an integer number between 1 and 4095. When repetition block (r; l) is obtained after decompressing i − 1 characters of text, characters t[i − r ... i − r + l − 1] are copied to output. Note, that r can be less than l, in this
case recently copied characters are copied to output as well.

To help decompressor distinguish between plain characters and repetition blocks a leading bit is prepended to each element of the compressed text: 0 means plain character follows, 1 — repetition block follows.

For example, “aaabbaaabababababab” can be compressed as “aaabb(5,4)(2,10)”. The compressed variant has 8 + 8 + 8 + 8 + 8 + 24 + 24 + 7 = 95 bits instead of 152 in the original text (additional 7 bits are used to distinguish between plain characters and repetition blocks).
      Given a text chunk, find its compressed representation which needs fewest number of bits to encode

Input

      Input file contains a text chunk t. Its length doesn’t exceed 4096. A text chunk contains only small letters of the English alphabet.

Output

      Print the length of the compressed text in bits at the first line of the output file. Print the compressed chunk itself at the second line of the output file. Use characters themselves to denote plain characters and “(r,l)” notation (without spaces) to denote repetition blocks.

Sample Input

aaabbaaabababababab 

Sample Output

95 
aaabb(5,4)(2,10)

题意概述

给定一种压缩规则：或直接复制，或将重复出现的字符用二元数对(r,l)表示，代表[i − r ... i − r + l − 1]范围内的字符串。其中直接复制的字符占9位，每个二元数对占25位。对于给定的待压缩字符串，要求输出压缩后的最小数据位数和压缩后的编码。

分析

容易看出，字符串中前i位如何编码，对后继字符串的编码是没有影响的。这样，我们就可以想到运用保存决策的动态规划进行编码。
这里需要的一点小trick在于如何寻找尽量靠前的一段最长重复子串。代入kmp算法的思路，我们可以对原字符串的每一段后缀预处理出next数组，这样原字符串中每个前缀的最长重复子串就可以在O(n)的时间内得到了。于是这里可以得出一个复杂度O(n^2)的动态规划：
记minbit[i]为压缩前i个字符所需的最小数据量，str[i]为此时的决策，r[i],l[i]为这次转移时压缩成的数对（若不需压缩，str[i]=i, r[i]储存不需压缩的部分的起始点)
那么，每次转移时就可以从0到i-1枚举决策j，选择可以使(minbit[j] + (i-j)*9)或minbit[i - next[j][i-1]] + 25取得最小值的j，并保存决策。最后可以通过一个递归函数推出最终答案。
（这里需要注意一点问题……next数组是二维的，数据范围maxn为2^12，而内存限制为64000KB……如果用next[maxn][maxn]的方式开数组明显会MLE……所以我鼓起勇气采用了动态内存分配……）

AC代码

 1 //Verdict: Accepted 2 // Submission Date: -- ::
 3 // Time: 8256MS
 4 // Memory: 34624KB
 5
 6 /*=============================================================================================================================*/
 7 /*======================================================Code by Asm.Def========================================================*/
 8 /*=============================================================================================================================*/
 9 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <cmath>
 #include <cctype>
 #include <memory.h>
 #include <cstring>
 #include <cstdlib>
 using namespace std;
 #define maxn ((int)4.1e3)
 /*===========================================================TYPES=============================================================*/
 typedef long long LL;
   
 /*======================================================GLOBAL VARIABLES=======================================================*/
 char ch[maxn];
 int len = , minbit[maxn], *next[maxn];
 int l[maxn], r[maxn], str[maxn];
 /*==========================================================FUNCTIONS==========================================================*/
 inline void getnext(int l){
     int i, j, L = len - l;
     next[l] = new int[L+];
     int *Next = next[l];
     Next[] = ;
     for(i = ;i < L;++i){
         j = Next[i-] - ;
         while(ch[l+i] != ch[l+j+] && j >= )
             j = Next[j] - ;
         if(ch[l+i] == ch[l+j+])
             Next[i] = j + ;
         else Next[i] = ;
     }
 }
 void printpro(int i){
     if(str[i] == i){
         if(r[i])printpro(r[i]-);
         int j;
         for(j = r[i];j <= i;++j)putchar(ch[j]);
         return;
     }
     printpro(str[i]);
     printf("(%d,%d)", r[i], l[i]);
 }
 int main(){
     #ifdef DEBUG
     assert(freopen("test","r",stdin));
     #endif
     //--------------------------------------------------variables-----------------------------------------------------------
       
     //-----------------------------------------------------work-------------------------------------------------------------
     char c;
     while(isalpha(c = getchar()))str[len] = len, ch[len++] = c;
     int i, j, Min, t;
     for(i = ;i < len - ; ++i)
         getnext(i);
     minbit[] = ;
     for(i = ;i < len; ++i){
         Min = 0x7fffffff;
         for(j = ;j < i;++j)
             if(minbit[j] + (i-j)* < Min){
                 Min = minbit[j] + (i-j)*;
                 str[i] = i;
                 r[i] = j+;
             }
         for(j = ;j < i; ++j){
             t = next[j][i-j];
             if(!t)continue;
             if(minbit[i-t] +  < Min){
                 Min = minbit[i-t] + ;
                 str[i] = i-t;
                 r[i] = i+-t-j;
                 l[i] = t;
             }
         }
         minbit[i] = Min;
     }
     printf("%d\n", minbit[len-]);
     printpro(len-);
     return ;
 }
 /*=============================================================================================================================*/