Subsets 求子集 @LeetCode

package Level3;

/**
 * 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],
  []
]
 * 
 */

import java.util.ArrayList;
import java.util.Arrays;

public class S78 {

	public static void main(String[] args) {
		int[] S = {1,2,3};
		System.out.println(subsets(S));
	}

	public static ArrayList<ArrayList<Integer>> subsets(int[] S) {
		int len = S.length;
		ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
		Arrays.sort(S);
		
		// 利用2进制对应的bit来求所有subset，2进制中，0代表不选，1代表选择
		for(int i=0; i<Math.pow(2,len); i++){
			ArrayList<Integer> list = new ArrayList<Integer>();
			int tmp = i;
			// 对长为len的数，循环检查最右位是否为一
			for(int j=0; j<len; j++){
				int bit = tmp & 1;
				tmp >>= 1;
				if(bit == 1){
					list.add(S[j]);
				}
			}
			ret.add(list);
		}
		return ret;
    }
	
}

任何一个元素都可以放入子集，也可以不放入子集

package Recursion;

import java.util.ArrayList;
import java.util.List;

public class Subsets {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		subsets(list);
	}
	
	public static void subsets(List<String> list){
		ArrayList<ArrayList<String>> ret = new ArrayList<ArrayList<String>>();
		List<String> done = new ArrayList<String>();
		rec(done, list, ret);
//		System.out.println(ret);
		for (ArrayList<String> al : ret) {
			System.out.println(al);
		}
	}

	public static void rec(List<String> done, List<String> rest, ArrayList<ArrayList<String>> ret){
		if(rest.size() == 0){
			ret.add(new ArrayList<String>(done));
			return;
		}
		
		String head = rest.remove(0);
		done.add(head);
		rec(done, rest, ret);
		done.remove(done.size()-1);
		
		rec(done, rest, ret);
		rest.add(0, head);
	}
}

注意：

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

public class Solution {
    public List<List<Integer>> subsets(int[] S) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        ArrayList<Integer> list = new ArrayList<Integer>();
        Arrays.sort(S);   // to keep ascending order
        rec(S, ret, list, 0);
        return ret;
    }
    
    public void rec(int[] S, List<List<Integer>> ret, List<Integer> list, int pos) {
        if(pos >= S.length) {
            ret.add(new ArrayList<Integer>(list));
            return;
        }
        
        rec(S, ret, list, pos+1);
        
        list.add(S[pos]);
        rec(S, ret, list, pos+1);
        list.remove(list.size()-1);
    }
}