feat(algorithms, dynamic programming minimum path sum): find the minimum path sum in a grid

Author: BrianLusina

algorithms/arrays/find_missing_elem/README.md

@@ -1,4 +1,4 @@
-# Find Missing element
+# Find Missing Element
 
 An array A consisting of N different integers is given. The array contains integers in the range [1..(N + 1)], which
 means that exactly one element is missing.
@@ -40,3 +40,8 @@ within the range [1..(N + 1)].
 - Binary Search
 - Bit Manipulation
 - Sorting
+
+---
+
+Find Missing Numbers
+

algorithms/arrays/find_missing_elem/__init__.py

@@ -55,3 +55,7 @@ def find_missing_number_sum_of_n_terms(nums):
     expected_sum = len_nums * (len_nums + 1) // 2
 
     return expected_sum - total_sum
+
+
+def find_missing_numbers(nums: List[int]) -> List[int]:
+    pass

algorithms/dynamic_programming/min_path_sum/README.md

@@ -53,3 +53,39 @@ grows quadratically.
 ### Space Complexity
 
 The space complexity is O(n) since we only maintain a single working array `dp` with one entry per row.
+
+--- 
+
+## Min Path Sum in Grid
+
+Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum
+of all numbers along its path.
+
+> Note: You can only move either down or right at any point in time.
+
+Example 1
+```text
+Input: grid = [[1,3,1],[1,5,1],[4,2,1]]
+Output: 7
+Explanation: Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum.
+```
+
+Example 2:
+
+```text
+Input: grid = [[1,2,3],[4,5,6]]
+Output: 12
+```
+
+### Constraints
+
+- m == grid.length
+- n == grid[i].length
+- 1 <= m, n <= 200
+- 0 <= grid[i][j] <= 200
+
+## Topics
+
+- Array
+- Dynamic Programming
+- Matrix

algorithms/dynamic_programming/min_path_sum/__init__.py

@@ -1,7 +1,7 @@
 from typing import List
 
 
-def min_path_sum(triangle: List[List[int]]) -> int:
+def min_path_sum_in_triangle(triangle: List[List[int]]) -> int:
     """
     Finds the minimum path sum in a given triangle of numbers
     This uses bottom up dynamic programming by starting at the bottom, we ensure that every decision made at a higher row
@@ -32,7 +32,7 @@ def min_path_sum(triangle: List[List[int]]) -> int:
     return triangle[0][0]
 
 
-def min_path_sum_2(triangle: List[List[int]]) -> int:
+def min_path_sum_in_triangle_2(triangle: List[List[int]]) -> int:
     """
     Finds the minimum path sum in a given triangle of numbers
     This uses bottom up dynamic programming by starting at the bottom, we ensure that every decision made at a higher row
@@ -60,3 +60,46 @@ def min_path_sum_2(triangle: List[List[int]]) -> int:
 
     # the result trickles to the apex
     return dp[0]
+
+
+def min_path_sum_grid(grid: List[List[int]]) -> int:
+    # m = number of rows, n = number of columns
+    m = len(grid)
+    n = len(grid[0])
+
+    # Iterate over every cell in row-major order
+    for i in range(m):
+        for j in range(n):
+            if i == 0 and j > 0:
+               # First row but not [0][0]: we can only come from the left
+                grid[i][j] += grid[i][j - 1]
+            elif j == 0 and i > 0:
+                # First column but not [0][0]: we can only come from above
+                grid[i][j] += grid[i - 1][j]
+            elif i > 0 and j > 0:
+                 # For all other cells, choose the minimum of:
+                # - the path sum from above (i-1, j)
+                # - the path sum from the left (i, j-1)
+                grid[i][j] += min(grid[i - 1][j], grid[i][j - 1])
+
+    # The bottom-right cell now contains the minimum path sum
+    return grid[m - 1][n - 1]
+
+
+def min_path_sum_grid_2(grid: List[List[int]]) -> int:
+    if not grid or not grid[0]:
+        return 0
+
+    n_rows, n_cols = len(grid), len(grid[0])
+
+    for i in range(1, n_rows):
+        grid[i][0] += grid[i - 1][0]
+
+    for i in range(1, n_cols):
+        grid[0][i] += grid[0][i - 1]
+
+    for r in range(1, n_rows):
+        for c in range(1, n_cols):
+            grid[r][c] += min(grid[r - 1][c], grid[r][c - 1])
+
+    return grid[-1][-1]

algorithms/dynamic_programming/min_path_sum/test_min_path_sum.py

@@ -2,28 +2,50 @@
 import copy
 from typing import List
 from parameterized import parameterized
-from algorithms.dynamic_programming.min_path_sum import min_path_sum, min_path_sum_2
+from algorithms.dynamic_programming.min_path_sum import min_path_sum_in_triangle, min_path_sum_in_triangle_2, min_path_sum_grid, min_path_sum_grid_2
 
-TEST_CASES = [
+MIN_PATH_SUM_TRIANGLE_TEST_CASES = [
     ([[5]], 5),
     ([[2], [3, 4]], 5),
     ([[1000], [2000, 3000]], 3000),
     ([[2], [3, 4], [6, 5, 7], [4, 1, 8, 3]], 11),
     ([[7], [3, 8], [8, 1, 0], [2, 7, 4, 4], [4, 5, 2, 6, 5]], 17),
 ]
 
+MIN_PATH_SUM_GRID_TEST_CASES = [
+    ([[1,3,1],[1,5,1],[4,2,1]], 7),
+    ([[1,2,3],[4,5,6]], 12),
+    ([[1, 2, 5], [3, 2, 1]], 6),
+    ([[5, 9, 1, 3], [4, 2, 1, 7], [3, 1, 1, 2]], 15),
+    ([[5]], 5),
+    ([[1, 0, 0], [1, 1, 0], [1, 1, 1]], 2),
+    ([[7, 1, 3, 2], [2, 5, 10, 1], [4, 2, 1, 3]], 17),
+]
 
-class MinPathSumInTriangleTestCase(unittest.TestCase):
-    @parameterized.expand(TEST_CASES)
+
+class MinPathSumTestCase(unittest.TestCase):
+    @parameterized.expand(MIN_PATH_SUM_TRIANGLE_TEST_CASES)
     def test_min_path_sum_in_triangle(self, triangle: List[List[int]], expected: int):
         input_triangle = copy.deepcopy(triangle)
-        actual = min_path_sum(input_triangle)
+        actual = min_path_sum_in_triangle(input_triangle)
         self.assertEqual(expected, actual)
 
-    @parameterized.expand(TEST_CASES)
+    @parameterized.expand(MIN_PATH_SUM_TRIANGLE_TEST_CASES)
     def test_min_path_sum_2_in_triangle(self, triangle: List[List[int]], expected: int):
         input_triangle = copy.deepcopy(triangle)
-        actual = min_path_sum_2(input_triangle)
+        actual = min_path_sum_in_triangle_2(input_triangle)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(MIN_PATH_SUM_GRID_TEST_CASES)
+    def test_min_path_sum_in_grid(self, grid: List[List[int]], expected: int):
+        input_triangle = copy.deepcopy(grid)
+        actual = min_path_sum_grid(input_triangle)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(MIN_PATH_SUM_GRID_TEST_CASES)
+    def test_min_path_sum_2_in_grid(self, grid: List[List[int]], expected: int):
+        input_triangle = copy.deepcopy(grid)
+        actual = min_path_sum_grid_2(input_triangle)
         self.assertEqual(expected, actual)
 
 

algorithms/trie/topkfreqwords/README.md

@@ -0,0 +1,32 @@
+# Top K Frequent Words
+
+Given a list of strings words and an integer k, return the k most frequently occurring strings.
+
+Note: The result should be sorted in descending order based on frequency. If multiple words have the same frequency,
+they should be sorted in lexicographical order.
+
+## Constraints
+
+- 1 <= words.length <= 500
+- 1 <= words[i].length <= 10
+- words[i] consists of lowercase English letters.
+- k is in the range [1, The number of unique words[i]]
+
+## Examples
+
+Example 1:
+```text
+Input: words = ["i","love","leetcode","i","love","coding"], k = 2
+Output: ["i","love"]
+Explanation: "i" and "love" are the two most frequent words.
+Note that "i" comes before "love" due to a lower alphabetical order.
+```
+
+Example 2:
+```text
+Input: words = ["the","day","is","sunny","the","the","the","sunny","is","is"], k = 4
+Output: ["the","is","sunny","day"]
+Explanation: "the", "is", "sunny" and "day" are the four most frequent words, with the number of occurrence being 4, 3,
+2 and 1 respectively. 
+```
+

algorithms/trie/topkfreqwords/__init__.py

@@ -0,0 +1,36 @@
+from typing import List, Optional
+from collections import defaultdict, Counter
+from datastructures.trees.trie import Trie
+
+
+def top_k_frequent_words(words: List[str], k: int) -> List[str]:
+    frequency_map = defaultdict(int)
+    buckets: List[Optional[Trie]] = [None] * (len(words) + 1)
+    top_k = []
+
+    for word in words:
+        frequency_map[word] += 1
+
+    for word, frequency in frequency_map.items():
+        if buckets[frequency] is None:
+            buckets[frequency] = Trie()
+        buckets[frequency].insert(word)
+
+    for i in range(len(buckets) - 1, -1, -1):
+        if buckets[i] is not None:
+            retrieve_words = buckets[i].get_all_words()
+            if len(retrieve_words) < k:
+                top_k.extend(retrieve_words)
+                k -= len(retrieve_words)
+            else:
+                top_k.extend(retrieve_words[:k])
+                break
+    return top_k
+
+
+def top_k_frequent_words_2(words: List[str], k: int) -> List[str]:
+    word_freq = Counter(sorted(words))
+
+    top_k = word_freq.most_common(k)
+
+    return [w for w, c in top_k]

algorithms/trie/topkfreqwords/test_top_k_frequent_words.py

@@ -0,0 +1,34 @@
+import unittest
+from typing import List
+
+from parameterized import parameterized
+
+from algorithms.trie.topkfreqwords import top_k_frequent_words_2, top_k_frequent_words
+
+TOP_K_FREQUENT_WORDS_TEST_CASES = [
+    (["i", "love", "leetcode", "i", "love", "coding"], 2, ["i", "love"]),
+    (
+        ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"],
+        4,
+        ["the", "is", "sunny", "day"],
+    ),
+    (["i", "love", "leetcode", "i", "love", "coding"], 3, ["i", "love", "coding"]),
+]
+
+
+class TopKFrequentWordsTestCase(unittest.TestCase):
+    @parameterized.expand(TOP_K_FREQUENT_WORDS_TEST_CASES)
+    def test_top_k_frequent_words(self, words: List[str], k: int, expected: List[str]):
+        actual = top_k_frequent_words(words, k)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(TOP_K_FREQUENT_WORDS_TEST_CASES)
+    def test_top_k_frequent_words_2(
+        self, words: List[str], k: int, expected: List[str]
+    ):
+        actual = top_k_frequent_words_2(words, k)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()

datastructures/linked_lists/singly_linked_list/README.md

@@ -855,7 +855,7 @@ We will first traverse the linked list and check which groups of k nodes can be
   the head.
 - We set a pointer, `ptr`, equal to the `dummy` node. We will use this pointer to traverse the linked list.
 - We traverse the linked list till `ptr` becomes NULL:
-  - We initialize a pointer, tracker, to ptr. This pointer will be used to keep track of the number of nodes in the
+  - We initialize a pointer, `tracker`, to `ptr`. This pointer will be used to keep track of the number of nodes in the
     current group in the linked list.
   - We use a nested loop to try to move `tracker` _k_ nodes forward in the linked list. If tracker becomes NULL before
     moving _k_ nodes forward, the end of the linked list has been reached and the current group can not be traversed,

datastructures/lists/missing_array/README.md

@@ -1,3 +1,5 @@
+# Missing Array
+
 You get an array of arrays. If you sort the arrays by their length, you will see, that their length-values are
 consecutive. But one array is missing!