爬楼梯
根据题目,可以知道,通过n阶到楼顶的方法数是到n-1阶的方法数加上到n-2阶的方法数。
很容易想到递归的方法,以及斐波那切数列:f(n)=f(n-1)+f(n-2)。
递归:
class Solution {
public:
int climbStairs(int n) {
if(n==2)
return 2;
if(n==1)
return 1;
return climbStairs(n-2)+climbStairs(n-1);
}
};
直接使用递归的方法,提交显示超时,显然这种方法会有很多重复计算,时间复杂度达到O(2n)。
记忆递归:
这是官方答案中记忆递归的方法,可以减少重复计算。
这种方法将已经计算出来的爬n级台阶的方法存放在数组memo里
class Solution {
public:
int climbStairs(int n) {
int *memo= new int[n+1];
return climbStairsMemo(n,memo);
}
public:
int climbStairsMemo(int n,int memo[]){
if(memo[n]>0) //这个位置大于0说明曾经计算过,结果存在memo[n]里
return memo[n];
if(n==1)
memo[n] = 1 ;
else if(n==2)
memo[n] = 2 ;
else memo[n]=climbStairsMemo(n-1,memo)+climbStairsMemo(n-2,memo) ; //递归调用自身
return memo[n];
}
};
在这里我声明这个数组的时候,用 int memo[ ] 报错了,后来改成 int *memo 就没问题了。
滚动数组
因为n的结果由n-1和n-2处得到,我们可以通过维护几个常量,把空间复杂度优化成O(1)。
class Solution {
public:
int climbStairs(int n) {
int p = 0, q = 0, r = 1;
for(int i = 1 ;i <= n; i++){
p = q;
q = r;
r = p + q ;
}
return r;
}
};
循环执行n次,时间复杂度为O(n)。
矩阵快速幂
这个的代码部分还没有实现
最小花费爬楼梯
这题的翻译有些不清楚,原文是:Once you pay the cost, you can either climb one or two steps.
与简单的爬楼梯相似,这题也存在一个递归关系,就是f[i] = cost[i] + min(cost[i-1],cost[i-2]) 。
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
int c1 = cost[0];
int c2 = cost[1];
int N = cost.size();
for (int i = 2; i < N; ++i) {
int c3 = min(c1, c2) + cost[i];
c1 = c2;
c2 = c3;
}
return min(c1, c2); //到达顶部之前到最后一个或者倒数第二个都可以
}
};