39. 组合总和
分析这道题的搜索过程如下：
因为这道题没有限制要搜索几层，所以可以一直搜索直到sum==target或者sum>target就return
回溯三部曲
1.递归函数参数
本题还需要startIndex来控制for循环的起始位置，对于组合问题，什么时候需要startIndex呢？
果是一个集合来求组合的话，就需要startIndex，例如：77.组合 (opens new window)，216.组合总和III (opens new window)。
如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合
2.终止条件
从叶子节点可以清晰看到，终止只有两种情况，sum大于target和sum等于target。
注意sum等于target的时候，需要收集结果
3.单层搜索的逻辑
单层for循环依然是从startIndex开始，搜索candidates集合。
注意本题和77.组合 (opens new window)、216.组合总和III (opens new window)的一个区别是：本题元素为可重复选取的。
//递归逻辑
for(int i=startIndex;i<candidates.length;i++){
sum+=candidates[i];
path.add(candidates[i]);
backtracking(candidates,target,sum,i);//不用i+1,因为这道题是可以重复读取元素的
sum-=candidates[i];//回溯
path.removeLast();//移除最新加入的元素
}总体代码
class Solution {
List<List<Integer>> res=new ArrayList<List<Integer>>();
LinkedList<Integer> path=new LinkedList<Integer>();
//无限制重复被选取
//只要选取的元素总和超过target，就返回！
public List<List<Integer>> combinationSum(int[] candidates, int target) {
Arrays.sort(candidates);//可要可不要
backtracking(candidates,target,0,0);
return res;
}
public void backtracking(int[] candidates, int target,int sum,int startIndex){
//递归终止条件
// sum==target或者sum>target,就return
if(sum==target){
res.add(new ArrayList<>(path));
}
if(sum>target){
return;
}
//递归逻辑
for(int i=startIndex;i<candidates.length;i++){
sum+=candidates[i];
path.add(candidates[i]);
backtracking(candidates,target,sum,i);//不用i+1,因为这道题是可以重复读取元素的
sum-=candidates[i];//回溯
path.removeLast();//移除最新加入的元素
}
}
}4.剪枝优化
在递归逻辑中如果sum>target了，那就不需要再继续遍历了，所以需要剪枝的部分是
for(int i=startIndex;i<candidates.length&&sum<=target;i++){40.组合总和II
这道题因为其数组candidates有重复元素，而要求返回的结果不能有重复的组合，所以相对于39.组合总和 (opens new window)难度提升了不少。
问题1.要去重的是哪里
所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。
强调一下，树层去重的话，需要对数组排序！
可以看到图中，每个节点相对于 39.组合总和 (opens new window)我多加了used数组，
用来记录同一树枝上的元素是否使用过。这个集合去重的重任就是used来完成的。
问题2.要去重的是“同一树层上的使用过”，如何判断同一树层上元素（相同的元素）是否使用过了呢。
如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝(一条路径可以看成一个树枝)，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。
此时for循环里就应该做continue的操作。跳过当前遍历的candidates[i]
我在图中将used的变化用橘黄色标注上，可以看出在candidates[i] == candidates[i - 1]相同的前提(注意这个前提)下：
- used[i - 1] == true，说明同一树枝candidates[i - 1]使用过（这是递归）
- used[i - 1] == false，说明同一树层candidates[i - 1]使用过，因为这一部分会回溯才能到同一树层，所以used[i-1]会等于false（这是回溯）
问题3.可能有的录友想，为什么 used[i - 1] == false 就是同一树层呢？
因为同一树层，used[i - 1] == false 才能表示，当前取的 candidates[i] 是从 candidates[i - 1] 回溯而来的。而 used[i - 1] == true，说明是进入下一层递归，去下一个数，所以是树枝上，如图所示：
回溯三部曲
1.递归函数参数
同39.组合总和 (opens new window)，此题还需要加一个bool型数组used，用来记录同一树枝上的元素是否使用过。
2.终止条件
同39题
3.单层搜索的逻辑
如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。
实现代码
//candidates 中的每个数字在每个组合中只能使用 一次 。
class Solution {
List<List<Integer>> res=new ArrayList<>();
LinkedList<Integer> path=new LinkedList<Integer>();
boolean[] used;
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
used=new boolean[candidates.length];
Arrays.sort(candidates);//排序是为了让相同的元素聚集在一起，方便判断同一层是不是已使用过这个元素
backtracking(candidates,target,0,0);
return res;
}
public void backtracking(int[] candidates, int target,int sum,int startIndex){
//1.终止条件
if(sum==target){
res.add(new ArrayList<>(path));//如果补new的话加入的path都是空集
return;
}
if(sum>target){
return;
}
//2.递归逻辑
//
for(int i=startIndex;i<candidates.length&&sum<target;i++){
if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==false){//同一树层不能返回相同的元素，要跳过
continue;
}
used[i]=true;//标记下标为i的这个数字被使用了
sum+=candidates[i];
path.add(candidates[i]);
backtracking(candidates,target,sum,i+1);//每个数字只能用1次，所以i+1要遍历下一个数字
used[i]=false;//回溯
sum-=candidates[i];//回溯
path.removeLast();//移除path中最新加入的元素
}
}
}131.分割回文串
问题1 回溯究竟是如何切割字符串呢？
切割问题，也可以抽象为一棵树形结构，如图：
递归用来纵向遍历，for循环用来横向遍历，切割线（就是图中的红线）切割到字符串的结尾位置，说明找到了一个切割方法。
此时可以发现，切割问题的回溯搜索的过程和组合问题的回溯搜索的过程是差不多的。
回溯三部曲
1.递归函数参数
本题递归函数参数还需要startIndex，因为切割过的地方，不能重复切割，和组合问题也是保持一致的。
在回溯算法：求组合总和（二） (opens new window)中我们深入探讨了组合问题什么时候需要startIndex，什么时候不需要startIndex。
2.终止条件
切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。
那么在代码里什么是切割线呢？
在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。
3.单层搜索的逻辑
来看看在递归循环中如何截取子串呢？
在for (int i = startIndex; i < s.size(); i++)循环中，我们 定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。
首先判断这个子串是不是回文，如果是回文，就加入在vector<string> path中，path用来记录切割过的回文子串。
代码实现
class Solution {
List<List<String>> res=new ArrayList<>();
LinkedList<String> path=new LinkedList<>();
public List<List<String>> partition(String s) {
backtracking(s,0);
return res;
}
public void backtracking(String s,int startIndex){
//终止条件
//如果起始的位置大于s的大小，说明已经找到一组分割方案了
if(startIndex>=s.length()){
res.add(new ArrayList<>(path));
return;
}
// 搜索逻辑
for(int i=startIndex;i<s.length();i++){
if(isPalindrome(s,startIndex,i)){ //是回文，要添加
String str = s.substring(startIndex, i + 1);
path.add(str);
}
else{
continue;//不是回文，说明这种分割不对，return
}
backtracking(s,i+1); //回溯，继续横向分割(参考树的搜索过程)
path.removeLast();//回溯
}
}
//判断是否为回文
boolean isPalindrome(String s,int start,int end){
for(int i=start,j=end;i<=j;i++,j--){
if(s.charAt(i)!=s.charAt(j)){//
return false;
}
}
return true;
}
}总结默念：
回溯三部曲：
1.递归函数参数和返回值
2.递归终止条件
3.单层搜索的逻辑
