64 Minimum Path Sum

Author: int32bit

README.md

@@ -24,6 +24,7 @@
 + [50 Pow(x, n)(二分，浮点数比较，INT\_MIN绝对值)](algorithms/Pow)
 + [58 Length of Last Word](algorithms/LengthofLastWord)
 + [60 Permutation Sequence(康托展开)](algorithms/PermutationSequence)
++ [64 Minimum Path Sum(DP,空间压缩)](algorithms/MinimumPathSum)
 + [65 Valid Number(细节题,状态机)](algorithms/ValidNumber)
 + [67 Add Binary](algorithms/AddBinary)
 + [72 Edit Distance(DP)](algorithms/EditDistance)

algorithms/MinimumPathSum/README.md

@@ -0,0 +1,52 @@
+## Minimum Path Sum
+
+Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.
+
+**Note: You can only move either down or right at any point in time.**
+
+## Solution
+
+最开始想到用BFS，这思维！
+
+显然这是最最经典直接的DP问题。
+
+设`dp[i][j]`表示`a[0][0]`到`a[i][j]`的最小路径, 则显然有动态方程`dp[i][j] = MIN(dp[i - 1][j], dp[i][j - 1])`,
+```cpp
+int minPathSum(vector<vector<int>> &grid) {
+	if (grid.size() < 1)
+		return 0;
+	int n = grid.size();
+	int m = grid[0].size();
+	vector<vector<int>> dp(n, vector<int>(m, 0));
+	dp[0][0] = grid[0][0];
+	for (int i = 1; i < n; ++i)
+		dp[i][0] = dp[i - 1][0] + grid[i][0];
+	for (int j = 1; j < m; ++j)
+		dp[0][j] = dp[0][j - 1] + grid[0][j];
+	for (int i = 1; i < n; ++i)
+		for (int j = 1; j < m; ++j)
+			dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+	return dp[n - 1][m - 1];
+}
+```
+
+时间和空间复杂度都是O(nm)。时间复杂度没有什么优化方案，当空间可以采用压缩的方法,显然`dp[i][j]`只依赖于左边和上边一个值,即`dp[i - 1][j]`和`dp[i][j - 1]`,
+而与前面的值无关。所以处理第i行j列时，与i-1行的该j列有关，以及i行j-1列有关，我们只需要声明dp[i], dp表示第i行j列的值,旧值dp[i]相当于`dp[i][j - 1]`,
+ `dp[i - 1]`相当于`dp[i - 1][j]`,于是`dp[i] = MIN (dp[i], dp[i - 1]`
+```cpp
+int minPathSum(vector<vector<int>> &grid) {
+	if (grid.size() < 1)
+		return 0;
+	int n = grid.size();
+	int m = grid[0].size();
+	vector<int> dp(n, 0);
+	dp[0] = grid[0][0];
+	for (int i = 1; i < n; ++i)
+		dp[i] = dp[i - 1] + grid[i][0];
+	for (int i = 1; i < n; ++i)
+		for (int j = 1; j < n; ++j) {
+			dp[j] = min(dp[j], dp[j - 1]) + grid[i][j];
+		}
+	return dp[n - 1];
+}
+```

algorithms/MinimumPathSum/in.txt

@@ -0,0 +1,24 @@
+3 3
+1 2 0
+0 5 1
+3 6 0
+19 10
+1 7 4 3 2 2 2 9 2 6
+3 6 6 1 0 5 9 6 3 8
+1 5 4 5 3 8 7 2 5 6
+5 7 6 9 0 8 1 4 7 5
+0 2 1 9 5 3 6 5 9 9
+5 3 6 1 8 9 0 7 4 7
+6 9 4 2 0 6 0 3 2 9
+8 3 3 1 2 9 5 8 6 6
+9 1 9 5 4 7 6 4 5 0
+4 1 1 8 5 1 7 5 4 9
+6 4 4 9 8 8 8 5 8 4
+1 7 7 3 2 4 0 9 8 7
+1 4 0 3 5 5 4 2 2 1
+3 0 5 8 0 3 6 0 0 5
+7 2 4 6 5 7 0 7 8 1
+7 9 5 7 4 0 5 1 4 9
+2 8 0 9 8 2 5 6 2 5
+3 9 9 8 6 4 7 8 4 5
+9 1 6 5 0 3 5 5 4 0

algorithms/MinimumPathSum/solve.cpp

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+class Solution {
+	public:
+		int minPathSum(vector<vector<int>> &grid) {
+			return minPathSum1(grid);
+		}
+	private:
+		int minPathSum1(vector<vector<int>> &grid) {
+			if (grid.size() < 1)
+				return 0;
+			int n = grid.size();
+			int m = grid[0].size();
+			vector<vector<int>> dp(n, vector<int>(m, 0));
+			dp[0][0] = grid[0][0];
+			for (int i = 1; i < n; ++i)
+				dp[i][0] = dp[i - 1][0] + grid[i][0];
+			for (int j = 1; j < m; ++j)
+				dp[0][j] = dp[0][j - 1] + grid[0][j];
+			for (int i = 1; i < n; ++i)
+				for (int j = 1; j < m; ++j)
+					dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+			return dp[n - 1][m - 1];
+		}
+		int minPathSum2(vector<vector<int>> &grid) {
+			if (grid.size() < 1)
+				return 0;
+			int n = grid.size();
+			int m = grid[0].size();
+			vector<int> dp(n, 0);
+			dp[0] = grid[0][0];
+			for (int i = 1; i < n; ++i)
+				dp[i] = dp[i - 1] + grid[i][0];
+			for (int i = 1; i < n; ++i)
+				for (int j = 1; j < n; ++j) {
+					dp[j] = min(dp[j], dp[j - 1]) + grid[i][j];
+				}
+			return dp[n - 1];
+		}
+};
+int main(int argc, char **argv)
+{
+	Solution solution;
+	int n, m;
+	while (scanf("%d%d", &n, &m) != EOF) {
+		vector<vector<int>> v(n, vector<int>(m, 0));
+		for (int i = 0; i < n; ++i)
+			for (int j = 0; j < m; ++j) {
+				cin >> v[i][j];
+			}
+		cout << solution.minPathSum(v) << endl;
+	}
+	return 0;
+}