LeetCode078 Subsets

详细见：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))