131. 分割回文串

回溯

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

class Solution {

    List<List<String>> list = new ArrayList<>();
    LinkedList<String> li = new LinkedList<>();

    public List<List<String>> partition(String s) {

        backtracking(s, 0);
        return list;
    }

    public void backtracking(String s, int startIndex){

        /**
         * 如果索引到了字符串末尾，说明已经找到了解
         */
        if (startIndex == s.length()){

            list.add(new ArrayList<>(li));
            return;
        }

        /**
         * 每次for循环，i从不同的起始位置开始，i代表的就是切割线
         * 每次在切割之前，需要先判断i前面的子串是否是回文，如果不是，那就不能在此处切割，i继续循环直到可以切割
         * 切割完以后，下一位i + 1成为新的起始位置，开始递归
         */
        for (int i = startIndex; i < s.length(); i++) {

            if (isPalindrome(s, startIndex, i)){
                li.add(s.substring(startIndex, i + 1));
            }
            else {
                continue;
            }

            backtracking(s, i + 1);
            li.removeLast();
        }
    }

    /**
     * 双指针判断回文
     */
    public boolean isPalindrome(String s, int start, int end){

        for (int left = start, right = end; left < right; left++, right--) {

            if (s.charAt(left) != s.charAt(right)){
                return false;
            }
        }

        return true;
    }
}

/**
 * 时间复杂度 O(n×2^n)
 * 空间复杂度 O(n^2)
 */

https://leetcode-cn.com/problems/palindrome-partitioning/