input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
prev = 1
for i in range(k):
prev *= a[i]
for i in range(k,n):
cur = (prev//a[i-k])*a[i]
print(("Yes" if cur > prev else "No"))
prev = cur | import math as m
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
prev = 1
for i in range(k):
prev += m.log(a[i])
for i in range(k,n):
cur = prev + m.log(a[i])
cur -= m.log(a[i-k])
print(("Yes" if cur > prev else "No"))
prev = cur | p02602 |
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
s=[]
for j in range(K-1,N):
score=1
for i in range(j-K+1,j+1):
score*=A[i]
s.append(score)
for i in range(len(s)-1):
if s[i]<s[i+1]:
print("Yes")
else:
print("No") | N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(N-K):
if A[i]<A[i+K]:
print("Yes")
else:
print("No") | p02602 |
#!/usr/bin/env python3
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
point = [1] * K
point[0] = A[0]
for i in range(1, K):
point[i] = point[i - 1] * A[i]
ans = ['No'] * (N - K)
p = point[K - 1]
for i in range(N - K):
tmp = p * A[K + i] / A[i]
if p < tmp:
ans[i] = 'Yes'
p = tmp
print(("\n".join(ans)))
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = ['No'] * (N - K)
for i in range(N - K):
tmp = A[K + i] / A[i]
if 1 < tmp:
ans[i] = 'Yes'
print(("\n".join(ans)))
if __name__ == "__main__":
main()
| p02602 |
sem, per = list(map(int, input().split()))
scores = list(map(int, input().split()))
period_score = []
for i in range(len(scores) - (per - 1)):
period = scores[i:per + i]
temp = period[0]
for j in range(1, per):
temp *= period[j]
period_score.append(temp)
for k in range(1, len(period_score)):
if period_score[k - 1] < period_score[k]:
print('Yes')
else:
print('No') | sem, per = list(map(int, input().split()))
scores = list(map(int, input().split()))
for i in range(sem - per):
if scores[i] < scores[i + per] :
print('Yes')
else:
print('No') | p02602 |
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(n):
if i + k >= n:
exit()
a = A[i:i+k]
pre = a[0]
aft = A[i+k]
if pre >= aft:
print('No')
else:
print('Yes')
| n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(n):
if i + k >= n:
exit()
pre = A[i]
aft = A[i+k]
if pre >= aft:
print('No')
else:
print('Yes')
| p02602 |
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(n-k):
if A[i] < A[k+i]:
print("Yes")
else:
print("No")
| n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(n-k):
if A[i] >= A[i+k]:
print("No")
else:
print("Yes")
| p02602 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = 1
for i in range(k):
s *= a[i]
# s = sum(a[:k])
pre = s
for i in range(1,n-k+1):
s /= a[i-1]
s *= a[i+k-1]
if s > pre:
print("Yes")
else:
print("No")
pre = s
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
# s = 1
# for i in range(k):
# s *= a[i]
# # s = sum(a[:k])
# pre = s
for i in range(1,n-k+1):
if a[i+k-1]/a[i-1]>1:
print("Yes")
else:
print("No")
| p02602 |
from collections import deque
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
prev = 1
for i in range(k):
prev *= a[i]
a_old = deque(a)
a = deque(a[k:])
for i in range(k, n):
score = prev*a.popleft() / a_old.popleft()
if score <= prev:
print('No')
else:
print('Yes')
prev = score
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n-k):
if a[i+k] <= a[i]:
print('No')
else:
print('Yes')
| p02602 |
import os
import heapq
import sys
import math
import bisect
import operator
from collections import defaultdict
from io import BytesIO, IOBase
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def power(x, p,m):
res = 1
while p:
if p & 1:
res = (res * x) % m
x = (x * x) % m
p >>= 1
return res
def inar():
return [int(k) for k in input().split()]
# def bubbleSort(arr,b):
# n = len(arr)
# for i in range(n):
# for j in range(0, n - i - 1):
# if arr[j] > arr[j + 1] and b[j]!=b[j+1]:
# arr[j], arr[j + 1] = arr[j + 1], arr[j]
# b[j],b[j+1]=b[j+1],b[j]
def lcm(num1,num2):
return (num1*num2)//gcd(num1,num2)
def main():
#for _ in range(int(input())):
#n=int(input())
n,k=inar()
arr=inar()
res=[]
dp=[]
for i in range(k):
if i==0:
dp.append(arr[i])
continue
dp.append(arr[i]*dp[-1])
j=0
for i in range(k,n):
dp.append((arr[i]*dp[-1])//arr[j])
if dp[i]>dp[i-1]:
res.append("Yes")
else:
res.append("No")
j+=1
for i in range(len(res)):
print((res[i]))
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
| import os
import heapq
import sys
import math
import bisect
import operator
from collections import defaultdict
from io import BytesIO, IOBase
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def power(x, p,m):
res = 1
while p:
if p & 1:
res = (res * x) % m
x = (x * x) % m
p >>= 1
return res
def inar():
return [int(k) for k in input().split()]
# def bubbleSort(arr,b):
# n = len(arr)
# for i in range(n):
# for j in range(0, n - i - 1):
# if arr[j] > arr[j + 1] and b[j]!=b[j+1]:
# arr[j], arr[j + 1] = arr[j + 1], arr[j]
# b[j],b[j+1]=b[j+1],b[j]
def lcm(num1,num2):
return (num1*num2)//gcd(num1,num2)
def main():
#for _ in range(int(input())):
#n=int(input())
n,k=inar()
arr=inar()
res=[]
for i in range(k,n):
if arr[i]>arr[i-k]:
res.append("Yes")
else:
res.append("No")
for i in range(len(res)):
print((res[i]))
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
| p02602 |
n,k=map(int,input().split())
a=list(map(int,input().split()))
for i in range(n-k):
print("Yes")if a[k+i]>a[i] else print("No")
| n,k=map(int,input().split())
a=list(map(int,input().split()))
for i in range(n-k):
print("Yes")if a[i]<a[k+i] else print("No")
| p02602 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
hyoten = [1]*(n-k+1)
for i in range(n-k+1):
for j in range(i, i+k):
hyoten[i] *= a[j]
for i in range(n-k):
if hyoten[i+1] > hyoten[i]:
print("Yes")
else:
print("No")
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n-k):
if a[i] < a[i+k]:
print("Yes")
elif a[i] >= a[i+k]:
print("No")
| p02602 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
total = 1
for i in range(k - 1, -1, -1):
total *= a[i]
after = total
for i in range(k + 1, n + 1):
before = total
after //= a[i - k - 1]
after *= a[i - 1]
if before < after:
print("Yes")
else:
print("No")
total = after
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(k + 1, n + 1):
if a[i - k - 1] < a[i - 1]:
print("Yes")
else:
print("No")
| p02602 |
n, k = list(map(int, input().split()))
aas = list(map(int, input().split()))
scores = []
cnt = 0
tmp = 1
for i in range(n):
tmp *= aas[i]
if i >= k-1:
scores.append(tmp)
tmp //= aas[i-(k-1)]
for i in range(1,len(scores)):
if scores[i] > scores[i-1]:
print('Yes')
else:
print('No') | n, k = list(map(int, input().split()))
aas = list(map(int, input().split()))
scores = []
for i in range(k,n):
if aas[i] > aas[i-k]:
print('Yes')
else:
print('No') | p02602 |
# 2020/07/25
# M-SOLUTIONS プロコンオープン 2020 - C
# Input
n, k = list(map(int,input().split()))
a = list(map(int,input().split()))
# Calc
pt = a[0]
for i in range(1, k):
pt = pt * a[i]
for i in range(k, n):
bef_pt = pt
pt = pt * a[i] // a[i-k]
# Output
if bef_pt < pt:
print('Yes')
else:
print('No')
| # 2020/07/25
# M-SOLUTIONS プロコンオープン 2020 - C
# Input
n, k = list(map(int,input().split()))
a = list(map(int,input().split()))
# Calc
for i in range(k, n):
# Output
if a[i] > a[i-k]:
print('Yes')
else:
print('No')
| p02602 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
now_sum_val = 1
for i in range(K):
now_sum_val *= A[i]
for i in range(K, N):
next_sum_val = now_sum_val // A[i - K] * A[i]
if next_sum_val > now_sum_val:
print('Yes')
else:
print('No')
now_sum_val = next_sum_val | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(K, N):
# next_sum_val = now_sum_val // A[i - K] * A[i]
if A[i] > A[i - K]:
print('Yes')
else:
print('No') | p02602 |
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict as dd
def main():
n,k=list(map(int,input().split()))
ar=list(map(int,input().split()))
prod=1
for i in range(k):
prod*=ar[i]
for i in range(k,n):
x=prod*ar[i]//ar[i-k]
if x>prod:
print('Yes')
else:
print('No')
prod=x
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
| from math import log2
n,k=list(map(int,input().split()))
ar=list(map(int,input().split()))
for i in range(n):
ar[i]=log2(ar[i])
prod=0
for i in range(k):
prod+=ar[i]
for i in range(k,n):
x=prod+ar[i]-ar[i-k]
if x>prod:
print('Yes')
else:
print('No')
prod=x
| p02602 |
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
now = 1
for i in range(k):
now *= a[i]
for i in range(k,n):
ima = now * a[i]
ima //= a[i-k]
if ima > now:
print("Yes")
else:
print("No")
now = ima | n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(k,n):
if a[i]/a[i-k] > 1:
print("Yes")
else:
print("No") | p02602 |
N,K=list(map(int,input().split()))
A = list(map(int,input().split()))
s0=1
for i in range(1,K+1):
s0=s0*A[K-i]
for i in range(N-K):
s1=s0/A[K-K+i]*A[K+i]
if s1>s0:
print('Yes')
else:
print('No')
s0=s1 | N,K=list(map(int,input().split()))
A = list(map(int,input().split()))
s0=A[0]
for i in range(N-K):
s1=A[K+i]
if s1>s0:
print('Yes')
else:
print('No')
s0=A[i+1] | p02602 |
import sys
n, k = list(map(int,input().split()))
As = list(map(int, input().split()))
ans = 1
tmp = -1
for i in range(n-k+1):
for j in range(k):
ans= ans*As[k+i-j-1]
if not tmp==-1:
if tmp<ans:
print('Yes')
else:
print('No')
tmp = ans
ans = 1 | n, k = list(map(int,input().split()))
As = list(map(int, input().split()))
ans = 1
tmp = -1
for i in range(n-k):
if As[k+i]>As[i]:
print('Yes')
else:
print('No') | p02602 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
ref = 1
for i in range(k):
ref *= a[i]
for i in range(n - k):
ref2 = ref*a[i + k]/a[i]
if ref2 > ref:
print("Yes")
else:
print("No")
ref = ref2 | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n - k):
if a[i + k] > a[i]:
print("Yes")
else:
print("No") | p02602 |
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush
def main():
n,k = list(map(int, input().split()))
A = list(map(int, input().split()))
before = 1
for i in range(k):
before *= A[k-1-i]
for i in range(k,n):
after = (before//A[i-k])*A[i]
if before < after:
print('Yes')
else:
print('No')
before = after
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush
def main():
n,k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(k,n):
if A[i-k]<A[i]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| p02602 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
num = A[0]
for i in range(1, K):
num *= A[i]
check = num
for i in range(K, N):
num //= A[i-K]
num *= A[i]
if check < num:
print('Yes')
else:
print('No')
check = num | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(K, N):
if A[i-K] < A[i]:
print('Yes')
else:
print('No') | p02602 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
tmp = 1
for i in range(K):
tmp *= A[i]
tmp1 = tmp
idx = 0
for i in range(K, N):
tmp1 *= A[i]
tmp1 = tmp1//A[idx]
if(tmp1 > tmp):
print("Yes")
tmp = tmp1
idx += 1
else:
print("No")
tmp = tmp1
idx += 1 | N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
idx = 0
for i in range(K, N):
if(A[idx] < A[i]):
print("Yes")
else:
print("No")
idx += 1 | p02602 |
#!/usr/bin/env python
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
inip = 1
for i in range(k):
inip *= a[i]
# p = [inip]
p = [-1 for _ in range(n-k+1)]
p[0] = inip
tmp = inip
#print('inip =', inip)
for i in range(k, n):
s = tmp//a[i-k]*a[i]
# p.append(s)
p[i-k+1] = s
tmp = s
# print('p =', p)
for i in range(len(p)-1):
if p[i+1] > p[i]:
print('Yes')
else:
print('No')
| #!/usr/bin/env python
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n-k):
if a[i] < a[i+k]:
print('Yes')
else:
print('No')
| p02602 |
#!/usr/bin/env python3
import sys
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y: return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve(N: int, M: int, p: "List[int]", x: "List[int]", y: "List[int]"):
uf = UnionFind(N)
for i in range(M):
uf.union(x[i]-1,y[i]-1)
answer = 0
for indexes in list(uf.all_group_members().values()):
a = set(p[index] for index in indexes)
b = set(index+1 for index in indexes)
answer += len(a&b)
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
p = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
x = [int()] * (M) # type: "List[int]"
y = [int()] * (M) # type: "List[int]"
for i in range(M):
x[i] = int(next(tokens))
y[i] = int(next(tokens))
solve(N, M, p, x, y)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y: return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve(N: int, M: int, p: "List[int]", x: "List[int]", y: "List[int]"):
uf = UnionFind(N)
for i in range(M):
uf.union(x[i]-1,y[i]-1)
answer = 0
for j in range(N):
if uf.same(p[j]-1,j):
answer +=1
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
p = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
x = [int()] * (M) # type: "List[int]"
y = [int()] * (M) # type: "List[int]"
for i in range(M):
x[i] = int(next(tokens))
y[i] = int(next(tokens))
solve(N, M, p, x, y)
if __name__ == '__main__':
main()
| p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return {i for i in range(self.n) if self.find(i) == root}
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M = list(map(int,input().split()))
uf = UnionFind(N)
p = list(map(int,input().split()))
L = []
for i in range(M):
x,y = list(map(int,input().split()))
uf.union(x - 1,y - 1)
cnt = 0
for i in range(N):
if i in uf.members( p[i] - 1 ):
cnt+=1
print(cnt)
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return {i for i in range(self.n) if self.find(i) == root}
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M = list(map(int,input().split()))
uf = UnionFind(N)
p = list(map(int,input().split()))
L = []
for i in range(M):
x,y = list(map(int,input().split()))
uf.union(x - 1,y - 1)
cnt = 0
for i in range(N):
if uf.same(i,p[i]-1):
cnt+=1
print(cnt)
| p03354 |
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
unionfind = UnionFind(N + 1)
for _ in range(M):
x, y = list(map(int, input().split()))
unionfind.union(P[x - 1], P[y - 1])
ans = 0
idx = []
for i in range(N):
if P[i] == (i + 1):
ans += 1
else:
idx.append(i)
for i in idx:
if unionfind.same(P[i], i + 1):
ans += 1
print(ans) | N, M = list(map(int, input().split()))
p = list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
unionfind = UnionFind(N + 1)
for _ in range(M):
x, y = list(map(int, input().split()))
unionfind.union(x, y)
ans = 0
for i in range(N):
if i + 1 != p[i]:
if unionfind.same(p[i], i + 1):
ans += 1
else:
ans += 1
print(ans) | p03354 |
import sys
input = sys.stdin.readline
def read_values():
return list(map(int, input().split()))
def read_list():
return list(read_values())
def func(N, mod):
F = [1]
for i in range(1, N + 1):
F.append(F[-1] * i % mod)
return F
INV = {}
def inv(a, mod):
if a in INV:
return INV[a]
r = pow(a, mod - 2, mod)
INV[a] = r
return r
def C(F, a, b, mod):
return F[a] * inv(F[b], mod) * inv(F[a - b], mod) % mod
class UF:
def __init__(self, N):
self.parent = [i for i in range(N)]
def get_parent(self, a):
p = self.parent[a]
if a == p:
return a
q = self.get_parent(p)
self.parent[a] = q
return q
def make_pare(self, a, b):
pa = self.get_parent(a)
pb = self.get_parent(b)
if pa != pb:
self.parent[pa] = pb
self.parent[a] = pb
def is_pare(self, a, b):
return self.get_parent(a) == self.get_parent(b)
def main():
N, M = read_values()
P = read_list()
F = [0] * N
for i, p in enumerate(P):
F[p - 1] = i
W = [tuple(read_values()) for _ in range(M)]
U = UF(N)
for a, b in W:
a -= 1
b -= 1
U.make_pare(a, b)
res = 0
already = [False] * N
for i in range(N):
if already[i]:
continue
if i == F[i]:
res += 1
continue
S_num = {i}
S_index = {F[i]}
for j in range(i + 1, N):
if already[j]:
continue
if U.is_pare(i, j):
S_num.add(j)
S_index.add(F[j])
already[j] = True
res += len(S_num & S_index)
print(res)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def read_values():
return list(map(int, input().split()))
def read_list():
return list(read_values())
def func(N, mod):
F = [1]
for i in range(1, N + 1):
F.append(F[-1] * i % mod)
return F
INV = {}
def inv(a, mod):
if a in INV:
return INV[a]
r = pow(a, mod - 2, mod)
INV[a] = r
return r
def C(F, a, b, mod):
return F[a] * inv(F[b], mod) * inv(F[a - b], mod) % mod
class UF:
def __init__(self, N):
self.parent = [i for i in range(N)]
def get_parent(self, a):
p = self.parent[a]
if a == p:
return a
q = self.get_parent(p)
self.parent[a] = q
return q
def make_pare(self, a, b):
pa = self.get_parent(a)
pb = self.get_parent(b)
if pa != pb:
self.parent[pa] = pb
self.parent[a] = pb
def is_pare(self, a, b):
return self.get_parent(a) == self.get_parent(b)
def main():
N, M = read_values()
P = read_list()
F = [0] * N
W = [tuple(read_values()) for _ in range(M)]
U = UF(N)
for a, b in W:
a -= 1
b -= 1
U.make_pare(a, b)
res = 0
for p in P:
p -= 1
if U.is_pare(p, P[p] - 1):
res += 1
print(res)
if __name__ == "__main__":
main()
| p03354 |
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
P = list(enumerate(P, start=1))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
uf = UnionFind(N)
for m in range(M):
x, y = list(map(int, input().split()))
uf.union(x, y)
ans = 0
for now, value in P:
if uf.same_check(now, value):
ans += 1
print(ans) | N, M = list(map(int, input().split()))
P = list(enumerate(map(int, input().split())))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# すべての頂点に対して親を検索する
def all_find(self):
for n in range(len(self.par)):
self.find(n)
UF = UnionFind(N)
for i in range(M):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
UF.union(x, y)
UF.all_find()
ans = 0
for index, number in P:
ans += UF.same(index, number - 1)
print(ans)
| p03354 |
N, M = list(map(int, input().split()))
P = list(enumerate(map(int, input().split())))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# すべての頂点に対して親を検索する
def all_find(self):
for n in range(len(self.par)):
self.find(n)
UF = UnionFind(N)
for i in range(M):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
UF.union(x, y)
UF.all_find()
ans = 0
for index, number in P:
ans += UF.same(index, number - 1)
print(ans)
| N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# すべての頂点に対して親を検索する
def all_find(self):
for n in range(len(self.par)):
self.find(n)
UF = UnionFind(N)
for i in range(M):
x, y = list(map(int, input().split()))
x, y = x - 1, y - 1
UF.union(x, y)
ans = 0
for i, p in enumerate(P):
ans += UF.same(i, p - 1)
print(ans)
| p03354 |
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
uf = UnionFind(N+1)
for i in range(M):
x, y = list(map(int, input().split()))
uf.union(x, y)
ans = 0
for r in uf.roots():
ms = uf.members(r)
p = set()
for m in ms:
p.add(P[m-1])
# print(p, ms)
ans += len(p & set(ms))
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def main():
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
uf = UnionFind(N)
for i in range(M):
x, y = list(map(int, input().split()))
uf.union(x-1, y-1)
ans = 0
for i in range(N):
if uf.same(P[i]-1, i):
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p03354 |
# ABC097D - Equals (ARC097D)
class UnionFind: # O(α(N))
def __init__(self, N): # construct a Union-Find tree (1-idx)
self.parent = [i for i in range(N + 1)]
self.rank = [0] * (N + 1)
def find(self, x): # find the group (root) of a vertex
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x, y): # check two vertices are in the same group
return self.find(x) == self.find(y)
def unite(self, x, y): # unite two groups
x, y = self.find(x), self.find(y)
if x == y: # the same group
return
# unite a small one to a bigger one to balance trees
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
# check i and Pi are connected components or not
N, M, *A = list(map(int, open(0).read().split()))
P, E = A[:N], A[N:]
U = UnionFind(N) # construct a Union-Find tree (1-idx)
for v, u in zip(*[iter(E)] * 2): # connected components are in the same group
U.unite(v, u)
ans = sum(U.is_same(i, p) for i, p in enumerate(P, 1))
print(ans)
if __name__ == "__main__":
main() | # ABC097D - Equals (ARC097D)
class UnionFind:
__slots__ = ["_data_size", "_first_index", "_parents"]
def __init__(self, data_size: int, is_zero_indexed: bool = True) -> None:
self._data_size = data_size
self._first_index = 0 if is_zero_indexed else 1
self._parents = [-1] * (data_size + self._first_index)
def find(self, x: int) -> int:
"""Find the group (root) of vertex x"""
if self._parents[x] < 0:
return x
self._parents[x] = self.find(self._parents[x])
return self._parents[x]
def is_same(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are in the same group or not."""
return self.find(x) == self.find(y)
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y."""
x, y = self.find(x), self.find(y)
if x == y:
return
if self._parents[x] > self._parents[y]:
x, y = y, x
self._parents[x] += self._parents[y]
self._parents[y] = x
def main():
N, _, *PXY = list(map(int, open(0).read().split()))
P, XY = PXY[:N], PXY[N:]
uf = UnionFind(N, is_zero_indexed=False)
for x, y in zip(*[iter(XY)] * 2):
uf.unite(x, y)
ans = sum(uf.is_same(i, p) for i, p in enumerate(P, 1))
print(ans)
if __name__ == "__main__":
main()
| p03354 |
class UnionFind:
def __init__(self,n):
self.n=n
self.parents=[-1]*n
self.rank=[0]*n
def find(self,x):
if self.parents[x]<0:
return x
else:
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.rank[x]<self.rank[y]:
self.parents[y]+=self.parents[x]
self.parents[x]=y
else:
self.parents[x]+=self.parents[y]
self.parents[y]=x
if self.rank[x]==self.rank[y]:
self.rank[x]+=1
def are_same(self,x,y):
return self.find(x)==self.find(y)
def element_count(self,x):
x=self.find(x)
return -self.parents[x]
def group_count(self):
count=0
for e in self.parents:
if e<0: count+=1
return count
from sys import stdin
def main():
#入力
readline=stdin.readline
n,m=list(map(int,readline().split()))
a=list(map(int,readline().split()))
uf=UnionFind(n+1)
for i in range(m):
x,y=list(map(int,readline().split()))
uf.union(x,y)
i=1
while i<n+1:
x=a[i-1]
if x==i:
i+=1
elif uf.are_same(i,x):
a[i-1],a[x-1]=a[x-1],a[i-1]
else:
i+=1
print((len([a[i] for i in range(n) if a[i]-1==i])))
if __name__=="__main__":
main() | class UnionFind:
def __init__(self,n):
self.n=n
self.parents=[-1]*n
self.rank=[0]*n
def find(self,x):
if self.parents[x]<0:
return x
else:
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.rank[x]<self.rank[y]:
self.parents[y]+=self.parents[x]
self.parents[x]=y
else:
self.parents[x]+=self.parents[y]
self.parents[y]=x
if self.rank[x]==self.rank[y]:
self.rank[x]+=1
def are_same(self,x,y):
return self.find(x)==self.find(y)
def element_count(self,x):
x=self.find(x)
return -self.parents[x]
def group_count(self):
count=0
for e in self.parents:
if e<0: count+=1
return count
from sys import stdin
def main():
#入力
readline=stdin.readline
n,m=list(map(int,readline().split()))
a=list(map(int,readline().split()))
uf=UnionFind(n+1)
for i in range(m):
x,y=list(map(int,readline().split()))
uf.union(x,y)
ans=0
for i in range(n):
if uf.are_same(a[i],i+1):
ans+=1
print(ans)
if __name__=="__main__":
main() | p03354 |
n,m = list(map(int, input().split()))
p = list(map(int, input().split()))
par = [i for i in range(n)]
rank = [0 for x in range(n)]
def root(x):
tmp = par[x]
if tmp == x:
return x
else:
a = root(tmp)
par[x] = a
return a
def merge(x, y):
x = root(x)
y = root(y)
if x == y:
return
else:
if rank[x] > rank[y]:
par[y] = x
rank[y] += rank[x]
else:
par[x] = y
rank[x] += rank[y]
return
for i in range(m):
x, y = list(map(int, input().split()))
merge(x-1, y-1)
ans = 0
for i in range(n):
if p[i]-1 == i:
ans += 1
elif root(p[i]-1) == root(i):
ans += 1
print(ans) | n,m = list(map(int, input().split()))
p = list(map(int, input().split()))
par = [i for i in range(n)]
def root(x):
tmp = par[x]
if tmp == x:
return x
else:
a = root(tmp)
par[x] = a
return a
def merge(x, y):
x = root(x)
y = root(y)
if x != y:
par[x] = y
return
for i in range(m):
x, y = list(map(int, input().split()))
merge(x-1, y-1)
ans = 0
for i in range(n):
if p[i]-1 == i:
ans += 1
elif root(p[i]-1) == root(i):
ans += 1
print(ans) | p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# 要素xの根の値を取得
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def resolve():
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(M)]
uf = UnionFind(N)
for xy in XY:
uf.union(xy[0]-1, xy[1]-1)
group_members = list(map(set, list(uf.all_group_members().values())))
#print(group_members)
cnt = 0
for v in group_members:
for i in v:
if P[i]-1 in v:
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve() | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# 要素xの根の値を取得
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def resolve():
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(M)]
uf = UnionFind(N)
for xy in XY:
uf.union(xy[0]-1, xy[1]-1)
cnt = 0
for i in range(N):
if uf.same(i, P[i]-1):
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve() | p03354 |
#16:00
n,m = list(map(int,input().split()))
a = list([int(x)-1 for x in input().split()])
pre = [i for i in range(n)]
for _ in range(m):
X,Y = list(map(int,input().split()))
X -= 1
Y -= 1
while pre[X] != X:
X = pre[X]
while pre[Y] != Y:
Y = pre[Y]
if X == Y:
continue
elif X < Y:
pre[Y] = X
else:
pre[X] = Y
#print(a)
#print(pre)
region = [[] for _ in range(n)]
ser = [[] for _ in range(n)]
for i in range(n):
b = a[i]
I = i
while pre[I] != I:
I = pre[I]
region[I].append(b)
ser[I].append(i)
#print(region)
#print(ser)
home = [10**6 for _ in range(n)]
mother = [10**6 for _ in range(n)]
for i in range(n):
for x in region[i]:
home[x] = i
for i in range(n):
for y in ser[i]:
mother[y] = i
#print(home)
#print(mother)
ans = []
for i in range(n):
if home[i] == mother[i]:
ans.append(i)
#print(ans)
print((len(ans))) | n,m = list(map(int,input().split()))
a = list([int(z)-1 for z in input().split()])
pre = [i for i in range(n)]
for _ in range(m):
x,y = [int(z)-1 for z in input().split()]
while pre[x] != x:
x = pre[x]
while pre[y] != y:
y = pre[y]
if x == y:
continue
elif x < y:
pre[y] = x
else:
pre[x] = y
home1 = [10**6 for _ in range(n)]
home2 = [10**6 for _ in range(n)]
for i in range(n):
I = i
while pre[I] != I:
I = pre[I]
home1[i] = I
home2[a[i]] = I
ans = 0
for i in range(n):
if home1[i] == home2[i]:
ans += 1
print(ans) | p03354 |
from collections import deque
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
graph = [[] for _ in range(N)]
can = [[] for _ in range(N)]
xy = list()
for i in range(M):
x, y = list(map(int, input().split()))
graph[x-1].append(y-1)
graph[y-1].append(x-1)
for i in range(N):
q = deque([i])
while q:
t = q.popleft()
can[i].append(t)
for next in graph[t]:
if next not in can[i]:
q.append(next)
ans = 0
for i in range(N):
p = P[i] - 1
if p in can[i]:
ans += 1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x,y = y,x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
uf = UnionFind(N+1)
graph = [[] for _ in range(N)]
can = [[] for _ in range(N)]
xy = list()
for i in range(M):
x, y = list(map(int, input().split()))
uf.union(x, y)
ans = 0
for i in range(1, N+1):
if uf.same(i, P[i-1]):
ans += 1
print(ans) | p03354 |
def solve():
n, m = list(map(int,input().split()))
plst = list(map(int,input().split()))
pare_inds = [i for i in range(n)]
belongs = [[] for i in range(n)]
def get_root(x):
p = pare_inds[x]
if p == x:
return x
a = get_root(p)
pare_inds[x] = a
return a
for i in range(m):
x, y = list(map(int,input().split()))
x, y = x - 1, y - 1
r_x, r_y = get_root(x), get_root(y)
if r_x < r_y:
pare_inds[y] = r_x
pare_inds[r_y] = r_x
else:
pare_inds[x] = r_y
pare_inds[r_x] = r_y
for i in range(n):
belongs[get_root(i)].append(i)
ans = 0
for lst in belongs:
for i in lst:
if plst[i] - 1 in lst:
ans += 1
print(ans)
solve() | def solve():
n, m = list(map(int,input().split()))
plst = list(map(int,input().split()))
pare_inds = [i for i in range(n)]
belongs = [[] for i in range(n)]
def get_root(x):
p = pare_inds[x]
if p == x:
return x
a = get_root(p)
pare_inds[x] = a
return a
for i in range(m):
x, y = list(map(int,input().split()))
x, y = x - 1, y - 1
r_x, r_y = get_root(x), get_root(y)
if r_x < r_y:
pare_inds[y] = r_x
pare_inds[r_y] = r_x
else:
pare_inds[x] = r_y
pare_inds[r_x] = r_y
for i in range(n):
belongs[get_root(i)].append(i)
#print(belongs)
#print(plst)
ans = 0
for lst in belongs:
lst2 = [plst[i] - 1 for i in lst]
lst.sort()
lst2.sort()
ind1 = 0
ind2 = 0
end = len(lst)
while ind1 < end and ind2 < end:
if lst[ind1] == lst2[ind2]:
ans += 1
ind1 += 1
ind2 += 1
elif lst[ind1] < lst2[ind2]:
ind1 += 1
else:
ind2 += 1
print(ans)
solve() | p03354 |
def solve():
n, m = list(map(int,input().split()))
plst = list(map(int,input().split()))
pare_inds = [i for i in range(n)]
belongs = [[] for i in range(n)]
def get_root(x):
p = pare_inds[x]
if p == x:
return x
a = get_root(p)
pare_inds[x] = a
return a
for i in range(m):
x, y = list(map(int,input().split()))
x, y = x - 1, y - 1
r_x, r_y = get_root(x), get_root(y)
if r_x < r_y:
pare_inds[y] = r_x
pare_inds[r_y] = r_x
else:
pare_inds[x] = r_y
pare_inds[r_x] = r_y
for i in range(n):
belongs[get_root(i)].append(i)
#print(belongs)
#print(plst)
ans = 0
for lst in belongs:
lst2 = [plst[i] - 1 for i in lst]
lst.sort()
lst2.sort()
ind1 = 0
ind2 = 0
end = len(lst)
while ind1 < end and ind2 < end:
if lst[ind1] == lst2[ind2]:
ans += 1
ind1 += 1
ind2 += 1
elif lst[ind1] < lst2[ind2]:
ind1 += 1
else:
ind2 += 1
print(ans)
solve() | def solve():
n, m = list(map(int,input().split()))
plst = list(map(int,input().split()))
pare_inds = [i for i in range(n)]
belongs = [[] for i in range(n)]
def get_root(x):
p = pare_inds[x]
if p == x:
return x
a = get_root(p)
pare_inds[x] = a
return a
for i in range(m):
x, y = list(map(int,input().split()))
x, y = x - 1, y - 1
r_x, r_y = get_root(x), get_root(y)
if r_x < r_y:
pare_inds[y] = r_x
pare_inds[r_y] = r_x
else:
pare_inds[x] = r_y
pare_inds[r_x] = r_y
for i in range(n):
belongs[get_root(i)].append(i)
ans = 0
for lst in belongs:
lst2 = [plst[i] - 1 for i in lst]
set1 = set(lst)
set2 = set(lst2)
ans += len(set1 & set2)
# lst.sort()
# lst2.sort()
# ind1 = 0
# ind2 = 0
# end = len(lst)
# while ind1 < end and ind2 < end:
# if lst[ind1] == lst2[ind2]:
# ans += 1
# ind1 += 1
# ind2 += 1
# elif lst[ind1] < lst2[ind2]:
# ind1 += 1
# else:
# ind2 += 1
print(ans)
solve() | p03354 |
N,M = list(map(int,input().split()))
class UnionFind:
def __init__(self, n):
#ノード数nの配列を作る
#親の番号を格納する
#-> 自分が根だった場合は、-(その集合のサイズ)とする
#作るときはparentの値を全て-1にする
#こうすると全てバラバラになる
self.parent = [-1 for _ in range(n)]
self.n = n
def root(self, x):
#要素xの根の番号を返す
if self.parent[x] < 0:
# 自分が根
return x
# 要素xの親を要素xの根に変えておく(付け替える)
# 次の呼び出しが早くなる
self.parent[x] = self.root(self.parent[x])
return self.parent[x]
def size(self, x):
#要素xの所属するグループの頂点数を調べる
#根のparentにサイズが格納されている
return -self.parent[self.root(x)]
def merge(self, x, y):
#xとyを結合する
x = self.root(x)
y = self.root(y)
if x == y:
return False
#大きい方(x)に小さい方(y)をくっつけたい
if self.parent[x] > self.parent[y]:
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def family(self,x): # xが属する連結集合を返す
return [i for i in range(self.n) if self.issame(i,x)]
def maximum(self): # 連結最大集合を返す
return self.family(self.parent.index(min(self.parent)))
p = list(map(int,input().split()))
UF = UnionFind(N)
for i in range(M):
x,y = list(map(int,input().split()))
UF.merge(x-1,y-1)
ans = 0
L = [i for i in range(N) if UF.root(i)==i]
for i in range(len(L)):
if UF.size(L[i])==1:
if L[i]==p[L[i]]-1:
ans +=1
else:
S = UF.family(L[i])
T = [p[i]-1 for i in S]
ans += len(set(S).intersection(set(T)))
print(ans) | N,M = list(map(int,input().split()))
class UnionFind:
def __init__(self, n):
#ノード数nの配列を作る
#親の番号を格納する
#-> 自分が根だった場合は、-(その集合のサイズ)とする
#作るときはparentの値を全て-1にする
#こうすると全てバラバラになる
self.parent = [-1 for _ in range(n)]
self.n = n
def root(self, x):
#要素xの根の番号を返す
if self.parent[x] < 0:
# 自分が根
return x
# 要素xの親を要素xの根に変えておく(付け替える)
# 次の呼び出しが早くなる
self.parent[x] = self.root(self.parent[x])
return self.parent[x]
def size(self, x):
#要素xの所属するグループの頂点数を調べる
#根のparentにサイズが格納されている
return -self.parent[self.root(x)]
def merge(self, x, y):
#xとyを結合する
x = self.root(x)
y = self.root(y)
if x == y:
return False
#大きい方(x)に小さい方(y)をくっつけたい
if self.parent[x] > self.parent[y]:
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def family(self,x): # xが属する連結集合を返す
return [i for i in range(self.n) if self.issame(i,x)]
def maximum(self): # 連結最大集合を返す
return self.family(self.parent.index(min(self.parent)))
def all_family(self): # 根集合P, 子集合の集合C(C[P[i]]にはiを根とする子集合が入る)
P = {} # 根のindexの集合はP.keys()で取得できる．これは根iが何番目の根かを返すdict
now = 0
for i in range(self.n):
if self.parent[i] < 0:
P[i] = now
now += 1
C = [[] for _ in range(len(P))] # P[i]
for i in range(self.n):
C[P[self.root(i)]].append(i)
return P,C
p = list(map(int,input().split()))
UF = UnionFind(N)
for i in range(M):
x,y = list(map(int,input().split()))
UF.merge(x-1,y-1)
ans = 0
_,C = UF.all_family()
for i in range(len(C)):
S = C[i]
T = [p[i]-1 for i in S]
ans += len(set(S).intersection(set(T)))
print(ans) | p03354 |
# union-find
n, m = list(map(int, input().split()))
def find_root(x):
if par[x] == x:
return x
else:
par[x] = find_root(par[x])
return par[x]
def unite(x, y):
x = find_root(x)
y = find_root(y)
if(x == y):
return 0
if rank[x] < rank[y]:
par[x] = y
temp = size[x] * size[y]
size[y] = size[x] + size[y]
else:
par[y] = x
if (rank[x] == rank[y]):
rank[x] += 11
temp = size[x] * size[y]
size[x] = size[x] + size[y]
return temp
def is_same(x,y):
return find_root(x) == find_root(y)
# par = [0]*n
par = list(range(n))
rank = [0]*n
size = [1]*n
init_nums = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(m)]
edges = [[b[0]-1, b[1]-1] for b in edges] #1-idx -> 0-idx
for b in range(m):
unite(edges[b][0] , edges[b][1])
# print(par)
# print(len(set(par)))
ans = 0
for i in range(n):
num = init_nums[i]
# i+1 が init_numの中でi+1と同じグループだったら
if is_same(i, num - 1):
ans += 1
arr = [0] * n
for i in range(n):
arr[i] = find_root(i)
print(ans)
| # union-find
# こういう問題のときにUnion-Findなのか幅優先探索なのか深さ優先探索なのか迷う。
# ちなみに解説PDFはUnion-Findを挙げている。
n, m = list(map(int, input().split()))
def find_root(x):
if par[x] == x:
return x
else:
par[x] = find_root(par[x])
return par[x]
def unite(x, y):
x = find_root(x)
y = find_root(y)
if(x == y):
return 0
if rank[x] < rank[y]:
par[x] = y
temp = size[x] * size[y]
size[y] = size[x] + size[y]
else:
par[y] = x
if (rank[x] == rank[y]):
rank[x] += 11
temp = size[x] * size[y]
size[x] = size[x] + size[y]
return temp
def is_same(x,y):
return find_root(x) == find_root(y)
# par = [0]*n
par = list(range(n))
rank = [0]*n
size = [1]*n
init_nums = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(m)]
edges = [[b[0]-1, b[1]-1] for b in edges] #1-idx -> 0-idx
for b in range(m):
unite(edges[b][0] , edges[b][1])
ans = 0
for i in range(n):
num = init_nums[i]
# i+1 が init_numの中でi+1と同じグループだったら
if is_same(i, num - 1):
ans += 1
print(ans)
| p03354 |
from collections import deque
n, m = list(map(int, input().split()))
s = list(map(int, input().split()))
g = [[] for i in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].append(b)
g[b].append(a)
q = deque()
chk = [0] * n
res = []
for i in range(n):
tmp = set()
if not chk[i]:
q.append(i)
while q:
v = q.pop()
chk[v] = 1
tmp.add(v)
for u in g[v]:
if chk[u] == 1:
continue
q.append(u)
res.append(tmp)
ans = 0
for re in res:
tmp2 = set()
for r in re:
tmp2.add(s[r] - 1)
ans += len(tmp2 & re)
print(ans)
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] < self.rank[y]:
self.par[x] = y
return
elif self.rank[y] < self.rank[x]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
s = list(map(int, input().split()))
u = UnionFind(n)
for _ in range(m):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
u.unit(a, b)
ans = 0
for i, p in enumerate(s):
if u.same(i, p - 1):
ans += 1
print(ans)
| p03354 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
n,m = list(map(int,input().split()))
p = list(map(int,input().split()))
xy = [list(map(int,input().split())) for _ in range(m)]
Graph = [[] for _ in range(n)]
for x,y in xy:
Graph[x-1].append(y-1)
Graph[y-1].append(x-1)
check = [False for _ in range(n)]
def dfs(g,start,c,goal):
c[start] = True
if start == goal:
return True
for u in g[start]:
if c[u]:
continue
if dfs(g,u,c,goal):
return True
ans = 0
for i in range(n):
c = check.copy()
if dfs(Graph,i,c,p.index(i+1)):
ans += 1
print(ans)
| #!/usr/bin/env python3
n,m = list(map(int,input().split()))
p = list(map(int,input().split()))
for i in range(n):
p[i] -= 1
#連結成分に属するかどうかを見るときはUnion-Findを用いる
#根(属するクラス)を返す関数
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
#同じクラスに属するかどうかを返す関数
def same(x,y):
return root(x) == root(y)
#木を結合する関数
def union(x,y):
x = root(x)
y = root(y)
#高さの高いほうに低いほうを結合
if rank[x] < rank[y]:
par[x] = y#xの親(属するクラス)をyとする
else:
par[y] = x
if rank[x] == rank[y]:#高さが同じ場合
rank[x] += 1#高さは1つ増える
par = [i for i in range(n)]
rank = [0 for _ in range(n)]
for i in range(m):
x,y = list(map(int,input().split()))
#swapできる頂点は同じ木にして同じ連結成分にする
if not same(x-1,y-1):
union(x-1,y-1)
ans = 0
for i in range(n):
#p[i]とiが同じ連結成分ならばans+1
if root(p[i]) == root(i):
ans += 1
print(ans)
| p03354 |
# -*- coding: utf-8 -*-
from collections import deque
from pprint import pprint
N, M = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
graph = [[0 for _ in range(N)] for _ in range(N)]
visited = [0 for _ in range(N)]
for x,y in xy:
graph[x-1][y-1] = 1
graph[y-1][x-1] = 1
def dfs(v):
que = deque()
vis_list = []
visited[v] = 1
vis_list.append(v)
que.append(v)
while len(que) > 0:
i = que.pop() #深さ優先探索
# i = que.popleft() #幅優先探索
for n in range(N):
if graph[i][n] == 1 and visited[n] == 0:
visited[n] = 1
vis_list.append(n)
que.append(n)
return vis_list
grps = []
for i in range(N):
if visited[i] == 0:
grps.append(dfs(i))
ans = 0
for g_list in grps:
if len(g_list) == 1:
if g_list[0] == p[g_list[0]]-1:
ans += 1
else:
tmp = set([])
for i in g_list:
tmp.add(p[i]-1)
ans += len( set(g_list) & tmp)
print(ans)
| # -*- coding: utf-8 -*-
from collections import deque, defaultdict
N, M = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
graph = defaultdict(set)
visited = [False for _ in range(N)]
for x,y in xy:
graph[x-1].add(y-1)
graph[y-1].add(x-1)
def dfs(v):
que = deque()
vis_list = []
visited[v] = True
vis_list.append(v)
que.append(v)
while len(que) > 0:
i = que.pop() #深さ優先探索
# i = que.popleft() #幅優先探索
for n in list(graph[i]):
if visited[n] == False:
visited[n] = True
vis_list.append(n)
que.append(n)
return vis_list
grps = []
for i in range(N):
if visited[i] == False:
grps.append(dfs(i))
ans = 0
for g_list in grps:
if len(g_list) == 1:
if g_list[0] == p[g_list[0]]-1:
ans += 1
else:
tmp = set([])
for i in g_list:
tmp.add(p[i]-1)
ans += len( set(g_list) & tmp)
print(ans)
| p03354 |
n,m=list(map(int,input().split()))
p=list(map(int,input().split()))
ans=0
import sys;sys.setrecursionlimit(10**9)
class u():#UnionFind f-根探し u-連結 s-連結? c-要素数
def __init__(self,n):self.n,self.r=[-1]*n,[0]*n
def f(self,x):
if self.n[x]<0:return x
else:self.n[x]=self.f(self.n[x]);return self.n[x]
def u(self,x,y):
x,y=self.f(x),self.f(y)
if x==y:return
elif self.r[x]>self.r[y]:self.n[x]+=self.n[y];self.n[y]=x
else:self.n[y]+=self.n[x];self.n[x]=y;self.r[y]+=self.r[x]==self.r[y]
u=u(n)
for i in range(m):
a,b=list(map(int,input().split()))
u.u(a-1,b-1)
for i in range(n):
if p[i]==i+1:ans+=1
elif u.f(i)==u.f(p[i]-1):ans+=1
print(ans) | n,m=list(map(int,input().split()));p=list(map(int,input().split()));z=0;import sys;sys.setrecursionlimit(10**9);f=[i for i in range(n)]
def r(f,x):
if f[x]!=x:f[x]=r(f,f[x])
return f[x]
def u(f,a,b):
x,y=r(f,a),r(f,b)
if x!=y:f[x]=y
for i in range(m):a,b=list(map(int,input().split()));u(f,a-1,b-1)
for i in range(n):z+=r(f,i)==r(f,p[i]-1)
print(z) | p03354 |
from collections import deque
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
paths = {}
for _ in range(m):
x, y = list(map(int, input().split()))
if not x in list(paths.keys()):
paths[x] = [y]
else:
paths[x].append(y)
if not y in list(paths.keys()):
paths[y] = [x]
else:
paths[y].append(x)
connected = [None]*(n+1)
path_id = 1
for i in range(1, n+1):
if connected[i] is None:
connected[i] = path_id
else:
continue
if i in list(paths.keys()):
stack = deque(paths[i])
cluster = set([i]+paths[i])
else:
stack = []
while len(stack) > 0:
j = stack.pop()
connected[j] = path_id
for k in paths[j]:
if connected[k] is None and not k in cluster:
stack.append(k)
cluster.add(k)
path_id += 1
# print(connected)
ans = 0
for i in range(n):
if connected[i+1] == connected[p[i]]:
ans += 1
print(ans)
| from collections import deque
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
par = list(range(n+1))
def find(x):
p_ = par[x]
if p_ == x:
return x
a = find(p_)
par[x] = a
return a
for _ in range(m):
x, y = list(map(int, input().split()))
bx, by = find(x), find(y)
par[y] = bx
par[by] = bx
ans = 0
for i in range(1, n+1):
if find(i) == find(p[i-1]):
ans += 1
print(ans)
| p03354 |
N,M=list(map(int,input().split()))
P_list=[int(p) for p in input().split()]
Tree=[-1]*N
def find(x):
while Tree[x]>=0:
x=Tree[x]
return x
def unite(x,y):
s1=find(x)
s2=find(y)
if s1==s2:
pass
else:
if Tree[s1]<Tree[s2]:
Tree[s2]=s1
elif Tree[s2]>Tree[s1]:
Tree[s1]=s2
else:
Tree[s1]+=-1
Tree[s2]=s1
return
for m in range(M):
x,y=list(map(int,input().split()))
unite(x-1,y-1)
ans=0
for i in range(N):
if find(P_list[i]-1)==find(i):
ans+=1
print(ans)
| N,M=list(map(int,input().split()))
P_list=[int(p) for p in input().split()]
Tree=[i for i in range(N)]
def find(x):
if x==Tree[x]:
return x
else:
root=find(Tree[x])
Tree[x]=root
return root
def unite(x,y):
s1=find(x)
s2=find(y)
if s1==s2:
pass
else:
Tree[s1]=s2
for m in range(M):
x,y=list(map(int,input().split()))
unite(x-1,y-1)
ans=0
for i in range(N):
if find(P_list[i]-1)==find(i):
ans+=1
print(ans)
| p03354 |
from copy import deepcopy
n, m = [int(i) for i in input().split()]
p = [int(i) for i in input().split()]
x = [[int(i) for i in input().split()] for j in range(m)]
x_ = deepcopy(x)
tree = []
memo = []
try:
for i, y in enumerate(x_):
if y in memo:
continue
tree.append(set(y))
while True:
prev = tree[i]
for j in x_[i+1:]:
if tree[i] & set(j):
tree[i] = tree[i] | set(j)
memo.append(j)
if not tree[i] - prev:
break
except:
pass
for i in tree:
i = list(i)
temp = [p[j-1] for j in i]
for j in i:
if j in temp:
p[j-1] = j
ans = 0
for i, p_ in enumerate(p):
if i+1 == p_:
ans += 1
print(ans) | n, m = [int(i) for i in input().split()]
p = [int(i) for i in input().split()]
x = [[int(i) for i in input().split()] for j in range(m)]
par = [i for i in range(0, n+1)]
def root(x):
if par[x] == x:
return x
else:
par[x] = root(par[x])
return par[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
par[x] = y
for i in x:
a, b = i
unite(a, b)
ans = 0
for i, p_ in enumerate(p):
if root(i+1) == root(p_):
ans += 1
print(ans) | p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
p=[int(i)-1 for i in input().split()]
tree=UnionFind(n)
for _ in range(m):
x,y=list(map(int,input().split()))
tree.union(x-1,y-1)
ans=0
for i in range(n):
#print(p[i],tree.members(i))
if p[i] in tree.members(i):
ans+=1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
p=[int(i)-1 for i in input().split()]
tree=UnionFind(n)
for _ in range(m):
x,y=list(map(int,input().split()))
tree.union(x-1,y-1)
ans=0
for i in range(n):
#print(p[i],tree.members(i))
if tree.same(p[i],i):
ans+=1
print(ans) | p03354 |
N,M=list(map(int,input().split()))
P=list(map(int,input().split()))
par=[i for i in range(N)]
rank=[1]*N
ans=0
def root(x):
if par[x]==x:
return x
else:
par[x]=root(par[x])
return par[x]
def same(x,y):
return root(x)==root(y)
def connect(x,y):
if root(x)==root(y):
return
else:
if rank[x]<rank[y]:
x,y=y,x
par[root(y)]=root(x)
rank[y]+=1
for i in range(M):
x,y=list(map(int,input().split()))
connect(x-1,y-1)
for i in range(N):
if same(i,P[i]-1):
ans+=1
print(ans) | N,M=list(map(int,input().split()))
P=list(map(int,input().split()))
par=[i for i in range(N)]
ans=0
def root(x):
if x!=par[x]:
par[x]=root(par[x])
return par[x]
def connect(x,y):
if root(x)!=root(y):
par[root(y)]=root(x)
for i in range(M):
x,y=list(map(int,input().split()))
connect(x-1,y-1)
for i in range(N):
if root(i)==root(P[i]-1):
ans+=1
print(ans) | p03354 |
class Unionfind:
def __init__(self,n):
self.uf = [-1]*n
def find(self,x):
if self.uf[x] < 0:
return x
else:
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def same(self,x,y):
return self.find(x) == self.find(y)
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.uf[x] > self.uf[y]:
x,y = y,x
self.uf[x] += self.uf[y]
self.uf[y] = x
def size(self,x):
x = self.find(x)
return -self.uf[x]
n,m = list(map(int,input().split()))
l = list(map(int,input().split()))
u = Unionfind(n)
for i in range(m):
x,y = list(map(int,input().split()))
u.union(x-1,y-1)
l1 = [[] for i in range(n)]
l2 = [[] for i in range(n)]
for i in range(n):
x = u.find(i)
l1[x].append(i)
l2[x].append(l[i]-1)
ans = 0
for i in range(n):
a = set(l1[i])
b = set(l2[i])
ans += len(a&b)
print(ans)
| class Unionfind:
def __init__(self,n):
self.uf = [-1]*n
def find(self,x):
if self.uf[x] < 0:
return x
else:
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def same(self,x,y):
return self.find(x) == self.find(y)
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.uf[x] > self.uf[y]:
x,y = y,x
self.uf[x] += self.uf[y]
self.uf[y] = x
def size(self,x):
x = self.find(x)
return -self.uf[x]
n,m = list(map(int,input().split()))
l = list(map(int,input().split()))
u = Unionfind(n)
for i in range(m):
x,y = list(map(int,input().split()))
u.union(x-1,y-1)
ans = 0
for i in range(n):
if u.same(i,l[i]-1):
ans += 1
print(ans)
| p03354 |
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n, m = None, read = 0):
self.n = n
self.parents = [-1] * n
if read:
if m is None:
exit(print("Warning: What is M"))
for i in range(m):
a, b = map(int, input().split())
self.union(a - 1, b - 1)
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
n, m = map(int, input().split())
*p, = map(int, input().split())
UF = UnionFind(n, m, read = 1)
a = 0
for i in range(n):
P = p[i] - 1
if UF.same(P, i):
a += 1
print(a)
| #!/usr/bin/env python3
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n, m = None, read = 0):
self.n = n
self.parents = [-1] * n
if read:
if m is None:
raise ValueError("What is M")
for i in range(m):
a, b = list(map(int, input().split()))
self.union(a - 1, b - 1)
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
n, m = list(map(int, input().split()))
*p, = list(map(int, input().split()))
UF = UnionFind(n, m, read = 1)
a = 0
for i in range(n):
P = p[i] - 1
if UF.same(P, i):
a += 1
print(a) | p03354 |
n, m = list(map(int, input().split()))
P = tuple([int(x)-1 for x in input().split()])
swaps = [set() for _ in range(n)]
for i in range(m):
x, y = tuple([int(x)-1 for x in input().split()])
swaps[x].add(y)
swaps[y].add(x)
c = 0
from collections import deque
for idx in range(n):
q = deque([idx])
visited = {idx}
while q:
i = q.pop()
if idx == P[i]:
c += 1
break
for s in swaps[i]:
if not s in visited:
visited.add(s)
q.append(s)
print(c)
| n, m = list(map(int, input().split()))
P = tuple([int(x)-1 for x in input().split()])
par = list(range(n))
size = [1] * n
def find(x):
""" 根のノードの値を見つけて返す """
if x != par[x]:
par[x] = find(par[x])
return par[x]
def unite(x, y):
"""xとyを結合する"""
rootx = find(x)
rooty = find(y)
if rootx == rooty:
return False
else:
if size[rootx] < size[rooty]:
par[rootx] = rooty
size[rooty] += size[rootx]
else:
par[rooty] = rootx
size[rootx] += size[rooty]
return True
def same(x, y):
""" xとyが同じ集合に属しているか """
return find(x) == find(y)
for _ in range(m):
x, y = [int(x)-1 for x in input().split()]
unite(x, y)
groups = {}
for idx, p in enumerate(par):
p = find(p)
groups.setdefault(p, set())
groups[p].add(idx)
cnt = 0
for k, g in list(groups.items()):
for gi in g:
pi = P[gi]
if pi in g:
cnt += 1
print(cnt)
| p03354 |
N,M = list(map(int,input().split()))
*P, = list(map(int,input().split()))
XY = [list(map(int,input().split())) for _ in [0]*M]
E = [[] for _ in [0]*N]
for x,y in XY:
E[x-1].append(y-1)
E[y-1].append(x-1)
def dist_bfs(N,E,start):
d = [-1]*N
d[start] = 0
q = [start]
while q:
i = q.pop()
di = d[i]
for j in E[i]:
if d[j]!=-1:continue
d[j] = di+1
q.append(j)
return d
done = [False]*N
ans = 0
for i in range(N):
if done[i]:continue
d = dist_bfs(N,E,i)
J = set(j for j in range(N) if d[j]>=0)
PJ = set(P[j]-1 for j in J)
ans += len(J & PJ)
for j in J:
done[j] = True
print(ans) | N,M = list(map(int,input().split()))
*P, = list(map(int,input().split()))
XY = [list(map(int,input().split())) for _ in [0]*M]
E = [[] for _ in [0]*N]
for x,y in XY:
E[x-1].append(y-1)
E[y-1].append(x-1)
def connect_bfs(N,E,start):
connect = {start}
q = [start]
while q:
i = q.pop()
for j in E[i]:
if j in connect:continue
connect.add(j)
q.append(j)
return connect
done = [False]*N
ans = 0
for i in range(N):
if done[i]:continue
J = connect_bfs(N,E,i)
PJ = set(P[j]-1 for j in J)
ans += len(J & PJ)
for j in J:
done[j] = True
print(ans) | p03354 |
N,M = list(map(int,input().split()))
*P, = list(map(int,input().split()))
XY = [list(map(int,input().split())) for _ in [0]*M]
E = [[] for _ in [0]*N]
for x,y in XY:
E[x-1].append(y-1)
E[y-1].append(x-1)
def connect_bfs(N,E,start):
connect = {start}
q = [start]
while q:
i = q.pop()
for j in E[i]:
if j in connect:continue
connect.add(j)
q.append(j)
return connect
done = [False]*N
ans = 0
for i in range(N):
if done[i]:continue
J = connect_bfs(N,E,i)
PJ = set(P[j]-1 for j in J)
ans += len(J & PJ)
for j in J:
done[j] = True
print(ans) | N,M = list(map(int,input().split()))
*P, = list(map(int,input().split()))
XY = [list(map(int,input().split())) for _ in [0]*M]
def get_Parent(n):
if Parent[n] == -1:return n
par = get_Parent(Parent[n])
Parent[n] = par
return par
def merge(x,y):
x = get_Parent(x)
y = get_Parent(y)
if x!=y: Parent[y] = x
return
def is_united(x,y):
return get_Parent(x)==get_Parent(y)
Parent = [-1]*N
for x,y in XY:
x-=1
y-=1
merge(x,y)
print((sum(is_united(i,p-1) for i,p in enumerate(P)))) | p03354 |
n,m = list(map(int,input().split()))
p = list(map(int,input().split()))
root = [[] for i in range(n)]
for _ in range(m):
a, b = (int(x) for x in input().split())
root[b-1].append(a-1)
root[a-1].append(b-1)
dp = [False]*n
ans = 0
for j in range(n):
if dp[j]:
continue
check = [-1]*n
check[j] = 0
stack=[j]
dp[j] = True
while len(stack):
v = stack.pop()
for i in root[v]:
if check[i] == -1:
dp[i] = True
check[i]=i
stack.append(i)
for k in range(n):
if check[k] != -1 and check[p[k]-1] != -1:
ans += 1
print(ans) | n,m = list(map(int,input().split()))
p = list(map(int,input().split()))
root = [[] for i in range(n)]
for _ in range(m):
a, b = (int(x) for x in input().split())
root[b-1].append(a-1)
root[a-1].append(b-1)
check = [-1]*n
ans = 0
for j in range(n):
if check[j] != -1:
continue
stack=[j]
check[j]=j
while len(stack):
v = stack.pop(0)
for i in root[v]:
if check[i] == -1:
check[i]=j
stack.append(i)
for k in range(n):
if check[k] == check[p[k]-1] :
ans += 1
print(ans) | p03354 |
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
tree = UnionFind(n)
for x, y in xy:
tree.Unite(x, y)
root = [[] for _ in range(n+1)]
f_root = []
for i in range(n):
x = tree.Find_Root(p[i])
root[x].append(i+1)
f_root.append(x)
out_put = 0
for i in range(n):
if p[i] in root[f_root[i]]:
out_put += 1
print(out_put)
if __name__=="__main__":
main() | class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
tree = UnionFind(n)
for x, y in xy:
tree.Unite(x, y)
root = [[] for _ in range(n+1)]
f_root = []
for i in range(n):
x = tree.Find_Root(p[i])
root[x].append(i+1)
f_root.append(x)
out_put = 0
for i in range(n):
if f_root[i]==f_root[p[i]-1]:
out_put += 1
print(out_put)
if __name__=="__main__":
main() | p03354 |
n, m = list(map(int, input().split()))
ps = [int(i) - 1 for i in input().split()]
neighbors = {v: [] for v in range(n)}
for _ in range(m):
x, y = list(map(int, input().split()))
neighbors[x - 1] += [y - 1]
neighbors[y - 1] += [x - 1]
visited = [False] * n
def conn(i0):
q = [i0]
c = set([i0])
while q:
i = q.pop()
visited[i] = True
c.add(i)
for n in neighbors[i]:
if not visited[n]:
q.append(n)
return c
def nmatch(c):
p = set([ps[i] for i in c])
return len(p & c)
conns = []
for i in range(n):
if not visited[i]:
conns.append(conn(i))
answer = sum(nmatch(c) for c in conns)
print(answer)
| n, m = list(map(int, input().split()))
ps = [int(i) - 1 for i in input().split()]
xy = [list(map(int, input().split())) for _ in range(m)]
dfind = {i: i for i in range(n)}
def find(v):
visit = []
while dfind[v] != v:
visit.append(v)
v = dfind[v]
for i in visit:
dfind[i] = v
return v
def union(v0, v1):
g0, g1 = find(v0), find(v1)
g0, g1 = min(g0, g1), max(g0, g1)
if g0 != g1:
dfind[g1] = g0
for x, y in xy:
union(x - 1, y - 1)
nmatch = 0
for i, p in enumerate(ps):
if find(i) == find(p):
nmatch += 1
print(nmatch)
| p03354 |
N,M = list(map(int, input().split()))
P = list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(N)
for _ in range(M):
x,y = list(map(int, input().split()))
uf.union(x-1,y-1)
ans = 0
for lis in list(uf.all_group_members().values()):
s = set(lis)
for a in s:
if P[a]-1 in s:
ans += 1
print(ans) | N,M = list(map(int, input().split()))
P = list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(N+1)
for _ in range(M):
x,y = list(map(int, input().split()))
uf.union(x,y)
ans = 0
for i in range(N):
if uf.same(i+1, P[i]):
ans += 1
print(ans) | p03354 |
from collections import defaultdict
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
if self.rank[x]<self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x]==self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
N, M = list(map(int, input().split()))
h = [int(i)-1 for i in input().split()]
dic1 = defaultdict(list)
dic2 = defaultdict(list)
u = UnionFind(N)
for i in range(M):
a, b = list(map(int, input().split()))
u.unite(a-1,b-1)
for c in range(N):
p = u.find(c)
dic1[p] += [c]
dic2[p] += [h[c]]
ans = 0
for p in list(dic1.keys()):
dic1[p].sort()
dic2[p].sort()
i = 0
j = 0
while i<len(dic1[p]) and j<len(dic2[p]):
if dic1[p][i]==dic2[p][j]:
i += 1
j += 1
ans += 1
elif dic1[p][i]<dic2[p][j]:
i += 1
else:
j += 1
print(ans) | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
return
elif self.rank[y]<self.rank[x]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
N, M, *L = list(map(int, open(0).read().split()))
p = L[:N]
ls = L[N:]
u = UnionFind(N+1)
for x,y in zip(*[iter(ls)]*2):
u.unit(x,y)
inf = {p[i]:i for i in range(N)}
ans = sum(1 if u.same(i,inf[i]+1) else 0 for i in range(1,N+1))
print(ans) | p03354 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
return
elif self.rank[y]<self.rank[x]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
N, M, *L = list(map(int, open(0).read().split()))
p = L[:N]
ls = L[N:]
u = UnionFind(N+1)
for x,y in zip(*[iter(ls)]*2):
u.unit(x,y)
inf = {p[i]:i for i in range(N)}
ans = sum(1 if u.same(i,inf[i]+1) else 0 for i in range(1,N+1))
print(ans) | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
return
elif self.rank[y]<self.rank[x]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
N, M, *L = list(map(int, open(0).read().split()))
p = L[:N]
ls = L[N:]
u = UnionFind(N+1)
for x,y in zip(*[iter(ls)]*2):
u.unit(x,y)
inf = [0]*(N+1)
for i in range(N):
inf[p[i]] = i
ans = sum(1 if u.same(i,inf[i]+1) else 0 for i in range(1,N+1))
print(ans) | p03354 |
n,m = list(map(int, input().split()))
P = [0]+list(map(int, input().split()))
XY = list(list(map(int, input().split())) for _ in range(m))
G = [[] for _ in range(n+1)]
for x, y in XY:
G[x].append(y)
G[y].append(x)
# print(n,m)
# print(P)
# print(XY)
# print(G)
# for i in range(len(G)):#########
# print(i, G[i])###############
from collections import deque
q = deque()
vis = [False]*(n+1)
ans = 0
for i in range(1,len(G)):
# print('i',i, 'G[i]',G[i])
inc_x = set()
inc_px = set()
q.append(i)
while q:
# print(q)
x = q.popleft()
if vis[x]: continue
vis[x] = True
inc_x.add(x)
inc_px.add(P[x])
# print('x',x,'P[x]',P[x],'G[x]',G[x])
for y in G[x]:
# print('y',y)
if vis[y]: continue
q.append(y)
# print('inc_x',inc_x)
# print('inc_px',inc_px)
# print('inc_x&inc_px',inc_x&inc_px)
# print('len(inc_x&inc_px)',len(inc_x&inc_px))
ans += len(inc_x & inc_px)
print(ans)
| from collections import deque
n,m = list(map(int, input().split()))
P = [0]+list(map(int, input().split()))
XY = list(list(map(int, input().split())) for _ in range(m))
G = [[] for _ in range(n+1)]
for x, y in XY:
G[x].append(y)
G[y].append(x)
q = deque()
vis = [False]*(n+1)
ans = 0
for i in range(1,len(G)):
set_x, set_px = set(), set()
q.append(i)
while q:
x = q.popleft()
if vis[x]: continue
vis[x] = True
set_x.add(x)
set_px.add(P[x])
for y in G[x]:
if vis[y]: continue
q.append(y)
ans += len(set_x & set_px)
print(ans)
| p03354 |
N,M=list(map(int,input().split()))
p=list([int(x)-1 for x in input().split()])
xy=[list([int(x)-1 for x in input().split()]) for _ in [0]*M]
z=[[i,1] for i in range(N)]
def root_find(a):
while(a!=z[a][0]):
a=z[a][0]
return a
def union(a,b):
ra=root_find(a[0])
rb=root_find(b[0])
if z[ra][1]<=z[rb][1]:
z[ra][0]=rb
z[rb][1]=max(z[rb][1],z[ra][1]+1)
else:
z[rb][0]=ra
z[ra][1]=max(z[ra][1],z[rb][1]+1)
for i in range(M):
union(z[xy[i][0]],z[xy[i][1]])
for i in range(N):
z[i][0]=root_find(z[i][0])
dic=dict()
for i in range(N):
zz=z[i][0]
if zz not in list(dic.keys()):
dic[zz]=[i]
else:
dic[zz].append(i)
list1=list(dic.values())
list2=[[] for _ in [0]*len(list1)]
for i in range(len(list1)):
for a in list1[i]:
list2[i].append(p[a])
cnt=0
for i in range(len(list1)):
for a in list1[i]:
if a in list2[i]:
cnt+=1
print(cnt) | N,M=list(map(int,input().split()))
p=list([int(x)-1 for x in input().split()])
xy=[list([int(x)-1 for x in input().split()]) for _ in [0]*M]
z=[[i,1] for i in range(N)]
def root_find(a):
while(a!=z[a][0]):
a=z[a][0]
return a
def union(a,b):
ra=root_find(a[0])
rb=root_find(b[0])
if z[ra][1]<=z[rb][1]:
z[ra][0]=rb
z[rb][1]=max(z[rb][1],z[ra][1]+1)
else:
z[rb][0]=ra
z[ra][1]=max(z[ra][1],z[rb][1]+1)
for i in range(M):
union(z[xy[i][0]],z[xy[i][1]])
for i in range(N):
z[i][0]=root_find(z[i][0])
dic=dict()
for i in range(N):
zz=z[i][0]
if zz not in list(dic.keys()):
dic[zz]=[i]
else:
dic[zz].append(i)
list1=list(dic.values())
list2=[[p[a] for a in list1[i]] for i in range(len(list1))]
cnt=sum(len(set(list1[i])&set(list2[i])) for i in range(len(list1)))
print(cnt) | p03354 |
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.par = [i for i in range(n)]
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
self.par[x] = y
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
p = [v-1 for v in p]
uf = UnionFind(n)
for _ in range(m):
x, y = list(map(int, input().split()))
uf.unite(x-1, y-1)
a = defaultdict(list)
b = defaultdict(list)
for i in range(n):
k = uf.find(i)
a[k].append(i)
b[k].append(p[i])
ans = 0
for k in list(a.keys()):
ans += len(set(a[k]) & set(b[k]))
print(ans)
| from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.par = [i for i in range(n)]
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
self.par[x] = y
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
p = [v-1 for v in p]
uf = UnionFind(n)
for _ in range(m):
x, y = list(map(int, input().split()))
uf.unite(x-1, y-1)
ans = 0
for i in range(n):
if uf.same(i, p[i]):
ans += 1
print(ans)
| p03354 |
import sys
input = sys.stdin.buffer.readline
N,M = list(map(int,input().split()))
p = [i-1 for i in map(int,input().split())]
alr = [False for i in range(N)]
xy = [[] for i in range(N)]
for i in range(M):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
xy[x].append(y)
xy[y].append(x)
count = 0
for i in range(N):
if (not alr[i]) and (xy[i]):
alr[i] = True
stack = [i]
indlist = set()
indlist.add(p.index(i))
numlist = set()
numlist.add(i)
while stack:
j = stack.pop()
for k in xy[j]:
if not alr[k]:
alr[k] = True
stack.append(k)
numlist.add(k)
indlist.add(p.index(k))
count += len(numlist & indlist)
else:
if (not alr[i]) and p[i] == i:
count += 1
print(count)
| import sys
input = sys.stdin.buffer.readline
N,M = list(map(int,input().split()))
p = [i-1 for i in map(int,input().split())]
alr = [False for i in range(N)]
xy = [[] for i in range(N)]
for i in range(M):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
xy[x].append(y)
xy[y].append(x)
count = 0
for i in range(N):
if (not alr[i]) and (xy[i]):
alr[i] = True
stack = [i]
numlist = set()
numlist.add(i)
while stack:
j = stack.pop()
for k in xy[j]:
if not alr[k]:
alr[k] = True
stack.append(k)
numlist.add(k)
indlist = set([p[i] for i in numlist])
count += len(numlist & indlist)
else:
if (not alr[i]) and p[i] == i:
count += 1
print(count)
| p03354 |
N,M = list(map(int,input().split()))
p = [0] + [int(x) for x in input().split()]
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x: return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]: self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
UF = UnionFind(N)
for _ in range(M):
x,y = list(map(int,input().split()))
UF.union(x, y)
unionUF, unionp, par = [], [], []
for i in range(1, N+1):
temp = UF.find(i)
if temp in par:
unionUF[par.index(temp)].add(i)
unionp[par.index(temp)].add(p[i])
else:
par.append(temp)
unionUF.append(set([i]))
unionp.append(set([p[i]]))
ans = 0
for i in range(len(unionUF)):
ans += len(unionUF[i] & unionp[i])
print(ans) | N,M = list(map(int,input().split()))
p = [0] + [int(x) for x in input().split()]
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x: return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]: self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
UF = UnionFind(N)
for _ in range(M):
x,y = list(map(int,input().split()))
UF.union(x, y)
unionUF, unionp = [set() for _ in range(N+1)], [set() for _ in range(N+1)]
for i in range(1, N+1):
temp = UF.find(i)
unionUF[temp].add(i)
unionp[temp].add(p[i])
ans = 0
for i in range(len(unionUF)):
ans += len(unionUF[i] & unionp[i])
print(ans) | p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = list(map(int,input().split()))
P = list(map(int,input().split()))
uf = UnionFind(N)
for i in range(M):
a, b = list(map(int,input().split()))
uf.union(a-1,b-1)
A = list(uf.all_group_members().values())
a = len(A)
B =[[] for i in range(a)]
import bisect
ans = 0
for i in range(a):
S = A[i]
for j in range(len(S)):
s = S[j]
insert_index = bisect.bisect_left(B[i],P[s]-1)
B[i].insert(insert_index,P[s]-1)
for k in range(len(S)):
s = S[k]
n = bisect.bisect_left(B[i],s)
if n < len(B[i]):
if B[i][n] == s:
ans += 1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = list(map(int,input().split()))
P = list(map(int,input().split()))
uf = UnionFind(N+1)
for i in range(M):
a, b = list(map(int,input().split()))
uf.union(a,b)
ans = 0
for i in range(1,N+1):
if uf.same(i,P[i-1]):
ans += 1
print(ans) | p03354 |
#!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
p = list(map(int, input().split()))
swappair= [list(map(int, input().split())) for _ in range(M)]
union_list = [-1 for _ in range(N+1)]
def find(a): # get root
while not union_list[a] == -1:
a = union_list[a]
return a
def merge(a,b):
ia = find(a)
ib = find(b)
if ia < ib:
union_list[ib] = ia
elif ia > ib:
union_list[ia] = ib
elif ia==ib:
union_list[ia] -= 1
union_list[ib] = ia
def is_same_grp(a,b):
ia = find(a)
ib = find(b)
return ia == ib
for i in range(M):
merge(*swappair[i])
ans = 0
for i in range(1,N+1):
ans += int( is_same_grp(i, p[i-1]))
print(ans)
| #!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
p = list(map(int, input().split()))
swappair= [list(map(int, input().split())) for _ in range(M)]
union_list = [-1 for _ in range(N+1)]
def find(a): # get root
while not union_list[a] == -1:
a = union_list[a]
return a
def merge(a,b):
ia = find(a)
ib = find(b)
if ia == ib:
return
if ia < ib:
union_list[ib] = ia
elif ia > ib:
union_list[ia] = ib
def is_same_grp(a,b):
ia = find(a)
ib = find(b)
return ia == ib
for i in range(M):
merge(*swappair[i])
ans = 0
for i in range(1,N+1):
ans += int( is_same_grp(i, p[i-1]))
print(ans)
| p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
p = [int(i)-1 for i in input().split() ]
uf = UnionFind(n)
for i in range(m):
x,y = list(map(int,input().split()))
uf.union(x-1,y-1)
ans=0
groups = list(uf.all_group_members().values())
for c in groups:
ans+= len( set(c) & set(p[i] for i in c ) )
print(ans)
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
p = [int(i)-1 for i in input().split() ]
uf = UnionFind(n)
for i in range(m):
x,y = list(map(int,input().split()))
uf.union(x-1,y-1)
print((sum(uf.same(i,p[i]) for i in range(n) ) )) | p03354 |
class DisjointSet:
def __init__(self,size):
self.rank=[0]*size
self.p=[0]*size
for i in range(size):
self.makeSet(i)
def makeSet(self,i):
self.p[i]=i
self.rank[i]=0
def same(self,x,y):
return self.findSet(x) == self.findSet(y)
def unite(self, x,y):
self.link(self.findSet(x), self.findSet(y))
def link(self, x, y):
if(self.rank[x] > self.rank[y]):
self.p[y] = x
else:
self.p[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y]+=1
def findSet(self, x):
if(x!=self.p[x]):
self.p[x]=self.findSet(self.p[x])
return self.p[x]
def print(self):
print(self.p)
def readinput():
n,m=list(map(int,input().split()))
p=list(map(int,input().split()))
p.insert(0,0)
pairs=[]
for _ in range(m):
pair=list(map(int,input().split()))
pairs.append(pair)
return n,m,p,pairs
def main(n,m,p,pairs):
uft=DisjointSet(n+1)
for x,y in pairs:
if uft.same(x, y):
pass
else:
uft.unite(x, y)
#uft.print()
#print(p)
count=0
for i in range(1,n+1):
for j in range(1,n+1):
if i==p[j]:
#print(i,j)
break
if uft.same(i,j):
#p[i],p[j] = p[j], p[i]
count+=1
return count
if __name__=='__main__':
n,m,p,pairs=readinput()
ans=main(n,m,p,pairs)
print(ans)
| class DisjointSet:
def __init__(self,size):
self.rank=[0]*size
self.p=[0]*size
for i in range(size):
self.makeSet(i)
def makeSet(self,i):
self.p[i]=i
self.rank[i]=0
def same(self,x,y):
return self.findSet(x) == self.findSet(y)
def unite(self, x,y):
self.link(self.findSet(x), self.findSet(y))
def link(self, x, y):
if(self.rank[x] > self.rank[y]):
self.p[y] = x
else:
self.p[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y]+=1
def findSet(self, x):
if(x!=self.p[x]):
self.p[x]=self.findSet(self.p[x])
return self.p[x]
def print(self):
print(self.p)
def readinput():
n,m=list(map(int,input().split()))
p=list(map(int,input().split()))
p.insert(0,0)
pairs=[]
for _ in range(m):
pair=list(map(int,input().split()))
pairs.append(pair)
return n,m,p,pairs
def main(n,m,p,pairs):
uft=DisjointSet(n+1)
for x,y in pairs:
if uft.same(x, y):
pass
else:
uft.unite(x, y)
#uft.print()
#print(p)
count=0
for i in range(1,n+1):
if uft.same(i,p[i]):
#p[i],p[j] = p[j], p[i]
count+=1
return count
if __name__=='__main__':
n,m,p,pairs=readinput()
ans=main(n,m,p,pairs)
print(ans)
| p03354 |
n, m = list(map(int, input().split()))
ps = [int(p)-1 for p in input().split()]
xys = [tuple(int(x)-1 for x in input().split()) for _ in range(m)]
nodes = list(range(n))
union = {node:node for node in nodes}
def root(node):
if union[node] == node:
return node
union[node] = root(union[node])
return union[node]
for x, y in xys:
rx = root(x)
ry = root(y)
union[rx] = ry
print((sum(root(i) == root(p) for i, p in enumerate(ps)))) | n, m = list(map(int, input().split()))
ps = [int(p)-1 for p in input().split()]
xys = [tuple(int(x)-1 for x in input().split()) for _ in range(m)]
union = {node:node for node in range(n)}
def root(node):
if union[node] == node:
return node
union[node] = root(union[node])
return union[node]
for x, y in xys:
union[root(x)] = root(y)
print((sum(root(i) == root(p) for i, p in enumerate(ps)))) | p03354 |
n, m = list(map(int, input().split()))
ps = [int(p)-1 for p in input().split()]
xys = [tuple(int(x)-1 for x in input().split()) for _ in range(m)]
union = {node:(node, 0) for node in range(n)}
def root(node):
if union[node][0] == node:
return union[node]
union[node] = root(union[node][0])
return union[node]
def unite(*roots):
r1, r2 = sorted(roots, key=lambda x:x[1])
rank = max(r1[1]+1, r2[1])
r = (r2[0], rank)
union[r1[0]] = union[r2[0]] = r
for x, y in xys:
unite(root(x), root(y))
print((sum(root(i) == root(p) for i, p in enumerate(ps)))) | n, m = list(map(int, input().split()))
ps = [int(p)-1 for p in input().split()]
xys = [tuple(int(x)-1 for x in input().split()) for _ in range(m)]
union = {node:node for node in range(n)}
depth = {node:0 for node in range(n)}
def root(node):
if union[node] == node:
return union[node]
union[node] = root(union[node])
return union[node]
for x, y in xys:
a, b = sorted((root(x), root(y)), key=lambda z:depth[z])
union[a] = b
depth[b] = max(depth[b], depth[a]+1)
print((sum(root(i) == root(p) for i, p in enumerate(ps)))) | p03354 |
N, M = list(map(int, input().split()))
sigma = list(map(int, input().split()))
gokans = []
for i in range(M):
pair = tuple(map(int, input().split()))
gokans.append(pair)
def connected(i, j, paths):
if [pair for pair in paths if i in pair] and [pair for pair in paths if j in pair]:
new_chain_i = [pair for pair in paths if i in pair]
new_chain_j = [pair for pair in paths if j in pair]
for pair in set(new_chain_i + new_chain_j):
paths.remove(pair)
narabi_i = set([couple[0] for couple in new_chain_i] + [couple[1] for couple in new_chain_i])
narabi_j = set([couple[0] for couple in new_chain_j] + [couple[1] for couple in new_chain_j])
if narabi_i & narabi_j != set():
return True
while new_chain_i and new_chain_j:
new_chain_i_kari = []
new_chain_j_kari = []
for pair in new_chain_i:
new_chain_i_kari += [couple for couple in paths if set(couple) & set(pair) != set()]
for pair in new_chain_j:
new_chain_j_kari += [couple for couple in paths if set(couple) & set(pair) != set()]
new_chain_i = new_chain_i_kari
new_chain_j = new_chain_j_kari
for pair in set(new_chain_i + new_chain_j):
paths.remove(pair)
narabi_i = set([couple[0] for couple in new_chain_i] + [couple[1] for couple in new_chain_i])
narabi_j = set([couple[0] for couple in new_chain_j] + [couple[1] for couple in new_chain_j])
if narabi_i & narabi_j != set():
return True
return False
else:
return False
count = 0
for i in range(1, N+1):
if i != sigma[i-1]:
gokans1 = gokans.copy()
if connected(i, sigma[i-1], gokans1):
count += 1
else:
count += 1
print(count) | n,m = list(map(int, input().split()))
p = list(map(int, input().split()))
par = [i for i in range(n)]
#rootの計算量は、parが最初の状態に近いほど値は小さくて、高々O(n)
def root(x):
tmp = par[x]
if tmp == x:
return x
else:
a = root(tmp)
par[x] = a
return a
def merge(x, y):
x = root(x)
y = root(y)
if x != y:
par[x] = y
return
for i in range(m):
x, y = list(map(int, input().split()))
merge(x-1, y-1)
#print(par)
ans = 0
for i in range(n):
if p[i]-1 == i:
ans += 1
elif root(p[i]-1) == root(i):
ans += 1
print(ans) | p03354 |
import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
p = [int(x) for x in input().split()]
from collections import deque
def bfs(u):
d = [-1] * n
queue = deque([u])
d[u] = 0
while queue:
v = queue.popleft()
for i in g[v]:
if d[i] < 0:
d[i] = d[v] + 1
queue.append(i)
return d
g = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x) for x in input().split()]
g[x - 1].append(y - 1)
g[y - 1].append(x - 1)
ans = 0
for i, j in enumerate(p):
# print(i, j)
d = bfs(i)
# print(d)
if d[j - 1] >= 0:
ans += 1
print(ans)
| import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
p = [int(x) for x in input().split()]
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
#初期化
#根なら-size,子なら親の頂点
par = [-1]*n
###具体例###
for _ in range(m):
a, b = [int(x) for x in input().split()]
unite(a - 1, b - 1)
ans = 0
for i, j in enumerate(p):
if same(i, j - 1):
ans += 1
print(ans) | p03354 |
N,M=list(map(int,input().split()))
p=list(map(int,input().split()))
p=[0]+p
par=[i for i in range(N+1)]
size=[1 for i in range(N+1)]
def find(x):
if par[x]==x:
return x
else:
return find(par[x])
def union(x,y):
if size[x]>size[y]:
size[x]+=size[y]
par[y]=find(x)
elif size[y]>size[x]:
size[y]+=size[x]
par[x]=find(y)
elif size[x]==size[y]:
size[x]+=size[y]
par[y]=find(x)
for i in range(M):
a,b=list(map(int,input().split()))
if find(a)==find(b):
pass
else:
union(find(a),find(b))
#print(par)
ans=0
for i in range(1,N+1):
if find(i)==find(p.index(i)):
ans+=1
#print(i,find(i))
print(ans) | N,M=list(map(int,input().split()))
p=list(map(int,input().split()))
p=[0]+p
par=[i for i in range(N+1)]
size=[1 for i in range(N+1)]
def find(x):
if par[x]==x:
return x
else:
return find(par[x])
def union(x,y):
if size[x]>size[y]:
size[x]+=size[y]
par[y]=find(x)
elif size[y]>size[x]:
size[y]+=size[x]
par[x]=find(y)
elif size[x]==size[y]:
size[x]+=size[y]
par[y]=find(x)
for i in range(M):
a,b=list(map(int,input().split()))
if find(a)==find(b):
pass
else:
union(find(a),find(b))
#print(par)
ans=0
for i in range(1,N+1):
if find(i)==find(p[i]):
ans+=1
#print(i,find(i))
print(ans)
| p03354 |
from operator import itemgetter
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')
N, M = map(int, input().split())
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*(n)
self.size = [1]*(n)
self.n = n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def get_size(self, x):
x = self.find(x)
return self.size[x]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i, x in enumerate(self.par) if i==x]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
uni = UnionFind(N)
for xyi in xy:
x, y = xyi
x, y = x-1, y-1
uni.union(x, y)
# print(uni.all_group_members())
res = 0
for gr in uni.all_group_members().values():
if len(gr)==1:
if gr[0]+1 == p[gr[0]]:
res += 1
else:
s1 = set(itemgetter(*gr)(p))
s2 = set([val+1 for val in gr])
res += len(s1&s2)
print(res)
| # import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * (n)
self.size = [1] * (n)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def get_size(self, x):
x = self.find(x)
return self.size[x]
N, M = map(int, input().split())
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
uni = UnionFind(N + 1)
for xyi in xy:
x, y = xyi
uni.union(x, y)
cnt = 0
for i, pi in enu(p):
if uni.same_check(i + 1, pi):
cnt += 1
print(cnt)
| p03354 |
from collections import deque
q = deque([])
def get_root(i):
while True:
if parent[i] == -1:
return i
i = parent[i]
def bfs(i):
global l
c = 0
q.append(i)
while True:
if len(q) == 0:
break
p = q.popleft()
l.append(p)
c += 1
if not children[p] == -1:
for j in children[p]:
q.append(j)
return c
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = [-1] * n
children = [-1] * n
d = [0] * n
root = []
rank = []
num = ["a"] * n
for _ in range(m):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
if num[x] == "a":
num[x] = [y]
else:
num[x].append(y)
if num[y] == "a":
num[y] = [x]
else:
num[y].append(x)
if d[x] == d[y] == 0:
root.append(x)
rank.append(1)
children[x] = [y]
parent[y] = x
d[x] = 1
d[y] = 1
elif d[x] == 1 and d[y] == 0:
r = get_root(x)
children[r].append(y)
parent[y] = r
d[y] = 1
elif d[x] == 0 and d[y] == 1:
r = get_root(y)
children[r].append(x)
parent[x] = r
d[x] = 1
else:
s = get_root(x)
t = get_root(y)
if not s == t:
i = rank[root.index(s)]
j = rank[root.index(t)]
if i >= j:
parent[t] = s
children[s].append(t)
if i == j:
rank[root.index(s)] += 1
else:
parent[s] = t
children[t].append(s)
ans = 0
for i in range(n):
if parent[i] == -1 and children[i] != -1:
l = []
bfs(i)
p0 = list(l)
for j in l:
pp = p[j] - 1
p0.append(pp)
k = len(p0)
ans += k - len(set(p0))
elif parent[i] == -1:
if p[i] - 1 == i:
ans += 1
print(ans) | def get_root(s):
if s != root[s]:
root[s] = get_root(root[s])
return root[s]
return s
def unite(s, t):
root_s = get_root(s)
root_t = get_root(t)
if not root_s == root_t:
if rank[s] == rank[t]:
root[root_t] = root_s
rank[root_s] += 1
elif rank[s] > rank[t]:
root[root_t] = root_s
else:
root[root_s] = root_t
def same(s, t):
if get_root(s) == get_root(t):
return True
else:
return False
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
root = [i for i in range(n)]
rank = [1 for _ in range(n)]
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x - 1, y - 1)
ans = 0
for i in range(n):
if get_root(i) == get_root(p[i] - 1):
ans += 1
print(ans) | p03354 |
class unionFind():
def __init__(self,n):
self.tree=[-1]*n
def find(self,x):
if self.tree[x]<0:
return x
else:
return self.find(self.tree[x])
def union(self,x,y):
xr=self.find(x)
yr=self.find(y)
if xr!=yr:
if self.tree[xr]<self.tree[yr]:
self.tree[yr]=xr
elif self.tree[xr]>self.tree[yr]:
self.tree[xr]=yr
else:
self.tree[xr]-=1
self.tree[yr]=xr
return True
return False
def main():
ans=0
n,m=list(map(int,input().split()))
a=unionFind(n)
li=[x-1 for x in list(map(int,input().split()))]
for _ in range(m):
x,y=list(map(int,input().split()))
a.union(x-1,y-1)
for x in range(n):
if a.find(x)==a.find(li[x]):
ans+=1
return ans
print((main()))
| class unionFind():
def __init__(self,n):
self.tree=[-1]*n
def find(self,x):
if self.tree[x]<0:
return x
else:
return self.find(self.tree[x])
def union(self,x,y):
xr=self.find(x)
yr=self.find(y)
if xr!=yr:
if self.tree[xr]<self.tree[yr]:
self.tree[yr]=xr
elif self.tree[xr]>self.tree[yr]:
self.tree[xr]=yr
else:
self.tree[xr]-=1
self.tree[yr]=xr
return True
return False
def main():
ans=0
n,m=list(map(int,input().split()))
a=unionFind(n)
li=[x-1 for x in list(map(int,input().split()))]
for _ in range(m):
x,y=list(map(int,input().split()))
a.union(x-1,y-1)
for x in range(n):
ans += a.find(x)==a.find(li[x])
return ans
print((main()))
| p03354 |
class unionFind():
def __init__(self,n):
self.tree=[-1]*n
def find(self,x):
if self.tree[x]<0:
return x
else:
return self.find(self.tree[x])
def union(self,x,y):
xr=self.find(x)
yr=self.find(y)
if xr!=yr:
if self.tree[xr]<self.tree[yr]:
self.tree[yr]=xr
elif self.tree[xr]>self.tree[yr]:
self.tree[xr]=yr
else:
self.tree[xr]-=1
self.tree[yr]=xr
return True
return False
def main():
ans=0
n,m=list(map(int,input().split()))
a=unionFind(n)
li=[x-1 for x in list(map(int,input().split()))]
for _ in range(m):
x,y=list(map(int,input().split()))
a.union(x-1,y-1)
for x in range(n):
ans += a.find(x)==a.find(li[x])
return ans
print((main()))
| class unionFind():
def __init__(self,n):
self.tree=[-1]*n
def find(self,x):
if self.tree[x]<0:
return x
else:
self.tree[x]=self.find(self.tree[x])
return self.tree[x]
def union(self,x,y):
xr=self.find(x)
yr=self.find(y)
if xr!=yr:
if self.tree[xr]<self.tree[yr]:
self.tree[yr]=xr
elif self.tree[xr]>self.tree[yr]:
self.tree[xr]=yr
else:
self.tree[xr]-=1
self.tree[yr]=xr
return True
return False
def main():
ans=0
n,m=list(map(int,input().split()))
a=unionFind(n)
li=[x-1 for x in list(map(int,input().split()))]
for _ in range(m):
x,y=list(map(int,input().split()))
a.union(x-1,y-1)
for x in range(n):
ans += a.find(x)==a.find(li[x])
return ans
print((main())) | p03354 |
import sys
sys.setrecursionlimit(2000000000)
class Node:
def __init__(self, index):
self.index = index
self.connected_indices = set()
def __repr__(self):
return '{}: {}'.format(self.index, self.connected_indices)
def build_graph(nodes, curr_index, connected_indices, reached_indices):
# already reached
if curr_index in connected_indices or curr_index in reached_indices:
return
connected_indices |= {curr_index}
reached_indices |= {curr_index}
unreached_indices = nodes[curr_index].connected_indices - connected_indices
for i in unreached_indices:
build_graph(nodes, i, connected_indices, reached_indices)
return connected_indices
# if True:
# line_index = 0
#
#
# def input():
# global line_index
# lines = ['10 8',
# '5 3 6 8 7 10 9 1 2 4',
# '3 1',
# '4 1',
# '5 9',
# '2 5',
# '6 5',
# '3 5',
# '8 9',
# '7 9']
#
# line = lines[line_index]
# line_index += 1
# return line
if __name__ == '__main__':
N, M = list(map(int, input().split()))
p = [int(v) - 1 for v in input().split()]
nodes = [Node(i) for i in range(N)]
for _ in range(M):
xy_str = input().split()
x, y = int(xy_str[0]) - 1, int(xy_str[1]) - 1
nodes[x].connected_indices |= {y}
nodes[y].connected_indices |= {x}
reached_indices = set()
all_connected_indices = [None] * N
for i in range(N):
connected_indices = build_graph(nodes, i, set(), reached_indices)
if connected_indices is None:
continue
for c in connected_indices:
all_connected_indices[c] = connected_indices
answer = sum([p[i] in all_connected_indices[i] for i in range(N)])
print(answer)
# print(desirable_swaps)
# print(nodes)
| import sys
sys.setrecursionlimit(2000000000)
class Node:
def __init__(self, index):
self.index = index
self.connected_indices = set()
def build_graph(nodes, curr_index, connected_indices, reached_indices):
# already reached
if curr_index in connected_indices or curr_index in reached_indices:
return
connected_indices |= {curr_index}
reached_indices |= {curr_index}
unreached_indices = nodes[curr_index].connected_indices - connected_indices
for i in unreached_indices:
build_graph(nodes, i, connected_indices, reached_indices)
return connected_indices
if __name__ == '__main__':
N, M = list(map(int, input().split()))
p = [int(v) - 1 for v in input().split()]
nodes = [Node(i) for i in range(N)]
for _ in range(M):
xy_str = input().split()
x, y = int(xy_str[0]) - 1, int(xy_str[1]) - 1
# link neighbors
nodes[x].connected_indices |= {y}
nodes[y].connected_indices |= {x}
reached_indices = set()
all_connected_indices = [None] * N
for i in range(N):
connected_indices = build_graph(nodes, i, set(), reached_indices)
if connected_indices is None:
continue
for c in connected_indices:
all_connected_indices[c] = connected_indices
answer = sum([p[i] in all_connected_indices[i] for i in range(N)])
print(answer)
| p03354 |
from collections import deque
n,m = list(map(int,input().split()))
ps = [0] + list(map(int,input().split()))
memo = [[] for _ in range(n+1)]
connect = [[] for _ in range(n+1)]
visited = [0]*(n+1)
for i in range(m):
x,y = list(map(int,input().split()))
memo[x].append(y)
memo[y].append(x)
for i in range(1,n+1):
connect[i] = memo[i]
que = deque(memo[i])
while que:
vtx = que.popleft()
for num in memo[vtx]:
if num not in connect[i]:
que.append(num)
connect[i].append(num)
for i in range(1,n+1):
if ps[i] == i:
continue
else:
pos = ps.index(i)
if pos in connect[i]:
ps[pos] = ps[i]
ps[i] = i
cnt = 0
for i in range(1,n+1):
if ps[i] != i:
cnt += 1
print((n - cnt)) | class UnionFind:
def __init__(self,n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self,x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self,x,y):
return self.find(x) == self.find(y)
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
n,m = list(map(int,input().split()))
ps = list(map(int,input().split()))
uf = UnionFind(n)
for i in range(m):
x,y = list(map(int,input().split()))
uf.union(x,y)
cnt = 0
for i,j in enumerate(ps):
if uf.same_check(i+1 , j):
cnt += 1
print(cnt)
| p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m = list(map(int,input().split()))
pl = list(map(int,input().split()))
uf = UnionFind(n)
for _ in range(m):
x,y = list(map(int,input().split()))
uf.union(x-1,y-1)
ans = 0
for member in list(uf.all_group_members().values()):
a = [pl[i]-1 for i in member]
ans += len(set(a) & set(member))
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m = list(map(int,input().split()))
pl = list(map(int,input().split()))
uf = UnionFind(n)
for _ in range(m):
x,y = list(map(int,input().split()))
uf.union(x-1,y-1)
ans = 0
for idx,p in enumerate(pl):
ans += uf.same(p-1,idx)
print(ans) | p03354 |
N,M=list(map(int,input().split()))
e=[int(x)-1 for x in input().split()]
p=[i for i in range(N)]
r=[0]*N
def find(x):
if p[x]!=x:
p[x]=find(p[x])
return p[x]
def unite(x,y):
x=find(x)
y=find(y)
if x==y:
return
if r[x]<r[y]:
p[x]=y
else:
p[y]=x
if r[x]==r[y]:
r[x]+=1
def same(x,y):
return find(x)==find(y)
for i in range(M):
x,y=list(map(int,input().split()))
unite(x-1,y-1)
l=list()
for i in range(N):
f=False
for j in l:
if j[0]==find(i):
j[1].add(i)
f=True
break
if not f:
l.append([find(i),set([i])])
c=0
for i in l:
for j in i[1]:
if e[j] in i[1]:
c+=1
print(c)
| N,M=list(map(int,input().split()))
e=[int(x)-1 for x in input().split()]
p=[i for i in range(N)]
r=[0]*N
def find(x):
if p[x]!=x:
p[x]=find(p[x])
return p[x]
def unite(x,y):
x=find(x)
y=find(y)
if x==y:
return
if r[x]<r[y]:
p[x]=y
else:
p[y]=x
if r[x]==r[y]:
r[x]+=1
def same(x,y):
return find(x)==find(y)
for i in range(M):
x,y=list(map(int,input().split()))
unite(x-1,y-1)
c=0
for i in range(N):
if same(i,e[i]):
c+=1
print(c)
| p03354 |
N, M = list(map(int,input().split()))
P=list(map(int,input().split()))
Group=[i for i in range(N+1)]
Swap=[None]*M
for i in range(M):
Swap[i]=sorted(map(int,input().split()))
def find(x):
while Group[x] != x:
x=Group[x]
return x
for i in range(M):
if find(Swap[i][1]) != find(Swap[i][0]):
Group[find(Swap[i][1])]=min(find(Swap[i][1]),find(Swap[i][0]))
Group[find(Swap[i][0])]=min(find(Swap[i][1]),find(Swap[i][0]))
Group[Swap[i][1]]=min(find(Swap[i][1]),find(Swap[i][0]))
Group[Swap[i][1]]=min(find(Swap[i][1]),find(Swap[i][0]))
count=0
for i in range(N):
if find(P[i])==find(i+1):
count+=1
print(count)
| N,M = list(map(int,input().split()))
P = list(map(int,input().split()))
S = [list(map(int,input().split())) for i in range(M)]
class Union_find():
def __init__(self, N):
self.Group = [i for i in range(N)]
def find(self,x):# find(a)=find(b)のとき同じグループ
while self.Group[x] != x:
x = self.Group[x]
return x
def Union(self,x,y): # xとyが同じグループになるよう更新
if self.find(x) != self.find(y):
self.Group[self.find(y)] = self.Group[self.find(x)] = min(self.find(y),self.find(x))
A = Union_find(N)
for x,y in S:
A.Union(x-1,y-1)
ANS = 0
for i in range(N):
P[i]-=1
for i in range(N):
if A.find(i) == A.find (P[i]):
ANS += 1
print(ANS) | p03354 |
n, m = list(map(int, input().split()))
p = list([int(x) - 1 for x in input().split()])
xy = [list([int(x) - 1 for x in input().split()]) for _ in range(m)]
par = [i for i in range(n)]
rank = [0 for _ in range(n)]
def root(x):
if par[x] == x:
return par[x]
par[x] = root(par[x])
return par[x]
def is_same(x, y):
return root(x) == root(y)
def union(x, y):
x = root(x)
y = root(y)
if x == y:
return
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[y] == rank[x]:
rank[y] += 1
for x, y in xy:
union(x, y)
count = 0
for i, p_i in enumerate(p):
count += 1 if is_same(i, p_i) else 0
print(count)
| n, m = list(map(int, input().split()))
p = list([int(x) - 1 for x in input().split()])
xy = [list([int(x) - 1 for x in input().split()]) for _ in range(m)]
par = [i for i in range(n)]
rank = [0 for _ in range(n)]
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def is_same(x, y):
return root(x) == root(y)
def union(x, y):
x = root(x)
y = root(y)
if x == y:
return
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[y] == rank[x]:
rank[x] += 1
for x, y in xy:
union(x, y)
count = 0
for i, p_i in enumerate(p):
count += 1 if is_same(i, p_i) else 0
print(count)
| p03354 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
N,M=map(int,input().split())
p=list(map(int1,input().split()))
edge=[[] for _ in range(N)]
for _ in range(M):
x,y=map(int1,input().split())
edge[x].append((0,y))
edge[y].append((0,x))
from heapq import heappop,heappush
def dijkstra(start,n,edges):
d=[INF]*n
used=[False]*n
d[start]=0
used[start]=True
edgelist=[]
for edge in edges[start]:
heappush(edgelist,edge)
while edgelist:
minedge=heappop(edgelist)
if used[minedge[1]]:
continue
v=minedge[1]
d[v]=minedge[0]
used[v]=True
for edge in edges[v]:
if not used[edge[1]]:
heappush(edgelist,(edge[0]+d[v],edge[1]))
return d
ans=0
for i in range(N):
d=dijkstra(i,N,edge)
if d[p[i]]==0:
ans+=1
print(ans)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
N,M=map(int,input().split())
p=list(map(int1,input().split()))
class UnionFind:
def __init__(self,n):
self.par=[i for i in range(n)]
self.siz=[1]*n
def root(self,x):
while self.par[x]!=x:
self.par[x]=self.par[self.par[x]]
x=self.par[x]
return x
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x==y:
return False
if self.siz[x]<self.siz[y]:
x,y=y,x
self.siz[x]+=self.siz[y]
self.par[y]=x
return True
def is_same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return self.siz[self.root(x)]
u=UnionFind(N)
for _ in range(M):
x,y=map(int1,input().split())
u.unite(x,y)
ans=0
for i in range(N):
if u.is_same(i,p[i]):
ans+=1
print(ans)
if __name__ == '__main__':
main()
| p03354 |
#coding:utf-8
n,m = list(map(int,input().split()))
List = list(map(int,input().split()))
forest = [i for i in range(n+1)]
rank = [0 for i in range(n+1)]
def unite(x,y):
while forest[x] != x:
x = forest[x]
a = rank[x]
while forest[y] != y:
y = forest[y]
b = rank[y]
if a <= b:
if a == b:
rank[x] += 1
forest[y] = x
else:
forest[x] = y
def Find(x):
if forest[x] != x:
rank[x] = 1
forest[x] = Find(forest[x])
return forest[x]
else:
return x
for xi in Q:
forest[xi] = x
rank[xi] = 1
return x
cnt = 0
for i in range(m):
x,y = list(map(int,input().split()))
unite(x,y)
for i in range(1,n+1):
x = Find(i)
y = Find(List[i-1])
if x == y:
cnt += 1
print(cnt)
| #coding:utf-8
n,m = list(map(int,input().split()))
List = list(map(int,input().split()))
forest = [i for i in range(n+1)]
rank = [0 for i in range(n+1)]
def unite(x,y):
x = Find(x)
y = Find(y)
a = rank[x]
b = rank[y]
forest[x] = y
def Find(x):
if forest[x] != x:
rank[x] = 1
forest[x] = Find(forest[x])
return forest[x]
else:
return x
for xi in Q:
forest[xi] = x
rank[xi] = 1
return x
cnt = 0
for i in range(m):
x,y = list(map(int,input().split()))
unite(x,y)
for i in range(1,n+1):
x = Find(i)
y = Find(List[i-1])
if x == y:
cnt += 1
print(cnt)
| p03354 |
class UnionFind():
def __init__(self,size):
self.table=[-1for _ in range(size)]
def root(self,x):
while self.table[x]>=0:
x=self.table[x]
return x
def unite(self,x,y):
s1=self.root(x)
s2=self.root(y)
if s1!=s2:
if self.table[s1]!=self.table[s2]:
if self.table[s1]<self.table[s2]:
self.table[s2]=s1
else:
self.table[s1]=s2
else:
self.table[s1]-=1
self.table[s2]=s1
return
def same(self,x,y):
return self.root(x)==self.root(y)
I=lambda:list(map(int,input().split()))
n,m=I()
p=I()
u=UnionFind(n)
for _ in range(m):
a,b=I()
u.unite(a-1,b-1)
print((sum(u.same(i,j-1)for i,j in zip(list(range(n)),p)))) | I=lambda:list(map(int,input().split()));n,m=I();p=I();l=[i for i in range(n+1)]
def u(x):
if l[x]!=x:l[x]=u(l[x])
return l[x]
for _ in[0]*m:x,y=I();l[u(x)]=u(y)
print((sum(u(i)==u(j)for i,j in enumerate(p,1)))) | p03354 |
from copy import deepcopy
n,m = (int(i) for i in input().split())
p = [int(i) for i in input().split()]
x = [[int(i) for i in input().split()] for i in range(m)]
c,d,e = [[] for i in range(n+1)],[True for i in range(n+1)],[]
d[0],ans = False,0
for i,j in x:
c[i].append(j)
c[j].append(i)
while sum(d)!=0:
for i in range(n+1):
if d[i]: break
num2,numx,d[i] = set([i]),[i],False
while True:
num3 = set([])
for i2 in list(num2):
for j in c[i2]:
if d[j]:
num3.add(j)
d[j] = False
if len(num3)==0: break
else:
num2,num3 = deepcopy(num3),set([])
for i in num2: numx.append(i)
e.append(numx)
for i in e:
for j in i:
if p[j-1] in i: ans+=1
print(ans) | n,m = (int(i) for i in input().split())
par,rank = [i for i in range(n+1)],[0 for i in range(n+1)]
def root(x):
if par[x]!=x: par[x] = root(par[x])
return par[x]
def unite(x,y):
x2,y2 = root(x),root(y)
if x2!=y2:
if rank[x2]<rank[y2]: par[x2] = y2
else: par[y2] = x2
if rank[x2]==rank[y2]: rank[x2]+=1
p = [int(i) for i in input().split()]
x = [[int(i) for i in input().split()] for i in range(m)]
for i,j in x: unite(i,j)
ans = -1
for i,j in enumerate([0]+p):
if root(i)==root(j): ans += 1
print(ans) | p03354 |
class UnionFind:
def __init__(self, N):
self.N = N
self.parents = [-1] * N
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def members(self, x):
root = self.find(x)
return [i for i in range(self.N) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
UF = UnionFind(N)
for i in range(N):
P[i] -= 1
for _ in range(M):
x, y = list(map(int, input().split()))
x-=1
y-=1
UF.union(x, y)
print((sum(len(set(mem)&set(P[i] for i in mem)) for _, mem in list(UF.all_group_members().items())))) | class UnionFind:
def __init__(self, N):
self.N = N
self.parents = [-1] * N
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.N) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
N, M = list(map(int, input().split()))
P = list(map(int, input().split()))
UF = UnionFind(N)
for i in range(N):
P[i] -= 1
for _ in range(M):
x, y = list(map(int, input().split()))
x-=1
y-=1
UF.union(x, y)
print((sum(UF.same(i,p) for i,p in enumerate(P)))) | p03354 |
n, m = list(map(int, input().split()))
pp = list(map(int, input().split()))
xyxy = [list(map(int, input().split())) for _ in range(m)]
class UnionFind(list) :
def __init__(self, n) :
super().__init__(list(range(n)))
def find(self, i) :
if self[i] == i : return i
self[i] = self.find(self[i])
return self[i]
def union(self, x, y) :
from copy import copy
x = self.find(x)
y = self.find(y)
self.new = copy(self)
self.new[y] = x
return self.new
def sameroot(self, x, y) :
return self.find(x) == self.find(y)
uf = UnionFind(n)
for x, y in xyxy :
uf = uf.union(x-1, y-1)
for i in range(n) :
uf.find(i)
d = {}
for i, k in enumerate(uf) :
if k not in d :
d[k] = {i}
else :
d[k].add(i)
e = {}
for k, set0 in list(d.items()):
e[k] = set()
for i in set0 :
e[k].add(pp[i]-1)
ans = 0
for k in list(d.keys()) :
set0 = d[k]
set1 = e[k]
ans += len(set0&set1)
print(ans) | n, m = list(map(int, input().split()))
pp = list(map(int, input().split()))
xyxy = [list(map(int, input().split())) for _ in range(m)]
class UnionFind(list) :
def __init__(self, n) :
super().__init__(list(range(n)))
def find(self, i) :
if self[i] == i : return i
self[i] = self.find(self[i])
return self[i]
def union(self, x, y) :
x = self.find(x)
y = self.find(y)
self[y] = x
def sameroot(self, x, y) :
return self.find(x) == self.find(y)
uf = UnionFind(n)
for x, y in xyxy :
uf.union(x-1, y-1)
for i in range(n) :
uf.find(i)
d = {}
for i, k in enumerate(uf) :
if k not in d :
d[k] = {i}
else :
d[k].add(i)
e = {}
for k, set0 in list(d.items()):
e[k] = set()
for i in set0 :
e[k].add(pp[i]-1)
ans = 0
for k in list(d.keys()) :
set0 = d[k]
set1 = e[k]
ans += len(set0&set1)
print(ans) | p03354 |
n,m = list(map(int,input().split()))
p = list(map(int,input().split()))
info = [list(map(int,input().split())) for _ in range(m)]
par =[i for i in range(n+1)]
rank=[0]*(n+1)
# xの根を見つける
def root(x):
if par[x] == x:
return x
else:
par[x] = root(par[x])
return par[x]
# x,yの根が同じかどうかを返す（根が同じ:True、根が異なる:False）
def find(x, y):
return root(x) == root(y)
# xとyの根を結合させる
def union(x, y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
for i in range(m):
union(info[i][0],info[i][1])
ans = 0
for i in range(n):
if find(i+1,p.index(i+1)+1):
ans += 1
print(ans) | n,m = list(map(int,input().split()))
p = list(map(int,input().split()))
info = [list(map(int,input().split())) for _ in range(m)]
par =[i for i in range(n+1)]
rank=[0]*(n+1)
# xの根を見つける
def root(x):
if par[x] == x:
return x
else:
par[x] = root(par[x])
return par[x]
# x,yの根が同じかどうかを返す（根が同じ:True、根が異なる:False）
def find(x, y):
return root(x) == root(y)
# xとyの根を結合させる
def union(x, y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
for i in range(m):
union(info[i][0],info[i][1])
a=[0]*(n+1)
for i in range(n):
a[p[i]]=i+1
ans = 0
for i in range(1,n+1):
if find(i,a[i]):
ans += 1
print(ans) | p03354 |
import sys
n, m = [int(i) for i in input().split(" ")]
p = [0] + [int(i) for i in input().split(" ")]
par = [i for i in range(0, n + 1)]
id_set = [[i] for i in range(0, n + 1)]
p_set = [[p[i]] for i in range(0, n + 1)]
sys.setrecursionlimit(10**6)
def root(x):
if par[x] == x:
return x
else:
r = root(par[x])
par[x] = r
return r
def unite(x, y):
x = root(x)
y = root(y)
if x == y:
return
else:
par[x] = y
id_set[y] = id_set[x] + id_set[y]
p_set[y] = p_set[x] + p_set[y]
for i in range(0, m):
x, y = [int(i) for i in input().split(" ")]
unite(x, y)
s = 0
for i in range(1, n + 1):
if i == root(i):
id_i = sorted(id_set[i])
p_i = sorted(p_set[i])
k = 0
for j in range(0, len(id_i)):
while k < len(p_i) and p_i[k] < id_i[j]:
k += 1
if k >= len(p_i):
break
if p_i[k] == id_i[j]:
s += 1
print(s) | import sys
n, m = [int(i) for i in input().split(" ")]
p = [0] + [int(i) for i in input().split(" ")]
par = [i for i in range(0, n + 1)]
id_set = [[] for i in range(0, n + 1)]
p_set = [[] for i in range(0, n + 1)]
sys.setrecursionlimit(10**6)
def root(x):
if par[x] == x:
return x
else:
r = root(par[x])
par[x] = r
return r
def unite(x, y):
x = root(x)
y = root(y)
if x == y:
return
else:
par[x] = y
for i in range(0, m):
x, y = [int(i) for i in input().split(" ")]
unite(x, y)
for i in range(1, n + 1):
r = root(i)
id_set[r].append(i)
p_set[r].append(p[i])
s = 0
for i in range(1, n + 1):
if i == root(i):
id_i = sorted(id_set[i])
p_i = sorted(p_set[i])
k = 0
for j in range(0, len(id_i)):
while k < len(p_i) and p_i[k] < id_i[j]:
k += 1
if k >= len(p_i):
break
if p_i[k] == id_i[j]:
s += 1
print(s) | p03354 |
n,m=list(map(int,input().split()))
p=list([int(x)-1 for x in input().split()])
l=[list([int(x)-1 for x in input().split()]) for _ in [0]*m]
s=[0]*n
i=1
for x in l:
if s[x[0]]==s[x[1]]==0:
s[x[0]]=i
s[x[1]]=i
i+=1
elif s[x[0]]==s[x[1]]>0:
pass
elif s[x[0]]==0:
s[x[0]]=s[x[1]]
elif s[x[1]]==0:
s[x[1]]=s[x[0]]
else:
t=s[x[1]]
for j in range(n):
if s[j]==t:s[j]=s[x[0]]
list=list(set(s))
ans=0
if 0 in list:
for j in range(n):
if s[j]==0 and p[j]==j:ans+=1
list.remove(0)
for j in list:
ans+=len(set([p[k] for k in range(n) if s[k]==j])&set([k for k in range(n) if s[k]==j]))
print(ans) | n,m=list(map(int,input().split()))
p=list(map(int,input().split()))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
uf=UnionFind(n)
for _ in range(m):
x,y=list(map(int,input().split()))
uf.union(x,y)
ans=0
for i in range(n):
if uf.same_check(i+1,p[i]):ans+=1
print(ans) | p03354 |
n,m = list(map(int,input().split()))
f = lambda x : int(x) - 1
p = list(map(f,input().split()))
par = [i for i in range(n)]
def root(x):
if par[x] == x:
return x
else:
par[x] = root(par[x])
return par[x]
def unite(x,y):
if root(x) == root(y):
return
else:
par[root(x)] = root(y)
for i in range(m):
x,y = list(map(f,input().split()))
unite(x,y)
ans = 0
for i in range(n):
if root(i) == root(p[i]): ans += 1
print(ans) | n,m = list(map(int,input().split()))
f = lambda x : int(x) - 1
p = list(map(f,input().split()))
par = [i for i in range(n)]
def root(x):
if par[x] == x:
return x
else:
par[x] = root(par[x])
return par[x]
def unite(x,y):
rx = root(x)
ry = root(y)
if rx != ry:
par[rx] = ry
for i in range(m):
x,y = list(map(f,input().split()))
unite(x,y)
ans = 0
for i in range(n):
if root(i) == root(p[i]): ans += 1
print(ans)
| p03354 |
class UnionFind():
def __init__(self,n):
self.par=[i for i in range(n)]
def root(self, x):
if self.par[x]==x:
return x
else:
self.par[x]=self.root(self.par[x])
return self.par[x]
def same(self,x,y):
return self.root(x)==self.root(y)
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x!=y:
self.par[x]=y
n, m=list(map(int, input().split()))
p=[int(s)-1 for s in input().split()]
pair=[[int(s)-1 for s in input().split()] for _ in range(m)]
uf=UnionFind(n)
for pi in pair:
uf.unite(pi[0],pi[1])
cnt=0
for i in range(n):
if uf.same(i,p.index(i)):
cnt+=1
print(cnt)
| class UnionFind():
def __init__(self,n):
self.par=[i for i in range(n)]
def root(self, x):
if self.par[x]==x:
return x
else:
self.par[x]=self.root(self.par[x])
return self.par[x]
def same(self,x,y):
return self.root(x)==self.root(y)
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x!=y:
self.par[x]=y
n, m=list(map(int, input().split()))
p=[int(s)-1 for s in input().split()]
pair=[[int(s)-1 for s in input().split()] for _ in range(m)]
uf=UnionFind(n)
for pi in pair:
uf.unite(pi[0],pi[1])
cnt=0
for i, pi in enumerate(p):
if uf.same(i,pi):
cnt+=1
print(cnt)
| p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
uf = UnionFind(n+1)
for x, y in xy:
uf.Unite(p[x-1], p[y-1])
ans = 0
for i in range(n):
if uf.isSameGroup(i+1, p[i]):
ans += 1
print(ans) | import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
N, M = list(map(int, input().split()))
uf = UnionFind(N+1)
p = list(map(int, input().split()))
roots = {i:i for i in range(N)}
proots = {i:i for i in range(N)}
for _ in range(M):
x, y = [int(x)-1 for x in input().split()]
uf.Unite(x, y)
for i in range(N):
r = uf.Find_Root(i)
roots[i] = r
proots[p[i]-1] = r
ans = 0
for i in range(N):
if roots[i] == proots[i]:
ans += 1
print(ans)
| p03354 |
I=lambda:[int(i) for i in input().split()]
n, m = I()
P = I()
D = {i:i for i in range(n+1)}
def U(x):
if D[x] != x:
D[x] = U(D[x])
return D[x]
for _ in range(m):
x, y = I()
D[U(x)] = U(y)
print((sum(U(i)==U(p) for i, p in enumerate(P,1)))) | I=lambda:[int(i)for i in input().split()]
n,m=I()
P=I()
D={i:i for i in range(n+1)}
def U(x):
if D[x]!=x:D[x]=U(D[x])
return D[x]
for _ in [0]*m:
x,y=I();D[U(x)]=U(y)
print((sum(U(i)==U(p)for i,p in enumerate(P,1)))) | p03354 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
n,m = list(map(int, input().split()))
p = list(map(int, input().split()))
adj = [[] for _ in range(n)] #頂点数, 場合によって変える
for _ in range(m):
a,b = list(map(int, input().split()))
adj[a-1].append(b-1)
adj[b-1].append(a-1)
swap = [[] for _ in range(n)]
res = 0
for i in range(n):
if i == p[i]-1:
res += 1
continue
d = deque([i])
visited = [0]*n
visited[i] = 1
while d:
v = d.popleft()
for nv in adj[v]:
if visited[nv] == 0:
if nv == p[i]-1:
res += 1
d.append(nv)
visited[nv] = 1
swap[i].append(nv)
print(res)
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
n,m = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
def same(x,y):
return find(x) == find(y)
par = [-1]*n
for x, y in xy:
if same(x-1, y-1) == False:
unite(x-1, y-1)
res = 0
for i in range(n):
if i == p[i]-1:
res += 1
else:
if same(i, p[i]-1):
res += 1
print(res)
if __name__ == '__main__':
main() | p03354 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
p=list(map(int,input().split()))
uf=UnionFind(n)
for i in range(m):
x,y=list(map(int,input().split()))
uf.union(x-1,y-1)
ans=0
for List in list(uf.all_group_members().values()):
tree=set()
for i in range(len(List)):
tree.add(p[List[i]])
for g in range(len(List)):
if List[g]+1 in tree:
tree.remove(List[g]+1)
ans+=1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
p=list(map(int,input().split()))
uf=UnionFind(n)
for i in range(m):
x,y=list(map(int,input().split()))
uf.union(x-1,y-1)
ans=0
for i in range(n):
if uf.same(i,p[i]-1):
ans+=1
print(ans) | p03354 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.