春晚综艺电视剧各出奇招 春节荧屏收视攻略指南

5.不同路径

不同路径
一个机器人位于一个?m x n?网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入： m = 3, n = 7
输出： 28

示例 2：

输入： m = 3, n = 2
输出： 3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入： m = 7, n = 3
输出： 28

示例 4：

输入： m = 3, n = 3
输出： 6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于?2 * 10^9

dp[i] [j]表示走到当前位置有多少种方式

初始化
1.虚拟节点里面的值，保证后面填表的结果是正确的
2.下标的映射
保证下面的边界不能出现越界的情况

初始化为1就行了

class Solution

{

public:

? ? int uniquePaths(int m, int n)

? ? {

? ? ? ? //创建dp吧表

? ? ? ? //初始化

? ? ? ? //填表

? ? ? ? //返回值

  

? ? ? ? vector<vector<int>>dp(m+1,vector<int>(n+1));//m+1行n+1列

? ? ? ? dp[0][1]=1;

? ? ? ? for(int i=1;i<=m;i++)//从上遍历每一行

? ? ? ? {

? ? ? ? ? ? for(int j=1;j<=n;j++)//从左往右填写每一行

? ? ? ? ? ? {

? ? ? ? ? ? ? ? dp[i][j]=dp[i-1][j]+dp[i][j-1];

? ? ? ? ? ? }

? ? ? ? }

? ? ? ? return dp[m][n];

? ? }

};

6.不同路径 II

不同路径 II
给定一个?m x n?的整数数组?grid。一个机器人初始位于?左上角（即?grid[0][0]）。机器人尝试移动到?右下角（即?grid[m - 1][n - 1]）。机器人每次只能向下或者向右移动一步。

网格中的障碍物和空位置分别用?1?和?0?来表示。机器人的移动路径中不能包含?任何?有障碍物的方格。

返回机器人能够到达右下角的不同路径数量。

测试用例保证答案小于等于?2 * 109。

示例 1：

输入： obstacleGrid = [[0,0,0],[0,1,0],[0,0,0] ]
输出： 2
解释： 3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入： obstacleGrid = [[0,1],[0,0] ]
输出： 1

提示：

• m ==?obstacleGrid.length
• n ==?obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j]?为?0?或?1

dp[i] [j]表示到达[i] [j]一共有多少种方法
初始化的时候只要我们的这个星星初始化好了就行了
所以我们在对边界的那一行一列进行初始化的时候，将dp[0] [1]初始化为1就行了

将我们五角星这个格子的左边或者是右边初始化为1就行了，我们从星星位置开始走

class Solution

{

public:

? ? int uniquePathsWithObstacles(vector<vector<int>>& ob)

? ? {

? ? ? ? //创建dp表

? ? ? ? //初始化

? ? ? ? //填表

? ? ? ? //返回值

? ? ? ? int m=ob.size(),n=ob[0].size();

? ? ? ? vector<vector<int>>dp(m+1,vector<int>(n+1));//m+1行，n+1列

? ? ? ? dp[1][0]=1;

? ? ? ? for(int i=1;i<=m;i++)

? ? ? ? {

? ? ? ? ? ? for(int j=1;j<=n;j++)

? ? ? ? ? ? {

? ? ? ? ? ? ? ? if(ob[i-1][j-1]==0)//这个位置是空位置。因为我们扩大了一行一列，所以我们这里的横纵坐标是需要进行减一的操作的

? ? ? ? ? ? ? ? {

? ? ? ? ? ? ? ? ? ?dp[i][j]=dp[i-1][j]+dp[i][j-1];

? ? ? ? ? ? ? ? }

  

? ? ? ? ? ? }

? ? ? ? }

? ? ? ? return dp[m][n];

? ? }

};

7.珠宝的最高价值

珠宝的最高价值
现有一个记作二维矩阵?frame?的珠宝架，其中?frame[i][j]?为该位置珠宝的价值。拿取珠宝的规则为：

• 只能从架子的左上角开始拿珠宝
• 每次可以移动到右侧或下侧的相邻位置
• 到达珠宝架子的右下角时，停止拿取

注意：珠宝的价值都是大于 0 的。除非这个架子上没有任何珠宝，比如?frame = [[0]]。

示例 1：

输入： frame = [[1,3,1],[1,5,1],[4,2,1] ]
输出：12
解释： 路径 1→3→5→2→1 可以拿到最高价值的珠宝

提示：

• 0 < frame.length <= 200
• 0 < frame[0].length <= 200
  就是看哪个路径拿到的礼物价值最多

dp[i] [j]表示，到达[i] [j]位置的时候 ，此时的最大价值
前一个格子的最大值加上我当前格子的值

初始化的时候我们多一行一列
里面的值是需要保证后面的填表是正确的
并且下标的映射关系要正确

我们需要将开始位置的上边和左边的格子初始化为0，不能影响到开始的位置

填表的时候如果要找到原始数组中的值，我们一定要进行横纵坐标-1的操作

填表顺序从上往下，从左往右

返回值就是dp[m] [n]

class Solution

{

public:

? ? int jewelleryValue(vector<vector<int>>& g)

? ? {

? ? ? ? //创建dp表

? ? ? ? //初始化

? ? ? ? //填表 ?

? ? ? ? //返回值

  

? ? ? ? int m=g.size(),n=g[0].size();

? ? ? ? vector<vector<int>>dp(m+1,vector<int>(n+1));

  

? ? ? ? //从坐标（1,1）开始

? ? ? ? for(int i=1;i<=m;i++)

? ? ? ? {

? ? ? ? ? ? for(int j=1;j<=n;j++)

? ? ? ? ? ? {

? ? ? ? ? ? ? ? dp[i][j]=max(dp[i-1][j],dp[i][j-1])+g[i-1][j-1];//两者位置的最大值加上我们当前位置的值

? ? ? ? ? ? }

? ? ? ? }

? ? ? ? return dp[m][n];

? ? }

};

8.下降路径最小和

下降路径最小和
给你一个?n x n?的?方形?整数数组?matrix?，请你找出并返回通过?matrix?的下降路径?的?最小和?。

下降路径?可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列（即位于正下方或者沿对角线向左或者向右的第一个元素）。具体来说，位置?(row, col)?的下一个元素应当是?(row + 1, col - 1)、(row + 1, col)?或者?(row + 1, col + 1)?。

示例 1：

输入： matrix = [[2,1,3],[6,5,4],[7,8,9] ]
输出： 13
解释： 如图所示，为和最小的两条下降路径

示例 2：

输入： matrix = [[-19,57],[-40,-5] ]
输出：-59
解释： 如图所示，为和最小的下降路径

提示：

• n == matrix.length == matrix[i].length
• 1 <= n <= 100
• -100 <= matrix[i][j] <= 100

dp[i] [j]就是到达[i] [j]时的最小下降路径



将第一行初始化为0，不能影响实际表格的第一行，
实际表格的第一行的值就是默认里面的值就行了

然后虚拟表格从第二行开始的第一列和最后一列都初始化为无穷大就行行了

因为我们要从三个路径中选择最小的一个路径，所以我们的虚拟位置是不能影响的这个最小路径的评选的，所以我们在这里初始化为正无穷大

这里我们是加上一行加上了两列虚拟位置

我们返回最后一行的最小值就行了

class Solution

?{

public:

? ? int minFallingPathSum(vector<vector<int>>& ma)

? ? {

? ? ? ? //创建一个dp表

? ? ? ? //初始化

? ? ? ? //确定填表顺序

? ? ? ? //返回结果

  

? ? ? ? int n=ma.size();

? ? ? ? vector<vector<int>>dp(n+1,vector<int>(n+2,INT_MAX));//初始化为最大值

? ? ? ? //初始化第一行

? ? ? ? for(int i=0;i<n+2;i++)dp[0][i]=0;//让第一行所有的i位置变成0就行了

  

? ? ? ? //那么到这里我们就将边界都初始化好了

? ? ? ? for(int i=1;i<=n;i++)

? ? ? ? {

? ? ? ? ? ? for(int j=1;j<=n;j++)

? ? ? ? ? ? {

? ? ? ? ? ? ? ? //我们这里的ma[i][j]坐标是需要-1的，需要映射到原始的矩阵里面的坐标的，因为我们加了一行两列

? ? ? ? ? ? ? ? dp[i][j]=min(dp[i-1][j-1],min(dp[i-1][j],dp[i-1][j+1]))+ma[i-1][j-1];//最小值加上当前的值

? ? ? ? ? ? }

? ? ? ? }

? ? ? ? int ret=INT_MAX;

? ? ? ? for(int j=1;j<=n;j++)

? ? ? ? {

? ? ? ? ? ? ret=min(ret,dp[n][j]);//找到最后一行的最小值就行了

? ? ? ? }

? ? ? ? return ret;

? ? }

};

9.最小路径和

最小路径和
给定一个包含非负整数的?_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

dp[i] [j]到达[i] [j]位置时，最小路径和

只需要修改两个位置的值为0，其他的都修改为正无穷大

class Solution

{

public:

? ? int minPathSum(vector<vector<int>>& g)

? ? {

? ? ? ? //创建一个dp表

? ? ? ? //初始化

? ? ? ? //确定填表顺序

? ? ? ? //返回结果

? ? ? ? int m=g.size(),n=g[0].size();

? ? ? ? vector<vector<int>>dp(m+1,vector<int>(n+1,INT_MAX));//将所有的值初始化为无穷大

? ? ? ? dp[0][1]=dp[1][0]=0 ;

  

? ? ? ? //到这里我们就将边界的情况初始化完毕了

? ? ? ? for(int i=1;i<=m;i++)

? ? ? ? {

? ? ? ? ? ? for(int j=1;j<=n;j++)

? ? ? ? ? ? {

? ? ? ? ? ? ? ? dp[i][j]=min(dp[i-1][j],dp[i][j-1])+g[i-1][j-1];

? ? ? ? ? ? }

? ? ? ? }

? ? ? ? return dp[m][n];

  
  
  

? ? }

};

10.地下城游戏

地下城游戏
恶魔们抓住了公主并将她关在了地下城?dungeon?的?右下角?。地下城是由?m x n?个房间组成的二维网格。我们英勇的骑士最初被安置在?左上角?的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。

骑士的初始健康点数为一个正整数。如果他的健康点数在某一时刻降至 0 或以下，他会立即死亡。

有些房间由恶魔守卫，因此骑士在进入这些房间时会失去健康点数（若房间里的值为_负整数_，则表示骑士将损失健康点数）；其他房间要么是空的（房间里的值为?0），要么包含增加骑士健康点数的魔法球（若房间里的值为_正整数_，则表示骑士将增加健康点数）。

为了尽快解救公主，骑士决定每次只?向右?或?向下?移动一步。

返回确保骑士能够拯救到公主所需的最低初始健康点数。

**注意：**任何房间都可能对骑士的健康点数造成威胁，也可能增加骑士的健康点数，包括骑士进入的左上角房间以及公主被监禁的右下角房间。

示例 1：

输入： dungeon = [[-2,-3,3],[-5,-10,1],[10,30,-5] ]
输出： 7
解释： 如果骑士遵循最佳路径：右 -> 右 -> 下 -> 下 ，则骑士的初始健康点数至少为 7 。

示例 2：

输入： dungeon = [[0] ]
输出： 1

dp[i ] [j]表示：从[i] [j]位置出发，到达终点，就是所需的最短健康数

class Solution

{

public:

? ? int calculateMinimumHP(vector<vector<int>>& d)

? ? {

? ? ? ? //创建一个dp表

? ? ? ? //初始化

? ? ? ? //确定填表顺序

? ? ? ? //返回结果

? ? ? ? int m=d.size(),n=d[0].size();

? ? ? ? vector<vector<int>>dp(m+1,vector<int>(n+1,INT_MAX));//都初始化为无穷大

? ? ? ? dp[m][n-1]=dp[m-1][n]=1;

? ? ? ? for(int i=m-1;i>=0;i--)

? ? ? ? {

? ? ? ? ? ? for(int j=n-1;j>=0;j--)

? ? ? ? ? ? {

? ? ? ? ? ? ? ? dp[i][j]=min(dp[i+1][j],dp[i][j+1])-d[i][j];//先期初这个点的下面和右边哪个最大

? ? ? ? ? ? ? ? dp[i][j]=max(1,dp[i][j]);//对负数进行处理操作

? ? ? ? ? ? ? ? //保证了角色的生命值至少为 1。

? ? ? ? ? ? }

? ? ? ? }

? ? ? ? return dp[0][0];

? ? }

};

//就是从后面开始到前面

从后向前开始进行遍历操作