剑指offer【斐波那契数列】

leetcode原题地址
斐波那契数列常作为语言入门的例子。
一般会给出递归解法

递归解法

如

//时间复杂度 O(2^n)
//空间复杂度 O(n)
class Solution {
public:
	const int MOD = (int)1e9+7;
    int fib(int n) {
        if(n == 0)  return 0;
        if(n <= 2)  return 1;
        return fib(n-1)%MOD + fib(n-2)%MOD;
    }
};

可以采取记录值的方式 避免重复计算

class Solution {
public:
	const int MOD = (int)1e9+7;
    int fib(int n) {
        return fib(1,1,n);
    }
    int fib(int x, int y, int n) {
        if(n == 0)  return 0;//边界条件
        if(n <= 2)  return 1;
        
        if(n == 3) {//计算到底 因为x y是 从第1 2个开始算起的
            return (x%MOD + y%MOD)%MOD;
        }
        return fib(y%MOD, (x + y)%MOD, n-1);
    }
};

循环

上述程序显然可以改成如下循环程序

class Solution {
public:
	const int MOD = (int)1e9+7;
    int fib(int n) {
        if(n == 0) return 0;
        if(n <= 2) return 1;
        
        int x = 1, y = 1, z;// x 代表fib(1) y 代表fib(2) 自底向上计算 z是临时变量
        
        for(int i = 2; i < n; ++i) {
        	z = y%MOD;
        	y += x%MOD;
        	x = y%MOD;
        }
        return y%MOD;
    }
};

当然如果要是嫌z多余 可以如此做

class Solution {
public:
	const int MOD = (int)1e9+7;
    int fib(int n) {
       int res = 0, pre = 1;// fib(0) fib(1)
        while (n--)
        {
            res += pre;//此处正确性不是那么显然 可以自己试试前几个数
            pre = res - pre;
            res %= MOD;
        }
        return res;
    }
};

但是这还不是最好的办法
因为数学上有

$$\left[\begin{array}{c}F(n+1)\\ F(n)\end{array}\right]={\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]}^n\left[\begin{array}{c}F(1)\\ F(0)\end{array}\right]$$
即将原问题变成了一个求解矩阵幂的问题
求解幂有快速幂的算法
只不过相乘的元素是矩阵罢了
因此给出如下代码

class Solution {
public:
    const int MOD = (int)1e9+7;

    int fib(int n) {
        if (n < 2) {
            return n;
        }
        vector<vector<int>> q{{1, 1}, {1, 0}};
        vector<vector<int>> res = pow(q, n - 1);
        return res[0][0];
    }

    vector<vector<int>> pow(vector<vector<int>>& a, int n) {//求解矩阵a的n次幂
        vector<vector<int>> ret{{1, 0}, {0, 1}};//单位阵
        while (n > 0) {
            if (n & 1) {//奇数 额外乘一个
                ret = multiply(ret, a);
            }
            n >>= 1;//n除以2 缩小1倍
            a = multiply(a, a);//a变成2倍
        }
        return ret;
    }

	//矩阵a 乘以 b 返回一个矩阵
    vector<vector<int>> multiply(vector<vector<int>>& a, vector<vector<int>>& b) {
        vector<vector<int>> c{{0, 0}, {0, 0}};
        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]) % MOD;
            }
        }
        return c;
    }
};