代码随想录刷题day25丨491.递增子序列 ,46.全排列 ,47.全排列 II

代码随想录刷题day25丨491.递增子序列 ,46.全排列 ,47.全排列 II

1.题目

1.1递增子序列

  • 题目链接:491. 非递减子序列 - 力扣(LeetCode)

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

  • 文档讲解:https://programmercarl.com/0491.递增子序列.html

  • 解题思路:回溯

    • 用[4, 7, 6, 7]这个数组来举例,抽象为树形结构如图:

  • 代码:

    java 复制代码
    class Solution {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
    
        public List<List<Integer>> findSubsequences(int[] nums) {
            backtracking(nums, 0);
            return result;
        }
    
        void backtracking(int[] nums, int startIndex) {
    
            if(path.size() >= 2){
                result.add(new ArrayList<>(path));
            }
    
            Set<Integer> tempSet = new HashSet<>();// 使用set对本层元素进行去重
    
            for (int i = startIndex; i < nums.length; i++) {
                if((!path.isEmpty() && nums[i] < path.get(path.size() - 1)) || tempSet.contains(nums[i])){
                    continue;
                }
                tempSet.add(nums[i]);
                path.add(nums[i]);
                backtracking(nums,i + 1);
                path.remove(path.size() - 1);
            }
        }
    }
  • 总结:

    • 本题求自增子序列,是不能对原数组进行排序的,排完序的数组都是自增子序列了。所以不能使用之前的去重逻辑!
    • 数组,set,map都可以做哈希表,而且数组干的活,map和set都能干,但如果数值范围小的话能用数组尽量用数组

1.2全排列

  • 题目链接:46. 全排列 - 力扣(LeetCode)

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

  • 文档讲解:https://programmercarl.com/0046.全排列.html

  • 解题思路:回溯

    • 以[1,2,3]为例,抽象成树形结构如下:

    • 回溯三部曲

      • 递归函数参数

        java 复制代码
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        void backtracking(int[] nums,boolean[] used)
      • 递归终止条件

        java 复制代码
        if(path.size() == nums.length){
            result.add(new ArrayList<>(path));
            return;
        }
      • 单层搜索的逻辑

        java 复制代码
        for(int i = 0;i < nums.length;i++){
            if(used[i] == true){
                continue;
            }
            path.add(nums[i]);
            used[i] = true;
            backtracking(nums,used);
            used[i] = false;
            path.remove(path.size() - 1);
        }
  • 代码:

    java 复制代码
    class Solution {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        public List<List<Integer>> permute(int[] nums) {
            boolean[] used = new boolean[nums.length];
            backtracking(nums,used);
            return result;
        }
    
        void backtracking(int[] nums,boolean[] used){
            if(path.size() == nums.length){
                result.add(new ArrayList<>(path));
                return;
            }
    
            for(int i = 0;i < nums.length;i++){
                if(used[i] == true){
                    continue;
                }
                path.add(nums[i]);
                used[i] = true;
                backtracking(nums,used);
                used[i] = false;
                path.remove(path.size() - 1);
            }
        }
    }
  • 总结:

    • 每层都是从0开始搜索而不是startIndex
    • 需要used数组记录path里都放了哪些元素了

1.3全排列 II

  • 题目链接:47. 全排列 II - 力扣(LeetCode)

  • 视频讲解:回溯算法求解全排列,如何去重?| LeetCode:47.全排列 II_哔哩哔哩_bilibili

  • 文档讲解:https://programmercarl.com/0047.全排列II.html

  • 解题思路:回溯

    • 去重一定要对元素进行排序,这样我们才方便通过相邻的节点来判断是否重复使用了

    • 以示例中的 [1,1,2]为例 (为了方便举例,已经排序)抽象为一棵树,去重过程如图:

    • 图中我们对同一树层,前一位(也就是nums[i-1])如果使用过,那么就进行去重。

  • 代码:

    java 复制代码
    class Solution {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
    
        public List<List<Integer>> permuteUnique(int[] nums) {
            boolean[] used = new boolean[nums.length];
            Arrays.sort(nums);
            backtracking(nums, used);
            return result;
        }
    
        void backtracking(int[] nums, boolean[] used) {
            if (path.size() == nums.length) {
                result.add(new ArrayList<>(path));
                return;
            }
    
            for (int i = 0; i < nums.length; i++) {
                if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                    continue;
                }
                if (used[i] == true) {
                    continue;
                }
                path.add(nums[i]);
                used[i] = true;
                backtracking(nums, used);
                used[i] = false;
                path.remove(path.size() - 1);
            }
        }
    }
  • 总结:

    • 一般来说:组合问题和排列问题是在树形结构的叶子节点上收集结果,而子集问题就是取树上所有节点的结果
相关推荐
Kevinyu101144 分钟前
P6149 [USACO20FEB] Triangles S题解
算法
weixin_417759991 小时前
97-java流式处理优点
java·开发语言
AskHarries1 小时前
Spring Boot集成Akka Cluster实现在分布式节点中执行任务
java·spring boot·maven·akka
计算机编程-吉哥1 小时前
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
java·spring boot·毕业设计·毕业论文·计算机毕业设计选题·计算机毕业设计开题报告·网上书店系统
arin8761 小时前
【组合】矩阵ksm+状压dp
算法·矩阵·深度优先
我爱豆子1 小时前
Leetcode Hot 100刷题记录 -Day14(矩阵置0)
java·算法·leetcode·矩阵
方圆师兄1 小时前
k8s 常见问题梳理
java·kubernetes
骆晨学长1 小时前
基于Springboot的校园防疫管理系统的设计与实现
java·spring boot·后端
java1234_小锋1 小时前
免费分享一套SpringBoot+Vue学生信息管理系统【论文+源码+SQL脚本】,帅呆了~~
java·springboot·java毕业设计·学生信息·java学生信息·springboot学生信息·vue学生信息
武昌库里写JAVA1 小时前
99AutoML 自动化机器学习实践--NNI 自动化机器学习工具包
c语言·开发语言·数据结构·算法·二维数组