快速幂与快速矩阵幂(以大数下的斐波那契数列为例)

一般地，a^n的算法时间复杂度为o(n)，但是如果n为大数，则运行时间过长，效率不高。因此，使用二分的思想降低时间复杂度，使其降至o(logn)，则会使运行效率较大提升。二分思想如下图所示。

例如：2^8=2^4*2^4=(2^2*2^2)*(2^2*2^2)=((2*2)*(2*2))*((2*2)*(2*2)),只需计算4次，比原来的8次降低许多(这里多一次，是把第一次乘1也算上)

  奇数次：2^9=2*(2^4)*(2^4)=2*(2^2*2^2)*(2^2*2^2)=2*((2*2)*(2*2))*((2*2)*(2*2)) 

因此，快速幂的代码实现如下：

def quick(a,n,p):
    res=1
    ans=a
    while n>=2:
        if n&1:
            res=(ans*res)%p
        ans=(ans*ans)%p
        n=n>>1
    ans=res*ans
    return ans%p
if __name__ == '__main__':
    a,n,p=map(int,raw_input().split())
    print quick(a,n,p)

借鉴快速幂的思想，求快速矩阵幂。

根据矩阵乘法的结合律AB.....B=A(B)^n,而B^n则可以用快速幂的方法求，就可以降低计算时间。

矩阵的快速幂是用来高效地计算矩阵的高次方的。将朴素的o（n）的时间复杂度，降到log（n）。这里先对原理（主要运用了矩阵乘法的结合律）做下简单形象的介绍：一般一个矩阵的n次方，我们会通过连乘n-1次来得到它的n次幂。但做下简单的改进就能减少连乘的次数，方法如下：把n个矩阵进行两两分组，比如：A*A*A*A*A*A  =>  (A*A)*(A*A)*(A*A)这样变的好处是，你只需要计算一次A*A，然后将结果(A*A)连乘自己两次就能得到A^6，即(A*A)^3=A^6。算一下发现这次一共乘了3次，少于原来的5次。其实大家还可以取A^3作为一个基本单位。原理都一样：利用矩阵乘法的结合律，来减少重复计算的次数。以上都是取一个具体的数来作为最小单位的长度，这样做虽然能够改进效率，但缺陷也是很明显的，取个极限的例子（可能有点不恰当，但基本能说明问题），当n无穷大的时候，你现在所取的长度其实和1没什么区别。所以就需要我们找到一种与n增长速度”相适应“的”单位长度“，那这个长度到底怎么去取呢？？？这点是我们要思考的问题。有了以上的知识，我们现在再来看看，到底怎么迅速地求得矩阵的N次幂。既然要减少重复计算，那么就要充分利用现有的计算结果咯！~怎么充分利用计算结果呢？？？这里考虑二分的思想。。
回头看看矩阵的快速幂问题，我们是不是也能把它离散化呢？比如A^19  =>  （A^16）*（A^2）*（A^1），显然采取这样的方式计算时因子数将是log(n)级别的(原来的因子数是n)，不仅这样，因子间也是存在某种联系的，比如A^4能通过(A^2)*(A^2)得到，A^8又能通过(A^4)*(A^4)得到，这点也充分利用了现有的结果作为有利条件。下面举个例子进行说明：

斐波那契数列的递推： f(n) = f(n-1) + f(n-2);其对应的矩阵就是      f(n)   f(n-1)    f(n-1)   f(n-2)     1    1          即形如C=A*B
                                                                                                                      0      0   =        0       0    *   1    0    
可以发现，左面是个常数矩阵，而右面的列向量中每一项就是递推公式中的依赖项。然后根据初始两f(1)=1,f(0)=0,则将初始值代入A中，求C=A*(B^(n-2))。

问题描述：

现在有一栋高楼，但是电梯却出了故障，无奈的你只能走楼梯上楼，根据你的腿长，你一次能走1级或2级楼梯，已知你要走n级楼梯才能走到你的目的楼层，请计算你走到目的楼层的方案数，由于楼很高，所以n的范围为int范围内的正整数。
给定楼梯总数n，请返回方案数。为了防止溢出，请返回结果Mod 1000000007的值。
测试样例：
      3
返回：3

代码实现：

#-*- coding:utf-8 -*-
class GoUpstairs:
    def countWays(self, n):
        n=n-1
        res=base=[[1,1],[1,0]]
        surplus=[[1,1],[0,0]]
        while(n>=2):
            if n&1:
                surplus=self.mutiply(surplus,res)
            res=self.mutiply(res,res)
            n=n>>1
        res=self.mutiply(surplus, res)
        return res[0][0]%1000000007
    def mutiply(self,a,b):
        temp=[[0,0],[0,0]]
        for i in range(len(a)):
            for j in range(len(b)):
                for k in range(len(temp)):
                    temp[i][j]+=a[i][k]*b[k][j]%1000000007
                      
        return temp

ps：遇到变形的递推公式，也可以用矩阵快速幂，只需找对相应的矩阵关系即可