LeetCode刷题笔录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],
  []
]

想法就是DFS。

自己总是写不出递归的方法，只能用非递归来写。

这里有一个递归的方法，里面的讲解非常的到位，点个赞。

public class Solution {
    public ArrayList<ArrayList<Integer>> subsets(int[] S) {
        if(S == null)
            return null;
        Arrays.sort(S);
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> output = new ArrayList<Integer>();
        subsets(S, 0, result, output);
        return result;
    }
    
    public void subsets(int[] S, int index, ArrayList<ArrayList<Integer>> result, ArrayList<Integer> output){
        if(index == S.length){
            result.add(new ArrayList<Integer>(output));
            return;
        }
        //choose i
        output.add(S[index]);
        subsets(S, index + 1, result, output);
        output.remove(output.size() - 1);
        //do not choose i
        subsets(S, index + 1, result, output);
    }
}

非递归的解法不难想：先把空集放到结果中；外层循环遍历S；对于S的每个元素，遍历当前的结果集，将结果集的每一个solution set复制一份，加上当前的元素，再放回结果集即可。

public class Solution {
    public List<List<Integer>> subsets(int[] S) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if(S == null || S.length == 0)
            return res;
        Arrays.sort(S);
        //put an empty set in the result
        res.add(new ArrayList<Integer>());
        
        for(int i = 0; i < S.length; i++){
            //iterate through the current result set and add the element into each solution set
            int size = res.size();
            for(int j = 0; j < size; j++){
                List<Integer> sol = new ArrayList<Integer>(res.get(j));
                sol.add(S[i]);
                res.add(sol);
            }
        }
        return res;
    }
    

}