UVA 1630 Folding——区间DP（记忆化搜索）

最新推荐文章于 2020-01-23 18:04:42 发布

hao_zong_yin

最新推荐文章于 2020-01-23 18:04:42 发布

阅读量451

点赞数 1

CC 4.0 BY-SA版权

分类专栏：动态规划文章标签： dp

本文链接：https://blog.csdn.net/hao_zong_yin/article/details/76177459

动态规划专栏收录该内容

195 篇文章

订阅专栏

本文介绍了一个字符串压缩算法的实现思路及代码实现。该算法通过区间动态规划的方式寻找字符串中最短的有效压缩形式，利用循环节特性进一步减少存储空间。文章详细解释了如何判断字符串是否能够进行有效压缩，并给出具体实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：根据样例可直接看出

Sample Input

AAAAAAAAAABABABCCD

NEERCYESYESYESNEERCYESYESYES

Sample Output

9(A)3(AB)CCD

2(NEERC3(YES))

思路：影响决策的因素是子串，因此一个状态应该能完整的保存一个子串，这就需要一个区间和一个string保存子串的位置和内容，这里我用了string dp【105】【105】来保存状态，状态转移类似于UVA 1626括号序列（经典的区间DP），当当前的串能压缩时先将其压缩，然后枚举切割位置，寻找切割后两个子问题之和的最小值。

这题的坑点在于判断一个串能否压缩，判断方法是枚举压缩长度，可以整除时用一个循环判断元素相等（循环具体内容参考我flod函数里的循环），总体来说有点难

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

string s, dp[150][150];//dp【i】【j】表示区间【i，j】长度最小的字符串

bool flod(const string &ss, int &len, int &cnt) {//判断一个串能否折叠，如果能的话获得最小循环节长度以及循环次数（引用的作用）
    bool ok = false;
    int nn = ss.size();
    for (len = 1; len <= nn / 2; len++) {
        if (nn % len == 0) {
            bool flag = true;
            for (int i = 0; i + len < nn; i++) {
                if (ss[i] != ss[i + len]) { flag = false; break; }
            }
            if (flag) { cnt = nn / len; ok = true; break; }
        }
    }
    return ok;
}

int dfs(int L, int R) {
    if (dp[L][R].size()) return dp[L][R].size();
    if (L == R) { dp[L][R] = s[L]; return 1; }
    string ss;
    for (int i = L; i <= R; i++) {
        ss.push_back(s[i]);
    }
    dp[L][R] = ss;
    int len = 0, cnt = 0;//循环节长度以及循环次数
    if (flod(ss, len, cnt)) {
        int temp = cnt; string num;
        while (temp) {
            num.push_back(temp % 10 + '0');
            temp /= 10;
        }
        reverse(num.begin(), num.end());//忘记反转WA了一次
        if (num.size() + 2 + dfs(L, L + len - 1) < dp[L][R].size()) {
            dp[L][R] = num + "(" + dp[L][L + len - 1] + ")";
        }
    }
    for (int k = L; k < R; k++) {
        if (dfs(L, k) + dfs(k + 1, R) < dp[L][R].size()) {
            dp[L][R] = dp[L][k] + dp[k + 1][R];
        }
    }
    return dp[L][R].size();
}

int main() {
    while (cin >> s) {
        int n = s.size();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j].clear();
            }
        }
        dfs(0, n - 1);
        cout << dp[0][n - 1] << endl;
    }
    return 0;
}