1. 判断一个字符串是否是回文并记录其中的子串是否是回文

state:boolean[i][j]表示str[i,j]是否是回文串
由于要判断两个指针之间是否是回文，所以应该是一个矩阵的形式
function: boolean[i-1][j+1] = boolean[i][j] && str[i-1] == str[j+1];
如果str[i,j]是回文那么只要i-1与j+1的字符相等str[i-1,j+1]也是回文
init: i==j boolean[i][j] = true; j = i+1 boolean[i][j] = str[i] == str[j]
单个字符串肯定是回文， i与i+1表示两两相邻的是否是回文
return boolean[str.length-1][str.length-1]

2.

// f[i] 表示前i个字母，最少被切割几次可以切割为都是回文串。
// init: 前i个每个经过i-1次分割能保证都是回文串，也就是单个字符都是回文串
//dp[0,j]表示分割到j是最小的分割数，如果[j+1,i]是回文串，那么dp[0,i]就是dp[j] + 1
// 最后return f[n]

// f[i] 表示前i个字母，最少被切割几次可以切割为都是回文串。
// 最后return f[n]
public class Solution {
    private boolean isPalindrome(String s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }

    private boolean[][] getIsPalindrome(String s) {
        boolean[][] isPalindrome = new boolean[s.length()][s.length()];

        for (int i = 0; i < s.length(); i++) {
            isPalindrome[i][i] = true;
        }
        for (int i = 0; i < s.length() - 1; i++) {
            isPalindrome[i][i + 1] = (s.charAt(i) == s.charAt(i + 1));
        }

        for (int length = 2; length < s.length(); length++) {
            for (int start = 0; start + length < s.length(); start++) {
                isPalindrome[start][start + length]
                    = isPalindrome[start + 1][start + length - 1] && s.charAt(start) == s.charAt(start + length);
            }
        }

        return isPalindrome;
    }

    public int minCut(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }

        // preparation
        boolean[][] isPalindrome = getIsPalindrome(s);
        
        // initialize
        int[] f = new int[s.length() + 1];
        for (int i = 0; i <= s.length(); i++) {
            f[i] = i - 1;
        }
        
        // main
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 0; j < i; j++) {
                if (isPalindrome[j][i - 1]) {
                    f[i] = Math.min(f[i], f[j] + 1);
                }
            }
        }

        return f[s.length()];
    }
}