矩阵的最小路径和（leetcode 64）

1、题目描述

    给定一个 m x n 的矩阵，矩阵中的每个元素都为非负整数，找出一条从左上角到右下角的路径，使得这条路径上的元素和最小。矩阵中的路径只能往下或者往右移动。示例：

                 

   对于这个矩阵，最小的路径和为 7 .

2、解题思路

（1）暴力法：类似于二叉树的递归

    int minPathSum(vector<vector<int>>& grid) 
    {
        int sum = 0;
        int min = INT32_MAX;
        int rows = grid.size();
        int cols = grid[0].size();
        Find(grid, 0, rows, 0, cols, sum, min);
        return min;
    }
    
    void Find(vector<vector<int>>& grid, int row, int rows, int col, int cols, int& sum, int& min)
    {
        if (row == rows || col == cols)
        {            
            return;
        }
        else
        {
            sum += grid[row][col];
            if (row == rows - 1 && col == cols -1)
            {
                if (min > sum)
                {
                    min = sum;
                }
                sum -= grid[row][col];
                return;
            }
            else
            {
                Find(grid, row + 1, rows, col, cols, sum, min);
                Find(grid, row, rows, col + 1, cols, sum, min);
                sum -= grid[row][col];
                
            }
        }
    }

（2）动态规划算法

    由于矩阵中的路径只能向下或者向右，所以从左上角 [ 0 , 0 ] 点到任何一个点 [ i,  j ] 的最短路径等于 [ 0,  0 ]到 [ i - 1,  j ] 的最短路径和[ 0,  0 ] 到 [ i, j - 1 ]的最短路径中的最小值再加上[ i, j ] 的值，因为可以用一个矩阵来保存 [0, 0] 点到任何一个点 [i,  j] 的最短路径值，代码如下：

int MinPathSum(vector<vector<int>>& grid) 
{
    int m = grid.size();    // m代表行数
    int n = grid[0].size(); // n代表列数
    vector<vector<int>> path(m, vector<int>(n, 0));    
    path[0][0] = grid[0][0];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int val = grid[i][j];
            if (i == 0 && j == 0)
            {                
                continue;
            }
            else if (i == 0)
            {
                path[i][j] = path[i][j - 1] + val;
            }
            else if (j == 0)
            {
                path[i][j] = path[i - 1][j] + val;
            }
            else
            {
                path[i][j] = min(path[i - 1][j] + val, path[i][j - 1] + val);
            } 
        }
        
    }
    return path[m - 1][n - 1];
}