代码随想录刷题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);
            }
        }
    }
  • 总结:

    • 一般来说:组合问题和排列问题是在树形结构的叶子节点上收集结果,而子集问题就是取树上所有节点的结果
相关推荐
武子康32 分钟前
Java-72 深入浅出 RPC Dubbo 上手 生产者模块详解
java·spring boot·分布式·后端·rpc·dubbo·nio
_殊途1 小时前
《Java HashMap底层原理全解析(源码+性能+面试)》
java·数据结构·算法
椰椰椰耶2 小时前
【Spring】拦截器详解
java·后端·spring
没有bug.的程序员3 小时前
JAVA面试宝典 - 《MyBatis 进阶:插件开发与二级缓存》
java·面试·mybatis
没有羊的王K4 小时前
SSM框架学习——day1
java·学习
珊瑚里的鱼4 小时前
LeetCode 692题解 | 前K个高频单词
开发语言·c++·算法·leetcode·职场和发展·学习方法
又菜又爱coding4 小时前
安装Keycloak并启动服务(macOS)
java·keycloak
不知道叫什么呀5 小时前
【C】vector和array的区别
java·c语言·开发语言·aigc
wan_da_ren5 小时前
JVM监控及诊断工具-GUI篇
java·开发语言·jvm·后端
秋说5 小时前
【PTA数据结构 | C语言版】顺序队列的3个操作
c语言·数据结构·算法