LeetCode-动态规划

最新推荐文章于 2024-08-11 11:04:14 发布
最新推荐文章于 2024-08-11 11:04:14 发布
阅读量285 收藏
点赞数
分类专栏： 算法 文章标签： leetcode 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43324905/article/details/120274242
版权
本文详细解析了LeetCode中动态规划类问题的解题思路，包括一维、二维动态规划，分割类、子序列问题，背包问题，字符串编辑和股票问题等，通过实例讲解了如何构建状态转移方程和边界条件，帮助读者掌握动态规划技巧。
摘要由CSDN通过智能技术生成

LeetCode-动态规划（持续更新中）

本文主要对LeetCode中的动态规划类型题进行解析，讲解一些问题的解题思路和动态规划的基础解法。

1.动态规划基础解法

我将动态规划基础解法分为三个步骤，具体如下：

  1. 定义数组dp,通过dp数组记录最终的函数返回值；
  2. 确认递推公式，确认数组之间的递推关系，如dp[i] = dp[i-1] + 1;
  3. 定义边界条件，确认边界处的临界值，如 dp[0] = 1 等。

2.动态规划题目类型

2.1 一维动态规划

70.爬楼梯

解题思路：
1.定义dp[i] 表示爬i层台阶的方法数；
2.找递推公式， 第i层台阶只能从 i-1层或i-2层爬上，故dp[i] = dp[i-1] + dp[i-2];
3.定义边界 dp[1] = 1,dp[2] = 2;

 public int climbStairs(int n) {
     if(n<=2){
         return n;
     }
     //定义数组 dp[i]表示爬i层台阶的方法数
     int[] dp = new int[n+1];
     // 定义递推关系： dp[i] = dp[i-1] + dp[i-2]
     // 定义边界条件
     dp[1] = 1;
     dp[2] = 2;
     for(int i=3;i<=n;i++){
         dp[i] = dp[i-1] + dp[i-2];
     }
     return dp[n];
 }

显然我们可以对这种解法进行空间优化，使用pre1、pre2、cur三个变量记录即可。

 public int climbStairs(int n) {
     if(n<=2){
         return n;
     }
     int pre2=1,pre1=2,cur=0;
     for(int i=3;i<=n;i++){
         cur = pre1 + pre2;
         pre2 = pre1;
         pre1 = cur;
     }
     return cur;
 }
198.打家劫舍

解题思路：
1.定义dp[i] 表示第i间房屋所能偷的最大金额；
2.找递推公式， i位置的金额与前一个和前二个相关，故递推公式：dp[i] = Math.max(dp[i-2],dp[i-1]);;
3.定义边界 dp[0] = nums[0]; dp[1] = Math.max(nums[0],nums[1]);;

 public int rob(int[] nums) {
     if(nums.length == 1){
         return nums[0];
     }
     if(nums.length == 2){
         return Math.max(nums[0],nums[1]);
     }
     // 定义数组dp[i] 表示第i间房屋所能偷的最大金额
     int[] dp = new int[nums.length];
     // 递推公式：dp[i] = Math.max(dp[i-2],dp[i-1]);
     // 边界：
     dp[0] = nums[0];
     dp[1] = Math.max(nums[0],nums[1]);
     for(int i=2;i<nums.length;i++){
         dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i]);
     }
     return dp[nums.length-1];
 }

优化：

 public int rob(int[] nums) {
     if(nums.length == 1){
         return nums[0];
     }
     if(nums.length == 2){
         return Math.max(nums[0],nums[1]);
     }
     int pre2 = nums[0],pre1 = Math.max(nums[0],nums[1]),cur =0;
     for(int i=2;i<nums.length;i++){
         cur = Math.max(pre1,pre2+nums[i]);
         pre2 = pre1;
         pre1 = cur;
     }
     return cur;
 }

2.2 二维动态规划

基本问题：找出题目的动态转移方程。

64.最小路径和

解题思路：
1.首先定义二维数组dp[i][j] 表示从左上角到当前位置的最小路径和，定义返回值：dp[grid.length-1][grid[0].length-1];
2.找出数组之间关系的递推公式，上边界：dp[i][j] = grid[i][j] + dp[i][j-1]; 左边界：dp[i][j] = grid[i][j] + dp[i-1][j]; 内部：dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
3.确定边界条件：左上角的点：dp[i][j] = grid[i][j];

 public int minPathSum(int[][] grid) {
     // 定义数组 dp[i][j] 表示从左上角到i，j位置的最短路径
     int[][] dp = new int[grid.length][grid[0].length];
     // 定义数组递推关系 dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])
     // 定义边界条件
     for(int i=0;i<grid.length;i++) {
         for(int j=0;j<grid[0].length;j++){
             if(i == 0){
                 if(j == 0){
                     dp[i][j] = grid[i][j];
                     continue;
                 }
                 dp[i][j] = grid[i][j] + dp[i][j-1];
             }else if(j == 0){
                 dp[i][j] = grid[i][j] + dp[i-1][j];
             }else {
                 dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
             }
         }
     }
     return dp[grid.length-1][grid[0].length-1];
 }
542.01矩阵

解题思路：
1.定义数组dp[i[[j] 表示当前位置到0最近的距离；
2.递推公式：此题遍历分为两步骤，先从左上角往右下角遍历，再从右下角往左上角遍历；两次遍历过程会覆盖到所有的位置；公式与上题类似，不再赘述。
3.边界，需要保证初始数组中的每个值保证足够大；

 public int[][] updateMatrix(int[][] mat) {
     // 定义数组dp[i][j] 表示当前位置到周围0的最小距离
     int m = mat.length;
     int n = mat[0].length;
     int[][] dp = new int[m][n];
     // 遍历分为两步骤，先从左上角往右下角遍历，再从右下角往左上角遍历；
     for(int i=0;i<m;i++){
         for(int j=0;j<n;j++){
             dp[i][j] = Integer.MAX_VALUE-1;
             if(mat[i][j] == 0){
                 dp[i][j] = 0;
             }else {
                 if(i > 0){
                     dp[i][j] = Math.min(dp[i][j],dp[i-1][j]);
                 }

                 if(j > 0){
                     dp[i][j] = Math.min(dp[i][j],dp[i][j-1]);
                 }
             }
         }
     }

     for(int i=m-1;i>=0;i--){
         for(int j=n-1;j>=0;j--){
             if(mat[i][j] != 0){
                 if(i < m-1){
                     dp[i][j] = Math.min(dp[i][j],dp[i+1][j]);
                 }
                 if(j < n-1){
                     dp[i][j] = Math.min(dp[i][j],dp[i][j+1]);
                 }
             }
         }
     }

     return dp;
 }

2.3 分割类问题

对于分割类型的动态规划题目，状态转移方程往往取决于满足分割条件处的位置。

139.单词拆分

此题状态转移方程 dp[i] 与 dp[i-len] 分割位置的数组有关。

 public boolean wordBreak(String s, List<String> wordDict) {
     // 遍历字符串
     int n = s.length();
     // 记录状态
     boolean[] dp = new boolean[n+1];
     dp[0] = true;
     for(int i=1;i<=n;i++){
         for(String word:wordDict){
             int len = word.length();
             if(i >= len && s.substring(i-len,i).equals(word)){
                 dp[i] = dp[i] || dp[i-len];
             }
         }
     }
     return dp[n];
 }
279.完全平方数

此题的状态转移方程，dp[i] 与满足条件的 dp[i-j*j] 相关

 public int numSquares(int n) {
     // 定义数组dp[i]表示i数组最少组成的完全平方数；
     int[] dp = new int[n+1];
     dp[0] = 0;
     for(int i=1;i<=n;i++){
         dp[i] = Integer.MAX_VALUE;
     }
     for(int i=1;i<=n;i++){
         for(int j=1;j*j <= i;j++){
             dp[i] = Math.min(dp[i],dp[i - j*j] + 1);
         }
     }
     return dp[n];
 }

2.4 子序列问题

对于子序列问题的常见解法为：1.定义一个数组 dp[i] 表示 i 结尾的子序列的特性，处理好每个位置后，再统计一遍即可。

300.最长递增子序列
 public int lengthOfLIS(int[] nums) {
     // 定义数组 dp[i]表示 i位置的nums最长的递增子序列；
     int[] dp = new int[nums.length];
     // 边界条件
     for (int i = 0; i < dp.length; i++) {
         dp[i] = 1;
     }
     // 定义最大返回子序列长度
     int max = 0;
     for (int i = 0; i < nums.length; i++) {
         for (int j = 0; j < i; j++) {
             if(nums[i] > nums[j]) {
                 dp[i] = Math.max(dp[i],dp[j] + 1);
             }
         }
         // 统计一遍最大的dp[i]
         max = Math.max(max,dp[i]);
     }

     return max;
 }
583.两个字符串的删除操作
646.最长对数链

2.5 背包问题

背包问题：有 N 个物品和容量为 W 的背包，每个物品都有自己的体积 w 和价值 v，求拿哪些物品可以使得背包所装下物品的总价值最大。
核心代码：
1.0-1背包，外层遍历物品，内层逆向遍历价值或重量；
2.完全背包：外层遍历物品，内层正向遍历价值或重量。

2.5.1 0-1背包问题

如果限定每种物品只能选择 0 个或 1 个，则此背包问题称为0-1背包问题。
解法1：

  1. 定义数组dp[i][j] 表示i个物品，容量为j所能取到的最大价值。
  2. 递推关系，当前位置存在取或不取两种状态，所以取两种情况的最大价值 dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-w]+v);
  3. 边界条件：默认为0即可。
 public int maxBagValue(int[] weights,int[] values,int N,int W){
     // 定义数组 dp[i][j] 表示 i个物品，j个容量所能取到的最大价值；
     int[][] dp = new int[N+1][W+1];
     for (int i = 1; i <= N; i++) {
         int w = weights[i-1],v = values[i-1];
         for (int j = 1; j <= W; j++) {
             if (j >= w){
                 dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-w]+v);
             }else {
                 dp[i][j] = dp[i-1][j];
             }
         }
     }
     return dp[N][W];
 }

在此我们可以发现递推公式之间，dp[i][] 只与dp[i-1][]相关,故可对解法1的空间进行优化。
解法2如下：

  1. 定义数组dp[i] 表示容量为i的背包所能取得的最大价值；
  2. 递推公式：dp[i] = Math.max(dp[i],dp[i-w]+v).
  3. 边界无。
 public int maxBagValue2(int[] weights,int[] values,int N,int W){
     // 定义数组 dp[i] 表示 重量为W的背包，所能取到的最大价值；
     int[] dp = new int[W+1];
     for (int i = 1; i <= N; i++) {
         int w = weights[i-1],v = values[i-1];
         // 需要倒序往前推,防止dp[j-w]不会被覆盖；若按照从左往右的顺序进行正向遍历，则 dp[j-w] 的值在遍历到
         // j 之前就已经被更新成物品 i 的值了
         for (int j = W; j >= w; j--) {
             dp[j] = Math.max(dp[j],dp[j-w]+v);
         }
     }
     return dp[W];
 }

同类题目：

416.分割等和子集

可以转换为是否可以获取数组总值一半的0-1背包问题

 public boolean canPartition(int[] nums) {
     // 等价于0-1背包问题
     int sum =0;
     for(int i=0;i<nums.length;i++){
         sum += nums[i];
     }

     if(sum % 2 != 0){
         return false;
     }

     int target = sum/2;

     // 定义数组dp[i] 表示数组是否能够取到目标值i
     boolean[] dp = new boolean[target+1];
     dp[0] = true;
     for(int i=0;i<nums.length;i++){
         for(int j=target;j>= nums[i];j--){
             dp[j] = dp[j] || dp[j-nums[i]];
         }
     }

     return dp[target];
 }
2.5.2 完全背包问题

同上0-1背包，核心代码可看背包问题下方区别。

 public int maxBagValue(int[] weights,int[] values,int N,int W){
     // 定义数组 dp[i] 表示 重量为W的背包，所能取到的最大价值；
     int[] dp = new int[W+1];
     for (int i = 1; i <= N; i++) {
         int w = weights[i-1],v = values[i-1];
         for (int j = w; j < W; j++) {
             dp[j] = Math.max(dp[j],dp[j-w]+v);
         }
     }
     return dp[W];
 }
322. 零钱兑换

外层遍历物品，内层正向遍历体积或价值。

 public int coinChange(int[] coins, int amount) {
     // 完全背包问题
     if(amount == 0){
         return 0;
     }
     // 定义数组 dp[i] 表示凑成i所需的最小硬币个数
     int[] dp = new int[amount+1];
     for(int i=1;i<dp.length;i++){
     	 // 保证初始值足够大
         dp[i] = amount+2;
     }
     dp[0] = 0;
     for(int i=0;i<coins.length;i++){
         for(int j=coins[i];j<=amount;j++){
             dp[j] = Math.min(dp[j],dp[j-coins[i]] + 1);
         }
     }

     return dp[amount] == amount+2?-1:dp[amount];

 }

2.6 字符串编辑问题

72.编辑距离

1.此题我们需要维护一个二维数组dp[]i[j] 表示 word1 到 i 位置和 word2 到 j 位置所需要的最小编辑数；
2. 当 i 和 j 位置的字符相同时，dp[i][j] = dp[i-1][j-1]; 当 i 和 j 位置的字符不同时，修改的需要 dp[i][j] = dp[i-1][j-1] + 1; 插入 i 位置/删除 j 位置的是 dp[i][j-1] + 1，插入 j 位置/删除 i 位置的是 dp[i-1][j] + 1 。

  public int minDistance(String word1, String word2) {
      int m = word1.length();
      int n = word2.length();
      int[][] dp = new int[m+1][n+1];
      for (int i = 0; i <= m; i++) {
          for(int j = 0;j <= n;j++) {
              if (i == 0){
                  dp[i][j] = j;
              }else if (j == 0){
                  dp[i][j] = i;
              }else{
                  dp[i][j] = Math.min(dp[i-1][j-1] + (word1.charAt(i-1) == word2.charAt(j-1)?0:1),Math.min(dp[i-1][j]+1,dp[i][j-1]+1));
              }
          }
      }
      return dp[m][n];
  }

2.7 股票问题

121.买卖股票的最佳时机

此题的主要解题思路在于，记录买入的最小值，同时记录卖出的最大利润即可。

   public int maxProfit(int[] prices) {
       // sell表示卖出的最大值，buy表示买入的最小值
       int sell=0,buy = Integer.MAX_VALUE;
       for(int i=0;i<prices.length;i++){
           buy = Math.min(buy,prices[i]);
           sell = Math.max(sell,prices[i] - buy);
       }
       return sell;
   }
188.买卖股票的最佳时机IV

此题的解题思路在于，维护两个数组buy[i] 表示在i时刻买入股票时取得的最大利润，sell[i] 表示在i时刻卖出的最大利润。同时区分K大于数组prices长度时，选择盈利即可。小于时正常处理。

    public int maxProfit(int k, int[] prices) {
        // 区分情况 k>prices.length 则赚钱就卖出
        if (k > prices.length){
            return profit(prices);
        }
        // 定义数组buy[j] 表示j时刻买入时的最大收入，sell[j] 表示j时刻卖出的最大收入
        int[] buy = new int[k+1];
        int[] sell = new int[k+1];
        for (int i = 0; i <= k; i++) {
            buy[i] = Integer.MIN_VALUE;
        }
        sell[0] = 0;

        for(int i=0;i<prices.length;i++){
            for(int j=1;j<=k;j++){
                // j位置买入的最大价值
                buy[j] = Math.max(buy[j],sell[j-1] - prices[i]);
                // j位置卖出的最大价值，此处转移方程
                sell[j] = Math.max(sell[j],buy[j] + prices[i]);
            }
        }

        return sell[k];
    }

    public int profit(int[] prices){
        int res = 0;
        for(int i=1;i<prices.length;i++){
            if(prices[i] > prices[i-1]){
                res += prices[i] - prices[i-1];
            }
        }

        return res;
    }
714.买卖股票的最佳时机含手续费

此题关键点在于找到状态转移方程，找到当前位置最大利润与前一步的关系。

  public int maxProfit(int[] prices, int fee) {
      // 股票
      int maxProfit = 0;
      // 定义数组，buy[i] sell[i]位置的数组分别表示买入和卖出的最大价值
      int[] buy = new int[prices.length];
      int[] sell = new int[prices.length];
      // 边界问题
      buy[0] = -prices[0];
      sell[0] = 0;

      for(int i=1;i<prices.length;i++){
          // 如果当前买入，最大值为前一个买入的最大值，或前一个位置卖出的最大值减当前位置买入
          buy[i] = Math.max(buy[i-1],sell[i-1] - prices[i]);
          // 建立状态机，如果当前卖出，取得最大值，前一个位置卖出的最大值或前一个买入的最大值+当前卖出
          sell[i] = Math.max(sell[i-1],buy[i-1]+prices[i]-fee);
      }
      return sell[prices.length-1];
  }
309、最佳买卖股票时机含冷冻期

此题需要四个数组表示状态转换，比较复杂，先不记录了…

迎风踏雪来
关注
专栏目录
【Leetcode】动态规划
CharlieTang的博客
08-22 396
动态规划 动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 主要思想 若要解一个给定问题，我们需要解其不同部分（即子问题），再根据子问题的解以得出原问题的解。动态规划往往用于优化递归问题，例如斐波那契数列，如果运用递归的方式来求解会重复计算很多相同的子问题，利用动态规划的思想可以减少计算量。 动态规划法仅仅解决每个子问题一次，具有天然剪枝的功能，从而减少计算量， 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 动态规划
Leetcode-动态规划
sinat_41920065的博客
01-21 1276
文章目录八、动态规划1. 斐波那契数列2. 青蛙跳台阶问题3. 最小路径和4. 最少的硬币数目5. 股票的最大利润6. 买卖股票的最佳时机 II7. 买卖股票的最佳时机 III（多看）8. N皇后9. 岛屿数量 八、动态规划 1. 斐波那契数列 方法一：Fib(n) = Fib(n - 1) + Fib(n - 2), 可采用递归的方法，获取n的值 方法二：定义两个变量mm和nn用来表示n-1的值和n-2的值，只需要O(n)的时间复杂度和O(1)的空间复杂度即可得到n的值 2. 青蛙跳台阶问题 本质上就是斐
leetcode之动态规划
weixin_47414034的博客
06-23 2010
以爬楼梯问题为例，总结动态规划的步骤：第一步：定义dp数组（可能时一维数组，也可能是二维数组），这一步需要确定两个问题：（1）dp[i]或者dp[i][j]是什么含义（比如在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法）（2）到底开多大的空间，你搞懂了第一个问题dp[i]或者dp[i][j]是什么含义，就知道到底要开多大的空间了，由于在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法，你最后求的是到达第n层所需要的爬法数，所以最后要返回的是dp[n]，所以显然要开n+1大小的数组，这样才能有dp[n
leetcode-动态规划
SunYutong_1234的博客
03-02 900
动态规划有自底向上和自顶向下两种解决问题的方式。自顶向下即记忆化递归，自底向上就是递推。
LeetCode之动态规划
最新发布
Jak的博客
08-11 388
遍历数组，i - 1加i - 2即是当前台阶的方法，全部存到相应的数组。最后result[n]就是n级台阶的方法。动态规划，数组存储每个台阶的方法。
Leetcode——动态规划
qq_43587345的博客
07-01 338
动态规划 例一： 给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。 输入: A: [1,2,3,2,1] B: [3,2,1,4,7] 输出: 3 解释: 长度最长的公共子数组是 [3, 2, 1]。 代码： class Solution { public: int findLength(vector<int>& A, vector<int>& B) { int num=0; in
leetcode答案-leetcode-practice:leetcode-练习
06-30
LeetCode的题目覆盖了从基础到高级的各种主题，包括但不限于排序、搜索、图论、动态规划、字符串处理、二叉树等。这些题目不仅有助于提升编程技巧，还能训练解决复杂问题的能力，因此在求职面试中常被用作考核标准。...
leetcode-动态
02-07
标题 "leetcode-动态" 暗示我们关注的是与 LeetCode 相关的动态规划问题。LeetCode 是一个在线平台，提供各种编程挑战，其中包括大量的动态规划题目，旨在提升程序员的算法技能。动态规划是一种解决复杂问题的有效...
leetcode答案-leetcode--python:leetcode--python
06-30
1. 问题分类文件夹：按照LeetCode上的问题分类，如“二叉树”，“动态规划”等。 2. 代码文件：每个问题的Python解决方案，可能以问题ID或标题命名。 3. README.md：项目介绍和使用说明，包括如何运行代码，贡献指南...
leetcode1239-leetcode-cpp:leetcode-cpp
07-01
3. **算法和数据结构**: LeetCode中的问题涵盖了各种算法（如排序、搜索、图论、动态规划）和数据结构（如数组、链表、树、堆、哈希表），这些都是程序员必备的知识。 4. **开源文化**: 开源软件允许社区共同参与...
leetcode动态规划
qq_43283527的博客
04-16 712
最优子结构 子问题最优问题可导出原问题最优决策 无后效性 重叠子问题 去冗余 空间换时间 基本步骤： 设计暴力算法，找到冗余 设计并储存状态 递归式（状态转移方程） 自底向上计算最优解（编程方式） 例题： 983. 最低票价 在一个火车旅行很受欢迎的国度，你提前一年计划了一些火车旅行。在接下来的一年里，你要旅行的日子将以一个名为 days 的数组给出。每一项是一个从 1 到 365 ...
LeetCode—动态规划
weixin_42589774的博客
06-22 424
LeetCode—动态规划 斐波那契数列 1、爬楼梯 T70. Climbing Stairs (Easy) class Solution { public: int climbStairs(int n) { if (n <= 1) return 1; vector<int> dp(n); dp[0] = 1; dp[1] = 2; for (int i = 2; i < n; ++i) {
leetcode 之动态规划
Hu_LSS的博客
03-25 302
动态规划 1. 最大子序和 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [0] 输出：0 示例 4： 输入：nums = [-1] 输出：-1 示例 5： 输入：nums = [-100000] 输出：-100000
Leetcode_动态规划
Liucxscornfield的博客
07-01 877
爬楼梯 有n级台阶，每次有两种方法上楼（一次上一节/一次上两节）。问：有多少种方案？ https://leetcode-cn.com/problems/climbing-stairs/ 输入： 3 输出： 3 解释： 有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶 解题思路 动态规划： 一个问题的最优解，可以从其子集的最优解组合而得。 第i级台阶的方法总数=（i-1）级台阶方法总数 + （i-2）级台阶方法总数 例外：n&l.
leetcode--动态规划
xiayto的博客
01-21 357
基础知识： 动态规划： 1、确认原问题和子问题 2、确认状态 3、确认边界条件 4、确认转移方程 leetcode题目 70. Climbing Stairs 题意： 每次可以上1阶和2阶，上n阶楼梯，有多少中可能的情况。 解题思路： 最暴力的做法是递归，时间复杂度O(2^n)会超时： class Solution { public: int c
LeetCode - 动态规划
weixin_39505091的博客
03-26 637
文章目录一. 动态规划 一. 动态规划 动态规划适用于最优子结构问题，即全局最优解由局部最优解决定； 它将原问题拆成多个子问题求解，与深度优先广度优先的区别是它需要保存子问题的解避免重复计算； 动态规划的关键是要找到状态转移方程； 动态规划还能进行空间压缩以节省空间。 例题70. 爬楼梯 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ n阶台阶的走法等于走到第n-1阶台阶的走法 + 走到第n-2阶台阶的走法，因此状态转移方程：dp[i
LeetCode-eclipse插件助力Java编程
使用LeetCode-Eclipse进行编程练习，可以帮助开发者巩固和深化在数据结构（如数组、链表、树、图等）、算法（如排序、搜索、动态规划等）、以及设计模式等方面的知识。此外，对于理解复杂系统设计和提高代码质量也有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值