版权声明：此文章为许诗宇所写，如需转载，请写下转载文章的地址 https://blog.csdn.net/xushiyu1996818/article/details/82906181
题目及测试
package pid070;
/*爬楼梯
假设你正在爬楼梯。需要 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 阶
*/
public class main {
public static void main(String[] args) {
int[] testTable = {2,10,30};
for (int i=0;i<testTable.length;i++) {
test(testTable[i]);
}
}
private static void test(int ito) {
Solution solution = new Solution();
int rtn;
long begin = System.currentTimeMillis();
System.out.println(ito);
rtn = solution.climbStairs(ito);//执行程序
long end = System.currentTimeMillis();
System.out.println(rtn);
System.out.println();
System.out.println("耗时：" + (end - begin) + "ms");
System.out.println("-------------------");
}
}
解法1（失败，超过时间限制）
简单递归的方法，速度是o(2^n),速度很慢
空间o(1)
//简单递归
public int climbStairs(int n) {
if(n<=0){
return 0;
}
if(n==1){
return 1;
}
if(n==2){
return 2;
}
return climbStairs(n-1)+climbStairs(n-2);
}
解法2（成功，3ms，很快）
动态规划，也是备忘录算法，用一个hashmap存放之前算过的值
速度o(n),空间o(n)
public int climbStairs(int n) {
if(n<=0){
return 0;
}
if(n==1){
return 1;
}
if(n==2){
return 2;
}
HashMap<Integer, Integer> map=new HashMap<Integer, Integer>();
return climbStair(n-1,map)+climbStair(n-2,map);
}
public int climbStair(int n,HashMap<Integer,Integer> map) {
if(n<=0){
return 0;
}
if(n==1){
return 1;
}
if(n==2){
return 2;
}
if(map.containsKey(n)){
return map.get(n);
}
else{
int val=climbStair(n-1,map)+climbStair(n-2,map);
map.put(n, val);
return val;
}
}
方法3（成功，3ms，极快）
速度o（n），空间o（c）
动态规划的算法，简洁的自底向上，只保留运算下一个所需要的数字，其余的不要，所以空间固定
public int climbStairs(int n) {
if(n<=0){
return 0;
}
if(n==1){
return 1;
}
if(n==2){
return 2;
}
int first=1;
int second=2;
int third=0;
for(int i=3;i<=n;i++){
third=first+second;
first=second;
second=third;
}
return third;
}