【xsy1237】 字符转换 矩阵快速幂

题目大意：给你两个长度都为n，字符集为{a,b,c}的字符串S和T。

对于字符串S的任意一个字符，我们可以用cost[0]的代价，把字符a变成字符b。用cost[1]的代价，把字符b变成c，用cost[2]的代价，把字符c变成a。

问你在总代价不超过MaxCost的情况下，有多少种方法，使得字符串S与字符串T相同。

两种方法被认为是不同的，当且仅当操作序列的长度是不同的，或者某一步操作的字符不同。

数据范围：$n≤11$，$1≤cost≤10^9$，$0≤MaxCost≤10^9$。

我们先用最少的代价使得$S=T$。不妨设该过程耗费的代价为$MinCost$，操作步数为$MinK$。

我们不难发现，接下来如果某个位置的字符需要发生变化，则该字符必须变化一整圈（变化3次），花费为$cost[0]+cost[1]+cost[2]$。

那么，变化的圈数显然不会超过$(MaxCost-MinCost)/(cost[0]+cost[1]+cost[2])$，我们令该值为$K$。

令$f[X][i][j][k]$表示第$X$次操作时，串$S$满足有$i$个位置与串$T$相同，有$j$个位置需要转$1$次才能与$T$相同，有$k$个位置需转$2$次才能与$T$相同。

显然，我们可以用$f[X][i][j][k]$，去更新：$f[X+1][i-1][j+1][k],f[X+1][i][j-1][k+1],f[i+1][j][k-1]$

不难发现我们可以用矩阵快速幂来加速转移。

考虑到$f[X][i][j][k]$需满足$i+j+k=0$。不难发现矩阵大小上限是$n^2\times n^2$的。

然后就做完了

时间复杂度：$O(n^6\log\ \frac{MaxCost}{Cost})$

 #include<bits/stdc++.h>
 #define N 11
 #define M 82
 #define L long long
 #define MOD 1000000007
 #define A 'a'
 #define B 'b'
 #define C 'c'
 using namespace std;

 struct mat{
     L a[M][M]; int n,m;
     mat(){memset(a,,sizeof(a)); n=m=;}
     mat(int _n,int _m){n=_n; m=_m; memset(a,,sizeof(a));}
     void dw(){
         memset(a,,sizeof(a));
         for(int i=;i<=n;i++) a[i][i]=;
     }
     friend mat operator *(mat a,mat b){
         mat c=mat(a.n,b.m);
         for(int i=;i<=a.n;i++)
         for(int j=;j<=a.m;j++)
         for(int k=;k<=b.n;k++){
             if(a.a[i][k]*b.a[k][j]){
                 int yxq;
                 yxq=;
             }
             c.a[i][j]=(c.a[i][j]+a.a[i][k]*b.a[k][j])%MOD;
         }
         return c;
     }
     friend mat operator ^(mat a,int b){
         mat ans=mat(a.n,a.n); ans.dw();
         while(b){
             if(b&) ans=ans*a;
             a=a*a; b>>=;
         }
         return ans;
     }
 };
 mat S,sta;

 int c[][]={},h[][]={};

 int n,times=,lim,k=; char s[]={},t[]={};
 int Init(){
     scanf("%s%s",s,t); n=strlen(s);
     scanf("%d%d%d",&c[A][B],&c[B][C],&c[C][A]);
     c[A][C]=c[A][B]+c[B][C];
     c[B][A]=c[B][C]+c[C][A];
     c[C][B]=c[C][A]+c[A][B];
     h[A][B]=h[B][C]=h[C][A]=;
     h[B][A]=h[C][B]=h[A][C]=;
     scanf("%d",&lim);
     int dn=;
     for(int i=;i<n;i++){
         k+=h[s[i]][t[i]];
         dn+=c[s[i]][t[i]];
     }
     k+=(lim-dn)/(c[A][B]+c[B][C]+c[C][A])*;
 }

 int id[N][N][N]={},cnt=;
 void BuildMatrix(){
     for(int i=;i<=n;i++)
     for(int j=;j<=n;j++)
     for(int k=;k<=n;k++)
     if(i+j+k==n){
         id[i][j][k]=++cnt;
     }
     S=mat(cnt+,cnt+);

     sta=mat(,cnt+);
     int p[]={};
     for(int i=;i<n;i++) p[h[t[i]][s[i]]]++;
     sta.a[][id[p[]][p[]][p[]]]=;

     for(int i=;i<=n;i++)
     for(int j=;j<=n;j++)
     for(int k=;k<=n;k++)
     if(i+j+k==n){
         int ID=id[i][j][k],P=;

         if(i->=) P=id[i-][j+][k]; else P=;
         if(P) S.a[ID][P]=i;

         if(j->=) P=id[i][j-][k+]; else P=;
         if(P) S.a[ID][P]=j;

         if(k->=) P=id[i+][j][k-]; else P=;
         if(P) S.a[ID][P]=k;
     }
     S.a[cnt+][cnt+]=S.a[id[n][][]][cnt+]=;
 }

 int main(){
     Init();
     BuildMatrix();
     S=S^k;
     sta=sta*S;
     cout<<(sta.a[][cnt+]+sta.a[][id[n][][]])%MOD<<endl;
 }