相信大家都对斐波那契数列已经相当的熟悉了，最多两分钟就可以写出来以下时间复杂度为O(N)的代码：
//递归实现
long long fib(int n)
{
if (n =1 || n== 2)
{
return 1;
}
return (fib(n - 2) + fib(n - 1));
}或者是这样的时间复杂度为O(N)，空间复杂度为O(1)：
//优化一：时间复杂度为O(N)
long long fib(int n)
{
long long* fibarry = new long long[n + 1];
fibarry[0] = 0;
fibarry[1] = 1;
for (int i = 2; i <= n; i++)
{
fibarry[i] = fibarry[i - 1] + fibarry[i - 2];
}
long long ret = fibarry[n];
delete fibarry;
return ret;
}
//优化二：时间复杂度O(N) 空间复杂度O(1)
long long fib(int n)
{
long long fibarry[3] = { 0, 1, 0 };
for (int i = 2; i <= n; i++)
{
fibarry[2] = fibarry[0] + fibarry[1];
fibarry[0] = fibarry[1];
fibarry[1] = fibarry[2];
}
return fibarry[2];
} 等等这些都是不错算法，都可以实现斐波那契数列的求解，但是今天我们讨论的是斐波那契数列的最优算法（当然博主水平就这样，各位亲有什么更加优的算法可以和博主分享）。这个算法的时间复杂度是O(logN)。
斐波那契数列的递推公式是：f(n)=f(n-1)+f(n-2);
在线性代数中，类似于斐波那契数列这种递推式称为二阶递推式。我们可以用f(n)=af(n-1)+bf(n-2)将二阶递推式一般化。只要符合这种二阶递推式的算法，都可以将算法的时间复杂度降为O(logN)。当然，三阶，四阶....都可以，只要得到递推公式的n阶矩阵即可。如下：
f(n)=af(n-1)+bf(n-2)+......
(f(n),f(n-1))=(f(n-1),f(n-2))*matrix;(matrix是一个矩阵，几阶递推式就是几阶的矩阵，在这里是二阶的矩阵，斐波那契数列属于二阶)
或许这样看起来还不够直观，我们带入一个例子看一下：
f(3)=f(2)+f(1)->(f(3),f(2))=(f(2),f(1))*(matrix)^1;
f(4)=f(3)+f(2)->(f(4),f(3))=(f(3),f(2))*(matrix)^1=(f(2),f(1))*(matrix)^2;
.....
f(n)=(f(2),f(1))*(matrix)^n-2;
根据这些公式可以算出二阶的matrix={{1，1}，{1，0}};
算出了matrix后只差怎样算出matrix^n-2这个难题了。时间复杂度的降低，在于降低求矩阵的n次方的时间复杂度。其实这个问题也不难，我们先来看一个数怎样能快速算出num^n,
例：10^68，我们通常是10*10乘上68次，这样时间效率为O(N),我们要用O(logN)方法算:
68的二进制序列为：1000100
10^68=10^64*10^4，也就是取出68二进制序列为1的位，其他忽略。这样我们只算了7次（二进制序列的长度）就可以算出10^68，效率就达到了O(logN)。（最优化算法的关键所在）
现在大家知道了算num^n的优化算法，matrix^n也是一样的道理。不懂的可以去查阅一下线性代数的矩阵乘法。
有了上面的基础，我们不难写出以下的代码：
//优化三 时间复杂度为O(logN)
static const long long int Mod = 1000000007;//防止结果溢出
static const int row = 2;
static const int col = 2;
struct DoubleArry//用来聚合二维数组
{
long _arry[row][col];
DoubleArry()
{
for (int i = 0; i < row; ++i)
for (int j = 0; j < col; ++j)
_arry[i][j] = 0;
}
DoubleArry(long matrix[][col])
{
for (int i = 0; i < row; ++i)
for (int j = 0; j < col; ++j)
_arry[i][j] = matrix[i][j];
}
DoubleArry(const DoubleArry& d)
{
for (int i = 0; i < row; ++i)
for (int j = 0; j < col; ++j)
_arry[i][j] = d._arry[i][j];
}
DoubleArry& operator=(DoubleArry d)
{
swap(d._arry, _arry);
return *this;
}
};//两个矩阵相乘
DoubleArry matrixMul(DoubleArry l, DoubleArry r)
{
DoubleArry ret;
for (int i = 0; i<row; ++i)
for (int j = 0; j<col; ++j)
{
for (int k = 0; k<row; ++k)
{
ret._arry[i][j] += ((l._arry[i][k] %= Mod)*(r._arry[k][j] %= Mod)) % Mod;
}
}
return ret;
}//矩阵的n次方
DoubleArry GetmatrixPower(DoubleArry matrix, int n)
{
DoubleArry ret;
//DoubleArry ret = new DoubleArry(cellmtrix);
for (int i = 0; i<col; ++i)
//先把ret设为单位矩阵，相当于整数中的1
{
ret._arry[i][i] = 1;
}
DoubleArry tmp = matrix;
for (; n != 0; n >>= 1)
{
if ((n & 1) == 1)//只拿出二进制序列中为1的位来乘
{
ret = matrixMul(ret, tmp);
}
tmp = matrixMul(tmp, tmp);
}
return ret;
}
long fib(int n)
{
if (n<1)
return 0;
if (n == 1 || n == 2)
return 1;
long matrix[][col] = { { 1, 1 }, { 1, 0 } };
DoubleArry ret = GetmatrixPower(matrix, n - 2);
return ((ret._arry[0][0] + ret._arry[1][0]) % Mod;
}在写代码的过程中一开始博主是没有定义DoubleArry结构体的。用的是一个二维数组，但是编译一直错误，提示应使用（....）初始化聚合对象，一直搞不懂是什么情况，上网搜了一下网友的解释，发现是对于non-aggregates(非聚合对象)，不能使用初始化列表。只有聚合对象才可以这样使用。所以把二维数组改为一个结构体来聚合起来，然后就成功了。
还有其他的办法就是使用指针，但是略麻烦，也不直观。有兴趣可以试一下。
本文出自 “稻草阳光” 博客，请务必保留此出处http://helloleex.blog.51cto.com/10728491/1769253
原文地址：http://helloleex.blog.51cto.com/10728491/1769253
