代码随想录算法训练营第29天 | 491、46、47

最新推荐文章于 2025-12-05 10:55:08 发布

原创最新推荐文章于 2025-12-05 10:55:08 发布 · 71 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #java

文章详细介绍了如何解决两个编程问题：找到整数数组的所有递增子序列以及所有可能的全排列。对于递增子序列，关键在于回溯思想的应用，避免使用已选择的元素。全排列问题则涉及到回溯的另一种应用，通过标记数组元素是否已使用来避免重复。文章提供了两种不同的Java解法，并强调了剪枝和处理重复元素的重要性。

491. 递增子序列

题目描述

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。
数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
示例1：
输入： $n u m s = [4, 6, 7, 7]$
输出： $[[4, 6], [4, 6, 7], [4, 6, 7, 7], [4, 7], [4, 7, 7], [6, 7], [6, 7, 7], [7, 7]]$
示例2：
输入： $n u m s = [4, 4, 3, 2, 1]$
输出： $[[4, 4]]$

思路

本题一眼看去真的菀菀类卿，它看起来和90题也太像了吧。但仔细分析之后又会发现90的套路无法用在这里，因为子集Ⅱ中剪枝的逻辑是建立在数组排序的基础上的，但本题就是要找到递增子序列所以不能随意改变顺序，于是就困在了这里。
看了答案之后会发现本题是一个跳出套路的题，考察的主要是这个回溯树的思想而不仅仅是这个套路。
还是求子序列那么这部分是可以继续按照套路的，而且同一个元素不能重复使用所以要从startindex开始循环，这些都是能想到的。
但接下来，就会发现，保存结果的部分和平时的套路是不同的，这里要表达的逻辑是同一父节点下的同层上使用过的元素不能再使用。
而且这里也要注意，保存后不要直接return，因为要记录每个节点才能确认是否符合。
此外，题目要求递增序列的大小至少为2，这也是容易忽略的点。

题解

class Solution {
    List<Integer> path = new ArrayList<>();
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        helper(nums,0);
        return res;
    }
    public void helper(int[]nums , int start){
        if(path.size() > 1){
            res.add(new ArrayList<>(path));
        }
        int[] used = new int[201];
        for(int i = start;i < nums.length;i++){
            if((!path.isEmpty() && nums[i] < path.get(path.size() - 1)) 
            || (used[nums[i]+100] == 1)){
                continue;
            }
            used[nums[i] + 100] = 1;
            path.add(nums[i]);
            helper(nums,i+1);
            path.remove(path.size()-1);
        }
    }
}

总结

本题真的是一个跳出套路的题，而且这里是放在了回溯了，其实说他是个深搜的题也完全没问题，反正内核递归也是一个原理。本题的思考量其实很大，跳出套路只是一种说法，本质上是要掌握这种回溯的思想，而不应该拘泥于套路。还得再看看再练练。

46. 全排列

题目描述

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。
示例1：
输入： $n u m s = [1, 2, 3]$
输出： $[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]$
示例2：
输入： $n u m s = [0, 1]$
输出： $[[0, 1], [1, 0]]$
示例3：
输入： $n u m s = [1]$
输出： $[[1]]$

思路

本题涉及到了另一个回溯的经典应用——排列。排列从本质上来说和组合是相同的，其区别在于排列具有顺序，即1，2和2，1是不相同的。
所以排列要求的回溯递归方法中具有如下特点：
1、具有顺序，所以这里我们能够想到不使用startindex来规避之前使用过的元素
2、一个排列中一个元素只能使用一次，所以需要一个used数组来记录是否使用
3、排列中应该何时跳出递归呢，题目要求的全排列中需要所有的元素都参与其中且不能重复使用，那么就应该是当收集元素的列表长度与数组长度相同时跳出，同时也可以加入是否符合要求保存的判断。

题解1

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> permute(int[] nums) {
        if(nums.length == 0){
            return res;
        }
        used = new boolean[nums.length];
        helper(nums);
        return res;
    }
    public void helper(int[] nums){
        if(path.size() == nums.length){
            res.add(new ArrayList<>(path));
            return ;
        }
        for(int i = 0;i < nums.length;i++){
            if(used[i]){
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            helper(nums);
            path.removeLast();
            used[i] = false;
        }
    }
}

题解2

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        if(nums.length == 0) return res;
        helper(nums);
        return res;
    }
    public void helper(int[] nums){
        if(path.size() == nums.length){
            res.add(new ArrayList<>(path));
        }
        for(int i = 0;i<nums.length;i++){
            if(path.contains(nums[i])){
                continue;
            }
            path.add(nums[i]);
            helper(nums);
            path.removeLast();
        }
    }
}

总结

如果不想使用记录是否用过的used数组也可以看保存元素的列表中是否包含该元素，但这本质上还是一样的，还是推荐解法1。
排列第一次接触需要更熟悉。

47. 全排列Ⅱ

题目描述

给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。
示例1：
输入： $n u m s = [1, 1, 2]$
输出： $[[1, 1, 2], [1, 2, 1], [2, 1, 1]]$
示例2：
输入： $n u m s = [1, 2, 3]$
输出： $[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]$

思路

全排列的升级版，升级之处在于存在重复数字的序列。
又出现了，这种跳过重复元素的气息！原理相同，但要应用在全排列中。

题解

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used,false);
        Arrays.sort(nums);
        helper(nums,used);
        return res;
    }
    public void helper(int[] nums,boolean[] used){
        if(path.size() == nums.length){
            res.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] == false){
                used[i] = true;
                path.add(nums[i]);
                helper(nums,used);
                path.remove(path.size()-1);
                used[i] = false;
            }
        }
    }
}

总结

一个意料之中的升级版，是剪枝操作或者说是跳过同层重复元素的又一次应用。好像有点感觉了！