算法训练 day38 | 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯

509. 斐波那契数

题目链接:斐波那契数

        动规五部曲：

1.确定dp数组和下标的含义

dp[i]的定义为：第i个数的斐波那契数值是dp[i]

2.确定递推公式

为什么这是一道非常简单的入门题目呢？

因为题目已经把递推公式直接给我们了：状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];

3.dp数组初始化

题目已经给出了初始化

dp[0] = 0;
dp[1] = 1;

 4.确定遍历顺序

本题直接从左向右遍历即可

5.举例推导dp数组

按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当N为10的时候，dp数组应该是如下的数列：

0 1 1 2 3 5 8 13 21 34 55

如果代码写出来，发现结果不对，就把dp数组打印出来看看和我们推导的数列是不是一致的。

// 时间复杂度：O(n)
// 空间复杂度：O(1)
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. 爬楼梯

题目链接:爬楼梯

        本题如果没有接触过的话，会感觉比较难，多举几个例子，就可以发现其规律。

爬到第一层楼梯有一种方法，爬到二层楼梯有两种方法。

那么第一层楼梯再跨两步就到第三层 ，第二层楼梯再跨一步就到第三层。

所以到第三层楼梯的状态可以由第二层楼梯 和 到第一层楼梯状态推导出来，那么就可以想到动态规划了。

这样就可以得出递推公式：dp[i] = dp[i - 1] + dp[i - 2]

其实跟斐波那契数是一样的。

// 时间复杂度：O(n)
// 空间复杂度：O(1)
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. 使用最小花费爬楼梯

题目链接:使用最小花费爬楼梯

        dp[i]的定义：到达第i台阶所花费的最少体力为dp[i]。

        可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。

        dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。

        dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。

        那么究竟是选从dp[i - 1]跳还是从dp[i - 2]跳呢？

        一定是选最小的，所以dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);

题目描述中明确说了 “你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。” 那么初始化为 dp[0] = 0，dp[1] = 0;

// 时间复杂度：O(n)
// 空间复杂度：O(n)
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        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()];  
    }
};