HZOJ 随

这个题的题解并不想写……一个写的很详细的blog

第1个测试点:mod=2,a[i]<mod(仔细看题),则n个数字都是1,直接输出1即可.

第2个测试点:每次乘上去的数字只有一种选择,快速幂即可.

第3,4,5个测试点:定义f[i][j]表示i次操作后x的数值为j的概率.直接转移,复杂度O(m*mod^2）

         f[][]=;
         for(int i=;i<m;i++)
             for(int j=;j<mod;j++)
                 for(int k=;k<mod;k++)//这里不要枚举n啊，可以先处理出来每个数出现的概率
                     f[i+][j*k%mod]=(f[i+][j*k%mod]+f[i][j]*v[k]%p)%p;    

第6,7,8个测试点:第3,4,5个测试点中的DP转移可以转化为矩阵乘法形式,利用矩阵快速幂进行优化,复杂度O(mod^3*logm)矩阵快速幂优化dp见--->这里

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<cmath>
 #define int LL
 #define MAXN 100010
 #define LL long long
 using namespace std;
 struct jz
 {
     LL m[][];
     void clear(){memset(m,,sizeof(m));}
 }base;
 int n,m,mod,a[MAXN];
 const int p=1e9+;
 jz operator * (jz &a,jz &b)
 {
     jz ans;ans.clear();
     for(int i=;i<mod;i++)
         for(int j=;j<mod;j++)
             for(int k=;k<mod;k++)
                 ans.m[i][j]=(ans.m[i][j]+a.m[i][k]*b.m[k][j]);
     for(int i=;i<mod;i++)
         for(int j=;j<mod;j++)
             ans.m[i][j]%=p;
     return ans;
 }
 jz operator ^ (jz a,int b)
 {
     jz ans=a;b--;
     while(b)
     {
         if(b&)ans=ans*a;
         a=a*a;
         b=b>>;
     }
     return ans;
 }
 LL f[][],tem;
 LL v[];
 LL poww(LL a,int b,int mod)
 {
     LL ans=;
     while(b)
     {
         if(b&)ans=ans*a%mod;
         a=a*a%mod;
         b=b>>;
     }
     return ans;
 }
 signed main()
 {
 //    freopen("in.txt","r",stdin);
 //    freopen("0.out","w",stdout);

     cin>>n>>m>>mod;tem=poww(n,p-,p);
     for(int i=;i<=n;i++)cin>>a[i],v[a[i]%mod]=(v[a[i]%mod]+tem)%p;
     if(mod==){puts("");return ;}
     if(n==){printf("%lld\n",poww(a[],m,mod));return ;}
     if(m<=)
     {
         f[][]=;
         for(int i=;i<m;i++)
             for(int j=;j<mod;j++)
                 for(int k=;k<mod;k++)
                     f[i+][j*k%mod]=(f[i+][j*k%mod]+f[i][j]*v[k]%p)%p;
         LL ans=;
         for(int i=;i<mod;i++)
             ans=(ans+f[m][i]*i%p)%p;
         printf("%lld\n",ans%p);
     }
     else if(mod<=)
     {
         for(int j=;j<mod;j++)
             for(int k=;k<mod;k++)
                 base.m[j*k%mod][j]=(base.m[j*k%mod][j]+v[k])%p;
         base=base^m;
         LL ans=;
         for(int i=;i<mod;i++)
             ans=(ans+base.m[i][]*i%p)%p;
         printf("%lld\n",ans%p);
     }
 }

这里放出暴力dp和矩阵优化dp

第9,10个测试点(标算)：上面那个blog讲的非常详细了（然而我并没有看懂……），总感觉这个矩阵优化dp怪怪的……

先把达哥题解放出来：

利用原根进行转化,则乘法转化为加法,f[i][j]表示i次操作后x取模后等于原根的j次方的概率.指数需要对(mod-1)取模.这样转化一下我们发现转移还是矩阵的形式,而且是循环矩阵的形式.循环矩阵快速幂,复杂度O(mod^2*logm)

然后是另一种标算（本人写的这个）：

定义f[i][j]表示i次操作后变成原根的j次方的概率.求出p[i][j]表示2^i次操作后变成原根的j次方的概率.倍增的思想求出f[m][]这个数组.也是O(mod^2*logm)

     for(int i=;i<=mod-;i++)p[][i]=tem*cnt[i]%mp;//乘2^0为rt^i的概率，tem为分母的逆元，cnt为个数。
     for(int i=;i<=;i++)
         for(int j=;j<=mod-;j++)
             for(int k=;k<=mod-;k++)
                 p[i][(j+k)%(mod-)]=(p[i][(j+k)%(mod-)]+p[i-][j]*p[i-][k]%mp)%mp;

然后用类似快速幂的方法就可以求出了，避免了直接理解矩阵。

 #include<iostream>
 #include<cstdio>
 #define MAXN 400010
 #define LL long long
 #define int LL
 using namespace std;
 const int mp=1e9+;
 int n,m,mod,a[MAXN];
 int xp[],cnt[];
 int rt;
 int p[][],f[][];
 LL poww(LL a,int b,int mod)
 {
     LL ans=;
     while(b)
     {
         if(b&)ans=ans*a%mod;
         a=a*a%mod;
         b=b>>;
     }
     return ans;
 }
 void findroot()
 {
     for(rt=;rt<mod;rt++)
     {
         bool pd=;
         for(int i=;i<mod-;i++)
             if(poww(rt,i,mod)==){pd=;break;}
         if(pd||poww(rt,mod-,mod)!=)continue;
         else break;
     }
 }
 signed main()
 {
     cin>>n>>m>>mod;
     findroot();int tem=poww(n,mp-,mp),x;
     xp[]=;for(int i=;i<=mod;i++)xp[i]=xp[i-]*rt%mod;
     for(int i=;i<=mod-;i++)a[xp[i]]=i;
     for(int i=;i<=n;i++)cin>>x,cnt[a[x]]++;
     for(int i=;i<=mod-;i++)p[][i]=tem*cnt[i]%mp;//乘2^0为rt^i的概率;
     for(int i=;i<=;i++)
         for(int j=;j<=mod-;j++)
             for(int k=;k<=mod-;k++)
                 p[i][(j+k)%(mod-)]=(p[i][(j+k)%(mod-)]+p[i-][j]*p[i-][k]%mp)%mp;
     f[][]=;
     for(int k=;m;m/=,k++)
     if(m&)
     {
         for(int i=;i<=mod-;i++)f[][i]=;
         for(int i=;i<=mod-;i++)
             for(int j=;j<=mod-;j++)
                 f[][(j+i)%(mod-)]=(f[][(j+i)%(mod-)]+f[][i]*p[k][j]%mp)%mp;
         for(int i=;i<=mod-;i++)f[][i]=f[][i];
     }
     LL ans=;
     for(int i=;i<=mod-;i++)ans=(ans+f[][i]*xp[i]%mp)%mp;
     printf("%lld\n",ans);
 }

完整代码

更加优越的算法（？？？）:本质上我们要做的是循环卷积,可以使用fft.但本题的模数使得fft较为不方便..