Infinite Path
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=\underbrace{p \times p \times \dots \times p}_{k \text{ times}}$$$.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.
In the first test case, $$$p^1 = p = [1, 3, 4, 2]$$$ and the sequence starting from $$$1$$$: $$$1, p[1] = 1, \dots$$$ is an infinite path.In the second test case, $$$p^5 = [1, 2, 3, 4, 5]$$$ and it obviously contains several infinite paths.In the third test case, $$$p^2 = [3, 6, 1, 8, 7, 2, 5, 4]$$$ and the sequence starting from $$$4$$$: $$$4, p^2[4]=8, p^2[8]=4, \dots$$$ is an infinite path since $$$c_4 = c_8 = 4$$$.
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 \neq p_j$$$ for $$$i \neq 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.
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
    return int(sys.stdin.readline())

def MI():
    return map(int, sys.stdin.readline().split())

def LI():
    return list(map(int, sys.stdin.readline().split()))

def LI1():
    return list(map(int1, sys.stdin.readline().split()))

def LLI(rows_number):
    return [LI() for _ in range(rows_number)]

def SI():
    return sys.stdin.readline()[:-1]

def main():

    def factor(a):
        res = []
        for d in range(1, a + 1):
            if d ** 2 > a:
                break
            if a % d == 0:
                res.append(d)
                if d ** 2 != a:
                    res.append(a // d)
        return res

    def solve(ans):
        for f in ff:
            if f >= ans:
                return ans
            for sj in range(f):
                pc = colors[sj]
                for j in range(sj + f, cn, f):
                    c = colors[j]
                    if c != pc:
                        break
                    pc = c
                else:
                    return f
    q = II()
    for _ in range(q):
        n = II()
        pp = LI1()
        cc = LI()
        fin = [False] * n
        ans = 10 ** 9
        for i in range(n):
            if fin[i]:
                continue
            colors = []
            while not fin[i]:
                fin[i] = True
                colors.append(cc[i])
                i = pp[i]
            cn = len(colors)
            ff = factor(cn)
            ff.sort()
            ans = solve(ans)
        print(ans)
main()
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys
print = sys.stdout.write

def divisors(a, ans):
    div = []
    t1 = int(a ** 0.5)
    for i in range(1, min(t1 + 1, ans)):
        if a % i == 0:
            div.append(i)
            div.append(int(a / i))
    div.sort()
    return div
for _ in range(int(input())):
    n = int(input())
    p = [int(i) - 1 for i in input().split()]
    c = list(map(int, input().split()))
    alive = [True] * n
    cycle = []
    ans = n
    for i in p:
        if alive[i]:
            cycle.append([])
            while True:
                if alive[i]:
                    alive[i] = False
                    cycle[-1].append(i)
                    i = p[i]
                else:
                    break
    for i in cycle:
        t2 = len(i)
        div = divisors(t2, ans)
        for j in div:
            if j >= ans:
                break
            for q in range(j):
                t4 = c[i[q]]
                for r in range(q + j, t2, j):
                    if t4 != c[i[r]]:
                        break
                else:
                    ans = min(ans, j)
                    break
    print(str(ans) + '\n')
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys
print = sys.stdout.write

def divisors(a, ans):
    div = []
    t1 = int(a ** 0.5)
    for i in range(1, min(t1 + 1, ans)):
        if a % i == 0:
            div.append(i)
            div.append(int(a / i))
    div.sort()
    return div
for _ in range(int(input())):
    n = int(input())
    p = [int(i) - 1 for i in input().split()]
    c = list(map(int, input().split()))
    alive = [True] * n
    cycle = []
    ans = n
    for i in p:
        if alive[i]:
            cycle.append([])
            while True:
                if alive[i]:
                    alive[i] = False
                    cycle[-1].append(i)
                    i = p[i]
                else:
                    break
    for i in cycle:
        t2 = len(i)
        div = divisors(t2, ans)
        for j in div:
            if j >= ans:
                break
            for q in range(j):
                t4 = c[i[q]]
                for r in range(q + j, t2, j):
                    if t4 != c[i[r]]:
                        break
                else:
                    ans = min(ans, j)
    print(str(ans) + '\n')