🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇
⭐回溯⭐
🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇
前言
回溯算法是⼀种经典的递归算法,通常⽤于解决组合问题、排列问题和搜索问题等。
回溯算法的基本思想:从⼀个初始状态开始,按照⼀定的规则向前搜索,当搜索到某个状态⽆法前进 时,回退到前⼀个状态,再按照其他的规则搜索。
回溯算法在搜索过程中维护⼀个状态树,通过遍历 状态树来实现对所有可能解的搜索。 回溯算法的核⼼思想:“试错”,即在搜索过程中不断地做出选择,如果选择正确,则继续向前搜 索;否则,回退到上⼀个状态,重新做出选择。
回溯算法通常⽤于解决具有多个解,且每个解都需要 搜索才能找到的问题。
回溯算法的模板
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Backtracking {
public void backtracking(int[] candidates, int target) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(candidates);
// 如果需要对candidates进行排序
backtrack(result, new ArrayList<>(), candidates, target, 0);
}
private void backtrack(List<List<Integer>> result, List<Integer> tempList, int[] candidates, int remain, int start) {
if (remain < 0) {
// 如果 remain 小于 0,表示当前的组合不符合要求,直接返回
return;
} else if (remain == 0) {
// 如果 remain 等于 0,表示当前的组合符合要求,加入到结果中
result.add(new ArrayList<>(tempList));
} else {
for (int i = start; i < candidates.length; i++) {
if (i > start && candidates[i] == candidates[i - 1]) {
continue;
// 避免重复计算,如果当前数字和上一个数字相同,则跳过
}
tempList.add(candidates[i]); // 将当前数字加入到临时列表中
backtrack(result, tempList, candidates, remain - candidates[i], i + 1);
// 递归调用,继续向下搜索
tempList.remove(tempList.size() - 1);
// 回溯,将最后加入的数字移除,尝试下一个数字
}
}
}
}
回溯算法是⼀种⾮常重要的算法,可以解决许多组合问题、排列问题和搜索问题等。回溯算法的核⼼ 思想是搜索状态树,通过遍历状态树来实现对所有可能解的搜索。回溯算法的模板⾮常简单,但是实 现起来需要注意⼀些细节,⽐如如何做出选择、如何撤销选择等。
2. 组合总和(medium)
问题描述
给定两个整数 n 和 k,返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
算法思路
算法原理描述
这个问题的核心是从 1 到 n 中选择 k 个数的所有组合,而不考虑顺序。为了实现这一目标,我们可以采用深度优先搜索(DFS)的方法来生成所有可能的组合。
类定义及变量初始化
类定义:
- 定义一个名为
Solution
的类来封装解决方案逻辑。成员变量初始化:
List<Integer> path
: 用于存储当前的组合路径。List<List<Integer>> ret
: 用于存储所有有效的组合结果。int max
: 表示总的元素数量 n。int num
: 表示每个组合需要选择的元素数量 k。主方法实现
- 主方法
combine
:
- 初始化
path
和ret
。- 设置
max
和num
。- 从 1 开始调用
dfs
方法开始递归。- 最后返回
ret
,即所有有效的组合。递归方法实现
- 递归方法
dfs
:
- 参数
cur
表示当前正在考虑放置哪个数字。- 递归的基本结束条件是当
path
的大小等于num
时,此时已经找到了一个有效的组合,将其添加到结果集中ret
并返回。- 对于每一个数字
i
(从cur
开始到max
),执行以下操作:
- 将
i
添加到当前组合path
中。- 调用
dfs(i + 1)
进行下一层递归。- 在递归返回后,从
path
中移除最后一个添加的元素i
,这是回溯的过程,以便尝试下一个可能的组合。
代码实现:
class Solution {
List<Integer> path;
List<List<Integer>> ret;
public List<List<Integer>> combinationSum(int[] candidates, int target) {
path = new ArrayList<>();
ret = new ArrayList<>();
int sum=0;
dfs(sum,candidates,target,0);
return ret;
}
public void dfs(int sum,int[] candidates,int target,int pos){
//如果满足条件就返回
if(sum == target){
ret.add(new ArrayList(path));
return;
}
//如果越界或者超过也返回
if(sum>target||pos == candidates.length){
return;
}
for(int i = pos ;i<candidates.length;i++){
path.add(candidates[i]);
dfs(sum+candidates[i],candidates,target,i);
path.remove(path.size()-1);
}
}
}
总结
动动手点个赞会让作者更开心,感谢阅览,加油各位 !