poj2888 Magic Bracelet

给你一个正n（<10^9）边形和m（<10）种色料，要求给正n边形顶点染色并且规定k组颜色对不能相邻，

输入保证n与mod互质，计数染色总方案数（绕图形中心旋转后相同的方案算一种）对mod取模。

问题的关键在于保证给定的颜色对不相邻，而如果我们用传统的容斥来排除不合法的染色方案在题目给定的n的规模下是不具有可操作性的。

考虑n边形的σi旋转置换，显然有循环：

0 : 0 -> i % n -> 2 *i % n ->... -> 0

1 : 1 -> (i + 1) % n -> (i * 2 + 1) % n ->... -> 1

...

d - 1 : d - 1 -> (i + d - 1) % n -> (i * 2 + d - 1) % n ->... d - 1

即存在d个循环，考虑到每个点的位置是等价的且恰处于一个循环节中,有

各循环节长度相等，其值为l = n / d。

第j + 1个循环中的点p满足 p Ξ j (mod n), 因此若(j + d1 * i ) % n = j,

有d1 * i Ξ 0 (mod n), d1 的最小值为lcm(i, n) / i = n * gcd(i, n)即循环节长度l。

解出d = gcd(i, n)。

显然每个循环节内染色相同，假设第i个循环节染色c(i)。

则n边形染色:c(0) -> c(1) ->...-> c(d - 1) -> c(0) -> c(1) ->....c(d - 1)。

这等价于我们用m种颜色对d 边形染色，同时保证染色合法。

也就是说保证染色：(c(0)c(1)) (c(1)c(2))...(c(d-1)c(0))中成对颜色是合法的。（*）

即便到此用容斥解决也是不可行的，需要将其实现到可快速计算的载体中。

令f(p, q)=

1，若p, q色料可以相邻。

0，其他。

则（*）等价于f(c(0), c(1)) * ... * f(c(d-1), c(0)) = 1。

也就是说每种可行方案为该连乘式贡献1。

考虑布尔矩阵F：

F^n（i，j）表示从i到j路径长度为n的路径总数（这里假设任两点之间距离为1）。

如此所求方案数即∑φ(n / d) * F^d * Inversion(n, mod) % mod (d | n)。

http://poj.org/problem?id=2888

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 using namespace std;
 const int mod = ;
 const int maxn = ;
 int n, m, k, n1;
 int prime[], k1;
 int p2[], k2;
 int cnt[];
 int ans;

 struct Matrix{
     int matrix[maxn][maxn];
 }B, C;

 Matrix operator * (Matrix A, Matrix B){
     Matrix C;
     memset(C.matrix, , sizeof C.matrix);
     for(int i = ; i < m; i++){
         for(int j = ; j < m; j++){
             for(int u = ; u < m; u++){
                 int p = A.matrix[i][u], q = B.matrix[u][j];
                 if(p && q) C.matrix[i][j] += p * q;
             }
             C.matrix[i][j] %= mod;
         }
     }
     return C;
 }

 Matrix operator ^ (Matrix A, int p){
     Matrix C;
     memset(C.matrix, , sizeof C.matrix);
     for(int i = ; i < m; i++) C.matrix[i][i] = ;
     while(p){
         if(p & ) C = C * A;
         p >>= ;
         A = A * A;
     }
     return C;
 }

 int phi(int num){
     k2 = ;
     for(int i = ; i < k1; i++) if(num % prime[i] == ) num /= prime[i], p2[k2++] = prime[i];
     for(int i = ; i < k2; i++) num *= p2[i] - ;
     return num % mod;
 }

 int power(int a, int p){
     a %= mod;
     int ans = ;
     while(p){
         if(p & ) ans *= a, ans %= mod;
         p >>= ;
         a *= a;
         a %= mod;
     }
     return ans;
 }

 void dfs(int pos, int num){
     if(pos == k1){
         C = B ^ num;
         int ans1 = ;
         for(int i = ; i < m; i++) ans1 += C.matrix[i][i], ans1 %= mod;
         ans1 = (ans1 * phi(n / num)) % mod;
         ans = (ans + ans1) % mod;
         return;
     }
     int tem = num;
     for(int i = ; i <= cnt[pos]; i++){
         dfs(pos + , tem);
         tem *= prime[pos];
     }
 }

 void solve(){
     n1 = n;
     k1 = ;
     memset(cnt, , sizeof cnt);
     if(!(n & )){
         prime[k1++] = ;
         while(!(n & )) n >>= , ++cnt[k1 - ];
     }
     int mid = (int)sqrt(n);
     for(int i = ; i <= mid; i += ){
         if(n % i == ){
             prime[k1++] = i;
             while(n % i == ) n /= i, ++cnt[k1 - ];
             mid = (int)sqrt(n);
         }
     }
     if(n != ) prime[k1++] = n, ++cnt[k1 - ];
     n = n1;
     ans = ;
     dfs(, );
     ans = ans * power(n, mod - ) % mod;
     printf("%d\n", ans);
 }

 int main(){
     //freopen("in.txt", "r", stdin);
     int T;
     scanf("%d", &T);
     while(T--){
         scanf("%d%d%d", &n, &m, &k);
         for(int i = ; i < m; i++) for(int j = ; j < m; j++) B.matrix[i][j] = ;
         for(int i = , p, q; i < k; i++){
             scanf("%d%d", &p, &q);
             --p, --q;
             B.matrix[p][q] = B.matrix[q][p] = ;
         }
         solve();
     }
     return ;
 }