随（rand）：原根，循环矩阵，dp

20分特判，一个puts("1")一个快速幂，不讲。

50%算法：

上次就讲了，可是应该还是有像 xuefen某 或 Dybal某 一样没听的。

用a×inv(b)%mod来表示分数的时候，这个分数值可加可乘（有空证明）

像是一个dp题啊。

初状态是1方案数为1，然后做乘法转移不就好了嘛？

设dp[i][j]表示进行了i次操作后所得的值为j

dp[i][j*a[k]%mod]+=dp[i-1][j];

复杂度O(mod²×m)

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #include<string>
 #include<cstring>
 #define int long long
 #define m(a) memset(a,0,sizeof(a))
 #define AA cout<<"Alita"<<endl
 using namespace std;
 const int mod=1e9+;
 int ans,S,n,m,p,v[],a[],f[][],g[][],tmp[][];
 int poww(int x,int y,int z)
 {
         int sum=;
         while(y)
         {
                 if(y&) sum=sum*x%z;
                 y>>=;
                 x=x*x%z;
         }
         return sum;
 }
 void X_g()
 {
         memset(tmp,,sizeof(tmp));
         for(int i=;i<p;i++)
         {
                 for(int j=;j<p;j++)
                 {
                         (tmp[][i]+=g[][j]*f[j][i]%mod)%=mod;
                 }
         }
         for(int i=;i<p;i++)
         {
                 g[][i]=tmp[][i];
         }
 }
 void X_f()
 {
         memset(tmp,,sizeof(tmp));
         for(int i=;i<p;i++)
         {
                 for(int j=;j<p;j++)
                 {
                         for(int k=;k<p;k++)
                         {
                                 (tmp[i][j]+=f[i][k]*f[k][j]%mod)%=mod;
                         }
                 }
         }
         for(int i=;i<p;i++)
         {
                 for(int j=;j<p;j++)
                 {
                         f[i][j]=tmp[i][j];
                 }
         }
 }
 void work(int y)
 {
         while(y)
         {
                 if(y&) X_g();
                 y>>=;
                 X_f();
         }
 }
 signed main()
 {
         //freopen("1.in","r",stdin);
         //freopen("1.out","w",stdout);
         scanf("%lld%lld%lld",&n,&m,&p);
         if(p==){puts("");return ;}
         for(int i=;i<=n;i++) scanf("%lld",&a[i]);
         if(n==){printf("%lld",poww(a[],m,p));return ;}
         S=poww(n,mod-,mod);
         for(int i=;i<=n;i++)
         {
                 (v[a[i]%p]+=S)%=mod;
         }
         g[][]=;
         for(int j=;j<p;j++)
         {
                 for(int k=;k<p;k++)
                 {
                         f[j][j*k%p]+=v[k];
                 }
         }
         work(m);
         for(int i=;i<p;i++)
         {
                 (ans+=g[][i]*i%mod)%=mod;
         }
         printf("%lld",ans);
         return ;
 }

Dybala的50分代码（已征得同意后转载）

因为我直接没想这个这么暴力的dp，看到题目的m已经破1e8了那么要么复杂度与之无关要么把它log掉

理论80%算法：

这题m又不是一个计算参数，复杂度不太可能与之无关，尝试log？

带log的dp。。。矩阵快速幂啊！

可以发现dp的第二维并不大，是mod级别，矩阵乘mod³貌似勉强可以接受

O(mod³×log₂m)的复杂度。我也不知道题解为什么说能得80分。

略微一算，知道复杂度已经略微超过极限，卡常？没有用，还是50分。

个人认为把矩阵快速幂和暴力dp的得分设置成一样不太道德。

到现在还有人不会用矩阵快速幂优化dp啊。。。这。。。我该怎么讲？

ans矩阵用来更新答案，base矩阵是快速幂的基底。

普通快速幂是这个样子的：for(;t;t>>=1,base=base*base){if(t&1)ans*=base;base*=base;}

换成矩阵也是一样的啊：for(;t;t>>=1){if(t&1)mult_ans();mult_base();}

只不过是两个矩阵乘法函数而已。

提醒：包括用重载运算符的矩阵乘，传参时要带上‘&’符号，不然有时会TLE/RE

base矩阵的构造也很简单，对于每一个可能被选到的数a[i]，枚举乘之前的数j。

base[j][j*a[i]%p]+=1;（这里是求解总方案书数，如果是概率打法要把1改成概率）

就是能从a转移到b的话，base[a][b]就有值，是方案的话就是1，算概率的话就是概率。

ans矩阵可以弄成一维数组，能略快一些。这题初始为1，那么ans[1]=1就好了。

注意：代码中的p是原题中的mod，而代码中的mod是1e9+7。我是概率打法

 #include<cstdio>
 #define int long long
 #define mod 1000000007ll
 int n,m,p,base[][],ans[],res[][],a[],ANS;
 int pow(int bbase,int t,int modd,int aans=){
     for(;t;t>>=,bbase=bbase*bbase%modd)if(t&)aans=aans*bbase%modd;
     return aans;
 }
 void mult_base(){
     for(int i=;i<p;++i)for(int j=;j<p;++j)for(int k=;k<p;++k)(res[i][j]+=base[i][k]*base[k][j])%=mod;
     for(int i=;i<p;++i)for(int j=;j<p;++j)base[i][j]=res[i][j],res[i][j]=;
 }
 void mult_ans(){
     for(int i=;i<p;++i)for(int j=;j<p;++j)(res[][j]+=ans[i]*base[i][j])%=mod;
     for(int i=;i<p;++i)ans[i]=res[][i],res[][i]=;
 }
 signed main(){
     scanf("%lld%lld%lld",&n,&m,&p);
     if(n==){
         scanf("%lld",&a[]);
         printf("%lld\n",pow(a[],m,p));return ;
     }
     ans[]=;const int P=pow(n,mod-,mod);//概率，即1/n
     for(int i=;i<=n;++i)scanf("%lld",&a[i]),a[i]%=p;
     for(int i=;i<=n;++i)for(int j=;j<p;++j)(base[j][j*a[i]%p]+=P)%=mod;
     for(;m;m>>=){if(m&)mult_ans();mult_base();}
     for(int i=;i<p;++i)(ANS+=ans[i]*i)%=mod;
     printf("%lld\n",ANS);
 }

卡死常数还是50分

100%算法：

想象一下如果题目改一下，你是随机选择数加上它而不是乘，该怎么做？

原始dp方程：dp[i][(j+a[k])%mod]+=dp[i-1][j];

同理，构造矩阵。

base[i][(i+a[j])%mod]=1;//或者概率

写几个不太大的样例，把矩阵写出来，你会发现，它是一个循环矩阵。

这个加法类型的转移矩阵基本上都是循环矩阵（对于不同的被转移数，加数都一样）

回到这道题。

首先从复杂度上考虑，也许可以猜出来这是个循环矩阵。

可是那个诡异的乘法形式并不是循环的，虽然它对于不同的被转移数，乘数都一样。

如果它也是一个加法，该多好啊。

没办法，它是个乘法，我们要接受这个现实。

但是，这并不能阻碍我们把它强制弄成加法。

看看孙金宁老师的叮嘱：啊，什么原根，啊，几次方，啊什么取到所有值。。。（困）

次方？乘法？加法？欧拉定理？

x^a × x^b=x^a+b

诶，这里有加法了！这样可以把乘法换成加法。

动用一下欧拉定理：

x^a × x^b=x^{(a+b)%(mod-1)}

如果题目的所有输入都是x的几次方，就很好做了。

考虑：刚开始一个数是a⁰,你可以从a⁴,a⁷,a²³里面随机选数把它乘起来，值对mod取模，得到ans，求最后ans的期望

这个问题就相当于：考虑：刚开始一个数是0,你可以从4，7，23里面随机选数把它加起来，值对mod-1取模，求最后a^ans%mod的期望

好做好做！就是普通的加法dp，循环矩阵肝它！

但是。。。这个a是多少呢？

继续听孙金宁的数学课。原根啥啥啥的。。。

原根？啥？原根？哦。好吧。原根就原根吧。

如果你比我聪明，你可能会直接发现，既然原根的次方值能够取遍1～mod-1的所有数，那么这些数就都可以用原根唯一确定的表示出来。那么就可以把题目的所有数都用原根表示，然后当成加法dp来做。你就A了。

如果你没我聪明，那么就相当与你和我一样聪明。

那么如果咱们一样聪明，诶，那好啊，咱们都想不到。既然它一直在念叨原根，那就试试拿原根表示呗。

那么首先我们需要求出原根。用题目给出的那个充要条件很好求。

for(int i=;i<p;i++){
    int now=,j;
    for(j=;j<p-;++j)
        if(al[now]==-)//像它描述里说的一样，不能出现重复的，因为它要在mod-1次里取到mod-1个不同值，故不能重复
            al[now]=j,//记录下now这个值唯一确定的对应着i的几次幂
            qpow[j]=now,//记录下来i的j次幂是几，以后会用到
            now=now*i%p;//now是i的j次幂，j++，更新
        else break;
    if(j==p-){g=i;break;}//如果j成功的走完了，没有被中途break掉，那么i就是原根。
    else for(int i=;i<p;++i)al[i]=-;//清空
}

然而我这么求是用了它说的第一条，这样的话可以顺便求出qpow和al数组里面的值。

al数组不仅是用来标记是否出现过的。如果它出现过，还记录了它对应的是原根g的几次幂。

接下来，我们就拥有了1～mod-1里面每个值和g的几次幂间的双向映射。

那么就把原问题映射成加法dp，循环矩阵干他，再映射回来统计答案即可。

 #include<cstdio>
 #define int long long
 #define mod 1000000007ll
 int n,m,p,base[],ans[],res[],a[],ANS;
 int al[],g,qpow[];
 int pow(int bbase,int t,int modd,int aans=){
     for(;t;t>>=,bbase=bbase*bbase%modd)if(t&)aans=aans*bbase%modd;
     return aans;
 }
 void mult_base(){
     for(int i=;i<p;++i)for(int j=;j<p;++j)(res[j]+=base[i]*base[(j-i+p)%p])%=mod;
     for(int i=;i<p;++i)base[i]=res[i],res[i]=;
 }
 void mult_ans(){
     for(int i=;i<p;++i)for(int j=;j<p;++j)(res[j]+=ans[i]*base[(j-i+p)%p])%=mod;
     for(int i=;i<p;++i)ans[i]=res[i],res[i]=;
 }
 signed main(){
     scanf("%lld%lld%lld",&n,&m,&p);
     ans[]=;const int P=pow(n,mod-,mod);
     for(int i=;i<=;++i)al[i]=-;
     for(int i=;i<p;i++){
         int now=,j;
         for(j=;j<p-;++j)
             if(al[now]==-)al[now]=j,qpow[j]=now,now=now*i%p;
             else break;
         if(j==p-){g=i;break;}
         else for(int i=;i<p;++i)al[i]=-;
     }p--;
     for(int i=;i<=n;++i)scanf("%lld",&a[i]),a[i]=al[a[i]];
     for(int i=;i<=n;++i)(base[a[i]]+=P)%=mod;
     for(;m;m>>=){if(m&)mult_ans();mult_base();}
     for(int i=;i<p;++i)(ANS+=ans[i]*qpow[i])%=mod;
     printf("%lld\n",ANS);
 }

于倬浩：然后你就愉快的拿到了100分的好成绩