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

快速幂算法可以说是ACM一类竞赛中必不可少，并且也是非常基础的一类算法，鉴于我一直学的比较零散，所以今天用这个帖子总结一下

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

一、整数运算：（快速乘法、快速幂）

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

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

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

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

a*b

快速乘法的基本思想 ，是二进制和乘法分配律的结合，（不由得想起浮点数不满足结合律，严重吐槽！！！╮(╯-╰)╭），比如说，13 ==（1101）₂  ，4*13等于4*（1101）_{2 ，}用分配律展开得到4*13 == 4*（1000+100+1）₂，我们不难观察出，快速幂可以通过判断当前的位（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 == 4⁸ * 4⁴ * 4¹。再注意到指数之间的2倍关系，我们就可以用很少的几个变量，完成这一算法。这样，我们就将原本用循环需要O(n)的算法，改进为O（logN）的算法。

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

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

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

如果涉及到快速乘法取模，则需要进行一些微小改动

改动所基于的数学原理，请参考红色字体标出的数学常识

 //快速乘法取模
 int qmul_mod(int a,int b,int mod){
     int ans=;
     while(b){
         if((b%=mod)&)ans+=a%=mod;//这里需要b%=mod 以及a%=mod
         b>>=;a<<=;
     }
     return ans%mod;  //ans也需要对mod取模
 }

接下来是快速幂的实现：

 //快速幂 a^b
 int qpow(int a,int b){
     if(a==)return ;//这是个坑，校赛被坑过，很多网上的实现都没写这一点
     int ans=;
     while(b){
         if(b&)ans*=a;//和快速乘法的区别
         b>>=;a*=a;//区别，同上
     }
     return ans;
 } 

以及含有取模的快速幂：

int qpow_mod(int a,int b,int mod){
    if(a==)return ;
    int ans=;
    while(b){
        if(b&)ans=(ans%mod)*(a%mod);//如果确定数据不会爆的话，可写成 ans*=a%=mod;
        b>>=;a*=a%=mod;//等价于a=(a%mod)*(a%mod)，且将一个模运算通过赋值代替，提高了效率
    }
    return ans%mod;//数据不会爆的话，这里的%运算会等价于第5中不断重复的 ans%mod
}

如果我们对于性能还有更进一步的要求，那么也就是减少取模运算了，那么我们需要确定数据范围不会爆掉

在这样的前提下，我们可以只用原先1/4的取模运算量完成快速幂

int qpow_mod(int a,int b,int mod){
    if(!a)return ;
    int ans=;
    while(b){
        if(b&)ans*=a%=mod;//这里的模运算只有一个
        b>>=;a*=a;//这里的模运算没有了
    }
    return ans%mod;
}

这些天找了好久，终于找到了纯粹的整数快速幂题目，按照惯例，给一波传送门：

poj1995：http://poj.org/problem?id=1995

这个题。。。没什么好说的，但是需要注意，用1/4模运算量的那种写法，数据会爆，所以必须写成完全取模的运算，这样程序会慢一点。。。呜呜呜，63ms水过，这是目前我做的最慢的了，如果大神知道如何在16ms及以下A掉它，欢迎联系我谢谢~o(*￣▽￣*)ブ

实现的代码如下：

 #include<cstdio>
 int z,a,b,m,h,sum;
 int qpow_mod(int a,int b,int mod){
     if(!a)return ;
     int ans=;
     while(b){
         if(b&)ans=ans%mod*(a%=mod);
         b>>=;a=a%mod*(a%mod);
     }
     return ans%mod;
 }
 int main(){
     scanf("%d",&z);
     while(z--){
         scanf("%d%d",&m,&h);sum=;
         while(h--){
             scanf("%d%d",&a,&b);
             sum+=qpow_mod(a,b,m);
             sum%=m;
         }
         printf("%d\n",sum);
     }
 }

先更新到这，有时间再更新矩阵的Strassen算法以及矩阵快速幂，，大家稍后见(●'◡'●)

2016-06-13 16:47:56

大家好，我又回来啦

二、矩阵运算：（快速幂）（Strassen算法有空再说）

矩阵的快速幂运算，其实思路和上面的整数快速幂是一样的，对指数进行二分，不过我们对于快速幂本身，可能既可以写成函数，也可以写成运算符重载，所以这里我写的是运算符的重载，毕竟重载练得少，得多练一练

首先我们可以定义一个矩阵数据结构，也可以直接用二维数组

 #define N 100
 struct matrix{
     int m[N][N];
 };

然后我们重载^运算符，完成矩阵m的b次幂的快速幂运算

这里为了我自己代码习惯，我重载了*和*=两种运算符，当然，在写的时候跪在了忘了写函数声明上，毕竟C++不是java，对于函数声明的顺序有依赖，so~大家记得写函数声明呦

代码如下

 //矩阵的数据结构
 struct matrix{
     int m[N][N];
 };
 matrix operator * (matrix ,matrix);//重载声明
 matrix operator *= (matrix,matrix);
 matrix operator ^ (matrix a,int b){
     matrix ans;
     for(int i=;i<N;i++)
         for(int j=;j<N;j++)ans.m[i][j]=(i==j);//初始化为单位矩阵
     if(b&)ans*=a;
     b>>=;a*=a;
     return ans;
 }
 matrix operator * (const matrix a,const matrix b){//朴素矩阵乘法
     matrix ans;
     for(int i=;i<N;i++)
         for(int j=;j<N;j++)
             for(int k=;k<N;k++)
                 ans.m[i][j]=a.m[i][k]+b.m[k][j];
     return ans;
 }
 matrix operator *= (matrix a,const matrix b){
     return a=b*b;
 }

当然，有必要的时候，我会再更新一波Strassen算法，考虑到在很多情况下，Strassen算法反而会降低矩阵运算的速度，所以我们就先到这里~拜拜(●ˇ∀ˇ●)