Add files via upload

Author: JanaSabuj

64/main.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int minPathSum(vector<vector<int>>& grid) {
+        int n = grid.size();
+        int m = grid[0].size();
+
+        // dp grid f
+        vector<vector<int>> f(n, vector<int>(m, 0));
+        f[0][0] = grid[0][0];
+        for (int j = 1; j < m; j++)
+            f[0][j] = f[0][j - 1] + grid[0][j];
+        for (int i = 1; i < n; i++)
+            f[i][0] = f[i - 1][0] + grid[i][0];
+
+        // work
+        // f[i][j] = min cost to reach cell(i,j) from 0,0
+        for (int i = 1; i < n; i++) {
+            for (int j = 1; j < m; j++) {
+                f[i][j] = min(f[i - 1][j], f[i][j - 1]) + grid[i][j];
+            }
+        }
+
+        return f[n - 1][m - 1];
+
+    }
+};

64/main.java

@@ -0,0 +1,22 @@
+class Solution {
+    public int minPathSum(int[][] grid) {
+        int n = grid.length;
+        int m = grid[0].length;
+
+        int[][] f = new int[n][m];
+        f[0][0] = grid[0][0];
+        for (int j = 1; j < m; j++)
+            f[0][j] = f[0][j - 1] + grid[0][j];
+        for (int i = 1; i < n; i++)
+            f[i][0] = f[i - 1][0] + grid[i][0];
+
+        for (int i = 1; i < n; i++) {
+            for (int j = 1; j < m; j++) {
+                f[i][j] = Math.min(f[i - 1][j], f[i][j - 1]) + grid[i][j];
+            }
+        }
+
+        return f[n - 1][m - 1];
+
+    }
+}

64/main.py

@@ -0,0 +1,17 @@
+class Solution:
+    def minPathSum(self, grid: List[List[int]]) -> int:
+        n = len(grid)
+        m = len(grid[0])
+        f = [[None for _ in range(m)] for _ in range(n)]
+
+        f[0][0] = grid[0][0]
+        for j in range(1, m):
+            f[0][j] = f[0][j-1] + grid[0][j]
+        for i in range(1, n):
+            f[i][0] = f[i - 1][0] + grid[i][0]
+
+        for i in range(1, n):
+            for j in range(1, m):
+                f[i][j] = min(f[i - 1][j] , f[i][j - 1]) + grid[i][j]
+
+        return f[n - 1][m - 1]

746/main.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int minCostClimbingStairs(vector<int>& cost) {
+        int n = cost.size();
+        vector<int> f(n + 1);
+        f[0] = 0;
+        f[1] = 0;
+
+        for (int i = 2; i <= n; i++) {
+            f[i] = min(f[i - 1] + cost[i - 1], f[i - 2] + cost[i - 2]);
+        }
+
+        return f[n];
+    }
+};

746/main.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int minCostClimbingStairs(int[] cost) {
+        int n = cost.length;
+        int f[] = new int[n + 1];
+        f[0] = 0;
+        f[1] = 0;
+
+        for (int i = 2; i <= n; i++) {
+            f[i] = Math.min(f[i - 1] + cost[i - 1], f[i - 2] + cost[i - 2]);
+        }
+
+        return f[n];
+    }
+}

746/main.py

@@ -0,0 +1,14 @@
+class Solution:
+    def minCostClimbingStairs(self, cost: List[int]) -> int:
+        n = len(cost)
+        f = [None] * (n + 1)
+        
+        f[0] = 0
+        f[1] = 0
+        
+        for i in range(2, n + 1):
+            f[i] = min(f[i - 1] + cost[i - 1], f[i - 2] + cost[i - 2])
+        return f[n]
+        
+        
+        

931/main.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int minFallingPathSum(vector<vector<int>>& A) {
+        int n = A.size();
+        int m = A[0].size();
+
+        vector<vector<int>> f(n, vector<int>(m, 0));
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (i == 0)
+                    f[i][j] = A[i][j];
+                else {
+                    int val = f[i - 1][j];
+                    for (int k = j - 1; k <= j + 1; k++)
+                        if (k >= 0 and k < m)
+                            val = min(val, f[i - 1][k]);
+
+                    f[i][j] = val + A[i][j];
+                }
+            }
+        }
+
+        int ans = INT_MAX;
+        for (int j = 0; j < m; j++)
+            ans = min(ans, f[n - 1][j]);
+
+        return ans;
+    }
+};

931/main.java

@@ -0,0 +1,30 @@
+class Solution {
+	public int minFallingPathSum(int[][] A) {
+		int n = A.length;
+		int m = A[0].length;
+
+		// vector<vector<int>> f(n, vector<int>(m, 0));
+		int[][] f = new int[n][m];
+
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				if (i == 0)
+					f[i][j] = A[i][j];
+				else {
+					int val = f[i - 1][j];
+					for (int k = j - 1; k <= j + 1; k++)
+						if (k >= 0 && k < m)
+							val = Math.min(val, f[i - 1][k]);
+
+					f[i][j] = val + A[i][j];
+				}
+			}
+		}
+
+		int ans = Integer.MAX_VALUE;
+		for (int j = 0; j < m; j++)
+			ans = Math.min(ans, f[n - 1][j]);
+
+		return ans;
+	}
+}

931/main.py

@@ -0,0 +1,22 @@
+class Solution:
+    def minFallingPathSum(self, A: List[List[int]]) -> int:
+        n = len(A)
+        m = len(A[0])
+
+        f = [[None for _ in range(m)] for _ in range(n)]
+
+        for i in range(n):
+            for j in range(m):
+                if i == 0:
+                    f[i][j] = A[i][j]
+                else:
+                    val = f[i-1][j]
+                    for k in [j-1,j,j+1]:
+                        if k >= 0 and k < m:
+                            val = min(val, f[i-1][k])
+                    f[i][j] = val + A[i][j]
+
+        ans = float('inf')
+        for j in range(m):
+            ans = min(ans, f[n-1][j])
+        return ans