【HDU】2865 Birthday Toy

题意：n个小圆组成的正n边形，中间有一个大圆。有木棍相连的两个圆不能有相同的颜色，旋转后相同视为相同的方案，求着色方案数。

设有n个小圆，k种颜色(3<=N<=10^9, 4<=K<=10^9)。

首先，很容易想到从k种选一种给大圆，然后用k-1种颜色对小圆着色。

若不存在相邻圆颜色不同这个限制，则直接Burnside定理。

若存在限制，但是颜色种数很少，可以构造矩阵然后快速幂，得到一个置换使着色不变的着色方案数。

现在颜色种数很多，但是颜色限制较简单，可以考虑公式之类的。

考虑将n个圆的环，等分成t部分，每部分有m个圆。F表示m个圆满足限制的着色方案数。

若m=1，则F=0

若m=2，则F=k*(k-1)

若m=3，则F=k*(k-1)*(k-2)

若m=4，则F=k*(k-1)*[(k-1)+(k-2)*(k-2)]

……

观察到F[n]=F[n-1]*(k-2)+F[n-2]*(k-1)。

那么就可以对该递推式构造矩阵快速幂得到每种分法的方案数。

剩下的同【POJ】2888 Magic Bracelet。

#include<cstdio>
#include<cstring>
#include<vector>
#define P 1000000007
#define MAXM 2
#define MAXN 32000
typedef long long LL;
using namespace std;
bool p[MAXN];
vector<int> factor;
vector<int> prime;
struct Matrix {
    LL mat[MAXM][MAXM];
    void Zero() {
        memset(mat, 0, sizeof(mat));
    }
    void Unit() {
        Zero();
        mat[0][0] = mat[1][1] = 1;
    }
    void Build(int k) {
        Zero();
        mat[0][1] = 1;
        mat[0][0] = k - 2;
        mat[1][0] = k - 1;
    }
};
Matrix operator *(Matrix &a, Matrix &b) {
    int i, j, k;
    Matrix tmp;
    tmp.Zero();
    for (i = 0; i < MAXM; i++) {
        for (j = 0; j < MAXM; j++) {
            for (k = 0; k < MAXM; k++)
                tmp.mat[i][j] += a.mat[i][k] * b.mat[k][j];
            tmp.mat[i][j] %= P;
        }
    }
    return tmp;
}
Matrix operator ^(Matrix a, int k) {
    Matrix tmp;
    for (tmp.Unit(); k; k >>= 1) {
        if (k & 1)
            tmp = tmp * a;
        a = a * a;
    }
    return tmp;
}
void Factor(int n) {
    int i;
    factor.clear();
    for (i = 1; i * i < n; i++) {
        if (n % i == 0) {
            factor.push_back(i);
            factor.push_back(n / i);
        }
    }
    if (i * i == n)
        factor.push_back(i);
}
LL ExtGcd(LL a, LL b, LL &x, LL &y) {
    LL t, d;
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    d = ExtGcd(b, a % b, x, y);
    t = x;
    x = y;
    y = t - a / b * y;
    return d;
}
LL InvMod(LL a, LL n) {
    LL x, y;
    ExtGcd(a, n, x, y);
    return (x % n + n) % n;
}
int Count(int x) {
    int res, i;
    res = x;
    for (i = 0; prime[i] * prime[i] <= x; i++) {
        if (x % prime[i] == 0) {
            res -= res / prime[i];
            while (x % prime[i] == 0)
                x /= prime[i];
        }
    }
    if (x > 1)
        res -= res / x;
    return res;
}
LL F(int n, int k) {
    LL res;
    if (n == 1)
        res = 0;
    else if (n == 2)
        res = (LL) k * (k - 1);
    else if (n == 3)
        res = (LL) k * (k - 1) % P * (k - 2);
    else {
        Matrix g;
        g.Build(k);
        g = g ^ (n - 3);
        res = g.mat[0][0] * k % P * (k - 1) % P * (k - 2);
        res += g.mat[1][0] * k % P * (k - 1);
    }
    return res % P;
}
LL Burnside(int n, int k) {
    LL ans;
    int i;
    Factor(n);
    for (i = ans = 0; i < (int) factor.size(); i++) {
        ans += F(factor[i], k) * Count(n / factor[i]) % P;
        if (ans >= P)
            ans -= P;
    }
    return ans * InvMod(n, P) % P;
}
void Init() {
    int i, j;
    memset(p, true, sizeof(p));
    for (i = 2; i < 180; i++) {
        if (p[i]) {
            for (j = i * i; j < MAXN; j += i)
                p[j] = false;
        }
    }
    prime.clear();
    for (i = 2; i < MAXN; i++) {
        if (p[i])
            prime.push_back(i);
    }
}
int main() {
    int n, k;
    Init();
    while (~scanf("%d%d", &n, &k))
        printf("%I64d\n", Burnside(n, k - 1) * k % P);
    return 0;
}