由于每次压缩的都是连续的一段,所以可以想到分段DP,又由于压缩可以嵌套,所以考虑区间DP。为了方便,先假设压缩后的字符串前面自带一个M,统计答案时减
1
即可。
先想到最经典的模型:
第
1
种转移,就是
第
2
种转移,就是对应的子串长度为偶数,并且可以拆分成两个相等的子串时的转移,设
这时候转移就是
f[l][r]=min(f[l][r],f[l][mid]+2)
。
但上面的转移是错的。原因就在于第
2
种转移受到子串
所以这里就可以规定一个新的方案:
f[l][r][1]
表示子串
[l,r]
,压缩的第一个字符必须为M,并且不再含有其它任何M;
f[l][r][0]
表示子串
[l,r]
,压缩的第一个字符必须为M,且压缩串中M的个数必须大于
1
。
边界为
第
1
种转移为
min(f[i+1][r][0],f[i+1][r][1]))
,但在实现上要注意判边界,具体见代码。
第
2
种转移:
第
3
种转移也就是子串
最后答案就是
min(f[1][n][0],f[1][n][1])−1
,
n
<script type="math/tex" id="MathJax-Element-31">n</script>为原字符串长度。
代码:
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 55, INF = 0x3f3f3f3f;
int n, f[N][N][2]; char s[N];
int dfs(int l, int r, int op) {
if (f[l][r][op] != -1) return f[l][r][op];
if (l == r) return f[l][r][op] = 2;
int i, res = INF; if (op) {
res = r - l + 2; int mid; bool flag = 1;
if (!(r - l & 1)) flag = 0;
mid = l + r >> 1; for (i = l; i <= mid; i++)
if (s[i] != s[mid + i - l + 1]) flag = 0;
if (flag) res = min(res, dfs(l, mid, 1) + 1);
for (i = l; i < r; i++) res = min(res, dfs(l, i, 1) + r - i);
}
else for (i = l; i < r; i++) {
res = min(res, dfs(l, i, 0) + dfs(i + 1, r, 0));
if (i + 1 < r) res = min(res, dfs(l, i, 0) + dfs(i + 1, r, 1));
if (l < i) res = min(res, dfs(l, i, 1) + dfs(i + 1, r, 0));
if (l < i && i + 1 < r) res = min(res, dfs(l, i, 1) + dfs(i + 1, r, 1));
}
return f[l][r][op] = res;
}
int main() {
memset(f, -1, sizeof(f));
scanf("%s", s + 1); n = strlen(s + 1);
dfs(1, n, 0); dfs(1, n, 1);
cout << min(f[1][n][0], f[1][n][1]) - 1 << endl;
return 0;
}