Codeforces Gym 100337B Lempel-Ziv Compression 字符串DP

题目大意：

就是现在给出一个长度不超过4096的串要求进行压缩

每保留一个字符的代价是9, 用(r, len)表示的代价是25, r表示从当前位置 i 的前面 r 个字符开始连续复制写出长度为len的串

需要注意的是比如ab可以复制出 ab ababa

也就是复制是进行到一个部分的...刚开始这里没理解于是WA了一发..

大致思路：

首先预处理出字符串以i位置结尾和以j位置结尾向前能匹配出的最大长度, O(n*n)很明显的dp

然后给句得到的东西

用mi[i]表示串的长度为i前缀压缩后的最小代价

于是就可以发现, 通过枚举循环复制的部分的循环节长度可以得到转移到这个状态的状态, 从这些状态中取出最小值即可, 同时记录每个状态的最优解来自哪个子状态即可输出方案

对于每个位置pos, 枚举循环节的复杂度是O(pos + pos/2 + pos/3 + ... + pos/pos) = O(pos*log(pos))

于是整体的复杂度是O(n*n*logn)

常数很小可以通过

代码如下：

Result  :  Accepted     Memory  :  33172 KB     Time  :  218 ms

/*
 * Author: Gatevin
 * Created Time:  2015/9/4 18:30:28
 * File Name: E.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

#define copy cc

short dp[4100][4100];
char s[4100];
int mi[4100];
short f[4100];
const int inf = 1e9;
stack<pair<int, int> > S;
#define mp make_pair

int pre[4100];
int fir[4100];
int copy[4100];

int main()
{
    freopen("lz.in", "r", stdin);
    freopen("lz.out", "w", stdout);
    scanf("%s", s + 1);
    int len = strlen(s + 1);
    for(int i = 1; i <= len; i++)
        for(int j = 1; j <= len; j++)
            if(s[i] == s[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
    for(int i = 1; i <= len; i++)
    {
        memset(f, 0, sizeof(f));
        for(int j = 1; j <= i; j++)
        {
            f[j] = max(f[j - 1], dp[i][j]);
            if(f[j] > f[j - 1])
                for(int k = f[j - 1] + 1; k <= f[j]; k++)
                    fir[k] = j;//第一个出现向前公共匹配长度达到k的是j
        }
        
        mi[i] = mi[i - 1] + 9;
        pre[i] = i - 1;
        copy[i] = -1;//代表直接写
        for(int L = 1; L <= i; L++)
        {
            int ti = i;
            while(ti >= 0)
            {
                if(dp[i][ti] >= L)
                {
                    ti -= L;
                }
                else
                    break;
            }
            if(f[ti] >= L && ti == i - L)//从前面[1, ti]中找出一段长度为L的复制
            {
                if(mi[i] > mi[ti] + 25)
                {
                    mi[i] = mi[ti] + 25;
                    pre[i] = ti;
                    copy[i] = fir[L] - L + 1;//从这个位置开始复制长度为L的串, 即长度为i - pre[i]的串
                }
            }
            ti -= dp[i][ti];
            if(mi[i] > mi[ti + L] + 25)
            {
                mi[i] = mi[ti + L] + 25;
                pre[i] = ti + L;
                copy[i] = ti + 1;//从这个位置一直复制, 复制出的部分总长度为i - pre[i];
            }
        }
    }
    printf("%d\n", mi[len]);
    int now = len;
    S.push(mp(len, 0));
    while(now >= 1)
    {
        S.push(mp(pre[now], copy[now]));
        now = pre[now];
    }
    while(!S.empty())
    {
        int pos = S.top().first;
        int start = S.top().second;
        if(pos == len) break;
        S.pop();
        int end = S.top().first;
        if(end - pos == 1)
            putchar(s[end]);
        else
            printf("(%d,%d)", pos + 1 - (start), end - pos);
    }
    return 0;
}
/*
aaabbaaabababababab

abababaaaaaaaaaaaaaaaaaababab
*/