Solution -「JZOJ #5457」项链

$\mathscr{Description}$

  Private link.

  给定一条有 $n$ 个点的圆环和 $m$ 中颜色, 求在位置旋转, 位置翻转, 颜色旋转等价的意义下, 本质不同的染色方案数.

  数据组数 $T\le20$, $n,m\le10^{18}$.

$\mathscr{Solution}$

  颜色旋转 ... 那么它就不是颜色了, 就用 Burnside 就行.

  首先需要明确的是, 我们的变换群长什么样子. 以 $n=4,m=3$ 的情况为例:

$$\begin{aligned} G &= (\{ \iota_4, \begin{pmatrix}4&1&2&3\end{pmatrix}, \begin{pmatrix}3&4&1&2\end{pmatrix}, \begin{pmatrix}2&3&4&1\end{pmatrix} \} \\ &\cup\{ \iota_4, \begin{pmatrix}2&1&4&3\end{pmatrix}, \begin{pmatrix}3&2&1&4\end{pmatrix}, \begin{pmatrix}4&3&1&2\end{pmatrix} \})\\ &\times \{ \iota_3, \begin{pmatrix}3&1&2\end{pmatrix}, \begin{pmatrix}2&3&1\end{pmatrix} \}. \end{aligned}$$

第一组是位置旋转, 第二组是位置对称翻转, 第三组是颜色旋转, $\times$ 是笛卡尔积.

  Burnside, 考虑不动点. 假设某个 (位置, 颜色) 的映射对为 $(\varphi_p,\varphi_c)$, 位置 $x$ 的颜色为 $c(x)$, 那么不动点需要满足 $\varphi_c(c(x))=c(\varphi_p(x))$. 先来研究 $\varphi_p$ 是旋转置换的情况. 通过一些形象的观察可以发现, 设 $\varphi_p$ 的轮换大小为 $l_1$, $\varphi_c$ 的轮换大小为 $l_2$, 则不动点存在当且仅当 $l_2\mid l_1$. 此时对于 $\varphi_p$ 的一个环, 只要确定其中一个位置的颜色, 就可以根据 $\varphi_c(c(x))=c(\varphi_p(x))$ 唯一确定环上其他点的颜色, 此时环的方案数为 $m$.

  因此, 枚举 $l_1,l_2$, 我们可以得到 $\varphi_p$ 是旋转置换时的不动点总数 (式子里的 $\varphi$ 是欧拉函数 w):

$$\begin{aligned} \textit{ans}_1 &= \sum_{l_1\mid n}\varphi(l_1)\sum_{l_2\mid m,l_2\mid l_1}\varphi(l_2)m^{n/l_1}\\ &= \sum_{l_1\mid n}\varphi(l_1)m^{n/l_1}\gcd(m,l_1). \end{aligned}$$

  此后, 对于对称置换的 $\textit{ans}_2$, 需要讨论一下奇偶性:

1. $2\nmid n$, 此时所有置换的都有一个 $l_1=1$ 的轮换, 因此 $l_2=1$. 总不动点数为 $n\cdot m^{(n+1)/2}$.
2. $2\mid n,2\nmid m$, 当对称轴放在两个点上时, 和前一种一样, 总不动点数为 $n/2\cdot m^{n/2+1}$; 当对称轴放在两对点中间时, 所有 $l_2=2$, 但是 $2\nmid m$, 所以还是有 $l_2=1$, 总不动点数为 $n/2\cdot m^{n/2}$.
3. $2\mid n,2\mid m$, 当对称轴放在两个点上时还是 $n/2\cdot m^{n/2+1}$; 当对称轴放在两对点中间时, $l_2$ 可以取 $1$ 或 $2$, 总不动点数为 $n/2\cdot m^{n/2}+n/2\cdot m^{n/2}$.

  置换群大小为 $2nm$, 所以答案为 $(\textit{ans}_1+\textit{ans}_2)/(2nm)$. 计算上需要 Pollard-Rho, 精细处理 $\gcd$, 顺便预处理 $m$ 的光速幂, 可以做到 $\mathcal O(d(n))$.

$\mathscr{Code}$

/*+Rainybunny+*/

// #pragma GCC optimize("Ofast")

#include <bits/stdc++.h>

#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)

typedef long long LL;
typedef std::unordered_map<LL, int> MType;
typedef MType::iterator IType;
#define fi first
#define se second

const int MOD = 998244353;
int ans;
LL n, m;

namespace Factor {

inline LL add(LL u, const LL v, const LL m) {
    return (u += v) < m ? u : u - m;
}

inline LL mul(const LL u, const LL v, const LL m) {
    return __int128(u) * v % m;
}

inline LL mpow(LL u, LL v, LL m) {
    LL ret = 1;
    for (; v; u = mul(u, u, m), v >>= 1) ret = mul(ret, v & 1 ? u : 1, m);
    return ret;
}

inline LL gcd(const LL u, const LL v) { return v ? gcd(v, u % v) : u; }

inline LL labs(const LL u) { return u < 0 ? -u : u; }

inline bool millerRabin(const LL x, const LL b) {
    LL k = x - 1; while (!(k & 1)) k >>= 1;
    static LL pwr[70]; pwr[0] = 1, pwr[1] = mpow(b, k, x);
    while (k != x - 1) {
        pwr[pwr[0] + 1] = mul(pwr[pwr[0]], pwr[pwr[0]], x);
        ++pwr[0], k <<= 1;
    }
    per (i, pwr[0], 1) {
        if (pwr[i] != 1 && pwr[i] != x - 1) return false;
        if (pwr[i] == x - 1) return true;
    }
    return true;
}

inline bool isprime(const LL x) {
    if (x == 2 || x == 3 || x == 5 || x == 7 || x == 11) return true;
    if (x == 61 || x == 127) return true;
    if (!(x % 2) || !(x % 3) || !(x % 5) || !(x % 7) || !(x % 11))return false;
    if (!(x % 61) || !(x % 127)) return false;
    return millerRabin(x, 2) && millerRabin(x, 61) && millerRabin(x, 127);
}

inline LL pollardRho(const LL x) {
    static std::mt19937 emt(time(0) ^ 20120712);
    for (LL a = emt() % (x - 1) + 1, len = 1, st = 0, ed = 0; ;
      len <<= 1, st = ed) {
        LL prd = 1;
        rep (stp, 1, len) {
            prd = mul(prd, labs(st - (ed = add(mul(ed, ed, x), a, x))), x);
            if (!(stp & 127) && gcd(prd, x) > 1) return gcd(prd, x);
        }
        if (gcd(prd, x) > 1) return gcd(prd, x);
    }
}

inline void factor(LL x, MType& res, const int k = 1) {
    if (x == 1) return ;
    if (isprime(x)) return void(res[x] += k);
    LL d = pollardRho(x); int cnt = 0;
    while (!(x % d)) x /= d, ++cnt;
    factor(x, res, k), factor(d, res, k * cnt);
}

} // namespace Factor

inline int mul(const int u, const int v) { return 1ll * u * v % MOD; }
inline void subeq(int& u, const int v) { (u -= v) < 0 && (u += MOD); }
inline int sub(int u, const int v) { return (u -= v) < 0 ? u + MOD : u; }
inline void addeq(int& u, const int v) { (u += v) >= MOD && (u -= MOD); }
inline int add(int u, const int v) { return (u += v) < MOD ? u : u - MOD; }
inline int mpow(int u, int v) {
    int ret = 1;
    for (; v; u = mul(u, u), v >>= 1) ret = mul(ret, v & 1 ? u : 1);
    return ret;
}

MType buc;

inline int solve(const IType it, const int phi, const LL l) {
    if (it == buc.end()) {
        return mul(mul(phi, std::__gcd(m, l) % MOD),
          mpow(m % MOD, n / l % (MOD - 1)));
    }

    int ret = 0, tp = phi; LL tl = l;
    IType tmp(std::next(it));
    rep (i, 0, it->se) {
        addeq(ret, solve(tmp, tp, tl));
        tp = mul(tp, (it->fi - !i) % MOD), tl *= it->fi;
    }
    return ret;
}

int main() {
    int T; scanf("%d", &T);
    while (T--) {
        scanf("%lld %lld", &n, &m), ans = 0;

        if (n & 1) {
            addeq(ans, mul(n % MOD, mpow(m % MOD, (n + 1 >> 1) % (MOD - 1))));
        } else {
            addeq(ans, mul((n >> 1) % MOD,
              mpow(m % MOD, (n >> 1) % (MOD - 1))));
            addeq(ans, mul((n >> 1) % MOD,
              mpow(m % MOD, (n / 2 + 1) % (MOD - 1))));
            if (~m & 1) {
                addeq(ans, mul((n >> 1) % MOD,
                  mpow(m % MOD, (n >> 1) % (MOD - 1))));
            }
        }

        buc.clear();
        Factor::factor(n, buc);
        addeq(ans, solve(buc.begin(), 1, 1));

        ans = mul(ans, mpow(mul(m % MOD, (n << 1) % MOD), MOD - 2));
        printf("%d\n", ans);
    }
    return 0;
}