斐波那契数列及优化

由来

1202 年，生于意大利比萨的数学家 莱昂纳多·斐波那契 完成了他的传世名著《算盘书》，书中对一个有趣的 “兔子繁殖问题” 进行了研究，斐波那契数列便由此而来。

兔子繁殖问题实际上是 斐波那契 提出的一个数学模型：

• 假定一对大兔子一年生一对小兔
• 一对小兔子一年后长大成为一对大兔子
• 且所有的兔子都长生不死
• 那么这些兔子是按照什么样的规律繁殖的呢？
• 第一年，
• • 只有一对小兔子, f(1) = 1
• 第二年，
• • 这对小兔子长大成为一对大兔子
  • 兔子的对数还是 1, f(2) = 1
• 第三年，
• • 大兔子生出一对小兔子
  • 兔子的对数变为 2, f(3) = 2
• 第四年，
• • 大兔子又生出一对小兔子
  • 原来的一对小兔子长大成为一对大兔子
  • 兔子的对数变为 3, f(4) = 3

如果把第 n 年的兔子对数记为 Fn，则：

• F1＝F2＝1，且对 n ≥ 3，有 Fn＝Fn-1＋Fn-2

由于这个数列是由 斐波那契 首先加以研究的，后人就将其称为 斐波那契数列

斐波那契数列数学模型

代码实现

1. 暴力递归

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

   通过递归树可以发现递归效率低下的原因：
   

• 这个递归树怎么理解？就是说想要计算原问题 f(20)，我就得先计算出子问题 f(19) 和 f(18)，然后要计算 f(19)，我就要先算出子问题 f(18) 和 f(17)，以此类推。最后遇到 f(1) 或者 f(2) 的时候，结果已知，就能直接返回结果，递归树不再向下生长了
  递归算法的时间复杂度怎么计算？子问题个数乘以解决一个子问题需要的时间。
  子问题个数，即递归树中节点的总数。显然二叉树节点总数为指数级别，所以子问题个数为 O(2^n)。
  解决一个子问题的时间，在本算法中，没有循环，只有 f(n - 1) + f(n - 2) 一个加法操作，时间为 O(1)。
  所以，这个算法的时间复杂度为 O(2^n)，指数级别，爆炸。
  观察递归树，很明显发现了算法低效的原因：存在大量重复计算，比如 f(18) 被计算了两次，而且你可以看到，以 f(18) 为根的这个递归树体量巨大，多算一遍，会耗费巨大的时间。更何况，还不止 f(18) 这一个节点被重复计算，所以这个算法及其低效。

2. 带备忘录的递归解法
   明确了问题，其实就已经把问题解决了一半。即然耗时的原因是重复计算，那么我们可以造一个「备忘录」，每次算出某个子问题的答案后别急着返回，先记到「备忘录」里再返回；每次遇到一个子问题先去「备忘录」里查一查，如果发现之前已经解决过这个问题了，直接把答案拿出来用，不要再耗时去计算了。

   一般使用一个数组充当这个「备忘录」，当然你也可以使用哈希表（字典），思想都是一样的。

   public static int fib(int n) {
       if (n < 0) {
           return 0;
       }
       int[] arr = new int[n + 1];
       return getHelper(arr, n);
   }
   
   private static int getHelper(int[] arr, int n) {
       if (n == 0) {
           return 0;
       } else if (n == 1) {
           return 1;
       }
   
       // 如果f(n)已经计算过，无需再次计算，直接返回
       if (arr[n] != 0) {
           return arr[n];
       }
   
       arr[n] = getHelper(arr, n - 1) + getHelper(arr, n - 2);
       return arr[n];
   }
   

   现在，画出递归树，你就知道「备忘录」到底做了什么。
   
   实际上，带「备忘录」的递归算法，把一棵存在巨量冗余的递归树通过「剪枝」，改造成了一幅不存在冗余的递归图，极大减少了子问题（即递归图中节点）的个数。

此时 递归算法的时间复杂度怎么算？子问题个数乘以解决一个子问题需要的时间。

子问题个数，即图中节点的总数，由于本算法不存在冗余计算，子问题就是 f(1), f(2), f(3) … f(20)，数量和输入规模 n = 20 成正比，所以子问题个数为 O(n)。

解决一个子问题的时间，同上，没有什么循环，时间为 O(1)。

所以，本算法的时间复杂度是 O(n)。比起暴力算法，是降维打击。

至此，带备忘录的递归解法的效率已经和迭代的动态规划解法一样了。实际上，这种解法和迭代的动态规划已经差不多了，只不过这种方法叫做「自顶向下」，动态规划叫做「自底向上」。

啥叫「自顶向下」？注意我们刚才画的递归树（或者说图），是从上向下延伸，都是从一个规模较大的原问题比如说 f(20)，向下逐渐分解规模，直到 f(1) 和 f(2) 触底，然后逐层返回答案，这就叫「自顶向下」。

啥叫「自底向上」？反过来，我们直接从最底下，最简单，问题规模最小的 f(1) 和 f(2) 开始往上推，直到推到我们想要的答案 f(20)，这就是动态规划的思路，这也是为什么动态规划一般都脱离了递归，而是由循环迭代完成计算。

3. dp 数组的迭代解法

   有了上一步「备忘录」的启发，我们可以把这个「备忘录」独立出来成为一张表，就叫做 DP table 吧，在这张表上完成「自底向上」的推算岂不美哉！

	public static int fib(int N) {
    int[] dp = new int[N + 1];
    // base case
    dp[1] = dp[2] = 1;
    for (int i = 3; i <= N; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[N];
   }

画个图就很好理解了，而且你发现这个 DP table 特别像之前那个「剪枝」后的结果，只是反过来算而已。实际上，带备忘录的递归解法中的「备忘录」，最终完成后就是这个 DP table，所以说这两种解法其实是差不多的，大部分情况下，效率也基本相同。

4. 细节优化

   讲一个细节优化。细心的读者会发现，根据斐波那契数列的状态转移方程，当前状态只和之前的两个状态有关，其实并不需要那么长的一个 DP table 来存储所有的状态，只要想办法存储之前的两个状态就行了。所以，可以进一步优化，把空间复杂度降为 O(1)：

   public static int fib(int n) {
       if (n == 2 || n == 1) {
           return 1;
       }
   
       int prev = 1, curr = 1;
       for (int i = 3; i <= n; i++) {
           int sum = prev + curr;
           prev = curr;
           curr = sum;
       }
       return curr;
   }
   

涉及斐波那契数列的算法

1. 爬楼梯问题

   爬楼梯，一次只能爬一个台阶或两个台阶，问到第N层有几种爬法。f(n)即为斐波那契数列的定义，不过有一点小的差别就是：当n=0时，需要f(n) =1, 以满足 f(2) = 2，因为显然到第二层有两种爬法。

   public static int fib(int n) {
       if (n == 0 || n == 1) {
           return 1;
       }
   
       int prev = 1, curr = 1;
       for (int i = 2; i <= n; i++) {
           int sum = prev + curr;
           prev = curr;
           curr = sum;
       }
       return curr;
   }