斐波那契数列

提出的问题

将一对兔子放养于四周都是围墙的院子里，假设每月每对兔子能生育一对小兔子，小兔子第二个月起又能生育一对，那么最初每对兔子在一年之内能繁育出多少对兔子（兔子不死）

模型的假设

1. 兔子只会因为生育而增加，不会减少

2. 每一对小兔子要第二个月才能生育，成年后每一月都可生育

3. 成对配对不考虑杂交等情况

数学模型

F(0) = 0, F(1) = 1

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

求解

编写fibonacci.m函数

function f=fib(n)
% FIBONACCI
% f=FIBONACCI(n)
f(1)=1;
f(2)=2;
for k=3:n
    f(k)=f(k-1)+f(k-2);
end


% f(5)
% ans =

%     1     2     3     5     8

编写fibnum.m函数

function f=fibnum(n)
%FIBNUM 斐波那契数
%FIBNUM(n) 生成第n个斐波那契数
if n<=1
    f=1;
else
    f=fibnum(n-1)+fibnum(n-2);
end


%fibnum(5)

%ans =

%    8

题目

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1

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

斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例

示例 1：

输入：n = 2

输出：1

示例 2：

输入：n = 5

输出：5

提示：

• 0 <= n <= 100

题解1:动态规划

ls=[]

ls[0]=0

ls[1]=1

i=2

while i<=n:

ls[i]=ls[n-1]+ls[n-2]

i+=1

return ls[n]

class Solution:
    def fib(self, n: int) -> int:
        mod=10**9+7
        ls=[]
        ls.append(0)
        ls.append(1)
        i=2
        while i<=n:
            tmp=(ls[i-1]+ls[i-2])%mod
            ls.append(tmp)
            i+=1
        return ls[n]

滚动数组思想将空间复杂度优化，n=5

i=2 p=0 q= 1 r=1

i=3 p=1 q=1 r=2

i=4 p=1 q=2 r=3

i=5 p=2 q=3 r=5

return

优化之后

class Solution:
    def fib(self, n: int) -> int:
        mod=10**9+7
        if n==1:
            return 1
        elif n==0:
            return 0
        i=2
        p=0
        q=0
        r=1
        while i<=n:
            p=q
            q=r
            r=(p+q)%mod
            if i==n:
                return r
            i+=1

题解2：矩阵快速幂

构建

则

令

快速幂算法原理：

们在计算一个数的多次幂时，可以先判断其幂次的奇偶性，然后：

• 如果幂次为偶直接 base(底数) 作平方，power(幂次) 除以2

• 如果幂次为奇则底数平方，幂次整除于2然后再多乘一次底数

且系统的位运算比普通运算的效率是高的

注意下面代码没有mod=10**9+7

class Solution {
    public int fib(int n) {
        //矩阵快速幂
        if (n < 2) {
            return n;
        }
        //定义乘积底数
        int[][] base = {{1, 1}, {1, 0}};
        //定义幂次
        int power = n - 1;
        int[][] ans = calc(base, power);
        //按照公式，返回的是两行一列矩阵的第一个数
        return ans[0][0];
    }

    //定义函数,求底数为 base 幂次为 power 的结果
    public int[][] calc(int[][] base, int power) {
        //定义变量，存储计算结果，此次定义为单位阵
        int[][] res = {{1, 0}, {0, 1}};

        //可以一直对幂次进行整除
        while (power > 0) {
            //1.若为奇数，需多乘一次 base
            //2.若power除到1，乘积后得到res
            //此处使用位运算在于效率高
            if ((power & 1) == 1) {
                res = mul(res, base);
            }
            //不管幂次是奇还是偶，整除的结果是一样的如 5/2 和 4/2
            //此处使用位运算在于效率高
            power = power >> 1;
            base = mul(base, base);
        }
        return res;
    }

    //定义函数,求二维矩阵：两矩阵 a, b 的乘积
    public int[][] mul(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;
    }
}