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.

Given s = "aab",

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

For this problem, the minimum cuts to achieve all single palindrome words could be defined as f[n]. To solve this problem, the dynamic programming is needed to be used. For any integer from 0 to i-1, the f[i] is depend on the minimum value of f[j] + 1 becuase if there any value less than it will update it.

 public class Solution {
     /**
      * @param s a string
      * @return an integer
      */
     public int minCut(String s) {
         if (s==null || s.length() == 0 ) {
             return 0;
         }
         int n = s.length();
         //preprocessing to store all the sub-string's boolean palindrome feature
         boolean[][] isPalindrome = getIsPalindorme(s);
         int[] f = new int[n+1];
         //initialize
         for (int i =0; i <= n; i++) {
             f[i] = i-1;
         }
         //DP
         for (int i = 1; i <= n; i++) {
             for (int j = 0; j < i; j++ ) {
                 if (isPalindrome[j][i-1]) {
                     f[i] = Math.min(f[i],f[j]+1);
                 }
             }
         }
         return f[n];
     }
     //this method is used to preprocess the result whether it is a panlindrome string of
     //the certain substring from index i to index j and store them all into a matrix
     public boolean[][] getIsPalindorme(String s) {
         int length = s.length();
         boolean [][] isPalindrome = new boolean[length][length];
         //initialize for all single characters
         for (int i = 0; i < length; i++) {
             //this means all the single character in the string could be used as
             //a palindrome word
             isPalindrome[i][i] = true;
         }
         //initialize for all two neighbor characters
         for (int i = 0; i < length-1; i++) {
             isPalindrome[i][i + 1] = (s.charAt(i) == s.charAt(i + 1));
         }
         //develop for all result from start to start + lengthj indexs subtring
         for (int delta = 2; delta <= length -1; delta++) {
             for (int start = 0; start + delta < length; start++) {
                 //the result of the string from index start to start+length
                 //is based on the result of string with index start+1 to start+length-1
                 //and and the two chars at start indexa and start +length index are equal
                 isPalindrome[start][start + delta]
                     = isPalindrome[start + 1][start + delta - 1] && s.charAt(start) == s.charAt(start + delta);
             }
         }
         return isPalindrome;
     }
 }