整数快速乘法/快速幂+矩阵快速幂

快速乘法通常有两类应用：一、整数的运算，计算(a*b) mod c 二、矩阵快速乘法
一、整数运算：（快速乘法、快速幂）

先说明一下基本的数学常识：

(a*b) mod c == ( (a mod c) * (b mod c) ) mod c //这最后一个mod c 是为了保证结果不超过c

对于2进制，2n可用1后接n个0来表示、对于8进制，可用公式 i+3*j == n （其中 0<= i <=2 ），对于16进制，可用 i+4*j==n（0 <= i <=3）来推算，表达形式为2i 后接 j 个0。

接下来让我们尽可能简单的描述快速乘法的思想：
a*b

快速乘法的基本思想 ，是二进制和乘法分配律的结合，（不由得想起浮点数不满足结合律，严重吐槽！！！╮(╯-╰)╭），比如说，13 ==（1101）2 ，4*13等于4*（1101）2 ，用分配律展开得到4*13 == 4*（1000+100+1）2，我们不难观察出，快速幂可以通过判断当前的位（bit）是1还是0，推断出是否需要做求和操作，每次移动到下一位（bit）时，就对ans进行*2操作，等待是否求和。由于除以2和位移操作是等效的，因此这也可以看作是二分思想的应用，这种算法将b进行二分从而减少了不必要的运算，时间复杂度是log（n）。

a^b

快速幂其实可以看作是快速乘法的特例，在快速幂中，我们不再对ans进行2操作，因为在a^b中b的意义已经从乘数变成了指数，但是我们可以仍然把b写成二进制，举例说明：此时，我们将4*13改为4^13，13=（1101）2 ，二进制13写开我们得到（1000+100+1），注意，这里的所有二进制是指数，指数的相加意味着底数相乘，因此有4^13 == 48 * 44 * 41。再注意到指数之间的2倍关系，我们就可以用很少的几个变量，完成这一算法。这样，我们就将原本用循环需要O(n)的算法，改进为O（logN）的算法。

按照惯例，给出尽可能简洁高效的代码实现 （以下所有int都可用long long 代替）

首先，给出快速乘法的实现：

int qmul(int a, int b){//根据数据范围可选择long long 
    int ans=0;
    while(b){
        if(b&1)
            ans+=a;//按位与完成位数为1的判断
        b>>=1;
        a<<=1;//位运算代替/2和*2
    }
    return ans;
}

快速乘法取模:

int qmul_mod(int a, int b,int mod){//根据数据范围可选择long long 
    int ans=0;
    while(b){
        if((b&1)
            ans=(ans+a)%mod;//这里需要b%=mod 以及a%=mod
        b>>=1;
        a<<=1;//位运算代替/2和*2
    }
    return ans;// 
}

接下来是快速幂的实现：

//快速幂 a^n 
int qpow(int a, int n){//根据数据范围可选择long long 
    if(a==0)return 0;//这是个坑，校赛被坑过，很多网上的实现都没写这一点
    int ans=1;
    while(n){
        if(n&1)
            ans*=x;//和快速乘法的区别
    x*=x;//区别，同上
        n>>=1;

    }
    return ans;
}

以及含有取模的快速幂:

int qpow_mod(int a, int n,int mode){//根据数据范围可选择long long 
    if(a==0)
        return 0;//这是个坑，校赛被坑过，很多网上的实现都没写这一点
    int ans=1;
    while(n){
        if(n&1)
            ans=(ans*x)%mod;
        x=(x*x)%mod;
        n>>=1;

    }
    return ans;
}

矩阵乘法：

int c[N][N];  
void multi(int a[][N],int b[][N],int n)  
{  
    memset(c,0,sizeof c);  
    for(int i=1;i<=n;i++)  
        for(int k=1;k<=n;k++)  
        for(int j=1;j<=n;j++)  
        c[i][j]+=a[i][k]*b[k][j];  
} 

矩阵快速幂:
就是算A^n;方法很简单，把快速幂算法中的乘法改成矩阵的乘法就可以了

    const int N=10;  
    int tmp[N][N];  
    void multi(int a[][N],int b[][N],int n)  
    {  
        memset(tmp,0,sizeof tmp);  
        for(int i=1;i<=n;i++)  
            for(int j=1;j<=n;j++)  
            for(int k=1;k<=n;k++)  
            tmp[i][j]+=a[i][k]*b[k][j];  
        for(int i=1;i<=n;i++)  
            for(int j=1;j<=n;j++)  
            a[i][j]=tmp[i][j];  
    }  
    int res[N][N];  
    void Pow(int a[][N],int n)  
    {  
        memset(res,0,sizeof res);  
        for(int i=1;i<=n;i++) res[i][i]=1;  
        while(n)  
        {  
            if(n&1)  
                multi(res,a,n);//res=res*a;复制直接在multi里面实现了；  
            multi(a,a,n);//a=a*a  
            n>>=1;  
        }  
    }