详细见:leetcode.com/problems/subsets
Java Solution: github
package leetcode;
/*
* Given a set of distinct integers, nums, return all possible subsets.
Note: The solution set must not contain duplicate subsets.
For example,
If nums = [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.Iterator;
import java.util.LinkedList;
import java.util.List;
public class P078_Subsets {
public static void main(String[] args) {
List<List<Integer>> ans = new Solution().subsets(new int[] {3, 2, 1, 0});
Iterator<List<Integer>> it = ans.iterator();
while (it.hasNext()) {
tools.Utils.B_打印List_Integer_OneLine(it.next());
}
}
/*
* 比上题逻辑要好得多
* AC
* 2 ms
*/
static class Solution {
List<List<Integer>> ans = new LinkedList<List<Integer>>();
int[] ks = null;
public List<List<Integer>> subsets(int[] nums) {
ks = new int[nums.length];
for (int list_size = 0; list_size <= nums.length; list_size ++)
search(nums, list_size, 0, -1);
return ans;
}
private void search(int[] nums, int list_size, int li, int maxi) {
if (li == list_size) {
List<Integer> temp = new ArrayList<Integer>(list_size);
for (int i = 0; i != list_size; i ++)
temp.add(ks[i]);
ans.add(temp);
return;
}
for (int i = maxi + 1; i < nums.length; i ++) {
ks[li ++] = nums[i];
search(nums, list_size, li, i);
li --;
}
}
}
}
C Solution: github
/*
url: leetcode.com/problems/subsets/
AC 3ms 47.37%
*/
#include <stdio.h>
#include <stdlib.h>
typedef int* T;
typedef struct al sal;
typedef struct al * pal;
struct al {
int capacity;
int size;
T* arr;
};
pal al_init(int capacity) {
pal l = (pal) malloc(sizeof(sal));
if (capacity < 1) return NULL;
l->arr = (T*) malloc(sizeof(T) * capacity);
l->capacity = capacity;
l->size = 0;
return l;
}
void al_expand_capacity(pal l) {
T* new_arr = (T*) malloc(sizeof(T) * (l->capacity * 2 + 1));
int i = 0;
for (i = 0; i < l->capacity; i ++)
new_arr[i] = l->arr[i];
free(l->arr);
l->arr = new_arr;
l->capacity = l->capacity * 2 + 1;
}
void al_add_last(pal l, T v) {
if (l->capacity == l->size) al_expand_capacity(l);
l->arr[l->size] = v;
l->size ++;
}
T* al_convert_to_array_free_l(pal l) {
T* arr = l->arr;
free(l);
return arr;
}
int* arr_copy(int* save, int n) {
int* copy = (int*) malloc(sizeof(int) * n);
int i = 0;
for (i = 0; i < n; i ++)
copy[i] = save[i];
return copy;
}
//[l, r]
int _partition(int* n, int l, int r) {
int s = *(n + l);
while (l < r) {
while (l < r && *(n + r) >= s) r --;
*(n + l) = *(n + r);
while (l < r && *(n + l) <= s) l ++;
*(n + r) = *(n + l);
}
*(n + l) = s;
return l;
}
//[l, r)
void _quick_sort(int* n, int l, int r) {
int p = 0;
if (l < r) {
p = _partition(n, l, r - 1);
_quick_sort(n, l, p);
_quick_sort(n, p + 1, r);
}
}
void search(int* n, int ni, int nn, int* save, int si, int sn, pal l, pal ln) {
int* t = NULL;
int i = 0;
if (si == sn) {
al_add_last(l, arr_copy(save, sn));
t = (int*) malloc(sizeof(int));
t[0] = sn;
al_add_last(ln, t);
return;
}
for (i = ni; i < nn; i ++) {
if (i != 0 && n[i-1] == n[i]) continue;
save[si] = n[i];
search(n, i+1, nn, save, si+1, sn, l, ln);
}
}
int** subsets(int* n, int nn, int** cn, int* rn) {
int ni = 0;
int* save = (int*) malloc(sizeof(int) * nn);
int sn = 0;
pal l = al_init(16);
pal ln = al_init(16);
_quick_sort(n, 0, nn);
for (sn = 0; sn <= nn; sn ++) {
search(n, 0, nn, save, 0, sn, l, ln);
}
*cn = (int*) malloc(sizeof(int) * ln->size);
*rn = ln->size;
for (ni = 0; ni < ln->size; ni ++) {
(*cn)[ni] = ln->arr[ni][0];
}
return al_convert_to_array_free_l(l);
}
int main() {
int n[] = {1, 2, 3};
int nn = 3;
int* cn = NULL;
int rn = 0;
int** ans = subsets(n, nn, &cn, &rn);
printf("size is %d\r\n", rn);
}
Python Solution: github
#coding=utf-8
'''
url: leetcode.com/problems/subsets
@author: zxwtry
@email: zxwtry@qq.com
@date: 2017年4月18日
@details: Solution: 59ms 49.62%
'''
class Solution(object):
def search(self, n, ni, nn, s, si, sn, a):
if si == sn:
a.append(list(s))
return
for i in range(ni, nn):
if i != 0 and n[i]==n[i-1]: continue
s[si] = n[i]
self.search(n, i+1, nn, s, si+1, sn, a)
def subsets(self, n):
"""
:type n: List[int]
:rtype: List[List[int]]
"""
if n == None or len(n) == 0: return []
n.sort(key=None, reverse=False)
a, nn = [], len(n)
for i in range(nn+1):
s = [0] * i
self.search(n, 0, nn, s, 0, i, a)
return a
if __name__ == "__main__":
n = [1 ,2, 3]
print(Solution().subsets(n))