77 组合 17 电话号码的字母组合 216 组合总和III 39 组合总和 40 组合总和II 回溯法，一般可以解决如下几种问题（都可以抽象为树形结构，N叉树）： 组合问题：N个数里面按一定规则找出k个数的集合 切割问题：一个字符串按一定规则有几种切割方式 子集问题：一个N个数的集合里有多少符合条件的子集 排列问题：N个数按一定规则全排列，有几种排列方式 棋盘问题：N皇后，解数独等等 void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
回溯：
定义全局变量存储符合条件的一个结果和所有符合条件的结果集合，定义整数startIndex存储当前递归从哪里开始遍历（每次选择范围随着选择的进行而收缩）； 如果结果数组的长度符合条件，则保存结果数组到集合，终止递归； for循环从startIndex开始遍历，将节点保存到中数组中，数组符合条件时将数组加入数组集合，回溯后撤销本次递归处理的结果。 优化：每层for循环的上限修改为n - (k - path.size()) + 1。 class Solution {
//定义全局变量存储符合条件的一个结果和所有符合条件的结果集合
LinkedList<Integer> res = new LinkedList<>();
List<List<Integer>> result = new LinkedList<>();
public List<List<Integer>> combine(int n, int k) {
//定义整数存储当前递归从哪里开始遍历（每次选择范围随着选择的进行而收缩）
int startIndex = 1;
//开始回溯
backtracking(n, k, startIndex);
//返回结果
return result;
}
//回溯函数
private void backtracking(int n, int k, int startIndex){
//果结果数组的长度符合条件，则保存结果数组到集合，终止递归
if(res.size() == k){
result.add(new LinkedList<>(res));
return;
}
//for循环从定义的收缩整数开始遍历，将节点保存到中数组中
for(int i = startIndex; i <= n; i++){
res.add(i);
//回溯
backtracking(n, k, i + 1);
//回溯后撤销本次递归处理的结果
res.removeLast();
}
}
}
回溯：定义数组映射数字和字母。
定义全局字符串存储结果，定义全局字符串数组存储所有字符串，定义整数index记录遍历第几个数字； 如果index等于输入的数字个数，则将结果存储到数组中，结束递归； 通过index和Map获取字母集合，然后for循环遍历字母集合。 注意：
不同于上题77 组合，for循环不是从index开始，因为本题求的是每个数字代表的集合的组合，而上题为同一集合中多次循环。 实际需要考虑输入非法（0或1等）情况。 可以使用字符减去‘0’来定义数组映射字母。 字符串处理StringBuilder，转为字符串toString()，添加字符append()，删除指定位置的字符deleteChatAt()。 class Solution {
//定义全局字符串存储结果，定义全局字符串数组存储所有字符串
StringBuilder res = new StringBuilder();
List<String> result = new LinkedList<>();
public List<String> letterCombinations(String digits) {
if(digits.length() == 0) return result;
//定义数组映射数字和字母。
//实际需要考虑输入非法（0或1等）情况
String[] nums = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
//定义整数index记录遍历第几个数字（下标）
int index = 0;
//开始回溯
backtracking(digits, nums, index);
//返回结果
return result;
}
//回溯函数
private void backtracking(String digits, String[] nums, int index){
//如果index等于输入的数字个数，则将结果存储到数组中，结束递归
if(index == digits.length()){
result.add(res.toString());
return;
}
//通过index和数组获取字母集合，然后for循环遍历字母集合
String s = nums[digits.charAt(index) - '0'];
//for循环不是从index开始
for(int i = 0; i < s.length(); i++){
//存储字符到字符串
res.append(s.charAt(i));
//回溯
backtracking(digits, nums, index + 1);
//回溯后撤销本次递归处理的结果
res.deleteCharAt(res.length() - 1);
}
}
}
回溯：对比上面的77 组合，增加了个数限制。
定义全局数组存放符合条件的结果，定义全局二维数组存放结果集合，输入目标和，个数要求，已经累加的元素和，下层for循环起始位置startIndex； 当取了要求个数后结束，然后判断累加元素和是否等于目标值（也可以使用目标值递减，减为0时符合条件），若等于则将结果放入结果集合，然后返回，否则直接返回； for循环从startIndex开始，上限固定为9。 优化：
如果还没选取到要求个数，但是累加元素和已经超过目标值，可以直接结束。 同77 组合，for循环上限也可修改为9 - (k - path.size()) + 1。 class Solution {
//定义全局数组存放符合条件的结果，定义全局二维数组存放结果集合
LinkedList<Integer> res = new LinkedList<>();
List<List<Integer>> result = new LinkedList<>();
public List<List<Integer>> combinationSum3(int k, int n) {
//输入目标和，个数要求，已经累加的元素和，下层for循环起始位置startIndex
int sum = 0;
int startIndex = 0;
int[] nums = {1,2,3,4,5,6,7,8,9};
//开始回溯
backtracking(nums, n, k, sum, startIndex);
//返回结果
return result;
}
//回溯函数
private void backtracking(int[] nums, int n, int k, int sum, int startIndex){
//优化：如果还没选取到要求个数，但是累加元素和已经超过目标值，可以直接结束。
if(sum > n) return;
//当取了要求个数后结束
if(res.size() == k){
//然后判断累加元素和是否等于目标值（也可以使用目标值递减，减为0时符合条件）
if(sum == n){
//若等于则将结果放入结果集合，然后返回
result.add(new LinkedList<>(res));
}
//否则直接返回
return;
}
//for循环从startIndex开始，上限固定为9，可优化为9 - (k - res.size()) + 1
for(int i = startIndex; i < (9 - (k - res.size()) + 1); i++){
//累加元素
res.add(nums[i]);
sum += nums[i];
//回溯
backtracking(nums, n, k, sum, i + 1);
//回溯
res.removeLast();
sum -= nums[i];
}
}
}
回溯：对比开始的77 组合以及上题216 组合总和III，本题不要求元素数量，还可以重复选取元素，只要元素和符合要求。
定义全局数组存放符合条件的结果，定义全局二维数组存放结果的集合。使用startIndex控制for循环的起始位置，可以使用目标值递减，减为0时符合条件； 当和等于目标值时，将结果保存到数组集合，然后返回，当和大于目标值时，直接返回； for循环从startIndex开始，遍历给定的数组，回溯时startIndex不用加1，因为单个元素可以重复选择。 优化：在进入下一层递归时，先判断和是否大于目标值，若大于，则不用进入下一层递归，结束本轮for循环。 class Solution {
//定义全局数组存放符合条件的结果，定义全局二维数组存放结果的集合
LinkedList<Integer> res = new LinkedList<>();
List<List<Integer>> result = new LinkedList<>();
public List<List<Integer>> combinationSum(int[] candidates, int target) {
//使用startIndex控制for循环的起始位置，可以使用目标值递减，减为0时符合条件
int startIndex = 0;
//开始回溯
backtracking(candidates, target, startIndex);
//返回结果
return result;
}
//回溯
private void backtracking(int[] candidates, int target, int startIndex){
//当和等于目标值时，将结果保存到数组集合，然后返回，当和大于目标值时，直接返回
if(target == 0){
result.add(new LinkedList<>(res));
return;
}
if(target < 0) return;
//for循环从startIndex开始，遍历给定的数组
for(int i = startIndex; i < candidates.length; i++){
//累加元素（目标值递减）
res.add(candidates[i]);
target -= candidates[i];
//回溯时startIndex不用加1，因为单个元素可以重复选择
backtracking(candidates, target, i);
//回溯
res.removeLast();
target += candidates[i];
}
}
}
回溯：对比上题39 组合总和，本题单个元素不能重复使用，并且题目给定的数组中元素是可以重复的，结果要求不能重复，因此需要添加一个布尔型数组记录横向遍历时使用的数，在for循环时进行去重（需要对给定数组进行排序）。
输入给定数组，目标值，for循环起始位置startIndex，布尔型数组； 当和大于等于目标值时终止； 如果当前取出元素与上一个元素相同（排序后），且上一个元素对应布尔型数组为false，说明横向遍历（同一树层）使用过该元素，则跳过该元素。 注意：因为单个元素不能重复使用，所以回溯时startIndex需要加1。 补充：如果当前取出元素与上一个元素相同（排序后），且上一个元素对应布尔型数组为true，说明纵向遍历（同一树根）使用过该元素。 优化：同（4）39 组合总和，先判断和是否大于目标值，若大于，则不用进入下一层递归，结束本轮for循环（此时开头判断和大于目标值则可以省略）。横向循环去重也可以直接借助startIndex（当for循环的i大于startIndex且当前元素与上一元素相等时说明已使用，跳过）。 注意：数组排序Arrays.sort()。布尔数组初始化默认值false。 class Solution {
//定义全局数组存放符合条件的结果，定义全局二维数组存放结果的集合
LinkedList<Integer> res = new LinkedList<>();
List<List<Integer>> result = new LinkedList<>();
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
//使用startIndex控制for循环的起始位置，可以使用目标值递减，减为0时符合条件
int startIndex = 0;
//添加一个布尔型数组记录横向遍历时使用的数，在for循环时进行去重（需要对给定数组进行排序）
boolean[] used = new boolean[candidates.length];
//需要对给定数组进行排序
Arrays.sort(candidates);
//开始回溯
backtracking(candidates, target, startIndex, used);
//返回结果
return result;
}
//回溯函数，输入给定数组，目标值，for循环起始位置startIndex，布尔型数组
private void backtracking(int[] candidates, int target, int startIndex, boolean[] used){
//当和大于等于目标值时终止
if(target == 0){
result.add(new LinkedList<>(res));
return;
}
if(target < 0) return;
for(int i = startIndex; i < candidates.length; i++){
//如果当前取出元素与上一个元素相同（排序后）
//且上一个元素对应布尔型数组为false，
//说明横向遍历（同一树层）使用过该元素，则跳过该元素
if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) continue;
//处理
target -= candidates[i];
res.add(candidates[i]);
used[i] = true;
//回溯
backtracking(candidates, target, i + 1, used);
target += candidates[i];
res.removeLast();
used[i] = false;
}
}
}
本文详细解析了LeetCode中的回溯算法应用，包括77组合、17电话号码的字母组合、216组合总和III、39组合总和和40组合总和II。介绍了回溯法的基本思想和模板，并针对每个问题进行了具体讲解和优化策略。
1949
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
