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 。

题解：
    从当前下标开始爬，可以向前爬两个或一个台阶，这样表示，从i开始向上爬，可以爬到i+1或者i+2，两者所需的花费不同，取最小的作为目标，每次都选择最小的那一个，和起来就是最少费用到达终点，应当是一种贪心算法。
    也可以做动态规划，需求出状态转移方程
    (经过几次尝试后，发现最主要的是要判断，在最后一步时，是否能一步跨两格直接到达楼顶，还是要在最后一格再跨一步到达楼顶，也就是说判断最后一个落点在cost.length-1,还是在cost.length-2)

/**
 * @param {number[]} cost
 * @return {number}
 */
const cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1];
var minCostClimbingStairs = function (cost) {
  //   let a = 0,
  //     sum = 0,
  //     falg = 0;
  //   for (let i = 1; i < cost.length - 1; i++) {
  //     a = Math.min(cost[i], cost[i + 1]);
  //     //a=cost[i]<cost[i+1]?cost[i]:cost[i+1];
  //     sum += a;
  //     if (a == cost[i + 1]) {
  //       falg = i + 1;
  //       i++;
  //     } else {
  //       falg = i;
  //     }
  //     console.log(a);
  //     console.log(falg);
  //   }
  //   if (falg == cost.length - 2 && cost.length > 3) {
  //     sum += cost[cost.length - 1];
  //   }
  //   console.log(sum);
  //   return sum;
  let len = cost.length;
  let arr = [];
  arr[0] = cost[0];
  arr[1] = cost[1];
  for (let i = 2; i < len; i++) {
    arr[i] = Math.min(arr[i - 1], arr[i - 2]) + cost[i];
  }
  console.log(Math.min(arr[len - 1], arr[len - 2]));
  return Math.min(arr[len - 1], arr[len - 2]);
};
minCostClimbingStairs(cost);

道理我都懂，但是按照注释里这么写就不行，后来思考一下，可能是因为“可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯”，起点的不同，导致判断标准没法统一使用，也就是最后的落点判断不准，就导致了错误，也就是将i的起始位置定到i=2，再将动态转移方程，代入判断条件，寻求当前情况的最优解，将每一次的最优解相加，就是贪心算法。