本文深入探讨了回溯算法，一种用于解决组合、排列、子集和棋盘问题的搜索策略。通过递归和剪枝优化，有效地找到所有可能的解决方案。文中给出了多个示例，如77组合问题、216组合总和3、17电话号码字母组合、39组合总和和40组合总和2，展示了如何应用回溯算法解决实际问题。
follow：代码随想录
回溯算法是一种搜索方式，与递归息息相关，实际上是一个纯暴力的搜索，常见的题目如下“
组合问题：N个数里面按一定规则找出k个数的集合
排列问题：N个数按照一定规则全排列，有多少种排列方式
切割问题：一个字符串按一定规则有多少种切割方式
子集问题：一个字符串按一定规则有多少符合条件的子集
棋盘问题：N皇后，数独等
回溯算法的解决过程可以抽象为一棵树，回溯法解决的是在集合中递归查找子集，集合的大小就构成树的宽度，递归的次数就是树的深度。
回溯模版
- 递归函数的返回值和参数
返回值一般是void - 终止条件
遇到树的叶节点，就可以进行存放结果，并终止
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
for是横向遍历每个层的元素，递归是纵向遍历；直到找到一个叶子节点
77 组合问题
题目描述：
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
示例：
输入：n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
解析：
用递归来模拟嵌套问题，每层递归都是一个for循环。
List<List<Integer>> res = new ArrayList<>();
List<Integer> element = new ArrayList<>();
public List<List<Integer>> combine(int n, int k) {
backTracking(n, 1, 1, k);
return res;
}
public void backTracking(int n, int depth, int begin, int k){
if(depth > k){
res.add(new ArrayList(element));
return;
}
for(int i = begin; i <= n; i++){
element.add(i);
backTracking(n, depth + 1, i + 1, k);
element.remove(element.size() - 1);
}
}
剪枝优化：
在遍历每一层元素是，如果某个元素的子节点不满足个数，则可以不必遍历，比如在四个数中选了两个数，对于元素4，他已经没有子节点，所欲一定满足不了2个的要求，可以不必遍历；这个就可以在for循环中终止条件作文章：
- 递归到第depth层时，已有depth - 1个元素，需要在剩下的集合中选择k - (depth - 1)个元素,那么终止条件就是n - (k - (depth - 1)) + 1
List<List<Integer>> res = new ArrayList<>();
List<Integer> element = new ArrayList<>();
public List<List<Integer>> combine(int n, int k) {
backTracking(n, 1, 1, k);
return res;
}
public void backTracking(int n, int depth, int begin, int k){
if(depth > k){
res.add(new ArrayList(element));
return;
}
for(int i = begin; i <= n - (k - depth); i++){
element.add(i);
backTracking(n, depth + 1, i + 1, k);
element.remove(element.size() - 1);
}
}
}
216 组合总和3⃣️
题目描述：
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
- 只使用数字1到9
- 每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
示例：
输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。
普通的回溯算法：
List<List<Integer>> res = new ArrayList<>();
List<Integer> element = new ArrayList<>();
public List<List<Integer>> combinationSum3(int k, int n) {
backTracking(k, n, 1, 1);
return res;
}
public void backTracking(int nums, int sum, int depth, int begin){
if(depth > nums){
if(sum == 0){
res.add(new ArrayList(element));
}
return;
}
//剪枝优化
for(int i = begin; i <= Math.min(sum, 9); i++){
element.add(i);
backTracking(nums, sum - i, depth + 1, i + 1);
element.remove(element.size() - 1);
}
}
17. 电话号码的字母组合
题目描述：
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
char[][] letters;
List<String> result = new ArrayList<>();
StringBuilder element = new StringBuilder();
public List<String> letterCombinations(String digits) {
if(digits.length() == 0 ) return result;
//提取出各个数字代表的字母
letters = new char[digits.length()][4];
char[] digits_char = digits.toCharArray();
for(int i = 0; i < digits_char.length; i++){
char digit = digits_char[i];
int number = Character.getNumericValue(digit);
//char - int
if(number != 7 && number != 8 && number != 9){
int ascii = (number - 2) * 3;
for(int j = 0; j < 3; j++){
//int - char
letters[i][j] = (char) (97 + ascii + j);
}
}else if(number == 7){
int ascii = (number - 2) * 3;
for(int j = 0; j < 4; j++){
//int - char
letters[i][j] = (char) (97 + ascii + j);
}
}else if(number == 8){
int ascii = (number - 2) * 3 + 1;
for(int j = 0; j < 3; j++){
//int - char
letters[i][j] = (char) (97 + ascii + j);
}
}else{
int ascii = (number - 2) * 3 + 1;
for(int j = 0; j < 4; j++){
//int - char
letters[i][j] = (char) (97 + ascii + j);
}
}
}
backTracking(digits.length(), 0);
return result;
}
public void backTracking(int length, int now_length){
if(now_length == length){
result.add(element.toString());
return;
}
for(int i = 0; i < 4; i++){
if(letters[now_length][i] != 0){
element.append(letters[now_length][i]);
backTracking(length, now_length + 1);
element.delete(element.length() - 1, element.length());
}
}
}
39. 组合总和
题目描述：
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
示例：
输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解析：
该题目可以使用重复的元素，但是不能使用位置在前的元素，所以可以使用begin传参。
List<List<Integer>> res = new ArrayList<>();
List<Integer> element = new ArrayList<>();
public List<List<Integer>> combinationSum(int[] candidates, int target) {
//Collections.sort(candidates);
backTracking(candidates, target, 0, 0);
return res;
}
public void backTracking(int[] nums, int target, int now_sum, int begin){
if(now_sum == target){
res.add(new ArrayList(element));
return;
}
for(int i = begin; i < nums.length; i++){
if(now_sum + nums[i] > target) continue;
element.add(nums[i]);
backTracking(nums, target, now_sum + nums[i], i);
element.remove(element.size() - 1);
}
}
40. 组合总和2⃣️
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。
注意：解集不能包含重复的组合。
示例：
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
解析：
这道题难点是去重：原集合中有重复元素，但是结果集中不能有重复的元素，在同一个树枝的元素不需要去重，但同一层的元素需要去重
这道题包括两次剪枝
List<List<Integer>> res = new ArrayList<>();
List<Integer> element = new ArrayList<>();
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
//先对数组进行排序
Arrays.sort(candidates);
backTracking(candidates, target, 0, 0);
return res;
}
public void backTracking(int[] nums, int target, int now_sum, int begin){
if(now_sum == target){
res.add(new ArrayList(element));
return;
}
for(int i = begin; i < nums.length; i++){
//去重 小剪枝
if(i > begin && nums[i] == nums[i - 1]) continue;
//大剪枝
if(now_sum + nums[i] > target) break;
element.add(nums[i]);
backTracking(nums, target, now_sum + nums[i], i + 1);
element.remove(element.size() - 1);
}
}
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
