PU Subsets

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        if not nums: return []
        def recu(nums, pos, cur, res):
            if pos == len(nums):
                res.append(cur[:])
                return
            recu(nums, pos + 1, cur, res)
            cur.append(nums[pos])
            recu(nums, pos + 1, cur, res)
            cur.pop()
        res = []
        recu(nums, 0, [], res)
        return res

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = []
        cur = []
        def recu(nums):
            if not nums:
                res.append(cur[:])
                return
            num = nums.pop()
            recu(nums)
            cur.append(num)
            recu(nums)
            cur.pop()
            nums.add(num)
        recu(set(nums))
        return res

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = []
        cur = []
        def recu(nums, ind):
            if ind == len(nums):
                res.append(cur[:])
                return
            recu(nums, ind + 1)
            cur.append(nums[ind])
            recu(nums, ind + 1)
            cur.pop()
        recu(nums, 0)
        return res

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *columnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
void recu(int *nums, int numsSize, int **res, int *cs, int *returnSize, int *cur, int len) {
    if (!numsSize) {
        res[*returnSize] = malloc(len * sizeof(int));
        memcpy(res[*returnSize], cur, len * sizeof(int));
        cs[*returnSize] = len;
        ++*returnSize;
        return;
    }
    cur[len++] = nums[0];
    recu(nums + 1, numsSize - 1, res, cs, returnSize, cur, len);
    len--;
    recu(nums + 1, numsSize - 1, res, cs, returnSize, cur, len);
}
int** subsets(int* nums, int numsSize, int** columnSizes, int* returnSize) {
    *returnSize = 1 << numsSize;
    int **res = malloc(*returnSize * sizeof(int *));
    *columnSizes = malloc(*returnSize * sizeof(int));
    int *cur = malloc(numsSize * sizeof(int));
    *returnSize = 0;
    recu(nums, numsSize, res, *columnSizes, returnSize, cur, 0);
    free(cur);
    return res;
}

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *columnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** subsets(int* nums, int numsSize, int** columnSizes, int* returnSize) {
    *returnSize = 1 << numsSize;
    int **res = malloc(*returnSize * sizeof(int *));
    *columnSizes = calloc(*returnSize, sizeof(int));
    int j;
    for (j = 0; j < *returnSize; j++) res[j] = malloc(j * sizeof(int));
    int *mask = malloc(numsSize * sizeof(int));
    mask[0] = 1;
    int i;
    for (i = 1; i < numsSize; i++) mask[i] = mask[i - 1] << 1;
    for (i = 0; i < numsSize; i++) {
        for (j = 0; j < *returnSize; j++) {
            if (j & mask[i]) res[j][((*columnSizes)[j])++] = nums[i];
        }
    }
    return res;
}