Subsets in Python

Generating all possible subsets of a given set is a fundamental problem in computer science, also known as finding the power set. For a set like [1, 2, 3], the power set contains all combinations: [[], [1], [2], [3], [1,2], [1,3], [2,3], [1,2,3]].

We can solve this using a recursive backtracking approach where each element can either be included or excluded from a subset.

Recursive Backtracking Approach

The algorithm works by making binary choices for each element − include it (1) or exclude it (0) from the current subset.

Algorithm Steps

• Create a temporary array to track inclusion/exclusion (0 or 1) for each element
• Use recursion to explore both choices for each position
• When we reach the end, convert the binary representation to actual subset
• Backtrack to explore all possibilities

Implementation

class Solution:
    def subsets(self, nums):
        temp_result = []
        self.subsets_util(nums, [0 for i in range(len(nums))], temp_result, 0)
        
        main_result = []
        for binary_list in temp_result:
            temp = []
            for i in range(len(binary_list)):
                if binary_list[i] == 1:
                    temp.append(nums[i])
            main_result.append(temp)
        return main_result
    
    def subsets_util(self, nums, temp, result, index):
        if index == len(nums):
            result.append([i for i in temp])
            return
        
        # Exclude current element
        temp[index] = 0
        self.subsets_util(nums, temp, result, index + 1)
        
        # Include current element
        temp[index] = 1
        self.subsets_util(nums, temp, result, index + 1)

# Test the solution
solution = Solution()
result = solution.subsets([1, 2, 3, 4])
print("All subsets:")
for subset in result:
    print(subset)

All subsets:
[]
[4]
[3]
[3, 4]
[2]
[2, 4]
[2, 3]
[2, 3, 4]
[1]
[1, 4]
[1, 3]
[1, 3, 4]
[1, 2]
[1, 2, 4]
[1, 2, 3]
[1, 2, 3, 4]

Simpler Iterative Approach

For a more intuitive solution, we can use an iterative approach with list comprehension ?

def generate_subsets(nums):
    subsets = [[]]  # Start with empty subset
    
    for num in nums:
        # For each existing subset, create a new subset by adding current element
        new_subsets = [subset + [num] for subset in subsets]
        subsets.extend(new_subsets)
    
    return subsets

# Test the function
numbers = [1, 2, 3]
all_subsets = generate_subsets(numbers)
print(f"Subsets of {numbers}:")
for subset in all_subsets:
    print(subset)

Subsets of [1, 2, 3]:
[]
[1]
[2]
[1, 2]
[3]
[1, 3]
[2, 3]
[1, 2, 3]

Using Python's Built-in itertools

Python provides a built-in solution using itertools.combinations() ?

from itertools import combinations

def get_all_subsets(nums):
    subsets = []
    # Generate subsets of all possible lengths (0 to n)
    for length in range(len(nums) + 1):
        for subset in combinations(nums, length):
            subsets.append(list(subset))
    return subsets

# Example usage
numbers = [1, 2, 3]
result = get_all_subsets(numbers)
print(f"All subsets: {result}")
print(f"Total subsets: {len(result)}")

All subsets: [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]
Total subsets: 8

Key Points

• Time Complexity: O(2^n) where n is the number of elements
• Space Complexity: O(2^n) for storing all subsets
• Total number of subsets for n elements is always 2^n
• The recursive approach uses backtracking to explore all possibilities

Conclusion

Generating subsets can be solved using recursive backtracking, iterative building, or Python's built-in itertools.combinations(). The recursive approach demonstrates the fundamental concept, while itertools provides the most concise solution for practical use.