题目地址：

https://www.luogu.com.cn/problem/CF1327D

题面翻译：
$T$组数据。每次给一个长度为$n$的置换$p$和颜色数组$c$，求最小的$k$，使$p^k$中存在一个“同色环”。即，存在$i$，使$p_i^k$，$p_{p_i^k}^k$，$\dots$，全部同色。

数据范围：$1\le T\le 10^4$，$1\le n,\sum n\le 2\times 10^5$。

题目描述：
You are given a colored permutation $p_1,p_2,\dots ,p_n$ . The $i$ -th element of the permutation has color $c_i$ .

Let’s define an infinite path as infinite sequence $i,p[i],p[p[i]],p[p[p[i]]]\dots$ where all elements have same color ( $c[i]=c[p[i]]=c[p[p[i]]]=\dots$ ).

We can also define a multiplication of permutations $a$ and $b$ as permutation $c=a\times b$ where $c[i]=b[a[i]]$ . Moreover, we can define a power $k$ of permutation $p$ as $p^k=\underset{k\text{ times}}{\underbrace{p\times p\times \cdots \times p}}$ .

Find the minimum $k>0$ such that $p^k$ has at least one infinite path (i.e. there is a position $i$ in $p^k$ such that the sequence starting from $i$ is an infinite path).

It can be proved that the answer always exists.

输入格式：
The first line contains single integer $T$ ( $1\le T\le 10^4$ ) — the number of test cases.

Next $3T$ lines contain test cases — one per three lines. The first line contains single integer $n$ ( $1\le n\le 2\cdot 10^5$ ) — the size of the permutation.

The second line contains $n$ integers $p_1,p_2,\dots ,p_n$ ( $1\le p_i\le n$ , $p_i\ne p_j$ for $i\ne j$ ) — the permutation $p$ .

The third line contains $n$ integers $c_1,c_2,\dots ,c_n$ ( $1\le c_i\le n$ ) — the colors of elements of the permutation.

It is guaranteed that the total sum of $n$ doesn’t exceed $2\cdot 10^5$ .

输出格式：
Print $T$ integers — one per test case. For each test case print minimum $k>0$ such that $p^k$ has at least one infinite path.

首先每个置换可以分解为若干轮换之乘积，每个轮换是一个封闭的集合，那么同色环一定在某个轮换里。由于循环群的子群也一定是循环群，并且子群的阶是群的阶的因子，从而可以从小到大枚举所有因子，看哪个因子对应的子群是个同色环；对于每个轮换都找到最小的同色环，求出整体的最小解即可。代码如下：

#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;

const int N = 2e5 + 10, INF = N;
int n, a[N], col[N];
bool vis[N];
vector<int> v, fac;
int res;

// 看是否存在同色的k阶子群
bool check(int k) {
  // 所有的k阶子群其实都是群在某个k阶子群下的陪集分解，枚举所有的k阶子群
  for (int s = 0; s < k; s++) {
    int color = col[v[s]];
    bool flag = 1;
    // 看该子群是否同色
    for (int p = s + k; p < v.size(); p += k)
      if (col[v[p]] != color) {
        flag = 0; 
        break;
      }
    // 如果同色，说明存在k阶同色子群，返回true
    if (flag) return true;
  }
  return false;
}

int main() {
  int T;
  scanf("%d", &T);
  while (T--) {
    // 初始化一下答案
    res = INF;
    memset(vis, 0, sizeof vis);
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for (int i = 1; i <= n; i++) scanf("%d", &col[i]);
    
    for (int i = 1; i <= n; i++) {
      if (vis[i]) continue;
      // 求出i所在的轮换
      vis[i] = 1;
      v.clear();
      int p = a[i];
      v.push_back(i);
      for (; p != i; p = a[p]) v.push_back(p), vis[p] = 1;
      // 求出该轮换的阶的所有因子
      fac.clear();
      int s = v.size();
      for (int k = 1; k <= sqrt(s); k++) {
        if (s % k) continue;
        fac.push_back(k);
        if (k < s / k) fac.push_back(s / k);
      }
      // 对因子从小到大排序
      sort(fac.begin(), fac.end());
      // 枚举因子，求出最小的同色子群
      for (int x : fac) 
        if (check(x)) {
          // 找到最小的同色子群，用其阶更新答案
          res = min(res, x);
          break;
        }
    }

    printf("%d\n", res);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

每次询问时间复杂度$O({\sum }_i{l}_i\sqrt{l_i})$，$l_i$是轮换的长度，所以$\sum l_i=n$，空间$O(n)$。