代码随想录算法训练营_day25

最新推荐文章于 2024-10-01 04:50:10 发布

kennyS_ss

最新推荐文章于 2024-10-01 04:50:10 发布

阅读量956

点赞数 20

分类专栏：代码随想录算法训练营文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_43745961/article/details/141497861

版权

代码随想录算法训练营专栏收录该内容

33 篇文章 0 订阅

订阅专栏

题目信息 491. 非递减子序列

题目链接: https://leetcode.cn/problems/non-decreasing-subsequences/
题目描述:
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

解题思路

这个递增子序列比较像是取有序的子集。而且本题也要求不能有相同的递增子序列。

这又是子集，又是去重，是不是不由自主的想起了刚刚讲过的90.子集II (opens new window)。

就是因为太像了，更要注意差别所在，要不就掉坑里了！

在90.子集II (opens new window)中我们是通过排序，再加一个标记数组来达到去重的目的。

而本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。

所以不能使用之前的去重逻辑！

本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。

为了有鲜明的对比，我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

491. 递增子序列1

#回溯三部曲

递归函数参数

本题求子序列，很明显一个元素不能重复使用，所以需要startIndex，调整下一层递归的起始位置。

代码如下：

private List<List<Integer>> result = new ArrayList<>();  
private LinkedList<Integer> path = new LinkedList<>();
private void backTracking(int[] nums,int startIndex)

终止条件

本题其实类似求子集问题，也是要遍历树形结构找每一个节点，所以和回溯算法：求子集问题！ (opens new window)一样，可以不加终止条件，startIndex每次都会加1，并不会无限递归。

但本题收集结果有所不同，题目要求递增子序列大小至少为2，所以代码如下：

if (path.size() > 1) {
    result..add(new ArrayList<>(path));
    // 注意这里不要加return，因为要取树上的所有节点
}

单层搜索逻辑

491. 递增子序列1 在图中可以看出，同一父节点下的同层上使用过的元素就不能再使用了

那么单层搜索代码如下：

int[] used = new int[201];  
for (int i = startIndex;i < nums.length;i++){  
    if (!path.isEmpty() && nums[i] < path.getLast() || (used[nums[i] + 100] == 1)){  
        continue;  
    }  
    used[nums[i] + 100] = 1;  
    path.add(nums[i]);  
    backTracking(nums,i + 1);  
    path.removeLast();    
}

对于已经习惯写回溯的同学，看到递归函数上面的used[nums[i] + 100] = 1;`，下面却没有对应的pop之类的操作，应该很不习惯吧

这也是需要注意的点，int[] used = new int[201];` 是记录本层元素是否重复使用，新的一层uset都会重新定义（清空），所以要知道uset只负责本层！

最后整体代码如下：

代码实现

private List<List<Integer>> result = new ArrayList<>();  
private LinkedList<Integer> path = new LinkedList<>();  
  
public List<List<Integer>> findSubsequences(int[] nums) {  
    backTracking(nums,0);  
    return result;  
}  
  
private void backTracking(int[] nums,int startIndex){  
    if (path.size() > 1){  
        result.add(new ArrayList<>(path));  
    }  
    int[] used = new int[201];  
    for (int i = startIndex;i < nums.length;i++){  
        if (!path.isEmpty() && nums[i] < path.getLast() || (used[nums[i] + 100] == 1)){  
            continue;  
        }  
        used[nums[i] + 100] = 1;  
        path.add(nums[i]);  
        backTracking(nums,i + 1);  
        path.removeLast();    
    }  
}

used 数组的作用范围仅限于每一层递归中的某一位置，目的是在这一层递归中避免使用相同的元素进行重复选择。由于递归进入下一层时，used 数组会被重新初始化（used = new int[201]），因此不需要在回溯时将 used[nums[i] + 100] 重置为 0。

题目信息 46. 全排列

题目链接: https://leetcode.cn/problems/permutations/
题目描述:
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

解题思路

此时我们已经学习了77.组合问题 (opens new window)、 131.分割回文串 (opens new window)和78.子集问题 (opens new window)，接下来看一看排列问题。

相信这个排列问题就算是让你用for循环暴力把结果搜索出来，这个暴力也不是很好写。

所以正如我们在关于回溯算法，你该了解这些！ (opens new window)所讲的为什么回溯法是暴力搜索，效率这么低，还要用它？

因为一些问题能暴力搜出来就已经很不错了！

我以[1,2,3]为例，抽象成树形结构如下：

全排列

#回溯三部曲

递归函数参数

首先排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，这和之前分析的子集以及组合所不同的地方。

可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。

但排列问题需要一个used数组，标记已经选择的元素，如图橘黄色部分所示:

全排列

代码如下：

private List<List<Integer>> res1 = new ArrayList<>();  
private LinkedList<Integer> path1 = new LinkedList<>();  
boolean[] used;  
private void back(int[] nums)

递归终止条件

全排列

可以看出叶子节点，就是收割结果的地方。

那么什么时候，算是到达叶子节点呢？

当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

代码如下：

// 此时说明找到了一组
if (path1.size() == nums.length){  
        res1.add(new ArrayList<>(path1));  
        return;    
	}

单层搜索的逻辑

这里和77.组合问题 (opens new window)、131.切割问题 (opens new window)和78.子集问题 (opens new window)最大的不同就是for循环里不用startIndex了。

因为排列问题，每次都要从头开始搜索，例如元素1在[1,2]中已经使用过了，但是在[2,1]中还要再使用一次1。

而used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次。

代码如下：

for (int i = 0;i < nums.length;i++){  
    if (used[i] == true){  
    continue;  // path里已经收录的元素，直接跳过  
    }  
    used[i] = true;  
    path1.add(nums[i]);  
    back(nums);  
    path1.removeLast();  
    used[i] = false;  
    }

整体代码如下：

代码实现

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

题目信息 47. 全排列 II

题目链接: https://leetcode.cn/problems/permutations-ii/
题目描述:
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

解题思路

这道题目和46.全排列 (opens new window)的区别在与给定一个可包含重复数字的序列，要返回所有不重复的全排列。

这里又涉及到去重了。

在40.组合总和II (opens new window)、90.子集II (opens new window)我们分别详细讲解了组合问题和子集问题如何去重。

那么排列问题其实也是一样的套路。

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

我以示例中的 [1,1,2]为例（为了方便举例，已经排序）抽象为一棵树，去重过程如图：

47.全排列II1

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

一般来说：组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

在46.全排列 (opens new window)中已经详细讲解了排列问题的写法，在40.组合总和II (opens new window)、90.子集II (opens new window)中详细讲解了去重的写法

#拓展

大家发现，去重最为关键的代码为：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
    continue;
}

如果改成 used[i - 1] == true，也是正确的!，去重代码如下：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true) {
    continue;
}

这是为什么呢，就是上面我刚说的，如果要对树层中前一位去重，就用used[i - 1] == false，如果要对树枝前一位去重用used[i - 1] == true。

对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高！

这么说是不是有点抽象？

来来来，我就用输入: [1,1,1] 来举一个例子。

树层上去重(used[i - 1] == false)，的树形结构如下：

47.全排列II2

树枝上去重（used[i - 1] == true）的树型结构如下：

47.全排列II3

大家应该很清晰的看到，树层上对前一位去重非常彻底，效率很高，树枝上对前一位去重虽然最后可以得到答案，但是做了很多无用搜索。

#总结

这道题其实还是用了我们之前讲过的去重思路，但有意思的是，去重的代码中，这么写：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
    continue;
}

和这么写：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true) {
    continue;
}

都是可以的，这也是很多同学做这道题目困惑的地方，知道used[i - 1] == false也行而used[i - 1] == true也行，但是就想不明白为啥。

所以我通过举[1,1,1]的例子，把这两个去重的逻辑分别抽象成树形结构，大家可以一目了然：为什么两种写法都可以以及哪一种效率更高！

这里可能大家又有疑惑，既然 used[i - 1] == false也行而used[i - 1] == true也行，那为什么还要写这个条件呢？

直接这样写不就完事了？

if (i > 0 && nums[i] == nums[i - 1]) {
    continue;
}

其实并不行，一定要加上 used[i - 1] == false或者used[i - 1] == true，因为 used[i - 1] 要一直是 true 或者一直是false 才可以，而不是一会是true 一会又是false。所以这个条件要写上。

是不是豁然开朗了！！

代码实现

private List<List<Integer>> res2 = new ArrayList<>();  
private LinkedList<Integer> path2 = new LinkedList<>();  
boolean[] used2;  
public List<List<Integer>> permuteUnique(int[] nums) {  
    if (nums.length == 0){  
        return res2;  
    }  
    Arrays.sort(nums);  
    used2 = new boolean[nums.length];  
    track(nums);  
    return res2;  
}  
  
private void track(int[] nums){  
    if (path2.size() == nums.length){  
        res2.add(new ArrayList<>(path2));  
        return;    }  
    for (int i = 0;i < nums.length;i++){  
        if (i > 0 && nums[i - 1] == nums[i] && !used2[i - 1]){  
            continue;  
        }  
        if (used2[i]){  
            continue;  
        }  
        used2[i] = true;  
        path2.add(nums[i]);  
        track(nums);  
        path2.removeLast();  
        used2[i] = false;  
    }  
}