Merge pull request #126 from romankurnovskii/problems-944-3665-3669-3750

Add solutions and explanations for problems 944, 3665, 3669, and update explanation for 3750

Author: romankurnovskii

explanations/3665/en.md

@@ -0,0 +1,73 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to count the number of unique paths from the top-left corner (0,0) to the bottom-right corner (m-1, n-1) in a grid where mirrors can reflect the robot's movement. The robot can only move right or down. When attempting to move into a mirror cell, the robot is reflected: moving right into a mirror reflects down, and moving down into a mirror reflects right. If a reflection lands in another mirror, the process continues.
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** Grid dimensions m and n can be up to 500.
+- **Time Complexity:** O(m * n) - we use memoization with 3D DP (i, j, direction), and each state is computed at most once.
+- **Space Complexity:** O(m * n) - we store a 3D DP table of size m * n * 2 (two directions per cell).
+- **Edge Case:** If the starting or ending cell is a mirror, the problem states they are always 0 (non-mirror), so we don't need to handle that case.
+
+**1.2 High-level approach:**
+
+The goal is to use dynamic programming with memoization, tracking not just the position (i, j) but also the direction from which we arrived at that position. This is crucial because when we're at a mirror cell, the reflection depends on the direction we came from.
+
+![Mirror path reflection visualization](https://assets.leetcode.com/static_assets/others/mirror-reflection.png)
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible paths recursively without memoization, which would be exponential O(2^(m+n)) in the worst case.
+- **Optimized Strategy:** Use 3D dynamic programming with memoization, tracking position (i, j) and direction (dir). The direction is necessary because when at a mirror, the reflection depends on how we arrived. This is O(m * n) time.
+- **Optimization:** By memoizing states (i, j, dir), we avoid recalculating the same subproblems, reducing time complexity from exponential to polynomial.
+
+**1.4 Decomposition:**
+
+1. Use a 3D DP table where dp[i][j][dir] represents the number of ways to reach (i,j) with direction dir.
+2. Direction dir = 0 means we came from the left (moved right to reach here), dir = 1 means we came from above (moved down to reach here).
+3. For each cell (i, j) with direction dir:
+   - If the cell is a mirror (grid[i][j] == 1), reflect based on direction:
+     - If dir == 0 (came from left), reflect down (move to i+1, j with dir=1).
+     - If dir == 1 (came from above), reflect right (move to i, j+1 with dir=0).
+   - If the cell is not a mirror, try both moves: right and down.
+4. Use memoization to avoid recalculating the same states.
+5. Return the result modulo 10^9 + 7.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `grid = [[0,1,0],[0,0,1],[1,0,0]]`
+
+- Grid dimensions: m = 3, n = 3
+- Starting position: (0, 0) with dir = 0
+- Destination: (2, 2)
+- Mirrors at: (0,1), (1,2), (2,0)
+
+**2.2 Start Processing:**
+
+We begin recursive DFS from (0, 0) with direction 0.
+
+**2.3 Trace Walkthrough:**
+
+| Position (i,j) | Direction | Cell Type | Action | Next States |
+|----------------|-----------|-----------|--------|-------------|
+| (0,0) | 0 | 0 (empty) | Try both moves | (0,1) dir=0, (1,0) dir=1 |
+| (0,1) | 0 | 1 (mirror) | Reflect down | (1,1) dir=1 |
+| (1,0) | 1 | 0 (empty) | Try both moves | (1,1) dir=0, (2,0) dir=1 |
+| (1,1) | 0 | 0 (empty) | Try both moves | (1,2) dir=0, (2,1) dir=1 |
+| (1,1) | 1 | 0 (empty) | Try both moves | (1,2) dir=0, (2,1) dir=1 |
+| (1,2) | 0 | 1 (mirror) | Reflect down | (2,2) dir=1 ✓ |
+| (2,0) | 1 | 1 (mirror) | Reflect right | (2,1) dir=0 |
+| (2,1) | 0 | 0 (empty) | Try both moves | (2,2) dir=0 ✓ |
+
+**2.4 Increment and Loop:**
+
+The recursive DFS explores all valid paths, using memoization to avoid recalculating the same (i, j, dir) states.
+
+**2.5 Return Result:**
+
+The result is 5, which represents the total number of unique valid paths from (0,0) to (2,2) considering all mirror reflections.
+

explanations/3669/en.md

@@ -0,0 +1,69 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to split an integer n into exactly k positive integers such that their product equals n, and we want to minimize the maximum difference between any two numbers in the split.
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** n can be up to 10^5, and k is between 2 and 5.
+- **Time Complexity:** O(d^k) where d is the number of divisors of n - we use backtracking to try all combinations of k divisors. Since k is small (≤5) and the number of divisors is typically small, this is feasible.
+- **Space Complexity:** O(d + k) - we store all divisors and the current path during backtracking.
+- **Edge Case:** If n is a prime number, the only valid split is [1, 1, ..., 1, n] (k-1 ones and n).
+
+**1.2 High-level approach:**
+
+The goal is to find all divisors of n, then use backtracking to find a combination of k divisors whose product equals n, while minimizing the difference between the maximum and minimum values in the combination.
+
+![Factor decomposition visualization](https://assets.leetcode.com/static_assets/others/factor-decomposition.png)
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Try all possible combinations of k numbers that multiply to n, which would be exponential and inefficient.
+- **Optimized Strategy:** First find all divisors of n, then use backtracking to explore combinations of k divisors. We can prune early when the product exceeds n. This is O(d^k) where d is the number of divisors.
+- **Optimization:** By working only with divisors and pruning branches where the product exceeds n, we significantly reduce the search space compared to trying all possible number combinations.
+
+**1.4 Decomposition:**
+
+1. Find all divisors of n by checking numbers from 1 to sqrt(n).
+2. Sort the divisors for efficient backtracking.
+3. Use backtracking (DFS) to try combinations of k divisors:
+   - Start with an empty path and product = 1.
+   - For each divisor, try adding it to the path and recursively explore.
+   - If we have k divisors and product equals n, check if this combination has a smaller max-min difference.
+   - Prune branches where product exceeds n.
+4. Return the combination with the minimum max-min difference.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `n = 100`, `k = 2`
+
+- Divisors of 100: [1, 2, 4, 5, 10, 20, 25, 50, 100]
+- We need to find 2 divisors whose product is 100 and minimize max - min.
+
+**2.2 Start Processing:**
+
+We begin backtracking with an empty path, product = 1, and picked = 0.
+
+**2.3 Trace Walkthrough:**
+
+| Step | Path | Product | Picked | Action | Valid? |
+|------|------|---------|---------|--------|--------|
+| 1 | [1] | 1 | 1 | Add divisor 1 | Continue |
+| 2 | [1, 1] | 1 | 2 | Add divisor 1 | Product < 100, continue |
+| 3 | [1, 100] | 100 | 2 | Add divisor 100 | Product = 100, diff = 99 |
+| 4 | [1, 50] | 50 | 2 | Try divisor 50 | Product < 100, backtrack |
+| 5 | [10, 10] | 100 | 2 | Try divisor 10 | Product = 100, diff = 0 ✓ |
+
+The best combination is [10, 10] with difference 0.
+
+**2.4 Increment and Loop:**
+
+The backtracking algorithm explores all valid combinations, keeping track of the best result (minimum difference).
+
+**2.5 Return Result:**
+
+The result is [10, 10], which has a product of 100 and a maximum difference of 0, which is the minimum possible.
+

explanations/3750/en.md

@@ -1,47 +1,62 @@
 ## Explanation
 
-### Strategy
+### Strategy (The "Why")
 
-**Constraints & Edge Cases**
+**Restate the problem:** We need to find the minimum number of bit flips required to make an integer equal to its binary reverse. The binary reverse of a number is obtained by reversing its binary representation.
 
-  * **Binary Representation:** We are working with the bits of an integer $n$. The length of the binary string depends on the magnitude of $n$ (up to $\approx 30$ bits for standard integers).
-  * **Time Complexity:** Since the number of bits is small ($\log_2 n$), the solution will be very fast, effectively $O(\log n)$.
-  * **Edge Case:** If $n=0$ or $n$ is a single bit (e.g., 1), the reverse is identical to the original, so the answer is 0.
+**1.1 Constraints & Complexity:**
 
-**High-level approach**
-The problem asks for the minimum flips to make a number equal to its **original** binary reverse.
-Imagine the binary string as a row of lights. We compare the light at the very start (left) with the light at the very end (right).
+- **Input Size:** The integer n can be up to 2^31 - 1, which means up to approximately 31 bits in binary representation.
+- **Time Complexity:** O(log n) - we need to process each bit in the binary representation once, and the number of bits is logarithmic in n.
+- **Space Complexity:** O(log n) - we store the binary string representation, which has length proportional to log n.
+- **Edge Case:** If n = 0 or n has only one bit (e.g., 1), the reverse is identical to the original, so the answer is 0.
 
-  * If the left bit is `1` and the right bit is `0`, we have a mismatch.
-  * To make the number equal to its reverse, the left position *must* become what the right position was, and the right position *must* become what the left position was. This requires flipping **both** bits.
-  * Therefore, every mismatching symmetric pair costs exactly **2 flips**.
+**1.2 High-level approach:**
 
-**Brute force vs. optimized strategy**
+The goal is to compare symmetric bit positions in the binary representation and count how many pairs need to be flipped to make the number equal to its reverse.
 
-  * **Brute Force:** Calculate the reverse of $n$ separately, then iterate through every bit of $n$ and the reverse to count differences.
-  * **Optimized (Two Pointers):** We extract the binary string once. We place pointers at the start and end. We move them inward, counting mismatches. This is efficient and requires only one pass over the bits.
+![Binary bit comparison visualization](https://assets.leetcode.com/static_assets/others/binary-comparison.png)
 
-**Decomposition**
+**1.3 Brute force vs. optimized strategy:**
 
-1.  **Bit Extraction:** Convert the integer $n$ into its binary string format (removing the '0b' prefix).
-2.  **Two-Pointer Scan:** Initialize `left` at index 0 and `right` at the last index.
-3.  **Check Pairs:** If `s[left] != s[right]`, we found a mismatch. Add 2 to our result (1 flip for each side).
-4.  **Converge:** Move `left` forward and `right` backward until they meet.
+- **Brute Force:** Calculate the reverse of n separately, then iterate through every bit of n and the reverse to count differences. This requires creating the full reverse and comparing bit by bit.
+- **Optimized Strategy:** Use two pointers starting from both ends of the binary string, moving inward while comparing symmetric bits. This is O(log n) time and only requires one pass.
+- **Optimization:** By using two pointers, we avoid creating a separate reversed binary string and can process the comparison in a single pass, making the solution more efficient.
 
-### Steps
+**1.4 Decomposition:**
 
-1.  **Convert to Binary**
-    Turn the integer $n$ into a string of bits. For example, if $n=10$, we get the string `"1010"`.
+1. Convert the integer to its binary string representation (removing the '0b' prefix).
+2. Initialize two pointers at the start and end of the binary string.
+3. Compare bits at symmetric positions (left and right pointers).
+4. If bits differ, we need to flip both bits (add 2 to the result).
+5. Move pointers inward until they meet.
+6. Return the total number of flips needed.
 
-2.  **Initialize Pointers**
-    Set a variable `res` to 0. Set `l` to the start of the string and `r` to the end.
+### Steps (The "How")
 
-3.  **Iterate and Compare**
-    While `l` is less than `r`:
+**2.1 Initialization & Example Setup:**
 
-      * Check if the bit at `l` is different from the bit at `r`.
-      * **Why?** If the bits are different (e.g., `1` and `0`), then to swap their values effectively (so the number equals its reverse), both positions must be flipped.
-      * If they differ, add **2** to `res`.
+Let's use the example: `n = 10`
 
-4.  **Close the Window**
-    Increment `l` and decrement `r` to check the next pair of bits. Continue until the pointers meet in the middle.
+- Binary representation: `bin(10) = "0b1010"`, so `s = "1010"`
+- Left pointer `l = 0`, right pointer `r = 3`
+- Result `res = 0`
+
+**2.2 Start Checking:**
+
+We begin comparing bits from both ends of the binary string.
+
+**2.3 Trace Walkthrough:**
+
+| Step | l   | r   | s[l] | s[r] | Match? | Action                | res |
+| ---- | --- | --- | ---- | ---- | ------ | --------------------- | --- |
+| 1    | 0   | 3   | '1'  | '0'  | No     | Flip both bits, add 2 | 2   |
+| 2    | 1   | 2   | '0'  | '1'  | No     | Flip both bits, add 2 | 4   |
+
+**2.4 Increment and Loop:**
+
+After each comparison, we increment `l` and decrement `r` to move toward the center. We continue until `l >= r`.
+
+**2.5 Return Result:**
+
+The result is 4, which means we need to flip 4 bits (2 pairs) to make the number equal to its binary reverse.

explanations/944/en.md

@@ -0,0 +1,69 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We are given an array of strings, all of the same length. When arranged in a grid (one string per row), we need to count how many columns are not sorted lexicographically (in non-decreasing order).
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** The number of strings n can be up to 100, and each string length m can be up to 1000.
+- **Time Complexity:** O(n * m) - we need to check each column, and for each column, we check all rows to see if it's sorted.
+- **Space Complexity:** O(1) - we only use a constant amount of extra space to track the result.
+- **Edge Case:** If all columns are sorted, we return 0. If there's only one string, all columns are trivially sorted.
+
+**1.2 High-level approach:**
+
+The goal is to check each column of the grid to see if it's sorted lexicographically (each character is greater than or equal to the character above it). We count how many columns fail this check.
+
+![Column sorting visualization](https://assets.leetcode.com/static_assets/others/column-sorting.png)
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** This is already the optimal approach - we must check each column and each row in that column to determine if it's sorted.
+- **Optimized Strategy:** Iterate through each column, and for each column, check if any row violates the sorted order (current character < previous character). If we find a violation, we can immediately mark that column as unsorted and move to the next column. This is O(n * m) time.
+- **Optimization:** By breaking early when we find a violation in a column, we avoid unnecessary comparisons, though the worst-case complexity remains the same.
+
+**1.4 Decomposition:**
+
+1. Get the dimensions: number of strings (rows) n and string length (columns) m.
+2. For each column from 0 to m-1:
+   - Check if the column is sorted by comparing each row with the previous row.
+   - If we find any row where the character is less than the character in the previous row, the column is not sorted.
+   - Increment the result counter for each unsorted column.
+3. Return the total count of unsorted columns.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `strs = ["cba", "daf", "ghi"]`
+
+- Number of rows n = 3, number of columns m = 3
+- Grid arrangement:
+  ```
+  c b a
+  d a f
+  g h i
+  ```
+- Result `res = 0`
+
+**2.2 Start Checking:**
+
+We iterate through each column and check if it's sorted.
+
+**2.3 Trace Walkthrough:**
+
+| Column | Row 0 | Row 1 | Row 2 | Is Sorted? | Action | res |
+|--------|-------|-------|-------|------------|--------|-----|
+| 0 | 'c' | 'd' | 'g' | Yes (c < d < g) | Continue | 0 |
+| 1 | 'b' | 'a' | 'h' | No (b > a) | Increment res | 1 |
+| 2 | 'a' | 'f' | 'i' | Yes (a < f < i) | Continue | 1 |
+
+**2.4 Increment and Loop:**
+
+After checking each column, we move to the next column. If we find a violation (current character < previous character), we immediately break from the inner loop and move to the next column.
+
+**2.5 Return Result:**
+
+The result is 1, which means we need to delete 1 column (column 1) because it's not sorted lexicographically.
+

solutions/3665/01.py

@@ -0,0 +1,45 @@
+class Solution:
+    def uniquePaths(self, grid: List[List[int]]) -> int:
+        MOD = 10**9 + 7
+        m, n = len(grid), len(grid[0])
+
+        # 3D DP: dp[i][j][dir] = number of ways to reach (i,j) with direction dir
+        # dir = 0: came from left (moved right to reach here)
+        # dir = 1: came from above (moved down to reach here)
+        dp = [[[-1, -1] for _ in range(n)] for _ in range(m)]
+
+        def dfs(i, j, dir):
+            # Base case: reached destination
+            if i == m - 1 and j == n - 1:
+                return 1
+
+            # Out of bounds
+            if i >= m or j >= n:
+                return 0
+
+            # Memoization
+            if dp[i][j][dir] != -1:
+                return dp[i][j][dir]
+
+            res = 0
+
+            # If current cell is a mirror
+            if grid[i][j] == 1:
+                if dir == 0:  # Came from left, reflect down
+                    res = dfs(i + 1, j, 1)
+                else:  # dir == 1, came from above, reflect right
+                    res = dfs(i, j + 1, 0)
+            else:
+                # Not a mirror, can move both right and down
+                # Move right
+                res = (res + dfs(i, j + 1, 0)) % MOD
+                # Move down
+                res = (res + dfs(i + 1, j, 1)) % MOD
+
+            dp[i][j][dir] = res
+            return res
+
+        # Start at (0,0). Since grid[0][0] is always 0 (not a mirror), we can start with dir=0
+        # The dir parameter represents the direction we came from, but at start it's arbitrary
+        # Since (0,0) is not a mirror, we'll try both moves anyway
+        return dfs(0, 0, 0) % MOD

solutions/3669/01.py

@@ -0,0 +1,41 @@
+class Solution:
+    def minDifference(self, n: int, k: int) -> List[int]:
+        # Find all divisors of n
+        divisors = []
+        i = 1
+        while i * i <= n:
+            if n % i == 0:
+                divisors.append(i)
+                if i != n // i:
+                    divisors.append(n // i)
+            i += 1
+        divisors.sort()
+        
+        res = None
+        min_diff = float('inf')
+        
+        def dfs(start, picked, prod, path):
+            nonlocal res, min_diff
+            
+            if picked == k:
+                if prod == n:
+                    diff = max(path) - min(path)
+                    if diff < min_diff:
+                        min_diff = diff
+                        res = path[:]
+                return
+            
+            if prod > n:
+                return
+            
+            for i in range(start, len(divisors)):
+                divisor = divisors[i]
+                if prod * divisor > n:
+                    break
+                path.append(divisor)
+                dfs(i, picked + 1, prod * divisor, path)
+                path.pop()
+        
+        dfs(0, 0, 1, [])
+        return res
+