矩阵快速幂专题：
（参考各位大神的博客学习一下）
一：
据说，矩阵快速幂在递推式优化上相当神奇，而且效率很高。。。
两矩阵相乘，朴素算法的复杂度是O(N^3)。如果求一次矩阵的M次幂，按朴素的写法就是O(N^3*M)。既然是求幂，不免想到快速幂取模的算法，这里有快速幂取模的介绍，a^b %m 的复杂度可以降到O(logb)。如果矩阵相乘是不是也可以实现O(N^3 * logM)的时间复杂度呢？答案是肯定的。
先定义矩阵数据结构：
struct Mat {
double mat[N][N];
};
O(N^3)实现一次矩阵乘法
Mat operator * (Mat a, Mat b) {
Mat c;
memset(c.mat, 0, sizeof(c.mat));
int i, j, k;
for(k = 0; k < n; ++k) {
for(i = 0; i < n; ++i) {
if(a.mat[i][k] <= 0) continue;
//不要小看这里的剪枝，cpu运算乘法的效率并不是想像的那么理想（加法的运算效率高于乘法，比如Strassen矩阵乘法）
for(j = 0; j < n; ++j) {
if(b.mat[k][j] <=
0) continue; //剪枝
c.mat[i][j] +=
a.mat[i][k] * b.mat[k][j];
}
}
}
return c;
}
下面介绍一种特殊的矩阵：单位矩阵
很明显的可以推知，任何矩阵乘以单位矩阵，其值不改变。
有了前边的介绍，就可以实现矩阵的快速连乘了。
Mat operator ^ (Mat a, int k) {
Mat c;
int i, j;
for(i = 0; i < n; ++i)
for(j = 0; j < n; ++j)
c.mat[i][j] = (i == j); //初始化为单位矩阵
for(; k; k >>= 1) {
if(k&1) c = c*a;
a = a*a;
}
return c;
}
举个例子:
求第n个Fibonacci数模M的值。如果这个n非常大的话，普通的递推时间复杂度为O(n)，这样的复杂度很有可能会挂掉。这里可以用矩阵做优化，复杂度可以降到O(logn * 2^3)
如图：
A = F(n - 1), B = F(N - 2)，这样使构造矩阵的n次幂乘以初始矩阵得到的结果就是。
因为是2*2的据称，所以一次相乘的时间复杂度是O(2^3)，总的复杂度是O(logn * 2^3 + 2*2*1)。
zoj上的一道例题: zoj 2853 Evolution.
这道题都不用考虑怎么去构造能够实现有效运算的矩阵。直接修改单位矩阵就可以。比如P(i, j) = 0.5，则mat[i][j] += 0.5,mat[i][i] -= 0.5; 然后求T*mat^M,(T表示原始的population序列，相当于1*n的矩阵)
ps:这道题不加剪枝的话还是会挂掉 -_-!
渣代码 :3S+ 过得，很水 T_T
View Code
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 210;
struct Mat {
double mat[N][N];
};
double num[N];
int n, m;
Mat a;
void init() {
int i, j, q;
double x;
for(i = 0; i < n; ++i)
for(j = 0; j < n; ++j)
a.mat[i][j] = (i == j);
for(i = 0; i < n; ++i) {
scanf("%lf", num + i);
}
scanf("%d", &q);
while(q--) {
scanf("%d%d%lf",
&i, &j, &x);
a.mat[i][i] -= x;
a.mat[i][j] += x;
}
}
Mat operator * (Mat a, Mat b) {
Mat c;
memset(c.mat, 0, sizeof(c.mat));
int i, j, k;
for(k = 0; k < n; ++k) {
for(i = 0; i < n; ++i) {
if(a.mat[i][k] <= 0) continue;
//***
for(j = 0; j < n; ++j) {
if(b.mat[k][j] <=
0) continue; //***
c.mat[i][j] +=
a.mat[i][k] * b.mat[k][j];
}
}
}
return c;
}
Mat operator ^ (Mat a, int k) {
Mat c;
int i, j;
for(i = 0; i < n; ++i)
for(j = 0; j < n; ++j)
c.mat[i][j] = (i == j);
for(; k; k >>= 1) {
if(k&1) c = c*a;
a = a*a;
}
return c;
}
int main() {
//freopen("data.in",
"r", stdin);
int i;
double res;
while(~scanf("%d%d",
&n, &m)) {
if(!n && !m) break;
init();
a = a^m; res = 0;
for(i = 0; i < n; ++i) {
res += num[i]*a.mat[i][n-1];
}
printf("%.0f
", res);
}
return 0;
}
另一个大神的博客：
矩阵的快速幂是用来高效地计算矩阵的高次方的。将朴素的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中的最右端开始计算到最左端。细节就说到这，下面给核心代码：
1 while(N)
2 {
3 if(N&1)
4 res=res*A;
5 n>>=1;
6 A=A*A;
7 }
里面的乘号，是矩阵乘的运算，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;
}
二、矩阵快速幂的模板：
矩阵快速幂其实跟普通快速幂一样，只是把数换成矩阵而已。
模板，两种写法，亲测可用：
//made by whatbeg
//2014.6.15
struct Matrix
{
int m[3][3];
};
Matrix Mul(Matrix a,Matrix b)
{
Matrix c;
memset(c.m,0,sizeof(c.m));
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
c.m[i][j] += ((a.m[i][k]*b.m[k][j])%SMod + SMod)%SMod;
return c;
}
Matrix fastm(Matrix a,int n)
{
Matrix res;
memset(res.m,0,sizeof(res.m));
res.m[0][0] = res.m[1][1] = res.m[2][2] = 1;
while(n)
{
if(n&1)
res = Mul(res,a);
n>>=1;
a = Mul(a,a);
}
return res;
}
Matrix MPow(Matrix a,int n) //第二种写法,慎用,易RE
{
if(n == 1)
return a;
Matrix res = fastm(a,n/2);
res = Mul(res,res);
if(n&1)
res = Mul(res,a);
return res;
}
另一种：
struct Matrix
{
lll m[13][13];
Matrix()
{
memset(m,0,sizeof(m));
for(int i=1;i<=n+2;i++)
m[i][i] = 1LL;
}
};
Matrix Mul(Matrix a,Matrix b)
{
Matrix res;
int i,j,k;
for(i=1;i<=n+2;i++)
{
for(j=1;j<=n+2;j++)
{
res.m[i][j] = 0;
for(k=1;k<=n+2;k++)
res.m[i][j] = (res.m[i][j]+(a.m[i][k]*b.m[k][j])%SMod + SMod)%SMod;
}
}
return res;
}
Matrix fastm(Matrix a,int b)
{
Matrix res;
while(b)
{
if(b&1)
res = Mul(res,a);
a = Mul(a,a);
b >>= 1;
}
return res;
}
对元素0较多的矩阵取快速幂时可在Mul函数中加一个小优化：
Matrix Mul(Matrix a,Matrix b)
{
Matrix res;
int i,j,k;
memset(res.m,0,sizeof(res.m));
for(k=1;k<=n+2;k++)
{
for(i=1;i<=n+2;i++)
{
if(a.m[i][k])
{
for(j=1;j<=n+2;j++)
res.m[i][j] = (res.m[i][j]+(a.m[i][k]*b.m[k][j])%SMod + SMod)%SMod;
}
}
}
return res;
}
1//整数的快速幂 m^n % k 的快速幂：
long long quickpow(long long m , long long n ,
long long k){
long long ans = 1;
while(n){
if(n&1)//如果n是奇数
ans = (ans *
m) % k;
n = n >> 1;//位运算“右移1类似除2”
m = (m * m) % k;
}
return ans;
}
2//矩阵快速幂：
定义一个矩阵类，例如求（A^n）%mod
class Matrix {
public:
long long m[MAXN][MAXN];
//二维数组存放矩阵
Matrix(){}
//对数组的初始化
void init(long long num[MAXN][MAXN]){
for(int i = 0 ; i < MAXN ;
i++){
for(int j =
0 ; j < MAXN ; j++){
m[i][j] = num[i][j];
}
}
}
//重载矩阵的乘法运算
friend Matrix operator*(Matrix &m1 ,Matrix &m2)
{
int i, j, k;
Matrix temp;
for (i = 0; i < MAXN; i++)
{
for (j = 0;
j < MAXN; j++) {
temp.m[i][j] = 0;
for(k = 0 ; k < MAXN ; k++)
temp.m[i][j] += (m1.m[i][k] * m2.m[k][j])%mod
temp.m[i][j] %= mod;
//注意每一步都进行取模
}
}
return temp;
}
//矩阵的快速幂
friend Matrix quickpow(Matrix &M , long long n){
Matrix tempans;
//初始化为单位矩阵
//初始化
for(int i = 0 ; i < MAXN ;
i++){
for(int j =
0 ; j < MAXN ; j++){
if(i == j)
tempans.m[i][j] = 1;
else
tempans.m[i][j] = 0;
}
}
//快速幂（类似整数）
while(n){
if(n &
1) www.2cto.com
tempans = tempans * M;
//已经重载了*
n = n
>> 1;
M = M *
M;
}
return tempans;
}
};
int main() {
Matrix A , ans;
long long T , n , k , sum;
//数据类型为long
long
long long num[MAXN][MAXN];
//输入的数据存入数组
scanf("%lld" , &T);
while(T--){
scanf("%lld%lld
", &n
, &k);
memset(num , 0 , sizeof(num));
for(int i = 0 ; i < n ;
i++){
for(int j = 0
; j < n ; j++)
scanf("%lld" , &num[i][j]);
}
A.init(num);//初始化A矩阵
ans = quickpow(A , k);//求出矩阵的快速幂
}
}
三、矩阵快速幂的练习题博客地址：http://m.blog.csdn.net/blog/cgl1079743846/10309423