[luogu p8338] [AHOI2022] 排列
P8338 [AHOI2022] 排列 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
\(T\) 组数据。
对于一个长度为 \(n\) 的排列 \(P = (p_1, p_2, \ldots, p_n)\) 和整数 \(k \ge 0\)，定义 \(P\) 的 \(k\) 次幂
该排列的第 \(i\) 项为
容易证明任意排列的任意次幂都是一个排列。
定义排列 \(P\) 的循环值 \(v(P)\) 为最小的正整数 \(k\) 使得 \(P^{(k + 1)} = P\)。
给出一个长度为 \(n\) 的排列 \(A = (a_1, a_2, \ldots, a_n)\)，对于整数 \(1 \le i, j \le n\)，定义 \(f(i, j)\)：若存在 \(k \ge 0\) 使得 \(a^{(k)}_i = j\)，则 \(f(i, j) = 0\)，否则设排列 \(A_{i, j}\) 为将排列 \(A\) 的第 \(i\) 项 \(a_i\) 和第 \(j\) 项 \(a_j\) 交换后得到的排列，则 \(f(i, j) = v(A_{i, j})\)。
求 \(\sum_{i = 1}^{n} \sum_{j = 1}^{n} f(i, j)\) 的值。答案可能很大，你只需要输出其对 \(({10}^9 + 7)\) 取模的结果。
-
\(1 \le T \le 5\)；
-
\(1 \le a_i \le n \le 5 \times 10^5\)。
首先明确一下排列的基本定义：长度为 \(n\) 的排列指的是一个 \(n\) 元组（可以理解为长度为 \(n\) 的数组），满足 \(1\) 到 \(n\) 这 \(n\) 个数，每个数都恰好在这个 \(n\) 元组中出现 \(1\) 次。
观察题目中排列的幂的定义，从 \(P^{(k)}\) 到 \(P^{(k + 1)}\)，是通过将 \(P^{(k)}\) 中每一个数 \(v\) 更改为 \(p_v\) 得到的，也就是一种类似于 \(i \to p_i\) 的迭代。
考虑对于长度为 \(n\) 的排列 \(P\) ，构造一个有向图 \(G\)，图 \(G\) 中恰有 \(n\) 个编号从 \(1\) 到 \(n\) 的点和 \(n\) 条边，第 \(i\) 条边为 \(i \to p_i\)。
发现这个图会是一堆简单环构成的（可以有自环），这是因为图 \(G\) 经过上述连边方式，每个点的入度一定恰好为 \(1\)（注意到排列的性质），出度也一定恰好为 \(1\)，如此以来一定会形成一堆简单环的集合。
这么建图我们的目的在于将 \(i \to p_i\) 的迭代具体化——一开始有 \(n\) 个小人，第 \(i\) 个小人在节点 \(i\)，每个小人顺着所在的环走 \(k\) 步后，第 \(i\) 个小人所在的节点就是 \(P^{(k)}\) 的第 \(i\) 个元素。
举个例子：\(P = (3, 1, 2)\)。对排列 \(P\) 建图得到：
第 \(1\) 个小人一开始在 \(1\)，第 \(2\) 个小人一开始在 \(2\)，第 \(3\) 个小人一开始在 \(3\)。\(P^0 = (1, 2, 3)\)。
现在所有小人顺着走一步。第 \(1\) 个小人此时在 \(3\)，第 \(2\) 个小人此时在 \(1\)，第 \(3\) 个小人此时在 \(2\)，因此 \(P^1 = (3, 1, 2)\)。
另外很显然 \(P^1 = P\)。
然后所有小人再顺着走一步，第 \(1\) 个小人此时在 \(2\)，……就可以得到 \(P^2 = (2, 3, 1)\)。
然后再走一步，得到 \(P^3 = (1, 2, 3)\)。发现：这等于 \(P^0\)！
那么接下来肯定又会有 \(P^4 = P^1\)，\(P^5 = P^2\)，\(P^6 = P^3=P^0\)，如此循环下去……发现循环节是 \(3\)。
事实上所有排列的幂都一定会出现循环，而循环节的长度正是 \(v(P)\) 的定义。
定义排列 \(P\) 的循环值 \(v(P)\) 为最小的正整数 \(k\) 使得 \(P^{(k + 1)} = P\)。
我们知道，\(P^ {(k +1)}\) 代表第 \(i\) 个小人在节点 \(p_i\)，每个人顺着走 \(k\) 步后的结果。
那么 \(P^{(k + 1)} = P\) 是什么意思？ 也就是说，每个小人一开始在 \(p_i\)，能满足所有人挨个顺着走 \(k\) 步后还能回到 \(p_i\)。\(v(P)\) 描述了 \(k\) 的最小值。
设总共有 \(m’\) 个环，第 \(i\) 个环的环长是 \(r_i\)，于是有 \(v(P) = \operatorname{lcm}(r_1, r_2, \cdots, r_{m'})\)。原因：每个人在 \(p_i\)，走 \(k\) 步还能回来，充要条件就是 \(k\) 是所有环长的倍数，那最小的 \(k\) 就是所有环长的最小公倍数。
举个例子，我们对 \(P = (4, 6, 8, 9, 2, 5, 10, 7, 1, 3)\) 进行循环值分析。首先画个图：
发现总共有 \(3\) 个环，长度分别为 \(4, 3, 3\)，于是 \(v(P)\) 就应该等于 $ \operatorname{lcm}(4, 3, 3) = 12$。因为所有小人都至少走 \(12\) 步后，才能保证所有小人回到原位置。
现在来把视线转移到排列 \(A\) 上。
对于整数 \(1 \le i, j \le n\)，定义 \(f(i, j)\)：若存在 \(k \ge 0\) 使得 \(a^{(k)}_i = j\)，则 \(f(i, j) = 0\)，否则设排列 \(A_{i, j}\) 为将排列 \(A\) 的第 \(i\) 项 \(a_i\) 和第 \(j\) 项 \(a_j\) 交换后得到的排列，则 \(f(i, j) = v(A_{i, j})\)。
分别考虑。
什么时候存在 \(k \ge 0\) 使得 \(a^{(k)}_i = j\)？
先来看 \(a_i^{(k)}\) 是个什么东西。阅读题目我们发现，它其实是 \(A^k\) 的第 \(i\) 项。
考虑在 \(A\) 的图上，发现所有的 \(a_i^{(k)}\) 其实也就是在说图上的 \(a_i\) 这个点走 \(k\) 步。由于 \(k\) 的取值是任意的，那么只要 \(a_i\) 和 \(j\) 在同一个环上，那么 \(a_i\) 就可以走 \(k\) 步到达 \(j\)。
也就是说：\(a_i\) 和 \(j\) 在同一个环上，是存在 \(k \ge 0\) 使得 \(a^{(k)}_i = j\) 的充要条件。
否则，怎么求 \(v(A_{i, j})\)？
考虑交换 \(a_i\) 和 \(a_j\) 会有什么影响。
由于我们现在知道，\(a_i\) 和 \(j\) 不在同一个环上（否则会走上面那个分支），然后 \(j\) 在 \(a_j\) 在同一个环上，因此 \(a_i\) 和 \(a_j\) 不在同一个环上。
交换 \(a_i\) 和 \(a_j\)，相当于在 \(A\) 对应的图基础上，将 \(i \to a_i\) 和 \(j \to a_j\) 这两条边分别改为 \(i \to a_j\) 和 \(j \to a_i\)，其他的边都不变，形成的新图就是 \(A_{i, j}\) 的图。
发现这样修改，相当于将 \(a_i\) 和 \(a_j\) 所在的两个环合并成一个大环，环长是原来两个小环长的和。
证明：假设 \(pre_i\) 是 \(i\) 的前驱（\(a_i\) 是 \(i\) 的后继），假设原来是 \(pre_i \to i \to a_i \to \cdots \to pre_i\) 和 \(pre_j \to j \to a_j \to \cdots \to pre_j\) 两个小环，那么 \(A_{i, j}\) 的图里面就会变成 \(pre_i \to i \to a_j \to \cdots \to pre_j \to j \to a_i \to \cdots \to pre_i\) 这样一个大环。
举个例子，假设 \(A = (4, 6, 8, 9, 2, 5, 10, 7, 1, 3)\)（没错还是那个熟悉的排列）。把图再放一遍：
现在考虑从 \(A\) 扩展到 \(A_{5, 3}\)。\(a_5 = 2, a_3 = 8\)，那么我们应该把 \(5 \to 2\) 和 \(3 \to 8\) 这两条边分别改为 \(5 \to 8\) 和 \(3 \to 2\)。
然后就会变成这样：
可以看到确实是 \(a_i\) 和 \(a_j\) 所在的两个环合并了。
所以 \(v(A_{i, j})\) 其实就是把 \(a_i\) 和 \(a_j\) 所在的两个环加和，和其他的所有环长取 \(\operatorname{lcm}\) 的结果。
上面这个例子中就是 \(v(A_{5, 3}) = \operatorname{lcm}(4 + 3, 3) = 21\)。
到这里已经理论可做了，我们已经大体完成了翻译题目的工作。现在考虑加速最后结果的计算。
还是上面那个图，再放一次：
我们把目标锁定在上面那个环和左下角那个环。会发现，从上面那个环随便选一个点，从左下角那个环随便选一个点，交换，结果肯定是 \(21\)。比如：\(v(A_{5, 8}) = v(A_{2, 7}) = v(A_{6, 10}) = v(A_{2, 3}) = 21\)。
再把目标锁定在上面那个环和右下角那个环，发现随便选之后答案仍然是 \(21\)。\(v(A_{8, 9}) = v(A_{7, 1}) = v(A_{3, 4}) = v(A_{9, 3}) = 21\)。
那有不是 \(21\) 的吗？如果我们把目标锁定在下面这两个环，那么答案就会恒为 \(\operatorname{lcm}(4, 3 + 3) = 12\)。
为什么会这样呢？发现他跟我们选取两个点所在的环的长度有关系。选取两个点所在环长度分别是 \(3, 4\)，那答案就是 \(21\)；选取的两个点所在环长度分别是 \(3, 3\)，那么答案就是 \(12\)。那为啥没有 \(4, 4\) 呢，因为没有两个长度为 \(4\) 的环，选不出来。
如果两个环的长度相同，我们可以认为他们的本质是相同的，设本质不同的环总共有 \(m\) 个，这个 \(m\) 最多可能有多少个？
我们知道，环长总和不能超过 \(n\)，因此最坏的情况就是环长分别为 \(1, 2, 3, \cdots, m\) 的情况，即使这样 \(m\) 也是 \(\sqrt n\) 量级的。
这是一个经典结论：如果 \(\Sigma w_i = n\)，那么值不同的 \(w_i\) 的种类是 \(\sqrt n\) 量级的（而且不满）。
因此只要枚举本质不同的环长，进行计算。
我们设 \(v(i, j)\) 表示将长度为 \(i\) 的环和长度为 \(j\) 的环合并后排列的循环值，考虑它会对最后的答案产生多少个贡献。我们再设 \(c_i\) 表示长度为 \(i\) 的环的数量。
需要分两种情况讨论：
- \(i \ne j\)，根据乘法原理，贡献量应该是长度为 \(i\) 的所有环里的所有点的数量（数目为 \(c_i \times i\)，环数量乘环长），乘上长度为 \(j\) 的所有环里所有点的数量（数目为 \(c_j \times j\)），也就是 \(c_i \times i \times c_j \times j\)。
- \(i = j\)，即 \(v(i, i)\) 的贡献。首先肯定需要满足 \(c_i > 1\)，因为至少有 \(2\) 个长度为 \(i\) 的环才能实现交换。同样根据乘法原理能得到贡献是 \(c_i \times i \times (c_i - 1) \times i\)。
根据对称性，上面的第一种情况中，也可以直接把 \(j\) 从 \(i + 1\) 开始枚举，给贡献乘个 \(2\) 就行了。
由于枚举的开销是 \(m \times m= n\) 的，直接从 \(n^2\) 优化到线性。
到这里复杂度是 \(\mathcal{O}(n \times m \log n) = \mathcal{O}(n \sqrt{n} \log n)\)。虽然拿不到满分也能拿到一个高分了。（这个复杂度似乎是 \(80\) 分）
我们发现原题实际上就是想维护一个可重集合的 \(\operatorname{lcm}\)，支持询问删除 \(2\) 个数，增加 \(1\) 个数之后新的 \(\operatorname{lcm}\) 的操作。询问之间互相独立（一次询问不会真的增删数）
但是发现 \(\operatorname{lcm}\) 有可能非常大，很有可能不能直接算。
于是有了这样的启发：考虑对每个 \(r_i\) 质因数分解，然后取每个质因子的幂次最大值计算结果。不过事实上我们后面还要获取两个环合并后长度的质因数分解，他可能不在 \(r_i\) 中，所以我们需要把 \(n\) 以内的数都预处理质因数分解好。
注意这里有一个小技巧：将 \(2\) 到 \(n\) 所有数质因数分解，可以先对 \(2\) 到 \(n\) 跑线性筛，同时记录每个数的最小质因子。然后再对 \(2\) 到 \(n\) 每个数枚举，对于一个数，不断除以它的最小质因子，直到除尽，再把除尽后剩下的数接着不断除以它的最小质因子……直到分解到剩下 \(1\) 为止。这样因式分解的复杂度可以从 \(\mathcal{O}(n \sqrt n)\) 优化到 \(\mathcal{O}(n \log n)\)。
那么就可以转化为维护若干个质数幂（所有环长的质因数分解出来的所有质因子幂的并集，同样，是可重集），支持询问删除 \(2\) 个数对应的质因子幂，增加 \(1\) 个数对应的质因子幂的情况下，每一个质因子的最大幂的乘积（就是 \(\operatorname{lcm}\)）。询问互相独立。
然后发现一开始那个集合只用记录下所有质因子幂中，每个质数对应最大的 \(3\) 个幂，因为后面的不可能影响到 \(\operatorname{lcm}\)。比如如果集合里有 \(2^2, 2^3, 2^4, 2^7\)，那么 \(2^2\) 就是没有用的。因为删掉两个数后，\(2^3, 2^4, 2^7\) 会至少剩下一个，轮不到 \(2^2\) 头上，因此它可以直接放弃统计。
所以询问直接暴力删暴力加暴力获取最大值即可，一次询问中，每个质因数的暴力都是小常数级别的，所以单次询问是 \(\mathcal{O}(\log n)\) 的。
总复杂度 \(\mathcal{O}(n \log n)\)。小常数可以和跑不太满的 \(\log n\) 抵消抵消。
另外，实际上不需要建图，只需要写一个维护大小的并查集即可。
单组数据 \(\mathcal{O}(n \log n)\)。
#include <bits/stdc++.h>
#define int long long
inline int read() {
int x = 0;
bool flag = true;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-')
flag = false;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
if(flag)
return x;
return ~(x - 1);
}
inline bool updmax(int &x, int y) {
return y > x ? x = y, true : false;
}
const int maxn = 500005;
const int maxm = 805; // sqrt(maxn)
const int mod = (int)1e9 + 7;
int a[maxn];
int inv[maxn], pfmin[maxn]; // prime factor min，存放了一个数的最小质因子。
int pr[maxn], pcnt = 0;
bool isp[maxn];
int lcm = 1;
std :: vector <std :: pair <int, int> > pfs[maxn];
// pfs[i] 存的是 i 的质因数分解，为一个 pair <int, int> 数组。
// pair 的第一个元素是质因子，第二个元素是质因子对应的幂（不是指数，因为在这个题里没必要）。
// 具体看代码，代码比这些文字好懂。
inline void pre(int n = maxn - 5) {
inv[1] = pfmin[1] = 1;
for (int i = 2; i <= n; ++i)
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
std :: memset(isp, true, sizeof(isp));
for (int i = 2; i <= n; ++i) {
if (isp[i]) {
pr[++pcnt] = i;
pfmin[i] = i;
}
for (int j = 1; j <= pcnt && i * pr[j] <= n; ++j) {
isp[i * pr[j]] = false;
pfmin[i * pr[j]] = pr[j];
if (i % pr[j] == 0)
break;
}
}
for (int i = 2; i <= n; ++i) {
int t = i;
while (t != 1) {
int p = pfmin[t], q = 1;
while (t % p == 0) {
q *= p;
t /= p;
}
pfs[i].emplace_back(p, q);
// printf("%lld %lld %lld\n", i, p, q);
}
}
}
int siz[maxn], fa[maxn];
inline int find(int x) {
while (x != fa[x])
x = fa[x] = fa[fa[x]];
return x;
}
inline void uni(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return ;
if (siz[x] > siz[y])
x ^= y ^= x ^= y;
fa[x] = y;
siz[y] += siz[x];
}
int cnt[maxn];
std :: vector <int> f[maxn];
inline void insert(int x) {
// printf("%lld\n", x);
for (auto v : pfs[x]) {
int p = v.first, q = v.second;
// printf("%lld %lld\n", p, q);
f[p].push_back(q);
std :: sort(f[p].begin(), f[p].end(), std :: greater <int> ());
// 这里 sort 可以看做常数级别，因为 f[p] 始终大小不超过 3
if (f[p].size() > 3)
f[p].pop_back();
}
return ;
}
int s[maxm], m;
std :: vector <std :: pair <int, int> > g[maxn];
// g[p][i] 表示第 i 个关于质数 p 的幂的修改，first 表示幂的值，second 表示修改量。
// 这个是我们的修改实现，举例说明：
// 删除 12 这个数，先质因数分解 2 ^ 2 * 3
// 然后转化成删掉两个质因子幂，一个 2 ^ 2，一个 3。
// 相当于我们把 2 ^ 2 和 3 的出现次数在集合中分别削了 1，所以 -1 就是两个修改的修改量
// 具体看代码。
int tcnt[maxn];
inline int getv(int p) {
int z = 1;
for (int q : f[p])
++tcnt[q];
for (auto v : g[p])
tcnt[v.first] += v.second;
for (int q : f[p]) {
if (tcnt[q] != 0) {
// 注意！！为什么这里要写成 ！= 0 而不能是 > 0！！！
// 首先，我们想：tcnt[q] 有可能小于 0 吗？
// 其实是可以构造的，只需要让 f[p][2] 这个质因子幂被删两次就可以了。
// （也就是说 f[p][2] 和 f[p][3]（事实上没有）这两个质因子幂相同，而且恰好都被删，
// 但是因为 f[p][3] 因为只存前三个的原则并没有记录，所以 f[p][2] 会被记录一次删除两次。
// 所以 tcnt[q] < 0 是有可能的。
// 由于我们 tcnt[q] 是边扫边清零的（看下面第二行），为了清零成功，我们需要把 < 0 的也清零。
// updmax(z, q) 会被影响吗？
// 我们一次最多删两个数，那么 f[p][2] 被删了两次，f[p][0] 和 f[p][1] 肯定没被删过。
// 那么这一轮的 z 肯定会成功识别出 f[p][0]，所以没有影响。
updmax(z, q);
tcnt[q] = 0;
}
}
for (auto v : g[p]) {
int q = v.first;
if (tcnt[q] != 0) {
// 这里同上，不能写 > 0。
// 这里 < 0 是因为可能会有删掉的质因子幂因为不是前三大没记录在 f 中。
updmax(z, q);
tcnt[q] = 0;
}
}
return z;
}
inline void modify(int x, int val) {
for (auto v : pfs[x]) {
int p = v.first, q = v.second;
(lcm *= inv[getv(p)]) %= mod;
g[p].push_back(std :: make_pair(q, val));
(lcm *= getv(p)) %= mod;
// 把 lcm 暴力除以原来 p 这里的贡献，修改之后再暴力乘回去。
}
}
inline void rec(int x) {
for (auto v : pfs[x])
g[v.first].clear();
// 清空修改
}
inline void init(int n = maxn - 5) {
std :: fill(siz + 1, siz + 1 + n, 1);
std :: iota(fa + 1, fa + 1 + n, 1);
std :: memset(cnt, 0, sizeof(cnt));
std :: memset(s, 0, sizeof(s));
m = 0;
for (int i = 1; i <= n; ++i)
f[i].clear();
lcm = 1;
}
signed main() {
int T = read();
pre();
while (T--) {
init();
int n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
uni(i, a[i]);
}
for (int i = 1; i <= n; ++i) {
if (find(i) == i) {
++cnt[siz[i]];
insert(siz[i]);
// printf("%lld ", siz[i]);
}
}
for (int i = 1; i <= n; ++i)
if (cnt[i] > 0)
s[++m] = i;
for (int i = 1; i <= n; ++i) {
if (!f[i].empty())
(lcm *= f[i][0]) %= mod;
// 初始 lcm
}
// printf("%lld\n", lcm);
int ans = 0;
for (int i = 1; i <= m; ++i) {
int u = s[i];
if (cnt[u] >= 2) {
// puts("meitain");
int org = lcm;
modify(u << 1, 1);
modify(u, -2);
// printf("%lld\n", lcm);
(ans += lcm * cnt[u] % mod * u % mod * (cnt[u] - 1) % mod * u % mod) %= mod;
rec(u << 1);
lcm = org;
}
for (int j = i + 1; j <= m; ++j) {
int v = s[j], org = lcm;
modify(u + v, 1);
modify(u, -1);
modify(v, -1);
(ans += 2 * lcm % mod * cnt[u] % mod * u % mod * cnt[v] % mod * v % mod) %= mod;
rec(u + v);
rec(u);
rec(v);
lcm = org;
}
}
printf("%lld\n", ans);
}
return 0;
}
