【HDU】3441 Rotation

题意：给出A和C(1<=A,C<=10^9)，所有满足B * B * K + 1 = A * A, (K >= 0)的B，构成边长为B的正方形，等角度的围绕在一个小正方形的周围。用C种颜色着色，边长为B的正方形旋转后相同视为相同的方案，整个图形绕中间的小正方形旋转后相同也视为相同的着色方案，求着色方案数。

整体思路是：

首先，忽略中间的小正方形，得到所有的B，求边长为B的着色的方案数X。

其次，将每个B看成一个点，求用X种颜色对一个环着色的方案数。

最后，将答案乘以C。

要得到所有的B。由于A*A达10^18次方，根号n的复杂度寻找B肯定行不通。观察到B*B*K=A*A-1=(A+1)*(A-1)。

因此，分别对A+1和A-1分解质因子。

通过DFS枚举质因子得到B的值，同时剩下的质因子是K的。

再通过一个DFS对剩下的质因子枚举出K的约数即可。

对正方形着色：【HDU】1812 Count the Tetris

对环着色：【POJ】2154 Color

#include<cstdio>
#include<cstring>
#include<algorithm>
#define MAXN 32000
#define P 1000000007
typedef long long LL;
using namespace std;
bool p[MAXN], flag1, flag2;
LL A, B, C, K;
LL ans1, ans2;
int depth1, depth2;
int prime[MAXN], factor[MAXN];
int prime_size, factor_size, prifac_size;
struct node {
    int val, cnt;
} prifac[MAXN];
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_size = 0;
    for (i = 2; i < MAXN; i++) {
        if (p[i])
            prime[prime_size++] = i;
    }
}
void Factor(int x) {
    int i;
    for (i = 0; prime[i] * prime[i] <= x; i++) {
        while (x % prime[i] == 0) {
            factor[factor_size++] = prime[i];
            x /= prime[i];
        }
    }
    if (x > 1)
        factor[factor_size++] = x;
}
LL Pow(LL a, LL b) {
    LL ans;
    for (ans = 1; b; b >>= 1) {
        if (b & 1)
            ans *= a;
        a *= a;
    }
    return ans;
}
LL PowMod(LL a, LL b, LL c) {
    LL ans;
    a %= c;
    for (ans = 1; b; b >>= 1) {
        if (b & 1) {
            ans *= a;
            ans %= c;
        }
        a *= a;
        a %= c;
    }
    return ans;
}
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;
}
LL Count1(LL n) {
    LL ans;
    if (n & 1)
        ans = (n - 1) * (n / 2 + 1) / 2 + 1;
    else
        ans = (n / 2) * (n / 2);
    return ans;
}
LL Count2(LL n) {
    LL ans;
    if (n & 1)
        ans = (n + 1) * (n - 1) / 2 + 1;
    else
        ans = n * n / 2;
    return ans;
}
LL Square(LL x, LL k) {
    LL ans;
    ans = PowMod(k, x * x, P);
    ans += PowMod(k, Count1(x), P) * 2 % P;
    if (ans >= P)
        ans -= P;
    ans += PowMod(k, Count2(x), P);
    if (ans >= P)
        ans -= P;
    return ans * InvMod(4, P) % P;
}
LL Phi(LL x) {
    int i;
    LL res;
    res = x;
    for (i = 0; i < prifac_size; i++) {
        if (prifac[i].cnt && x % prifac[i].val == 0)
            res -= res / prifac[i].val;
    }
    return res % P;
}
void Find(int now, int index, LL res, LL color) {
    if (now == depth2) {
        flag2 = true;
        ans2 += PowMod(color, res, P) * Phi(K / res) % P;
        if (ans2 >= P)
            ans2 -= P;
    } else {
        int i, j;
        for (i = index; i < prifac_size; i++) {
            for (j = 1; j <= prifac[i].cnt; j++)
                Find(now + 1, i + 1,
                        res * Pow(prifac[i].val, j),
                        color);
        }
    }
}
LL Burnside(LL n, LL k) {
    ans2 = 0;
    for (depth2 = 0;; depth2++) {
        flag2 = false;
        Find(0, 0, 1, k);
        if (!flag2)
            break;
    }
    return ans2 * InvMod(n, P) % P;
}
void DFS(int now, int index, LL res) {
    if (now == depth1) {
        flag1 = true;
        B = res;
        K = (A - 1) * (A + 1) / (B * B);
        ans1 += Burnside(K, Square(B, C));
        if (ans1 >= P)
            ans1 -= P;
    } else {
        LL tmp;
        int i, j;
        for (i = index; i < prifac_size; i++) {
            for (j = 2; j <= prifac[i].cnt; j += 2) {
                prifac[i].cnt -= j;
                tmp = res * Pow(prifac[i].val, j >> 1);
                DFS(now + 1, i + 1, tmp);
                prifac[i].cnt += j;
            }
        }
    }
}
LL Cal() {
    int i, j;
    factor_size = prifac_size = 0;
    Factor(A - 1);
    Factor(A + 1);
    sort(factor, factor + factor_size);
    for (i = 0; i < factor_size; i = j) {
        prifac[prifac_size].val = factor[i];
        prifac[prifac_size].cnt = 0;
        for (j = i; j < factor_size && factor[i] == factor[j]; j++)
            prifac[prifac_size].cnt++;
        prifac_size++;
    }
    ans1 = 0;
    for (depth1 = 0;; depth1++) {
        flag1 = false;
        DFS(0, 0, 1);
        if (!flag1)
            break;
    }
    return ans1 * C % P;
}
int main() {
    int c, ca = 1;
    LL ans;
    Init();
    scanf("%d", &c);
    while (c--) {
        scanf("%lld%lld", &A, &C);
        if (A == 1)
            ans = C;
        else
            ans = Cal();
        printf("Case %d: %lld\n", ca++, ans);
    }
    return 0;
}