力扣：使用最小花费爬楼梯

数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost[i](索引从0开始)。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

示例 1:

输入: cost = [10, 15, 20]
输出: 15
解释: 最低花费是从cost[1]开始，然后走两步即可到阶梯顶，一共花费15。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-cost-climbing-stairs

 

无论是选哪个都不确定会不会对后面的有影响，所以会暴雷 

//大致思路就是倒着看，到达但前的一步所用比较少的前一步的
//但是只能通过部分样例，是由漏洞的【0，2，2，1】
//然后就是想从前面看
int minCostClimbingStairs(vector<int>& cost) {
	int min_sum = 0;
	if (cost.size() == 0)
		return min_sum;
	for (int i = cost.size(); i > 0;)
	{
		if (i == 1)
		{
			return min_sum;
		}
		else
		{
			min_sum += min(cost[i - 1], cost[i - 2]);
			if (cost[i - 2] == min(cost[i - 1], cost[i - 2]))
			{
				i-=2;
			}
			else
				i -- ;
		}
	}
	return min_sum;
}

int main()
{
	vector<int> n = { 0,2,2,1};
	cout << minCostClimbingStairs(n);
	return 0;
}

//这是综合了前面后面的，但是还是错的，虽然预料到了，但是还是难受

int minCostClimbingStairs(vector<int>& cost) {
	int min_sum = 0;
	if (cost.size() == 0)
		return min_sum;
	for (int i = 0; i < cost.size();)
	{
		if (i!=cost.size()-1) 
		{
			if (cost[i+1]<=cost[i])
			{
				min_sum += cost[i + 1];
				i += 2;
			}
			else
			{
				min_sum += cost[i];
				i++;
			}
		}
		else
		{
			return min_sum;
		}
	}
	int minsum = 0;
	for (int i = cost.size(); i > 0;)
{
	if (i == 1)
	{
		return minsum;
	}
	else
	{
		minsum += min(cost[i - 1], cost[i - 2]);
		if (cost[i - 2] == min(cost[i - 1], cost[i - 2]))
		{
			i-=2;
		}
		else
			i -- ;
	}
}
	return min(minsum,min_sum);
}

这才是动态规划，上面的两个不知道是啥子

class Solution {
public:
	int minCostClimbingStairs(vector<int>& cost) {
		int min_sum = 0;
		if (cost.size() == 0)
			return min_sum;
		for (int i = 2; i < cost.size(); ++i)
		{
                        //到达这一步的最小的花费
			cost[i] += min(cost[i - 1], cost[i - 2]);
		}
		return min(cost[cost.size() - 1], cost[cost.size() - 2]);
	}
};

//但是时间仅打败了16%？？？？
//都什么神仙
//好像是因为我频繁的调用cost.size()
//下面这个是4ms的神仙题解
class Solution {
public:
	int minCostClimbingStairs(vector<int>& cost) {
		int n = cost.size();
		vector<int> p(n, 0);
		p[n - 1] = cost[n - 1];
		p[n - 2] = cost[n - 2];
		for (int i = n - 3; i >= 0; --i)
		{
			p[i] = cost[i] + min(p[i + 1], p[i + 2]);
		}

		return min(p[0], p[1]);
	}
};