矩阵快速幂

Fibonacci数列f[n]=f[n-1]+f[n-2],f[1]=f[2]=1的第n项快速求法（不考虑高精度）

 

其中A是一个矩阵，使得这个矩阵的存在，让第2/3位斐波那契额数变成第3 、4位斐波那契额数

这个时候的A是

还可以表达成|f[2],f[3]|*A^(n-1)=|f[n],f[n+1]|;

因为矩阵乘法满足结合律

数列f[n]=f[n-1]+f[n-2]+1,f[1]=f[2]=1的第n项的快速求法（不考虑高精度）

按照刚才第一个问题，我们队f[n]进行分解，首先拿f[2]来说，f[2]被分解为f[1]+f[0]+1，注意，这里多了一个1，那么在对于A来说，在第一列的时候就应该有三个1

A=

 

就拿第一个例子来说：我们在求矩阵快速幂的时候，大致的思路其实是跟快速幂相似的（如果对快速幂不熟悉的话，可以先看一下这一篇博客：），我们要求第n位斐波那契数，就会进行通过某一个矩阵进行转换的操作使其逐渐靠近第n位，通过矩阵的性质，可以把这一操作叠加起来，这样就可以得到我们想要的-第n位斐波那契数了。

对我们求得的这个矩阵进行降幂操作就是矩阵快速幂所要解决的问题。

 

由于是初识矩阵快速幂，对于我的理解来说，我们求得的这个矩阵（以后见到后暂且说它是AAA吧）应该是在草纸上推算出来的，然后把推算出来的矩阵的值赋值到结构体数组中，然后进行操作。

struct node
{
    long long g[5][5];
}f,ans;

开一个结构体，存储矩阵数据

在主函数中进行赋值
    f.g[1][1]=0;
    f.g[1][2]=1;
    f.g[2][1]=1;
    f.g[2][2]=1;

接下来的操作如下：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int n,mod;
struct node
{
    long long g[5][5];
} f,ans;

void multiple(node &x,node &y, node &z)
{
    memset(z.g,0,sizeof(z.g));
    for(int i=1; i<=2; ++i)
    {
        for(int j=1; j<=2; ++j)
        {
            if(x.g[i][j])
            {
                for(int k=1; k<=2; ++k)
                {
                    z.g[i][k]+=x.g[i][j]*y.g[j][k];
                    if(z.g[i][k]>=mod)
                        z.g[i][k]%=mod;
                }
            }
        }
    }
    return ;
}

void init(node &x)//构建单位矩阵
{
    for(int i=1; i<=2; ++i)
        for(int j=1; j<=2; ++j)
        {
            if(i==j)
                x.g[i][j]=1;
            else
                x.g[i][j]=0;
        }
    return ;
}
//单位矩阵乘一个矩阵等于这个矩阵的原矩阵

void quickpow(int x)
{
    init(ans);
    //现在的ans是单位矩阵，把ans当做矩阵快速幂乘次的媒介
    node temp=f,t;
    while(x)
    {
        if(x&1)//如果x是奇数
        {
            multiple(ans,temp,t);//矩阵快速幂的乘法部分
            //分别代表ans和temp矩阵相乘，存储在t中
            ans=t;
        }
        multiple(temp,temp,t);
        temp=t;
        x>>=1;//减1操作包含其中,妙哉！
    }
}

int solve()
{
    if(n<=2)
        return 1;//这里代表的是f[1]=1,f[2]=1;
    quickpow(n-2);
    //现在只是求得了(f[n-1],f[n]),还未求得f[n]
    long long int ret=ans.g[1][2]*1+ans.g[2][2]*1;
    /*
    这里之所以是两个都乘以1是因为：
    我们通过[f[1] f[2]]推导得出[[f[n-1] f[n]],最后
    我们得到的矩阵ans代表的是中间的n-1次方的那个矩
    阵，前面的[f[1] f[2]]还没乘，这样，正好可以通过
    这个矩阵得出f[n]


    */
    ret%=mod;
    return ret;
}

int main()
{
    cin>>n>>mod;//求第n位斐波那契数
    f.g[1][1]=0;
    f.g[1][2]=1;
    f.g[2][1]=1;
    f.g[2][2]=1;
    printf("%lld\n",(long long)solve());
    return 0;
}