【LeetCode 509 】斐波那契数

题目描述

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

解题思路

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

解题代码

• 朴素动态规划版本：

    /**
     * 最朴素动态规划
     * 执行用时： 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;
    }