【代码随想录刷题笔记】DAY29 第七章回溯算法

最新推荐文章于 2024-09-21 14:48:47 发布

Azimiu

最新推荐文章于 2024-09-21 14:48:47 发布

阅读量178

点赞数

文章标签：算法 leetcode java

本文链接：https://blog.csdn.net/Azimumiao/article/details/128485453

版权

博客介绍了如何使用回溯算法解决LeetCode中的46.全排列和47.全排列 II问题，强调了排列与组合问题的区别，并提供了视频讲解链接，帮助理解去重策略。

摘要由CSDN通过智能技术生成

491.递增子序列

本题和大家刚做过的 90.子集II 非常像，但又很不一样，很容易掉坑里。

代码随想录

视频讲解：回溯算法精讲，树层去重与树枝去重 | LeetCode：491.递增子序列_哔哩哔哩_bilibili

//子集回溯三部曲
//去重, 注意nums[i] == nums[i - 1] 去重只针对排好序的
//此题没有排序，所以不可以用nums[i] == nums[i - 1]来去重
//使用hashmap记录使用过的元素
//这里是要对结果中出现的重复组合去重， 要与第46题区分
//排序
class Solution {
    //新建List保存result
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    //新建List保存每次得到的路径path
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums, 0);
        return result;
    }
    
    //定义回溯方法
    private void backtracking(int[] nums, int startIndex) {
        //size大于1才搜集子集
        if(path.size() > 1) {
            result.add(new LinkedList<>(path));
        }
        //子集的终止条件可以省略，因为在for循环定义了
        //使用hashmap记录使用过的元素
        HashMap<Integer,Integer> map = new HashMap<>();
        //for循环，单层搜索过程
        for(int i = startIndex; i < nums.length; i++) {
            //确保升序， 注意!path.isEmpty()
            if(!path.isEmpty() && nums[i]< path.getLast()) {
                continue;
            }
            //用hashpmap判断是否使用过了当前数（不同的i，但值一样），用过则跳过
            //这里是要对结果中出现的重复组合去重
            //不单单是用过的数不能再用，要与第46题区分
            if ( map.getOrDefault( nums[i], 0 ) >= 1 ){
                continue;
            }
            //用过的元素放入hashmap
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
            //子集加入path
            path.add( nums[i] );
            //递归
            backtracking(nums, i + 1);
            //回溯
            path.removeLast();
        }
    }
}

46.全排列

本题重点感受一下，排列问题与组合问题，组合总和，子集问题的区别。为什么排列问题不用 startIndex

代码随想录

视频讲解：组合与排列的区别，回溯算法求解的时候，有何不同？| LeetCode：46.全排列_哔哩哔哩_bilibili

//排列，使用used数组保证用过的元素不再用
//回溯三部曲
class Solution {
    //新建List保存result
    List<List<Integer>> result = new ArrayList<>();
    //用来存放符合条件结果
    LinkedList<Integer> path = new LinkedList<>();
    //新建used数组，记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次
    boolean[] used;
    
    public List<List<Integer>> permute(int[] nums) {
        if (nums.length == 0){
            return result;
        }
        //根据nums来设置used数组长度
        used = new boolean[nums.length];
        backtracking(nums);
        return result;
    }

    //定义回溯方法
    private void backtracking(int[] nums){
        //终止条件， 此时说明找到了一组
        if (path.size() == nums.length){
            result.add(new ArrayList<>(path));
            return;
        }
        //for循环，单层搜索过程
        //排列问题每次都从0开始搜索
        for (int i = 0; i < nums.length; i++){
            //path里已经收录的元素，直接跳过
            //判断第i个数是否用过，用过则跳过
            if (used[i]){
                continue;
            }
            //将第i个数设为true
            used[i] = true;
            path.add(nums[i]);
            //递归
            backtracking(nums);
            //回溯
            path.removeLast();
            //回溯
            used[i] = false;
        }
    }
}

47.全排列 II

本题就是我们讲过的 40.组合总和II 去重逻辑和 46.全排列的结合，可以先自己做一下，然后重点看一下文章中我讲的拓展内容。 used[i - 1] == true 也行，used[i - 1] == false 也行

代码随想录

视频讲解：回溯算法求解全排列，如何去重？| LeetCode：47.全排列 II_哔哩哔哩_bilibili

//排列，回溯三部曲
//used数组去重（给定数组本身有重复的值）
//used数组保证遍历时用过的值不再用
class Solution {
    //新建List保存result
    List<List<Integer>> result = new ArrayList<>();
    //新建List保存path
    LinkedList<Integer> path = new LinkedList<>();
    //新建used数组
    boolean[] used;
    public List<List<Integer>> permuteUnique(int[] nums) {
        //先把数组排序，方便去重
        Arrays.sort(nums);
        //根据nums来设置used数组长度
        used = new boolean[nums.length];
        backtracking(nums);
        return result;  
    }
    
    //定义回溯方法
    private void backtracking(int[] nums) {
        //终止条件
        if(path.size() == nums.length) {
            //收集结果
            result.add(new ArrayList(path));
            return;
        }
        
        //for循环，单层搜索过程
        //排列问题每次都从0开始搜索
        for(int i = 0; i < nums.length; i++) {
            //去重
            //因为回溯的原因，used[i - 1] 表示之前用过的元素会放回去
            // used[i - 1] == true，说明同⼀树⽀nums[i - 1]使⽤过
            // used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //排列中用过的元素不用
            if(used[i] == true) {
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            //递归
            backtracking(nums);
            //回溯
            path.removeLast();
            //回溯
            used[i] = false;
        }
    }
}