[Leetcode]664.Strange Printer

链接：LeetCode664

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

打印机每次只能打印同一个字符序列。
每次可以在任意起始和结束位置打印新字符，并且会覆盖掉原来已有的字符。
给定一个只包含小写英文字母的字符串，你的任务是计算这个打印机打印它需要的最少次数。

示例 1:

输入: "aaabbb"
输出: 2
解释: 首先打印 "aaa" 然后打印 "bbb"。
示例 2:

输入: "aba"
输出: 2
解释: 首先打印 "aaa" 然后在第二个位置打印 "b" 覆盖掉原来的字符 'a'。

相关标签：动态规划

动态规划是解决字符串问题的常规思路。这里使用的方法是区间DP。
首先，我们先把第一个字符打印了，后边的字符要么和第前边某个字符一起打印，要么单独打印；
如果和前边的字符一起打印，后边的字符不占用打印次数，但是源字符串被拆分成两段

代码如下：

python:

# 区间DP
class Solution(object):
    def strangePrinter(self, s):
        """
        :type s: str
        :rtype: int
        """
        if not s:
            return 0
        n = len(s)
        dp = [[0 for j in range(n)] for i in range(n)]
        for i in reversed(range(n)):
            for j in range(i,n):
                if i==j:
                    dp[i][j] = 1
                else:
                    dp[i][j] = dp[i][j-1]+1
                    for k in range(i,j):
                        if s[k] == s[j]:
                            dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j-1])
        return dp[0][-1]

C++:

class Solution {
public:
    int strangePrinter(string s) {
        if(s.empty()) return 0;
        int n = s.size();
        vector<vector<int>> dp(n,vector<int>(n,0));
        for(int i=n-1;i>=0;i--){
            for (int j=i;j<n;j++){
                if(i==j){
                    dp[i][j] = 1;
                }
                else {
                    dp[i][j] = 1+dp[i][j-1];
                    for(int k=i;k<j;k++){
                        if(s[k]==s[j]){
                            dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j-1]);
                        }
                    }
                }
            }
        }
        return dp[0][n-1];        
    }
};