Merge pull request #116 from romankurnovskii/problems-3606-2627-2807-1769-239-2161-2181-2044-1038-2433-2125-2657-2265-1828

Add solutions and explanations for problems 3606, 2807, 1769, 239, 2161, 2181, 2044, 1038, 2433, 2125, 2657, 2265, 1828

Author: romankurnovskii

explanations/1038/en.md

@@ -0,0 +1,55 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** The number of nodes is in the range `[1, 100]`, and node values are between 0 and 100.
+  * **Time Complexity:** O(n) - We traverse each node exactly once in reverse inorder.
+  * **Space Complexity:** O(h) - The recursion stack uses space proportional to the height of the tree, where h is at most n.
+  * **Edge Case:** A tree with a single node returns itself with the same value.
+
+**High-level approach**
+We perform a reverse inorder traversal (right, root, left) of the BST. This visits nodes in descending order. As we traverse, we accumulate the sum of all values we've seen and update each node's value to be the sum of itself and all greater values.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** Collect all values, sort them, and update nodes - but this requires extra space.
+  * **Optimized Strategy:** Use reverse inorder traversal to visit nodes in descending order naturally, updating values in-place.
+
+**Decomposition**
+
+1.  **Initialize Accumulator:** Create a variable to track the running sum of all values seen.
+2.  **Reverse Inorder Traversal:** Traverse right subtree first, then process current node, then left subtree.
+3.  **Update Node Value:** Add current node's value to the accumulator and update the node.
+4.  **Continue Traversal:** Process all nodes in descending order.
+
+### Steps
+
+1.  **Initialization & Example Setup:**
+    Let's say we have a BST: `[4, 1, 6, 0, 2, 5, 7, null, null, null, 3, null, null, null, 8]`
+    We initialize `total = 0`.
+
+2.  **Start Traversal:**
+    We begin reverse inorder traversal (right, root, left).
+
+3.  **Trace Walkthrough:**
+    
+    | Node Value | Total Before | Total After | Node Updated To |
+    |------------|--------------|-------------|-----------------|
+    | 8 | 0 | 8 | 8 |
+    | 7 | 8 | 15 | 15 |
+    | 6 | 15 | 21 | 21 |
+    | 5 | 21 | 26 | 26 |
+    | 4 | 26 | 30 | 30 |
+    | 3 | 30 | 33 | 33 |
+    | 2 | 33 | 35 | 35 |
+    | 1 | 35 | 36 | 36 |
+    | 0 | 36 | 36 | 36 |
+
+4.  **Result:**
+    The tree is updated in-place with new values.
+
+5.  **Return Result:**
+    Return the modified root of the tree.
+

explanations/1769/en.md

@@ -0,0 +1,49 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** The length of boxes string `n` is between 1 and 2000.
+  * **Time Complexity:** O(n²) - For each of n positions, we iterate through all n boxes to calculate operations.
+  * **Space Complexity:** O(n) - We create a result array of size n.
+  * **Edge Case:** If all boxes are empty (all '0'), all positions require 0 operations.
+
+**High-level approach**
+For each target position, we calculate the total number of operations needed to move all balls from their current positions to that target. Each ball requires `abs(target_position - current_position)` operations to move.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** For each position, iterate through all boxes and sum the distances. This is O(n²) which is acceptable for n ≤ 2000.
+  * **Optimized Strategy:** We could use prefix sums to optimize, but for the given constraints, the brute force approach is straightforward and efficient enough.
+
+**Decomposition**
+
+1.  **Initialize Result Array:** Create an array of zeros with length n.
+2.  **For Each Target Position:** Calculate operations needed to move all balls to this position.
+3.  **Sum Distances:** For each ball (box with '1'), add the absolute distance to the target.
+4.  **Store Result:** Save the total operations for each position.
+
+### Steps
+
+1.  **Initialization & Example Setup:**
+    Let's say `boxes = "110"` (boxes at positions 0 and 1 have balls).
+    We create `res = [0, 0, 0]` to store operations for each position.
+
+2.  **Start Checking:**
+    For each position `i` from 0 to n-1, we'll calculate the total operations.
+
+3.  **Trace Walkthrough:**
+    
+    | Target Position | Ball at 0 | Ball at 1 | Total Operations |
+    |----------------|-----------|-----------|------------------|
+    | 0 | abs(0-0) = 0 | abs(0-1) = 1 | 0 + 1 = 1 |
+    | 1 | abs(1-0) = 1 | abs(1-1) = 0 | 1 + 0 = 1 |
+    | 2 | abs(2-0) = 2 | abs(2-1) = 1 | 2 + 1 = 3 |
+
+4.  **Result:**
+    After processing all positions, `res = [1, 1, 3]`
+
+5.  **Return Result:**
+    Return the result array `[1, 1, 3]`.
+

explanations/1828/en.md

@@ -0,0 +1,52 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** Points array has up to 500 points, and queries array has up to 500 queries.
+  * **Time Complexity:** O(q * p) - For each query, we check all points, where q is the number of queries and p is the number of points.
+  * **Space Complexity:** O(q) - We create a result array of size q.
+  * **Edge Case:** If a circle has radius 0, only points exactly at the center are inside.
+
+**High-level approach**
+For each query circle, we check all points to see if they're inside the circle. A point is inside if the distance from the point to the circle center is less than or equal to the radius.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** For each query, check all points - this is O(q * p) which is acceptable for the given constraints.
+  * **Optimized Strategy:** We could use spatial data structures, but for the given constraints, the brute force approach is simple and efficient.
+
+**Decomposition**
+
+1.  **Process Each Query:** For each circle query, extract center coordinates and radius.
+2.  **Check Each Point:** For each point, calculate distance to circle center.
+3.  **Check Inclusion:** If distance squared <= radius squared, the point is inside.
+4.  **Count Points:** Count how many points are inside each circle.
+
+### Steps
+
+1.  **Initialization & Example Setup:**
+    Let's say `points = [[1,3], [3,3], [5,3], [2,2]]` and `queries = [[2,3,1], [4,3,1], [1,1,2]]`.
+    We create `res = []`.
+
+2.  **Start Processing:**
+    We iterate through each query.
+
+3.  **Trace Walkthrough:**
+    
+    | Query | Center | Radius | Point | Distance² | Inside? | Count |
+    |-------|--------|--------|-------|-----------|---------|-------|
+    | [2,3,1] | (2,3) | 1 | [1,3] | (1-2)²+(3-3)²=1 | Yes | 1 |
+    | | | | [3,3] | (3-2)²+(3-3)²=1 | Yes | 2 |
+    | | | | [5,3] | (5-2)²+(3-3)²=9 | No | 2 |
+    | | | | [2,2] | (2-2)²+(2-3)²=1 | Yes | 3 |
+    | [4,3,1] | (4,3) | 1 | ... | ... | ... | 2 |
+    | [1,1,2] | (1,1) | 2 | ... | ... | ... | 2 |
+
+4.  **Result:**
+    After processing all queries, `res = [3, 2, 2]`
+
+5.  **Return Result:**
+    Return the array `[3, 2, 2]`.
+

explanations/2044/en.md

@@ -0,0 +1,49 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** Array length is between 1 and 16, and values are between 1 and 10⁵.
+  * **Time Complexity:** O(2^n * n) - We generate 2^n subsets, and for each subset we compute the OR in O(n) time.
+  * **Space Complexity:** O(1) - We only use a constant amount of extra space (excluding the output).
+  * **Edge Case:** When all elements are the same, all non-empty subsets have the same OR value.
+
+**High-level approach**
+The maximum possible bitwise OR is achieved by taking the OR of all elements. We generate all non-empty subsets and count how many have this maximum OR value.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** Generate all subsets using bitmasks and check their OR values - this is what we do, and it's efficient for n ≤ 16.
+  * **Optimized Strategy:** Same approach - use bitmasking to enumerate all 2^n subsets efficiently.
+
+**Decomposition**
+
+1.  **Calculate Maximum OR:** Compute the OR of all elements to find the maximum possible OR.
+2.  **Generate Subsets:** Use bitmasks from 1 to 2^n - 1 to represent all non-empty subsets.
+3.  **Compute Subset OR:** For each subset, calculate its bitwise OR.
+4.  **Count Matches:** Count how many subsets have OR equal to the maximum.
+
+### Steps
+
+1.  **Initialization & Example Setup:**
+    Let's say `nums = [3, 1]`.
+    We calculate `max_or = 3 | 1 = 3`.
+
+2.  **Start Processing:**
+    We iterate through all bitmasks from 1 to (1 << n) - 1 = 3.
+
+3.  **Trace Walkthrough:**
+    
+    | Mask (binary) | Subset | OR Value | Match? |
+    |---------------|--------|----------|--------|
+    | 01 | [3] | 3 | Yes |
+    | 10 | [1] | 1 | No |
+    | 11 | [3, 1] | 3 | Yes |
+
+4.  **Result:**
+    We count 2 subsets with OR = 3.
+
+5.  **Return Result:**
+    Return `res = 2`.
+

explanations/2125/en.md

@@ -0,0 +1,54 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** The bank has dimensions m x n where `1 <= m, n <= 500`.
+  * **Time Complexity:** O(m * n) - We iterate through all rows to count devices, then through device counts to calculate beams.
+  * **Space Complexity:** O(m) - We store device counts for each row (at most m rows).
+  * **Edge Case:** If there's only one row with devices, there are no beams (need at least two rows).
+
+**High-level approach**
+We count security devices in each row, skip empty rows, and calculate beams between adjacent non-empty rows. The number of beams between two rows equals the product of device counts in those rows.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** For each device pair, check if there's a clear path - this is O(m² * n²).
+  * **Optimized Strategy:** Count devices per row, then multiply counts of adjacent rows. This is O(m * n).
+
+**Decomposition**
+
+1.  **Count Devices Per Row:** Count '1' characters in each row.
+2.  **Filter Non-Empty Rows:** Only keep rows with at least one device.
+3.  **Calculate Beams:** For each pair of adjacent rows, multiply their device counts.
+4.  **Sum Total:** Add up all beam counts.
+
+### Steps
+
+1.  **Initialization & Example Setup:**
+    Let's say `bank = ["011001", "000000", "010100", "001000"]`.
+    We create `device_counts = []`.
+
+2.  **Start Counting:**
+    We iterate through each row and count '1' characters.
+
+3.  **Trace Walkthrough:**
+    
+    | Row | Devices | Count | Action |
+    |-----|---------|-------|--------|
+    | "011001" | 3 | 3 | Add to device_counts |
+    | "000000" | 0 | 0 | Skip (empty row) |
+    | "010100" | 2 | 2 | Add to device_counts |
+    | "001000" | 1 | 1 | Add to device_counts |
+
+    After counting: `device_counts = [3, 2, 1]`
+
+4.  **Calculate Beams:**
+    - Between rows 0 and 1: 3 * 2 = 6 beams
+    - Between rows 1 and 2: 2 * 1 = 2 beams
+    - Total: 6 + 2 = 8 beams
+
+5.  **Return Result:**
+    Return `res = 8`.
+

explanations/2161/en.md

@@ -0,0 +1,52 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** Array length can be up to 10⁵, and values can range from -10⁶ to 10⁶.
+  * **Time Complexity:** O(n) - We make a single pass through the array to partition elements.
+  * **Space Complexity:** O(n) - We create three lists to store elements (less, equal, greater).
+  * **Edge Case:** All elements equal to pivot results in returning the original array.
+
+**High-level approach**
+We partition the array into three groups: elements less than pivot, elements equal to pivot, and elements greater than pivot. We maintain the relative order within each group, then combine them.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** Sort the array - but this doesn't maintain relative order of elements within groups.
+  * **Optimized Strategy:** Use three separate lists to collect elements in a single pass, preserving relative order.
+
+**Decomposition**
+
+1.  **Create Three Lists:** Initialize lists for elements less than, equal to, and greater than pivot.
+2.  **Partition Elements:** Iterate through the array and place each element into the appropriate list.
+3.  **Combine Lists:** Concatenate the three lists in order: less, equal, greater.
+
+### Steps
+
+1.  **Initialization & Example Setup:**
+    Let's say `nums = [9, 12, 5, 10, 14, 3, 10]` and `pivot = 10`.
+    We create three empty lists: `less = []`, `equal = []`, `greater = []`.
+
+2.  **Start Processing:**
+    We iterate through each element in `nums`.
+
+3.  **Trace Walkthrough:**
+    
+    | Element | Comparison | Action | less | equal | greater |
+    |---------|-------------|--------|------|-------|---------|
+    | 9 | 9 < 10 | Add to less | [9] | [] | [] |
+    | 12 | 12 > 10 | Add to greater | [9] | [] | [12] |
+    | 5 | 5 < 10 | Add to less | [9, 5] | [] | [12] |
+    | 10 | 10 == 10 | Add to equal | [9, 5] | [10] | [12] |
+    | 14 | 14 > 10 | Add to greater | [9, 5] | [10] | [12, 14] |
+    | 3 | 3 < 10 | Add to less | [9, 5, 3] | [10] | [12, 14] |
+    | 10 | 10 == 10 | Add to equal | [9, 5, 3] | [10, 10] | [12, 14] |
+
+4.  **Combine:**
+    `res = less + equal + greater = [9, 5, 3] + [10, 10] + [12, 14] = [9, 5, 3, 10, 10, 12, 14]`
+
+5.  **Return Result:**
+    Return the combined array `[9, 5, 3, 10, 10, 12, 14]`.
+

explanations/2181/en.md

@@ -0,0 +1,53 @@
+## Explanation
+
+### Strategy
+
+**Constraints & Edge Cases**
+
+  * **Input Size:** The number of nodes is in the range `[3, 2 * 10⁵]`, and node values are between 0 and 1000.
+  * **Time Complexity:** O(n) - We traverse the linked list once, visiting each node exactly once.
+  * **Space Complexity:** O(1) - We only use a constant amount of extra space (excluding the output list).
+  * **Edge Case:** The list always starts and ends with zero nodes, and there are no two consecutive zeros.
+
+**High-level approach**
+We traverse the linked list, summing values between consecutive zero nodes. Each sum becomes a new node in the result list, and we skip the zero nodes.
+
+**Brute force vs. optimized strategy**
+
+  * **Brute Force:** Create a new list by collecting values between zeros - this is what we do, and it's optimal.
+  * **Optimized Strategy:** Same approach - single pass through the list, summing values between zeros.
+
+**Decomposition**
+
+1.  **Skip First Zero:** Start from the node after the first zero.
+2.  **Sum Values:** Accumulate values until we encounter the next zero.
+3.  **Create Node:** Create a new node with the sum and add it to the result.
+4.  **Repeat:** Continue until we've processed all nodes.
+
+### Steps
+
+1.  **Initialization & Example Setup:**
+    Let's say we have a linked list: `[0, 3, 1, 0, 4, 5, 2, 0]`
+    We skip the first zero and start with `current` pointing to node with value 3.
+
+2.  **Start Processing:**
+    We create a dummy node to build the result list: `dummy = ListNode(0)`, `tail = dummy`.
+
+3.  **Trace Walkthrough:**
+    
+    | Current Node | Value | Sum | Action |
+    |-------------|------|-----|--------|
+    | 3 | 3 | 3 | Add to sum |
+    | 1 | 1 | 4 | Add to sum |
+    | 0 | 0 | - | Create node(4), reset sum |
+    | 4 | 4 | 4 | Add to sum |
+    | 5 | 5 | 9 | Add to sum |
+    | 2 | 2 | 11 | Add to sum |
+    | 0 | 0 | - | Create node(11), done |
+
+4.  **Result:**
+    After processing, we have a list: `[4, 11]`
+
+5.  **Return Result:**
+    Return `dummy.next` which points to the first merged node.
+