Leetcode力扣秋招刷题路-0664

从0开始的秋招刷题路，记录下所刷每道题的题解，帮助自己回顾总结

664. 奇怪的打印机

有台奇怪的打印机有以下两个特殊要求：

打印机每次只能打印由 同一个字符 组成的序列。
每次可以在从起始到结束的任意位置打印新字符，并且会覆盖掉原来已有的字符。
给你一个字符串 s ，你的任务是计算这个打印机打印它需要的最少打印次数。

示例 1：
输入：s = “aaabbb”
输出：2
解释：首先打印 “aaa” 然后打印 “bbb”。

示例 2：
输入：s = “aba”
输出：2
解释：首先打印 “aaa” 然后在第二个位置打印 “b” 覆盖掉原来的字符 ‘a’。

提示：
1 <= s.length <= 100
s 由小写英文字母组成

解题思路
动态规划思想是希望连续的，也就是说上一个状态和下一个状态(自变量)之间有关系而且连续。

如果涉及到最多，最少的，一般使用动态规划。

dp[i][j]：表示字符串 s 在区间 [i, j]中需要最少的打印次数。。

只有一个字符 ’ a '：只需要打印 一次；

打印两个字符 ’ abab '：打印 两次，在打印 ’ a ’ 的基础上再打印一个 ’ b '；

打印 ’ aba '：打印 两次，先打印 ’ aaa '，再将中间的 ’ a ’ 打印成 ’ b '；

打印 ’ abab '：打印 三次，可以在打印完 ’ aba ’ 的基础上再打印一个 ’ b ’ 或是在打印完 ’ bab ’ 的基础上再打印一个 ’ a '，最少需要三次才能打印出来。

当区间 [i,j] 两端点的字符相同时（’ aba ‘）：此时它的打印次数可以从它的更小一层的子区间的打印次数而来（’ ab '），此时状态转移方程：dp[i][j] = dp[i][j - 1]；

当区间 [i,j] 两端点的字符不同时（’ abab '）：此时要遍历所有可能的组合，将该区间中的字符串进行拆分，取需要打印次数最小的解。

示例：s = 'abab'
先打印 ' a ' 再打印 ' bab '，此时需要 1 + 2 = 3 次打印；
先打印 ' ab ' 再打印 ' ab '，此时需要 2 + 2 = 4 次打印；
先打印 ' aba ' 再打印 ' b '，此时需要 2 + 1 = 3 次打印，因此得到 ' abab ' 至少需要三次打印。

初始化：当只打印一个字符时，状态转移方程为：dp[i][j] = 1（其中，i==j）；

示例：s = 'abab'，dp[0][0] = dp[1][1] = dp[2][2] = dp[3][3] = 1
i = 3，j = 4 直接跳过；

i = 2，j = 3，' ab '，s[i] != s[j]，k ∈ [2, 3)，dp[2][3] = val = dp[2][2] + dp[3][3] = 2；

i = 1，j = 2，' ba '，s[i] != s[j]，k ∈ [1, 2)，dp[1][2] = val = dp[1][1] + dp[2][2] = 2；
       j = 3，' bab '，s[i] == s[j]，dp[1][3] = dp[1][2] = 2；

i = 0，j = 1，' ab '，易得 dp[0][1] = 2；
       j = 2，' aba '，s[i] == s[j]，dp[0][2] = dp[0][1] = 2；
       j = 3，' abab '，s[i] != s[j]，k ∈ [0, 3)，
            将 ' abab ' 拆分为 ' a ' + ' bab '：dp[0][0] + dp[1][3] = 1 + 2 = 3；
            将 ' abab ' 拆分为 ' ab ' + ' ab '：dp[0][1] + dp[2][3] = 2 + 2 = 4；
            将 ' abab ' 拆分为 ' aba ' + ' b '：dp[0][2] + dp[3][3] = 2 + 1 = 3；
       取最小次数，则 dp[0][3] = 3。

代码

class Solution {

    public int strangePrinter(String s) {

        int n = s.length();
        if (n == 0) return 0;

        int[][] dp = new int[n][n];
        for (int i=0;i<n;i++) { // 对于一个元素时，只打印一次即可。

            dp[i][i] = 1;
        }

        for (int i=n-1;i>=0;i--) {

            for (int j=i+1;j<n;j++) { // 从 i + 1 开始，往右端点(n - 1)移动，有 i < j。

                if (s.charAt(j) == s.charAt(i)) {

                    dp[i][j] = dp[i][j - 1];
                } else {

                    int val = Integer.MAX_VALUE;
                    for (int k=i;k<j;k++) { // 从 i 开始向 j 移动

                        val = Math.min(val, dp[i][k] + dp[k + 1][j]);
                    }
                    dp[i][j] = val;
                }
            }
        }
        return dp[0][n - 1];
    }
}