【回溯算法 2】子集（medium）（每日一题）-优快云博客

本文链接：https://blog.youkuaiyun.com/Y_1215/article/details/139428203

🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

⭐回溯⭐

🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

前言

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

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

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

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

回溯算法的模板

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）

题目链接：78. 子集 - 力扣（LeetCode）

算法思路：解法（归并排序）：

算法思路：

算法思路：为了获得nums数组的所有⼦集，我们需要对数组中的每个元素进⾏选择或不选择的操作，即nums 数组⼀定存在2^(数组⻓度)个⼦集。对于查找⼦集，具体可以定义⼀个数组，来记录当前的状态，并对其进⾏递归。

对于每个元素有两种选择：

1.不进⾏任何操作；

2.将其添加⾄当前状态的集合。在递归时我们需要保证递归结束时当前的状态与进⾏递归操作前的状态不变，⽽当我们在选择进⾏步骤2进⾏递归时，当前状态会发⽣变化，因此我们需要在递归结束时撤回添加操作，即进⾏回溯。

代码实现：

class Solution {
    List<List<Integer>> ret;
    List<Integer> path;
    public List<List<Integer>> subsets(int[] nums) {
       //解法 1:对每个元素做选择,选还是不选画决策树
        ret = new ArrayList<>();
        path = new ArrayList<>();
       // dfs1(nums,0);
       //解法 2:按子集元素个数来选择
        dfs2(nums,0);
        return ret;
    }

    private void dfs1(int[] nums, int index) {
        if(index == nums.length){
            ret.add(new ArrayList<>(path));
            return;
        }
        //选择
        path.add(nums[index]);
        dfs1(nums,index+1);
        //回溯 恢复现场
        path.remove(path.size()-1);
        //不选择
        dfs1(nums,index+1);
    }
    private void dfs2(int[] nums, int pos) {
      //每个节点都是子集
      ret.add(new ArrayList<>(path));
      //对该元素之后的数遍历处理
      for(int i =pos;i<nums.length;i++){
          path.add(nums[i]);
          dfs2(nums,i+1);
          path.remove(path.size()-1);
      }
    }
}