Subsets

Author: dksifoua

README.md

@@ -22,6 +22,7 @@
 | 0049 | Medium     | Group Anagrams                                            | Array, HashTable, String, Sorting                                           | [solution](./docs/0049-Group-Anagrams.md )                                                                        |
 | 0074 | Medium     | Search a 2D Matrix                                        | Array, Binary Search, Matrix                                                | [solution](./docs/0074-Search-A-2D-Matrix.md)                                                                     |
 | 0076 | Hard       | Minimum Window Substring                                  | Hash Table, String, Sliding Window                                          | [solution](./docs/0076-Mininum-Window-Substring.md)                                                               |
+| 0078 | Medium     | Subsets                                                   | Array, Backtracking, Bit Manipulation                                       | [solution](./docs/0078-Subsets.md)                                                                                |
 | 0084 | Hard       | Largest Rectangle in Histogram                            | Array, Stack, Monotonic Stack                                               | [solution](./docs/0084-Largest-Rectangle-In-Histogram.md)                                                         |
 | 0098 | Medium     | Validate Binary Search Tree                               | Tree, Depth-First Search, Binary Search Tree, Binary Tree                   | [solution](./docs/0098-Validate-Binary-Search-Tree.md)                                                            |
 | 0100 | Easy       | Same Tree                                                 | Tree, Depth-First Search, Breadth-First Search, Binary Tree                 | [solution](./docs/0100-Same-Tree.md)                                                                              |

docs/0078-Subsets.md

@@ -0,0 +1,40 @@
+# 🧠 [Subsets](https://leetcode.com/problems/subsets/description/)
+
+## 💡 Intuition
+
+To generate all possible subsets (the power set) of an array of unique integers, we recognize that each element has two
+choices: either it is included in a subset or it is not. This binary decision at each element leads to a total of
+\(2^n\) subsets for an array of length \(n\).
+
+The key idea is to simulate this decision-making process iteratively using a queue (Breadth-First Search style), where
+each tuple in the queue represents a current subset and the index of the element being considered next.
+
+## 🔍 Approach
+
+- Use a `Deque` to perform a breadth-first construction of subsets.
+- Begin with an empty subset and index 0.
+- While the number of generated subsets is less than \(2^n\), pop a tuple off the queue.
+- For each tuple, branch into two new tuples:
+    - One that keeps the subset as is (excluding the current index).
+    - One that includes the current index element in the subset.
+- Push both new tuples back into the queue with the index incremented.
+- Continue until all subsets are generated.
+- Return only the subsets (not the indices).
+
+## ⏱️ Complexity
+
+- **Time Complexity**: \(O(2^n \cdot n)\)
+    - There are \(2^n\) subsets.
+    - Each subset can take up to \(O(n)\) time to copy or create.
+- **Space Complexity**: \(O(2^n \cdot n)\)
+    - Due to storing all subsets in memory.
+
+## 🧪 Code
+
+- [Java](../src/main/java/io/dksifoua/leetcode/subsets/Solution.java)
+
+## ✅ Summary
+
+This solution takes an iterative BFS-inspired approach to subset generation. It systematically expands each subset by
+including or excluding the current element. The result is an efficient and clean method that produces all \(2^n\)
+subsets without duplication.

src/main/java/io/dksifoua/leetcode/subsets/Solution.java

@@ -0,0 +1,37 @@
+package io.dksifoua.leetcode.subsets;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.*;
+
+public class Solution {
+
+    public List<List<Integer>> subsets(int[] nums) {
+        Deque<Tuple> queue = new ArrayDeque<>() {{
+            add(new Tuple(Collections.emptyList(), 0));
+        }};
+        int subsetLength = (int) Math.pow(2, nums.length);
+        while (queue.size() < subsetLength) {
+            Tuple tuple = queue.removeFirst();
+
+
+            List<Integer> subset1 = new ArrayList<>(tuple.getSubset());
+            List<Integer> subset2 = new ArrayList<>(tuple.getSubset()) {{ add(nums[tuple.getIndex()]); }};
+
+            queue.addLast(new Tuple(subset1, tuple.getIndex() + 1));
+            queue.addLast(new Tuple(subset2, tuple.getIndex() + 1));
+        }
+
+        return queue.stream().map(Tuple::getSubset).toList();
+    }
+
+    @Getter
+    @Setter
+    @AllArgsConstructor
+    private static class Tuple {
+        private List<Integer> subset;
+        private int index;
+    }
+}