代码随想录day32 || 509斐波那契数列 70爬楼梯 746使用最小花费爬楼梯

509斐波那契数列

力扣题目链接

题目描述：

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

代码1（自己的）

class Solution {
public:
    int fib(int n)
    { 
       int f0=0,f1=1;int result=0;
       if(n==0){
        result = f0;
       }
       if(n==1){
        result = f1;
       }
       for(int i=1;i<n;i++){
            result=f0+f1;
            f0=f1;
            f1=result;
       }
       return result;
    }
};

比较官方的：

class Solution {
public:
    int fib(int N) {
        if (N <= 1) return N;
        int dp[2];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= N; i++) {
            int sum = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = sum;
        }
        return dp[1];
    }
};

70爬楼梯

力扣题目链接

题目描述：

假设你正在爬楼梯。需要 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 阶

代码自己的：

class Solution {
public:
    int climbStairs(int n) 
    {
        if(n<=3){
            return n;
        }       
        vector<int> dp(n+1);
            dp[0]=0;
            dp[1]=1;
            dp[2]=2;
            int result=0;
            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) {
        if (n <= 1) return n;
        int dp[3];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            int sum = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};

746使用最小花费爬楼梯

力扣题目链接

题目描述:

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

代码自己的：

#include <vector>  
using namespace std;  

class Solution {  
public:  
    int minCostClimbingStairs(vector<int>& cost) {  
        // 创建一个动态规划数组 dp，大小为 cost.size() + 1  
        vector<int> dp(cost.size() + 1);  
        
        // dp[0] 表示爬到第0级台阶的最小成本，起始费用为0  
        dp[0] = 0;  
        // dp[1] 表示爬到第1级台阶的最小成本，也为0  
        dp[1] = 0;  
        
        // dp[2] 表示从第0级或第1级到达第2级的最小费用  
        dp[2] = min(cost[0], cost[1]);  
        
        int result = dp[2]; // 将当前结果初始化为 dp[2]  

        // 从第3级台阶开始，直到最高级的台阶（即 cost.size() 级台阶）  
        for (int i = 3; i <= cost.size(); i++) {  
            // 计算到达第 i 级台阶的最小花费  
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);  
            // 更新结果为当前台阶的最小费用  
            result = dp[i];  
        }  
        
        // 返回达到楼梯顶部的最低花费  
        return result;  
    }  
};  

代码解释：

1. 动态规划数组的定义：

   • 创建一个长度为 cost.size() + 1 的动态规划数组 dp，其中 dp[i] 表示到达第 i 级台阶的最小花费。

2. 初始化基础情况：

   • dp[0] 和 dp[1] 都初始化为 0，因为在这两个台阶上不需要支付费用。
   • dp[2] 的值为 cost[0] 和 cost[1] 中的最小值，因为从第 0 级或第 1 级到达第 2 级只需支付其中一个的费用。

3. 动态规划转移：

   • 从第 3 级台阶开始，利用动态规划的转移方程来计算最小花费：
     • 到达第 i 级台阶的最小费用等于到达前一个台阶的费用加上当前台阶的费用，或到达前两个台阶的费用加上前一个台阶的费用。
     • 这段代码中的 dp[i] 是通过比较 dp[i - 1] + cost[i - 1] 和 dp[i - 2] + cost[i - 2] 来得到的。

4. 结果更新：

   • 在每次循环中，更新 result 为当前 dp[i] 的值，最终得到到达楼顶的最低花费。

5. 返回结果：

   • 函数的最后返回 result，即达到楼梯顶部所需的最低花费。

/*比较像贪心算法，从头开始遍历，只统计到某个台阶的最小花费，所以遍历到后面就都是最小值的和，所以是最小花费*/

理解动态规划的重要部分是理解dp数组的含义！！