unique path

src/solutions/dp/minimum_path_sum.rs

@@ -0,0 +1,40 @@
+struct Solution;
+
+impl Solution {
+    pub fn min_path_sum(grid: Vec<Vec<i32>>) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut dp = vec![0; n];
+
+        dp[0] = grid[0][0];
+        for j in 1..n {
+            dp[j] = grid[0][j] + dp[j - 1];
+        }
+
+        for i in 1..m {
+            for j in 0..n {
+                if j == 0 {
+                    dp[0] += grid[i][0];
+                } else {
+                    dp[j] = dp[j - 1].min(dp[j]) + grid[i][j];
+                }
+            }
+        }
+
+        dp[n - 1]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn test_case_1() {
+        let grid = vec![vec![1, 3, 1], vec![1, 5, 1], vec![4, 2, 1]];
+
+        let res = Solution::min_path_sum(grid);
+        assert_eq!(res, 7);
+    }
+}

src/solutions/dp/mod.rs

@@ -2,4 +2,7 @@ mod best_time_to_buy_and_sell_stock;
 mod jump_game_2;
 mod longest_valid_parentheses;
 mod maximum_subarray;
+mod minimum_path_sum;
 mod trapping_train_water;
+mod unique_paths;
+mod unique_paths_2;

src/solutions/dp/unique_paths.rs

@@ -0,0 +1,29 @@
+struct Solution;
+
+impl Solution {
+    pub fn unique_paths(m: i32, n: i32) -> i32 {
+        let n = n as usize;
+        let m = m as usize;
+        let mut dp = vec![1; n];
+        for _ in 1..m {
+            for j in 1..n {
+                dp[j] += dp[j - 1];
+            }
+        }
+
+        dp[n - 1]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_case1() {
+        let m = 3;
+        let n = 7;
+        let res = Solution::unique_paths(m, n);
+        assert_eq!(res, 28);
+    }
+}

src/solutions/dp/unique_paths_2.rs

@@ -0,0 +1,46 @@
+struct Solution;
+
+impl Solution {
+    pub fn unique_paths_with_obstacles(obstacle_grid: Vec<Vec<i32>>) -> i32 {
+        let m = obstacle_grid.len();
+        let n = obstacle_grid[0].len();
+
+        let mut dp = vec![1; n];
+        for i in 0..n {
+            if obstacle_grid[0][i] == 1 {
+                dp[i] = 0;
+            } else if i == 0 {
+                dp[i] = 1;
+            } else {
+                dp[i] = dp[i - 1];
+            }
+        }
+
+        for i in 1..m {
+            for j in 0..n {
+                if obstacle_grid[i][j] == 1 {
+                    dp[j] = 0;
+                } else if j == 0 {
+                    continue;
+                } else {
+                    dp[j] += dp[j - 1];
+                }
+            }
+        }
+
+        dp[n - 1]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn test_case_1() {
+        let obstacle_grid = vec![vec![0, 0, 0], vec![1, 1, 0], vec![0, 0, 0]];
+        let res = Solution::unique_paths_with_obstacles(obstacle_grid);
+        assert_eq!(res, 1);
+    }
+}