【LeetCode - 1246】删除回文子数组

1、题目描述

2、解题思路

  设 dp[l][r] 表示删除 arr 的 l 到 r 索引元素的回文子数组所需的最少操作次数。（包含 l 和 r）

  如果 l 到 r 的元素个数只有 0 个，返回 0；

  如果 l 到 r 的元素个数只有 1 个，返回 1；

  如果 l 到 r 的元素个数只有 2 个，两个元素相等则返回 1，不等则返回 2；

  对于 l 到 r 的元素大于等于 3 的情况，如下分析：

  情况一：若 arr[l] == arr[r]，则这两个元素可以跟着 [l+1, r-1] 情况下的最后一次删除一起被删除，此时，dp[l][r] = dp[l+1][r-1]；

  情况二：无论 arr[l] 和 arr[r] 是否相等，最优操作可能是：先删除 [l, k] 再删除 [k+1, r]，具体 k 是多少，我们可以从 l 到 r-1 进行遍历。

  因为我们需要的是最少操作数，所以取上面所有情况中最小的那个。

  最后返回 dp[0][arr.length-1]

3、解题代码

class Solution {
    public int minimumMoves(int[] arr) {
        int len = arr.length;
        if (len == 0) return 0;
        if (len == 1) return 1;
        if (len == 2) return arr[0] == arr[1] ? 1 : 2;
        // dp[l][r] 表示删除 arr 的 [l, r] 的回文子数组最少操作次数
        int[][] dp = new int[len][len];
        // base_case
        for (int i = 0; i < len; i++) {
            dp[i][i] = 1;   // 只有一个元素，删除操作数为 1
        }
        for (int r = 1; r < len; r++) {
            for (int l = r - 1; l >= 0; l--) {
                // 只有两个元素
                if (l == r - 1) {
                    dp[l][r] = arr[l] == arr[r] ? 1 : 2;
                    continue;
                }
                // 元素大于等于三的情况
                int min = Integer.MAX_VALUE;
                if (arr[l] == arr[r]) {
                    // 这两个元素很可能跟着 [l+1, r-1] 最后一步删除，先假设是这样，后面会比较
                    min = dp[l + 1][r - 1];
                }
                // 可能是先删除 [l,k] 所有回文子数组，再删除 [k+1,r] 的所有回文子数组，具体 k 是谁则需遍历
                for (int k = l; k < r; k++) {
                    min = Math.min(min, dp[l][k] + dp[k + 1][r]);
                }
                dp[l][r] = min;
            }
        }
        return dp[0][len - 1];
    }
}