力扣动态规划专题（一）背包理论基础 基础动规题 动规注意点 步骤及C++实现

已于 2023-06-25 20:30:22 修改
阅读量736 收藏 1
点赞数
分类专栏： C++刷题-LeetCode-牛客 文章标签： leetcode c++ 动态规划
于 2023-06-01 22:38:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uuuuu22/article/details/130876564
版权

文章目录

动态规划

  1. 动态规划，DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。
  2. 与贪心的区别：动态规划中每一个状态一定是由上一个状态推导出来的；贪心没有状态推导，而是从局部直接选最优的。
  3. 动态规划五步骤：
  • 确定dp数组（dp table）以及下标的含义
  • 确定递推公式
  • dp数组如何初始化
  • 确定遍历顺序
  • 举例推导dp数组
  1. 动态规划题目

  • 基础：509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯、62.不同路径、63. 不同路径 II、343. 整数拆分、96.不同的二叉搜索树

  • 背包问题

    • 背包：416. 分割等和子集、1049.最后一块石头的重量II、494.目标和、474.一和零
    • 完全背包：518.零钱兑换II、377.组合总和Ⅳ、70爬楼梯、322.零钱兑换、279.完全平方数、139.单词拆分
    • 多重背包

  • 打家劫舍：198.打家劫舍、213.打家劫舍II、337.打家劫舍III

  • 股票问题：121. 买卖股票的最佳时机（只能买卖一次）、122.买卖股票的最佳时机II（可以买卖多次）、123.买卖股票的最佳时机III（最多买卖两次）、188.买卖股票的最佳时机IV（最多买卖k次）、309.最佳买卖股票时机含冷冻期（买卖多次，卖出一天有冷冻期）、714.买卖股票的最佳时机含手续费（买卖多次，每次有手续费）

  • 子序列问题

    • 不连续子序列：300.最长递增子序列、1143.最长公共子序列、1035.不相交的线
    • 连续子序列：674.最长连续递增子序列、718. 最长重复子数组、53. 最大子序和
    • 编辑距离：392.判断子序列、115.不同的子序列、583. 两个字符串的删除操作、72. 编辑距离
    • 回文：647. 回文子串、516.最长回文子序列

509. 斐波那契数

在这里插入图片描述

五步骤

  1. 确定dp数组以及下标的含义：题目给出了，斐波那契数F(n)就是dp数组，因此第i个数的斐波那契数值F(i)就是dp[i]

  2. 确定递推公式：题目给出了递推公式，F(n) = F(n - 1) + F(n - 2)，因此状态转移方程为dp[i] = dp[i - 1] + dp[i - 2]

  3. dp数组如何初始化：题目给出了初始值，F(0) = 0，F(1) = 1，因此dp[0] = 0，dp[1] = 1

  4. 确定遍历顺序：dp[i]是由dp[i - 1]和dp[i - 2]推导而来的，那么遍历顺序是从前往后

  5. 举例推导dp数组：假设i=7，那么dp数组应该是{0, 1, 1, 2, 3, 5, 8, 13}

代码

维护整个数组

class Solution {
public:
    int fib(int n) {
        if(n <= 1) return n;
        vector<int> dp(n+1);//创建dp数组
        dp[0] = 0;//dp数组初始值
        dp[1] = 1;//dp数组初始值
        //开始从前往后遍历
        for(int i=2; i<=n; i++)
        {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
};

改进，只维护两个数值

class Solution {
public:
    //改进，只维护两个数值，不是整个数组
    int fib(int n)
    {
        if(n <= 1) return n;
        int dp[2];//数组 仅维护两个数值
        dp[0] = 0;
        dp[1] = 1;
        int sum = 0;
        for(int i=2; i<=n; i++)
        {
            sum = dp[0] + dp[1];//中间状态记录
            dp[0] = dp[1];//当前dp[0] = 上一个dp[1]
            dp[1] = sum;//当前dp[1] = 上一个的 dp[0]+dp[1]
        }
        return dp[1];
    }
};

70. 爬楼梯

在这里插入图片描述

五步骤

  1. 确定dp数组以及下标的含义：dp[i]，爬到第i层楼梯，有dp[i]种方法

  2. 确定递推公式：
    题目中说每次可以爬1或2个台阶，那么有两个方向可以得到dp[i]
    如果只爬一个台阶，就从i-1层楼梯上一个台阶。即dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，再上一个台阶就是dp[i]。
    如果只爬两个台阶，就从i-2层楼梯上两个台阶。即dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，再上两个台阶就是dp[i]。
    所以dp[i]就是dp[i - 1]与dp[i - 2]之和，即dp[i] = dp[i - 1] + dp[i - 2]

  3. dp数组如何初始化：
    不考虑dp[0]如何初始化，只初始化dp[1] = 1，dp[2] = 2，然后从i = 3开始递推

  4. 确定遍历顺序：dp[i]是由dp[i - 1]和dp[i - 2]推导而来的，那么遍历顺序是从前往后

  5. 举例推导dp数组：假设i=10，那么dp数组应该是{1，2，3，5，8，13，21，44，65，109}

  6. 和斐波那契数唯一的区别就是没有dp[0]

代码

  • 维护整个数组
class Solution {
public:
    int climbStairs(int n) {
        //2.维护整个数组
        if(n <= 1) return n;
        vector<int> dp(n+1);
        dp[1] = 1;
        dp[2] = 2;
        for(int i=3; i<=n; i++)
        {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
};
  • 维护两个数值
class Solution {
public:
    int climbStairs(int n) {
        //1.只维护两个数值
        if(n <= 1) return n;
        int dp[3];
        dp[1] = 1;
        dp[2] = 2;
        int sum = 0;
        for(int i=3; i<=n; i++)
        {
            sum = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};

746. 使用最小花费爬楼梯

五步骤

  1. 确定dp数组以及下标的含义：dp[i]，爬到第i层楼梯所花费最少的体力

  2. 确定递推公式：

  • 和70.爬楼梯相同的是，每次可以爬1或2个台阶，也就是有两个方向可以推导出dp[i]，即dp[i] = dp[i - 1] + dp[i - 2]。
  • 和70.爬楼梯不同的是，每次爬楼需要支付费用：
    从i-1层楼梯dp[i - 1] 再上 一个台阶到dp[i]，需要花费dp[i - 1] + cost[i - 1]
    从i-1层楼梯dp[i - 2] 再上 两个台阶到dp[i]，需要花费dp[i - 2] + cost[i - 2]
  • 因此到达dp[i]层楼梯，一共需要花费dp[i - 1] + cost[i - 1] + dp[i - 2] + cost[i - 2]。但题目中要求是最小花费，不是所有方法的总费用。到达dp[i]层楼梯，哪种方法下费用最少就用哪种方法爬楼，即dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])

  1. dp数组如何初始化：
    注意题目中描述的你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯，也就是说，到第0个或者第1个台阶不需要花钱，但是从第0个或者第1个台阶需要花钱，可以看题目给的例子。因此初始化dp[10] = 0，dp[1] = 0

  2. 确定遍历顺序：dp[i]是由dp[i - 1]和dp[i - 2]推导而来的，那么遍历顺序是从前往后

  3. 举例推导dp数组：假设使用题目的示例2，cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]，则有

cost[i]1100111100111001
下标i0123456789
dp[i]0012233445

代码

  • 维护整个数组
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //1.维护整个数组
        vector<int> dp(cost.size()+1);
        dp[0] = 0;
        dp[1] = 0;
        for(int i=2; i<=cost.size(); i++)
        {
            dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]);
        }
        return dp[cost.size()];
    }
};
  • 维护两个数值 使用数组
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int dp[2];
        dp[0] = dp[1] = 0;
        int finalcost = 0;
        for(int i=2; i<=cost.size(); i++)
        {
            finalcost = min(dp[0]+cost[i-2], dp[1]+cost[i-1]);
            dp[0] = dp[1];
            dp[1] = finalcost;
        }
        return dp[1];
    }
};
  • 维护两个数值 不用数组
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int dp0 = 0, dp1 = 0;
        int dpi;
        for(int i=2; i<=cost.size(); i++)
        {
            dpi = min(dp1+cost[i-1], dp0+cost[i-2]);
            dp0 = dp1;
            dp1 = dpi;
        }
        return dp1;
    }
};

扩展

如果按照第一步花钱，最后一步不花钱。也就是在第0个或者第1个台阶需要花钱，但是到达顶楼的时候不需要花钱

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //4.如果按照 第一步是花钱的，最后一步不花钱
        vector<int> dp(cost.size()+1);
        dp[0] = cost[0];
        dp[1] = cost[1];
        for(int i = 2; i<cost.size(); i++)//顶楼不花钱 不取等号
        {
            dp[i] = min(dp[i-2], dp[i-1]) + cost[i];
        }
        //最后一步不花钱的话，取倒数第一步和倒数第二步的最小值
        return min(dp[cost.size()-1], dp[cost.size()-2]);
    }
};

62. 不同路径

在这里插入图片描述
在这里插入图片描述

动态规划

五步骤

  1. 确定dp数组以及下标的含义：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径

  2. 确定递推公式：和爬楼梯的题目类似，每次可以选择向下或者向右走，也就是有两个方向可以推导出dp[i][j]，即dp[i][j] = dp[i - 1][j] + dp[i][j-1]

  3. dp数组如何初始化：从(0, 0)的位置到(i, 0)的路径只有一条，所以dp[i][0]一定都是1，那么dp[0][j]也是1

  4. 确定遍历顺序：dp[i][j]是由dp[i - 1][j]和dp[i][j-1]推导而来的，也就是从上或者左边推导而来，那么遍历顺序是从左到右

  5. 举例推导dp数组：假设m=5，n=6，则有

111111
123456
136101521
1410203556
15153570126

代码

  • 两个数组，逐行逐列遍历，有m*n个位置，每个位置记录对应的路径数，保存每个位置的结果
111111
123456
136101521
1410203556
15153570126
class Solution {
public:
    int uniquePaths(int m, int n) {
        //1.两个数组
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i=0; i<m; i++) dp[i][0] = 1;//初始化
        for(int j=0; j<n; j++) dp[0][j] = 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];
    }
};
  • 一个数组时，逐行遍历，只有n或m个位置，每个位置记录的是到达该位置的总路径数，数组只保存i=n的结果，每次都更新，滚动数组
i=1111111
i=2123456
i=3136101521
i=41410203556
i=515153570126
class Solution {
public:
    int uniquePaths(int m, int n) {
        //2.一个数组
        vector<int> dp(n, 0);
        for(int i=0; i<n; i++) dp[i] = 1;
        for(int j=1; j<m; j++)
        {
            for(int i=1; i<n; i++)
            {
                dp[i] += dp[i-1];
            }
        }
        return dp[n-1];
    }
};

数论

在这里插入图片描述
在这m + n - 2 步中，一定有 m - 1 步是要向下走的，不用管什么时候向下走。那么可以转化为组合问题，给m + n - 2个不同的数，随便取m - 1个数，有几种取法：

C m + n − 2 m − 1 C_{m+n-2}^{m-1} Cm+n−2m−1​ == C m − 1 + n − 1 m − 1 C_{m-1+n-1}^{m-1} Cm−1+n−1m−1​ == C m + n − 2 n − 1 C_{m+n-2}^{n-1} Cm+n−2n−1​ == ( m + n − 2 ) ! ( n − 1 ) ! × ( m − 1 ) ! {(m+n-2)!\over (n-1)!×(m-1)!} (n−1)!×(m−1)!(m+n−2)!​ == ( m − 1 + n − 2 ) × . . . × m × ( m − 1 ) × . . . × 2 × 1 ( n − 1 ) × . . . × 2 × 1 × ( m − 1 ) × . . . × 2 × 1 {(m-1+n-2)×...×m×(m-1)×...×2×1\over (n-1)×...×2×1×(m-1)×...×2×1} (n−1)×...×2×1×(m−1)×...×2×1(m−1+n−2)×...×m×(m−1)×...×2×1​ == ( m − 1 + n − 2 ) × . . . × m 1 {(m-1+n-2)×...×m\over 1} 1(m−1+n−2)×...×m​

注意最后结果是返回m×…×(m-1+n-2)，也就是分母除以分子的结果，还要注意分子溢出的情况，不能直接模拟公式计算。

class Solution {
public:
    int uniquePaths(int m, int n) {
        //3.数论 组合问题
        long long numerator = 1; // 分子
        int denominator = m - 1; // 分母
        int count = m-1;//相当于分子分母相消m-1项
        int t = m+n-2;//分子项
        while(count--)
        {
            numerator *= (t--);
            //分母不为0；numerator%denominator==0 表示找到相消项
            while(denominator!=0 && numerator%denominator==0)
            {
                numerator /= denominator;//更新结果
                denominator--;//分母项
            }
        }
        return numerator;
    }
};

63. 不同路径 II

​在这里插入图片描述
在这里插入图片描述

五步骤

  1. 确定dp数组以及下标的含义：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径

  2. 确定递推公式：

  • 和62题一样，每次可以选择向下或者向右走，有两个方向可以推导出dp[i][j]，即dp[i][j] = dp[i - 1][j] + dp[i][j-1]
  • 和62题不一样的是，遇到障碍就保持初始状态，相当于重新出发
  1. dp数组如何初始化：
  • 从(0, 0)的位置到(i, 0)的路径只有一条，所以dp[i][0]一定都是1，那么dp[0][j]也是1
  • 如果(i, 0)位置有障碍，该位置及其后面的路都没有办法走，就要重新出发。即遇到障碍后，dp[i][0]=0，对于(0, j)的位置也是同样的处理
  1. 确定遍历顺序：dp[i][j]是由dp[i - 1][j]和dp[i][j-1]推导而来的，也就是从上或者左边推导而来，那么遍历顺序是从左到右
  2. 举例推导dp数组，略

代码

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        //1.动态数组 两个数组
        int n = obstacleGrid[0].size();
        int m = obstacleGrid.size();
        //起点或者终点有障碍物 无路可走
        if(obstacleGrid[0][0]==1 || obstacleGrid[m-1][n-1]==1) return 0;
        //初始化dp数组
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i=0; i<m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
        for(int j=0; j<n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
        //更新dp数组
        for(int i=1; i<m; i++)
        {
            for(int j=1; j<n; j++)
            {
                if(obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
};
  • 一个数组时，逐行遍历，只有n或m个位置，每个位置记录的是到达该位置的总路径数，数组只保存i=n的结果，每次都更新，滚动数组
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        //2.动态数组 一个数组
        if(obstacleGrid[0][0] == 1) return 0;
        int n = obstacleGrid[0].size();
        vector<int> dp(n, 0);
        //初始化
        for(int j=0; j<n; j++)
        {
            if(obstacleGrid[0][j] == 1) dp[j] = 0;//遇到障碍物
            else if(j==0) dp[j] = 1;
            else dp[j] = dp[j-1];
        }
        //更新dp数组
        for(int i=1; i<obstacleGrid.size(); i++)
        {
            for(int j=0; j<n; j++)//注意这里从0开始
            {
                if(obstacleGrid[i][j] == 1) dp[j] = 0;
                else if(j!=0) dp[j] += dp[j-1];
            }
        }
        return dp[n-1];
    }
};

343. 整数拆分

在这里插入图片描述

五步骤

  1. 确定dp数组以及下标的含义：分拆数字i，可以得到的最大乘积为dp[i]

  2. 确定递推公式：

  • 有两个方向推导，j * (i - j)
  • j×(i - j)，直接把整数拆分为两个数相乘
  • j×dp[i - j]，相当于是拆分(i - j)，拆分成两个以及两个以上的个数相乘
  • 如果定义dp[i - j]×dp[j] 也是默认将一个数强制拆成4份以及4份以上了
  • 递推公式：dp[i] = max({dp[i], (i - j) * j, dp[i - j] * j});，在递推公式推导的过程中，每次计算dp[i]，取最大值

  1. dp数组如何初始化：拆分0和拆分1的最大乘积没有意义。从dp[i]的定义来说，拆分数字2，得到的最大乘积是1，初始化dp[2] = 1。

  2. 确定遍历顺序：

  • dp[i]是由dp[i - 1]推导而来的，那么遍历顺序是从左到右
  • j的结束条件是 j < i - 1，也可以是 j < i，但是后者重复计算。j=1时，拆分j与i-1；j = i - 1时，拆分i-1与1，重复计算。
  • i从3开始，那么dp[i - j]=dp[2]，可以通过初始化值求出来

  1. 拆分一个数n使其乘积最大，那么一定是拆分成m个数值相近的因子相乘的乘积最大。10 拆成 3 * 3 * 4和拆成2 * 5，前者的乘积更大。虽然无法确定m，但m一定大于等于2，也就是意味着拆成两个相同的因子的乘积有可能是最大值。那么遍历j时，只需要遍历到 n/2 就可以了，但乘积一定不是最大值。

  2. 举例推导dp数组，n为10 时

i345678910
j1~21~31~41~51~61~71~81~9
i-j2~13~14~15~16~17~18~19~1
dp[i-j]dp[2]dp[3] dp[2]dp[4] dp[3] dp[2]dp[5] dp[4] dp[3] dp[2]dp[6] dp[5] dp[4] dp[3] dp[2]dp[7] dp[6] dp[5] dp[4] dp[3] dp[2]dp[8] dp[7] dp[6] dp[5] dp[4] dp[3] dp[2]dp[9] dp[8] dp[7] dp[6] dp[5] dp[4] dp[3] dp[2]
dp[i]dp[3]dp[4]dp[5]dp[6]dp[7]dp[8]dp[9]dp[10]

代码

class Solution {
public:
    int integerBreak(int n) {
    //1.动态规划
    vector<int> dp(n+1);
    dp[2] = 1;
    for(int i=3; i<=n; i++)//dp[1] dp[0]没有意义
    {
        //内层for循环有三种写法
        //1.for(int j=1; j<i; j++)
        //2.for(int j=1; j<i-1; j++)
        for(int j=1; j<=i/2; j++)
        {
            dp[i] = max(dp[i], max(j*(i-j), j*dp[i-j]));
        }
    }
    return dp[n];
    }
};

96.不同的二叉搜索树

在这里插入图片描述

五步骤

  1. 确定dp数组以及下标的含义：1到i为节点组成的二叉搜索树的个数为dp[i]，i个不同元素节点组成的二叉搜索树的个数

  2. 确定递推公式：
    在这里插入图片描述

  • 1为头结点时，相当于n=2的两棵树加了值为1的头结点，3为头结点时，亦同理。2为头结点时，布局同n=1的树。

  • dp[3]可以通过dp[1] 和 dp[2] 推导，即元素1为头结点搜索树的数量 + 元 素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量：

    • 元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量，dp[2] * dp[0]；
    • 元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量，dp[1] * dp[1]；
    • 元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量，dp[0] * dp[2]；

  • dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

  • dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]，j相当于是头结点的元素，从1遍历到i为止。

  • dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量

  1. dp数组如何初始化：空节点也是一棵二叉树，也是一棵二叉搜索树，为了避免乘法为0，初始化dp[0]=1。

  2. 确定遍历顺序：dp[i] += dp[j - 1] * dp[i - j]可以看出，节点数为i的状态是依靠 i之前节点数的状态，用j来遍历i中每一个数作为头结点的状态

  3. 拆分一个数n使其乘积最大，那么一定是拆分成m个数值相近的因子相乘的乘积最大。10 拆成 3 * 3 * 4和拆成2 * 5，前者的乘积更大。虽然无法确定m，但m一定大于等于2，也就是意味着拆成两个相同的因子的乘积有可能是最大值。那么遍历j时，只需要遍历到 n/2 就可以了，但乘积一定不是最大值。

  4. 举例推导dp数组
    在这里插入图片描述

代码

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n+1);
        dp[0] = 1;//初始化空树的状态为1，避免乘法为0
        //更新dp数组
        for(int i=1; i<=n; i++)//以i为头结点的树
        {
            //符合条件的有多少棵树 用j从1-i遍历
            for(int j=1; j<=i; j++)
            {
                //对于第i个节点，需要考虑1作为根节点直到i作为根节点的情况，所以需要累加
                //一共i个节点，对于根节点j时,左子树的节点个数为j-1，右子树的节点个数为i-j
                //dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]
                dp[i] += dp[j-1] * dp[i-j];
            }
        }
        return dp[n];
    }
};

注意点：

  • 从509、70、746题来看，如果不到最后一层for循环的结束条件不取等号，到的话要取等号。例如，爬楼梯是，最后一层花钱或者要到顶楼的话，for循环的结束条件都要取等号。
  • 509、70、746题三个题大同小异，要注意dp数组初始化时要结合dp数组的定义，例如70、746题dp数组初始化的区别。
  • 不同路径可以用动态规划和数论的方法，数论注意分子溢出，注意遇到障碍物的处理方法
  • 不同的二叉搜索树，好难想到
虚假自律就会真自律！
关注
专栏目录
力扣动态规划
dayday学习的博客
09-06 1659
力扣动态规划1. 斐波那契数列70. 爬楼梯1要求2 思路198. 打家劫舍1要求2.思路2131 要求2.思路矩阵路径64. 最小路径和1 要求2.思路62. 不同路径1要求 1. 斐波那契数列 70. 爬楼梯 1要求 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。 示例 1： 输入： 2 输...
剑指Offer(第二版)10-2
随便写写
12-23 326
/** * @Author Tiam * @Date 2021/12/22 17:20 * @Description: 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 * <p> * 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。 * 0 <= n <= 100 */ public class Offer10_2 { /** * 设跳上 n 级.
力扣 | 动态规划
zzzlueng的博客
10-12 208
力扣152. 乘积最大子数组 给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积 示例 : 输入: [2,3,-2,4] 输出: 6 解释: 子数组 [2,3] 有最大乘积 6。 输入: [-2,0,-1] 输出: 0 解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。 这道题如果按照 53. 最大子序和 来写的话，就会简单想到一个dp数组， 记录着以num[i]为结尾的最大乘积的数。但是如果这样做的话， 就是错误
动态规划-力扣
Ctrl_kun的博客
07-19 2842
力扣上的动态规划题目本人题记
动态规划之01背包和完全背包问题（力扣C++题解）
lihua777的博客
02-04 1249
强烈推荐代码随想录！！！（纯路人）
力扣经典算法题-动态规划算法-golang语言解法
07-26
本文将深入探讨“力扣”（LeetCode）中的一个经典算法题，该题目涉及动态规划方法，旨在求解最大最小区域电话线的个数。我们将主要讨论动态规划的基本原理、在Golang语言中的实现细节以及如何应用这些概念来解决这个...
动态规划--5道题入门（C++力扣）（小细节多）
weixin_45479946的博客
11-15 1098
动态规划是由递归一步步优化出来的 递归–>记忆化递归–>动态规划 动态规划与其说是一个算法，不如说是一种方法论。该方法论主要致力于将合适的问题拆分成三个子目标——击破： 1.建立状态转移方程 2.缓存并复用以往结果 3.按顺序从小往大算 比如： 一、斐波那契额数列（剑指offer10-I） 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下： F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N
0-1背包问题（动态规划）
11-17
利用动态规划方法求解经典0-1背包问题，仅供参考，欢迎指正
力扣动态规划篇
最新发布
LeGuan_Ha的博客
03-07 404
以下思路来自代码随想录和官方题解。
力扣专题---动态规划
weixin_45055431的博客
12-31 575
动态规划–：Dynamic programming，简称 DP，是一种可以将将原问题分解成一个个小问题求解的过程。动态规划需要保存子问题的结果，然后根据子问题的结果递推更大的问题，这种是自底向上解法；另一种是自顶向下解法，采用递归函数向下求解。动态规划往往使用在有递归子问题或者最优子结构类型的题目，动态规划中最难的就是找到递推子式，也就是从子问题递推最终问题的过程。
动态规划 力扣题目
qq_44744450的博客
08-25 376
70.爬楼梯 每次可上楼一阶台阶或谅解台阶。 第i阶的怕发数量 = 第i-1阶的爬法数量 + 第i-2阶的爬法数量 class Solution { public: int climbStairs(int n) { vector<int> dp(n + 3, 0); dp[1] = 1; dp[2] = 2; for( int i = 3; i <=n; i++) { d
746. 使用最小花费爬楼梯
.
07-23 305
数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值cost[i]（下标从 0 开始）。 每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。 请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。 示例1： 输入：cost = [10, 15, 20] 输出：15 解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。 示例 2： 输入：cos...
力扣方法总结：动态规划
南航小菜鸡
02-04 339
动态规划
20191222——力扣动态规划
寄蜉蝣于天地，渺沧海之一粟。
12-22 202
做一个力扣单项的专栏 关于动态规划 第一个看的博文 动态规划1 动态规划的定义 动态规划实际上是一类题目的总称，并不是指某个固定的算法。动态规划的意义就是通过采用递推（或者分而治之）的策略，通过解决大问题的子问题从而解决整体的做法。动态规划的核心思想是巧妙的将问题拆分成多个子问题，通过计算子问题而得到整体问题的解。而子问题又可以拆分成更多的子问题，从而用类似递推迭代的方法解决要求的问题。 动态规划...
学习记录七
young_man2的博客
07-08 147
学习记录七
(力扣---动态规划)爬楼梯
qq_40258761的博客
03-10 1529
(力扣)爬楼梯 说明 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。 示例 1： 输入： 2 输出： 2 解释： 有两种方法可以爬到楼顶。 1 阶 + 1 阶 2 阶 示例 2： 输入： 3 输出： 3 解释： 有三种方法可以爬到楼顶。 1 阶 + 1 阶 + 1 阶 1 阶 + 2...
力扣方法总结-----动态规划
打工人。。
06-30 875
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
算法｜LeetCode（力扣）经典题：动态规划
峰峰的博客
02-24 2625
LeetCode经典（数据结构与算法）题刷题指南：动态规划篇
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值