LeetCode:Subsets I

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

開始想法以給定數組爲字典序進行排序，給定一個子序列之後求下一個序列，最終得到全部序列：

public class Solution {
    ArrayList<Integer> nextSubSet(ArrayList<Integer> in,int [] A)
    {
        int len=A.length;
        int i,j,size=in.size();
        if(len==size)return null;
        int num=in.get(0);
        ArrayList<Integer> out=new ArrayList<Integer>();
        if(num==A[len-size]){
            for(i=0;i<size+1;i++)out.add(A[i]);
            return out;
        }
        Iterator<Integer> it=in.iterator();
        while(it.hasNext())out.add(it.next());
        i=0;
        while(out.get(size-1-i)==A[len-1-i])i++;
        i=size-1-i;
        num=out.get(i);
        for(j=0;j<len;j++)if(A[j]==num)break;
        out.set(i,A[j+1]);
        i=i+1;
        j=j+2;
for(;i<size;i++,j++)out.set(i,A[j]);
        return out;
    }
    public ArrayList<ArrayList<Integer>> subsets(int[] S) {
        ArrayList<ArrayList<Integer>> list=new ArrayList<ArrayList<Integer>>();
        int len=S.length;
        if(len==0)return list;
        Arrays.sort(S);
        ArrayList<Integer> innerList=new ArrayList<Integer>();
        list.add(innerList);
        innerList=new ArrayList<Integer>();
        innerList.add(S[0]);
        while(innerList!=null)
        {
            list.add(innerList);
            innerList=nextSubSet(innerList,S);
            
        }
        return list;
    }
}

之後想到可以用遞歸直接來做，實質上是DFS：

public class Solution {
      ArrayList<ArrayList<Integer>> list=new ArrayList<ArrayList<Integer>>();
      ArrayList<Integer> copy(ArrayList<Integer> in)
      {
          
            ArrayList<Integer> out=new ArrayList<Integer>();
          Iterator<Integer> it=in.iterator();
          while(it.hasNext())out.add(it.next());
          return out;
      }
    public void dfs(int [] A,int index,ArrayList<Integer> in)
    {   
        if(index==A.length){
            ArrayList<Integer> out=copy(in);
            list.add(out);
            return;
            }
        in.add(A[index]);
        dfs(A,index+1,in);
        in.remove(in.size()-1);
        dfs(A,index+1,in);
    }
    public ArrayList<ArrayList<Integer>> subsets(int[] S) {
         ArrayList<Integer> in=new ArrayList<Integer>();
        int len=S.length;
        Arrays.sort(S);
        dfs(S,0,in);
        return list;
    }
}