664. Strange Printer

Problem Statement

Hard

There is a strange printer with the following two special properties:

The printer can only print a sequence of the same character each time.
At each turn, the printer can print new characters starting from and ending at any place and will cover the original existing characters.

Given a string s, return the minimum number of turns the printer needed to print it.

Example 1:

Input: s = "aaabbb"
Output: 2
Explanation: Print "aaa" first and then print "bbb".

Example 2:

Input: s = "aba"
Output: 2
Explanation: Print "aaa" first and then print "b" from the second place of the string, which will cover the existing character 'a'.

Constraints:

1 <= s.length <= 100
s consists of lowercase English letters.

C++

Source file

class Solution {
public:
    int strangePrinter(string s) {
        s.erase(unique(s.begin(), s.end()), s.end());
        int n = s.size();
        vector<vector<int>> dp(n, vector<int>(n));
        // if substr.size()==1, then prints reqd: 1;
        for(int i=0; i<n; ++i)
            dp[i][i] = 1;

        for(int i=1; i<n; ++i){
            for(int j=0; j<n-i; ++j){
                int k = i + j;
                if(s[j]==s[k]){
                    dp[j][k] = dp[j][k-1];
                } else {
                    dp[j][k] = numeric_limits<int>::max();
                    for (int l = j; l < k; ++l) {
                        dp[j][k] = min(dp[j][k], dp[j][l] + dp[l + 1][k]);
                    }
                }
            }
        }
        return dp[0][n-1];
    }
};

Java

Source file

class Solution {
    public int strangePrinter(String s) {
        String str = removeDuplicates(s);
        char[] S = str.toCharArray();
        int n = S.length;
        int[][] dp = new int[n + 1][n + 1];
        return solve(S, dp, 0, n - 1);
    }

    private String removeDuplicates(String s) {
        StringBuilder sb = new StringBuilder();
        char[] cs = s.toCharArray();
        char curr = cs[0];
        sb.append(curr);
        for (char c : cs) {
            if (c == curr)
                continue;
            sb.append(c);
            curr = c;
        }
        return sb.toString();
    }

    private int solve(char[] cs, int[][] dp, int lt, int rt) {
        if (lt > rt)
            return 0;
        if (dp[lt][rt] != 0)
            return dp[lt][rt];
        int minTurns = 1 + solve(cs, dp, lt + 1, rt);
        char curr = cs[lt];
        for (int mid = lt + 1; mid <= rt; mid++) {
            if (curr == cs[mid])
                minTurns = Math.min(minTurns,
                        solve(cs, dp, lt, mid - 1) + solve(cs, dp, mid + 1, rt));
        }
        return dp[lt][rt] = minTurns;
    }
}