LeetCode No132. 分割回文串 II

题目描述

解法一：记忆化递归

class Solution {
    private char[] cs;
    private int[] temp; //记忆化数组
    public int minCut(String s) {
        this.cs = s.toCharArray();
        this.temp = new int[cs.length];
        return dfs(0) - 1;
    }

    /**
     * 检查字符串s[from,...,to]是不是回文
     * @param from 开始索引
     * @param to 结束
     * @return
     */
    private boolean check(int from,int to){
        int i = from,j = to;
        while(i < j && cs[i] == cs[j]){
            ++i;
            --j;
        }
        return i >= j;
    }

    private int dfs(int startIndex){
        if(startIndex == cs.length){
            return 0;
        }
        if(temp[startIndex] > 0){
            return temp[startIndex];
        }
        int j = cs.length - 1;
        int res = 2001;
        while(j >= startIndex){
            if(check(startIndex,j)){
                res = Math.min(res,1 + dfs(j + 1));
            }
            --j;
        }
        temp[startIndex] = res;
        return res;
    }
}

解法二：动态规划

class Solution {
    public int minCut(String s) {
        char[] cs = s.toCharArray();
        int n = cs.length;
        int[] dp = new int[n + 1];
        dp[0] = 0;
        for (int i = 1; i <= n; i++) {
            dp[i] = 2001;
            for (int j = 0; j < i; j++) {
                if(check(cs,j,i-1)){
                    dp[i] = Math.min(dp[i],dp[j] + 1);
                }
            }
        }
        return dp[n] - 1;
    }


    private boolean check(char[] cs, int from, int to) {
        int i = from, j = to;
        while (i < j && cs[i] == cs[j]) {
            ++i;
            --j;
        }
        return i >= j;
    }
}