【回溯算法 9】组合总和(medium)(每日一题)

 

                                      ⭐回溯⭐


前言

回溯算法是⼀种经典的递归算法,通常⽤于解决组合问题、排列问题和搜索问题等。

回溯算法的基本思想:从⼀个初始状态开始,按照⼀定的规则向前搜索,当搜索到某个状态⽆法前进 时,回退到前⼀个状态,再按照其他的规则搜索。

回溯算法在搜索过程中维护⼀个状态树,通过遍历 状态树来实现对所有可能解的搜索。 回溯算法的核⼼思想:“试错”,即在搜索过程中不断地做出选择,如果选择正确,则继续向前搜 索;否则,回退到上⼀个状态,重新做出选择。

回溯算法通常⽤于解决具有多个解,且每个解都需要 搜索才能找到的问题。


 回溯算法的模板

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Backtracking {
    public void backtracking(int[] candidates, int target) {
        List> result = new ArrayList<>();
        Arrays.sort(candidates);
      // 如果需要对candidates进行排序

        backtrack(result, new ArrayList<>(), candidates, target, 0);
    }

    private void backtrack(List> result, List 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)

题目链接:39. 组合总和 - 力扣(LeetCode)

问题描述

给定两个整数 n 和 k,返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

算法思路

算法原理描述

这个问题的核心是从 1 到 n 中选择 k 个数的所有组合,而不考虑顺序。为了实现这一目标,我们可以采用深度优先搜索(DFS)的方法来生成所有可能的组合。

类定义及变量初始化
  1. 类定义:

    • 定义一个名为 Solution 的类来封装解决方案逻辑。
  2. 成员变量初始化:

    • List path: 用于存储当前的组合路径。
    • List> ret: 用于存储所有有效的组合结果。
    • int max: 表示总的元素数量 n。
    • int num: 表示每个组合需要选择的元素数量 k。
主方法实现
  1. 主方法 combine:
    • 初始化 path 和 ret
    • 设置 max 和 num
    • 从 1 开始调用 dfs 方法开始递归。
    • 最后返回 ret,即所有有效的组合。
递归方法实现
  1. 递归方法 dfs:
    • 参数 cur 表示当前正在考虑放置哪个数字。
    • 递归的基本结束条件是当 path 的大小等于 num 时,此时已经找到了一个有效的组合,将其添加到结果集中 ret 并返回。
    • 对于每一个数字 i (从 cur 开始到 max),执行以下操作:
      • 将 i 添加到当前组合 path 中。
      • 调用 dfs(i + 1) 进行下一层递归。
      • 在递归返回后,从 path 中移除最后一个添加的元素 i,这是回溯的过程,以便尝试下一个可能的组合。

 代码实现:

class Solution {
    List path;
    List> ret;
    public List> 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


总结

动动手点个赞会让作者更开心,感谢阅览,加油各位 !

你可能感兴趣的:(回溯算法,windows,linux,运维,动态规划,leetcode,算法,java)