矩阵二分快速幂

最新推荐文章于 2020-11-28 12:34:28 发布

灰黑飞

最新推荐文章于 2020-11-28 12:34:28 发布

阅读量1.1k

点赞数

分类专栏：数论

本文链接：https://blog.csdn.net/qinzhenhua100/article/details/39735349

版权

数论专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一.矩阵的定义

由m×n个数a_ij（i=1,2,……,m;j=1,2,……，n）排成的m行n列的数表

如称为一个m×n的矩阵，记做A=

简记做A=A_m×n=（a_ij）_m×n

其中的m×n个数称为A的元素，简称为元。

二.矩阵乘法

定义：A_m×s与B_s×n的乘积是一个m×n的矩阵C_m×n

其中c_ij=a_i1b_1j+a_i2b_2j+a_i3b_3j+……+a_isb_sj

=a_ikb_kj（k∈（1，s））

记做C=AB称“AB”为“以A左乘B”或“以B右乘A”，

如

其中c₁₁=a₁₁b₁₁+a₁₂b₂₁+a₁₃b₃₁

c₁₂=a₁₁b₁₂+a₁₂b₂₂+a₁₃b₃₂

三.矩阵运算律

结合律：（AB）C=A(BC)

分配律：（A+B）C=AC+BC

C（A+B）=CA+CB

注：矩阵运算并不满足交换律，AB与BA不等价

若A为m×s矩阵，B为s×n矩阵，则AB为m×n矩阵

而BA无法进行矩阵乘法运算；即便是方阵（n×n）交换后乘得的结果也不一定相同，除了相当特殊的，例如每个元素都是1的方阵

四.矩阵与线性递推

线性递推方程即形如f_n=a₁f_n-1+a₂f_n-2+……+a_if_n-i的方程

以斐波那契数列为例a_n=a_n-1+a_n-2

我们的目的是通过矩阵乘法，求得斐波那契数列的第n项，为了得到这个结果，我们还需要由[a_n-2a_n-1]推得[a_n-1a_n]

我们设[a_n-2a_n-1]为矩阵A，因为A_1×2B_2×2=C_1×2，所以C与A是同规模的矩阵

[a_n-2a_n-1]= [a_n-1a_n]

一般的对于线性递推方程f_n=a₁f_n-1+a₂f_n-2+……+a_if_n-i

可以建立B=

设A=[f₁f₂f₃…… f_i]，则由ABB……B（k个B）即可得到f_i+k

{这个自行手模一下就可以发现规律}

五.利用矩阵乘法优化递推

原理：①快速幂②矩阵乘法满足结合律

如AB⁷=AB⁴B²B AB¹⁹=AB¹⁶B²B

快速幂的有关知识不清楚的请自行检索

这样可以令每一步运算都得到最大限度利用

理论上可以由普通递推的O(n)降至O(logn)当然矩阵越大，花在矩阵乘法中的时间就越长，时间效率也会低些

矩阵的快速幂是用来高效地计算矩阵的高次方的。将朴素的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中的最右端开始计算到最左端。细节就说到这，下面给核心代码：

1while(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<stdio.h>

#defineN 100

__int64map[N][N],tmp1[N][N],tmp2[N][N];

voidfun(__int64 map[N][N],int n,int k)//求矩阵map的k次幂,n代表每一维的数据个数

{

inti,j,m;

k--; //求map的k次幂，那map还需乘以map的k-1次幂

for(i=1;i<=n;i++)//初始化tmp1数组，tmp1数组记录的是map的2^x次幂

for(j=1;j<=n;j++)

tmp1[i][j]=map[i][j];

while(k)

{

if(k%2)

{

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

tmp2[i][j]=map[i][j];

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

{

map[i][j]=0;

for(m=1;m<=n;m++)

{

map[i][j]=(map[i][j]+tmp2[i][m]

*tmp1[m][j]);

}

}

}

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

tmp2[i][j]=tmp1[i][j];

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

{

tmp1[i][j]=0;

for(m=1;m<=n;m++)

tmp1[i][j]=(tmp1[i][j]+tmp2[i][m]*tmp2[m][j]);

}

k=k/2;

}

}

intmain()

{

int t;

scanf("%d",&t);

while(t--)

{

intn,k,i,j;

scanf("%d%d",&n,&k);

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

scanf("%I64d",&map[i][j]);

fun(map,n,k);

}

return0;

}

贴一个更好用的模板

#include<stdio.h>
#include<string.h>
struct matrix
{
    long long mat[5][5];
};
matrix matmul(matrix a,matrix b,int n,int m)
{
    int i,j,k;
    matrix ans;
    memset(ans.mat,0,sizeof(ans.mat));
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            for(k=0;k<n;k++)
                ans.mat[i][j]+=a.mat[i][k]*b.mat[k][j];
            ans.mat[i][j]%=m;
        }
    }
    return ans;
}
matrix matpow(matrix a ,int k,int n,int m)
{
    matrix ans=a;
    k--;
    while(k)
    {
        if(k&1)
            ans=matmul(ans,a,n,m);
        a=matmul(a,a,n,m);
        k/=2;
    }
    return ans;
}
int main()
{
    int k;
    matrix a,b,ans;
    while(scanf("%d",&k)!=EOF)
    {
        memset(a.mat,0,sizeof(a.mat));
        memset(b.mat,0,sizeof(b.mat));
        if(k<=2)
        {
            printf("%d\n",k);
            continue;
        }
        a.mat[0][0]=2; a.mat[1][0]=1; a.mat[2][0]=1;

        b.mat[0][0]=1; b.mat[0][1]=2; b.mat[0][2]=1;
        b.mat[1][0]=1; b.mat[1][1]=0; b.mat[1][2]=0;
        b.mat[2][0]=0; b.mat[2][1]=0; b.mat[2][2]=1;
       ans=matmul(matpow(b,k-2,3,10007),a,3,10007);
       printf("%lld\n",ans.mat[0][0]%10007);
    }
    return 0;
}