- 难度: 简单
- 通过率: 42.7%
- 题目链接:力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台
题目描述
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?
注意:给定 n 是一个正整数。
示例 1:
输入: 2 输出: 2 解释: 有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶
示例 2:
输入: 3 输出: 3 解释: 有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶
解法一 暴力解法
用递归的思路想一下,要求 n 层的台阶的走法,由于一次走 1 或 2 个台阶,所以上到第 n 个台阶之前,一定是停留在第 n - 1 个台阶上,或者 n - 2 个台阶上。所以如果用 f ( n ) 代表 n 个台阶的走法。那么,
f ( n ) = f ( n - 1) + f ( n - 2 )。
f ( 1 ) = 1,f ( 2 ) = 2 。
发现个神奇的事情,这就是斐波那契数列(Fibonacci sequence)。
直接暴力一点,利用递归写出来。
public int climbStairs(int n) {
return climbStairsN(n);
}
private int climbStairsN(int n) {
if (n == 1) {
return 1;
}
if (n == 2) {
return 2;
}
return climbStairsN(n - 1) + climbStairsN(n - 2);
}
时间复杂度:是一个树状图,�(2�)O(2n)。
空间复杂度:
解法二 暴力解法优化
解法一很慢,leetcode 上报了超时,原因就是先求 climbStairsN ( n - 1 ),然后求 climbStairsN ( n - 2 ) 的时候,其实很多解已经有了,但是它依旧进入了递归。优化方法就是把求出的解都存起来,后边求的时候直接使用,不用再进入递归了。叫做 memoization 技术。
public int climbStairs(int n) {
return climbStairsN(n, new HashMap<Integer, Integer>());
}
private int climbStairsN(int n, HashMap<Integer, Integer> hashMap) {
if (n == 1) {
return 1;
}
if (n == 2) {
return 2;
}
int n1 = 0;
if (!hashMap.containsKey(n - 1)) {
n1 = climbStairsN(n - 1, hashMap);
hashMap.put(n - 1, n1);
} else {
n1 = hashMap.get(n - 1);
}
int n2 = 0;
if (!hashMap.containsKey(n - 2)) {
n2 = climbStairsN(n - 2, hashMap);
hashMap.put(n - 2, n1);
} else {
n2 = hashMap.get(n - 2);
}
return n1 + n2;
}
时间复杂度:
空间复杂度:
当然由于 key 都是整数,我们完全可以用一个数组去存储,不需要 Hash。
public int climbStairs(int n) {
int memo[] = new int[n + 1];
return climbStairsN(n, memo);
}
private int climbStairsN(int n, int[] memo) {
if (n == 1) {
return 1;
}
if (n == 2) {
return 2;
}
int n1 = 0;
//数组的默认值是 0
if (memo[n - 1] == 0) {
n1 = climbStairsN(n - 1, memo);
memo[n - 1] = n1;
} else {
n1 = memo[n - 1];
}
int n2 = 0;
if (memo[n - 2] == 0) {
n2 = climbStairsN(n - 2, memo);
memo[n - 2] = n2;
} else {
n2 = memo[n - 2];
}
return n1 + n2;
}
解法三 迭代
当然递归可以解决,我们可以直接迭代,省去递归压栈的过程。初始值 f ( 1 ) 和 f ( 2 ),然后可以求出 f ( 3 ),然后求出 f ( 4 ) ... 直到 f ( n ),一个循环就够了。其实就是动态规划的思想了。
public int climbStairs(int n) {
int n1 = 1;
int n2 = 2;
if (n == 1) {
return n1;
}
if (n == 2) {
return n2;
}
//n1、n2 都后移一个位置
for (int i = 3; i <= n; i++) {
int temp = n2;
n2 = n1 + n2;
n1 = temp;
}
return n2;
}
时间复杂度:O(n)。
空间复杂度:O(1)。