Leetcode_70. 爬楼梯

题目

假设你正在爬楼梯。需要 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 阶

普通递归解法（失败）

使用了递归的方法，由于超出时间限制，导致失败。代码如下，类似于斐波那契数的结构。

class Solution {
    public int climbStairs(int n) {
        return f(n);
    }
    public int f(int n){
        if(n==1) return 1;
        else if(n==2) return 2;
        else {
            return f(n-1)+f(n-2);
        }
    }
}

改进的动态规划的递归写法

使用了整数数组来保存中间结果，代价比普通递归小很多，但空间复杂度较差。

执行用时 :0 ms
内存消耗 :33 MB

写法如下：

class Solution {
     public int climbStairs(int n) {
        int []r=new int[n+1];
        for(int i=0;i<=n;i++){
            r[i]=-1;
        }
        return climb(n,r);
    }

 public int climb(int n,int []r){
        if(n==0) return 0;
        else if(n==1) return 1;
        else if(n==2) return 2;
     	else if(r[n]>0) return r[n];
        else {
            int q=-1;
            for(int i=1;i<=n;i++)
                q=Math.max(q,climb(n-1, r)+climb(n-2, r));
            r[n]=q;
        }
        
        return r[n];
    }
}

时间复杂度：Ｏ(n),单循环

空间复杂度：Ｏ(n)，int[n+1]的空间

自底向上的动态规划

执行用时 :１ ms
内存消耗 :33 MB

public int climbStairs(int n) {
        int[] r=new int[n+1];
        r[0]=0;
        r[1]=1;
        if(n>=2){
            r[2]=2;
            int q=-1;
            for(int i=3;i<=n;i++){
                q=Math.max(q,r[i-1]+r[i-2]);
                r[i]=q;
            }
        }
        return r[n];
    }

时间复杂度：Ｏ(n) 单循环到ns

空间复杂度：Ｏ(n)　n+1个int大小的空间

自底向上滚动数组的动态规划

public int climbStairs(int n) {
        int[] r=new int[3];
        r[0]=0;
        r[1]=1;
        r[2]=2;
        if(n==1||n==2) return r[n];
        else{
            for(int i=2;i<n;i++){
                r[0]=r[1];
                r[1]=r[2];
                r[2]=r[0]+r[1];
            }
            return r[2];
        }
    }

时间复杂度：O(n)，单循环到 n，需要计算第 n 个斐波那契数。

空间复杂度：O(1)，使用常量级空间。

​