【动态规划】（斐波那契数列模型）使⽤最⼩花费爬楼梯（easy）

题⽬链接：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 。

注意注意：
在这道题中，数组内的每⼀个下标 [0, n - 1] 表⽰的都是楼层，⽽顶楼的位置其实是在 n 的
位置！！！

解法（动态规划）

算法思路：

解法⼀：

1. 状态表⽰：
   这道题可以根据「经验 + 题⽬要求」直接定义出状态表⽰：
   第⼀种：以 i 位置为结尾，巴拉巴拉
   dp[i] 表⽰：到达 i 位置时的最⼩花费。（注意：到达 i 位置的时候， i 位置的钱不需要算上）
2. 状态转移⽅程：
   根据最近的⼀步，分情况讨论：
   ▪ 先到达 i - 1 的位置，然后⽀付 cost[i - 1] ，接下来⾛⼀步⾛到 i 位置：dp[i - 1] + cost[i - 1] ；
   ▪ 先到达 i - 2 的位置，然后⽀付 cost[i - 2] ，接下来⾛⼀步⾛到 i 位置：dp[i - 2] + cost[i - 2] 。
3. 初始化：
   从我们的递推公式可以看出，我们需要先初始化 i = 0 ，以及 i = 1 位置的值。容易得到dp[0] = dp[1] = 0 ，因为不需要任何花费，就可以直接站在第 0 层和第 1 层上。
4. 填表顺序：
   根据「状态转移⽅程」可得，遍历的顺序是「从左往右」。
5. 返回值：
   根据「状态表⽰以及题⽬要求」，需要返回 dp[n] 位置的值。

算法代码：

class Solution{
 public int minCostClimbingStairs(int[] cost) {
	 // 1. 创建 dp 表
	 // 2. 初始化
	 // 3. 填表
	 // 4. 返回值
	 int n = cost.length;
	 int[] dp = new int[n + 1];
	 for(int i = 2; i <= n; i++)
	 dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
	 return dp[n];
 }
}

法⼆：

1. 状态表⽰：
   这道题可以根据「经验 + 题⽬要求」直接定义出状态表⽰：
   第⼆种：以 i 位置为起点，巴拉巴拉。
   dp[i] 表⽰：从 i 位置出发，到达楼顶，此时的最⼩花费。
2. 状态转移⽅程：
   根据最近的⼀步，分情况讨论：
   ▪ ⽀付 cost[i] ，往后⾛⼀步，接下来从 i + 1 的位置出发到终点： dp[i + 1] + cost[i] ；
   ▪ ⽀付 cost[i] ，往后⾛两步，接下来从 i + 2 的位置出发到终点： dp[i + 2] + cost[i] ；
   我们要的是最⼩花费，因此 dp[i] = min(dp[i + 1], dp[i + 2]) + cost[i] 。
3. 初始化：
   为了保证填表的时候不越界，我们需要初始化最后两个位置的值，结合状态表⽰易得： dp[n -
   1] = cost[n - 1], dp[n - 2] = cost[n - 2]
4. 填表顺序：
   根据「状态转移⽅程」可得，遍历的顺序是「从右往左」。
5. 返回值：
   根据「状态表⽰以及题⽬要求」，需要返回 dp[n] 位置的值。

算法代码：

class Solution{
 public int minCostClimbingStairs(int[] cost) {
	 // 1. 创建 dp 表
	 // 2. 初始化
	 // 3. 填表
	 // 4. 返回值
	 int n = cost.length;
	 int[] dp = new int[n];
	 dp[n - 1] = cost[n - 1]; dp[n - 2] = cost[n - 2];
	 for(int i = n - 3; i >= 0; i--)
	 	dp[i] = Math.min(dp[i + 1], dp[i + 2]) + cost[i];
	 return Math.min(dp[0], dp[1]);
 }
}