LeetCode 热题 100_最小路径和（92_64_中等_C++）（多维动态规划）

LeetCode 热题 100_最小路径和（92_64）

题目描述：

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

**说明：**每次只能向下或者向右移动一步。

输入输出样例：

示例 1：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

示例 2：
输入：grid = [[1,2,3],[4,5,6]]
输出：12

提示：

m== grid.length

n == grid[i].length

1 <= m, n <= 200

0 <= grid[i][j] <= 200

题解：

解题思路：

思路一（多维动态规划）：

1、题目要求每次只能向下或者向右移动一步。则一个位置的元素可由左方和上方的位置移动而来。

dp[ i ][ j ]为路径上的数字总和最小。
dp[ i ][ j ] = min(dp[ i-1 ][ j ],dp[ i ][ j-1 ])+grid[ i ][ j ]。
dp[ 0 ][ 0 ] = grid[ 0 ][ 0 ]。
dp[ 0 ][ j ] = dp[ 0 ][ j-1 ]+grid[ 0 ][ j ]。第一行的元素只能由左侧元素移动得来。
dp[ i ][ 0 ] = dp[ i-1 ][ 0 ]+grid[ 0 ][ j ]。第一列的元素只能由上侧元素移动得来。

2、复杂度分析：

① 时间复杂度：O(mn)，其中 m 和 n 分别是网格的行数和列数。需要对整个网格遍历一次，计算 dp 的每个元素的值。

② 空间复杂度：O(mn)，其中 m 和 n 分别是网格的行数和列数。创建一个二维数组 dp，和网格大小相同(也可使用一维dp数组：参考LeetCode 热题 100_不同路径（91_62_中等_C++）)。

代码实现

代码实现（思路一（多维动态规划））：

cpp 复制代码

class Solution {
public:
    // 计算从左上角到右下角的最小路径和
    int minPathSum(vector<vector<int>>& grid) {
        // 创建一个dp数组，用于存储从起点到达每个格子的最小路径和
        vector<vector<int>> dp(grid.size(), vector<int>(grid[0].size()));

        // 初始化dp数组的起始位置，起点的路径和就是grid[0][0]的值
        dp[0][0] = grid[0][0];

        // 处理第一行，从左到右累加
        // 因为只能从左边的格子走到当前格子，所以每一行的第一个格子的路径和是累加的
        for (int j = 1; j < grid[0].size(); j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }

        // 处理第一列，从上到下累加
        // 因为只能从上方的格子走到当前格子，所以每一列的第一个格子的路径和是累加的
        for (int i = 1; i < grid.size(); i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }

        // 从(1, 1)开始，遍历整个grid
        // 每个格子的最小路径和是从它的上方格子或者左方格子中选择较小的路径和，再加上当前格子的值
        for (int i = 1; i < grid.size(); i++) {
            for (int j = 1; j < grid[0].size(); j++) {
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }

        // 返回右下角的最小路径和，即dp数组的右下角元素
        return dp[grid.size() - 1][grid[0].size() - 1];
    }
};

以思路一为例进行调试

cpp 复制代码

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

class Solution {
public:
    // 计算从左上角到右下角的最小路径和
    int minPathSum(vector<vector<int>>& grid) {
        // 创建一个dp数组，用于存储从起点到达每个格子的最小路径和
        vector<vector<int>> dp(grid.size(), vector<int>(grid[0].size()));

        // 初始化dp数组的起始位置，起点的路径和就是grid[0][0]的值
        dp[0][0] = grid[0][0];

        // 处理第一行，从左到右累加
        // 因为只能从左边的格子走到当前格子，所以每一行的第一个格子的路径和是累加的
        for (int j = 1; j < grid[0].size(); j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }

        // 处理第一列，从上到下累加
        // 因为只能从上方的格子走到当前格子，所以每一列的第一个格子的路径和是累加的
        for (int i = 1; i < grid.size(); i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }

        // 从(1, 1)开始，遍历整个grid
        // 每个格子的最小路径和是从它的上方格子或者左方格子中选择较小的路径和，再加上当前格子的值
        for (int i = 1; i < grid.size(); i++) {
            for (int j = 1; j < grid[0].size(); j++) {
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }

        // 返回右下角的最小路径和，即dp数组的右下角元素
        return dp[grid.size() - 1][grid[0].size() - 1];
    }
};




int main(int argc, char const *argv[])
{
    vector<vector<int>> grid={{1,3,1},{1,5,1},{4,2,1}};

    Solution s;
    cout<<s.minPathSum(grid);
    return 0;
}

LeetCode 热题 100_最小路径和（92_64)原题链接

欢迎大家和我沟通交流(✿◠‿◠)