快速幂

int power(int n, int k) {  
    int         ans = 1;  
    while( k ) {  
        if(k & 1) {  
            ans *= n;  
        }  
        k >>= 1;  
        n *= n;  
    }  
    return ans;  
}  

下面是 m^n  % k 的快速幂：

int quickpow(int m,int n,int k)
{
    int b = 1;
    while (n > 0)
    {
          if (n & 1)
             b = (b*m)%k;
          n = n >> 1 ;
          m = (m*m)%k;
    }
    return b;
} 

下面是矩阵快速幂：

//HOJ 3493
/*===================================*/
|| 快速幂（quickpow）模板 
|| P 为等比，I 为单位矩阵
|| MAX 要初始化！！！！
||
/*===================================*/
/*****************************************************/
#include <cstdio>
const int MAX = 3;

typedef  struct{
        int  m[MAX][MAX];
}  Matrix;

Matrix P = {5,-7,4,
            1,0,0,
            0,1,0,
           };

Matrix I = {1,0,0,
            0,1,0,
            0,0,1,
           };
           
Matrix matrixmul(Matrix a,Matrix b) //矩阵乘法
{
       int i,j,k;
       Matrix c;
       for (i = 0 ; i < MAX; i++)
           for (j = 0; j < MAX;j++)
             {
                 c.m[i][j] = 0;
                 for (k = 0; k < MAX; k++)
                     c.m[i][j] += (a.m[i][k] * b.m[k][j])%9997;
                 c.m[i][j] %= 9997;
             }
       return c;
}
          
Matrix quickpow(long long n)
{
       Matrix m = P, b = I;
       while (n >= 1)
       {
             if (n & 1)
                b = matrixmul(b,m);
             n = n >> 1;
             m = matrixmul(m,m);
       }
       return b;
}
               /*************************************/

int main()
{
    Matrix re;
    int f[3] = {2,6,19};
    long long n;
    while (scanf("%I64d",&n) && n != 0)
    {
          if (n == 1)
             printf("1
");
          else if (n <= 4)
                  printf("%d
",f[n-2]);
               else {
                      re = quickpow(n - 4);
                      printf("%d
",(((re.m[0][0]*f[2]) 
                             + (re.m[0][1]*f[1]) + (re.m[0][2]*f[0])) %9997 + 9997) % 9997);
                      }
    }
    return 0;
}

//计算a^bmodn     
int modexp_recursion(int a,int b,int n)     
{    
    int t = 1;

    if (b == 0)
        return 1;

    if (b == 1)
         return a%n;

    t = modexp_recursion(a, b>>1, n);

    t = t*t % n;

    if (b&0x1)
    {    
        t = t*a % n;
    }

    return t;
 } 

#include <iostream>   
using namespace std;   
  
//计算a^bmodn   
int modexp(int a,int b,int n)   
{   
    int ret=1;   
    int tmp=a;   
    while(b)   
    {   
       //基数存在   
       if(b&0x1) ret=ret*tmp%n;   
       tmp=tmp*tmp%n;   
       b>>=1;   
    }   
    return ret;   
}   
  
int main()   
{   
    cout<<modexp(2,10,3)<<endl;   
    return 0;   
}  

矩阵快速幂

转自http://www.cnblogs.com/yan-boy/archive/2012/11/29/2795294.html

矩阵的快速幂是用来高效地计算矩阵的高次方的。将朴素的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次幂。

既然要减少重复计算，那么就要充分利用现有的计算结果咯！~怎么充分利用计算结果呢？？？这里考虑二分的思想。。

大家首先要认识到这一点：任何一个整数N，都能用二进制来表示。。这点大家都应该知道，但其中的内涵真的很深很深（这点笔者感触很深，在文章的最后，我将谈谈我对的感想）！！

计算机处理的是离散的信息，都是以0,1来作为信号的处理的。可想而知二进制在计算机上起着举足轻重的地位。它能将模拟信号转化成数字信号，将原来连续的实际模型，用一个离散的算法模型来解决。  好了，扯得有点多了，不过相信这写对下面的讲解还是有用的。

回头看看矩阵的快速幂问题，我们是不是也能把它离散化呢？比如A^19  =>  （A^16）*（A^2）*（A^1），显然采取这样的方式计算时因子数将是log(n)级别的(原来的因子数是n)，不仅这样，因子间也是存在某种联系的，比如A^4能通过(A^2)*(A^2)得到，A^8又能通过(A^4)*(A^4)得到，这点也充分利用了现有的结果作为有利条件。下面举个例子进行说明：

现在要求A^156,而156(10)=10011100(2) 

也就有A^156=>(A^4)*(A^8)*(A^16)*(A^128)  考虑到因子间的联系，我们从二进制10011100中的最右端开始计算到最左端。细节就说到这，下面给核心代码：

while(N)
 {
                if(N&1)
                       res=res*A;
                n>>=1;
                A=A*A;
 }

里面的乘号，是矩阵乘的运算，res是结果矩阵。

第3行代码每进行一次，二进制数就少了最后面的一个1。二进制数有多少个1就第3行代码就执行多少次。

好吧，矩阵快速幂的讲解就到这里吧。在文章我最后给出我实现快速幂的具体代码（代码以3*3的矩阵为例）。

现在我就说下我对二进制的感想吧：

我们在做很多”连续“的问题的时候都会用到二进制将他们离散简化

1.多重背包问题

2.树状数组

3.状态压缩DP

……………还有很多。。。究其根本还是那句话：化连续为离散。。很多时候我们并不是为了解决一个问题而使用二进制，更多是时候是为了优化而使用它。所以如果你想让你的程序更加能适应大数据的情况，那么学习学习二进制及其算法思想将会对你有很大帮助。

最后贴出一些代码供大家学习，主要起演示的效果：

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <iostream> 
using namespace std;

int N;

struct matrix
{
       int a[3][3];
}origin,res;


matrix multiply(matrix x,matrix y)
{
       matrix temp;
       memset(temp.a,0,sizeof(temp.a));
       for(int i=0;i<3;i++)
       {
               for(int j=0;j<3;j++)
               {
                       for(int k=0;k<3;k++)
                       {
                               temp.a[i][j]+=x.a[i][k]*y.a[k][j];
                       }
               }
       }
       return temp;
}

void init()
{
     printf("随机数组如下:
");
     for(int i=0;i<3;i++)
     {
             for(int j=0;j<3;j++)
             {
                     origin.a[i][j]=rand()%10;
                     printf("%8d",origin.a[i][j]);
             }
             printf("
");
     }
     printf("
");
     memset(res.a,0,sizeof(res.a));
     res.a[0][0]=res.a[1][1]=res.a[2][2]=1;                  //将res.a初始化为单位矩阵 
}

void calc(int n)
{
     while(n)
     {
             if(n&1)
                    res=multiply(res,origin);
             n>>=1;
             origin=multiply(origin,origin);
     }
     printf("%d次幂结果如下：
",n);
     for(int i=0;i<3;i++)
     {
             for(int j=0;j<3;j++)
                     printf("%8d",res.a[i][j]);
             printf("
");
     }
     printf("
");
}
int main()
{
    while(cin>>N)
    {
            init();
            calc(N);
    }
    return 0;
}

//HDU 4965 
#include<cstdio>
using namespace std;
const int maxn = 1010;
const int maxd = 6;
#define FOR(i,n) for(int i = 0; i < n; i++)
struct Mat{
    int mat[maxd][maxd];//注意这里maxd不能开太大，请将矩阵优化成此规模限制内 
};
int N,K;
int mat_a[maxn][maxd],mat_b[maxd][maxn];
int ret_a[maxn][maxn],ret_b[maxn][maxn];
Mat operator *(Mat x,Mat y){//重载矩阵乘法 
    Mat c;
    FOR(i,K) FOR(j,K){
        c.mat[i][j] = 0;
        FOR(k,K){c.mat[i][j] += (x.mat[i][k] * y.mat[k][j]); c.mat[i][j] %= 6;}
    }
    return c;
}
Mat mult(int mat_x[maxd][maxn],int mat_y[maxn][maxd]){
    Mat m;
    FOR(i,K) FOR(j,K){
        m.mat[i][j] = 0;
        FOR(k,N) m.mat[i][j] += (mat_x[i][k] * mat_y[k][j]);
    }
    return m;
}
int main(){
    while(scanf("%d%d",&N,&K)){
        if(!N && !K) break;
        FOR(i,N) FOR(j,K) scanf("%d",&mat_a[i][j]);
        FOR(i,K) FOR(j,N) scanf("%d",&mat_b[i][j]);
        Mat c = mult(mat_b,mat_a);
        int M = N * N  - 1;
        Mat ret;
        FOR(i,K) FOR(j,K) if(i == j) ret.mat[i][j] = 1;
        else ret.mat[i][j] = 0;
        while(M){
            if(M & 1)
                ret = ret * c;
            M >>= 1;
            c = c * c;
        }//矩阵快速幂（M次方），ret是单位矩阵 
        FOR(i,N) FOR(j,K){
            ret_a[i][j] = 0;
            FOR(k,K) ret_a[i][j] += (mat_a[i][k] * ret.mat[k][j]);
        }
        FOR(i,N) FOR(j,N){
            ret_b[i][j] = 0;
            FOR(k,K) ret_b[i][j] += (ret_a[i][k] * mat_b[k][j]);
        }
        int sum = 0;
        FOR(i,N) FOR(j,N)
            sum += (ret_b[i][j] % 6);
        printf("%d
",sum);
    }
    return 0;
}