Add solutions and explanations for problems 216, 328, 374, 437, 649, 700, 714, 735, 790, 872, 875, 1161, 1268, 1318, 1448, 1466, 2095, 2130, 2300, 2336

Author: vikahaze

explanations/1161/en.md

@@ -0,0 +1,64 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+* **Input Size:** The tree can have up to 10^4 nodes.
+* **Time Complexity:** O(n) - We visit each node once using BFS, where n is the number of nodes.
+* **Space Complexity:** O(w) where w is the maximum width of the tree. In worst case O(n).
+* **Edge Case:** If the tree is empty, return 0. If all level sums are equal, return the smallest level (1).
+
+**1.2 High-level approach:**
+
+The goal is to find the level with the maximum sum of node values. We use BFS (level-order traversal) to process nodes level by level and track the sum for each level.
+
+![BFS traversal showing level-by-level processing and sum calculation]
+
+**1.3 Brute force vs. optimized strategy:**
+
+* **Brute Force:** Use DFS to collect all nodes by level, then calculate sums. This requires extra space to store level information.
+* **Optimized (BFS):** Use BFS to process one level at a time, calculating the sum as we go. This is O(n) time and naturally processes levels in order.
+* **Why it's better:** BFS naturally processes levels sequentially, making it straightforward to track level sums without extra data structures.
+
+**1.4 Decomposition:**
+
+1. Use a queue for BFS traversal.
+2. For each level:
+   - Process all nodes at the current level.
+   - Sum their values.
+   - Track the maximum sum and corresponding level.
+3. Return the smallest level with maximum sum.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: root = [1,7,0,7,-8,null,null]
+
+We initialize:
+* `queue = deque([root])`
+* `max_sum = -inf`
+* `res = 1`
+* `level = 1`
+
+**2.2 Start Checking/Processing:**
+
+We enter a while loop while the queue is not empty.
+
+**2.3 Trace Walkthrough:**
+
+| Level | Nodes | Level Sum | max_sum | res |
+|-------|-------|-----------|---------|-----|
+| 1 | [1] | 1 | 1 | 1 |
+| 2 | [7, 0] | 7 | 7 | 2 |
+| 3 | [7, -8] | -1 | 7 | 2 |
+
+**2.4 Increment and Loop:**
+
+After processing each level, we increment the level counter and continue to the next level.
+
+**2.5 Return Result:**
+
+After processing all levels, `res = 2` is returned (level 2 has maximum sum of 7).
+

explanations/1268/en.md

@@ -0,0 +1,66 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+* **Input Size:** Products array can have up to 1000 strings, each up to 3000 characters. SearchWord can be up to 1000 characters.
+* **Time Complexity:** O(m * log m + n * m) where m is products length and n is searchWord length. Sorting takes O(m log m), and for each character we scan products.
+* **Space Complexity:** O(m) for sorted products plus O(n * 3) for results.
+* **Edge Case:** If no products match a prefix, return an empty list for that prefix.
+
+**1.2 High-level approach:**
+
+The goal is to suggest up to 3 products that have a common prefix with the search word as each character is typed. We sort products first, then for each prefix, find matching products.
+
+![Prefix matching showing how products are filtered as each character is typed]
+
+**1.3 Brute force vs. optimized strategy:**
+
+* **Brute Force:** For each prefix, scan all products and filter those starting with the prefix. This is O(n * m) where n is searchWord length.
+* **Optimized (Sorting + Linear Scan):** Sort products once, then for each prefix, scan from the beginning and collect up to 3 matches. This is O(m log m + n * m).
+* **Why it's better:** Sorting ensures we get lexicographically minimum products first, and we can stop after finding 3 matches.
+
+**1.4 Decomposition:**
+
+1. Sort the products array lexicographically.
+2. For each character in searchWord:
+   - Build the current prefix.
+   - Scan products from the beginning.
+   - Collect products that start with the prefix (up to 3).
+   - Add to results.
+3. Return the list of suggestion lists.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord = "mouse"
+
+We initialize:
+* Sort products: ["mobile","moneypot","monitor","mouse","mousepad"]
+* `res = []`
+* `prefix = ""`
+
+**2.2 Start Checking/Processing:**
+
+We iterate through each character in searchWord.
+
+**2.3 Trace Walkthrough:**
+
+| Char | prefix | Matching Products | Suggestions |
+|------|--------|-------------------|-------------|
+| 'm' | "m" | mobile, moneypot, monitor | ["mobile","moneypot","monitor"] |
+| 'o' | "mo" | mobile, moneypot, monitor | ["mobile","moneypot","monitor"] |
+| 'u' | "mou" | mouse, mousepad | ["mouse","mousepad"] |
+| 's' | "mous" | mouse, mousepad | ["mouse","mousepad"] |
+| 'e' | "mouse" | mouse, mousepad | ["mouse","mousepad"] |
+
+**2.4 Increment and Loop:**
+
+After processing each character, we append the suggestions list to results and continue.
+
+**2.5 Return Result:**
+
+After processing all characters, `res = [["mobile","moneypot","monitor"], ["mobile","moneypot","monitor"], ["mouse","mousepad"], ["mouse","mousepad"], ["mouse","mousepad"]]` is returned.
+

explanations/1318/en.md

@@ -0,0 +1,64 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+* **Input Size:** a, b, and c can be up to 10^9.
+* **Time Complexity:** O(log(max(a,b,c))) - We process each bit position, and the number of bits is logarithmic in the value.
+* **Space Complexity:** O(1) - We only use a constant amount of extra space.
+* **Edge Case:** If a OR b already equals c, return 0 (no flips needed).
+
+**1.2 High-level approach:**
+
+The goal is to find the minimum number of bit flips needed to make (a OR b) equal to c. We check each bit position and determine how many flips are needed.
+
+![Bit manipulation showing how each bit position is checked and flipped]
+
+**1.3 Brute force vs. optimized strategy:**
+
+* **Brute Force:** Try all possible combinations of bit flips. This is exponential.
+* **Optimized (Bit-by-bit Check):** Check each bit position independently. For each position, if (a_bit OR b_bit) != c_bit, calculate the minimum flips needed. This is O(log(max(a,b,c))) time.
+* **Why it's better:** Bit positions are independent, so we can process them separately and sum the flips needed.
+
+**1.4 Decomposition:**
+
+1. Initialize result counter to 0.
+2. While any of a, b, or c is non-zero:
+   - Extract the least significant bit of each.
+   - Check if (a_bit OR b_bit) equals c_bit.
+   - If not, calculate flips needed:
+     - If c_bit is 1: flip one of a or b (1 flip).
+     - If c_bit is 0: flip both a and b if they're both 1 (2 flips), or flip the one that's 1 (1 flip).
+   - Right-shift all numbers.
+3. Return total flips.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: a = 2 (binary 10), b = 6 (binary 110), c = 5 (binary 101)
+
+We initialize:
+* `res = 0`
+
+**2.2 Start Checking/Processing:**
+
+We enter a while loop while any number is non-zero.
+
+**2.3 Trace Walkthrough:**
+
+| Bit Pos | a_bit | b_bit | c_bit | a OR b | Match? | Flips Needed | res |
+|---------|-------|-------|-------|--------|-------|--------------|-----|
+| 0 | 0 | 0 | 1 | 0 | No | 1 (set a or b) | 1 |
+| 1 | 1 | 1 | 0 | 1 | No | 2 (clear both) | 3 |
+| 2 | 0 | 1 | 1 | 1 | Yes | 0 | 3 |
+
+**2.4 Increment and Loop:**
+
+After processing each bit, we right-shift all numbers and continue.
+
+**2.5 Return Result:**
+
+After processing all bits, `res = 3` is returned.
+

explanations/1448/en.md

@@ -0,0 +1,64 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+* **Input Size:** The tree can have up to 10^5 nodes.
+* **Time Complexity:** O(n) - We visit each node once using DFS, where n is the number of nodes.
+* **Space Complexity:** O(h) for the recursion stack where h is the height. In worst case O(n).
+* **Edge Case:** The root is always a good node since there are no nodes above it.
+
+**1.2 High-level approach:**
+
+The goal is to count nodes where the path from root to that node has no node with value greater than the current node. We use DFS to traverse the tree, tracking the maximum value seen so far.
+
+![Tree traversal showing how we track maximum values along paths]
+
+**1.3 Brute force vs. optimized strategy:**
+
+* **Brute Force:** For each node, check all nodes on the path from root to it. This is O(n^2) in worst case.
+* **Optimized (DFS with Max Tracking):** During DFS, pass the maximum value seen so far. If current node's value >= max, it's good. This is O(n) time.
+* **Why it's better:** We check the condition during traversal without storing paths, making it O(n) instead of O(n^2).
+
+**1.4 Decomposition:**
+
+1. Use DFS to traverse the tree.
+2. For each node, check if its value >= max_value_seen.
+3. If yes, increment the count and update max_value_seen.
+4. Recursively process left and right children with updated max_value.
+5. Return the total count.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: root = [3,1,4,3,null,1,5]
+
+We initialize:
+* `res = 0`
+* Start DFS from root with `max_val = 3` (root value)
+
+**2.2 Start Checking/Processing:**
+
+We call `dfs(root, root.val)`.
+
+**2.3 Trace Walkthrough:**
+
+| Node | Value | max_val | Value >= max? | Action | res |
+|------|-------|---------|---------------|--------|-----|
+| 3 | 3 | 3 | Yes | Count++, max=3 | 1 |
+| 1 | 1 | 3 | No | Skip | 1 |
+| 3 | 3 | 3 | Yes | Count++, max=3 | 2 |
+| 4 | 4 | 3 | Yes | Count++, max=4 | 3 |
+| 1 | 1 | 4 | No | Skip | 3 |
+| 5 | 5 | 4 | Yes | Count++, max=5 | 4 |
+
+**2.4 Increment and Loop:**
+
+After processing each node, we recursively process its children.
+
+**2.5 Return Result:**
+
+After processing all nodes, `res = 4` is returned (nodes 3, 3, 4, and 5 are good).
+

explanations/1466/en.md

@@ -0,0 +1,71 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+* **Input Size:** n can be up to 5 * 10^4, and there are n-1 connections.
+* **Time Complexity:** O(n) - We build the graph and traverse it once using DFS.
+* **Space Complexity:** O(n) - We store the graph and use O(n) for recursion stack.
+* **Edge Case:** If all roads already point toward city 0, return 0.
+
+**1.2 High-level approach:**
+
+The goal is to find the minimum number of road reversals needed so all cities can reach city 0. We treat the graph as undirected and use DFS from city 0, counting roads that need reversal.
+
+![Graph traversal showing which roads need to be reversed]
+
+**1.3 Brute force vs. optimized strategy:**
+
+* **Brute Force:** Try all possible combinations of road reversals. This is exponential.
+* **Optimized (DFS from Root):** Treat graph as undirected, start DFS from city 0. When traversing an edge in the original direction (away from 0), it needs reversal. This is O(n) time.
+* **Why it's better:** We only need one DFS traversal to identify all roads that need reversal, making it O(n) instead of exponential.
+
+**1.4 Decomposition:**
+
+1. Build an undirected graph from connections, marking original direction.
+2. Start DFS from city 0.
+3. For each edge traversed:
+   - If the edge was originally directed away from the current node (toward 0), it's correct, no reversal needed.
+   - If the edge was originally directed toward the current node (away from 0), it needs reversal, increment count.
+4. Return the count.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]
+
+We initialize:
+* Build graph: 
+  - 0: [(1,0)] (edge to 1, original direction)
+  - 1: [(0,0), (3,1)]
+  - 2: [(3,1)]
+  - 3: [(1,0), (2,0)]
+  - 4: [(0,1), (5,1)]
+  - 5: [(4,0)]
+* `res = 0`
+
+**2.2 Start Checking/Processing:**
+
+We call `dfs(0, -1)` starting from city 0.
+
+**2.3 Trace Walkthrough:**
+
+| Current | Neighbor | Direction | Action | res |
+|---------|----------|-----------|--------|-----|
+| 0 | 1 | 0 (toward 0) | Correct, no reversal | 0 |
+| 1 | 3 | 1 (away from 0) | Needs reversal | 1 |
+| 3 | 2 | 1 (away from 0) | Needs reversal | 2 |
+| 0 | 4 | 1 (away from 0) | Wait, from 0's perspective... | |
+| 4 | 0 | 1 (toward 0) | Correct | 2 |
+| 4 | 5 | 1 (away from 0) | Needs reversal | 3 |
+
+**2.4 Increment and Loop:**
+
+After processing each edge, we continue DFS to the next city.
+
+**2.5 Return Result:**
+
+After processing all cities, `res = 3` is returned (roads [1,3], [2,3], and [4,5] need reversal).
+