【LeetCode 509 】斐波那契数

题目描述

原题链接： LeetCode.0509 斐波那契数

解题思路

• 题目直接给出了公式， 朴素解法可以直接用\(O(n)\)复杂度求出答案， 可以看做是递归或动态规划的入门题；
• 这里重点作为模板题来介绍矩阵快速幂技巧， 讲一下\(O(log_2n)\)复杂度的解法：
  • 递推公式\(F(n)=F(n-1)+F(n-2)\)， 转换为矩阵形式为： \(\begin{pmatrix}F_{n-1} & F_{n-2}\end{pmatrix}*\begin{pmatrix}a_1 & a_2\\b_1 & b_2\end{pmatrix} = \begin{pmatrix}F_n & F_{n-1}\end{pmatrix}\)， 要想求得\(F_n\)就求得\(\begin{pmatrix}F_2&F_1\end{pmatrix}\)乘以\(\begin{pmatrix}a_1&a_2\\b_1&b_2\end{pmatrix}^{n-2}\)的结果。
  • 代入\(F_0=0, F_1=1, F_2=1, F_3=2\)可得方程组：
  \[\begin{cases} 1*a_1+0*b_1=1\\ 1*a_2+0*b_2=1\\ 1*a_1+1*b_1=2\\ 1*a_2+1*b_2=1 \end{cases} => \begin{cases} a_1=1\\ a_2=1\\ a_1+b_1=2\\ a_2+b_2=1 \end{cases} \]
  • 求得递推矩阵为： \(\begin{pmatrix}1&1\\1&0\end{pmatrix}\)。

解题代码

• 朴素动态规划版本：

    /**
     * 最朴素动态规划
     * 执行用时： 0 ms , 在所有 Java 提交中击败了 100.00% 的用户
     * 内存消耗： 38.1 MB , 在所有 Java 提交中击败了 70.11% 的用户
     */
    public int fib(int n) {
        if (n < 2) {
            return n;
        }
        // 定义数组是为了直观, 也可以用三个变量滚动求解
        int[] dp = new int[n + 1];
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
  

• 基于递推矩阵的快速幂解法：

    /**
     * 矩阵快速幂技巧
     * 执行用时： 0 ms , 在所有 Java 提交中击败了 100.00% 的用户
     * 内存消耗： 39.39 MB , 在所有 Java 提交中击败了 35.84% 的用户
     */
    public int fib(int n) {
        if (n < 2) {
            return n;
        }
        int[][] transfer = {{1, 1}, {1, 0}};
        int[][] start = {{1,1}};
        int[][] res = matrixMultiply(start, matrixPower(transfer, n - 2));
        return res[0][0];
    }
  
    private int[][] matrixPower(int[][] base, int n) {
        int row = base.length;
        int[][] res = new int[row][row];
        for (int i = 0; i < row; i++) {
            res[i][i] = 1;
        }
        while (n > 0) {
            if ((n & 1) == 1) {
                res = matrixMultiply(res, base);
            }
            base = matrixMultiply(base, base);
            n >>= 1;
        }
        return res;
    }
  
    private int[][] matrixMultiply(int[][] a, int[][] b) {
        int m = a.length, n = b[0].length;
        int k = b.length;
        int[][] res = new int[m][n];
        for (int aRow = 0; aRow < m; aRow++) {
            for (int bCol = 0; bCol < n; bCol++) {
                for (int i = 0; i < k; i++) {
                    res[aRow][bCol] += a[aRow][i] * b[i][bCol];
                }
            }
        }
        return res;
    }