01.组合
回溯三部曲
- 确定递归函数参数
- 确定终止条件
- 单层搜索过程
别忘了处理过程 和 回溯过程是一一对应的，处理有加，回溯就要有减！
77. 组合
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
示例 1：
输入：n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> combine(int n, int k) {
process(n, k, 1);
return result;
}
/**
* 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
* @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
*/
private void process(int n, int k, int startIndex){
//终止条件
if (path.size() == k){
result.add(new ArrayList<>(path));
return;
}
////加速：n-(k-path.size())+1
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
path.add(i);
process(n, k, i + 1);
path.removeLast();
}
}
}
216. 组合总和 III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
所有数字都是正整数。
解集不能包含重复的组合。
示例 1:
输入: k = 3, n = 7
输出: [[1,2,4]]
示例 2:
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
本题k相当于了树的深度，9（因为整个集合就是9个数）就是树的宽度。
例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9]中求 k（个数） = 2, n（和） = 4的组合。
选取过程如图：
图中，可以看出，只有最后取到集合（1，3）和为4 符合条件。
class Solution {
private List<List<Integer>> res=new ArrayList<>();;
private LinkedList<Integer> path=new LinkedList<>();
public List<List<Integer>> combinationSum3(int k, int n) {
process(n,0,1,k);
return res;
}
private void process(int targetSum,int curSum,int startIndex,int k){
//base case
if(path.size()==k){
if(targetSum==curSum){
res.add(new ArrayList<>(path));
}
}
if(curSum>targetSum){
return;
}
for(int i=startIndex;i<=9-(k-path.size())+1;i++){
curSum+=i;
path.add(i);
process(targetSum,curSum,i+1,k);
// 回溯
path.removeLast();
// 回溯
curSum-=i;
}
}
}
17. 电话号码的字母组合
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例: 输入："23" 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。
例如：输入："23"，抽象为树形结构，如图所示：
图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，
输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。
本题每一个数字代表的是不同集合，也就是求不同集合之间的组合
class Solution {
List<String> res=new ArrayList<>();
public List<String> letterCombinations(String digits) {
if(digits==null|| digits.length()==0){
return res;
}
//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
String[] strArr={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
process(strArr,digits,0);
return res;
}
//每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuilder
StringBuilder path=new StringBuilder();
private void process(String[] strArr,String digits,int index){
if(index==digits.length()){
res.add(path.toString());
return;
}
int strIndex=digits.charAt(index)-'0';
//str 表示当前strIndex对应的字符串
String str=strArr[strIndex];
for(int i=0;i<str.length();i++){
path.append(str.charAt(i));
process(strArr,digits,index+1);
path.deleteCharAt(path.length()-1);
}
}
}
class Solution {
List<String> ans=new ArrayList<>();
public List<String> letterCombinations(String digits) {
if(digits.length()==0){
return ans;
}
//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
String[] strArr={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
String[] arr=new String[digits.length()];
for(int i=0;i<digits.length();i++){
arr[i]=strArr[digits.charAt(i)-'0'];
}
List<Character> path=new ArrayList<>();
process(arr,0,path);
return ans;
}
private void process(String[] arr,int index, List<Character> path){
if(index==arr.length){
ans.add(getPath(path));
return;
}
for(int i=0;i<arr[index].length();i++)
{
List<Character> pick=new ArrayList<>(path);
pick.add(arr[index].charAt(i));
process(arr,index+1,pick);
}
}
private String getPath(List<Character> path){
StringBuilder sb=new StringBuilder();
for(Character c:path){
sb.append(c);
}
return sb.toString();
}
}
class Solution {
List<String> ans=new ArrayList<>();
public List<String> letterCombinations(String digits) {
if(digits.length()==0){
return ans;
}
//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
String[] strArr={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
String[] arr=new String[digits.length()];
for(int i=0;i<digits.length();i++){
arr[i]=strArr[digits.charAt(i)-'0'];
}
process(arr,0);
return ans;
}
StringBuilder path=new StringBuilder();
private void process(String[] arr,int index){
if(index==arr.length){
ans.add(path.toString());
return;
}
for(int i=0;i<arr[index].length();i++)
{
path.append(arr[index].charAt(i));
process(arr,index+1);
path.deleteCharAt(path.length()-1);
}
}
}
39. 组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明：
- 所有数字（包括 target）都是正整数。
- 解集不能包含重复的组合。
示例 1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ]
示例 2： 输入：candidates = [2,3,5], target = 8, 所求解集为： [ [2,2,2,2], [2,3,3], [3,5] ]
本题搜索的过程抽象成树形结构如下：
class Solution {
private List<List<Integer>> res=new ArrayList<>();
List<Integer> path=new ArrayList<>();
public List<List<Integer>> combinationSum(int[] candidates, int target) {
// 先进行排序
Arrays.sort(candidates);
process(candidates,0,target,0);
return res;
}
private void process(int[] candidates,int index,int target,int sum){
// 找到了数字和为 target 的组合
if(target==sum){
res.add(new ArrayList<>(path));
return;
}
for(int i=index;i<candidates.length;i++){
sum+=candidates[i];
// 如果 sum + candidates[i] > target 就终止遍历
if(sum>target){
break;
}
path.add(candidates[i]);
// 不用i+1了，表示可以重复读取当前的数
process(candidates,i,target,sum);
// 回溯，移除路径 path 最后一个元素
path.remove(path.size()-1);
sum-=candidates[i];
}
}
}
40. 组合总和 II
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明： 所有数字（包括目标数）都是正整数。 解集不能包含重复的组合。
示例 1: 输入: candidates = [10,1,2,7,6,1,5], target = 8, 所求解集为: [ [1, 7], [1, 2, 5], [2, 6], [1, 1, 6] ]
示例 2: 输入: candidates = [2,5,2,1,2], target = 5, 所求解集为: [ [1,2,2], [5] ]
本题的难点在：集合（数组candidates）有重复元素，但还不能有重复的组合。
用set或者map去重，这么做很容易超时！
所谓去重，其实就是使用过的元素不能重复选取。 这么一说好像很简单！
都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。
那么问题来了，我们是要同一树层上使用过，还是同一树枝上使用过呢？
回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。
所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。
举一个例子，candidates = [1, 1, 2], target = 3，（方便起见candidates已经排序了）
强调一下，树层去重的话，需要对数组排序！
选择过程树形结构如图所示：
可以看到图中，每个节点相对于 39.组合总和 (opens new window)我多加了used数组
回溯三部曲
- 递归函数参数
加一个bool型数组used，用来记录同一树枝上的元素是否使用过。
这个集合去重的重任就是used来完成的。
- 递归终止条件
终止条件为 sum > target 和 sum == target。
sum > target 这个条件其实可以省略，因为和在递归单层遍历的时候，会有剪枝的操作
- 单层搜索的逻辑
要去重的是“同一树层上的使用过”，如何判断同一树层上元素（相同的元素）是否使用过了呢。
如果candidates[i] == candidates[i - 1]
并且 used[i - 1] == false，
就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。
此时for循环里就应该做continue的操作。
这块比较抽象，如图：
我在图中将used的变化用橘黄色标注上，可以看出在candidates[i] == candidates[i - 1]相同的情况下：
- used[i - 1] == true，说明同一树支candidates[i - 1]使用过
- used[i - 1] == false，说明同一树层candidates[i - 1]使用过
class Solution {
List<List<Integer>> lists = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
int sum = 0;
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
//为了将重复的数字都放到一起，所以先进行排序
Arrays.sort(candidates);
//加标志数组，用来辅助判断同层节点是否已经遍历
boolean[] flag = new boolean[candidates.length];
backTracking(candidates, target, 0, flag);
return lists;
}
public void backTracking(int[] arr, int target, int index, boolean[] flag) {
if (sum == target) {
lists.add(new ArrayList(path));
return;
}
for (int i = index; i < arr.length && arr[i] + sum <= target; i++) {
//出现重复节点，同层的第一个节点已经被访问过，所以直接跳过
if (i > 0 && arr[i] == arr[i - 1] && !flag[i - 1]) {
continue;
}
flag[i] = true;
sum += arr[i];
path.push(arr[i]);
//每个节点仅能选择一次，所以从下一位开始
backTracking(arr, target, i + 1, flag);
int temp = path.pop();
flag[i] = false;
sum -= temp;
}
}
}
class Solution {
List<List<Integer>> ans=new ArrayList<>();
LinkedList<Integer> path=new LinkedList<>();
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
process(candidates,target,0,0);
return ans;
}
private void process(int[] nums,int target,int sum,int index){
if(sum==target){
ans.add(new ArrayList<>(path));
return;
}
Set<Integer> set=new HashSet<>();
for(int i=index;i<nums.length;i++){
if(!set.contains(nums[i]))
{
set.add(nums[i]);
sum+=nums[i];
if(sum>target){
break;
}
path.add(nums[i]);
process(nums,target,sum,i+1);
path.removeLast();
sum-=nums[i];
}
}
}
}
