upd

Author: romankurnovskii

explanations/237/en.md

@@ -0,0 +1,60 @@
+## Explanation
+
+### Strategy
+
+**Restate the problem**
+
+We need to delete a node from a linked list, but we are only given access to the node to be deleted (not the head). We cannot access the previous node directly.
+
+**1.1 Constraints & Complexity**
+
+- **Input Size:** The linked list has 2 to 1000 nodes.
+- **Time Complexity:** O(1) - We only perform a constant number of operations.
+- **Space Complexity:** O(1) - No additional space is used.
+- **Edge Case:** The node to delete is guaranteed not to be the tail node, so we can safely access node.next.next.
+
+**1.2 High-level approach**
+
+Since we cannot access the previous node, we cannot directly unlink the current node. Instead, we copy the value from the next node into the current node, then skip the next node by linking the current node to the node after the next one.
+
+![Linked list node deletion by copying value](https://assets.leetcode.com/uploads/2020/09/01/node1.jpg)
+
+**1.3 Brute force vs. optimized strategy**
+
+- **Brute Force:** If we had access to the head, we could traverse to find the previous node and update its next pointer. This would be O(n) time.
+- **Optimized Strategy:** Copy the next node's value to the current node and skip the next node. This is O(1) time.
+- **Why optimized is better:** We achieve constant time deletion by cleverly copying data instead of restructuring the list.
+
+**1.4 Decomposition**
+
+1. **Copy Value:** Copy the value from node.next to node.
+2. **Skip Next Node:** Update node.next to point to node.next.next, effectively removing the next node from the list.
+
+### Steps
+
+**2.1 Initialization & Example Setup**
+
+Let's use the example: `head = [4,5,1,9]`, `node = 5` (the node with value 5)
+
+- The linked list: 4 → 5 → 1 → 9
+- We are given the node containing value 5 (second node)
+
+**2.2 Start Processing**
+
+We need to delete the node with value 5. Since we only have access to this node, we cannot modify the previous node (4).
+
+**2.3 Trace Walkthrough**
+
+| Step | Current Node Value | Next Node Value | Action | Result |
+|------|-------------------|-----------------|--------|--------|
+| Initial | 5 | 1 | - | 4 → 5 → 1 → 9 |
+| Copy | 5 → 1 | 1 | Copy next value | 4 → 1 → 1 → 9 |
+| Skip | 1 | 9 | Link to next.next | 4 → 1 → 9 |
+
+**2.4 Update Pointers**
+
+After copying the value, we update `node.next = node.next.next`, which removes the duplicate node from the list.
+
+**2.5 Return Result**
+
+The list becomes `[4,1,9]`, effectively deleting the original node with value 5. Note that we actually deleted the next node, but from the user's perspective, the node with value 5 is gone.

explanations/2482/en.md

@@ -0,0 +1,75 @@
+## Explanation
+
+### Strategy
+
+**Restate the problem**
+
+We are given a binary matrix and need to create a difference matrix where each cell `diff[i][j]` is calculated as: ones in row i + ones in column j - zeros in row i - zeros in column j.
+
+**1.1 Constraints & Complexity**
+
+- **Input Size:** The matrix can have up to 10^5 rows and columns, with total cells up to 10^5.
+- **Time Complexity:** O(m*n) - We need to traverse the matrix twice: once to count ones in rows and columns, and once to build the result matrix.
+- **Space Complexity:** O(m + n) - We store arrays for row and column counts.
+- **Edge Case:** Empty matrix or single cell matrix are handled naturally by the algorithm.
+
+**1.2 High-level approach**
+
+The goal is to compute the difference matrix efficiently by precomputing row and column statistics. Instead of recalculating counts for each cell, we count ones in each row and column once, then use these counts to compute each cell's value.
+
+![Matrix showing row and column counts with difference calculation](https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png)
+
+**1.3 Brute force vs. optimized strategy**
+
+- **Brute Force:** For each cell (i, j), count ones and zeros in row i and column j separately. This results in O(m*n*(m+n)) time complexity, which is inefficient.
+- **Optimized Strategy:** Precompute ones count for all rows and columns in O(m*n) time, then compute each cell in O(1) time using the precomputed values. Total time is O(m*n).
+- **Why optimized is better:** We avoid redundant calculations by reusing row and column statistics across all cells in the same row or column.
+
+**1.4 Decomposition**
+
+1. **Count Row Statistics:** Traverse the matrix once to count the number of ones in each row.
+2. **Count Column Statistics:** During the same traversal, count the number of ones in each column.
+3. **Calculate Zeros:** For each row, zeros = total columns - ones. For each column, zeros = total rows - ones.
+4. **Build Result Matrix:** For each cell (i, j), compute diff[i][j] = ones_row[i] + ones_col[j] - zeros_row[i] - zeros_col[j].
+
+### Steps
+
+**2.1 Initialization & Example Setup**
+
+Let's use the example: `grid = [[0,1,1],[1,0,1],[0,0,1]]`
+
+- Matrix dimensions: 3 rows × 3 columns
+- Initialize `ones_row = [0, 0, 0]` and `ones_col = [0, 0, 0]`
+
+**2.2 Start Counting**
+
+Traverse the matrix to count ones:
+- Row 0: [0,1,1] → ones_row[0] = 2
+- Row 1: [1,0,1] → ones_row[1] = 2
+- Row 2: [0,0,1] → ones_row[2] = 1
+
+- Column 0: [0,1,0] → ones_col[0] = 1
+- Column 1: [1,0,0] → ones_col[1] = 1
+- Column 2: [1,1,1] → ones_col[2] = 3
+
+**2.3 Trace Walkthrough**
+
+| Cell (i,j) | ones_row[i] | ones_col[j] | zeros_row[i] | zeros_col[j] | diff[i][j] |
+|------------|-------------|-------------|--------------|--------------|------------|
+| (0,0) | 2 | 1 | 1 | 2 | 2+1-1-2 = 0 |
+| (0,1) | 2 | 1 | 1 | 2 | 2+1-1-2 = 0 |
+| (0,2) | 2 | 3 | 1 | 0 | 2+3-1-0 = 4 |
+| (1,0) | 2 | 1 | 1 | 2 | 2+1-1-2 = 0 |
+| (1,1) | 2 | 1 | 1 | 2 | 2+1-1-2 = 0 |
+| (1,2) | 2 | 3 | 1 | 0 | 2+3-1-0 = 4 |
+| (2,0) | 1 | 1 | 2 | 2 | 1+1-2-2 = -2 |
+| (2,1) | 1 | 1 | 2 | 2 | 1+1-2-2 = -2 |
+| (2,2) | 1 | 3 | 2 | 0 | 1+3-2-0 = 2 |
+
+**2.4 Build Result**
+
+Create result matrix `res` with dimensions 3×3 and fill each cell using the formula.
+
+**2.5 Return Result**
+
+Return `[[0,0,4],[0,0,4],[-2,-2,2]]`, which matches the expected output.

explanations/797/en.md

@@ -0,0 +1,68 @@
+## Explanation
+
+### Strategy
+
+**Restate the problem**
+
+We need to find all paths from node 0 to node n-1 in a directed acyclic graph (DAG). Each path is a sequence of nodes connected by edges.
+
+**1.1 Constraints & Complexity**
+
+- **Input Size:** The graph has 2 to 15 nodes.
+- **Time Complexity:** O(2^n * n) - In the worst case, there can be exponentially many paths, and each path can have up to n nodes.
+- **Space Complexity:** O(2^n * n) - We need to store all paths, and the recursion stack can go up to n levels.
+- **Edge Case:** If there are no paths from 0 to n-1, we return an empty list.
+
+**1.2 High-level approach**
+
+Use depth-first search (DFS) to explore all possible paths from the source node (0) to the target node (n-1). As we traverse, we maintain the current path and add it to results when we reach the destination.
+
+![Graph showing all paths from source to target](https://assets.leetcode.com/uploads/2020/09/28/all_1.jpg)
+
+**1.3 Brute force vs. optimized strategy**
+
+- **Brute Force:** Generate all possible paths and filter those that end at n-1. This is inefficient and doesn't leverage the DAG structure.
+- **Optimized Strategy:** Use DFS with backtracking to explore paths incrementally, only following edges that can potentially lead to the target. This naturally finds all valid paths.
+- **Why optimized is better:** DFS with backtracking efficiently explores the graph structure without redundant computations, and backtracking allows us to reuse the path list.
+
+**1.4 Decomposition**
+
+1. **Initialize Result:** Create an empty list to store all paths.
+2. **Start DFS:** Begin DFS from node 0 with an initial path containing just node 0.
+3. **Explore Neighbors:** For each neighbor of the current node, add it to the path and recursively explore.
+4. **Record Complete Paths:** When we reach node n-1, add the current path to results.
+5. **Backtrack:** After exploring a neighbor, remove it from the path to try other paths.
+
+### Steps
+
+**2.1 Initialization & Example Setup**
+
+Let's use the example: `graph = [[1,2],[3],[3],[]]`
+
+- Nodes: 0, 1, 2, 3
+- Edges: 0→1, 0→2, 1→3, 2→3
+- Target: node 3
+
+**2.2 Start DFS**
+
+Initialize `res = []` and start DFS from node 0 with `path = [0]`.
+
+**2.3 Trace Walkthrough**
+
+| Current Node | Path | Neighbors | Action | Result |
+|-------------|------|-----------|--------|--------|
+| 0 | [0] | [1,2] | Explore 1 | - |
+| 1 | [0,1] | [3] | Explore 3 | - |
+| 3 | [0,1,3] | [] | Reached target! | Add [0,1,3] |
+| 1 | [0,1] | [3] | Backtrack | - |
+| 0 | [0] | [1,2] | Explore 2 | - |
+| 2 | [0,2] | [3] | Explore 3 | - |
+| 3 | [0,2,3] | [] | Reached target! | Add [0,2,3] |
+
+**2.4 Backtrack and Continue**
+
+After finding path [0,1,3], we backtrack by removing 3 and 1 from the path, returning to node 0. Then we explore the other neighbor (2) to find [0,2,3].
+
+**2.5 Return Result**
+
+After DFS completes, `res = [[0,1,3],[0,2,3]]`, which contains all paths from node 0 to node 3.

solutions/1008/01.py

@@ -0,0 +1,29 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def bstFromPreorder(self, preorder: List[int]) -> Optional[TreeNode]:
+        if not preorder:
+            return None
+
+        root = TreeNode(preorder[0])
+        stack = [root]
+
+        for val in preorder[1:]:
+            node = TreeNode(val)
+
+            # If current value is less than stack top, it's left child
+            if val < stack[-1].val:
+                stack[-1].left = node
+            else:
+                # Find the parent where this node should be right child
+                while stack and stack[-1].val < val:
+                    parent = stack.pop()
+                parent.right = node
+
+            stack.append(node)
+
+        return root

solutions/1079/01.py

@@ -0,0 +1,16 @@
+class Solution:
+    def numTilePossibilities(self, tiles: str) -> int:
+        from collections import Counter
+
+        def backtrack(count):
+            res = 0
+            for char in count:
+                if count[char] > 0:
+                    res += 1  # Count this sequence
+                    count[char] -= 1
+                    res += backtrack(count)  # Continue building
+                    count[char] += 1  # Backtrack
+            return res
+
+        count = Counter(tiles)
+        return backtrack(count)

solutions/1261/01.py

@@ -0,0 +1,28 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class FindElements:
+
+    def __init__(self, root: Optional[TreeNode]):
+        self.values = set()
+
+        def recover(node, val):
+            if not node:
+                return
+            node.val = val
+            self.values.add(val)
+            recover(node.left, 2 * val + 1)
+            recover(node.right, 2 * val + 2)
+
+        recover(root, 0)
+
+    def find(self, target: int) -> bool:
+        return target in self.values
+
+
+# Your FindElements object will be instantiated and called as such:
+# obj = FindElements(root)
+# param_1 = obj.find(target)

solutions/1326/01.py

@@ -0,0 +1,34 @@
+class Solution:
+    def minTaps(self, n: int, ranges: List[int]) -> int:
+        # Create intervals
+        intervals = []
+        for i in range(n + 1):
+            if ranges[i] > 0:
+                left = max(0, i - ranges[i])
+                right = min(n, i + ranges[i])
+                intervals.append((left, right))
+
+        if not intervals:
+            return -1
+
+        # Sort by left endpoint
+        intervals.sort()
+
+        res = 0
+        covered = 0
+        i = 0
+
+        while covered < n:
+            max_right = covered
+            # Find interval that starts <= covered and extends farthest
+            while i < len(intervals) and intervals[i][0] <= covered:
+                max_right = max(max_right, intervals[i][1])
+                i += 1
+
+            if max_right == covered:
+                return -1  # Cannot extend coverage
+
+            covered = max_right
+            res += 1
+
+        return res

solutions/1347/01.py

@@ -0,0 +1,13 @@
+class Solution:
+    def minSteps(self, s: str, t: str) -> int:
+        from collections import Counter
+
+        count_s = Counter(s)
+        count_t = Counter(t)
+
+        res = 0
+        for char in count_s:
+            if count_s[char] > count_t[char]:
+                res += count_s[char] - count_t[char]
+
+        return res

solutions/1551/01.py

@@ -0,0 +1,17 @@
+class Solution:
+    def findMinFibonacciNumbers(self, k: int) -> int:
+        # Generate Fibonacci numbers up to k
+        fib = [1, 1]
+        while fib[-1] < k:
+            fib.append(fib[-1] + fib[-2])
+
+        # Greedy: use largest Fibonacci number <= remaining k
+        res = 0
+        idx = len(fib) - 1
+        while k > 0:
+            while fib[idx] > k:
+                idx -= 1
+            k -= fib[idx]
+            res += 1
+
+        return res

solutions/1605/01.py

@@ -0,0 +1,14 @@
+class Solution:
+    def restoreMatrix(self, rowSum: List[int], colSum: List[int]) -> List[List[int]]:
+        m, n = len(rowSum), len(colSum)
+        res = [[0] * n for _ in range(m)]
+
+        for i in range(m):
+            for j in range(n):
+                # Place minimum of remaining row sum and column sum
+                val = min(rowSum[i], colSum[j])
+                res[i][j] = val
+                rowSum[i] -= val
+                colSum[j] -= val
+
+        return res