什么是动态规划？
动态规划算法的基本思想-求解步骤-基本要素和一些经典的动态规划问题【干货】-CSDN博客
矩阵动态规划/单表动态规划
一、三步问题
面试题 08.01. 三步问题 - 力扣（LeetCode）
思路
我们要知道，走楼梯，前三个阶梯步数已经知道，那我们若是想走到第四楼，还需要一个个推吗？
走到4层，我们有三种方法
1.从一楼出发，这样只需要走3层即可。
2.从二楼出发，这样只需要走2层即可。
3.从三楼出发，这样只需要走1层即可。
所以在此问题中，我们要找到到达n个阶梯时，离n个阶梯最近的n-1，n-2，n-3的阶梯的最短路径。并且以此来递推出走到第n个阶梯的最短距离。
代码
int waysToStep(int n) {
const int MOD=1e9+7;
if(n==1||n==2) return n;
if(n==3) return 4;
vector<int> dp(n+1);
dp[1]=1,dp[2]=2,dp[3]=4;
for(int i=4;i<=n;i++)
{
dp[i]=((dp[i-1]+dp[i-2])%MOD+dp[i-3])%MOD;
}
return dp[n];
}二、使用最小花费爬楼梯
LCR 088. 使用最小花费爬楼梯 - 力扣（LeetCode）
思路
这也是个动态规划的题目，从底层楼梯爬到最上层，那我们建立表呢？
——设一个dp表，dp[i]表示到第i层需要花费的最少的钱。
由于付一次钱，就可以爬一层或者两层楼梯，所以我们需要比较的是到第i-1层和到第i-2层最小的值————min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]) 因此这就是我们的状态转移方程。
状态转移方程就是要把握到达每一步的值从哪里来？——然后比较出最小的那一步的值，依次类推，最后得出到达第i层最小的值。
代码
int minCostClimbingStairs(vector<int>& cost) {
int len=cost.size();
vector<int> dp(len+1);
if(len==1) return cost[0];
if(len==2) return min(cost[0],cost[1]);//返回两个中的最小值
dp[0]=0,dp[1]=0;
for(int i=2;i<=len;i++)
{
dp[i]=min(cost[i-1]+dp[i-1],dp[i-2]+cost[i-2]);
}
return dp[cost.size()];
}三、解码方法
思路
这里我们知道判断就只有两个，一个是单个数字，一个是两个数字，所以我们也可以按照动态规划的方式，由第n-1个和第n-2个推出第n个的值。
代码
int numDecodings(string s) {
int n=s.size();
vector<int> dp(n+1);
dp[0]=1;
for(int i=1;i<=n;i++)
{
if(s[i-1]!='0') dp[i]+=dp[i-1];//单个字母不为0，那么就往上加,一个字母就往前加一个
if(i>1&&s[i-2]!='0'&&(s[i-2]-'0')*10+(s[i-1]-'0')<=26) dp[i]+=dp[i-2];//两个字母就加前两个的
}
return dp[n];
}四、不同路径
思路
首先，我们知道，只能向右或者向下行走，那么我们可以通过动态规划得出转移方程
dp[i][j]=dp[i][j-1]+dp[i-1][j],其中dp表代表的是到达i处的路径数。
初始化呢？——第一行和第一列都只有1，然后通过状态转移方程即可得出最后一个位置的值，也就是打到终点的路径数。
代码
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m, vector<int>(n));
if(m==1&&n==1)
return 1;
for (int i = 1; i < n; i++)
{
dp[0][i] = 1;
}
for (int i = 1; i < m; i++)
{
dp[i][0] = 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 - 1][n - 1];
}五、不同路径II
思路
思路和不同路径的思路一样，只不过需要判断障碍物的位置，若是有障碍物，那么就直接将障碍物所在的dp表的值定为0，表明到此位置的路径数为0，无法到达。
代码
int numDecodings(string s) {
int n=s.size();
vector<int> dp(n+1);
dp[0]=1;
for(int i=1;i<=n;i++)
{
if(s[i-1]!='0') dp[i]+=dp[i-1];//单个字母不为0，那么就往上加,一个字母就往前加一个
if(i>1&&s[i-2]!='0'&&(s[i-2]-'0')*10+(s[i-1]-'0')<=26) dp[i]+=dp[i-2];//两个字母就加前两个的
}
return dp[n];
}六、珠宝的最高价值
LCR 166. 珠宝的最高价值 - 力扣（LeetCode）
思路
类比于不同路径的求法，还是通过动态规划，分清楚每个位置的最高价值从哪里来，列出状态转移方程即可。
代码
int jewelleryValue(vector<vector<int>>& grid) {
int m=grid.size(),n=grid[0].size();
vector<vector<int>> dp(m+1,vector<int>(n+1));
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
dp[i][j]=grid[i-1][j-1]+max(dp[i-1][j],dp[i][j-1]);
return dp[m][n];
}七、下降路径的最小和
思路
此处的方法同上几道题的想法，只不过在边界的时候需要进行判断若是在边界，则是另一种的判断方法，不是边界则就按照正常的方法去记录
代码
int minFallingPathSum(vector<vector<int>>& matrix) {
int m=matrix.size(),n=matrix[0].size();
vector<vector<int>> dp(m,vector<int>(n));
for(int i=0;i<n;i++)
{
dp[0][i]=matrix[0][i];//初始化
}
for(int i=1;i<m;i++)
{
for(int j=0;j<n;j++)
{
int min=dp[i-1][j];//假定最小的就是正对的上一个数字
if(j-1>=0&&dp[i-1][j-1]<min)
{
min=dp[i-1][j-1];
}
if(j+1<n&&dp[i-1][j+1]<min)
{
min=dp[i-1][j+1];
}
dp[i][j]=matrix[i][j]+min;
}
}
int Min=dp[m-1][0];
for(int i=1;i<n;i++)
{
Min=min(Min,dp[m-1][i]);
}
return Min;
}八、最小路径和
思路
此处同上，仅需要先判断出边界的大小，然后依次取最小的即可。
代码
int minPathSum(vector<vector<int>>& grid) {
int m=grid.size(),n=grid[0].size();
vector<vector<int>> dp(m,vector<int>(n));
dp[0][0]=grid[0][0];
for(int i=1;i<n;i++)//初始化第一行
{
dp[0][i]=dp[0][i-1]+grid[0][i];
}
for(int i=1;i<m;i++)//初始化第一列
{
dp[i][0]=grid[i][0]+dp[i-1][0];
}
for(int i=1;i<m;i++)
for(int j=1;j<n;j++)
dp[i][j]=grid[i][j]+min(dp[i-1][j],dp[i][j-1]);
return dp[m-1][n-1];
}九、地下城游戏
思路
此处我们会先想到计算出最小的值，但是此处要的是最小的初始健康点数，其实也就是最小的负数的绝对值。
所以我们对于元素应该采用相减，而不是相加。
但又值得注意的是，若是最后一步到了正数，那我们需要的健康点数至少为1。
所以我们需要转换思路，从结尾到开始处的最小距离，如果点数<=0，那么就说明到此处位置的点数超出了，就不需要这么多，那么就重置为1。
代码
int calculateMinimumHP(vector<vector<int>>& dungeon) {
//转换思路，从右下角到左上角的最小消耗距离，负数为加，正数为减
//从后往前,可以看做是一个累积生命值的过程
//那么就是，若生命到了0以下，说明正能量球给的足够多了，到此处的生命值只需要1即可
int m=dungeon.size(),n=dungeon[0].size();
vector<vector<int>> dp(m,vector<int>(n));
dp[m-1][n-1]=-dungeon[m-1][n-1]+1;//直接定义最后一个位置的
if(dp[m-1][n-1]<=0) //说明最后一个位置为正数，那么到此处的生命值只需要1
dp[m-1][n-1]=1;
//定义最后一列
for(int i=n-2;i>=0;i--)
{
int ret=dp[m-1][i+1]-dungeon[m-1][i];
if(ret<=0){
ret=1;
}
dp[m-1][i]=ret;
}
for(int j=m-2;j>=0;j--)
{
int ret=dp[j+1][n-1]-dungeon[j][n-1];
if(ret<=0){
ret=1;
}
dp[j][n-1]=ret;
}
for(int i=m-2;i>=0;i--)
{
for(int j=n-2;j>=0;j--)
{
int life1=dp[i+1][j]-dungeon[i][j];
int life2=dp[i][j+1]-dungeon[i][j];
if(life1<=0||life2<=0)//两个中有一个大于0，那么就可以把这个定为1，因为要找最小的路径,那么经过的正能量球也要适当的多
{
dp[i][j]=1;
}
else
{
dp[i][j]=min(life1,life2);//或者给一个两个之中一个较小的
}
}
}
return dp[0][0];
}双表动态规划
十、按摩师
思路
双表动态规划，往往会涉及到"拿"和"不拿"两个选择，那我们就需要定义两个表，分别表示不同状态下，同一位置的不同情况。
而且我们要对数字进行初始化 f[0]表示服务第一个客人获得的点数，所以
就是f[0]=nums[0],g[0]=0
代码
int massage(vector<int>& nums) {
int len=nums.size();
if(len==0)
return 0;
vector<int> g(len);
auto f=g;
g[0]=nums[0],f[0]=0;//若第一个接受，那么就是第一个元素，若不接受就是0
for(int i=1;i<len;i++)
{
g[i]=f[i-1]+nums[i];
f[i]=max(f[i-1],g[i-1]);//不接受就不加上当前的数字
}
return max(f[len-1],g[len-1]);
}十一、打家劫舍
思路
思路其实同按摩师，就是不能相邻的进行盗窃，代码相同，但是这个思路需要记住，以后还会有用到
代码
int rob(vector<int>& nums) {
int n=nums.size();
vector<int> f(n);
vector<int> h(n);
f[0]=nums[0],h[0]=0;
for(int i=1;i<n;i++)
{
f[i]=h[i-1]+nums[i];
h[i]=max(f[i-1],h[i-1]);
}
return max(f[n-1],h[n-1]);
}十二、删除并且获得点数
思路
其实就是打家劫舍的升级版，删除一个数据后，那么其相邻的元素都会被删除。
而且删除同一个数据后，就会连续进行删除，所以需要一个哈希表来记录每个数据出现个数的总和
代码
int deleteAndEarn(vector<int>& nums) {
int hash[100001]={0};
const int N=100001;
int len=nums.size();
for(auto e:nums)
{
hash[e]+=e;//统计每个数出现的总和——哈希表
}
vector<int> f(N);
auto g=f;
for(int i=1;i<N;i++)
{
f[i]=g[i-1]+hash[i];
g[i]=max(g[i-1],f[i-1]);
}
return max(f[N-1],g[N-1]);
}
6370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
