CSP-J-动态规划

1.1 最小插入次数回文问题

给定一个字符串str，你可以通过在任意位置插入字符，使得该字符串变成一个回文。请你编写一个程序，计算并返回需要插入的最少字符数。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int min(int x, int y) {
    return (x < y) ? x : y;
}

int min_insertions_for_palindrome(string str) {
    int n = str.length();
    vector<vector<int>> dp(n, vector<int>(n, 0));
    
    for (int gap = 1; gap < n; gap++) {
        for (int i = 0, j = gap; j < n; i++, j++) {
            if (str[i] == str[j])
                dp[i][j] = ①;
            else
                dp[i][j] = 1 + min(②, ③);
        }
    }
    
    return dp[0][n - 1];
}

int main() {
    string str;
    cin >> str;
    cout << "Minimum number of insertions to make a palindrome: " << min_insertions_for_palindrome(str) << endl;
    return 0;
}

①处应填（ ）
A. dp[i + 1][j - 1]
B. 0
C. 1
D. dp[i][j]

②处应填（ ）
A. dp[i + 1][j]
B. dp[i][j - 1]
C. dp[i + 1][j - 1]
D. dp[i][j]

③处应填（ ）
A. dp[i + 1][j]
B. dp[i][j - 1]
C. dp[i + 1][j - 1]
D. dp[i][j]

1.1答案解析

①处应填（A）
A. dp[i + 1][j - 1]
B. 0
C. 1
D. dp[i][j]

详细解析：
正确答案是 A. dp[i + 1][j - 1]

1. 这个选择对应的是 str[i] == str[j] 的情况。
2. 当 str[i] 和 str[j] 相等时，我们不需要在这两个位置插入任何字符。
3. 此时，使 str[i, j] 成为回文的问题就转化为使 str[i+1, j-1] 成为回文。
4. dp[i+1][j-1] 正是表示使 str[i+1, j-1] 成为回文所需的最少插入次数。
5. 选项 B (0) 不正确，因为虽然 i 和 j 位置不需要插入，但中间可能需要。
6. 选项 C (1) 不正确，因为我们不一定需要插入字符。
7. 选项 D (dp[i][j]) 不正确，因为这会导致循环定义。

②处应填（A）
A. dp[i + 1][j]
B. dp[i][j - 1]
C. dp[i + 1][j - 1]
D. dp[i][j]

详细解析：
正确答案是 A. dp[i + 1][j]

1. 这个选择是 str[i] != str[j] 情况下的一种处理方式。
2. 当 str[i] 和 str[j] 不相等时，我们有两种选择：在左边插入或在右边插入。
3. dp[i + 1][j] 表示在左边插入一个字符的情况。
   • 具体来说，我们在 i 位置左边插入一个与 str[j] 相同的字符。
   • 插入后，新的子问题变成了 str[i+1, j]。
4. 选项 B (dp[i][j - 1]) 是另一种有效的选择，对应在右边插入的情况。
5. 选项 C (dp[i + 1][j - 1]) 不正确，因为它没有考虑新插入的字符。
6. 选项 D (dp[i][j]) 不正确，因为这会导致循环定义。

③处应填（B）
A. dp[i + 1][j]
B. dp[i][j - 1]
C. dp[i + 1][j - 1]
D. dp[i][j]

详细解析：
正确答案是 B. dp[i][j - 1]

1. 这个选择是 str[i] != str[j] 情况下的另一种处理方式。
2. dp[i][j - 1] 表示在右边插入一个字符的情况。
   • 具体来说，我们在 j 位置右边插入一个与 str[i] 相同的字符。
   • 插入后，新的子问题变成了 str[i, j-1]。
3. 选项 A (dp[i + 1][j]) 已经在 ② 中考虑过，是左边插入的情况。
4. 选项 C (dp[i + 1][j - 1]) 不正确，因为它没有考虑新插入的字符。
5. 选项 D (dp[i][j]) 不正确，因为这会导致循环定义。

综合分析：

• 这个动态规划算法的核心是考虑每一个子串 str[i, j]。
• 对于每个子串，我们考虑两种情况：
  1. str[i] == str[j]：不需要插入，问题缩小为 str[i+1, j-1]。
  2. str[i] != str[j]：需要插入，有两种选择（左插或右插），取较小值。
• 通过填充 dp 数组，我们逐步解决所有子问题，最终得到整个字符串的解。
• 时间复杂度 O(n^2)：两层循环，每层 O(n)。
• 空间复杂度 O(n^2)：使用了一个 n×n 的 dp 数组。