回文最小分割数

首先，这是一道动态规划的题目，并且借助了辅助的数据结构
文章将先定义状态，然后介绍辅助的数据结构

定义状态

// 从后向前
    public int myMinCut(String str) {
        if(str == null || str.length() == 0) return 0;

        char[] input = str.toCharArray();

        int len = input.length;

        //记录了input[i~j]是否是一个回文子串
        boolean[][] judgement = new boolean[len][len];

        //初始dp，dp[len] = 0,这样当j = len - 1时，访问dp[j + 1] 也不会发生数组访问越界
        int[] dp = new int[len + 1];
        dp[len] = -1;

        //从i~n-1需要几次划分，枚举j，进行[i-j],[j+1-n-1]的划分
        for(int i = len-1; i >=0; i-- ) {
            //初始化dp[i]
            //System.out.println(i);
            dp[i] = Integer.MAX_VALUE;
            for(int j = i; j < len; j++) {
                //在内循环中，需要同时维护judgement
                if(i == j) {
                    //一定要加上i==j的判断，直接用input[i] == input[j]判断会越界
                    judgement[i][j] = true;
                }else if(input[i] == input[j]) {
                    if(j-i < 2) {
                        judgement[i][j] = true;
                    }else {
                        judgement[i][j] = judgement[i+1][j-1];
                    }
                }else { 
                    //初始就为false，可以不写，但为了逻辑完整，在这里添上
                    judgement[i][j] = false;
                }

                //利用judgement[i][j]的结果更新dp
                if(judgement[i][j]) {
                    dp[i] = Math.min(dp[i], dp[j+1] + 1);
                }
            }
        }
        /**
        int result = Integer.MAX_VALUE;
        for(int i = 0; i < len; i++) {
            if(dp[i] < result) result = dp[i];
        }**/

        return dp[0];
    }