39.组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。
示例 2：输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]
示例 3：输入: candidates = [2], target = 1
输出: []

注意candidates中的数字可以无限次重复被读取
还是和回溯法模板一样，全局变量path和res。需要一个startIndex控制for循环的起始位置。
什么时候需要startIndex：一个集合求组合（例如昨天的两道题）
多个集合求组合就不需要startIndex（电话号码）

每个数字可以重复利用：startIndex每次不用+1。

优化：如果在for循环中剪枝，就需要对数组先进行排序，这样如果sum+candidates[i]>target，那么后面的i肯定也都不符合条件。

class Solution {List<Integer> path;List<List<Integer>> res;int[] candidates;public List<List<Integer>> combinationSum(int[] candidates, int target) {path = new ArrayList<>();res = new ArrayList<>();this.candidates = candidates;Arrays.sort(this.candidates);backtracking(target, 0, 0);return res;}void backtracking(int target, int sum, int startIndex) {// if (target < sum) {//     return;// }if (target == sum) {res.add(new ArrayList<Integer>(path));return;}for (int i = startIndex; i < candidates.length && sum + candidates[i] <= target; i++) {path.add(candidates[i]);sum += candidates[i];backtracking(target, sum, i);sum -= candidates[i];path.remove(path.size() - 1);}}
}

40.组合总和II

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。

示例 1:输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
示例 2:输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

数字可以重复，但是不能超过在candicates中出现的次数。比如candidates有两个1，那结果集合不能超过2个1。
所以在上一题的基础上，需要引入一个布尔数组used，标志每个candidates中的数是否被使用了（加入了path）。
Java初始化boolean数组都是false。
回溯函数同样需要index，但是因为candidates中的值不能重复，所以继续回溯还是要i+1。

去重：
同一树枝使用过：同一树枝上的元素都是一个组合里的元素（path），不用去重
同一树层使用过：需要去重，去重前还要先对数组排序。同一树层上相同两个重复元素不能重复选取。所以判断条件就是candidates[i-1]==candidates[i]&&used[i-1]==false。used[i-1]是false说明了i-1元素在上一次回溯使用过，所以不能再选。

class Solution {int[] candidates;List<List<Integer>> res;List<Integer> path;public List<List<Integer>> combinationSum2(int[] candidates, int target) {Arrays.sort(candidates); // 树层去重需要对数组排序this.candidates = candidates;res = new ArrayList<>();path = new ArrayList<>();boolean[] used = new boolean[candidates.length];backtracking(target, 0, 0, used);return res;}void backtracking(int target, int sum, int startIndex, boolean[] used) {if (sum == target) {res.add(new ArrayList<Integer>(path));return;}for (int i = startIndex; i < candidates.length && sum + candidates[i] <= target; i++) {if (i > 0 && candidates[i - 1] == candidates[i] && used[i - 1] == false) {continue;}sum += candidates[i];path.add(candidates[i]);used[i] = true;backtracking(target, sum, i + 1, used);used[i] = false;path.remove(path.size() - 1);sum -= candidates[i];}}
}

131.分割回文串

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

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

切割问题也类似组合问题，可以使用排序解决。需要一个startIndex标志每次分割开始的位置。
backtracking终止条件：startIndex>=s.length() startIndex已经走到了字符串末尾，说明分割完了
for循环从startIndex的位置开始遍历，每次判断[startIndex,i]子串（闭区间）是否是回文串，如果是，就分割，然后下次回溯从i+1开始。

class Solution {List<String> path;List<List<String>> res;public List<List<String>> partition(String s) {path = new ArrayList<>();res = new ArrayList<>();backtracking(s, 0);return res;}public void backtracking(String s, int startIndex) {if (startIndex >= s.length()) {res.add(new ArrayList<String>(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;}backtracking(s, i + 1);path.remove(path.size() - 1);}}public boolean isPalindrome(String s, int begin, int end) {while (begin < end) {if (s.charAt(begin) != s.charAt(end)) {return false;}begin++;end--;}return true;}
}