Description

　　给一个由小写字母组成的字符串，我们可以用一种简单的方法来压缩其中的重复信息。压缩后的字符串除了小
写字母外还可以（但不必）包含大写字母R与M，其中M标记重复串的开始，R重复从上一个M（如果当前位置左边没
有M，则从串的开始算起）开始的解压结果（称为缓冲串）。 bcdcdcdcd可以压缩为bMcdRR，下面是解压缩的过程

　　另一个例子是abcabcdabcabcdxyxyz可以被压缩为abcRdRMxyRz。
Input

　　输入仅一行，包含待压缩字符串，仅包含小写字母，长度为n。
Output

　　输出仅一行，即压缩后字符串的最短长度。
Sample Input
bcdcdcdcdxcdcdcdcd
Sample Output
12
HINT

在第一个例子中，解为aaaRa，在第二个例子中，解为bMcdRRxMcdRR。

【限制】

100%的数据满足：1<=n<=50 100%的数据满足：1<=n<=50

解题方法： 我们先转化一下这个问题，先假设字符串长度为n 并且 在字符串的最前面已经有一个m存在了，那么原文题就等价于区间[1,n]之前已经放有一个字母M。那么我们就是要用若干个M和R，将字符串中的循环节括起来，并使最终压缩后的字符串尽量短。那么这个问题就成为了一个划分DP，用记忆化搜索是最好***的。
令DP[l][r][k]表示区间为[l, r]，k = 1，表示在l, r区间的缝隙里放了M, k = 0 表示没放，并且做一个强制规定，就是l - 1位置一定存在一个M了，也许你会想开头怎么办呢？开头就特判一下吧。转移分两种，第一种是k = 1，我们只需要去枚举一下 M放的位置，并且用分割后的两个区间去更新[l, r]的最优值即可。
另外一种是k = 0,的时候，这种情况我们首先要判断一下，这个[l, r]区间是否本身就是一个循环节。如果是我们直接在中间位置给它加上一个R就可以啦，不是的话我们枚举一下R的位置，让R和前面L-1和L之间的M对应括起来成为一个循环节部分，然后再用这个循环节部分的DP值做转移，R的后面那部分的值保持不变就可以啦。然后这题就做完啦。小细节代码也有解释。就不赘述了。

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
const int inf = 0x3f3f3f3f;
int n, dp[maxn][maxn][2]; //dp[l][r][k]表示l,r区间是否放了M，并且l-1位置有M或者L-1等于0
char s[maxn];

bool judge(int l, int r){ //judge [l, mid] && [mid+1, r] is same?
    int len = r - l + 1;
    if(len % 2 == 0){
        int mid = (l + r) / 2;
        for(int i = l; i <= mid; i++){
            int j = mid + i - l + 1;
            if(s[i] != s[j]) return false;
        }
        return true;
    }
    else{ //特判长度为奇数
        return false;
    }
}

int dfs(int l, int r, int k){ //dp[l][r][k]
    if(dp[l][r][k] != inf) return dp[l][r][k];
    int len = r - l + 1;
    if(len == 1){
        if(k) return dp[l][r][k] = inf;
        else return dp[l][r][k] = 1;
    }
    int mid = (l + r) / 2;
    if(k){//k = 1, 暴力枚举M放在哪里
        for(int i = l; i < r; i++){
            dp[l][r][k] = min(dp[l][r][k], dfs(l, i, 1) + 1 + dfs(i + 1, r, 1));
            dp[l][r][k] = min(dp[l][r][k], dfs(l, i, 1) + 1 + dfs(i + 1, r, 0));
            dp[l][r][k] = min(dp[l][r][k], dfs(l, i, 0) + 1 + dfs(i + 1, r, 0));
            dp[l][r][k] = min(dp[l][r][k], dfs(l, i, 0) + 1 + dfs(i + 1, r, 1));
        }
        return dp[l][r][k];
    }
    else{
        //k = 0
        if(judge(l, r)){//如果[L,R]区间是两个相同的字符串拼起来的话，那么这个区间只需要左边一半加上一个R的长度来表达
            dp[l][r][k] = dfs(l, mid, 0) + 1;
        }
        for(int i = l; i < r; i++){
            dp[l][r][k] = min(dp[l][r][k], dfs(l, i, 0) + r - i); //枚举R的位置
        }
        return dp[l][r][k];
    }
}
int main(){
    memset(dp, inf, sizeof(dp));
    scanf("%s", s + 1);
    n = strlen(s + 1);
    int ans = min(dfs(1, n, 1), dfs(1, n, 0));
    printf("%d\n", ans);
    return 0;
}