第70题 爬楼梯+剑指Offer 10 斐波那契序列

70. 题目描述：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

Level	AC rate
Easy	54.0%

70. 题目解析：

从简单的情况考虑，当只有一个楼梯的时候，只有一个上法，当有两个楼梯的时候，这时候有两种上法：1. 先上一梯再上一梯，2. 直接上两梯。当楼梯的数量大于等于三的时候，我们可以这样想，假设我们设定当楼梯数量为n时有f(n)种方法爬到楼顶，最后一步只有两种情况，上一梯或者上两梯，所以就能够得到对应的递推关系式：f(n) = f(n-1)+f(n-2)。即上n阶楼梯的方法等于上n-1阶楼梯和上n-2阶楼梯的方法总和。代码如下：

// 递归
class Solution {
    public int climbStairs(int n) {
        if(n==1)return 1;
        if(n==2)return 2;
        return climbStairs(n-1)+climbStairs(n-2);
    }
}

O(N^2)的时间复杂度，指数暴涨导致了超时，这时候我们发现，在递归过程中存在大量的重复计算，比如计算f(n-1)的时候已经计算过一遍f(n-2)了，这时候我们可以将其通过哈希表存储起来，等到后面需要计算f(n-2)时，直接从哈希表中取数值即可。代码如下：

// 哈希表存储
class Solution {
    HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
    public int climbStairs(int n) {
        if(n==1)return 1;
        if(n==2)return 2;
        if(map.containsKey(n)){
            return map.get(n);
        }
        else{
            int r = climbStairs(n-1)+climbStairs(n-2);
            map.put(n,r);
            return r;
        }
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：38.5 MB, 在所有 Java 提交中击败了18.39%的用户

通过一步简单的存储调用操作将时间复杂度从O(N^2)降到了O(N)。当这导致了O(N)的空间复杂度，那么有没有一种方法可以，不使用额外的空间来达到想要的效果呢，这个时候我们发现了递推公式，f(3) = f(1) +f (2)，f(4) = f(3) + f(2)。我们只需要用到两个数来存储，然后不断循环更新可得到f(n)的结果。代码如下：

// 循环代替递归进行求解
class Solution {
    public int climbStairs(int n) {
        if(n==1)return 1;
        if(n==2)return 2;
        int ppre = 1;
        int pre = 2;
        int ans = pre+ppre;
        for(int i = 3; i<n; i++){
            ppre = pre;
            pre = ans;
            ans = pre+ppre;
        }
        return ans;
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：38 MB, 在所有 Java 提交中击败了90.26%的用户

---

剑指Offer 10. 题目描述：

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

F(0) = 0,   F(1) = 1

F(N) = F(N - 1) + F(N - 2), 其中 N > 1.

斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，返回 1。

Level	AC rate
Easy	36.1%

剑指Offer 10. 题目解析：

和爬楼梯一模一样，这里同样给出三种思路解法：1. 递归，2. 哈希表存储调用，3. 循环更新。代码如下：

// 递归
// class Solution {
//     public int fib(int n) {
//         if(n==0)return 0;
//         if(n==1)return 1;
//         int result = fib(n-1)+fib(n-2);
//         return result%(1e9+7);
//     }
// }

// Hash表存储
// class Solution {
//     HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
//     public int fib(int n) {
//         if(n==0)return 0;
//         if(n==1)return 1;
//         if(map.containsKey(n)){
//             return map.get(n)%(int)(1e9+7);
//         }
//         else{
//             int result = fib(n-1)+fib(n-2);
//             map.put(n,result);
//             return result%(int)(1e9+7);
//         }
//     }
// }

//循环
class Solution {
    public int fib(int n) {
        if(n==0)return 0;
        if(n==1)return 1;
        int pre = 1;
        int ppre = 0;
        int ans = pre+ppre;
        for(int i = 2; i<n ; i++){
            ppre = pre;
            pre = ans;
            ans = (pre+ppre)%(int)(1e9+7);
        }
        return ans;
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：38.3 MB, 在所有 Java 提交中击败了49.76%的用户