feat: add solutions to lc problem: No.0064. Minimum Path Sum

Author: yanglbme

README.md

@@ -191,8 +191,8 @@
 - [二维区域和检索 - 矩阵不可变](./solution/0300-0399/0304.Range%20Sum%20Query%202D%20-%20Immutable/README.md)
 - [不同路径](./solution/0000-0099/0062.Unique%20Paths/README.md)
 - [不同路径 II](./solution/0000-0099/0063.Unique%20Paths%20II/README.md)
-- [礼物的最大价值](./lcof/面试题47.%20礼物的最大价值/README.md)
 - [最小路径和](./solution/0000-0099/0064.Minimum%20Path%20Sum/README.md)
+- [礼物的最大价值](./lcof/面试题47.%20礼物的最大价值/README.md)
 - [最长上升子序列](./solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README.md)
 - [俄罗斯套娃信封问题](./solution/0300-0399/0354.Russian%20Doll%20Envelopes/README.md)
 - [最长公共子序列](./solution/1100-1199/1143.Longest%20Common%20Subsequence/README.md)

solution/0000-0099/0064.Minimum Path Sum/README.md

@@ -42,7 +42,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-动态规划法。
+动态规划。假设 `dp[i][j]` 表示到达网格 `(i,j)` 的最小数字和，先初始化 dp 第一列和第一行的所有值，然后利用递推公式：`dp[i][j] = min(dp[i -1][j], dp[i][j - 1]) + grid[i][j]` 求得 dp。
+
+最后返回 `dp[m - 1][n - 1]` 即可。
 
 <!-- tabs:start -->
 
@@ -61,8 +63,8 @@ class Solution:
             dp[0][j] = dp[0][j - 1] + grid[0][j]
         for i in range(1, m):
             for j in range(1, n):
-                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
-        return dp[m - 1][n - 1]
+                dp[i][j] = min(dp[i -1][j], dp[i][j - 1]) + grid[i][j]
+        return dp[-1][-1]
 ```
 
 ### **Java**
@@ -115,6 +117,38 @@ public:
 };
 ```
 
+### **Go**
+
+```go
+func minPathSum(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	dp := make([][]int, m)
+	for i := 0; i < m; i++ {
+		dp[i] = make([]int, n)
+	}
+	dp[0][0] = grid[0][0]
+	for i := 1; i < m; i++ {
+		dp[i][0] = dp[i-1][0] + grid[i][0]
+	}
+	for j := 1; j < n; j++ {
+		dp[0][j] = dp[0][j-1] + grid[0][j]
+	}
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
+		}
+	}
+	return dp[m-1][n-1]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0064.Minimum Path Sum/README_EN.md

@@ -36,6 +36,8 @@
 
 ## Solutions
 
+Dynamic programming.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -51,8 +53,8 @@ class Solution:
             dp[0][j] = dp[0][j - 1] + grid[0][j]
         for i in range(1, m):
             for j in range(1, n):
-                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
-        return dp[m - 1][n - 1]
+                dp[i][j] = min(dp[i -1][j], dp[i][j - 1]) + grid[i][j]
+        return dp[-1][-1]
 ```
 
 ### **Java**
@@ -103,6 +105,38 @@ public:
 };
 ```
 
+### **Go**
+
+```go
+func minPathSum(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	dp := make([][]int, m)
+	for i := 0; i < m; i++ {
+		dp[i] = make([]int, n)
+	}
+	dp[0][0] = grid[0][0]
+	for i := 1; i < m; i++ {
+		dp[i][0] = dp[i-1][0] + grid[i][0]
+	}
+	for j := 1; j < n; j++ {
+		dp[0][j] = dp[0][j-1] + grid[0][j]
+	}
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
+		}
+	}
+	return dp[m-1][n-1]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0064.Minimum Path Sum/Solution.go

@@ -1,36 +1,27 @@
-
 func minPathSum(grid [][]int) int {
-	yl := len(grid)
-	if yl == 0 {
-		return 0
-	}
-	xl := len(grid[0])
-	if xl == 0 {
-		return 0
-	}
-	// malloc
-	dp := make([][]int, yl)
-	for i, _ := range dp {
-		dp[i] = make([]int, xl)
+	m, n := len(grid), len(grid[0])
+	dp := make([][]int, m)
+	for i := 0; i < m; i++ {
+		dp[i] = make([]int, n)
 	}
 	dp[0][0] = grid[0][0]
-	for i := 1; i < yl; i++ {
-		dp[i][0] = grid[i][0] + dp[i-1][0]
+	for i := 1; i < m; i++ {
+		dp[i][0] = dp[i-1][0] + grid[i][0]
 	}
-	for j := 1; j < xl; j++ {
-		dp[0][j] = grid[0][j] + dp[0][j-1]
+	for j := 1; j < n; j++ {
+		dp[0][j] = dp[0][j-1] + grid[0][j]
 	}
-	for i := 1; i < yl; i++ {
-		for j := 1; j < xl; j++ {
-			dp[i][j] = grid[i][j] + minInt(dp[i-1][j], dp[i][j-1])
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
 		}
 	}
-	return dp[yl-1][xl-1]
+	return dp[m-1][n-1]
 }
 
-func minInt(x, y int) int {
-	if x < y {
-		return x
+func min(a, b int) int {
+	if a < b {
+		return a
 	}
-	return y
-} 
+	return b
+}

solution/0000-0099/0064.Minimum Path Sum/Solution.py

@@ -8,5 +8,5 @@ def minPathSum(self, grid: List[List[int]]) -> int:
             dp[0][j] = dp[0][j - 1] + grid[0][j]
         for i in range(1, m):
             for j in range(1, n):
-                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
-        return dp[m - 1][n - 1]
+                dp[i][j] = min(dp[i -1][j], dp[i][j - 1]) + grid[i][j]
+        return dp[-1][-1]