day 29 & 补day28

78. 子集

中等

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> subsets(int[] nums) {
        backTracking (nums,0);
        return result;
    }

    private void backTracking(int[] nums,int idx){
        result.add(new ArrayList<>(path));
        if(idx >= nums.length){
            return;
        }

        for(int i = idx; i<nums.length; i++){
            path.add(nums[i]);
            backTracking(nums,i+1);
            path.removeLast();
        } 
    }
}

小结：

1.标准的三部曲，和树型结构

2.但是要注意这里的终止条件是idx>= nums.length ; for 循环里面是i<nums.length

因为结果是子集，是每一个节点,所以只需要idx>= nums.length;

90. 子集 II

中等

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean [] used;

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if(nums.length==0){
            res.add(path);
            return res;
        }
        Arrays.sort(nums);
        used = new boolean[nums.length];
        backTracking(nums,0);
        return res;

    }

    private void backTracking(int[] nums, int idx){
        res.add(new ArrayList<>(path));
        if(idx>= nums.length) return;

        for(int i =idx; i<nums.length; i++){
            if(i>0&&nums[i]== nums[i-1]&&!used[i-1]){
                continue;
            }
            path.add(nums[i]);
            used[i]=true;
            backTracking(nums,i+1);   
            path.removeLast();
            used[i]=false;    
        }
    }
}

小结：

1.这里注意用used 数组进行树层去重，而保留树枝，

而idx 控制递归

2.获得每个节点，都是结果。所以再递归一开始就加入结果，同时终止条件可看作将数组历遍结束，idx>=nums.length

3.可以不用used 的数组，但是和排列问题不通用 

参考： 

class Solution {

  List<List<Integer>> res = new ArrayList<>();
  LinkedList<Integer> path = new LinkedList<>();
  
  public List<List<Integer>> subsetsWithDup( int[] nums ) {
    Arrays.sort( nums );
    subsetsWithDupHelper( nums, 0 );
    return res;
  }


  private void subsetsWithDupHelper( int[] nums, int start ) {
    res.add( new ArrayList<>( path ) );

    for ( int i = start; i < nums.length; i++ ) {
        // 跳过当前树层使用过的、相同的元素
      if ( i > start && nums[i - 1] == nums[i] ) {
        continue;
      }
      path.add( nums[i] );
      subsetsWithDupHelper( nums, i + 1 );
      path.removeLast();
    }
  }

}

 

 

491. 递增子序列

中等

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

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

示例 1：

输入：nums = [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：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]

提示：

• 1 <= nums.length <= 15
• -100 <= nums[i] <= 100

class Solution {
    List <List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums, 0);
        return result;
    }

    private void backTracking(int [] nums, int idx){
        if(path.size()>1){
            result.add(new ArrayList<>(path));
        }

        int [] used = new int[201];
        for(int i = idx; 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();
        } 

    }
}

小结：

1.  注意这里的递增子集要求，示例2 表示这里是由顺序，所以不可以sort（）

2.这里去重，实际也是广度去重，深度不去重。 升序子集就还会剪小于上一个数的枝条

3.用used 数组记录会比map 和 set 更省空间