[LintCode] Palindrome Partitioning II

Given a string s, cut s into some substrings such that every substring is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of s.

Example

Given s = "aab",

Return 1 since the palindrome partitioning ["aa", "b"] could be produced using 1 cut.

Solution 1. Recursion and backtracking

A straightforward solution is to check all valid partitions and get the minimum cut.

1. First fix a substring and check if palindromic, if it is, add this substring to a list and 

recursively partition the rest of the string.

2. After the entire string is partitioned, update the min cut if necessary.

3. Backtrack to check other valid partitions. 

Efficiency: This algorithm is very inefficient for the following two reasons.

1. The same subproblem is computed redundantly. 

　 The following recursion tree shows this.

　　　　　　　　　　　　"aabbc"

　　　　　"abbc"　　　　　　　　　　　　　　"bbc"　　　　　　　　　　　　

　　　"bbc" 

 2.  Substring palindrome check does not use smaller substring's check result.

       For string "abcd",  if we've checked "bc" is not palindromic, then for sure 

　　"abcd" is not palindromic. isPalindorme() does the O(n) check for all substrings,

　　not using previous check results. 

public class Solution {
    public int minCut(String s) {
        if(s == null || s.length() == 0)
        {
            return -1;
        }
        ArrayList<Integer> minCut = new ArrayList<Integer>(1);
        minCut.add(s.length() - 1);
        
        minCutHelper(minCut, new ArrayList<String>(), s, 0);

        return minCut.get(0);
    }
    
    private void minCutHelper(ArrayList<Integer> currMinCut, 
                              List<String> curr,
                              String s, 
                              int startIdx)
    {
        if(curr.size() > 0 && startIdx >= s.length())
        {
            if((curr.size() - 1) < currMinCut.get(0))
            {
                currMinCut.set(0, curr.size() - 1);
            }
            return;
        }
        
        for(int i = startIdx; i < s.length(); i++)
        {
            if(isPalindrome(s, startIdx, i))
            {
                curr.add(s.substring(startIdx, i + 1));
                minCutHelper(currMinCut, curr, s, i + 1);
                curr.remove(curr.size() - 1);
            }
        }
    }
    
    private boolean isPalindrome(String str, int left, int right)
    {
        while(left <= right)
        {
            if(str.charAt(left) != str.charAt(right))
            {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

Solution 2. Dynamic Programming

To address the two performance issues in solution 1, we make some time-space tradeoff.

State:

pal[i][j] stores if s[i....j] is palindromic or not. 

minCuts[i] stores the minimal cuts needed to partition substring s[0....i].

Initialization:

pa[i][i] = true, as one character is palindromic.

pa[i][i + 1] = s.charAt(i) == s.charAt(i + 1).

minCuts[i] = i, as the most cuts for a string of length i + 1 is i. 

Function:

pal[i][j] = pal[i + 1][j - 1] && s.charAt(i) == s.charAt(j);  compute the result of shorter length substrings first, as they will be used to compute longer substrings' result.

For a given substring s[0...j], we check all possible partitions.

If pal[i][j] == true, s[i....j] is a valid palindromic partition, then the problem of s[0...j] can be reduced to s[0... i - 1] + 1, 1 represents the partition of s[i][j].

　　a.　　if i == 0, if s[0...j] is palindromic, then no cut is needed for s[0...j].

 　　　　   minCuts[j] = 0;

　　b.　　if i > 0, 

　　　　　minCuts[j] = Math.min(minCuts[j], minCuts[i - 1] + 1), i is from 1 to j;

public class Solution {
    public int minCut(String s) {
        if(s == null || s.length() <= 1){
            return 0;
        }    
        int len = s.length();
        int[] minCuts = new int[len];
        boolean[][] pal = new boolean[len][len];
        for (int i = 0; i < len; i++) {
            pal[i][i] = true;
        }
        for (int i = 0; i < len - 1; i++) {
            pal[i][i + 1] = (s.charAt(i) == s.charAt(i + 1));
        }
        for(int i = 0; i < len; i++){
            minCuts[i] = i;
        }
        for (int i = len - 3; i >= 0; i--) {
            for (int j = i + 2; j < len; j++) {
                pal[i][j] = pal[i + 1][j - 1] && s.charAt(i) == s.charAt(j);
            }
        }
        for(int i = 0; i < len; i++){
            for(int j = 0; j <= i; j++){
                if(pal[j][i]){
                    if(j == 0){
                        minCuts[i] = 0;
                    }
                    else{
                        minCuts[i] = Math.min(minCuts[i], minCuts[j - 1] + 1);
                    }
                }
            }
        }
        return minCuts[len - 1];
    }
}

The above dp uses a 1D array minCuts[i] to store min cut of substring s[0....i].  

This is similar with Text Justification and Word Break.

Text Justification:  minCost[i] = min { minCost[j] + cost[j + 1][i] }

Word Break:  dp[i] = dp[i - lastWordLen] && dict.contains(s.substring(i - lastWordLen, i));  

　　　　　　dp[i]: if s[0....... i - 1] can be broken into words in dict.

Related Problems 

Wiggle Sort II

Palindrome Partitioning 

Longest Palindromic Substring