动态规划--背包问题,最小路径和,不同路径总数

背包问题笔记

描述：
编号 1 2 3 4
体积 2 3 4 5
价值 3 4 5 6
放入一个体积为8的背包，怎样使背包所装东西的价值最大
背包容量从0以1单位递增，当前背包容量下，两个问题考虑：放不放的下当前物品；放得下的话，放不放这个物品，放了的价值就是把这个物品所占容积减出来剩下物品实现的价值加上当前放进去物品的价值，不放的话就是之前已经放进去的物品的总价值
放个视频链接：背包问题讲解

在这里插入代码片include<iostream>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N];//体积是i的背包能装下的最大价值
f[0]=0;

int main()
{
    cin >> n >> m;
    for(int i = 1;i <= n;i ++) cin >> v[i]>> w[i];
    for(int i = 0;i <= m;i ++)
    {
       for(int j = 1; j <= n; j ++)
       {
           if(i < v[j]) continue;
           f[i] = max(f[i], f[i - v[j]] + w[j]);
       }
    }
    cout<<f[m]<<endl;
}

最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。
来源：力扣（LeetCode）
链接：最小路径和
创建二维数组dp，与原始网格的大小相同，dp[i][j] 表示从左上角出发到 (i,j)(i,j) 位置的最小路径和。显然，dp[0][0]=grid[0][0]。对于 dp 中的其余元素，通过以下状态转移方程计算元素值。
当 i>0且 j=0 时，dp[i][0]=dp[i−1][0]+grid[i][0]。
当i=0 且 j>0 时，dp[0][j]=dp[0][j−1]+grid[0][j]。
当 i>0 且 j>0 时，dp[i][j]=min(dp[i−1][j],dp[i][j−1])+grid[i][j]。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int rows = grid.size();
        int colums = grid[0].size();
        auto dp = vector<vector<int>>(rows,vector<int>(colums));
        dp[0][0] = grid[0][0];
        for(int i=1; i<rows; i++){
            dp[i][0] = dp[i-1][0] + grid[i][0];
        }
        for(int j=1; j<colums; j++){
            dp[0][j] = dp[0][j-1] + grid[0][j];
        }
        for(int i=1; i<rows; i++){
            for(int j=1; j<colums; j++){
                dp[i][j] = min(dp[i-1][j], dp[i][j-1])+grid[i][j];
            }
        }
        return dp[rows-1][colums-1];
    }
};

或者

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int rows = grid.size();
        int colums = grid[0].size();
        auto dp = vector<vector<int>>(rows,vector<int>(colums));
        
        // for(int i=1; i<rows; i++){
        //     dp[i][0] = dp[i-1][0] + grid[i][0];
        // }
        // for(int j=1; j<colums; j++){
        //     dp[0][j] = dp[0][j-1] + grid[0][j];
        // }
        for(int i=0; i<rows; i++){
            for(int j=0; j<colums; j++){
                if(i==0&&j==0){
                    dp[0][0] = grid[0][0];
                }
                else if(i==0&&j!=0){
                    dp[0][j] = dp[0][j-1] + grid[0][j];
                }
                else if(i!=0&&j==0){
                    dp[i][0] = dp[i-1][0] + grid[i][0];
                }
                else{
                    dp[i][j] = min(dp[i-1][j], dp[i][j-1])+grid[i][j];
                }
            }
        }
        return dp[rows-1][colums-1];
    }
};

不同路径总数

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
问总共有多少条不同的路径？
链接：不同路径
和上一题有点相似和不同,总之要想走到右下角,只有可能从finish的上面一格下来或者从finish的左边一格过来.也就是说假设dp[i][j]代表走到finish的路径数,那么它一定等于走到finish上一格的路径数加上走到finish左边一格的路径数.
也就是dp[i][j]=dp[i-1][j] + dp[i][j-1]
当i=0,或者j=0时,意味着只有一种方式可以到finish,
即dp[0][j]=1,dp[i][0]=1

class Solution {
public:
    int uniquePaths(int m, int n) {
       vector<vector<int>> dp(m,vector<int>(n));
        //走到当前的路径数和
        //dp[i][j]=dp[i-1][j]+dp[i][j-1]
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(i==0||j==0){
                    dp[i][j]=1;
                }
                else
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};