131.分割回文串

题目

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]
示例 2：

输入：s = "a"
输出：[["a"]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-partitioning
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

思路

将s分割成一些子串，使每个子串都是回文串。
先枚举s可以分割成哪些子串，在判断哪些子串是回文串。分割相当于在字符串s上划线，元素之间的位置是不变的。

以'abba'为例子

在枚举abba子串的时候，步骤是这样的：
先切割a，在剩下的bba开始切割第二段，切割b，在剩下的ba中切割第三段...

这样看切割问题其实有点类似组合问题，都是从头开始取，组合问题一次取一个数，去一个数，再取一个数...；切割可以一次取多个，先切一个元素，再切两个元素..。考虑到回溯的本质是枚举，而回溯法都可以抽象成一颗树。就尝试把这道题抽象成一棵树，感觉这个思路是可行的。

递归的参数和返回值
切割问题必须的肯定是切割的起始点和切割的终点。
切割的终点是横向遍历for控制的
切割的起点是纵向遍历递归控制的
那么就需要一个参数startIndex去标识切割字符串s的起点。

s: 传入需要切割的字符串
startIndex: 切割的起点

List<List<String>> res;
List<String> path;
void backtracking(String s,int startIndex);

递归的终止条件
递归的层数是不确定，停止条件是切割到字符串的最后

 if(startIndex == s.length()){
 res.add(new ArrayList(path));
 return;
 }

单层递归逻辑
获取当前截取的子串，如果子串是回文串，加入path，继续往下递归；如果不是回文串则进行下一次循环;

String substring(int beginIndex,int endIndex):返回一个新的字符串，从begin开始、end结束

每层递归中的i+1其实还代表了取几个元素，i=starIndex说没是每层树的开头节点，取1个值，end也就是i+1;第二个节点是从startIndex开始取两个值，end也就是startIndex+2，此时i=startIndex+1

    for(int i = startIndex;i<s.length();i++){
		   String cur = s.substring(startIndex,i+1);
            if(!huiwen(cur))continue;
            path.add(cur);
            backtracking(s,i+1);
            path.remove(path.size()-1);
        }

如何判断是否回文串？
从左到右该字符第一次出现的位置应该和从右到左第一次出现的位置是相等的。
使用双指针，减少循环的次数。左右指针指的字符应该是相等的，如果不是相等的,说明不是回文串。

    boolean huiwen(String s){
        for(int left=0,right=s.length();left<right ;left++,right--){
            if(s.charAt(left)!=s.charAt(right)) return false;
        }
        return true;
    }

题解

class Solution {
    List<List<String>> res;
    List<String> path;
    public List<List<String>> partition(String s) {
         res = new ArrayList<>();
         path = new ArrayList<>();
         backtracking(s,0);
         return res;
    }
    void backtracking(String s,int startIndex){
        if(startIndex == s.length()){
            res.add(new ArrayList(path));
            return;
        }
        for(int i = startIndex;i<s.length();i++){
	    //因为截取字符串是消耗性能的，因此，采用传子串下标的方式判断一个子串是否是回文子串，不是回文就不需要截取了
            String cur = s.substring(startIndex,i+1);
            if(!huiwen(cur))continue;
            path.add(cur);
            backtracking(s,i+1);
            path.remove(path.size()-1);
        }
    }
    boolean huiwen(String s){
        for(int left=0,right=s.length()-1;left<right ;left++,right--){
            if(s.charAt(left)!=s.charAt(right)) return false;
        }
        return true;
    }
}


   //修改后的函数
    void backtracking(String s,int startIndex){
        if(startIndex == s.length()){
            res.add(new ArrayList(path));
            return;
        }
        for(int i = startIndex;i<s.length();i++){  
            if(!huiwen(s,startIndex,i+1))continue;
            String cur = s.substring(startIndex,i+1);
            path.add(cur);
            backtracking(s,i+1);
            path.remove(path.size()-1);
        }
    }
    boolean huiwen(String s,int startIndex,int end){
        for(int left=startIndex,right=end-1;left<right ;left++,right--){
            if(s.charAt(left)!=s.charAt(right)) return false;
        }
        return true;
    }
}