feat: added [algo-04] (#13)

* feat: added c++ solution

* feat: added go solution

* feat: added python solution

* feat: added rust solution

* feat: added ts solution

* fix: linting

Author: protiumx

PROBLEMS.md

@@ -46,7 +46,7 @@ NOTE: it can also be solved by traversing the tree in-order.
 **Auxiliary space:** `O(1)` -> The extra space is constant
 
 
-## `[algo-03]` Longest Substring Without Repeating Characters
+## `[algo-03]` Longest Substring Without Repeating Characters `[medium]`
 
 Problem description can be found at [leetcode](https://leetcode.com/problems/longest-substring-without-repeating-characters/)
 
@@ -64,3 +64,22 @@ E.g.
 
 **Time Complexity:** `O(n)` -> We iterate the whole string
 **Auxiliary space:** `O(1)` -> The extra space is the number of characters in `[a-z]`
+
+## `[algo-04]` Minimim Path Sum `[medium]`
+
+Problem description can be found at [leetcode](https://leetcode.com/problems/minimum-path-sum/)
+
+### Solution
+
+This is a weighted vertice graph problem. A solution doing DFS would be valid but the runtime would be O(2^(n+m)).
+When calculating a `minPath` on a node, we know that: `minCost[i][j] = matrix[i][j] + min(minCost[i-1][j], minCost[i][j-1])`.
+So, for each node, the minPath at that point is the minimum between the path until the node on the top and the path until the node to the left.
+With that in mind, we can **pre-fill** our matrix of costs on the first row and first column.
+Steps:
+- Pre-fill first column and row
+- Iterate over the matrix and fill the rest of cells knowing that `minCost[i][j] = matrix[i][j] + min(minCost[i-1][j], minCost[i][j-1])`.
+
+**Time Complexity:** `O(m * n)` -> We visit all the cells in the matrix
+**Auxiliary space:** `O(m * n)` -> We store the cost of all the cells
+
+

packages/algo-cpp/solutions/algo_04.cpp

@@ -0,0 +1,31 @@
+#include <gtest/gtest.h>
+#include <vector>
+
+using namespace std;
+
+int min_path_sum(vector<vector<int>> &grid) {
+  const int m = grid.size();
+  const int n = grid[0].size();
+  vector<vector<int>> costs(m, vector<int>(n, 0));
+
+  costs[0][0] = grid[0][0];
+
+  for (int i = 1; i < m; i++) {
+    costs[i][0] = grid[i][0] + costs[i - 1][0];
+  }
+  for (int i = 1; i < n; i++) {
+    costs[0][i] = grid[0][i] + costs[0][i - 1];
+  }
+
+  for (int i = 1; i < m; i++) {
+    for (int j = 1; j < n; j++) {
+      costs[i][j] = grid[i][j] + min(costs[i - 1][j], costs[i][j - 1]);
+    }
+  }
+  return costs[m - 1][n - 1];
+}
+
+TEST(MinPathSum, Test) {
+  vector<vector<int>> input = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
+  ASSERT_EQ(min_path_sum(input), 7);
+}

packages/algo-go/solutions/algo-04.go

@@ -0,0 +1,30 @@
+package solutions
+
+func MinPathSum(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	costs := make([][]int, m)
+	for i := range costs {
+		costs[i] = make([]int, n)
+	}
+	costs[0][0] = grid[0][0]
+
+	for i := 1; i < m; i++ {
+		costs[i][0] = grid[i][0] + costs[i-1][0]
+	}
+	for i := 1; i < n; i++ {
+		costs[0][i] = grid[0][i] + costs[0][i-1]
+	}
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			costs[i][j] = grid[i][j] + min(costs[i-1][j], costs[i][j-1])
+		}
+	}
+	return costs[m-1][n-1]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

packages/algo-go/solutions/algo-04_test.go

@@ -0,0 +1,15 @@
+package solutions
+
+import "testing"
+
+func TestMinPathSum(t *testing.T) {
+	input := [][]int{
+		{1, 3, 1},
+		{1, 5, 1},
+		{4, 2, 1},
+	}
+
+	if MinPathSum(input) != 7 {
+		t.Error("Failed")
+	}
+}

packages/algo-py/solutions/__init__.py

@@ -2,3 +2,4 @@
 from .algo_01 import *
 from .algo_02 import *
 from .algo_03 import *
+from .algo_04 import *

packages/algo-py/solutions/algo_04.py

@@ -0,0 +1,14 @@
+def min_path_sum(grid):
+    m = len(grid)
+    n = len(grid[0])
+    costs = [[0 for _ in range(n)] for _ in range(m)]
+    costs[0][0] = grid[0][0]
+    for i in range(1, m):
+        costs[i][0] = grid[i][0] + costs[i-1][0]
+    for j in range(1, n):      
+        costs[0][j] = grid[0][j] + costs[0][j-1]
+    for i in range(1, m):
+        for j in range(1, n):
+            costs[i][j] = grid[i][j] + min(costs[i-1][j], costs[i][j-1])
+
+    return costs[m-1][n-1]

packages/algo-py/solutions/algo_04_test.py

@@ -0,0 +1,16 @@
+import unittest
+from solutions import min_path_sum
+
+
+class TestAlgo_04(unittest.TestCase):
+    def test(self):
+        input = [
+                [1,3,1],
+                [1,5,1],
+                [4,2,1],
+                ]
+        self.assertEqual(min_path_sum(input), 7)
+
+
+if __name__ == '__main__':
+    unittest.main()

packages/algo-rust/src/algo_03.rs

@@ -1,17 +1,17 @@
 use std::cmp;
 
 fn max_substr(input: String) -> i32 {
-    let mut max = 0;
-    let mut start = 0;
-    let mut indexes = arr![-1; 127];
+    let mut max: i32 = 0;
+    let mut start: i32 = 0;
+    let mut indexes = vec![-1; 127];
     for (i, c) in input.chars().enumerate() {
-        if indexes[c] >= start {
-            start = indexes[c] + 1;
+        if indexes[c as usize] >= start {
+            start = indexes[c as usize] + 1;
         }
-        indexes[c] = i;
-        max = cmp::max(max, i - start + 1);
+        indexes[c as usize] = i as i32;
+        max = cmp::max(max, (i as i32) - start + 1);
     }
-    return max;
+    max
 }
 
 #[cfg(test)]
@@ -21,6 +21,6 @@ mod test {
     #[test]
     fn test() {
         let input = "abcbghjb";
-        assert_eq!(max_substr(input), 5);
+        assert_eq!(max_substr(input.to_string()), 5);
     }
 }

packages/algo-rust/src/algo_04.rs

@@ -0,0 +1,33 @@
+use std::cmp;
+
+fn min_path_sum(grid: Vec<Vec<i32>>) -> i32 {
+    let (m, n) = (grid.len(), grid[0].len());
+    let mut costs = vec![vec![0_i32; n]; m];
+    costs[0][0] = grid[0][0];
+
+    for i in 1..m {
+        costs[i][0] = grid[i][0] + costs[i - 1][0];
+    }
+    for j in 1..n {
+        costs[0][j] = grid[0][j] + costs[0][j - 1];
+    }
+
+    for i in 1..m {
+        for j in 1..n {
+            costs[i][j] = grid[i][j] + cmp::min(costs[i - 1][j], costs[i][j - 1]);
+        }
+    }
+
+    costs[m - 1][n - 1]
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test() {
+        let input = vec![vec![1, 3, 1], vec![1, 5, 1], vec![4, 2, 1]];
+        assert_eq!(min_path_sum(input), 7);
+    }
+}

packages/algo-rust/src/lib.rs

@@ -4,3 +4,5 @@
 mod algo_00;
 mod algo_01;
 mod algo_02;
+mod algo_03;
+mod algo_04;

packages/algo-ts/src/algo_04.ts

@@ -0,0 +1,20 @@
+export function MinPathSum(grid: number[][]): number {
+  const m = grid.length;
+  const n = grid[0].length;
+  const costs = Array.from(Array(m), () => new Array(n));
+
+  costs[0][0] = grid[0][0];
+  for (let i = 1; i < m; i++) {
+    costs[i][0] = grid[i][0] + costs[i - 1][0];
+  }
+  for (let j = 1; j < n; j++) {
+    costs[0][j] = grid[0][j] + costs[0][j - 1];
+  }
+  for (let i = 1; i < m; i++) {
+    for (let j = 1; j < n; j++) {
+      costs[i][j] = grid[i][j] + Math.min(costs[i - 1][j], costs[i][j - 1]);
+    }
+  }
+  return costs[m - 1][n - 1];
+}
+

packages/algo-ts/test/algo_04.spec.ts

@@ -0,0 +1,12 @@
+import {MinPathSum} from "$/algo_04";
+
+describe("algo-04", () => {
+  it("should find the minimum path", () => {
+    const input = [
+      [1, 3, 1],
+      [1, 5, 1],
+      [4, 2, 1],
+    ];
+    expect(MinPathSum(input)).toEqual((7))
+  });
+});