本题是一道区间型动态规划题目。

本题与 UVa 10559 Blocks 类似，可以说是该题的简化版本。令 $m[i]$ 表示第 $i$ 个物品，定义状态 $dp[l][r]$ 表示移除区间 $[l,r]$ 内的可回收物品所需的最少操作次数，那么对于区间 $[l,r]$ 的最左侧的物品 $m[l]$ 来说，如果它不是一个可回收物品，那么不需考虑，只需继续考虑区间 $[l+1,r]$ 的最少操作次数。如果物品 $m[l]$ 是一个可回收物品，有两种选择：

• 立即将物品 $m[l]$ 移除，此时最少操作次数为 $1+dp[l+1][r]$；

• 不立即移除 $m[l]$，而是先闲置，转而移除 $m[l]$ 右侧的若干可回收物品，等待出现一个类型与最左侧物品 $m[l]$ 类型相同的物品 $m[k]$ 时，选择将最左侧物品 $m[l]$ 与此物品 $m[k]$ 及其右侧同类型的可回收物品一并移除，此时最少操作次数为 $dp[l+1][k-1]+dp[k][r]$。对于此种情况，如果在向右移除并等待出现一个类型与 $m[l]$ 的类型相同的物品过程中，遇到了一个不可回收的物品，那么此时不必再继续向右扫描，可以终止，因为无法将不可回收的物品放到回收桶中，后续的物品移除过程可以单独作为动态规划的一个子任务看待。

最终动态规划的递推关系式为：

d p [ l ] [ r ] = m i n { d p [ l + 1 ] [ r ] + 1 , m i n { d p [ l + 1 ] [ k − 1 ] + d p [ k ] [ r ] , m [ k ] = = m [ l ] } } dp[l][r]=min\{dp[l+1][r]+1,min\{dp[l+1][k-1]+dp[k][r],m[k]==m[l]\}\} dp[l][r]=min{dp[l+1][r]+1,min{dp[l+1][k−1]+dp[k][r],m[k]==m[l]}}

参考代码：

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110, INF = 0x3f3f3f3f;
int n, m[MAXN], dp[MAXN][MAXN];
int dfs(int l, int r) {
    if (l > r) return 0;
    if (~dp[l][r]) return dp[l][r];
    if (!m[l]) return dp[l][r] = dfs(l + 1, r);
    int a = dfs(l + 1, r) + 1;
    for (int i = l + 1; i <= r; i++) {
        if (!m[i]) break;
        if (m[i] == m[l]) a = min(a, dfs(l + 1, i - 1) + dfs(i, r));
    }
    return dp[l][r] = a;
}
int main(int argc, char *argv[]) {
    cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
    int T; cin >> T;
    for (int cs = 1; cs <= T; cs++) {
        cin >> n;
        string s;
        map<string, int> indexer;
        int cnt = 1;
        for (int i = 0; i < n; i++) {
            cin >> s;
            if ('A' <= s[0] && s[0] <= 'Z') m[i] = 0;
            else {
                if (indexer.count(s)) m[i] = indexer[s];
                else {
                    indexer[s] = cnt;
                    m[i] = cnt++;
                }
            }
        }
        memset(dp, -1, sizeof dp);
        cout << "Case " << cs << ": " << dfs(0, n - 1) << '\n';
    }
    return 0;
}