DP+字符串 - hihoCoder #160

 

#1320 : 压缩字符串

 

描述

 

小Hi希望压缩一个只包含大写字母'A'-'Z'的字符串。他使用的方法是：如果某个子串 S 连续出现了 X 次，就用'X(S)'来表示。例如AAAAAAAAAABABABCCD可以用10(A)2(BA)B2(C)D表示。

此外，这种压缩方法是可以嵌套的，例如HIHOHIHOCODERHIHOHIHOCODER可以表示成2(2(HIHO)CODER)。

对于一个字符串 S ，合法的压缩表示可能有很多种。例如AAAAAAAAAABABABCCD还可以表示成9(A)3(AB)CCD。小Hi希望知道其中最短的表示方法长度是多少。

输入

第一行一个正整数 T (1 ≤ T ≤ 10)，表示测试数据的组数。

以下 T 行每行一个字符串 S ，长度不超过100。

输出

对于每组数据，输出最短的表示方法的长度。

 

一开始看这道题没看出来是动态规划，只能说自己还是太菜了。

官方题解：

 

本题是一道非常经典的动态规划题目。

设S[1..n]是一个长度为n的字符串，best(S)是S的最短压缩，那么best(S)可能为三种形式中最短的一种：

1) 原串形式：best(S) = S。例如CCD最短压缩就是CCD本身。

2) 拼接形式： best(S[1..n]) = best(S[1..i]) + best(S[i+1 .. n])。

    例如AAAAAAAAAABABABCCD的最短压缩9(A)3(AB)CCD，可以视为由best(AAAAAAAAAABABAB) = 9(A)3(AB) 和 best(CCD) = CCD 拼接而成。

3) 嵌套形式： best(S[1..n]) = k的位数 + 2 + best(S[1..n/k])，其中k>1且是n的约数，S是由k个S[1..n/k]循环拼接而成。

     也就是说S[1..n]可以表示成k(s[1..n/k])，这时k(s[1..n/k])的长度是k的位数 + 一对括号的长度2 + best(S[1..n/k)

     例如HIHOHIHOCODERHIHOHIHOCODER有循环节HIHOHIHOCODER，所以best(HIHOHIHOCODERHIHOHIHOCODER) = 1 + 2 + (best(HIHOHIHOCODER))。

 

思路就是这样，具体我们可以枚举最大的长度从2...len,最小就是1，但是初始化可以设为1，所以从而枚举，最大就是本身的长度。

枚举长度之后就枚举起始位置，结束位置就是 起始位置+长度。然后取上述三种情况中的最小值。注意边界条件，就是for数组的区间，还有长度等变量。（字符串的一大坑点）

 

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

const int ma=105,INF=0x3f3f3f3f;
char s[ma];
int dp[ma][ma];

int cal(int b,int t)
{
    bool flag;
    int l=t-b+1;
    for(int i=1; i<=l/2; ++i)
    {
        flag=true;
        for(int j=b+i; j<=t; j+=i)
        {
            for(int k=0; k<i; ++k)
            {
                if(s[b+k]!=s[j+k])
                {
                    flag=false;
                    break;
                }
            }
            if(!flag) break;
        }
        if(flag) return i;
    }
    return -1;
}


int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s",s);
        int len=strlen(s);
        memset(dp,INF,sizeof(dp));
        for(int i=0; i<len; ++i) dp[i][i]=1;

        for(int i=2; i<=len; ++i)
        {
            for(int j=0; j<len; j++)
            {
                int r=j+i-1;
                if(r>=len) break;

                dp[j][r]=min(dp[j][r],i);
                for(int k=j; k<r; ++k)
                    dp[j][r]=min(dp[j][r],dp[j][k]+dp[k+1][r]);

                int pos=cal(j,r);
                if(pos<0) continue;
                dp[j][r]=min(dp[j][r],(i/pos<10?1:2)+2+dp[j][j+pos-1]);
            }
        }
        printf("%d\n",dp[0][len-1]);
    }

    return 0;
}