leetcode 递归回溯-78 Subsets(java) ;80 Subsets II

一、

题目分析：

这个和我之前跟着左程云老师的牛客网初级班的最后一课，动态规划那一课看到过差不多的题

那个是动态规划之前的一个递归的使用，让打印一个字符串的全排列

跟这个题是一模一样的，不一样的是字符串可以直接char[]chr=str.toCharArray() 和str=String.valueOf(chr)，所以可以不用嵌套循环,直接打印出来。(但是我后来尝试了，可以使用两个递归，网上的都是只有一个循环，里面嵌套一个递归，但是我们可以不写循环，直接使用两个递归）

我们这个题是整型，而且开头方法就暗示了使用List<List<>>()，所以我们要考虑设置一个二维表，一个一维表，一维表是每一种可能，二维表是所有可能（每一行代表一种可能）

一个c++刷题班老师给的图我jio得很不错

java1：（一个递归）

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<Integer> result=new ArrayList<Integer>();
        List<List<Integer>> results=new ArrayList<List<Integer>>();
        if(nums==null||nums.length==0)
            return results;
        process(nums,0,results,result);
        return results;
    }
    public static void process(int[]nums, int j,List<List<Integer>> results,List<Integer> result){
        results.add(new ArrayList<Integer>(result));
        for(int i=j;i<nums.length;i++){
            result.add(nums[i]);
            process(nums,i+1,results,result);
            result.remove(result.size()-1);
        }
    }
}

java2:（两个递归）

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<Integer> result=new ArrayList<Integer>();
        List<List<Integer>> results=new ArrayList<>();
        if(nums==null||nums.length==0)
            return results;
        results.add(new ArrayList<Integer>(result));
        process(nums,0,results,result);
        return results;
    }
    public static void process(int[]nums, int i,List<List<Integer>> results,List<Integer> result){
        if(i>nums.length-1)
            return;
        //results.add(new ArrayList<Integer>(result));
        // for(int i=j;i<nums.length;i++){
        //     result.add(nums[i]);
        //     process(nums,i+1,results,result);
        //     result.remove(result.size()-1);
        // }
        result.add(nums[i]);
        results.add(new ArrayList<Integer>(result));
        //results.add(result);
        process(nums,i+1,results,result);
        result.remove(result.size()-1);
        process(nums,i+1,results,result);
    }
}

要注意：

（1）要使用results.add(new ArrayList<Integer>(result));

如果使用results.add(result);,最后输出结果都是空

（2）使用两个递归的时候，要在subsets函数里面先把空集加进去。第二个函数集合results的更新在result更新之后：

否则输出的结果会不完整，如下图

关于递归：我觉得网上已经说得很详细了

左程云老师说的很详细，想看可以去看他的视频。就是系统栈帮你把调用自身函数之前，把所有的状态压栈保存了，等到不能满足调用条件时，一个一个弹栈（弹完之后可能会压入其他新的状态）

题目分析：不允许有重复的子集

我刚开始以为是不允许有重复元素，想着这还不简单，后来一看，元素是可以重复的，子集不能重复。也就是说[1,2,2][2,2,1][2,1,1]是同一个子集，所以要去重。

大家都用的思路就是先排序，将原先的数组nums进行排序，这样，最后不管哪个位置上的数，输出包含这三个元素（不同位置）的集合就只有[1,2,2]这一种可能 ——可能性去重

然后再去除重复集合

if(i>j && nums[i]==nums[i-1])
                continue;

这两行就是为了去重的，只保留一个[1,2,2]

ps:

我看有人用list容器去重，但是我觉得上一个题用了List了，这个再加两行代码就行了，不用List也行。

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
       
        List<Integer> result=new ArrayList<Integer>();
        List<List<Integer>> results=new ArrayList<List<Integer>>();
            Arrays.sort(nums);
        if(nums==null||nums.length==0)
            return results;
        process(nums,0,results,result);
        return results;
    }
    public static void process(int[]nums, int j,List<List<Integer>> results,List<Integer> result){
        results.add(new ArrayList<Integer>(result));
        for(int i=j;i<nums.length;i++){
            if(i>j && nums[i]==nums[i-1])
                continue;
            result.add(nums[i]);
            process(nums,i+1,results,result);
            result.remove(result.size()-1);
        }
    }
    
}