LeetCode之递归——递归的记忆化（斐波那契数、爬楼梯）

在递归中由于需要调用自身可能会导致一些重复的计算，函数的调用不仅需要时间，而且也会暂用栈上的空间。有时候如果调用的深度太深，还会导致无限循环的问题（实际上是深度太深，要长时间的调用，导致无法在预期的时间内返回）。要解决这个问题，可以使用“记忆化”的方式，将需要的数据缓存，以减少重复的计算。

斐波那契数

链接：斐波那契数
描述：

斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：F(0) = 0, F(1) = 1。F(N) = F(N - 1) + F(N - 2), 其中 N > 1.给定 N，计算 F(N)。假设0 ≤ N ≤ 30。

一般解法：

class Solution {
public:
    int fib(int N) {
        if (N == 0 || N == 1) return N;   
        return fib(N - 1) + fib(N - 2);
    }
};

带缓存的解法：

由于题目中N的长度是有限的，且每个斐波那契数都只占用一个INT的长度，因此最多只需要申请一个INT[31]长度的数组即可以缓存所有数据，代码如下：

class Solution {
public:
    int fib(int N) {
        static int  sCaches[31] = {0};
        if (sCaches[N] != 0 || N == 0) return sCaches[N];
        if(N == 1) {
            sCaches[1] = 1;
            return 1;
        }

        sCaches[N] = fib(N - 1) + fib(N - 2);      
        return sCaches[N];
    }
};

爬楼梯

链接：爬楼梯
描述：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。

分析：

假设有n(n >= 2)阶台阶总共有f(n)总方法，你可以选择先走一步，也可以选择先走两步，则f(n) = f(n - 1) + f(n - 2)。有了这个公式，递归的解法很容易给出。

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

代码很简单，但是如果n比较大的时候，会出现上面提到的执行超时的问题，原因还是递归调用时重复执行问题。解决的办法还是减少不必要的重复调用——利用缓存来解决问题。

class Solution {
public:
    
    int climbStairs(int n) {
        static vector<int> sCache = {1,2};
        if (sCache.size() >= n) return sCache[n - 1];
        sCache.push_back(climbStairs(n - 1) +  climbStairs(n - 2));
        return sCache[sCache.size() - 1];
    }
};

再看一下上面推导出来的公式，实际上和斐波那契数列一样。斐波那契除了用递归实现，更快速的实现是使用循环。

class Solution {
    public int climbStairs(int n) {
        if (n < 3) {
            return n;
        }
        int a = 1, b= 2;
        for(int i = 0; i < (n - 1) / 2; i ++) {
            a = a + b;
            b = b + a;
        }
        return n % 2 == 0 ? b : a;
    }
}