本文是看到了菲波那契数列：F（N） = F（N-1）+ F（N-2），如果，严格遵守该序列，对于求第N项的值，有矩阵乘法的方式可以将时间复杂度降至O（logN）。上文转自:左程云（程序代码面试指南：pag182）
本文严重参考：左程云（程序代码面试指南）
当时，一直想不明白，为什么简单递归的优化跟矩阵乘法有关系，，，然后，矩阵乘法还能解决什么问题呢？？？？
嗯嗯，看到了下面这篇博文，觉得不错，于是乎，转载了，，，，，希望对大家有所帮助。。。。
题目：定义Fibonacci数列如下：
f(n)=
输入n，用最快的方法求该数列的第n项。
分析：在很多C语言教科书中讲到递归函数的时候，都会用Fibonacci作为例子。因此很多程序员对这道题的递归解法非常熟悉，看到题目就能写出如下的递归求解的代码。
///
//Calculate the nth item of Fibonacci Series recursively
///
long long Fibonacci_Solution1(unsigned int n)
{
int result[2]= {0, 1};
if(n< 2)
return result[n];
return Fibonacci_Solution1(n- 1) + Fibonacci_Solution1(n - 2); //不断的往回递归
}但是，教科书上反复用这个题目来讲解递归函数，并不能说明递归解法最适合这道题目。我们以求解f(10)作为例子来分析递归求解的过程。要求得f(10)，需要求得f(9)和f(8)。同样，要求得f(9)，要先求得f(8)和f(7)……我们用树形结构来表示这种依赖关系
我们不难发现在这棵树中有很多结点会重复的，而且重复的结点数会随着n的增大而急剧增加。这意味这计算量会随着n的增大而急剧增大。事实上，用递归方法计算的时间复杂度是以n的指数的方式递增的。大家可以求Fibonacci的第100项试试，感受一下这样递归会慢到什么程度。在我的机器上，连续运行了一个多小时也没有出来结果。
其实改进的方法并不复杂。上述方法之所以慢是因为重复的计算太多，只要避免重复计算就行了。比如我们可以把已经得到的数列中间项保存起来，如果下次需要计算的时候我们先查找一下，如果前面已经计算过了就不用再次计算了。
更简单的办法是从下往上计算，首先根据f(0)和f(1)算出f(2)，在根据f(1)和f(2)算出f(3)……依此类推就可以算出第n项了。很容易理解，这种思路的时间复杂度是O(n)。
///
//Calculate the nth item of Fibonacci Series iteratively
///
long
{
}
此刻，如果递归式严格遵循F（N） = F（N -1） + F（N - 2），对于求第N项的值，有矩阵的乘法的方式可以将时间
复杂度降低为：O(logn)。F（N） = F（N -1） + F（N - 2）是一个二阶递推数列，一定可以用矩阵乘法的形式表示，
且状态矩阵为2×2的矩阵：
把菲波那契的前4项F（1）== 1，F（2）==1， F（3） == 2， F（4） == 3待入，可以求出状态矩阵：
求矩阵之后，当n > 2时，原来的公式可以化简为：
所以：求菲波那契数列第N项的问题就变成了如何用最快的方法求一个矩阵的N次方的问题，而求矩阵N次方的问题明显
是一个能够在O(logn)时间内解决的问题。为了表述方便，我们现在用求一个整数N次方的例子来说明，因为只要理解了
如何在O(logn)的时间复杂度内求整数N次方的问题，对于求矩阵N次方的问题是同理的。。。。区别在于矩阵和整数乘
法在细节上有些不一样，但对于如何乘更快，道理是一样的。
假设一个整数是10，如何最快的求解10的75次方？？？
1，75的二进制形式为：1001011
2，10的75次方为：
在这个过程中，我们先求10（1）相当于10的1次方，然后根据10（1）求出10（2），然后接着求出10（4），，，
最后根据10（32）求出10（64），即根据75的二进制数形式总共有多少位，我们就使用了几次乘法。
3，在步骤2中，把应该累乘的值相乘即可，比如，上面的10（64），10（8），10（2），10（1），只是因为64，8，
2，1对应到75的二进制数中，相应位上为1。仅此而已
单位矩阵：
对于矩阵来说：
求矩阵m的p次方（matrixPower）
两个矩阵相乘（muliMatrix）
public int[][] matrixPower(int[][] m, int p)
{
int[][] res = new int[m.length][m[0].length];
//先把res设为单位矩阵，相当于整数中的1
for(int i = 0; i< res.length; i++)
{
res[i][i] = 1;
}
int [][] tmp = m;
for(; p!= 0; p>>=1)
{
if((p & 1) != 0)
res = muliMatrix(res, tmp);
tmp = muliMatrix(tmp, tmp);
}
return res;
}
public int[][] muliMatrix(int [][] m1, int[][] m2)
{
int [][] res = new int[m1.length][m2[0].length];
for(int i=0; i< m1.length; i++)
{
for(int j=0; j<m2[0].length; j++)
{
for(int k =0; k < m2.length; k++)
{
res[i][j] += m1[i][k] * m2[k][j];
}
}
}
return res;
}所以，用矩阵乘法求解菲波那契数列第N项的全部过程：
public int f3(int n)
{
if(n < 1)
return 0;
if(n == 1 || n == 2)
return 1;
int [][] base = {{1,1}, {1,0}};
int [][] res = matrixPower(base, n-2);
return res[0][0] + res[1][0];
}台阶问题：
青蛙跳台阶，一次可以跳一阶，一次也可以跳两阶。如果台阶有1阶，方法只有一种;如果台阶有两阶，方法有两阶。
那么N阶呢？？？
S（N） = S（N-1） + S（N -2），初始S（1） == 1， S（2） == 2;
实现过程完全和上面是一样的，，，，
然后代码的最终实现：
public int(int n)
{
if(n < 1)
return 0;
if(n == 1 || n == 2)
return 1;
int [][] base = {{1,1}, {1,0}};
int [][] res = matrixPower(base, n-2);
return 2res[0][0] + res[1][0]; //这里出现的2，仅仅因为初值为2
}母牛问题：
假设农场中成熟的母牛每年只会生1头小母牛，并且永远不会死。第一年农场有1只成熟的母牛，从第二年开始，母牛开
始生小母牛。每只小母牛3年之后成熟又可以生小母牛。给定整数N，求出N年后牛的数量。
第N-1年的牛会毫无损失的活到第N年。同时所有成熟的牛都会生1头新的牛，就是第N-3年的所有牛到第N年肯定都是
成熟的牛，其间出生的牛肯定都没有成熟。所以：
C（n） = C（n - 1） + C（n - 3），初始：C（1） == 1， C（2） == 2， C（3） == 3;
同样的，C（n） = C（n - 1） + C（n - 3）是一个三阶递推数列，一定可以用矩阵乘法的形式表示，且状态矩阵为
3 × 3的矩阵。
求矩阵之后，当n>3,原来的公式可以化简为：
代码实现：
public int(int n)
{
if(n < 1)
return 0;
if(n == 1 || n == 2 || n==3)
return 1;
int [][] base = {{1,1,0}, {1,0,0}, {1,0,0}};
int [][] res = matrixPower(base, n-3);
return 3*res[0][0] + 2*res[1][0] + 3*res[2][0]; //这里出现的2，仅仅因为初值为2
}
如果，如果，递归式严格符合：
那么它就是一个i阶的递推式，必然有与i×i的状态矩阵有关的矩阵乘法表达式，都可以降
低时间复杂度。。。。。。
扫一扫
9024
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
