hdu 6395 （整除分块+矩阵快速幂）

是Mally呀！

于 2020-02-17 16:03:48 发布

阅读量246

点赞数

分类专栏： ACM数论

本文链接：https://blog.csdn.net/qq_43235540/article/details/104359799

版权

ACM数论专栏收录该内容

10 篇文章 0 订阅

订阅专栏

小记：

该题的表达式是
$\left[ \begin{matrix} F_n \\ F_{n-1} \\ 1\\ \end{matrix} \right]=\left[ \begin{matrix}3 D & C & [\frac{P}{n}] \\ 1 & 0 & 0\\ 0 & 0 & 1 \end{matrix} \right]*\left[ \begin{matrix} F_{n-1} \\ F_{n-2}\\ 1\\ \end{matrix} \right]$
建议先看代码，再看我其他瞎bb的。

代码是参考htx学长👦的，代码风格值得点赞。

矩阵快速幂

1.注意矩阵乘法不可以用交换律，因此左乘和右乘不一样。

2.精度问题要注意，可以用加（ll）的方式转换。

整除分块：

举P=21,n=13为例子：

l=3,得到这个值k=21/3=7

问有多少个矩阵会相同都取k=7，那么也就是P被分成7份，每份最少是l个，最多是P/7=3个。

即 [l,P/3]=[3,3]之间的矩阵是相同的，即都是 $\left[ \begin{matrix}D & C & 7 \\1 & 0 & 0\\0 & 0 & 1 \\\end{matrix} \right]$

l=4,得到这个值k=21/4=5

也就是P被分成5份，每份的个数最少是l=4个，最多是P/5=4,

即i=[l,P/5]=[4,4]之间的矩阵是相同的，都是 $\left[ \begin{matrix}D & C & 5 \\1 & 0 & 0\\0 & 0 & 1 \\\end{matrix} \right]$

l=5,得到这个值k=21/5=4

也就是P被分成4份，每份的个数最少是l=5个，最多是P/4=5,

即i=[l,P/4]=[5,5]之间的矩阵是相同的，都是 $\left[ \begin{matrix}D & C & 4 \\1 & 0 & 0\\0 & 0 & 1 \\\end{matrix} \right]$

l=6,得到这个值k=21/6=3

也就是P被分成3份，每份的个数最少是l=6个，最多是P/3=7,

即i=[l,P/3]=[6,7]之间的矩阵是相同的，都是 $\left[ \begin{matrix}D & C & 3 \\1 & 0 & 0\\0 & 0 & 1 \\\end{matrix} \right]$

l=8,得到这个值k=21/8=2

也就是P被分成2份，每份的个数最少是l=8个，最多是P/2=10,

即i=[l,P/2]=[8,10]之间的矩阵是相同的，都是 $\left[ \begin{matrix}D & C & 2 \\1 & 0 & 0\\0 & 0 & 1 \\\end{matrix} \right]$

l=11,得到这个值k=21/11=1

也就是P被分成1份，每份的个数最少是l=11个，最多是P/1=21,

又因为n=13<P/1,

故[l,P/1]=[11,13]之间的矩阵是相同的，都是 $\left[ \begin{matrix}D & C & 1 \\1 & 0 & 0\\0 & 0 & 1 \\\end{matrix} \right]$

代码

#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
typedef long long ll;
struct Mat{
    int a[3][3],n;
    Mat(){ memset(a,0,sizeof(a));n=3;}
    int* operator[](int x){return a[x];}
    Mat operator *(Mat bb)
    {
        Mat dst;
        for(int r=0;r<n;++r)
            for(int c=0;c<n;++c)
                for(int k=0;k<n;++k)
                    dst[r][c]=(dst[r][c]+(ll)a[r][k]*bb[k][c]%mod)%mod;  
                    //tip:对其中一个数变ll,那么这个算式也会自动转ll ;这里不加ll也会wa
        return dst;
    }

};
Mat matrix_pow(Mat rst,int n)
{
    Mat dst;
    for(int i=0;i<rst.n;++i)dst[i][i]=1;
    while(n)
    {
        if(n&1)dst=rst*dst; //这里左乘还是右乘都没有关系，还不明白原因
        rst=rst*rst;
        n=n>>1;
    }
    return dst;
}

int A,B,C,D,P,n;
int solve()
{
    Mat src;
    if(n==1)return A;
    if(n==2)return B;
    for(int i=0;i<src.n;++i)src[i][i]=1;
    for(int l=3,k,r;l<=n;l=r+1)
    {
        k=P/l;
        r= k&&(P/k)<n ? P/k:n;  //这个地方体现的就是整除分块
        Mat rst;
        rst[0][0]=D;
        rst[0][1]=C;
        rst[0][2]=k;
        rst[1][0]=1;
        rst[2][2]=1;
        rst=matrix_pow(rst,r-l+1);
        src=rst*src;          //这里是矩阵乘法的坑点，注意左乘和右乘是有区别的，而在这题目中，我们用的是左乘。
    }
    return ((ll)src[0][0]*B%mod+(ll)src[0][1]*A%mod+src[0][2])%mod;

}
int main(void)
{
//    freopen("in.text","r",stdin);
    int cas;
    scanf("%d",&cas);
    while(cas--)
    {
        cin>>A>>B>>C>>D>>P>>n;
        printf("%d\n",solve());
    }
    return 0;
}