跳台阶

题目描述

假设你正在爬楼梯。需要 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=5，当我们迈出第一步的时候，有两种解法，走1个台阶就剩下了4个台阶；走2个台阶就剩下了3个台阶。那么我们就可以将剩下的4个台阶继续按照上述的方法分解。
 所以n=5时，有两种情况，分解成子问题，走n=4和n=3的两种情况之和。所以可以画出图解为：

 但是如果按照上述的想法，计算上述题的时候，就是出现好多重叠的子问题。但是这样的话会出现时间复杂度过大，不是一个好的算法。

解法一：暴力解法

class Solution {
    public int climbStairs(int n) {
        // 1. 当n=1时，有一种解法：爬1个台阶
        if(n == 1)
            return 1;
        if(n == 2)
            return 2;
        
        // 当n=5时，有两种解法。
        // 先爬1个，计算climb(4)
        // 先爬2个，计算climb(3)
        return climbStairs(n-1) + climbStairs(n-2);
    }
}

 这个当我们运行的时候，就会发现当n=44时，该代码就超出的时间限制，因为这样的递归做法计算了好多的重叠子问题（当然不同的电脑可能n的最大取值不同）。

解法二：自顶向下备忘录法（记忆记录法）

就是使用一个数组，将计算过得n记录下来，当下一次要使用的时候，去查表，便可知道。这里就需要一个数组，去保存，这就是使用空间去换取时间的方法。

class Solution {
    public int climbStairs(int n) {
        int[] array = new int[n + 1];
        // 先初始化数组
        for(int i = 0; i < array.length; i++){
            array[i] = -1; // 作为标记，以此来判断是否已经计算过了
        }
        return climb(n, array);
    }
    private int climb(int i, int[] arr){
        if(i <= 1)
            arr[i] = 1;
        if(i == 2)
            arr[i] = 2;
        // 如果数组中的值为-1，没有计算，需要计算
        if(arr[i] == -1)
            arr[i] = climb(i-1, arr) + climb(i-2, arr);
        
        // 走到这里i个台阶的值已经计算过了直接返回
        return arr[i];
    }
}

解法三：自底向上的动态规划法

 我们要计算n=5的值，因为本类型题，是下一个答案依靠于上两个答案，那我只需要从1开始计算到5就行了呀！
 这就是先求解子问题，再由子问题求解父问题。
所以代码有了如下的改变，还是开辟数组保存前面子问题的解。

class Solution {
    public int climbStairs(int n) {
        if(n <= 0)
            return 0;
        if(n == 1)
            return 1;
        if(n == 2)
            return 2;
        int[] arr = new int[n+1];
        
        arr[1] = 1;
        arr[2] = 2;
        
        for(int i = 3; i <= n; i++){
            arr[i] = arr[i-1] + arr[i-2];
        }
        
        return arr[n];
    }
}

解法四：自底向上解法的优化版

 通过上面的解法我们可以知道，要求解父问题，我们可以先求解子问题，然后再由子问题求解父问题。所以我们在求解5的时候，只需要知道4和3就行了，不需要知道2、1，所以当我们消耗数组空间去存1、2时是不需要的步骤，所以我们会想到只用两个int型的变量去存放父问题的两个子问题的解就行了，所以上面的解法优化成了下面的解法：

class Solution {
    public int climbStairs(int n) {
        if(n == 1)
            return 1;
        if(n == 2)
            return 2;
        
        int num_i_2 = 1;
        int num_i_1 = 2;
        int num_i = 0;
        
        for(int i = 3; i <= n; i++){
            num_i = num_i_1 + num_i_2;
            num_i_2 = num_i_1;
            num_i_1 = num_i;
        }
        return num_i;
    }
}

我们会发现，这种解法与斐波那契数列求解第n项的代码一样。