动态规划刷题(1)

最近在自学动态规划，网上到处找资料学习：

在这里记录我的刷题历史：

题目都是在力扣里面刷的!!

这里，我放一个刷动态规划的链接在这里：动态规划知识点题库 - 力扣（LeetCode）

https://leetcode.cn/tag/dynamic-programming/problemset/

在这里附加动态规划相关知识点：https://blog.csdn.net/2301_77523055/article/details/137418158​​​​​​​

动态规划（Dynamic Programming，DP）是一种解决问题的算法思想，通常用于优化重叠子问题的递归算法。DP算法的核心思想是将原问题分解为相互重叠的子问题，并且将子问题的解存储起来，以便以后解决相同的子问题时可以直接使用已知的解，从而避免重复计算。

1. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1:

输入：n = 2

输出：2

解释：有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶

2. 2 阶

示例 2：

输入：n = 3

输出：3

解释：有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶

2. 1 阶 + 2 阶

3. 2 阶 + 1 阶

提示：

1 <= n <= 45

题目分析：

首先，遇到动态规划问题：

第一步：赋予数组某种含义

第二部：找关系，即状态转移方程

第三步：初始化

这个问题是一个经典的动态规划问题，可以通过状态转移方程来解决。我们定义一个数组 dp，其中 dp[i] 表示爬到第 i 阶楼顶的不同方法数。

根据题目描述，每次可以爬 1 或 2 个台阶，因此我们可以得到状态转移方程：

dp[i] = dp[i-1] + dp[i-2]

这个方程的含义是，到达第 i 阶楼顶的方法数等于到达第 i-1 阶楼顶的方法数（再爬 1 阶）加上到达第 i-2 阶楼顶的方法数（再爬 2 阶）。

同时，我们需要初始化 dp[1] 和 dp[2]，因为当只有 1 阶或 2 阶时，方法数是已知的。根据题目描述，dp[1] = 1（只有 1 种方法爬到第 1 阶），dp[2] = 2（有 2 种方法爬到第 2 阶）。

public class ClimbStairs {  
    public static int climbStairs(int n) {  
        if (n <= 2) {  
            return n; // 当n为1或2时，直接返回n  
        }  
          
        int[] dp = new int[n + 1]; // 初始化dp数组，长度为n+1  
        dp[1] = 1; // 第1阶有一种方法  
        dp[2] = 2; // 第2阶有两种方法  
          
        for (int i = 3; i <= n; i++) {  
            // 状态转移方程：到达第i阶的方法数等于到达第i-1阶的方法数加上到达第i-2阶的方法数  
            dp[i] = dp[i - 1] + dp[i - 2];  
        }  
          
        return dp[n]; // 返回到达第n阶的方法数  
    }  
      
    public static void main(String[] args) {  
        int n = 5; // 假设需要爬5阶楼梯  
        int result = climbStairs(n);  
        System.out.println("爬到" + n + "阶楼顶的不同方法数：" + result);  
    }  
}

或者：

import java.util.Scanner;

class Solution {
    public int climbStairs(int n) {
        if (n <= 0) {
            // 在输入不合法的情况下返回特定值，或者抛出异常
            return 0; // 或者其他合适的返回值
        }
        
        int dp[] = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;

        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        
        return dp[n]; // 返回爬到楼顶的方法数
    }
}

我的疑问：

int[] dp = new int[n + 1];

这个数组的长度为什么是n+1而不是n？

在爬楼梯问题中，我们使用数组 dp 来保存到达每一阶楼梯的方法数。数组的长度为 n+1 而不是 n 的原因如下：

1. 索引对应台阶数：在编程中，数组的索引通常从 0 开始。因此，如果我们定义一个长度为 n 的数组 dp，那么它的有效索引范围将是 0 到 n-1。然而，在这个问题中，我们想要的是数组的每个索引 i 对应到达第 i 阶楼梯的方法数。这意味着我们需要一个能够包含索引 0 到 n 的数组，因为我们要计算到达第 n 阶楼梯的方法数。

2. 包括起点：爬楼梯问题中，通常认为第 0 阶是一个有效的起点（尽管实际上没有台阶可以爬）。在这个问题中，我们是从第 0 阶开始计算的，所以我们需要一个额外的空间来保存到达第 0 阶的方法数（通常是 1，因为只有一种方法：不爬）。

3. 避免数组越界：如果我们定义数组长度为 n，那么在计算到达第 n 阶楼梯的方法数时，我们需要访问 dp[n]，这将导致数组越界错误，因为有效的索引范围只到 n-1。为了避免这个问题，我们将数组长度定义为 n+1，这样 dp[n] 就是有效的，并且对应到达第 n 阶楼梯的方法数。

因此，为了确保我们的数组能够正确地保存到达每一阶楼梯的方法数，并且避免任何潜在的越界错误，我们定义数组 dp 的长度为 n+1。这样，dp[0] 保存到达第 0 阶的方法数，dp[1] 保存到达第 1 阶的方法数，以此类推，直到 dp[n] 保存到达第 n 阶的方法数。

这篇文章如果对你有帮助，那就一键三连吧！！！