斐波那契数列的时间复杂度详释与改进方法

二阶常系数线性差分方程

齐次差分方程

二阶常系数线性差分方程的一般形式为：
$y_{n+2}+ay_{n+1}+by_n=f(n)， n=0， 1， 2，....(1-1)$
$其中a，b为已知常数，且b\not=0，f(n)为已知函数。$
$方程(1-1)的对应齐次方程为：$
$y_{n+2}+ay_{n+1}+by_n=0................................(1-2)$
$设y_n=\lambda^n为方程(1-2)的特解，其中\lambda为非零待定系数，代入方程后，有$
$\lambda^n(\lambda^2+a\lambda+b)=0$
$因\lambda\not=0，故函数y_n=\lambda^n是方程(1-2)的特解的充分必要条件是\lambda满足方程$
$\lambda^2+a\lambda+b=0............................................(1-3)$
方程(1-3)成为方程(1-1)或(1-2)的特征方程，特征方程的解称为特征根或特征值。
根据二次代数方程(1-3)解的三种情况，可以仿照二阶常系数齐次线性微分方程，分别给出方程(1-1)的通解。
1.1特征方程有两个相异实根
$即当判别式\Delta=a^2-4b>0时，方程(1-2)有两个相异实根$
$\lambda_1=\frac{1}{2}(-a-\sqrt\Delta)，\lambda_2=\frac{1}{2}(-a+\sqrt\Delta)....(1-4)$
于是方程(1-2)有两个特解
$y_n{_1}=\lambda_1^n，y_n{_2}=\lambda_2^n$
$且由\frac{y_n{_1}}{y_n{_2}}=(\frac{\lambda_1}{\lambda_2})^n\not=常数，知y_n{_1}与y_n{_2}线性无关，从而得到方程(1-2)的通解$
$y_n=C_1\lambda_1^n+C_2\lambda_2^n，其中\lambda_1， \lambda_2由式(1-4)给出，C_1，C_2为任意常数。$
1.2特征方程有二重根
$即当判别式\Delta=a^2-4b=0时，方程(1-3)有二重根\lambda_1=\lambda_2=-\frac{1}{2}a，于是方程(1-2)有一个特解y_n{_1}=(-\frac{1}{2}a)^n，可验证方程(1-2)有另一特解y_n{_2}=n(-\frac{1}{2}a)^n$
(注：系数n可参照二阶常系数线性齐次微分方程的通项证明求得)
$且由\frac{y_n{_1}}{y_n{_2}}=\frac{1}{n}\not=常数，知y_n{_1}与y_n{_2}线性无关，从而得到方程(10-2)的通解$
$y_n=(C_1+C_2n)(-\frac{1}{2}a)^n，其中C_1，C_2为任意常数。$
1.3特征方程有两个共轭复根
$即当判别式\Delta=a^2-4b<0时，方程(1-3)有两个共轭复根$
$\lambda_1=\frac{1}{2}(-a+i\sqrt{-\Delta})，\lambda_2=\frac{1}{2}(-a-i\sqrt{-\Delta})$
通过直接验证可知，方程(1-2)有两个特解
$y_n{_1}=r^ncos\beta n，y_n{_2}=r^nsin\beta n$
$其中r=\sqrt{(-\frac{a}{2})^2+(\frac{\sqrt{-\Delta}}{2})^2}=\sqrt{b}........(详见其他参考)$

斐波那契数列的递推式及通项公式

$递推式： y_{n+2}=\begin {cases} 0, & n=0 \\ 1, & n=1……..(1-5)\\ y_{n+1}+y_n,& n>1 \end {cases}$
$由式(1-2)可知，y_{n+2}-y_{n+1}-y_n=0............(1-6)$
其中a=-1，b=-1
$令y_n=\lambda^n，式(1-6)化成\lambda^n(\lambda^2-\lambda-1)=0，解得$
$y_n=C_1(\frac{1+\sqrt{5}}{2})^n+C_2(\frac{1-\sqrt{5}}{2})^n，由y_0=0，y_1=1可知$
$C_1=\frac{1}{\sqrt5}，C_2=-\frac{1}{\sqrt5}$
$y_n=\frac{1}{\sqrt5}(\frac{1+\sqrt{5}}{2})^n-\frac{1}{\sqrt5}(\frac{1-\sqrt{5}}{2})^n即为通解$
可知，时间复杂度为指数形式。

改进方法：

1.时间复杂度为O(n)的方法：

    int Fibonacci(int n) {
        if (n<=0) {
            return 0;
        }
        if (n==1) {
            return 1;
        }
        int min=0;
        int max=1;
        int i=2;
        int result=0;
        while (i<=n) {
            result=min+max;
            min=max;
            max=result;
            ++i;
        }
        return result;

2.时间复杂度为O(logn)的方法：
根据式(1-5)，可以化成矩阵的形式：
$(\begin{matrix}y_{n+2}\\y_{n+1}\end{matrix})=(\begin{matrix}1&1\\1&0\end{matrix}) (\begin{matrix}y_{n+1}\\y_{n}\end{matrix})=…= (\begin{matrix}1&1\\1&0\end{matrix})^{n+1} (\begin{matrix}y_1\\y_0\end{matrix})$
$因而计算y_n就简化为计算矩阵的(n+1)次方，再对矩阵分解，计算矩阵(n-2)/2次方的平方，逐步分解，因而时间复杂度为O(logn)$

#include <iostream>
using namespace std;

class Matrix
{
public:
    int n;
    int **m;
    Matrix(int num)
    {
        m=new int*[num];
        for (int i=0; i<num; i++) {
            m[i]=new int[num];
        }
        n=num;
        clear();
    }
    void clear()
    {
        for (int i=0; i<n; ++i) {
            for (int j=0; j<n; ++j) {
                m[i][j]=0;
            }
        }
    }
    void unit()
    {
        clear();
        for (int i=0; i<n; ++i) {
            m[i][i]=1;
        }
    }
    Matrix operator=(const Matrix mtx)
    {
        Matrix(mtx.n);
        for (int i=0; i<mtx.n; ++i) {
            for (int j=0; j<mtx.n; ++j) {
                m[i][j]=mtx.m[i][j];
            }
        }
        return *this;
    }
    Matrix operator*(const Matrix &mtx)
    {
        Matrix result(mtx.n);
        result.clear();
        for (int i=0; i<mtx.n; ++i) {
            for (int j=0; j<mtx.n; ++j) {
                for (int k=0; k<mtx.n; ++k) {
                    result.m[i][j]+=m[i][k]*mtx.m[k][j];
                }   
            }
        }
        return result;
    }
};
int main(int argc, const char * argv[]) {
    unsigned int num=2;
    Matrix first(num);
    first.m[0][0]=1;
    first.m[0][1]=1;
    first.m[1][0]=1;
    first.m[1][1]=0;
    int t;
    cin>>t;
    Matrix result(num);
    result.unit();
    int n=t-2;
    while (n) {
        if (n%2) {
            result=result*first;
            }
        first=first*first;
        n=n/2;
    }
    cout<<(result.m[0][0]+result.m[0][1])<<endl;
    return 0;
}