Merge pull request #103 from romankurnovskii/problems-1523-448-560-581-617-973-981-1029-1167-1249-1304-1337-1423-1528-1584-1672

Add solutions and explanations for problems 1523, 448, 560, 581, 617, 973, 981, 1029, 1167, 1249, 1304, 1337, 1423, 1528, 1584, 1672

Author: romankurnovskii

explanations/1029/en.md

@@ -0,0 +1,66 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** `2 <= costs.length <= 100`, and `costs.length` is even.
+- **Value Range:** `1 <= aCost_i, bCost_i <= 1000`.
+- **Time Complexity:** O(n log n) where n is the number of people. Sorting takes O(n log n) time.
+- **Space Complexity:** O(1) - we sort in place.
+- **Edge Case:** If there are only 2 people, send one to each city.
+
+**1.2 High-level approach:**
+
+The goal is to minimize the total cost of sending exactly n people to city A and n people to city B. The key insight is to sort people by the difference `(costA - costB)`. People with a large negative difference (much cheaper to go to A) should go to A, and people with a large positive difference (much cheaper to go to B) should go to B.
+
+![Visualization showing how sorting by cost difference helps determine optimal city assignment]
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible ways to assign n people to city A and n to city B. This takes O(C(2n, n)) time, which is exponential.
+- **Optimized Strategy:** Sort by the difference `(costA - costB)`, send the first n to city A and the rest to city B. This takes O(n log n) time.
+- **Why it's better:** The greedy approach of sorting by difference ensures we minimize the total cost by prioritizing people who save the most by going to their preferred city.
+
+**1.4 Decomposition:**
+
+1. Sort the costs array by the difference `(costA - costB)`.
+2. Send the first n people (smallest differences, meaning cheaper to go to A) to city A.
+3. Send the remaining n people (largest differences, meaning cheaper to go to B) to city B.
+4. Return the total cost.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `costs = [[10, 20], [30, 200], [400, 50], [30, 20]]`.
+
+We need to send 2 people to city A and 2 to city B (n = 2).
+
+**2.2 Start Checking:**
+
+Sort by difference `(costA - costB)`.
+
+**2.3 Trace Walkthrough:**
+
+| Person | costA | costB | Difference (costA - costB) | Sorted order | Assignment |
+|--------|-------|-------|---------------------------|--------------|------------|
+| 0 | 10 | 20 | -10 | 1 | City A |
+| 1 | 30 | 200 | -170 | 0 | City A |
+| 2 | 400 | 50 | 350 | 3 | City B |
+| 3 | 30 | 20 | 10 | 2 | City B |
+
+After sorting by difference:
+- Person 1: difference = -170 (cheapest to go to A) -> City A, cost = 30
+- Person 0: difference = -10 (cheaper to go to A) -> City A, cost = 10
+- Person 3: difference = 10 (cheaper to go to B) -> City B, cost = 20
+- Person 2: difference = 350 (cheapest to go to B) -> City B, cost = 50
+
+**2.4 Increment and Loop:**
+
+Calculate total: 30 + 10 + 20 + 50 = 110.
+
+**2.5 Return Result:**
+
+Return `res = 110` - the minimum total cost.
+

explanations/1167/en.md

@@ -0,0 +1,67 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** `1 <= sticks.length <= 10^4`, `1 <= sticks[i] <= 10^4`.
+- **Time Complexity:** O(n log n) where n is the number of sticks. Each heap operation takes O(log n) and we perform O(n) operations.
+- **Space Complexity:** O(n) for the heap.
+- **Edge Case:** If there's only one stick, return 0 (no connection needed).
+
+**1.2 High-level approach:**
+
+The goal is to minimize the total cost of connecting all sticks, where the cost of connecting two sticks is the sum of their lengths. The key insight is to always connect the two shortest sticks first (greedy approach). This minimizes the cost because shorter sticks are used fewer times in the total sum. We use a min-heap to efficiently get the two shortest sticks at each step.
+
+![Visualization showing how connecting shortest sticks first minimizes total cost, with a heap maintaining the shortest sticks]
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible orders of connecting sticks. This is exponential and impractical.
+- **Optimized Strategy:** Use a min-heap to always connect the two shortest sticks. This greedy approach is optimal.
+- **Why it's better:** The greedy approach ensures that shorter sticks (which contribute less) are used in later connections, minimizing the total cost. This is similar to Huffman coding.
+
+**1.4 Decomposition:**
+
+1. Convert the sticks array into a min-heap.
+2. While there's more than one stick in the heap:
+   - Pop the two shortest sticks.
+   - Calculate the cost of connecting them (sum of their lengths).
+   - Add the cost to the total.
+   - Push the merged stick (sum) back into the heap.
+3. Return the total cost.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `sticks = [2, 4, 3]`.
+
+We initialize:
+- Heap: `[2, 3, 4]` (min-heap)
+- `res = 0`
+
+**2.2 Start Checking:**
+
+Connect sticks until only one remains.
+
+**2.3 Trace Walkthrough:**
+
+| Step | Heap before | Pop 1 | Pop 2 | Cost | New stick | Heap after | Total cost |
+|------|-------------|-------|-------|------|-----------|------------|------------|
+| 1 | [2, 3, 4] | 2 | 3 | 5 | 5 | [4, 5] | 5 |
+| 2 | [4, 5] | 4 | 5 | 9 | 9 | [9] | 5 + 9 = 14 |
+
+Detailed steps:
+- Step 1: Pop 2 and 3, cost = 2 + 3 = 5. Push 5 back. Heap: [4, 5]. Total: 5.
+- Step 2: Pop 4 and 5, cost = 4 + 5 = 9. Push 9 back. Heap: [9]. Total: 5 + 9 = 14.
+- Only one stick remains, so we're done.
+
+**2.4 Increment and Loop:**
+
+Continue until heap size is 1.
+
+**2.5 Return Result:**
+
+Return `res = 14` - the minimum total cost to connect all sticks.
+

explanations/1249/en.md

@@ -0,0 +1,92 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** `1 <= s.length <= 10^5`.
+- **Characters:** `s[i]` is either '(', ')', or a lowercase English letter.
+- **Time Complexity:** O(n) - we make two passes through the string.
+- **Space Complexity:** O(n) - we use a stack and a set to track indices to remove.
+- **Edge Case:** If the string has no parentheses, return the original string. If all parentheses are invalid, return only the letters.
+
+**1.2 High-level approach:**
+
+The goal is to remove the minimum number of parentheses to make the string valid. We use a two-pass approach: first, identify invalid parentheses using a stack, then build the result string by skipping those indices.
+
+![Visualization showing how a stack is used to match parentheses and identify invalid ones that need to be removed]
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible combinations of removing parentheses and check validity. This is exponential.
+- **Optimized Strategy:** Use a stack to identify unmatched parentheses in one pass, then build the result in a second pass. This takes O(n) time.
+- **Why it's better:** The stack-based approach efficiently identifies invalid parentheses in linear time, which is optimal for this problem.
+
+**1.4 Decomposition:**
+
+1. First pass: Use a stack to track opening parentheses indices.
+2. When encountering ')', if stack is empty, mark this ')' for removal. Otherwise, pop from stack (matched pair).
+3. After first pass, any remaining indices in the stack are unmatched '(' and should be removed.
+4. Second pass: Build the result string by skipping indices marked for removal.
+5. Return the result string.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `s = "lee(t(c)o)de)"`.
+
+We initialize:
+- `stack = []`
+- `to_remove = set()`
+
+**2.2 Start Checking:**
+
+First pass: Identify invalid parentheses.
+
+**2.3 Trace Walkthrough:**
+
+| Step | char | index | Action | stack | to_remove |
+|------|------|-------|--------|-------|-----------|
+| 1 | 'l' | 0 | Letter, skip | [] | {} |
+| 2 | 'e' | 1 | Letter, skip | [] | {} |
+| 3 | 'e' | 2 | Letter, skip | [] | {} |
+| 4 | '(' | 3 | Push index 3 | [3] | {} |
+| 5 | 't' | 4 | Letter, skip | [3] | {} |
+| 6 | '(' | 5 | Push index 5 | [3, 5] | {} |
+| 7 | 'c' | 6 | Letter, skip | [3, 5] | {} |
+| 8 | ')' | 7 | Pop from stack | [3] | {} |
+| 9 | 'o' | 8 | Letter, skip | [3] | {} |
+| 10 | ')' | 9 | Pop from stack | [] | {} |
+| 11 | 'd' | 10 | Letter, skip | [] | {} |
+| 12 | 'e' | 11 | Letter, skip | [] | {} |
+| 13 | ')' | 12 | Stack empty, mark for removal | [] | {12} |
+
+After first pass:
+- `stack = []` (all '(' were matched)
+- `to_remove = {12}` (unmatched ')')
+
+**2.4 Increment and Loop:**
+
+Second pass: Build result string, skipping index 12.
+
+| Index | char | In to_remove? | Add to result? | Result so far |
+|-------|------|---------------|----------------|---------------|
+| 0 | 'l' | No | Yes | "l" |
+| 1 | 'e' | No | Yes | "le" |
+| 2 | 'e' | No | Yes | "lee" |
+| 3 | '(' | No | Yes | "lee(" |
+| 4 | 't' | No | Yes | "lee(t" |
+| 5 | '(' | No | Yes | "lee(t(" |
+| 6 | 'c' | No | Yes | "lee(t(c" |
+| 7 | ')' | No | Yes | "lee(t(c)" |
+| 8 | 'o' | No | Yes | "lee(t(c)o" |
+| 9 | ')' | No | Yes | "lee(t(c)o)" |
+| 10 | 'd' | No | Yes | "lee(t(c)o)d" |
+| 11 | 'e' | No | Yes | "lee(t(c)o)de" |
+| 12 | ')' | Yes | No | "lee(t(c)o)de" |
+
+**2.5 Return Result:**
+
+Return `res = "lee(t(c)o)de"` - the valid string after removing the minimum number of parentheses.
+

explanations/1304/en.md

@@ -0,0 +1,62 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** `1 <= n <= 1000`.
+- **Time Complexity:** O(n) - we iterate n/2 times to create pairs.
+- **Space Complexity:** O(n) - we create an array of size n.
+- **Edge Case:** If n = 1, return [0]. If n = 2, return [1, -1].
+
+**1.2 High-level approach:**
+
+The goal is to create an array of n unique integers that sum to zero. The key insight is to use pairs of positive and negative numbers that cancel each other out. For even n, we can use n/2 pairs. For odd n, we use (n-1)/2 pairs plus 0.
+
+![Visualization showing how positive and negative number pairs cancel out to sum to zero, with 0 added for odd n]
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible combinations of n unique integers and check if they sum to zero. This is exponential and impractical.
+- **Optimized Strategy:** Use symmetric pairs (x, -x) for even n, or pairs plus 0 for odd n. This is simple and efficient.
+- **Why it's better:** The symmetric pair approach guarantees a sum of zero and is straightforward to implement in O(n) time.
+
+**1.4 Decomposition:**
+
+1. For each integer from 1 to n/2, add both the positive and negative versions to the result.
+2. If n is odd, add 0 to the result.
+3. Return the result array.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `n = 5`.
+
+We initialize:
+- `res = []`
+
+**2.2 Start Checking:**
+
+Create pairs of positive and negative numbers.
+
+**2.3 Trace Walkthrough:**
+
+| Step | i | Positive number | Negative number | res after step |
+|------|---|-----------------|------------------|----------------|
+| 1 | 1 | 1 | -1 | [1, -1] |
+| 2 | 2 | 2 | -2 | [1, -1, 2, -2] |
+
+After creating pairs:
+- We have 2 pairs: [1, -1, 2, -2]
+- Since n = 5 is odd, we need to add 0
+- Final: [1, -1, 2, -2, 0]
+
+**2.4 Increment and Loop:**
+
+Continue until we've created n/2 pairs.
+
+**2.5 Return Result:**
+
+Return `res = [1, -1, 2, -2, 0]` - an array of 5 unique integers that sum to zero (1 + (-1) + 2 + (-2) + 0 = 0).
+

explanations/1337/en.md

@@ -0,0 +1,74 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** `2 <= n, m <= 100`, `1 <= k <= m`.
+- **Time Complexity:** O(m * n + m log m) where m is the number of rows. We count soldiers in each row (O(m * n)), then sort (O(m log m)).
+- **Space Complexity:** O(m) - we store strength and index for each row.
+- **Edge Case:** If k = m, return all row indices. If all rows have the same strength, return the first k indices.
+
+**1.2 High-level approach:**
+
+The goal is to find the k weakest rows, where weakness is determined by the number of soldiers (1s) in the row, with row index as a tiebreaker. We calculate the strength (number of soldiers) for each row, sort by strength (and index as tiebreaker), and return the first k indices.
+
+![Visualization showing a matrix with soldiers (1s) and civilians (0s), with rows sorted by strength from weakest to strongest]
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** For each row, count soldiers, then sort all rows. This is the same as the optimized approach.
+- **Optimized Strategy:** Count soldiers for each row, store (strength, index) pairs, sort by strength then index, return first k indices.
+- **Why it's better:** By storing (strength, index) pairs and sorting once, we efficiently find the k weakest rows in O(m log m) time after counting.
+
+**1.4 Decomposition:**
+
+1. For each row, count the number of soldiers (1s).
+2. Store (strength, row_index) pairs in a list.
+3. Sort the list by strength (ascending), then by index (ascending) as tiebreaker.
+4. Extract the first k indices from the sorted list.
+5. Return the list of k weakest row indices.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example:
+```
+mat = [[1,1,0,0,0],
+       [1,1,1,1,0],
+       [1,0,0,0,0],
+       [1,1,0,0,0],
+       [1,1,1,1,1]]
+k = 3
+```
+
+**2.2 Start Checking:**
+
+Calculate strength for each row.
+
+**2.3 Trace Walkthrough:**
+
+| Row | Row index | Soldiers count | Strength | (strength, index) |
+|-----|-----------|----------------|----------|-------------------|
+| [1,1,0,0,0] | 0 | 2 | 2 | (2, 0) |
+| [1,1,1,1,0] | 1 | 4 | 4 | (4, 1) |
+| [1,0,0,0,0] | 2 | 1 | 1 | (1, 2) |
+| [1,1,0,0,0] | 3 | 2 | 2 | (2, 3) |
+| [1,1,1,1,1] | 4 | 5 | 5 | (5, 4) |
+
+After sorting by (strength, index):
+- (1, 2) - weakest
+- (2, 0) - second weakest
+- (2, 3) - third weakest (tie broken by index)
+- (4, 1)
+- (5, 4)
+
+**2.4 Increment and Loop:**
+
+Extract first k = 3 indices: [2, 0, 3]
+
+**2.5 Return Result:**
+
+Return `res = [2, 0, 3]` - the indices of the 3 weakest rows.
+