递归的logN的优化（菲波那契数列，青蛙上台阶问题，母牛问题）！！！！

本文是看到了菲波那契数列：F（N） = F（N-1）+ F（N-2），如果，严格遵守该序列，对于求第N项的值，有矩阵乘法的方式可以将时间复杂度降至O（logN）。上文转自:左程云（程序代码面试指南：pag182）

本文严重参考：左程云（程序代码面试指南）

当时，一直想不明白，为什么简单递归的优化跟矩阵乘法有关系，，，然后，矩阵乘法还能解决什么问题呢？？？？

嗯嗯，看到了下面这篇博文，觉得不错，于是乎，转载了，，，，，希望对大家有所帮助。。。。

题目：定义Fibonacci数列如下：

        /  0                      n=0
f(n)=      1                      n=1
        \  f(n-1)+f(n-2)          n=2

输入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)……我们用树形结构来表示这种依赖关系

                  f(10)
               /        \
            f(9)         f(8)
          /     \       /    \
      f(8)     f(7)  f(7)   f(6)
      /   \     /   \ 
   f(7)  f(6)  f(6)f(5)        （只画出了部分图）

我们不难发现在这棵树中有很多结点会重复的，而且重复的结点数会随着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 long Fibonacci_Solution2(unsigned n)
{
      int result[2]= {0, 1};
      if(n< 2)
            return result[n];

      long long  fibNMinusOne= 1;
      long long  fibNMinusTwo= 0;
      long long  fibN= 0;
      for(unsigned int i= 2; i <= n; ++ i)
      {
            fibN= fibNMinusOne + fibNMinusTwo;

            fibNMinusTwo= fibNMinusOne;
            fibNMinusOne= fibN;
      }

       return fibN;
}

此刻，如果递归式严格遵循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。仅此而已

单位矩阵：本质就相当于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的状态矩阵有关的矩阵乘法表达式，都可以降

低时间复杂度。。。。。。