【4.19-周二】lc回溯问题：47 && 77

最新推荐文章于 2024-04-21 21:12:49 发布

Gv_ee

最新推荐文章于 2024-04-21 21:12:49 发布

阅读量243

点赞数 1

分类专栏：刷题个人打卡文章标签：回溯算法

本文链接：https://blog.csdn.net/m0_50546235/article/details/124284736

版权

刷题个人打卡专栏收录该内容

12 篇文章 0 订阅

订阅专栏

47.全排列||

链接直达

思路分析

因为有重复数据，题目要求返回不重复的全排列，所以需要考虑重复数据导致的重复排列，这部分去重使用排序解决
在排序之后，重复的数据就连在了一起，所以就开始进行去重操作。依旧是使用used数组
【1，1，2】为例子，首先是第一个1的纵向遍历，此时我们将used[0]设置成true，此时纵向遍历到第二层选值的时候，我们不能选择第一个1了，所以used[i] == true的时候，我们是使用continue，遍历下一个。

另一个点是，到了横向遍历第二个1的时候，此时回溯回来的时候used[0]已经改成false了。检测到此时的nums[i]—>也就是第二个1，和nums[i-1]---->也就是第一个1是相同的。所以我们这一部的判断i > 0 && nums[i] ==nums[i - 1]也需要使用continue，遍历下一个元素，也就是2。

代码

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

77.组合

链接直达

思路分析

这个题目重要的不是写出来，而是通过这个学会剪枝操作

k是一种限制，表示我们的path中只能有两个元素。那么跳出回溯的出口就在这里，path.size()==k的时候就将path加入到returnArr中，然后结束本次向下递归，然后就是开始回溯了
其他思路正常，剪枝开始是比较难理解的。剪枝的条件：i <= n - (k - path.size()) + 1

当我们不剪枝的时候，也就是i <= n 这样会遍历整个数组。但是这是不必须的。

比如我们有5个数【1，2，3，4，5】，但是我们要找3个数。

当path.size() == 0的时候，之后需要3个，我们可以最迟从3开始取，下标是2。

当path.size() == 1的时候，之后需要2个，我们可以最迟从4开始取，下标是3。

当path.size() == 2的时候，之后需要1个，我们可以最迟从5开始取，下标是4。

以path.size() == 0为例子，如果说我们的path里面是空的，此时下标i到了4的位置，就可以直接返回了，就算将4和5取了，也凑不到3个数。

同理等于1和等于2的时候也是这样
这时候就可以分析出我们下标最大最大会是多少了

当path.size() == 0的时候，之后需要3个。从下标3及之后就可以直接return，也就是小于3

当path.size() == 1的时候，之后需要2个。从下标4及之后就可以直接return，也就是小于4

当path.size() == 2的时候，之后需要1个。从下标5及之后就可以直接return，也就是小于5

需要k个元素，path中有path.size()个，那么之后需要k-path.size()，也就是小于n+1-(k-path.size())

代码

class Solution {
    List<List<Integer>>returnArr = new ArrayList();
    ArrayList<Integer>path = new ArrayList();
    public List<List<Integer>> combine(int n, int k) {
         combineHelp(n, k, 1);
         return returnArr;       
    }
    public void combineHelp(int n, int k, int startindex){
        if(path.size() == k) {
            returnArr.add(new ArrayList<>(path));
            // System.out.println(returnArr);
            return ;
        }
        for(int i = startindex; i <= n + 1 - (k - path.size()); i++){
            path.add(i);
            combineHelp(n, k, i + 1);
            // System.out.print(path);
            path.remove(path.size() - 1);
        }
    }
}