程序员面试代码指南 回文最少分割数

给定一个字符串str，返回吧str全部切成回文子串的最小分割数
输入：str = “ACDCDCDAD”
输出：3
因为 str能分成 A CDCDC DAD三个回文子串

这道题考虑用动态规划做
dp[i]表示从str(0)…str(i)的最少回文分割数。dp[i]是从dp[i-1],dp[i-2],….dp[0]状态变化过来，取其中的最小值。
如果str[j],str[j+1]…str[i]构成回文，则能确保dp[i]<= dp[j-1] +1。
现在的问题是如果快速确定str[j],str[j+1]…str[i]是不是回文。还是用动态规划，维护一个二维数组，
boolen[][] p,如果p[i][j]是true代表str[i] str[i+1] …. str[j]是回文
原来写的代码是这样的：

public class Main {
    public static void main(String[] args) {
        String s = "ACDCDCDAD";
        System.out.println(minCut(s));
    }
    public static int minCut(String str){
        if (str == null || str.length() ==0){
            return 0;
        }
        boolean[][] p = new boolean[str.length()][str.length()];
        int[] dp = new int[str.length()];
        dp[0] = 0;
        for (int i = 0; i < str.length(); i++) {
            for (int j = i; j < str.length(); j++) {
                if (i == j || (j-i == 1 && str.charAt(i) == str.charAt(j)) || (i>0 && str.charAt(i) == str.charAt(j) && p[i+1][j-1]) == true){
                    p[i][j] = true;
                }
                else {
                    p[i][j] = false;
                }
            }
        }
        for (int i = 1; i < str.length(); i++) {
            int min = Integer.MAX_VALUE;
            for (int j = 0; j < i; j++) {
                if (p[j][i] == true){
                    if (j != 0){
                        if (min > dp[j-1] + 1){
                            min = dp[j-1] + 1;
                        }
                    }
                    else {
                        min = 0;
                    }
                }
            }
            dp[i] = min;
        }
        return dp[str.length() -1];
    }
}

从上到下，从左到右遍历，这样是错误的。因为判断回文的状态方程是这样的：
if(i == j || (j-i == 1 && str.charAt(i) == str.charAt(j)) || (i>0 && str.charAt(i) == str.charAt(j) && p[i+1][j-1]) == true){
p[i][j] = true;
}
这里有三种情况：
一、如果i== j，就是字符子串只有一个字符，所以肯定是回文。
二、如果有两个字符，如果这两个字符相等，是回文
三、两个以上的字符，如果最左边和最右边的字符相等，并且中间的字符串是回文，则这个字符子串也是回文。
p[i][j] 是从p[i+1][j-1]变化而来，说明如果是按正常顺序，从上往下，从左往右遍历的话，计算p[i][j]的时候得到p[i+1]行的结果呢。
所以这里的遍历要从最后一行还是，即从下往上，从左往右遍历。
所以代码应该如下

public class Main {
    public static void main(String[] args) {
        String s = "ACDCDCDAD";
        System.out.println(minCut(s));
    }
    public static int minCut(String str){
        if (str == null || str.length() ==0){
            return 0;
        }
        boolean[][] p = new boolean[str.length()][str.length()];
        int[] dp = new int[str.length()];

        for (int i = str.length() -1; i >= 0; --i) {
            for (int j = i; j < str.length(); j++) {
                if (i == j || (j-i == 1 && str.charAt(i) == str.charAt(j)) || (i+1 < str.length() && j - 1 >= 0 && str.charAt(i) == str.charAt(j) && p[i+1][j-1]) == true){
                    p[i][j] = true;
                }
                else {
                    p[i][j] = false;
                }
            }
        }
        for (int i = 1; i < str.length(); i++) {
            int min = i;
            for (int j = 0; j <= i; j++) {  //注意此处
                if (p[j][i] == true){
                    if (j != 0){
                        if (min > dp[j-1] + 1){
                            min = dp[j-1] + 1;
                        }
                    }
                    else {
                        min = 0;
                    }
                }
            }

            dp[i] = min;
        }
        return dp[str.length() -1];
    }
}

注意代码中的for (int j = 0; j <= i; j++) { //注意此处
if (p[j][i] == true){
if (j != 0){
if (min > dp[j-1] + 1){
min = dp[j-1] + 1;
}
这里j<= i，str[i]自己本身也是回文，也要考虑j==i，dp[j-1]+1（dp[i-1]+1）的可能性