#LeetCode#SubSets & SubSetsII

Subsets

Given a set of distinct integers, S, return all possible subsets.

Note:

• Elements in a subset must be in non-descending order.
• The solution set must not contain duplicate subsets.

For example,
If S = [1,2,3], a solution is:

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

解题分析：

这题其实算是基础题，　掌握好这个可以在其基础上衍生出很多题目。　主要应用了递归的思路，　对于每一个指针start， 循环加入以S[start]为起始元素的subset， 一层for循环结束后， 把刚刚加入到临时子集中的元素remove掉， 也就是回溯。

还是考察基本功， 自己还是漏洞百出啊... 第一个版本如下

public class Solution {
    public List<List<Integer>> subsets(int[] S) {
        List<List<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(S == null || S.length == 0){
            return result;
        }
        List<Integer> list = new ArrayList<Integer>();
        Arrays.sort(S);
        subsetsHelper(result, list, S, 0);
        return result;
    }
    public static void subsetsHelper(ArrayList<List<Integer>> result, ArrayList<Integer> list, int[] S, int pos){
        result.add(list);
        for(int i = pos; i < S.length; i++){
            list.add(S[i]);
            subsetsHelper(result, list, S, pos + 1);
            list.remove(list.size() - 1);
        }
    }
}

上面犯的错误有： 

1. result的生命方式不对：

List<List<Integer>> result = new ArrayList<ArrayList<Integer>>();

对应此种形式正确的表述方法应该是：

List<List<Integer>> result = new ArrayList<List<Integer>>();        TODO： WHY???

然后相对应的， 在helper method中的parameters类型 在上面的版本中也是错误的。。对于Java的多态我还是理解的不够。。。 应该改成以下形式

public class Solution {
    public List<List<Integer>> subsets(int[] S) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(S == null || S.length == 0){
            return result;
        }
        List<Integer> list = new ArrayList<Integer>();
        Arrays.sort(S);
        subsetsHelper(result, list, S, 0);
        return result;
    }
    public static void subsetsHelper(List<List<Integer>> result, List<Integer> list, int[] S, int pos){
        // result.add(list);
        result.add(new ArrayList<Integer>(list));
        for(int i = pos; i < S.length; i++){
            list.add(S[i]);
            subsetsHelper(result, list, S, i + 1);
            list.remove(list.size() - 1);
        }
    }
}

2. 

<span style="white-space:pre">	</span>// result.add(list);
        result.add(new ArrayList<Integer>(list));

pass by reference 这个自己也知道， 但是写的时候居然理所应当的直接add了list， 引用和别人讨论时写的一段话： “debug了一下, 发现了问题: 每次不new 一个arraylist, 而是直接 tmp.add(list); 这样tmp加进去的始终是同一个list的reference, 比如刚开始加进去是[], 然后当加入[1]到result时, result实际上是{{1} , {1}}, 然后加入[2]到list后, result add list变成了 {{1,2}{1,2}{1,2}}. 这显然是不对的”

        哦对， 还有一个犯的错误， 写code 的时候对于是 Arrays.sort() 还是 Array.sort() 犹豫不决， 想了老半天才决定用Arrays.sort()

对于Collection还是不熟。

=====================================================================================================

          

Subsets II

  Total Accepted: 17759  Total Submissions: 65681 My Submissions

Given a collection of integers that might contain duplicates, S, return all possible subsets.

Note:

• Elements in a subset must be in non-descending order.
• The solution set must not contain duplicate subsets.

For example,
If S = [1,2,2], a solution is:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

这个题和上面那道大体都是一样的， 但是有重复元素， 而结果要求不能有重复的子集。 自己做的时候没有想到什么巧妙的去重方法, 用了   if(!result.contains(list)){result.add(new ArrayList<Integer>(list));}   这样算是比较耍赖的做法了吧。。而且每次递归调用helper方法的时候都会校验是否有重复子集，速度肯定慢

其实只要在I的基础上稍微变形一下就可以了， 思路就是在循环中， 把不是起点，值又和起点相同的元素跳过， 这里参考了九章的答案

public class Solution {
    public List<List<Integer>> subsetsWithDup(int[] num) {
        List result = new ArrayList();
        if(num == null || num.length == 0){
            return result;
        }
        List<Integer> list = new ArrayList<Integer>();
        Arrays.sort(num);
        helper(result, list, num, 0);
        return result;
    }
    
    public void helper(List result, List<Integer> list, int[] num, int start){
        // if(!result.contains(list)){
        //     result.add(new ArrayList<Integer>(list));
        // }
        result.add(new ArrayList<Integer>(list));
        for(int i = start; i < num.length; i++){
            if(i != start && num[i] == num[i - 1]){
                continue;
            }
            list.add(num[i]);
            helper(result, list, num, i + 1);
            list.remove(list.size() - 1);
        }
    }
}

两种解法的Run Time差了差不多1/3.

这两题的时间复杂度应该都是O（n^2）