力扣解题思路：分割回文串

思路：

因为题目要求不是分割的方法种数，而是具体的分割方法，所以用dfs比较合适，那如果直接用dfs暴力遍历各种可能显然是不高效的，因此我们可以用一个set记录所有出现的回文子串（记忆化递归），这就不用每遇到一个子串就判断一次是不是回文字串了：

class Solution {
    List<List<String>> res = new ArrayList<>();
    Set<String> set = new HashSet<>();
    public List<List<String>> partition(String s) {
        if(s.length() == 0) return res;

        dfs(s,0,new ArrayList<>());

        return res;  
    }

    public void dfs(String s,int start,List<String> list){
        if(start == s.length()){
            res.add(new ArrayList<>(list));
            return;
        }
        for(int i=start;i<s.length();i++){
            if(set.contains(s.substring(start,i+1)) || is(s.substring(start,i+1))){
                list.add(s.substring(start,i+1));
                dfs(s,i+1,list);
                list.remove(list.size()-1);
            }
        }
    }

    public boolean is(String sub){
        if(sub.length() == 0) return false;
        int i = 0;
        int j = sub.length()-1;
        while(i<j){
            if(sub.charAt(i) != sub.charAt(j)){
                return false;
            }
            i++;
            j--;
        }
        set.add(sub);
        return true;
    }
}

思路：

    public int minCut(String s) {
        int len = s.length();
        if (len < 2) {
            return 0;
        }

        int[] dp = new int[len];
        for (int i = 0; i < len; i++) {
            dp[i] = i;
        }

        for (int i = 1; i < len; i++) {
            if (checkPalindrome(s, 0, i)) {
                dp[i] = 0;
                continue;
            }
            // 当 j == i 成立的时候，s[i] 就一个字符，一定是回文
            // 因此，枚举到 i - 1 即可
            for (int j = 0; j < i; j++) {
                if (checkPalindrome(s, j + 1, i)) {
                    dp[i] = Math.min(dp[i], dp[j] + 1);
                }
            }
        }
        return dp[len - 1];
    }

    private boolean checkPalindrome(String s, int left, int right) {
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }