爬楼梯（初识动态规划）

写在前面：
动态规划的应用十分广泛，这是博主第一次接触动态规划的内容，学起来也是比较吃力的，题解的代码精简，但解题的思维很深，就先拿入门的两道题来了解它吧

70.爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶

解题思路：
我是先举例，然后找规律的

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

我们先声明一个数组，长度为n+1，数组下标表示台阶数，这样数组元素就可以和台阶数形成一一对应,

举例：

       if(n==0) return 0;
       if(n==1) return 1;
       if(n==2) return 2;
       plt[1]=1;//台阶数为1的时候，只有一种方法
       plt[2]=2;//台阶数为2的时候，就有俩种，走俩次一个台阶，或者直接走俩个台阶

题目给的范围是从1开始的，下标为0的位置我就没使用了

重点：

for(int i=3;i<=n;i++){
            plt[i]=plt[i-1]+plt[i-2];
        }

这里可以计算一下，plt[3]=3，爬上第三个台阶，可以从第一个台阶爬两步上去，也可以从第二个台阶，走一步上去
从这里我们可以得出结论，plt[i]=plt[i-1]+plt[i-2];

到这里这一题就解决了。

完整代码：

 public int climbStairs(int n) {
       if(n==0) return 0;
       if(n==1) return 1;
       if(n==2) return 2;
       int [] pl=new int [n+1];
       pl[1]=1;
       pl[2]=2;
       for(int i=3;i<=n;i++){
       pl[i]=pl[i-1]+pl[i-2];
       }
       return pl[n];
        }

746.花费最小花费爬楼梯

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。请你计算并返回达到楼梯顶部的最低花费。

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

输入：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 。

解题思路：
读懂题目意思花了不少时间，下面提取要点

• 第i级台阶是第i-1级台阶的阶梯顶部。

• 踏上第i级台阶花费cost[i]，而直接走两步跨过第i个台阶而不踏上去则不用花费。

下面引用一下题解区大佬画的图：

我们要到第i级台阶的顶部，这时就有俩个选择了：

• 1，从第i个台阶走一步上去
• 2，从第i-1个台阶走两步上去

1：先付出最小总花费代价mincost[i-1]到达第i级台阶（即第i-1级台阶的顶部），这时候我们就站在了第i级台阶上，我们需要做的是再迈一步到达第i级台阶的顶部，花费为cost[i]，这种方法的最小总花费为mincost[i-1]+cost[i]

2：我们先付出最小总花费代价mincost[i-2]到达第i-1级台阶（即第i-2级台阶的顶部），这时候我们站在第i-1级台阶上，我们需要的是在迈出两步到达第i级台阶的顶部，花费为cost[i-1]，这种方法的总花费为mincost[i-2]+cost[i-1]

我们要的最小花费代价mincost[i]就取这俩种方法中小的那个

mincost[i] = min(mincost[i-1] + cost[i], mincost[i-2] + cost[i-1])

看懂题意，然后我们设置初始值

台阶的数组从0开始计数。可以用-1代表地面，并设cost[-1] = 0。

最小总花费的初始值为：

第0级台阶： mincost[0] = min(cost[-1], cost[0]) = min(0, cost[0]) = 0，

第1级台阶： mincost[1] = min(cost[0], cost[1])。

完整代码如下：

 public int minCostClimbingStairs(int[] cost) {
    int size=cost.length;
    int [] mincost=new int[size];
    mincost[0]=0;
    mincost[1]=Math.min(cost[0],cost[1]);
    for(int i=2;i<size;i++){
        mincost[i]=Math.min(mincost[i-2]+cost[i-1],mincost[i-1]+cost[i]);
    }
    return mincost[size-1];
    }

初识动态规划，这次学习的感悟是要不断锻炼递推和找规律的思维，多画图，多推演，继续加油！

如果你觉得这篇文章对你有所帮助的话，还请点个赞哦。