牛客题解 | 最小花费爬楼梯

题目## 题目

题目链接

题目主要信息:

• 给定一个数组，其中每个元素代表该级楼梯向上爬需要支付的费用，下标从0开始
• 一旦支付费用，可以任意选择爬一级或是二级
• 需要求爬到顶楼，即越过数组末尾元素所需要的最小花费
• 可以从下标为0或是1的台阶开始

举一反三：

学习完本题的思路你可以解决如下题目：

BM62.斐波那契数列

BM63.跳台阶

BM69.把数字翻译成字符串

方法：动态规划（推荐使用）

知识点：动态规划

动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果

思路：

题目同样考察斐波那契数列的动态规划实现，不同的是题目要求了最小的花费，因此我们将方案统计进行递推的时候只记录最小的开销方案即可。

具体做法：

• step 1：可以用一个数组记录每次爬到第i阶楼梯的最小花费，然后每增加一级台阶就转移一次状态，最终得到结果。
• step 2：（初始状态） 因为可以直接从第0级或是第1级台阶开始，因此这两级的花费都直接为0.
• step 3：（状态转移） 每次到一个台阶，只有两种情况，要么是它前一级台阶向上一步，要么是它前两级的台阶向上两步，因为在前面的台阶花费我们都得到了，因此每次更新最小值即可，转移方程为：$dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])$。

图示：

Java实现代码：

import java.util.*;
public class Solution {
    public int minCostClimbingStairs (int[] cost) {
        //dp[i]表示爬到第i阶楼梯需要的最小花费
        int[] dp = new int[cost.length + 1]; 
        for(int i = 2; i <= cost.length; i++)
            //每次选取最小的方案
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]); 
        return dp[cost.length];
    }
}

C++实现代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //dp[i]表示爬到第i阶楼梯需要的最小花费
        vector<int> dp(cost.size() + 1, 0); 
        for(int i = 2; i <= cost.size(); i++)
            //每次选取最小的方案
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]); 
        return dp[cost.size()];
    }
};

Python代码实现：

class Solution:
    def minCostClimbingStairs(self , cost: List[int]) -> int:
        #dp[i]表示爬到第i阶楼梯需要的最小花费
        dp = [0 for i in range(len(cost) + 1)] 
        for i in range(2, len(cost) + 1):
            #每次选取最小的方案
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]) 
        return dp[len(cost)]

复杂度分析：

• 时间复杂度：$O(n)$，其中$n$为给定的数组长度，遍历一次数组
• 空间复杂度：$O(n)$，辅助数组dp的空间

题目链接

#描述
这是一篇针对初学者的题解。共用三种方法解决。
知识点：数组，堆，快排
难度：二星

---

#题解
题目抽象：求给定数组的topK小问题。

##方法一：排序
直接排序，然后去前k小数据。

###代码

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> ret;
        if (k==0 || k&gt;input.size()) return ret;
        sort(input.begin(), input.end());
        return vector<int>({input.begin(), input.begin()+k});   
    }
};

时间复杂度：O(nlongn)
空间复杂度：O(1)

##方法二：堆排序
建立一个容量为k的大根堆的优先队列。遍历一遍元素，如果队列大小<k,就直接入队，否则，让当前元素与队顶元素相比，如果队顶元素大，则出队，将当前元素入队 ###代码 ```class solution { public: vector GetLeastNumbers_Solution(vector input, int k) {
vector ret;
if (k==0 || k > input.size()) return ret;
priority_queue<int, vector> pq;
for (const int val : input) {
if (pq.size() < k) {
pq.push(val);
}
else {
if (val < pq.top()) {
pq.pop();
pq.push(val);
}

        }
    }
    
    while (!pq.empty()) {
        ret.push_back(pq.top());
        pq.pop();
    }
    return ret;
}

};

时间复杂度：O(nlongk), 插入容量为k的大根堆时间复杂度为O(longk), 一共遍历n个元素
空间复杂度：O(k)


##方法三：快排思想
对数组[l, r]一次快排partition过程可得到，[l, p), p, [p+1, r)三个区间,[l,p)为小于等于p的值
[p+1,r)为大于等于p的值。
然后再判断p，利用二分法
1. 如果[l,p), p，也就是p+1个元素（因为下标从0开始），如果p+1 == k, 找到答案
2。 如果p+1 < k, 说明答案在[p+1, r)区间内，
3， 如果p+1 > k , 说明答案在[l, p)内

###代码

class Solution {
public:
int partition(vector &input, int l, int r) {
int pivot = input[r-1];
int i = l;
for (int j=l; j<r-1; ++j) { if (input[j] < pivot) swap(input[i++], input[j]); } swap(input[i], input[r-1]); return i; vector GetLeastNumbers_Solution(vector input, int k) {
vector ret;
if (k==0 || k > input.size()) return ret;
int l = 0, r = input.size();
while (l < r) {
int p = partition(input, l, r);
if (p+1 == k) {
return vector({input.begin(), input.begin()+k});
}
if (p+1 < k) {
l = p + 1;
}
else {
r = p;
}

    }
    return ret;
}

};

时间复杂度：平均时间复杂度为O(n),每次partition的大小为`n+n/2+n/4+... = 2n`,最坏时间复杂度为O(n^2), 因为每次partition都只减少一个元素
空间复杂度：O(1)</int></int></int></r-1;></int></int,></int></int></k,就直接入队，否则，让当前元素与队顶元素相比，如果队顶元素大，则出队，将当前元素入队></int></int></int></int>