solve problem Minimum Path Sum

Author: P-ppc

README.md

@@ -242,6 +242,7 @@ All solutions will be accepted!
 |328|[Odd Even Linked List](https://leetcode-cn.com/problems/odd-even-linked-list/description/)|[java/py/js](./algorithms/OddEvenLinkedList)|Medium|
 |677|[Map Sum Pairs](https://leetcode-cn.com/problems/map-sum-pairs/description/)|[java/py/js](./algorithms/MapSumPairs)|Medium|
 |442|[Find All Duplicates In An Array](https://leetcode-cn.com/problems/find-all-duplicates-in-an-array/description/)|[java/py/js](./algorithms/FindAllDuplicatesInAnArray)|Medium|
+|64|[Minimum Path Sum](https://leetcode-cn.com/problems/minimum-path-sum/description/)|[java/py/js](./algorithms/MinimumPathSum)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/MinimumPathSum/README.md

@@ -0,0 +1,2 @@
+# Minimum Path Sum
+We can solve this problem by Dynamic Programming

algorithms/MinimumPathSum/Solution.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int minPathSum(int[][] grid) {
+        int rowLength = grid.length,
+            colLength = grid[0].length;
+        
+        int[][] dp = new int[rowLength][colLength];
+        
+        for (int i = 0; i < rowLength; i++) {
+            for (int j = 0; j < colLength; j++) {
+                if (i == 0 && j == 0) dp[i][j] = grid[i][j];
+                else if (i == 0 && j > 0) dp[i][j] = grid[i][j] + dp[i][j - 1];
+                else if (i > 0 && j == 0) dp[i][j] = grid[i][j] + dp[i - 1][j];
+                else dp[i][j] = grid[i][j] + Math.min(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+
+        return dp[rowLength - 1][colLength - 1];
+    }
+}

algorithms/MinimumPathSum/solution.js

@@ -0,0 +1,21 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minPathSum = function(grid) {
+    let rowCount = grid.length,
+        colCount = grid[0].length
+    let dp = []
+    
+    for (let i = 0; i < rowCount; i++) {
+        dp.push(new Array(colCount))
+        for (let j = 0; j < colCount; j++) {
+            if (i === 0 && j === 0) dp[i][j] = grid[i][j]
+            else if (i === 0 && j > 0) dp[i][j] = grid[i][j] + dp[i][j - 1]
+            else if (i > 0 && j === 0) dp[i][j] = grid[i][j] + dp[i - 1][j]
+            else dp[i][j] = grid[i][j] + Math.min(dp[i - 1][j], dp[i][j - 1])
+        }
+    }
+    
+    return dp[rowCount - 1][colCount - 1]
+};

algorithms/MinimumPathSum/solution.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def minPathSum(self, grid):
+        """
+        :type grid: List[List[int]]
+        :rtype: int
+        """
+        row_count = len(grid)
+        col_count = len(grid[0])
+        
+        dp = [[0] * col_count] * row_count
+        
+        for i in xrange(row_count):
+            for j in xrange(col_count):
+                if i > 0 and j > 0:
+                    dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1])
+                elif i == 0 and j > 0:
+                    dp[i][j] = grid[i][j] + dp[i][j - 1]
+                elif i > 0 and j == 0:
+                    dp[i][j] = grid[i][j] + dp[i - 1][j]
+                else:
+                    dp[i][j] = grid[i][j]
+                    
+        return dp[row_count - 1][col_count - 1]