矩阵快速幂

矩阵快速幂

很显然就是，矩阵加快速幂的一种算法。要想学会该算法就要先学会矩阵相乘算法和快速幂算法。

快速幂：

快速运算的一种算法。它可以简化运算的次数，已达到高效率。

它就是简单的将指数转化当成二进制。然后进行运算。

例如A^7次怎么运算，一般情况下是乘以7次就可以解决了。完全还可以减少次数。

ANS=1;MULTI=A; 

N=7 ;N%2=1;   ANS*=MULTI; 所以ANS=A;  MULTI*=MULTI; 所以MULTI=A^2

然后 N/=2;N=3; N%2=1; ANS*=MULTI; 所以 ANS=A*A^2=A^3 ; 又MULTI*=MULTI; 所以MULTI=A^4

然后N/=2;N=1;N%2=1;ANS*=MULTI; 所以 ANS=A*A^2*A^4=A^7;又MULTI*=MULTI; 所以MULTI=A^8

然后N/=2;N=0;算法结束  是不是很巧妙呢，实际上用的乘法次数是 6次你可能觉得，那个A^7=A*A*A*A*A*A*A，不也是用了6次乘法吗有什么区别？

这就是快速幂。

矩阵快速幂就是将里面的快速幂是用矩阵表达出来的。很显然就会涉及到矩阵的乘法。也可以运用重载的方式直接定义*

在学矩阵快速幂的时候，刚开始的时候还是先不用重载比较好，先用矩阵陈发，运用矩阵乘法可以更好的感受其中带来的

奥妙，再用重载就会好很多，而且就更容易理解。（补充一点的就是：重载就是根据条件的不同选择不同的调用函数。在这里

要表达的意思是将*号重新第一，变成自己想要的那种矩阵运算）。至于矩阵怎么乘法运算的。建议去看一下，线性代数书本。就会

明白怎么用的。其实很简单。

一道简单的练习题

Tr A

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5184    Accepted Submission(s): 3879

Problem Description

A为一个方阵，则Tr A表示A的迹（就是主对角线上各项的和），现要求Tr(A^k)%9973。

 

Input

数据的第一行是一个T，表示有T组数据。
每组数据的第一行有n(2 <= n <= 10)和k(2 <= k < 10^9)两个数据。接下来有n行，每行有n个数据，每个数据的范围是[0,9]，表示方阵A的内容。

 

Output

对应每组数据，输出Tr(A^k)%9973。

 

Sample Input

  
  

   
   2
2 2
1 0
0 1
3 99999999
1 2 3
4 5 6
7 8 9
  
  

 

Sample Output

  
  

   
   2
2686
  
  

 

Author

xhd

 

Source

这是一道特别简单的矩阵快速幂的题型；

下面给出自己代码：

//定义一个结构体，来装这个矩阵，下面的这个是单位矩阵。

int n,m;
struct node
{
    int a[15][15];
    void init()
    {
        memset(a,0,sizeof(a));
        for(int i=0;i<15;i++)
            a[i][i]=1;
    }
}b;

//重载，在这里重新定义了一下*
node operator*(node a1,node a2)
{
    node ans;
   // memset(ans.a,0,sizeof(ans.a));
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            ans.a[i][j]=0;
            for(int k=0;k<n;k++)
            {
                ans.a[i][j]+=a1.a[i][k]*a2.a[k][j];
            }
                ans.a[i][j]=ans.a[i][j]%9973;
        }
    }
    return ans;
}

//矩阵快速幂
node pow1(node a1,int m)
{
   node ans;
   ans.init();
    while(m)
    {
        if(m&1)
        ans=ans*a1;
        a1=a1*a1;
        m>>=1;
    }
    return ans;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                scanf("%d",&b.a[i][j]);
        }
        node ans=pow1(b,m);
        int sum=0;
        for(int i=0;i<n;i++)
        {
            sum+=ans.a[i][i];
            sum=sum%9973;
        }
        printf("%d\n",sum);
    }
}

上面是重载写矩阵快速幂

也可以用矩阵乘法写矩阵快速幂

node mull(node a1,node a2)
{
    node ans;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            ans.a[i][j]=0;
            for(int k=0;k<n;k++)
            {
                ans.a[i][j]+=a1.a[i][k]*a2.a[k][j];
            }
            ans.a[i][j]%=9973;
        }
    }
    return ans;
}
node pow1(node a1,int m)
{
   node ans;
   ans.init();
   while(m)
   {
       if(m&1)
        ans=mull(ans,a1);
       a1=mull(a1,a1);
       m>>=1;
   }
   return ans;
}

刚开始的时候来写矩阵快速幂，我更懂得了重载的定义。感觉很清晰

到目前为止终于将矩阵快速幂了解各入门，还要接着深入学。。。。。。