力扣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 阶分析：
-
如果有1个楼梯，那只能走1步登顶。 1中方法
-
如果有2个楼梯。
a. 我们可以一次走一步登顶。
b. 也可以一次走2步，登顶。
累计就是2种方法。
- 如果有3个楼梯：
a. 从楼底一步一步走上来
b. 从楼底先走1步，再一次走2步上来
c. 从楼底先一次走2步，再走1步上来
累计就是3种方法。
状态转移分析：
分析1： 步骤a是一步一步走上来的，也就是说要想走到3阶楼梯，前一次是从2阶楼梯上来的.
分析2： 步骤c是先从楼底一次走2步，然后一次走一步。也还是从2阶楼梯走上来的
也就是说 步骤a和步骤c，都依赖2阶楼梯的走法。而我们上面分析过了，从楼底走到2阶楼梯有 2 种方法.
分析3： 步骤b先从楼底走一步，最后一次走2步登顶。也就是说想要走到3阶楼梯，也可以从1 阶楼梯直接一次走2步直接登顶。依赖1阶楼梯
按照这种思路: 从楼底走到1阶楼梯有1种方法，从楼底走到2阶楼梯有2中方法。而3阶楼梯依赖 1阶楼梯和2阶楼梯。本体是要求一共多少种走法，那就是1阶楼梯和2阶楼梯的累加和。
得到公式： F(n) = F(n-1) + F(n-2). n > 2.
递归代码：
java
public int climbStairs(int n)
{
if (n <= 1) {
return n == 1 ? 1 : 0;
}
if (n == 2) {
return 2;
}
return climbStairs(n-1) + climbStairs(n-2);
}之前我已经写过很多篇介绍如何把递归改为动态规划的博客了。这一题比较简单，我再介绍一次。我们根据题目可以知道 n > 2. 那我假设 n== 4，那么推导过程：
第一步：
|------|---------------|--------------|-------|-------|
| 开始位置 | 1阶段楼梯 | 2阶段楼梯 | 3阶段楼梯 | 4阶段楼梯 |
| 楼底 | 根据 n<=1, 得到1 | 根据 n = 2 得到2 | | |
去掉推导过程，那结果就是：
|------|-------|-------|-------|-------|
| 开始位置 | 1阶段楼梯 | 2阶段楼梯 | 3阶段楼梯 | 4阶段楼梯 |
| 楼底 | 1 | 2 | | |
第二步：
根据 climbStairs(n-1) + climbStairs(n-2) 可以把后面的结果都给推出来：
|------|-------|-------|-------|-------|
| 开始位置 | 1阶段楼梯 | 2阶段楼梯 | 3阶段楼梯 | 4阶段楼梯 |
| 楼底 | 1 | 2 | 3 | 5 |
由此可以知道，动态规划使用1维数组即可：
java
//时间复杂度 O(n)
public int climbStairs2(int n){
//只有1阶楼梯
if (n <= 1) {
return n == 1 ? 1 : 0;
}
//2阶楼梯
if (n == 2) {
return 2;
}
int[] dp = new int[n+1];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}力扣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 。分析：
a. 这一题求的是最小花费，跟出发位置有关以及数组长度有关。以 [10,15,20]为例，数组长度为3，登顶的意思就是不是说到达数组最后一个下标，而是要把最后一个下标也给走完。
我们把爬楼梯理解成爬楼层，可能会更好懂一些。
假设一共有6层楼，登顶肯定是把6楼的楼梯也给走完才行。而数组的最后一个元素，只是代表 6楼到楼顶的所花费的代价。
b. 如果数组为空，那就直接返回0;
c. 如果数组为1， 直接返回数组的唯一值
d. 如果数组长度为2. 也就是说有2层楼。你要想到达楼顶，选取数组2个元素中较小的。
假设数组为 [10 ,15]. 到达楼顶：
如果你从楼底出发，一次走两层直接登顶。花费的代价就是10
如果你从1楼出发，一次走一层直接登顶。花费的代价就是15.
最终花费的代价就是10。
e：3个楼梯，假设数组 [10,15,20]。 到顶的意思，就是把楼梯走完，也就是数组的长度为3.
而数组10， 15， 20 代表的是 从楼底到1层 从1层到2层，从2层到3层的花费。
如果登顶, 那只能是从2层或者3层出发的。需要计算出到达2层花费的最小累加和，与到达3层的最小累加和。两者相比取小值。
java
package code04.动态规划专项训练01;
/**
* 力扣746题
* https://leetcode.cn/problems/min-cost-climbing-stairs/description/?envType=study-plan-v2&envId=dynamic-programming
*/
public class MinCostClimbingStairs_04 {
public int minCostClimbingStairs(int[] cost) {
//没有台阶
if (cost == null || cost.length == 0) {
return 0;
}
//只有1个台阶，只能从下标为0处开始爬
if (cost.length == 1) {
return cost[0];
}
//只有2个台阶，取小
if (cost.length == 2) {
return Math.min(cost[0], cost[1]);
}
int[] dp = new int[cost.length + 1];
dp[0] = 0;
dp[1] = 0;
int size = cost.length;
for (int i = 2; i <= size; i++) {
//需要计算 i-1 号楼梯经过1步走上来的代价 和 i - 2 号楼梯
//直接跨越2个楼梯走上来的代价
//这一题的其妙之处就是第i号楼梯的代价是要在 i + 1 和 i + 2楼梯的时候
//才会计算。如果没有这两个楼梯，就不需要考虑i号楼梯的代价了。比如:
//[10,15,20]. 只需要花费15就可以爬完楼梯
dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i-2] + cost[i-2]);
}
return dp[size];
}
public static void main(String[] args) {
MinCostClimbingStairs_04 ss = new MinCostClimbingStairs_04();
int[] arr = {10, 15, 20};
int[] arr2= {1,100,1,1,1,100,1,1,100,1};
System.out.println(ss.minCostClimbingStairs(arr2));
}
}