[LeetCode] 509. 斐波那契数

Posted qiu_jiaqi

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[LeetCode] 509. 斐波那契数相关的知识,希望对你有一定的参考价值。

传送门:[LeetCode] 509. 斐波那契数

题目描述

斐波那契数,通常用 F(n) 表示,形成的序列称为斐波那契数列。该数列由 01 开始,后面的每一项数字都是前面两项数字的和。也就是:

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

给定 N,计算 F(N)

示例 1:

输入:2
输出:1
解释:F(2) = F(1) + F(0) = 1 + 0 = 1.

示例 2:

输入:3
输出:2
解释:F(3) = F(2) + F(1) = 1 + 1 = 2.

示例 3:

输入:4
输出:3
解释:F(4) = F(3) + F(2) = 2 + 1 = 3.

提示:

  • 0 ≤ N ≤ 30

分析与代码

  • 斐波那契数列,简单来说,就是除了前两个数字,每个数字等于前面两个数字之和。

解法一、递归

  • 递归法简单,但是存在大量重复计算,可以用记忆化进行优化。

代码:

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

解法二、记忆化递归

  • 记忆化是一种优化技术,主要用于加快计算机程序的速度,方法是存储昂贵的函数调用的结果,并在相同的输入再次出现时返回缓存的结果。
  • 我们在之前递归的基础上,在计算之前判断是否已计算过,在计算完之后,先不要直接返回结果,而应先以当前 N 为 key,结果为 value 保存到 HashMap 中。

代码:

class Solution {
    Map<Integer, Integer> map = new HashMap<>();

    public int fib(int N) {
        if (N <= 1) {
            return N;
        }
        if (map.containsKey(N)) {
            return map.get(N);
        }
        int result = fib(N - 1) + fib(N - 2);
        map.put(N, result);
        return result;
    }
}

解法三、动态规划

  • 记忆化数组是自顶向下的,动态规划就把这个数组自底向上的生成。

代码:

class Solution {
    public int fib(int N) {
        if (N <= 1) {
            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];
    }
}

解法四、优化动态规划

  • 要计算的状态只和前两个状态有关,只记录这两个状态,能进一步优化空间。

代码:

class Solution {
    public int fib(int N) {
        if (N <= 1) {
            return N;
        }
        int pre = 0, cur = 1;
        for (int i = 2; i <= N; i++) {
            int next = pre + cur;
            pre = cur;
            cur = next;
        }
        return cur;
    }
}

解法五、常规矩阵乘法

[ egin{matrix} left[ egin{matrix} 1 & 0 0 & 0 end{matrix} ight] left[ egin{matrix} 1 & 1 1 & 0 end{matrix} ight] = left[ egin{matrix} 1+0 & 1+0 0+0 & 0+0 end{matrix} ight] = left[ egin{matrix} 1 & 1 0 & 0 end{matrix} ight] end{matrix} ]

[ egin{matrix} left[ egin{matrix} 1 & 1 0 & 0 end{matrix} ight] left[ egin{matrix} 1 & 1 1 & 0 end{matrix} ight] = left[ egin{matrix} 1+1 & 1+0 0+0 & 0+0 end{matrix} ight] = left[ egin{matrix} 2 & 1 0 & 0 end{matrix} ight] end{matrix} ]

[ egin{matrix} left[ egin{matrix} F_n & F_{n-1} 0 & 0 end{matrix} ight] left[ egin{matrix} 1 & 1 1 & 0 end{matrix} ight] = left[ egin{matrix} F_n+F_{n-1} & F_n 0 & 0 end{matrix} ight] = left[ egin{matrix} F_{n+1} & F_n 0 & 0 end{matrix} ight] end{matrix} ]

  • 用矩阵的第一行记录两个数,再和(left[ egin{matrix} 1 & 1\\ 1 & 0 end{matrix} ight])相乘得出下一个矩阵。

代码:

class Solution {
    public int fib(int N) {
        if (N <= 1) {
            return N;
        }
        int[][] matrix = { { 1, 0 }, { 0, 0 } };
        int[][] func = { { 1, 1 }, { 1, 0 } };
        for (int i = 2; i <= N; i++) {
            matrix = multiply(matrix, func);
        }
        return matrix[0][0];
    }

    private int[][] multiply(int[][] a, int[][] b) {
        int[][] c = new int[2][2];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
            }
        }
        return c;
    }
}

解法六、优化矩阵乘法

  • 在上一个方法中,每次都是乘一个相同的矩阵;而同一数字多个相乘即幂运算,可以用二分法优化成快速幂,而矩阵也同样可以使用,先计算(M^{n/2}),然后在用矩阵相乘的公式即可。

    快速幂运算题目:[LeetCode] 50. Pow(x, n)

  • 矩阵的起始乘积不再是 1,而是单位矩阵(left[ egin{matrix} 1 & 0\\ 0 & 1 end{matrix} ight])

  • 在这题我们就要把矩阵初始为(left[ egin{matrix} 1 & 1\\ 1 & 0 end{matrix} ight]),即从F(2)开始,才可以使用,矩阵结构改为(left[ egin{matrix} F_n & F_{n-1}\\ F_{n-1} & F_{n-2} end{matrix} ight])。又因为下标 2 才是第一个,所以传入时参数需要减一。

代码:

class Solution {
    public int fib(int N) {
        if (N <= 1) {
            return N;
        }
        int[][] matrix = { { 1, 1 }, { 1, 0 } };
        int[][] result = pow(matrix, N - 1);
        return result[0][0];
    }

    private int[][] pow(int[][] matrix, int n) {
        int[][] result = { { 1, 0 }, { 0, 1 } };
        for (int i = n; i > 0; i /= 2) {
            if ((i & 1) != 0) {
                result = multiply(matrix, result);
            }
            matrix = multiply(matrix, matrix);
        }
        return result;
    }

    private int[][] multiply(int[][] a, int[][] b) {
        int[][] c = new int[2][2];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
            }
        }
        return c;
    }
}

解法七、斐波那契公式

[ F(n) = cfrac{((cfrac{1+sqrt[2]{5}}{2})^n-(cfrac{1-sqrt[2]{5}}{2})^n)}{sqrt[2]{5}} ]

代码:

class Solution {
    public int fib(int N) {
        double sqrt5 = Math.sqrt(5);
        return (int) ((Math.pow((1 + sqrt5) / 2, N) - Math.pow((1 - sqrt5) / 2, N)) / sqrt5);
    }
}

解法八、作弊

  • 呃,先用动态规划的方式,生成 dp 数组,输出一下前 30 个,然后直接用这 30 个数就好。
  • 题目说了 N 的范围。

代码:

class Solution {
    public int fib(int N) {
        int[] result = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765,10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040 };
        return result[N];
    }
}

小结

方法很多,从递归到记忆表,再到动态规划,再优化,还有矩阵乘法,还能用公式,还能作弊。


以上是关于[LeetCode] 509. 斐波那契数的主要内容,如果未能解决你的问题,请参考以下文章

Leetcode刷题Python509. 斐波那契数

509. 斐波那契数

509. 斐波那契数

⭐算法入门⭐《递推》简单02 —— LeetCode 509. 斐波那契数

509-斐波那契数

509. 斐波那契数