Leetcode：Question64

题目描述

这是一道简单的动态规划问题。找最短的和，相当于动态规划求最短路径。因此采用递归很容易实现。

#include <iostream>
#include <climits>
#include <vector>
using namespace std;

typedef pair<int, int> point;
class Solution {
public:

    int minPathSum(vector<vector<int> >& grid) {
    	return findmin(make_pair(0, 0), make_pair(grid.size()-1, grid[0].size()-1), grid);
        
    }

    int findmin(point curr, point dest, vector<vector<int> >& grid) {
    	if (curr.first == dest.first && curr.second == dest.second) {
    		return grid[dest.first][dest.second];
    	}
    	else {
    		int right;
    		int bottom;
    		if (curr.first + 1 < grid.size()) {
				right = grid[curr.first][curr.second] + findmin(make_pair(curr.first + 1, curr.second), dest, grid);
    		}
    		else {
    			right = INT_MAX;
    		}
    		if (curr.second + 1 < grid[0].size()) {
				bottom = grid[curr.first][curr.second] + findmin(make_pair(curr.first, curr.second + 1), dest, grid);
    		}
    		else {
    			bottom = INT_MAX;
    		}
    		
    		if (right > bottom) {
    			return bottom;
    		}
    		else {
    			return right;
    		}
    	}

    }

    
};

这里使用了pair来表示grid上面的点，通过从左上角往右下角逐步递归寻找，当到达最右下角的点时，递归结束。

相同的思想采用循环来编写

class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
    	int m = grid.size();
    	int n = grid[0].size();
 
    	int paths[m][n];
 
    	paths[0][0] = grid[0][0];
 
    	for(int i = 1; i < m; ++i)
    	{
    		paths[i][0] = paths[i - 1][0] + grid[i][0];
    	}
    	
    	for(int j = 1; j < n; ++j)
    	{
    		paths[0][j] = paths[0][j - 1] + grid[0][j];
    	}
 
    	for(int i = 1; i < m; ++i)
    		for(int j = 1; j < n; ++j)
    		{
    			paths[i][j] = std::min(paths[i - 1][j], paths[i][j - 1])
    						+ grid[i][j];
    		}
 
    	return paths[m - 1][n - 1];
    }
};