bzoj1004题解

【题意分析】

　　给N个元素染色，可以在定置换群的作用下互相转化的染色方案算相同的，问本质不同的染色方案数。

【解题思路】

　　引理：Burnside定理

设集合S=[1,n]∩N，记等价类数为L，给定S上的置换群G。

Z_k (k不动置换类)：若k是S中某个元素，G中使k保持不变的置换的全体，记以Z_k，叫做G中使k保持不动的置换类，简称k不动置换类。

C(π)(置换n的不动点全集)：对于一个置换π∈G,及a∈X，若π(a)=a，则称a为π的不动点。π的不动点的全体记为C(π)。

有定理：L=1/|G|*∑|Z_k|(k∈S)=1/|G|*Σ|C(n)|(n∈G)。

　　所以，我们只要分别计算G中每个置换的不动点数，就可以计算出等价类数。外层复杂度O(m)。

　　考虑染色，对于每个置换，在同一个置换环中的元素必定染成同色，才能保证集合range(n)经过置换后染色方案不变，所以可以用三维背包来计算方案数。内层复杂度O(SrSgSb+n)。

　　总复杂度O(n^2+nSrSgSb)。

【参考代码】

 #include <cmath>
 #include <cstdio>
 #define REP(I,start,end) for(int I=(start);I<=(end);I++)
 #define PER(I,start,end) for(int I=(start);I>=(end);I--)
 #define REPs(I,start,end,step) for(int I=(start);I<=(end);I+=(step))
 #define PERs(I,start,end,step) for(int I=(start);I>=(end);I-=(step))
 using namespace std;
 typedef unsigned short US;
 typedef unsigned long UL;
 typedef long long LL;
 typedef unsigned long long ULL;
 inline int getint()
 {
     char ch=getchar();
     while((ch<''||ch>'')&&ch!='-')
         ch=getchar();
     int result=0;
     bool impositive=ch=='-';
     if(impositive)
         ch=getchar();
     while(ch>=''&&ch<='')
     {
          result=(result<<3)+(result<<1)+ch-'';
         ch=getchar();
     }
     return impositive?-result:result;
 }
 inline int putint(int n)
 {
     int result=1;
     char* sav=new char[20];
     bool impositive=n<0;
     if(impositive)
     {
         putchar('-');
         n=-n;
     }
     sav[0]=n%10+'';
     while(n/=10)
         sav[result++]=n%10+'';
     PER(i,result-1,0)
         putchar(sav[i]);
     delete []sav;
     return result+impositive;
 }
 inline LL getLL()
 {
     char ch=getchar();
     while((ch<''||ch>'')&&ch!='-')
         ch=getchar();
     LL result=0ll;
     bool impositive=ch=='-';
     if(impositive)
         ch=getchar();
     while(ch>=''&&ch<='')
     {
          result=(result<<3)+(result<<1)+ch-'';
         ch=getchar();
     }
     return impositive?-result:result;
 }
 inline int putLL(LL n)
 {
     int result=1;
     char* sav=new char[20];
     bool impositive=n<0;
     if(impositive)
     {
         putchar('-');
         n=-n;
     }
     sav[0]=n%10+'';
     while(n/=10)
         sav[result++]=n%10+'';
     PER(i,result-1,0)
         putchar(sav[i]);
     delete []sav;
     return result+impositive;
 }
 template<typename integer> inline int read_int(integer &n)
 {
     char ch=getchar();
     while((ch<''||ch>'')&&ch!='-')
         ch=getchar();
     int result=n=integer(0);
     bool impositive=ch=='-';
     if(impositive)
         ch=getchar();
     while(ch>=''&&ch<='')
     {
          n=(n<<3)+(n<<1)+integer(ch-'');
          result++;
         ch=getchar();
     }
     if(impositive)
     {
         n=-n;
         result++;
     }
     return result;
 }
 template<typename integer> inline int write_int(integer n)
 {
     int result=1;
     char* sav=new char[20];
     bool impositive=n<0;
     if(impositive)
     {
         putchar('-');
         n=-n;
     }
     sav[0]=n%10+'';
     while(n/=10)
         sav[result++]=n%10+'';
     PER(i,result-1,0)
         putchar(sav[i]);
     delete []sav;
     return result+impositive;
 }
 template<typename integer> inline integer sqr(integer n)
 {
     return n*n;
 }
 template<typename base_type,typename exp_type> inline base_type PowerMod(base_type Base,exp_type Exp,base_type Mod)
 {
     bool* sav=new bool[int(log(Exp)/log(2))+1];
     int tot=0;
     base_type result=base_type(1),baser=Base%Mod;
     exp_type tmp=Exp;
     while(tmp)
     {
         sav[tot++]=tmp&1;
         tmp>>=1;
     }
     while(tot)
     {
         result=sqr(result)%Mod;
         if(sav[--tot])
             result=result*baser%Mod;
     }
     delete []sav;
     return result;
 }
 //====================================Header Template===================================
 #include <cstring>
 bool used[100];
 int sr,sb,sg,n,p,trans[100],cnt[100],f[30][30][30];
 inline int mod_reverse(int _n,int _p)
 {
     return PowerMod(_n,_p-2,_p);
 }
 inline int DP()
 {
     memset(f,0,sizeof(f));
     memset(used,0,sizeof(used));
     int group=0;
     REP(i,1,n)
         if(!used[i])
         {
             used[i]=true;
             int j=trans[i],tot=1;
             while(!used[j])
             {
                 used[j]=true;
                 tot++;
                 j=trans[j];
             }
             cnt[++group]=tot;
         }
     f[0][0][0]=1;
     REP(g,1,group)
         PER(i,sr,0)
             PER(j,sb,0)
                 PER(k,sg,0)
                 {
                     if(i>=cnt[g])
                         (f[i][j][k]+=f[i-cnt[g]][j][k])%=p;
                     if(j>=cnt[g])
                         (f[i][j][k]+=f[i][j-cnt[g]][k])%=p;
                     if(k>=cnt[g])
                         (f[i][j][k]+=f[i][j][k-cnt[g]])%=p;
                 }
     return f[sr][sb][sg];
 }
 int main()
 {
     sr=getint();
     sb=getint();
     sg=getint();
     int m=getint();
     p=getint();
     n=sr+sb+sg;
     int ans=0;
     REP(i,1,m)
     {
         REP(j,1,n)
             trans[j]=getint();
         (ans+=DP())%=p;
     }
     REP(i,1,n)
         trans[i]=i;
     (ans+=DP())%=p;
     putint(ans*mod_reverse(m+1,p)%p);
     return 0;
 }