斐波那契数列

//计算斐波那契数列 f(n) 

#include <iostream>
#include <cmath> 
using namespace std;

long fib1(int n){
    /*递归程序1：这种是最原始的想法，这样的做法会重复调用，做很多无用的工作。下面是优化的几种方法 */
          if (n <= 2){
              return 1;
          }
          else{
              return fib1(n-1) + fib1(n-2);
          }
}

long fib(int n, long a, long b, int count){
     if (count == n)
         return b;
     return fib(n, b, a+b, ++count);
}
 
long fib2(int n){
    /* 递归程序2：这种递归的写法比fib1进步了不少，它略过了很多fib1中重复计算的部分。
    但是递归写法，时间复杂度依然很高，近似为线性时间O(n)，但比起下面的迭代循环仍然没有优势 */ 
     return fib(n, 0, 1, 1);
}


long fib3 (int n){
    /* 迭代解法：这里算法复杂度显然为O(n) ，
    这个解法目前来看是最好的解法，算法既不复杂，而且在时间复杂度和空间复杂度上都有保证  */ 
     long x = 0, y = 1;
     for (int j = 1; j < n; j++){
         y = x + y;
         x = y - x;
     }
     return y;
}

/* 这里也可以将每次计算的结果存储下来，这就是大名鼎鼎的以“空间换时间”，下面就是用空间换时间的程序   

long fib3(int n){
    if(n==0) return 0;
    long data[n];
    data[0]=0,data[1]=1;
    for(int i=2;i<=n;i++){
        data[i]=data[i-1]+data[i-2];
    }
    return data[n];
}

*/

class Matrix{
public:
       long matr[2][2];
       Matrix(const Matrix&rhs);
       Matrix(long a, long b, long c, long d);
       Matrix& operator=(const Matrix&);
       
       friend Matrix operator*(const Matrix& lhs, const Matrix& rhs){
              Matrix ret(0,0,0,0);
              ret.matr[0][0] = lhs.matr[0][0]*rhs.matr[0][0] + lhs.matr[0][1]*rhs.matr[1][0];
              ret.matr[0][1] = lhs.matr[0][0]*rhs.matr[0][1] + lhs.matr[0][1]*rhs.matr[1][1];
              ret.matr[1][0] = lhs.matr[1][0]*rhs.matr[0][0] + lhs.matr[1][1]*rhs.matr[1][0];
              ret.matr[1][1] = lhs.matr[1][0]*rhs.matr[0][1] + lhs.matr[1][1]*rhs.matr[1][1];
              return ret;
       }
};

Matrix::Matrix(long a, long b, long c, long d){
       this->matr[0][0] = a;
       this->matr[0][1] = b;
       this->matr[1][0] = c;
       this->matr[1][1] = d;
}

Matrix::Matrix(const Matrix &rhs){
       this->matr[0][0] = rhs.matr[0][0];
       this->matr[0][1] = rhs.matr[0][1];
       this->matr[1][0] = rhs.matr[1][0];
       this->matr[1][1] = rhs.matr[1][1];
}

Matrix& Matrix::operator =(const Matrix &rhs){
       this->matr[0][0] = rhs.matr[0][0];
       this->matr[0][1] = rhs.matr[0][1];
       this->matr[1][0] = rhs.matr[1][0];
       this->matr[1][1] = rhs.matr[1][1];
       return *this;
}
 
Matrix power(const Matrix& m, int n){
       if (n == 1)
              return m;
       if (n%2 == 0)
              return power(m*m, n/2);
       else
              return power(m*m, n/2) * m;
}

long fib4 (int n){
    /* 矩阵乘法：二分法进一步优化程序，时间复杂度为O(log(n))   */ 
       Matrix matrix0(1, 1, 1, 0);
       matrix0 = power(matrix0, n-1);
       return matrix0.matr[0][0];
}

long fib5(int n){
    /* 公式法：终极必杀，直接套用表达式求解，时间复杂度为O(1).
    不过有瑕疵的一点就是受制于库函数实现开方和乘方的效率,具体时间复杂度上考虑到上一点，估计也是 O(log(n)) */
     double z = sqrt(5.0);
     double x = (1 + z)/2;
     double y = (1 - z)/2;
     return (pow(x, n) - pow(y, n))/z + 0.5;
}

int main(){
     cout << fib1(45) << endl;
     cout << fib2(45) << endl;
     cout << fib3(45) << endl;
     cout << fib4(45) << endl;
     cout << fib5(45) << endl;
     return 0;
}