input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n = int(eval(input()))
l = list(map(int, input().split()))
def is_triangle(a,b,c):
if a < b + c and b < a + c:
return True
else:
return False
l.sort(reverse=True)
ans = 0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if is_triangle(l[i], l[j], l[k]):
ans += 1
else:
break
print(ans) | n = int(eval(input()))
l = list(map(int, input().split()))
l.sort(reverse=True)
ans = 0
#1番長い辺(a)は固定する
for i in range(n - 2):
#2番目に長い辺(b)＝次に長い辺とする
j = i + 1
#3番目の長さの辺(c)＝リストの中で最短の辺からスタート
k = n - 1
while j < k:
#b<a+c,c<a+b は自明。a<b+cを判定する。
#満たす場合、このbにおいて、cまでの全ての要素は条件を満たす(cが小さいほうから攻めているから)
if l[i] < l[j] + l[k]:
ans += k - j
j += 1
#満たさない場合、cを次に長い辺として再度判定。
else:
k -= 1
print(ans) | p02888 |
import sys
readline = sys.stdin.readline
N = int(readline())
L = list(map(int,readline().split()))
L = sorted(L)
# 2本固定すると、もう一本として選べるのは、2本の和より長いものだけ
# これを二分探索で数える
#print(L)
import bisect
ans = 0
for i in range(N - 1):
for j in range(i + 1,N):
limit = L[i] + L[j]
ng = len(L)
ok = j
while abs(ok - ng) > 1:
mid = abs(ok + ng) // 2
if L[mid] < limit:
ok = mid
else:
ng = mid
# print("i",i,"j",j,"L[i]",L[i],"L[j]",L[j],"limit",limit,ok - j)
ans += ok - j
print(ans) | import sys
readline = sys.stdin.readline
N = int(readline())
L = list(map(int,readline().split()))
L = sorted(L)
# 2本固定すると、もう一本として選べるのは、2本の和より長いものだけ
# これを二分探索で数える
#print(L)
import bisect
ans = 0
for i in range(N - 1):
for j in range(i + 1,N):
limit = L[i] + L[j]
ok = bisect.bisect_left(L, limit)
# print("i",i,"j",j,"L[i]",L[i],"L[j]",L[j],"limit",limit,"ok",ok,"ok - j",ok - 1 - j)
ans += ok - 1 - j
print(ans) | p02888 |
# https://atcoder.jp/contests/abc143/tasks/abc143_d
from bisect import bisect_left, bisect_right
import sys
input = sys.stdin.readline
n = int(eval(input())) # 入力が1つ
# map(int, input().split()) # 入力が複数
L = [int(i) for i in input().split()]
L.sort()
pairs = []
for i in range(n):
for j in range(i + 1, n):
pairs.append((i, j))
ans = 0
for i, j in pairs:
p = L[:i] + L[i + 1:j] + L[j + 1:]
a, b = L[i], L[j]
l = bisect_left(p, b - a + 1)
r = bisect_left(p, a)
if l < r:
ans += (r - l)
print(ans) | # https://atcoder.jp/contests/abc143/tasks/abc143_d
from bisect import bisect_left, bisect_right
import sys
input = sys.stdin.readline
n = int(eval(input())) # 入力が1つ
# map(int, input().split()) # 入力が複数
L = [int(i) for i in input().split()]
L.sort()
pairs = []
for i in range(n):
for j in range(i + 1, n):
pairs.append((i, j))
ans = 0
for i, j in pairs:
a, b = L[i], L[j]
ans += bisect_left(L, a + b) - 1 - j
print(ans) | p02888 |
# https://atcoder.jp/contests/abc143/tasks/abc143_d
from bisect import bisect_left, bisect_right
import sys
input = sys.stdin.readline
n = int(eval(input())) # 入力が1つ
# map(int, input().split()) # 入力が複数
L = [int(i) for i in input().split()]
L.sort()
pairs = []
for i in range(n):
for j in range(i + 1, n):
pairs.append((i, j))
ans = 0
for i, j in pairs:
a, b = L[i], L[j]
ans += bisect_left(L, a + b) - 1 - j
print(ans) | # https://atcoder.jp/contests/abc143/tasks/abc143_d
from bisect import bisect_left, bisect_right
import sys
input = sys.stdin.readline
n = int(eval(input())) # 入力が1つ
# map(int, input().split()) # 入力が複数
L = [int(i) for i in input().split()]
L.sort()
ans = 0
for i in range(n):
for j in range(i + 1, n):
a, b = L[i], L[j]
ans += bisect_left(L, a + b) - 1 - j
print(ans) | p02888 |
n = int(eval(input()))
xs = list(map(int, input().split()))
xs = sorted(list(xs))
ts = []
for i in range(n):
for j in range(i+1, n):
ts.append(xs[i] + xs[j])
ts.sort()
i = 0
j = 0
r = 0
xs.append(10**18)
while True:
if j == len(xs) or i == len(ts):
break
if ts[i] <= xs[j]:
i += 1
r += n-j
else:
j += 1
print((n*(n-1)*(n-2)//6-r))
| n = int(eval(input()))
X = list(map(int, input().split()))
X.sort()
k=r=0
for i in range(n):
k = i
for j in range(i+1, n):
while k<n and X[i]+X[j]>X[k]:
k +=1
r += k-j-1
print(r)
| p02888 |
n,*l=list(map(int,open(0).read().split()))
l.sort()
a=0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if l[k]>=l[i]+l[j]:
break
if l[i]<l[j]+l[k] and l[j]<l[k]+l[i] and l[k]<l[i]+l[j]:
a+=1
print(a) | import bisect
n,*l=list(map(int,open(0).read().split()))
l.sort()
a=0
for i in range(n):
for j in range(i+1,n):
k=l[i]+l[j]
a+=max(0,bisect.bisect_left(l,k)-j-1)
print(a) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
from bisect import bisect_left
cnt = 0
for i in range(0, N - 2):
for j in range(i + 1, N - 1):
t = L[i] + L[j]
idx = bisect_left(L, t, lo=j + 1, hi=len(L))
cnt += max(0, idx - j - 1)
print(cnt)
| N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
from bisect import bisect_left
cnt = 0
for i in range(0, N - 2):
for j in range(i + 1, N - 1):
t = L[i] + L[j]
idx = bisect_left(L, t, j + 1, len(L))
cnt += max(0, idx - j - 1)
print(cnt)
| p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
from bisect import bisect_left
cnt = 0
for i in range(0, N - 2):
for j in range(i + 1, N - 1):
t = L[i] + L[j]
idx = bisect_left(L, t, j + 1, len(L))
cnt += max(0, idx - j - 1)
print(cnt)
| N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
from bisect import bisect_left
cnt = 0
for i in range(0,N-2):
for j in range(i+1,N-1):
t = L[i]+L[j]
idx = bisect_left(L,t,lo=j+1)
cnt += max(0,idx-j-1)
print(cnt) | p02888 |
import sys
readline = sys.stdin.readline
N = int(readline())
L = list(map(int, readline().split()))
ans = 0
for i in range(N):
for j in range(N):
if i == j:
continue
for k in range(N):
if i == k or j == k:
continue
if (L[i] < L[j] + L[k]) and (L[j] < L[k] + L[i]) and (L[k] < L[i] + L[j]):
ans += 1
print((ans//6)) | import sys
import bisect
readline = sys.stdin.readline
N = int(readline())
L = list(map(int, readline().split()))
L.sort()
ans = 0
for i in range(N):
for j in range(i, N):
if i == j: continue
ab = L[i] + L[j]
to = bisect.bisect_left(L, ab, j, N)
ans += to - 1 - j
print(ans) | p02888 |
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
N = inputInt()
L = inputList()
ans = 0
for v in itertools.combinations(L, 3):
a,b,c = v
if a < b+c and b < c+a and c < a+b:
ans += 1
print(ans)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# special thanks :
# https://nagiss.hateblo.jp/entry/2019/07/01/185421
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
N = inputInt()
L = inputList()
L.sort()
#print(L)
ans = 0
for a in range(N):
for b in range(a+1,N):
A = L[a]
B = L[b]
tmp = A + B
C_ind = bisect_left(L, tmp)
if C_ind >= N:
ans += N - b - 1
else:
ans += C_ind - b - 1
print(ans)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# special thanks :
# https://nagiss.hateblo.jp/entry/2019/07/01/185421
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
if __name__ == "__main__":
main()
| p02888 |
from itertools import combinations
n = int(eval(input()))
l = list( map(int, input().split()))
ans = 0
l3s = list(combinations(l,3))
for l3 in l3s:
if abs(l3[1] - l3[2]) < l3[0] < (l3[1] + l3[2]):
ans += 1
print(ans) | n = int(eval(input()))
l = list( map(int, input().split()))
ans = 0
lsorted = sorted(l, reverse=True)
for longest in range(len(l)-2):
for second in range(longest+1, len(l)):
for k in range(second+1, len(l)):
if lsorted[longest] - lsorted[second] - lsorted[k] >= 0:
break
else:
ans += 1
print(ans) | p02888 |
from bisect import bisect_left
n = int(eval(input()))
l = list( map(int, input().split()))
ans = 0
l.sort()
for i in range(n-2):
shortest = l[i]
for j in range(i+1, n-1):
second = l[j]
k = bisect_left(l[j+1:], shortest + second)
ans += k
print(ans) | from bisect import bisect_left
n = int(eval(input()))
l = list( map(int, input().split()))
ans = 0
l.sort()
for i in range(n-2):
shortest = l[i]
for j in range(i+1, n-1):
second = l[j]
# このスライスしたやつと地味にTLEになる...
# k = bisect_left(l[j], shortest + second)
# ans += k
k = bisect_left(l, shortest + second)
ans += k - j - 1
print(ans) | p02888 |
import bisect
n = int(eval(input()))
l = sorted(list(map(int, input().split())))
dic = {}
ans = 0
for i in range(n-1):
for j in range(i+1, n):
tmp = l[i] + l[j]
if tmp in list(dic.keys()):
index2 = dic[tmp]
else:
index2 = bisect.bisect_left(l, tmp)
dic[tmp] = index2
if l[j] in list(dic.keys()):
index1 = dic[l[j]]
else:
index1 = bisect.bisect_left(l, l[j])
dic[l[j]] = index1
if l[i] == l[j]:
d = index2 - index1 - 2
else:
d = index2 - index1 - 1
ans += max(d,0)
print(ans) | import bisect as bs
n = int(eval(input()))
l = sorted(list(map(int,input().split())))
count = 0
for i in range(n):
for j in range(i+1,n):
index = bs.bisect_left(l,l[i]+l[j])
count += index - j - 1
print(count) | p02888 |
import itertools,bisect
N =int(eval(input()))
L = list(map(int,input().split()))
L.sort()
def j(a,b,c):
if a<b+c and c<b+a and b<a+c:
return True
else:
return False
cnt = 0
l = list(itertools.combinations(list(range(N)),2))
for i1,i2 in l:
a,b = L[i1],L[i2]
if a == b:
ib = bisect.bisect_right(L, b)
ic = bisect.bisect_right(L, a+b)
else:
ib = bisect.bisect_left(L, b)
ic = bisect.bisect_left(L, a+b)
if ic - ib >=1:
cnt += ic - ib -1
print(cnt) | import bisect
N =int(eval(input()))
L = sorted(list(map(int,input().split())))
cnt = 0
for i in range(N):
for j in range(i+1,N):
cnt += bisect.bisect_left(L,L[i]+L[j]) - (j+1)
print(cnt) | p02888 |
import itertools
n = eval(input())
l = list(map(int,input().split()))
ans = 0
for i in list(itertools.combinations(l,3)):
i = sorted(i)
a,b,c = i[0],i[1],i[2]
if c<a+b:
ans += 1
print(ans) | n = int(eval(input()))
l = list(map(int,input().split()))
l = sorted(l)
ans = 0
for c in range(n):
a=0
b=c-1
while a<b:
if l[a]+l[b]>l[c]:
ans+=b-a
b-=1
else:
a+=1
print(ans) | p02888 |
import itertools
n=int(eval(input()))
l=list(map(int,input().split()))
ans=0
for i in itertools.combinations(l,3):
a,b,c=list(map(int,i))
if a<b+c and b<c+a and c<a+b:
ans+=1
print(ans) | N=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
count=0
import bisect
for i in range(N):
for j in range(i+1,N-1):
m=bisect.bisect_left(l,l[i]+l[j])
count+=m-(j+1)
print(count) | p02888 |
n=int(eval(input()))
l=[0]*n
l[:]=list(map(int,input().split()))
ans=0
m=10**3
l=sorted(l)[::-1]
for i in range(n-2):
m=min(m,l[i])
for j in range(i+1,n-1):
for k in range(j+1,n):
if m<l[j]+l[k]:
ans+=1
else:
break
print(ans) | import bisect
N=int(eval(input()))
L=list(map(int,input().split()))
L=sorted(L)
ans=0
for i in range(N):
for j in range(i+1,N):
k=bisect.bisect_left(L,L[i]+L[j])
ans+=k-j-1
print(ans) | p02888 |
ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n = ni()
l = nl()
l = sorted(l)[::-1]
ans = 0
for a in range(n):
fl = 0
A = l[a]
for b in range(a+1,n):
B = l[b]
if A > B*2:
break
for c in range(b+1,n):
C = l[c]
if A >= B + C:
break
ans += 1
print(ans) | import bisect
ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n = ni()
l = nl()
l = sorted(l)
ans = 0
for a in range(n):
fl = 0
A = l[a]
for b in range(a+1,n):
B = l[b]
idx = bisect.bisect_left(l, A+B)
ans += max(0,idx-b-1)
print(ans) | p02888 |
import bisect
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(N-2):
for j in range(i+1, N-1):
min_sum = L[i]+L[j]
more_than = bisect.bisect_left(L[j+1:], min_sum)
ans += more_than
print(ans) | from bisect import bisect_left
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N):
for j in range(i+1,N):
ans += bisect_left(L, L[i]+L[j])-j-1
print(ans) | p02888 |
import sys
from bisect import bisect_left, bisect_right
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *L = list(map(int, read().split()))
L.sort()
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i + 1 :], i + 1):
k = bisect_left(L, a + b, lo=j + 1)
ans += k - j - 1
print(ans)
return
if __name__ == '__main__':
main()
| import sys
from itertools import accumulate
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, *L = list(map(int, read().split()))
L.sort()
max_L = max(L)
C = [0] * (max_L + 1)
for l in L:
C[l] += 1
C = list(accumulate(C))
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i + 1 :], i + 1):
if a + b > max_L:
ans += N - j - 1
else:
ans += C[a + b - 1] - j - 1
print(ans)
return
if __name__ == '__main__':
main()
| p02888 |
import sys
from itertools import accumulate
read = sys.stdin.buffer.read
def main():
N, *L = list(map(int, read().split()))
L.sort()
max_L = L[-1]
C = [0] * (max_L + 1)
for l in L:
C[l] += 1
C = list(accumulate(C))
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i + 1 :], i + 1):
if a + b > max_L:
ans += N - j - 1
else:
ans += C[a + b - 1] - j - 1
print(ans)
return
if __name__ == '__main__':
main()
| import sys
from itertools import accumulate
read = sys.stdin.buffer.read
def main():
N, *L = list(map(int, read().split()))
L.sort()
max_L = L[-1]
C = [0] * (max_L + 1)
for l in L:
C[l] += 1
C = list(accumulate(C))
ans = 0
for i in range(N):
for j in range(i + 1, N):
if L[i] + L[j] > max_L:
ans += N - j - 1
else:
ans += C[L[i] + L[j] - 1] - j - 1
print(ans)
return
if __name__ == '__main__':
main()
| p02888 |
from itertools import combinations
def main():
N = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
comb = [p for p in combinations(L, 3)]
for a, b, c in comb:
if c < a + b:
ans += 1
print(ans)
if __name__ == "__main__":
main() | from bisect import bisect_left
def main():
N = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(N-2):
a = L[i]
for j in range(i+1, N-1):
k = bisect_left(L[j+1:], a + L[j])
ans += k
print(ans)
if __name__ == "__main__":
main() | p02888 |
import bisect
N=int(input().strip())
L=list(map(int,input().strip().split()))
L.sort()
MAX=L[-1]
count=0
for i in range(N-2):
for j in range(i+1,N-1):
# print(i,j)
# print(L[i+1:-1])
minInd=j+1
# print(minInd)
if L[minInd]> L[i]+L[j]:
continue
if MAX<L[i]+L[j]:
count+=N-1-minInd+1
else:
ind = bisect.bisect_left(L[minInd:], L[i]+L[j]) # number of < a+b
count+=ind
# print(count)
print(count) | import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
c = 0
for i in range(N-2):
for j in range(i+1, N-1):
c += bisect.bisect_right(L, L[i]+L[j]-1) - j - 1
print(c) | p02888 |
from bisect import bisect_left,bisect_right
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
bc=l[i]+l[j]
idx=bisect_left(l,bc)
ans+=idx-j-1
print(ans)
| from bisect import bisect_left,bisect_right
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
ans=0
a=[]
for i in range(n-2):
for j in range(i+1,n-1):
t=l[i]+l[j]
cnt=bisect_left(l,t)
ans+=cnt-j-1
print(ans)
| p02888 |
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
ans=0
from bisect import bisect_left
for i in range(n-2):
for j in range(i+1,n-1):
ab=l[i]+l[j]
idx=bisect_left(l,ab)
ans+=max(idx-j-1,0)
print(ans)
| n=int(eval(input()))
l=list(map(int,input().split()))
from bisect import bisect_left
l.sort()
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
t=l[i]+l[j]
idx=bisect_left(l,t)
ans+=max(idx-j-1,0)
print(ans)
| p02888 |
import bisect
n = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(n - 2):
a = L[i]
for j in range(i + 1, n - 1):
b = L[j]
c_min = b - a
c_max = a + b
if c_max > c_min + 1:
l = L[j+1:]
i_min = bisect.bisect_right(l, c_min)
i_max = bisect.bisect_left(l, c_max)
ans += i_max-i_min
print(ans)
| import bisect
n = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(n):
for j in range(i+1, n):
k = bisect.bisect_left(L, L[i]+L[j])
ans += k-1 - j
print(ans)
| p02888 |
n=int(eval(input()))
a=list(map(int,input().split()))
a.sort()
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
b=a[i]+a[j]
k=j+1
while a[k]<b:
k+=1
if k>=n:
break
ans+=k-j-1
print(ans) | import bisect
n=int(eval(input()))
a=list(map(int,input().split()))
a.sort()
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
ans+=bisect.bisect_left(a,a[i]+a[j])-j-1
print(ans) | p02888 |
import sys
N=int(eval(input()))
L=list(map(int,sys.stdin.readline().split()))
counter=0
L.sort()
for i,A in enumerate(L[:-2]):
for j,B in enumerate(L[i+1:-1],i+1):
l=j
r=len(L)-1
c=(r+l)//2
while abs(r-l)>1:
if A>abs(L[c]-B):
b=c
c=(r+c)//2
l=b
else:
b=c
c=(c+l)//2
r=b
if A-abs(L[l]-B)>0 and A-abs(L[r]-B)>0:
c=r
elif A-abs(L[l]-B)>0 and A-abs(L[r]-B)<0:
c=l
if A>abs(L[c]-B):
counter+=c-j
print(counter)
|
N=int(eval(input()))
L=list(map(int,input().split()))
counter=0
L.sort()
for i in range(N-2):
k=i+2
for j in range(i+1,N-1):
while k < N and L[k] < L[i] + L[j]:
k += 1
counter += k - j -1
print(counter)
| p02888 |
n = int(eval(input()))
nums = list(map(int,input().split(" ")))
nums.sort()
total = 0
for i in range(n):
for j in range(i+1,n):
k = j+1
while k < n and nums[k] < nums[i] + nums[j]:
k+=1
total += k-j -1
print(total) | n = int(eval(input()))
nums = list(map(int,input().split(" ")))
nums.sort()
total = 0
for i in range(n-1,-1,-1):
l = 0
r = i-1
while l < r:
if nums[l] + nums[r] > nums[i]:
total += r - l
r -= 1
else:
l += 1
print(total) | p02888 |
import bisect
def main():
N = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(N):
for j in range(i+1, N):
X = L[i] + L[j]
l = bisect.bisect_left(L, X, lo=j+1)
ans += len(L[j+1:l])
#print(L[j + 1:l])
print(ans)
return 0
if __name__ == '__main__':
main()
| import bisect
def main():
N = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(N):
for j in range(i+1, N):
X = L[i] + L[j]
l = bisect.bisect_left(L, X, lo=j+1)
ans += (l-(j+1))
#print(L[j + 1:l])
print(ans)
return 0
if __name__ == '__main__':
main()
| p02888 |
n = int(eval(input()))
l = sorted([int(x) for x in input().split()])
ret = 0
for i in range(len(l)):
a = l[i]
for j in range(i + 1, len(l)):
b = l[j]
for k in range(j+1, len(l)):
c = l[k]
if c >= a+b:
break
if a<b+c and b<a+c and c<a+b:
ret += 1
print(ret) | n = int(eval(input()))
a = sorted([int(x) for x in input().split()])
ret = 0
for i in range(n-1, 0, -1):
l = 0
r = i-1
while l<r:
if a[l]+a[r]>a[i]:
ret += r - l
r -= 1
else:
l += 1
print(ret) | p02888 |
# D - Triangles
n = (int)(eval(input()))
length = list(map(int, input().split()))
sum = 0
for i in range(n):
for j in range(n):
for k in range(n):
a = length[i]
b = length[j]
c = length[k]
if i >= j or i >= k or j >= k:
continue
if a < b + c and b < c + a and c < a + b:
sum += 1
print(sum) | # D - Triangles
import bisect
n = (int)(eval(input()))
length = list(map(int, input().split()))
sum = 0
length.sort()
for i in range(n):
for j in range(n):
a = length[i]
b = length[j]
if i < j:
k = bisect.bisect_left(length, a + b)
sum += k - j - 1
print((max(0, sum))) | p02888 |
import bisect
N = int(eval(input()))
lst =list(map(int, input().split()))
lst.sort()
ret = 0
for i in range(N):
for j in range(i + 1, N):
n = lst[i] + lst[j]
idx = bisect.bisect_left(lst, n)
ret += max(0, idx - j - 1)
print(ret) | import bisect
N = int(eval(input()))
lst =list(map(int, input().split()))
lst.sort()
ret = 0
for i in range(N):
for j in range(i + 1, N):
n = lst[i] + lst[j]
idx = bisect.bisect_left(lst, n, j + 1, N)
ret += max(0, idx - j - 1)
print(ret) | p02888 |
import itertools
N = int(eval(input()))
L = list(map(int,input().split()))
# N = 2000
# L = list(range(N))
# # 重複を消す
# L = list(set(L))
# N = len(L)
# Lを小さい順にソート
L = sorted(L)
# j=0〜max(L)について，L[i]<jを満たす最大のi: X[j] = i
X = []
for j in range(L[-1]+1):
flag = False
for i in range(N-1,-1,-1):
if L[i] < j:
X.append(i)
flag = True
break
# 見つからなければ
if not flag: X.append(None)
# j=0〜max(L)について，L[i]>jを満たす最小のi: Y[j] = i
Y = []
for j in range(L[-1]+1):
flag = False
for i in range(N):
if L[i] > j:
Y.append(i)
flag = True
break
# 見つからなければ
if not flag: Y.append(None)
#print(L)
ind1 = 0
ind2 = N-1
ans = 0
for i in range(N-2):
a = L[i]
for j in range(i+1,N-1):
b = L[j]
# print(b-a,a+b,Y[b-a],X[a+b])
# cのindexの範囲 = Y[b-a]〜X[a+b]
cmin = Y[b-a]
if a+b <= L[-1]:
cmax = X[a+b]
else:
cmax = N - 1
# cminはjより大きい
if cmin is not None and cmin <= j:
cmin = j + 1
#print(b-a,a+b,cmin,cmax)
# if a == 2 and b == 3:
# print(b-a,a+b,cmin,cmax)
# exit()
# どちらかがNoneなら0
if cmin is not None and cmax is not None and cmin <= cmax:
ans += cmax - cmin + 1
print(ans) | import itertools
import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
# Lを小さい順にソート
L = sorted(L)
# a <= b <= cを仮定してもおｋ
# a,bを全探索し，条件を満たすcの数をO(N)未満の方法で求めればよい
ans = 0
for i in range(N-2):
a = L[i]
for j in range(i+1,N-1):
b = L[j]
# Lの中で条件b-a<cを満たす最小のc
ind_cmin = j+1
# Lの中で条件L[k]<a+bを満たす最大のk = Lの中で昇順ソートを崩さずa+bを挿入できる最小のインデックス-1
# 2分法で探す
ind_cmax = bisect.bisect_left(L,a+b) - 1
ans += ind_cmax - ind_cmin + 1
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort(reverse=True)
ans = 0
for i in range (0,N-2):
max = sum(x >= L[i] / 2 for x in L)
for j in range (i+1,max):
n = sum(x > L[i]-L[j] for x in L[j+1:N])
ans = ans + n
print(ans) | N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
ans = 0
for i in range (N-1,1,-1):
s = 0
l = i - 1
while l > s:
if L[s] + L[l] > L[i]:
ans = ans + (l - s)
l = l - 1
else:
s = s + 1
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int,input().split()))
a = 0
l.sort()
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if l[i] + l[j] > l[k]:
a += 1
print(a) | import bisect
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
for b in range(n):
for a in range(b):
ans += bisect.bisect_left(l,l[a]+l[b])-(b+1)
print(ans) | p02888 |
from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np
# from operator import xor
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
def resolve():
N=int(eval(input()))
L=list(map(int,input().split()))
cnt=0
for i in combinations(L,3):
if sum(i)-2*i[0]>0 and sum(i) - 2 * i[1] > 0 and sum(i)-2*i[2]>0:
cnt+=1
print(cnt)
resolve() | import bisect
# from collections import Counter, deque
# from copy import copy, deepcopy
# from fractions import gcd
# from functools import reduce
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np
# from operator import xor
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
def resolve():
N=int(eval(input()))
L=sorted(list(map(int,input().split())))
cnt=0
for i in range(N-2):
for j in range(i+1,N-1):
val=bisect.bisect_left(L,L[i]+L[j])
cnt+=val-j-1
print(cnt)
resolve() | p02888 |
import itertools
N = int(eval(input()))
L = list(map(int,input().split()))
edge = list(itertools.combinations(L,3))
con = 0
for i in range(0,len(edge)):
edge[i] = list(edge[i])
edge[i].sort(reverse = True)
a = edge[i][0]
b = edge[i][1]
c = edge[i][2]
if a < b + c:
con += 1
print(con) | from bisect import bisect_left
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
con = 0
for i in range(0,N):
for j in range(i + 1,N):
a = L[i]
b = L[j]
#a + bよりでかい最小の数のインデックス
p = bisect_left(L,a + b)
#cとbの間の区間を取る
con += (p - 1) - j
print(con)
| p02888 |
#!/usr/bin/env python3
N = int(eval(input()))
L = sorted([int(s) for s in input().split()])
MAX_SEARCH = max(L) + 1
def check_search(middle, idx_short2, l_lng, l_lows):
return l_lows[middle] + l_lows[idx_short2] > l_lng
l_lows = L[:2]
triangles = 0
for l_lng in L[2:]:
for idx, l_low in enumerate(l_lows):
left = 0
right = len(l_lows) - 1 - idx
end = right
while (left < right):
middle = (left + right) // 2
if check_search(middle, len(l_lows) - 1 - idx, l_lng, l_lows):
right = middle
else:
left = middle + 1
triangles += (end - right)
l_lows.append(l_lng)
print(triangles)
| #!/usr/bin/env python3
N = int(eval(input()))
L = sorted([int(s) for s in input().split()])
def check_search(middle, idx_short2, l_lng, l_lows):
return l_lows[middle] + l_lows[idx_short2] > l_lng
l_lows = L[:2]
triangles = 0
for l_lng in L[2:]:
for idx, l_low in enumerate(l_lows):
left = 0
right = len(l_lows) - 1 - idx
end = right
while (left < right):
middle = (left + right) // 2
if check_search(middle, len(l_lows) - 1 - idx, l_lng, l_lows):
right = middle
else:
left = middle + 1
triangles += (end - right)
l_lows.append(l_lng)
print(triangles) | p02888 |
import itertools
N = int(eval(input()))
l = list(map(int, input().split()))
t = list(itertools.combinations(l, 3))
count = 0
for i in t:
i_s = sorted(i)
a,b,c = i_s
if b <a+c and c<a+b:
count+=1
print(count)
| import bisect
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans =0
for i in range(1,n):
for j in range(i):
p = l[i]+ l[j]
q = bisect.bisect_left(l,p)
ans += q-i-1
print(ans) | p02888 |
n,m=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 i in range(m):
x,y,z=list(map(int,input().split()))
uf.union(x-1,y-1)
print((uf.group_count())) | 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,k=list(map(int,input().split()))
uf=UnionFind(n)
for i in range(k):
a,b,c=list(map(int,input().split()))
uf.union(a-1,b-1)
print((uf.group_count())) | p03045 |
N, M = 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())
uf = UnionFind(N)
for i in range(M):
X, Y, Z = list(map(int, input().split()))
uf.union(X-1, Y-1)
print((len(uf.roots())))
| import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, M = mapint()
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, z = mapint()
uf.union(x-1, y-1)
print((uf.group_count())) | p03045 |
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*n
self.rank = [0]*n
def find(self, x):
if self.root[x-1] < 0:
return x
else:
self.root[x-1] = self.find(self.root[x-1])
return self.root[x-1]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x-1] > self.rank[y-1]:
self.root[x-1] += self.root[y-1]
self.root[y-1] = x
else:
self.root[y-1] += self.root[x-1]
self.root[x-1] = y
if self.rank[x-1] == self.rank[y-1]:
self.rank[y-1] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
def count(self, x):
return -self.root[self.find(x)-1]
N,M=list(map(int,input().split()))
uf=UnionFind(N)
for i in range(M):
x,y,z=list(map(int,input().split()))
uf.unite(x,y)
s=set()
ans=0
for i in range(1,N+1):
if uf.find(i) not in s:
s.add(uf.find(i))
ans+=1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*n
self.rank = [0]*n
def find(self, x):
if self.root[x-1] < 0:
return x
else:
self.root[x-1] = self.find(self.root[x-1])
return self.root[x-1]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x-1] > self.rank[y-1]:
self.root[x-1] += self.root[y-1]
self.root[y-1] = x
self.n-=1
else:
self.n-=1
self.root[y-1] += self.root[x-1]
self.root[x-1] = y
if self.rank[x-1] == self.rank[y-1]:
self.rank[y-1] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
def count(self, x):
return -self.root[self.find(x)-1]
def num(self):
return self.n
N,M=list(map(int,input().split()))
uf=UnionFind(N)
for i in range(M):
x,y,z=list(map(int,input().split()))
uf.unite(x,y)
print((uf.num()))
| p03045 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
root = x
while self.parents[root] != root:
root = self.parents[root]
while self.parents[x] != root:
parent = self.parents[x]
self.parents[x] = root
x = parent
return root
def unite(self, x, y):
xroot = self.find(x)
yroot = self.find(y)
if xroot == yroot:
return
xrank = self.rank[xroot]
yrank = self.rank[yroot]
if xrank < yrank:
self.parents[xroot] = yroot
self.size[yroot] += self.size[xroot]
elif xrank == yrank:
self.parents[yroot] = xroot
self.rank[yroot] += 1
self.size[xroot] += self.size[yroot]
else:
self.parents[yroot] = xroot
self.size[xroot] += self.size[yroot]
def len(self, x):
return self.size[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N)
for _ in range(M):
x, y, z = list(map(int, input().split()))
uf.unite(x - 1, y - 1)
print((len(set([uf.find(i) for i in range(N)])))) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
root = x
while self.parents[root] != root:
root = self.parents[root]
while self.parents[x] != root:
parent = self.parents[x]
self.parents[x] = root
x = parent
return root
def unite(self, x, y):
xroot = self.find(x)
yroot = self.find(y)
if xroot == yroot:
return
xrank = self.rank[xroot]
yrank = self.rank[yroot]
if xrank < yrank:
self.parents[xroot] = yroot
self.size[yroot] += self.size[xroot]
elif xrank == yrank:
self.parents[yroot] = xroot
self.rank[yroot] += 1
self.size[xroot] += self.size[yroot]
else:
self.parents[yroot] = xroot
self.size[xroot] += self.size[yroot]
def len(self, x):
return self.size[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N)
for _ in range(M):
x, y, z = list(map(int, input().split()))
uf.unite(x - 1, y - 1)
print((len([i for i in range(N) if uf.rank[i] == 0]))) | p03045 |
import sys
sys.setrecursionlimit(10 ** 7)
def dfs(s):
if visited[s]:
return
visited[s] = 1
for to in t[s]:
if visited[to]:
continue
dfs(to)
N, M = list(map(int,input().split()))
t = [[] for _ in range(N)]
visited = [0] * N
for _ in range(M):
X, Y, Z = list(map(int,input().split()))
X -= 1
Y -= 1
t[X].append(Y)
t[Y].append(X)
ans = 0
for i in range(0, N):
if visited[i]:
continue
ans += 1
dfs(i)
print(ans) | N, M = list(map(int,input().split()))
t = [[] for _ in range(N)]
visited = [0] * N
for _ in range(M):
X, Y, Z = list(map(int,input().split()))
X -= 1
Y -= 1
t[X].append(Y)
t[Y].append(X)
ans = 0
for i in range(N):
if visited[i]:
continue
ans += 1
stack = [i]
while stack:
s = stack.pop()
for to in t[s]:
if visited[to]:
continue
visited[to] = 1
stack.append(to)
print(ans) | p03045 |
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 = [int(x) for x in input().split()]
XYZ = [[int(x) for x in input().split()] for _ in range(M)]
u = UnionFind(N + 2)
f = True
for x, y, z in XYZ:
x += 1
y += 1
if z % 2 == 0:
u.union(x, y)
else:
if f:
f = False
u.union(x, 0)
u.union(y, 1)
if u.same(x, 0):
u.union(y, 1)
if u.same(x, 1):
u.union(y, 0)
if u.same(y, 0):
u.union(x, 1)
if u.same(y, 1):
u.union(x, 0)
for x, y, z in XYZ:
x += 1
y += 1
if z % 2 == 1:
u.union(x, y)
else:
if f:
f = False
u.union(x, 0)
u.union(y, 1)
if u.same(x, 0):
u.union(y, 1)
if u.same(x, 1):
u.union(y, 0)
if u.same(y, 0):
u.union(x, 1)
if u.same(y, 1):
u.union(x, 0)
print((u.group_count()))
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 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 = [int(x) for x in input().split()]
XYZ = [[int(x) for x in input().split()] for _ in range(M)]
u = UnionFind(N)
for x, y, z in XYZ:
u.union(x - 1, y - 1)
print((u.group_count()))
if __name__ == '__main__':
main()
| p03045 |
import sys
sys.setrecursionlimit(100000)
def visit_tree(now, num):
visited[now] = num
for i in range(len(tree[now])):
if not visited[tree[now][i]]:
visit_tree(tree[now][i], num)
n, m = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for i in range(m):
x, y, z = list(map(int, input().split()))
tree[x - 1].append(y - 1)
tree[y - 1].append(x - 1)
visited = [0 for _ in range(n)]
num = 0
for i in range(n):
if not visited[i]:
num += 1
visit_tree(i, num)
print(num) | import sys
sys.setrecursionlimit(10000000)
def visit_tree(now, num):
visited[now] = num
for i in range(len(tree[now])):
if not visited[tree[now][i]]:
visit_tree(tree[now][i], num)
n, m = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for i in range(m):
x, y, z = list(map(int, input().split()))
tree[x - 1].append(y - 1)
tree[y - 1].append(x - 1)
visited = [0 for _ in range(n)]
num = 0
for i in range(n):
if not visited[i]:
num += 1
visit_tree(i, num)
print(num) | p03045 |
N, M = list(map(int, input().split()))
nodes = [i for i in range(N)]
def root(x):
while nodes[x] != x:
x = nodes[x]
return x
def same(x, y):
return root(x) == root(y)
def unite(x, y):
if not same(x, y):
nodes[root(y)] = root(x)
for _ in range(M):
X, Y, Z = list(map(int, input().split()))
unite(X-1, Y-1)
ans = 0
for i in range(len(nodes)):
if nodes[i] == i:
ans += 1
print(ans)
| N, M = list(map(int, input().split()))
nodes = [i for i in range(N)]
def root(x):
if nodes[x] == x:
return x
else:
nodes[x] = root(nodes[x])
return nodes[x]
def same(x, y):
return root(x) == root(y)
def unite(x, y):
if not same(x, y):
nodes[root(x)] = root(y)
for _ in range(M):
X, Y, Z = list(map(int, input().split()))
unite(X-1, Y-1)
ans = 0
for i in range(len(nodes)):
if nodes[i] == i:
ans += 1
print(ans)
| p03045 |
N,M=list(map(int,input().split()))
class UnionFind():
def __init__(self,n):
self.parent={}
for i in range(n):
self.parent[i]=[i]
def find_parent(self,x):
import sys
parent=self.parent
for key in list(parent.keys()):
if x in parent[key]:
return key
sys.exit()
def union(self,x,y):
parent=self.parent
x_par,y_par=self.find_parent(x),self.find_parent(y)
if x_par==y_par:
pass
else:
if len(parent[x_par])<len(parent[y_par]):
parent[y_par]+=parent[x_par]
parent.pop(x_par)
else:
parent[x_par]+=parent[y_par]
parent.pop(y_par)
self.parent=parent
return None
def same(self,x,y):
if self.find_parent(x)==self.find_parent(y):
return True
else:
return False
def cnt(self):
par=self.parent
return len(set(par))
uf=UnionFind(N)
for i in range(M):
x,y,z=list(map(int,input().split()))
uf.union(x-1,y-1)
print((uf.cnt())) | class UnionFind:
def __init__(self, n):
self.n = n
self.p = [e for e in range(n)]
self.rank = [0] * n
self.size = [1] * n
def same(self, u, v):
return self.find_set(u) == self.find_set(v)
def unite(self, u, v):
u = self.find_set(u)
v = self.find_set(v)
if u == v:
return
if self.rank[u] > self.rank[v]:
self.p[v] = u
self.size[u] += self.size[v]
else:
self.p[u] = v
self.size[v] += self.size[u]
if self.rank[u] == self.rank[v]:
self.rank[v] += 1
def find_set(self, u):
if u != self.p[u]:
self.p[u] = self.find_set(self.p[u])
return self.p[u]
def update_p(self):
for u in range(self.n):
self.find_set(u)
def get_size(self, u):
return self.size[self.find_set(u)]
n, m = list(map(int, input().split()))
xyz = [list(map(int, input().split())) for _ in range(m)]
uf = UnionFind(n)
for x, y, _ in xyz:
x -= 1
y -= 1
uf.unite(x, y)
uf.update_p()
ans = len(set(uf.p))
print(ans) | p03045 |
import queue
import sys
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
XYZ = []
for _ in range(M):
XYZ.append(tuple(map(int, input().split())))
G=[[] for _ in range(N+1)]
for el in XYZ:
G[el[0]].append(el[1])
G[el[1]].append(el[0])
#print(G)
seen=[False]*(N+1)
todo=queue.Queue()
def dfs(n):
seen[n]=True
for nxt in G[n]:
if seen[nxt]==False:
todo.put(nxt)
if todo.empty():
return None
else:
dfs(todo.get())
cnt=0
for check in range(1, N+1):
if seen[check]==False:
cnt+=1
dfs(check)
print(cnt)
| import queue
import sys
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
XYZ = []
for _ in range(M):
XYZ.append(tuple(map(int, input().split())))
G=[[] for _ in range(N+1)]
for el in XYZ:
G[el[0]].append(el[1])
G[el[1]].append(el[0])
#print(G)
seen=[False]*(N+1)
todo=queue.Queue()
def bfs(n):
seen[n]=True
for nxt in G[n]:
if seen[nxt]==False:
bfs(nxt)
cnt=0
for check in range(1, N+1):
if seen[check]==False:
cnt+=1
bfs(check)
print(cnt)
| p03045 |
N,M=list(map(int,input().split()))
root=[-1]*N
def search(i):
if root[i]>=0:
root[i]=search(root[i])
return root[i]
return i
for i in range(M):
x,y,z=list(map(int,input().split()))
x-=1
y-=1
rx=search(x)
ry=search(y)
if rx==ry:
continue
elif root[rx]<=root[ry]:
root[ry]+=root[rx]
root[rx]=ry
else:
root[rx]+=root[ry]
root[ry]=rx
ans=0
for i in range(N):
if root[i]<0:
ans+=1
print(ans)
| N,M=list(map(int,input().split()))
root=[-1]*N
def find(i):
global root
if root[i]>=0:
root[i]=find(root[i])
return root[i]
return i
for i in range(M):
X,Y,Z=list(map(int,input().split()))
rx=find(X-1)
ry=find(Y-1)
if rx==ry:
continue
elif root[rx]<=root[ry]:
root[rx]+=root[ry]
root[ry]=rx
elif root[rx]>root[ry]:
root[ry]+=root[rx]
root[rx]=ry
ans=0
for r in root:
if r<0:
ans+=1
print(ans) | p03045 |
n, m = list(map(int, input().split()))
xy = [i for i in range(n + 1)]
def root(x):
i = x
a = []
while i != xy[i]:
i = xy[i]
a += [i]
for b in a:
xy[b] = i
return i
for _ in range(m):
x, y = list(map(int, input().split()[:2]))
xy[root(x)] = root(y)
ans = sum(i == v for i, v in enumerate(xy)) - 1
print(ans)
| n, m = list(map(int, input().split()))
xy = [i for i in range(n + 1)]
def root(x):
i = x
while i != xy[i]:
i = xy[i]
xy[x] = i
return i
for _ in range(m):
x, y = list(map(int, input().split()[:2]))
xy[root(x)] = root(y)
print((sum(i == v for i, v in enumerate(xy)) - 1))
| p03045 |
#!/usr/bin/env python3
#abc126 e
import sys
sys.setrecursionlimit(100000)
N,M = list(map(int,input().split()))
XYZ = [list(map(int,input().split())) for _ in range(M)]
G = [[] for _ in range(N)]
for i in XYZ:
G[i[0]-1].append(i[1])
G[i[1]-1].append(i[0])
check = [False for _ in range(N)]#各頂点を訪問したかどうか
def DFS(G,s):
check[s-1] = True
for i in G[s-1]:
if not check[i-1]:
DFS(G,i)
ans = 0
for i in range(N):
if not check[i]:
DFS(G,i+1)
ans += 1
print(ans)
| #!/usr/bin/env python3
#abc126 e
import sys
sys.setrecursionlimit(1000000)
N,M = list(map(int,input().split()))
XYZ = [list(map(int,input().split())) for _ in range(M)]
G = [[] for _ in range(N)]
for i in XYZ:
G[i[0]-1].append(i[1])
G[i[1]-1].append(i[0])
check = [False for _ in range(N)]#各頂点を訪問したかどうか
def DFS(G,s):
check[s-1] = True
for i in G[s-1]:
if not check[i-1]:
DFS(G,i)
ans = 0
for i in range(N):
if not check[i]:
DFS(G,i+1)
ans += 1
print(ans)
| p03045 |
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]
def s(self,x,y):return self.f(x)==self.f(y)
def c(self,x):return -self.n[self.f(x)]
n,m=list(map(int,input().split()));u=u(n)
for i in range(m):
a,b,c=list(map(int,input().split()));a-=1;b-=1
if not(u.s(a,b)):n-=1;u.u(a,b)
print(n) | import sys;sys.setrecursionlimit(10**9)
class UnionFind:
def __init__(self,n):
self.n=[-1]*n
self.r=[0]*n
self.siz=n
def find_root(self,x):
if self.n[x]<0:
return x
else:
self.n[x]=self.find_root(self.n[x])
return self.n[x]
def unite(self,x,y):
x=self.find_root(x)
y=self.find_root(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
if self.r[x]==self.r[y]:
self.r[y]+=1
self.siz-=1
def root_same(self,x,y):
return self.find_root(x)==self.find_root(y)
def count(self,x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n,m=list(map(int,input().split()))
uf=UnionFind(n)
for i in range(m):
x,y,z=list(map(int,input().split()))
uf.unite(x-1,y-1)
print((uf.size())) | p03045 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10 ** 6)
def dfs(n):
# print('Search Start: ' + str(n))
if checked[n]:
# print('Checked: ' + str(n))
return
checked[n] = True
for e in edge:
if n in e:
x, y = e
if n != x:
dfs(x)
else:
dfs(y)
# print('Search End: ' + str(n))
N, M = list(map(int, input().split()))
edge = [] * M
checked = [False for _ in range(N)]
con_com = 0
for _ in range(M):
x, y, _ = list(map(int, input().split()))
edge.append([x-1, y-1])
for i in range(N):
if checked[i]:
continue
dfs(i)
# print('--- Connected Components ---')
con_com += 1
print(con_com)
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10 ** 6)
class UnionFind(object):
def __init__(self, n):
self.parent = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
self.components = n
def find(self, x):
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
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
elif self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.parent[y] = x
self.size[x] += self.size[y]
self.components -= 1
def isSame(self, x, y):
return self.find(x) == self.find(y)
def getSize(self, x):
return self.size(self.find(x))
N, M = list(map(int, input().split()))
edge = [] * M
uf = UnionFind(N)
for _ in range(M):
x, y, _ = list(map(int, input().split()))
uf.union(x-1, y-1)
print((uf.components))
| p03045 |
from collections import deque
n, m = list(map(int, input().split()))
xyz = {i:[] for i in range(1, n+1)}
for _ in range(m):
x, y, z = list(map(int, input().split()))
xyz[x].append((x, y, z))
xyz[y].append((y, x, z))
connects = [0]*(n+1)
group = 1
for i in range(1, n+1):
if connects[i] > 0:
continue
if len(xyz[i]) == 0:
connects[i] = group
group += 1
continue
que = deque(xyz[i])
connects[i] = group
while len(que) > 0:
x, y, z = que.popleft()
connects[y] = group
for xn, yn, zn in xyz[y]:
if connects[yn] > 0:
pass
else:
que.append((xn, yn, zn))
group += 1
# print(connects)
print((max(connects)))
| from collections import deque
n, m = list(map(int, input().split()))
xyz = []
for _ in range(m):
x, y, z = list(map(int, input().split()))
xyz.append((x, y, z))
uf = [-1]*(n+1)
def find(i):
if uf[i] < 0:
return i
else:
uf[i] = find(uf[i])
return uf[i]
for x, y, z in xyz:
px, py = find(x), find(y)
if px != py:
px, py = (px, py) if uf[py] < uf[px] else (px, py)
uf[px] += uf[py]
uf[py] = px
# print(uf)
ans = sum([1 for i in range(1, n+1) if uf[i] < 0])
print(ans)
| p03045 |
from collections import deque
n, m = list(map(int, input().split()))
xyz = [[] for i in range(n+1)]
for _ in range(m):
x, y, z = list(map(int, input().split()))
xyz[x].append(y)
xyz[y].append(x)
ans = 0
visited = [False]*(n+1)
for x in range(1, n+1):
if visited[x]:
continue
que = deque(xyz[x])
while len(que) > 0:
y = que.popleft()
visited[y] = True
for yn in xyz[y]:
if not visited[yn]:
que.append(yn)
ans += 1
# print(visited)
print(ans)
| import sys
sys.setrecursionlimit(10**9)
n, m = list(map(int, input().split()))
xyz = [[] for i in range(n+1)]
for _ in range(m):
x, y, z = list(map(int, input().split()))
xyz[x].append(y)
xyz[y].append(x)
ans = 0
visited = [False]*(n+1)
def dfs(x):
visited[x] = True
for y in xyz[x]:
if not visited[y]:
dfs(y)
for x in range(1, n+1):
if visited[x]:
continue
dfs(x)
ans += 1
# print(visited)
print(ans)
| p03045 |
class UnionFind(object):
def __init__(self, N):
self.parent = [-1] * N #parent[i] は(i+1)番目の要素が含まれる要素数の(-1)倍
#要素が負-->その数を親とするグループに属する要素の数×(-1)
#要素が正-->親のindex
#Aがどのグループに属しているかを調べる
def root(self, A):
if self.parent[A-1] < 0: #負の数-->その数は親
return A
self.parent[A-1] = self.root(self.parent[A-1]) #負では無い時、親の場所が入っているから、親が属しているグループを、自分自身に入れる(一度確認したところは直接親を見れるようにする)
return self.parent[A-1] #親の位置を返す
#Aが含まれているグループに属している数を返す
def size(self, A):
return -1 * self.parent[self.root(A)-1]
#AとBをくっ付ける
def connect(self, A, B):
A = self.root(A) #Aを含むグループの親を返す
B = self.root(B) #Bを含むグループの親を返す
if A == B: #親が同じならなにもしない
return False
#大きい方(A)に小さい方(B)をつなぎたい
if self.size(A) < self.size(B): #大小関係が逆の時は入れ替える
A, B = B, A
self.parent[A-1] += self.parent[B-1] #大きい方に小さい方を加える （負の数＋負の数 = 新しいグループに含まれる数×(-1)）
self.parent[B-1] = A #加えられた親の値を、加えた先の親の位置に書き変える
return True
def same(self, A, B):
if self.root(A) == self.root(B):
return True
else:
return False
# N, Q = map(int, input().split())
# uni = UnionFind(N)
# for _ in range(Q):
# P, A, B = map(int, input().split())
# if P == 1:
# if uni.root(A) == uni.root(B): #親が同じかどうか
# print ('Yes')
# else:
# print ('No')
# else:
# uni.connect(A, B)
N, M = list(map(int, input().split()))
uni = UnionFind(N)
ans = N
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
if uni.root(x) == uni.root(y): #親が同じ時
pass
else:
ans -= 1
uni.connect(x, y)
print (ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7
N, M = list(map(int, input().split()))
class UnionFind(object):
def __init__(self, N):
self.parent = [-1] * N #parent[i] は(i+1)番目の要素が含まれる要素数の(-1)倍
#要素が負-->その数を親とするグループに属する要素の数×(-1)
#要素が正-->親のindex
#Aがどのグループに属しているかを調べる
def root(self, A):
if self.parent[A-1] < 0: #負の数-->その数は親
return A
self.parent[A-1] = self.root(self.parent[A-1]) #負では無い時、親の場所が入っているから、親が属しているグループを、自分自身に入れる(一度確認したところは直接親を見れるようにする)
return self.parent[A-1] #親の位置を返す
#Aが含まれているグループに属している数を返す
def size(self, A):
return -1 * self.parent[self.root(A)-1]
#AとBをくっ付ける
def connect(self, A, B):
A = self.root(A) #Aを含むグループの親を返す
B = self.root(B) #Bを含むグループの親を返す
if A == B: #親が同じならなにもしない
return False
#大きい方(A)に小さい方(B)をつなぎたい
if self.size(A) < self.size(B): #大小関係が逆の時は入れ替える
A, B = B, A
self.parent[A-1] += self.parent[B-1] #大きい方に小さい方を加える （負の数＋負の数 = 新しいグループに含まれる数×(-1)）
self.parent[B-1] = A #加えられた親の値を、加えた先の親の位置に書き変える
return True
def same(self, A, B):
if self.root(A) == self.root(B):
return True
else:
return False
ans = N
uni = UnionFind(N + 1)
for _ in range(M):
x, y, z = list(map(int, input().split()))
if uni.same(x, y):
continue
uni.connect(x, y)
ans -= 1
print (ans) | p03045 |
N, M = list(map(int, input().split()))
G = [set([n]) for n in range(N)]
for m in range(M):
X, Y, Z = list(map(int, input().split()))
X -= 1
Y -= 1
Gx = G[X]
Gy = G[Y]
Gxy = Gx | Gy
for idx in Gxy:
G[idx] = Gxy
print((len(set([tuple(g) for g in G]))))
| class UnionFind:
def __init__(self, n):
self.depth = [0] * n
self.parent = list(range(n))
def find(self, x):
if x == self.parent[x]:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.depth[x] < self.depth[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.depth[x] == self.depth[y]:
self.depth[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.depth[self.ind(x)]
N, M = list(map(int, input().split()))
T = UnionFind(N)
for m in range(M):
X, Y, Z = list(map(int, input().split()))
T.unite(X-1, Y-1)
print((sum([1 for i in range(N) if T.find(i) == i])))
| p03045 |
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
#Union Find
par = [] #親
rank = [] #木の深さ
#初期化
for i in range(n):
#par[i]:i rank[i]:0
par.append(i)
rank.append(0)
#木の根を求める
def find(x,par):
if par[x] == x:
return x
else:
return find(par[x],par)
#xとyの属する集合の併合
def unite(x,y,par,rank):
x = find(x,par)
y = find(y,par)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y,par):
return find(x,par) == find(y,par)
for i in range(m):
X,Y,Z = list(map(int,input().split()))
unite(X-1,Y-1,par,rank)
tank = []
for i in range(n):
p = find(i,par)
tank.append(p)
print((len(set(tank)))) | #Union Find
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
par = [i for i in range(n)] #親
rank = [0]*n #木の深さ
#木の根を求める
def find(x,par):
if par[x] == x:
return x
else:
par[x] = par[par[x]]
return find(par[x],par)
#xとyの属する集合の併合
def unite(x,y,par,rank):
x = find(x,par)
y = find(y,par)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y,par):
return find(x,par) == find(y,par)
for i in range(m):
X,Y,Z = list(map(int,input().split()))
unite(X-1,Y-1,par,rank)
tank = set([])
for i in range(n):
p = find(i,par)
tank.add(p)
print((len(tank))) | p03045 |
#Union Find
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
#根なら-size,子なら親の頂点
par = [-1]*n
#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:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
for i in range(m):
X,Y,Z = list(map(int,input().split()))
unite(X-1,Y-1)
tank = set([])
for i in range(n):
p = find(i)
tank.add(p)
print((len(tank))) | def main():
import sys
input = sys.stdin.readline
#Union Find
#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)]
n,m = list(map(int,input().split()))
#初期化
#根なら-size,子なら親の頂点
par = [-1]*n
for i in range(m):
X,Y,Z = list(map(int,input().split()))
unite(X-1,Y-1)
tank = set([])
for i in range(n):
tank.add(find(i))
print((len(tank)))
if __name__ == '__main__':
main() | p03045 |
# Union-Findデータ構造
class UnionFind:
def __init__(self, numV):
self.pars = list(range(numV))
self.ranks = [0] * numV
def find(self, x):
if self.pars[x] == x: return x
else:
self.pars[x] = self.find(self.pars[x])
return self.pars[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x == y: return
if self.ranks[x] < self.ranks[y]:
self.pars[x] = y
else:
self.pars[y] = x
if self.ranks[x] == self.ranks[y]:
self.ranks[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
N, M = list(map(int, input().split()))
UF = UnionFind(N)
for _ in range(M):
X, Y, Z = list(map(int, input().split()))
UF.union(X-1, Y-1)
for i in range(N):
UF.find(i)
parents = UF.pars
print((len(set(parents))))
| class UnionFind:
def __init__(self, numV):
self.pars = list(range(numV))
self.ranks = [0] * numV
def getRoot(self, x):
par = self.pars[x]
if par != x:
self.pars[x] = par = self.getRoot(par)
return par
def merge(self, x, y):
x, y = self.getRoot(x), self.getRoot(y)
if x == y: return
if self.ranks[x] < self.ranks[y]:
self.pars[x] = y
else:
self.pars[y] = x
if self.ranks[x] == self.ranks[y]:
self.ranks[x] += 1
def isSame(self, x, y):
return self.getRoot(x) == self.getRoot(y)
def updatePars(self):
for v in range(len(self.pars)):
self.getRoot(v)
N, M = list(map(int, input().split()))
UF = UnionFind(N)
for _ in range(M):
x, y, z = list(map(int, input().split()))
x, y = x-1, y-1
UF.merge(x, y)
UF.updatePars()
ans = len(set(UF.pars))
print(ans)
| p03045 |
from queue import Queue
N, M = list(map(int, input().split()))
d = {}
for i in range(1, N+1):
d[i] = []
for i in range(M):
x, y, z = list(map(int, input().split()))
d[x].append(y)
d[y].append(x)
isChecked = [False for i in range(N)]
ans = 0
for k in d:
if isChecked[k-1]:
continue
ans += 1
q = Queue()
q.put(k)
while not q.empty():
v = q.get()
if isChecked[v-1]:
continue
isChecked[v-1] = True
for u in d[v]:
q.put(u)
print(ans)
| class UnionFindTree:
_node_num = 0
_parent_list = []
_tree_len = []
_num_trees = 0
def __init__(self, node_num):
self._node_num = node_num
self._parent_list = [-1 for i in range(node_num+1)]
self._tree_len = [0 for i in range(node_num+1)]
self._num_trees = node_num
def _root(self, node):
root = node
while self._parent_list[root] != -1:
root = self._parent_list[root]
return root
def union(self, x, y):
xr = self._root(x)
yr = self._root(y)
if xr == yr:
return
if self._tree_len[xr] < self._tree_len[yr]:
self._parent_list[xr] = yr
self._tree_len[yr] += 1
else:
self._parent_list[yr] = xr
self._tree_len[xr] += 1
self._num_trees -= 1
def get_num_trees(self):
return self._num_trees
def main():
N, M = list(map(int, input().split()))
uft = UnionFindTree(N)
for i in range(M):
x, y, z = list(map(int, input().split()))
uft.union(x, y)
print((uft.get_num_trees()))
if __name__ == '__main__':
main()
| p03045 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, XYZ):
g = defaultdict(dict)
for x, y, z in XYZ:
g[x][y] = z % 2
g[y][x] = z % 2
ans = 0
done = set()
for i in range(1, N+1):
if i in done:
continue
ans += 1
q = deque([i])
while q:
u = q.popleft()
done.add(u)
for v in g[u]:
if v not in done:
q.append(v)
return ans
def main():
# N = read_int()
N, M = read_int_n()
XYZ = [read_int_n() for _ in range(M)]
print(slv(N, M, XYZ))
# N = 10**5
# XYZ = [random.randint()]
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, XYZ):
g = defaultdict(dict)
for x, y, z in XYZ:
g[x][y] = z % 2
g[y][x] = z % 2
ans = 0
done = set()
for i in range(1, N+1):
if i in done:
continue
ans += 1
q = deque([i])
while q:
u = q.popleft()
done.add(u)
for v in g[u]:
if v not in done:
q.append(v)
done.add(v)
return ans
def main():
# N = read_int()
N, M = read_int_n()
XYZ = [read_int_n() for _ in range(M)]
print(slv(N, M, XYZ))
# N = 10**5
# XYZ = [random.randint()]
if __name__ == '__main__':
main()
| p03045 |
# Union Find 木
from sys import setrecursionlimit
def find(parent, i):
t = parent[i]
if t < 0:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[j] += parent[i]
parent[i] = j
setrecursionlimit(10 ** 5)
N, M = list(map(int, input().split()))
parent = [-1] * N
for _ in range(M):
X, Y, Z = list(map(int, input().split()))
unite(parent, X - 1, Y - 1)
print((len([x for x in parent if x < 0])))
| # Union Find 木
from sys import setrecursionlimit
def find(parent, i):
t = parent[i]
if t < 0:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[j] += parent[i]
parent[i] = j
setrecursionlimit(10 ** 6)
N, M = list(map(int, input().split()))
parent = [-1] * N
for _ in range(M):
X, Y, Z = list(map(int, input().split()))
unite(parent, X - 1, Y - 1)
print((len([x for x in parent if x < 0])))
| p03045 |
n,m=list(map(int,input().split()))
#Union-Find
par=[-1 for i in range(n)]
def root(a):
if par[a]<0:
return a
else:
return root(par[a])
def size(a):
return -par[root(a)]
def connect(a,b):
a=root(a)
b=root(b)
if a==b:
return False
if size(a)<size(b):
a,b=b,a
par[a]+=par[b]
par[b]=a
return True
xyz=[]
for i in range(m):
a=[int(j) for j in input().split()]
xyz.append([a[0]-1,a[1]-1,a[2]%2])
if root(a[0]-1)!=root(a[1]-1):
connect(a[0]-1,a[1]-1)
ans=0
for i in range(n):
ans+=1/size(i)
print((round(ans))) | n,m=list(map(int,input().split()))
#Union-Find
par=[-1 for i in range(n)]
def root(a):
if par[a]<0:
return a
else:
return root(par[a])
def size(a):
return -par[root(a)]
def connect(a,b):
a=root(a)
b=root(b)
if a==b:
return False
if size(a)<size(b):
a,b=b,a
par[a]+=par[b]
par[b]=a
return True
xyz=[]
for i in range(m):
a=[int(j) for j in input().split()]
xyz.append([a[0]-1,a[1]-1,a[2]%2])
if root(a[0]-1)!=root(a[1]-1):
connect(a[0]-1,a[1]-1)
ans=0
for i in range(n):
if par[i]<0:
ans+=1
print(ans) | p03045 |
n,m=list(map(int,input().split()))
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
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
if self.rnk[x]==self.rnk[y]:
self.rnk[y]+=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def Count(self,x):
return -self.root[self.Find_Root(x)]
uf=UnionFind(n)
for _ in range(m):
x,y,z=list(map(int,input().split()))
uf.Unite(x,y)
ans=set()
for i in range(1,n+1):
ans.add(uf.Find_Root(i))
print((len(ans)))
| n,m=list(map(int,input().split()))
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
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
if self.rnk[x]==self.rnk[y]:
self.rnk[y]+=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def Count(self,x):
return -self.root[self.Find_Root(x)]
uf=UnionFind(n)
for _ in range(m):
x,y,z=list(map(int,input().split()))
x-=1
y-=1
uf.Unite(x,y)
r=[0]*n
for i in range(n):
r[i]=uf.Find_Root(i)
s=set(r)
print((len(s)))
| p03045 |
# https://atcoder.jp/contests/abc126/tasks/abc126_e
import itertools
from collections import Counter
from collections import defaultdict
import bisect
# Union find
class UnionFind():
def __init__(self,size):
self.table = [-1 for _ in range(size)] # 負の値の場合根を表す。正の値は次の要素を返す、根まで続く
#集合の代表を求める
def find(self,x):
while self.table[x] >= 0:
#根に来た時,self.table[根のindex]は負の値なのでx = 根のindexで値が返される。
x = self.table[x]
return x
def is_same(self, x, y):
return self.find(x) == self.find(y)
#併合
def union(self,x,y):
s1 = self.find(x)#根のindex,table[s1]がグラフの高さ
s2 = self.find(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:
#グラフの長さが同じ場合,どちらを根にしても変わらない
#その際,グラフが1長くなることを考慮する
#self.table[s1] += -1
self.table[s2] = s1
return
def num_group(self):
# print(self.table)
return self.table.count(-1)
def main():
N, M = list(map(int, input().split()))
uf = UnionFind(N)
for _ in range(M):
x, y, z = list(map(int, input().split()))
uf.union(x - 1, y - 1)
print((uf.num_group()))
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/abc126/tasks/abc126_e
import itertools
from collections import Counter
from collections import defaultdict
import bisect
# Union find
class UnionFind():
def __init__(self,size):
self.table = [-1 for _ in range(size)] # 負の値の場合根を表す。正の値は次の要素を返す、根まで続く
#集合の代表を求める
def find(self,x):
while self.table[x] >= 0:
#根に来た時,self.table[根のindex]は負の値なのでx = 根のindexで値が返される。
x = self.table[x]
return x
def is_same(self, x, y):
return self.find(x) == self.find(y)
def rewrite(self,x, p):
while self.table[x] >= 0:
#根に来た時,self.table[根のindex]は負の値なのでx = 根のindexで値が返される。
tmp = x
x = self.table[x]
self.table[tmp] = p
return
#併合
def union(self,x,y):
s1 = self.find(x)#根のindex,table[s1]がグラフの高さ
s2 = self.find(y)
if s1 != s2:#根が異なる場合
if self.table[s1] != self.table[s2]:#グラフの高さが異なる場合
if self.table[s1] < self.table[s2]:
self.table[s2] = s1
self.rewrite(y, s1)
else:
self.table[s1] = s2
self.rewrite(x, s2)
else:
#グラフの長さが同じ場合,どちらを根にしても変わらない
self.table[s2] = s1
self.rewrite(y, s1)
return
def num_group(self):
# print(self.table)
return self.table.count(-1)
def main():
N, M = list(map(int, input().split()))
uf = UnionFind(N)
for _ in range(M):
x, y, z = list(map(int, input().split()))
uf.union(x - 1, y - 1)
print((uf.num_group()))
if __name__ == '__main__':
main()
| p03045 |
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root # 同じnodeへの2回目以降のget_rootを高速にするために、直接rootに繋いでおく
return root
def in_same_group(self, node1, node2):
root1 = self.get_root(node1)
root2 = self.get_root(node2)
return root1 == root2
def unite(self, node1, node2):
if self.in_same_group(node1, node2):
return
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if self.rank[main_root] < self.rank[sub_root]: # rankの大きい方をmain_rootにする
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((uf.groups))
| import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root # 同じnodeへの2回目以降のget_rootを高速にするために、直接rootに繋いでおく
return root
def unite(self, node1, node2):
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if main_root == sub_root:
return
if self.rank[main_root] < self.rank[sub_root]: # rankの大きい方をmain_rootにする
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((uf.groups))
| p03045 |
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root # 同じnodeへの2回目以降のget_rootを高速にするために、直接rootに繋いでおく
return root
def unite(self, node1, node2):
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if main_root == sub_root:
return
if self.rank[main_root] < self.rank[sub_root]: # rankの大きい方をmain_rootにする
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((uf.groups))
| class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root
return root
def unite(self, node1, node2):
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if main_root == sub_root:
return
if self.rank[main_root] < self.rank[sub_root]:
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m, *t = list(map(int,open(0).read().split()))
uf = UnionFind(n)
X = t[::3]
Y = t[1::3]
for x, y in zip(X, Y):
uf.unite(x-1, y-1)
print((uf.groups)) | p03045 |
#!/usr/bin/env python3
import sys
class UnionFind:
def __init__(self, n):
# par = Parent Number or NoV
self.par = [-1 for i in range(n+1)]
# rank = Tree Height
self.rank = [0] * (n+1)
# 自分が所属する集合の数を返す
def size(self, x):
return -self.find(self.par[x])
# 連結成分
def num_graph(self):
return len([i for i in self.par[1:] if i < 0])
# 根なら番号を返す
def find(self, x):
if(self.par[x] < 0):
return x
else:
self.par[x] = self.find(self.par[x])
return self.find(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):
return False
# つなぎ替える
if(self.size(x) < self.size(y)):
x,y = y,x
# xのサイズを更新
self.par[x] += self.par[y]
# yのサイズ(おやばんごう)をxに
self.par[y] = x
return True
def solve(N: int, M: int, X: "List[int]", Y: "List[int]", Z: "List[int]"):
uf = UnionFind(N)
for i in range(M):
uf.union(X[i],Y[i])
print((uf.num_graph()))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
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
X = [int()] * (M) # type: "List[int]"
Y = [int()] * (M) # type: "List[int]"
Z = [int()] * (M) # type: "List[int]"
for i in range(M):
X[i] = int(next(tokens))
Y[i] = int(next(tokens))
Z[i] = int(next(tokens))
solve(N, M, X, Y, Z)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
INF = 1<<32
class UnionFind:
def __init__(self, n):
# par = Parent Number or NoV
self.par = [-1] * (n+1)
# rank = Tree Height
self.rank = [0] * (n+1)
# 自分が所属する集合の数を返す
def size(self, x):
return -1*self.par[self.find(x)]
def size_list(self):
return [x*(-1) for x in self.par[1:] if x < 0]
# 根なら番号を返す
def find(self, x):
if(self.par[x] < 1):
return x
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):
return False
# つなぎ替える
if(self.size(x) < self.size(y)):
x,y = y,x
# xのサイズを更新
self.par[x] += self.par[y]
# yのサイズ(おやばんごう)をxに
self.par[y] = x
return True
def root_nodes(self):
# print([i for i in self.par[1:]])
return len([i for i in self.par[1:] if i <= -1])
def solve(N: int, M: int, X: "List[int]", Y: "List[int]", Z: "List[int]"):
uf = UnionFind(N)
for i in range(M):
uf.union(X[i], Y[i])
print((uf.root_nodes()))
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
X = [int()] * (M) # type: "List[int]"
Y = [int()] * (M) # type: "List[int]"
Z = [int()] * (M) # type: "List[int]"
for i in range(M):
X[i] = int(next(tokens))
Y[i] = int(next(tokens))
Z[i] = int(next(tokens))
solve(N, M, X, Y, Z)
if __name__ == '__main__':
main()
| p03045 |
class UnionFind :
def __init__(self, size) :
self.parent = list(range(size))
self.height = [0] * size
self.size = [1] * size
self.component = size
def root(self, index) :
if self.parent[index] == index : # 根の場合
return index
rootIndex = self.root(self.parent[index]) # 葉の場合親の根を取得
self.parent[index] = rootIndex # 親の付け直し
return rootIndex
def union(self, index1, index2) : # 結合
root1 = self.root(index1)
root2 = self.root(index2)
if root1 == root2 : # 連結されている場合
return
self.component -= 1 # 連結成分を減らす
if self.height[root1] < self.height[root2] :
self.parent[root1] = root2 # root2に結合
self.size[root2] += self.size[root1]
else :
self.parent[root2] = root1 # root1に結合
self.size[root1] += self.size[root2]
if self.height[root1] == self.height[root2] :
self.height[root1] += 1
return
def isSameRoot(self, index1, index2) :
return self.root(index1) == self.root(index2)
def sizeOfSameRoot(self, index) :
return self.size[self.root(index)]
def getComponent(self) :
return self.component
N, M = list(map(int, input().split()))
tree = UnionFind(N)
for _ in range(M):
fr, to, _ = list(map(int, input().split()))
tree.union(fr - 1, to - 1)
print((tree.getComponent()))
| class UnionFind:
def __init__(self, size):
self.parent = list(range(size))
self.height = [0] * size
self.size = [1] * size
self.componentCount = size
def root(self, index):
if self.parent[index] == index: # 根の場合
return index
rootIndex = self.root(self.parent[index]) # 葉の場合親の根を取得
self.parent[index] = rootIndex # 親の付け直し
return rootIndex
def union(self, index1, index2): # 結合
root1 = self.root(index1)
root2 = self.root(index2)
if root1 == root2: # 連結されている場合
return
self.componentCount -= 1 # 連結成分を減らす
if self.height[root1] < self.height[root2]:
self.parent[root1] = root2 # root2に結合
self.size[root2] += self.size[root1]
else:
self.parent[root2] = root1 # root1に結合
self.size[root1] += self.size[root2]
if self.height[root1] == self.height[root2]:
self.height[root1] += 1
return
def isSameRoot(self, index1, index2):
return self.root(index1) == self.root(index2)
def sizeOfSameRoot(self, index):
return self.size[self.root(index)]
N, M = list(map(int, input().split()))
tree = UnionFind(N)
for _ in range(M):
a, b, c = list(map(int, input().split()))
tree.union(a - 1, b - 1)
print((tree.componentCount))
| p03045 |
import sys
sys.setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
paths = [[] for _ in range(N)]
for _ in range(M):
a, b, z = list(map(int, input().split()))
paths[a-1].append(b-1)
paths[b-1].append(a-1)
visited = [False] * N
def dfs(node, prev):
if visited[node]:
return
visited[node] = True
for n in paths[node]:
if n != prev:
dfs(n, node)
count = 0
for i in range(N):
if visited[i] == False:
count += 1
dfs(i,-1)
print(count)
| import sys
sys.setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
class Union_Find:
def __init__(self,n):
self.parent = [i for i in range(n)]
self.rank = [1 for i in range(n)]
def find(self,x):
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def unite(self, x, y):
px = self.find(x)
py = self.find(y)
if px == py:
return
else:
if self.rank[px] == self.rank[py]:
self.parent[py] = px
self.rank[px] += 1
elif self.rank[px] > self.rank[py]:
self.parent[py] = px
else:
self.parent[px] = py
uftree = Union_Find(N+1)
for i in range(M):
x, y, _ = list(map(int, input().split()))
uftree.unite(x, y)
result = 0
for i in range(1, N+1):
if uftree.find(i) == i:
result += 1
print(result)
| p03045 |
n, m = list(map(int, input().split()))
tree = [-i for i in range(n+1)]
rank = [1 for _i in range(n+1)]
def search_root(num, tree=tree):
if tree[num] < 0:
return num
else:
tree[num] = search_root(tree[num])
return tree[num]
for _i in range(m):
x, y, z = list(map(int, input().split()))
x, y = [search_root(x), search_root(y)]
if x==y:
continue
else:
if rank[x]<rank[y]:
rank[y] += 1
tree[x] = y
else:
rank[x] += 1
tree[y] = x
print((sum(1 for i in tree if i<0))) | n, m = list(map(int, input().split()))
tree = [-i for i in range(n+1)]
def search_root(num, tree=tree):
if tree[num] < 0:
return num
else:
tree[num] = search_root(tree[num])
return tree[num]
for _i in range(m):
x, y, z = list(map(int, input().split()))
x, y = [search_root(x), search_root(y)]
if x==y:
continue
else:
tree[x] = y
print((sum(1 for i in tree if i<0))) | p03045 |
n, m = list(map(int, input().split()))
tree = [-i for i in range(n+1)]
for _i in range(m):
x, y, z = list(map(int, input().split()))
while tree[x]>0:
x = tree[x]
while tree[y]>0:
y = tree[y]
if x==y:
continue
else:
tree[x] = y
print((sum(1 for i in tree if i<0))) | n, m = list(map(int, input().split()))
tree = [-i for i in range(n+1)]
for _i in range(m):
x, y, z = list(map(int, input().split()))
while tree[x]>0:
x = tree[x]
while tree[y]>0:
y = tree[y]
x, y = sorted([x, y])
if x==y:
continue
else:
tree[y] = x
print((sum(1 for i in tree if i<0))) | p03045 |
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()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x-1, y-1)
print((len(set(uf.find(i) for i in range(n))))) | 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()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x-1, y-1)
print((sum(uf.par[i] == i for i in range(n)))) | p03045 |
class Node:
def __init__(self, val):
self.num = val
self.val = val
self.is_parent = True
self.parent = None
self.childs = []
def show(self):
print(self.num, end=" ")
print(self.is_parent, end=" ")
for child in self.childs:
print(child.num, end=" ")
def root(node):
while node.parent != None:
node = node.parent
return node
N, M = map(int, input().split())
roots = [Node(i) for i in range(N)]
count = N
for i in range(M):
x, y, z = map(int, input().split())
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
x.childs.append(y)
else:
root_x = root(x)
root_y = root(y)
if root_x != root_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
root_x.childs.append(root_y)
print(count)
| class Node:
def __init__(self, val):
self.num = val
self.val = val
self.is_parent = True
self.parent = None
self.childs = []
def show(self):
print(self.num, end=" ")
print(self.is_parent, end=" ")
for child in self.childs:
print(child.num, end=" ")
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = map(int, input().split())
roots = [Node(i) for i in range(N)]
count = N
for i in range(M):
x, y, z = map(int, input().split())
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
x.childs.append(y)
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
root_x.childs.append(root_y)
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
root_y.childs.append(root_x)
print(count)
| p03045 |
class Node:
def __init__(self, val):
self.num = val
self.val = val
self.is_parent = True
self.parent = None
self.childs = []
def show(self):
print(self.num, end=" ")
print(self.is_parent, end=" ")
for child in self.childs:
print(child.num, end=" ")
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = map(int, input().split())
roots = [Node(i) for i in range(N)]
count = N
for i in range(M):
x, y, z = map(int, input().split())
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
x.childs.append(y)
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
root_x.childs.append(root_y)
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
root_y.childs.append(root_x)
print(count)
| class Node:
def __init__(self, val):
self.num = val
self.val = val
self.is_parent = True
self.parent = None
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = list(map(int, input().split()))
roots = [Node(i) for i in range(N)]
count = N
for i in range(M):
x, y, z = list(map(int, input().split()))
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
print(count)
| p03045 |
class Node:
def __init__(self, val):
self.num = val
self.val = val
self.is_parent = True
self.parent = None
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = list(map(int, input().split()))
roots = [Node(i) for i in range(N)]
count = N
for i in range(M):
x, y, z = list(map(int, input().split()))
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
print(count)
| class Node:
def __init__(self):
self.is_parent = True
self.parent = None
def root(node):
depth = 0
while node.parent != None:
node = node.parent
depth += 1
return node, depth
N, M = list(map(int, input().split()))
roots = [Node() for i in range(N)]
count = N
for i in range(M):
x, y, z = list(map(int, input().split()))
x = roots[x-1]
y = roots[y-1]
if x.is_parent and y.is_parent:
y.is_parent = False
y.parent = x
count -= 1
else:
root_x, depth_x = root(x)
root_y, depth_y = root(y)
if root_x != root_y:
if depth_x >= depth_y:
root_y.is_parent = False
root_y.parent = root_x
count -= 1
else:
root_x.is_parent = False
root_x.parent = root_y
count -= 1
print(count)
| p03045 |
n,m=list(map(int,input().split()))
a=[]
for i in range(m):
x,y,z=list(map(int,input().split()))
a.append((x-1,y-1,z))
class union:
def __init__(self,num):
self.par=[-1]*num
def get_par(self,node):
if self.par[node]==-1:
return node
else:
x=self.get_par(self.par[node])
return x
def merge(self,x,y):
X=self.get_par(x)
Y=self.get_par(y)
if X!=Y:
self.par[Y]=X
def output(self):
print((self.par))
def count(self):
print((self.par.count(-1)))
u=union(n)
for i in range(m):
u.merge(a[i][0],a[i][1])
u.count()
| n,m=list(map(int,input().split()))
a=[]
for i in range(m):
x,y,z=list(map(int,input().split()))
a.append((x-1,y-1))
class union:
def __init__(self,num):
self.par=[-1]*num
def get_par(self,node):
if self.par[node]==-1:
return node
else:
x=self.get_par(self.par[node])
return x
def merge(self,x,y):
X=self.get_par(x)
Y=self.get_par(y)
if X!=Y:
self.par[Y]=X
def output(self):
print((self.par))
def count(self):
print((self.par.count(-1)))
def get_parent(node):
if par[node]==-1:
return node
else:
par[node]=get_parent(par[node])
return par[node]
def merge(x,y):
i=get_parent(x)
j=get_parent(y)
if i!=j:
par[i]=j
return
par=[-1]*n
for i in range(m):
merge(a[i][0],a[i][1])
print((par.count(-1))) | p03045 |
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()))
uf = UnionFind(N)
for _ in range(M):
x, y, z = list(map(int, input().split()))
uf.union(x-1,y-1)
print((uf.group_count()))
if __name__ == "__main__":
main() | 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()))
uf = UnionFind(n)
for _ in range(m):
x,y,z = list(map(int, input().split()))
# if z%2 == 0:
uf.union(x-1, y-1)
print((uf.group_count()))
if __name__ == "__main__":
main() | p03045 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
def root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.root(self.table[x])
return self.table[x]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def union(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
n, m = LI()
U = UnionFind(n)
for i in range(m):
x, y, z = LI()
U.union(x - 1, y - 1)
print((len(set([U.root(j) for j in range(n)]))))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
self.size = n
def root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.root(self.table[x])
return self.table[x]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def union(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
self.size -= 1
n, m = LI()
U = UnionFind(n)
for i in range(m):
x, y, z = LI()
U.union(x - 1, y - 1)
print((U.size))
| p03045 |
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1] * (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 False
if self.Size(x) < self.Size(y):
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
return True
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Size(self, x):
return -self.root[self.Find_Root(x)]
N, M = list(map(int, input().split()))
X = [0] * M
Y = [0] * M
Z = [0] * M
for i in range(M):
X[i], Y[i], Z[i] = list(map(int, input().split()))
Uni = UnionFind(N)
for i in range(M):
Uni.Unite(X[i], Y[i])
roots = set()
cnt = 0
for i in range(1, N+1):
r = Uni.Find_Root(i)
if r not in roots:
cnt += 1
roots.add(r)
print(cnt) | #最大公約数
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y)
#最小公倍数
def lcm(x, y):
return (x * y) // gcd(x, y)
#エストラテネスの篩
def isPrime():
MAX = 10**5
is_prime = [1] * (MAX+1)
is_prime[0] = 0
is_prime[1] = 0
for i in range(2, MAX+1):
if is_prime[i]:
for j in range(i*2, MAX+1, i):
is_prime[j] = 0
return is_prime
#約数を求める
def makeDivisor(n):
divisors = []
for i in range(1, int(n ** 0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
#素因数分解（試し割り法）
def makePrime(n):
factor = []
tmp = int(n ** 0.5) + 1
for num in range(2, tmp):
while n % num == 0:
n //= num
factor.append(num)
if n > 1:
factor.append(n)
return factor
#繰り返し２乗法
def modPow(a, p):
if p == 0:
return 1
if p % 2 == 0:
halfP = p // 2
half = modPow(a, halfP)
return half * half % mod
else:
return a * modPow(a, p-1) % mod
#組み合わせ
def comb(a, b):
if b > a - b:
return comb(a, a-b)
ansMul = 1
ansDiv = 1
for i in range(b):
ansMul *= a - i
ansDiv *= i + 1
ansMul %= mod
ansDiv %= mod
ans = ansMul * modPow(ansDiv, mod-2) % mod
return ans
#UnionFind
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1] * (n+1)
def FindRoot(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.FindRoot(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.FindRoot(x)
y = self.FindRoot(y)
if x == y:
return False
if self.Size(x) < self.Size(y):
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
return True
def isSameGroup(self, x, y):
return self.FindRoot(x) == self.FindRoot(y)
def Size(self, x):
return -self.root[self.FindRoot(x)]
N, M = list(map(int, input().split()))
X = [0] * M
Y = [0] * M
Z = [0] * M
for i in range(M):
X[i], Y[i], Z[i] = list(map(int, input().split()))
Uni = UnionFind(N)
for i in range(M):
Uni.Unite(X[i], Y[i])
roots = set()
for i in range(1, N+1):
roots.add(Uni.FindRoot(i))
print((len(roots)))
| p03045 |
N, M = list(map(int, input().split()))
relation = [[] for _ in range(N+1)]
for _ in range(M) :
X, Y, Z = list(map(int, input().split()))
relation[X].append(Y)
relation[Y].append(X)
visited = [False] * (N + 1)
def dfs(init) :
queue = [init]
while queue :
x_ = queue.pop(0)
visited[x_] = True
for y_ in relation[x_] :
if not visited[y_] :
queue.append(y_)
# 閉路ごとdfs実行
n_closed = 0
for i in range(1, N + 1) :
if len(relation[i]) and not visited[i] :
n_closed += 1
dfs(i)
print((n_closed + visited.count(False) - 1))
| N, M = list(map(int,input().split()))
parent = [-1] * (N + 1)
def root(x):
while parent[x] >= 0:
x = parent[x]
return x
def unite(x,y):
root_x = root(x)
root_y = root(y)
if root_x != root_y :
if parent[root_x] > parent[root_y] :
parent[root_x]=root_y
else :
if parent[root_x] == parent[root_y] :
parent[root_x] -= 1
parent[root_y] = root_x
return
for _ in range(M) :
X, Y, Z = list(map(int, input().split()))
unite(X, Y)
print((sum(i < 0 for i in parent) - 1)) | p03045 |
N, M = list(map(int, input().split()))
ans = [-1] * N
def find(x):
global ans
if ans[x] == -1:
return x
else:
return find(ans[x])
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
xx = find(x)
yy = find(y)
if ans[x] == ans[y] == -1:
ans[y] = x
elif xx == yy:
continue
else:
ans[yy] = xx
n = 0
for i in ans:
if i == -1:
n += 1
print(n) | N, M = list(map(int, input().split()))
ans = [-1] * N
def find(x):
global ans
if ans[x] == -1:
return x
else:
ans[x] = find(ans[x])
return ans[x]
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
xx = find(x)
yy = find(y)
if ans[x] == ans[y] == -1:
ans[y] = x
elif xx == yy:
continue
else:
ans[yy] = xx
n = 0
for i in ans:
if i == -1:
n += 1
print(n) | p03045 |
N, M = list(map(int, input().split()))
ans = [-1] * N
def find(x):
global ans
if ans[x] == -1:
return x
else:
ans[x] = find(ans[x])
return ans[x]
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
xx = find(x)
yy = find(y)
if ans[x] == ans[y] == -1:
ans[y] = x
elif xx == yy:
continue
else:
ans[yy] = xx
n = 0
for i in ans:
if i == -1:
n += 1
print(n) | N, M = list(map(int, input().split()))
UF = [-1] * (N+1)
def find(x):
global UF
if UF[x] == -1:
return x
else:
UF[x] = find(UF[x])
return UF[x]
def union(x,y):
global UF
xx = find(x)
yy = find(y)
if UF[x] == UF[y] == -1:
UF[y] = xx
return
elif xx == yy:
return
else:
UF[yy] = xx
return
for _ in range(M):
x, y, z = list(map(int, input().split()))
union(x,y)
print((sum([i < 0 for i in UF[1:]]))) | p03045 |
from collections import deque
N, M = list(map(int, input().split()))
X = [ list(map(int, input().split())) for _ in range(M)]
Y = [ [] for _ in range(N)]
for x in X:
Y[x[0]-1].append((x[0], x[1], x[2]))
Y[x[1]-1].append((x[1], x[0], x[2]))
# print(Y)
visited = [False] * N
count = 0
que = deque()
for i in range(len(Y)):
if len(Y[i]) == 0:
visited[i] = True
count +=1
while True:
if not False in visited:
break
count += 1
que.append(visited.index(False))
while len(que)>0:
v = que.popleft()
visited[v] = True
for y in Y[v]:
if not visited[y[1]-1]:
que.append(y[1]-1)
print(count) | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
def find_root(self, x):
if self.par[x] == x:
return x
self.par[x] = self.find_root(self.par[x])
return self.par[x]
def union(self, x, y):
x_root = self.find_root(x)
y_root = self.find_root(y)
if x_root != y_root:
if self.rank[x_root] < self.rank[y_root]:
x_root, y_root = y_root, x_root
if self.rank[x_root] == self.rank[y_root]:
self.rank[x_root] += 1
self.par[y_root] = x_root
def is_same(self, x, y):
x_root = self.find_root(x)
y_root = self.find_root(y)
return x_root == y_root
N, M = list(map(int, input().split()))
X = [ list(map(int, input().split())) for _ in range(M)]
uf = UnionFind(N)
for x in X:
uf.union(x[0]-1, x[1]-1)
roots = [ uf.find_root(i) for i in range(N)]
print((len(set(roots)))) | p03045 |
def main():
n,m = list(map(int,input().split()))
graph = {}
for i in range(n):
graph[i+1] = []
for i in range(m):
x,y,z = list(map(int,input().split()))
graph[x] += [y]
graph[y] += [x]
dis = [-1 for i in range (n)]
ans = 0
for i in range(n):
if dis[i]==-1:
ans += 1
que = [i]
dis[i] = 0
while len(que)>0:
s = que.pop(0)
for nv in graph[s+1]:
if dis[nv-1]!=-1:
continue
dis[nv-1] = 0
que.append(nv-1)
print(ans)
if __name__ == "__main__":
main()
| def main():
n,m = list(map(int,input().split()))
cards = [-1 for i in range(n)]
mg = {}
for i in range(n):
mg[i+1] = []
for i in range(m):
x,y,z = list(map(int,input().split()))
mg[x].append(y)
mg[y].append(x)
ans = 0
for i in range(n):
if cards[i]==-1:
ans += 1
cards[i] = 0
que = [i]
while len(que)>0:
s = que.pop(0)
for v in mg[s+1]:
if cards[v-1] == 0:
continue
cards[v-1] = 0
que.append(v-1)
print(ans)
if __name__ == "__main__":
main()
| p03045 |
from collections import deque
N,M = list(map(int,input().split()))
E = [[] for _ in range(N+1)]
for i in range(M):
x,y,z = list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
d = [-1]*(N+1)
def dfs(start,num):
q = deque([start])
while(q):
v = q.pop()
if(d[v] == -1):
d[v] = num
for s in E[v]:
if(d[s] == -1):
q.append(s)
group_num = 0
for i in range(1,N+1):
if(d[i] == -1):
group_num += 1
dfs(i,group_num)
print(group_num)
| from collections import deque
N,M = list(map(int,input().split()))
E = [[] for _ in range(N+1)]
for i in range(M):
x,y,z = list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
d = [-1]*(N+1)
def dfs(start,num):
q = deque([start])
d[start] = num
while(q):
v = q.pop()
for s in E[v]:
if(d[s] == -1):
d[s] = num
q.append(s)
group_num = 0
for i in range(1,N+1):
if(d[i] == -1):
group_num += 1
dfs(i,group_num)
print(group_num) | p03045 |
class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)] # 根(負): 連結頂点数 * (-1) / 子(正): 根の頂点番号(0-indexed)
def find(self, x): # xを含む木における根の頂点番号を返す
if self.v[x] < 0: # (負)は根
return x
else: # 根の頂点番号
self.v[x] = self.find(self.v[x]) # uniteでは, 旧根に属する頂点の根が旧根のままなので更新
return self.v[x]
def unite(self, x, y): # 違う根に属していたらrankが低くなるように連結
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]: # size比較, (-1) * (連結頂点数 * (-1)), (正)同士の大小比較
x, y = y, x # 連結頂点数が少ない方をyにすると, findでの更新回数が減る？
self.v[x] += self.v[y] # 連結頂点数の和を取る, 連結頂点数 * (-1)
self.v[y] = x # 連結頂点数が少ないy(引数yの根の頂点番号)の根をx(引数xの根の頂点番号)にする
def root(self, x):
return self.v[x] < 0 # (負)は根
def same(self, x, y):
return self.find(x) == self.find(y) # 同じ根に属するか
def size(self, x):
return -self.v[self.find(x)] # 連結頂点数を返す
N, M = list(map(int, input().split()))
uf = UnionFind(N * 2)
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
if z % 2 == 0:
uf.unite(x, y)
uf.unite(x + N, y + N)
else:
uf.unite(x, y + N)
uf.unite(x + N, y)
# print(uf.v)
ans = 0
for i in range(N):
if uf.root(i):
ans += 1
print(ans)
| class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)]
def find(self, x):
if self.v[x] < 0:
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
def root(self, x):
return self.v[x] < 0
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.v[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N * 2)
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
if z & 1:
uf.unite(x + N, y)
uf.unite(x, y + N)
else:
uf.unite(x, y)
uf.unite(x + N, y + N)
print((sum(1 for i in range(N) if uf.root(i))))
| p03045 |
class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)]
def find(self, x):
if self.v[x] < 0:
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
def root(self, x):
return self.v[x] < 0
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.v[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N * 2)
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
if z & 1:
uf.unite(x + N, y)
uf.unite(x, y + N)
else:
uf.unite(x, y)
uf.unite(x + N, y + N)
print((sum(1 for i in range(N) if uf.root(i))))
| class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)]
def find(self, x):
if self.v[x] < 0:
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
def root(self, x):
return self.v[x] < 0
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.v[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N)
for _ in range(M):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((sum(1 for i in range(N) if uf.root(i))))
| p03045 |
class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
# 正==子: 根の頂点番号 / 負==根: 連結頂点数
def find(self, x):
if self.parent[x] < 0:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return False
else:
if self.size(x) < self.size(y):
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
x = self.find(x)
return -self.parent[x]
def is_root(self, x):
return self.parent[x] < 0
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((sum(uf.is_root(i) for i in range(n))))
| import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)] # 根(負): 連結頂点数 * (-1) / 子(正): 根の頂点番号(0-indexed)
def find(self, x): # xを含む木における根の頂点番号を返す
if self.v[x] < 0: # (負)は根
return x
else: # 根の頂点番号
self.v[x] = self.find(self.v[x]) # uniteでは, 旧根に属する頂点の根が旧根のままなので更新
return self.v[x]
def unite(self, x, y): # 違う根に属していたらrankが低くなるように連結
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]: # size比較, (-1) * (連結頂点数 * (-1)), (正)同士の大小比較
x, y = y, x # 連結頂点数が少ない方をyにすると, findでの更新回数が減る？
self.v[x] += self.v[y] # 連結頂点数の和を取る, 連結頂点数 * (-1)
self.v[y] = x # 連結頂点数が少ないy(引数yの根の頂点番号)の根をx(引数xの根の頂点番号)にする
def root(self, x):
return self.v[x] < 0 # (負)は根
def same(self, x, y):
return self.find(x) == self.find(y) # 同じ根に属するか
def size(self, x):
return -self.v[self.find(x)] # 連結頂点数を返す
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((sum(uf.root(j) for j in range(n))))
| p03045 |
import sys
sys.setrecursionlimit(2*10**5)
N, M = list(map(int, input().split()))
X, Y, Z = (
list(zip(*(list(map(int, input().split())) for _ in range(M)))) if M else
((), ())
)
G = [set() for _ in range(N + 1)]
for x, y in zip(X, Y):
G[x].add(y)
G[y].add(x)
dp = [-1 for _ in range(N + 1)]
def f(i, k):
for t in G[i]:
if dp[t] == -1:
dp[t] = k
f(t, k)
L = 0
for i in range(1, N + 1):
if dp[i] == -1:
L += 1
f(i, L)
ans = L
print(ans)
| # 入力
N, M = list(map(int, input().split()))
X, Y, Z = (
list(zip(*(list(map(int, input().split())) for _ in range(M)))) if M else
((), (), ())
)
# UnionFind木で連結成分の個数を数える
class UnionFindTree:
def __init__(self, n):
self.p = [i for i in range(n + 1)]
self.r = [0 for _ in range(n + 1)]
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
px = self.find(x)
py = self.find(y)
if px != py:
if self.r[px] < self.r[py]:
self.p[px] = py
else:
self.p[py] = px
if self.r[px] == self.r[py]:
self.r[px] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
uft = UnionFindTree(N)
for x, y in zip(X, Y):
uft.union(x, y)
ans = len({uft.find(i) for i in range(1, N + 1)})
# 出力
print(ans)
| p03045 |
n,m=list(map(int,input().split()))
g = [[] for _ in range(n)]
for i in range(m):
x,y,z=list(map(int,input().split()))
g[x-1].append(y-1)
g[y-1].append(x-1)
check = [False]*n
cnt=0
import queue
for i in range(n):
if check[i]:
continue
cnt+=1
check[i]=True
q=queue.Queue()
q.put(i)
while not q.empty():
now=q.get()
for ne in g[now]:
if check[ne]:
continue
check[ne]=True
q.put(ne)
print(cnt) | n,m=list(map(int,input().split()))
g = [[] for _ in range(n)]
for i in range(m):
x,y,z=list(map(int,input().split()))
g[x-1].append(y-1)
g[y-1].append(x-1)
check = [False]*n
cnt=0
import queue
q=queue.Queue()
for i in range(n):
if check[i]:
continue
cnt+=1
check[i]=True
q.put(i)
while not q.empty():
now=q.get()
for ne in g[now]:
if check[ne]:
continue
check[ne]=True
q.put(ne)
print(cnt) | p03045 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
s = input()
for i in range(k-1):
print(s[i],end = "")
print(s[k-1].lower(),end = "")
for i in range(k,n):
print(s[i],end = "")
print()
return
#B
def B():
s = S()
k = int(s[0])*10+int(s[1])
l = int(s[2])*10+int(s[3])
if k == 0:
if l == 0:
print("NA")
elif l < 13:
print("YYMM")
else:
print("NA")
elif k < 13:
if l == 0:
print("MMYY")
elif l < 13:
print("AMBIGUOUS")
else:
print("MMYY")
else:
if l == 0:
print("NA")
elif l < 13:
print("YYMM")
else:
print("NA")
#C
def C():
n,k = LI()
ans = 0
for i in range(1,n+1):
l = k/i
ans += 1/n*1/(2 << max(0,math.ceil(math.log(l,2))))
print(ans*2)
return
#D
def D():
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
x,y,w = LI()
x -= 1
y -= 1
v[x].append((y,w))
v[y].append((x,w))
ans = [0 for i in range(n)]
bfs_map = [1 for i in range(n)]
bfs_map[0] = 0
q = deque()
q.append(0)
while q:
x = q.popleft()
for y,w in v[x]:
if bfs_map[y]:
if w%2:
ans[y] = ans[x]^1
else:
ans[y] = ans[x]
bfs_map[y] = 0
q.append(y)
for i in ans:
print(i)
return
#E
def E():
def root(x):
if par[x] == x:
return par[x]
par[x] = root(par[x])
return par[x]
def same(x,y):
return root(x) == root(y)
def unite(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
n,m = LI()
par = [i for i in range(n)]
rank = [0 for i in range(n)]
for i in range(m):
x,y,z = LI()
x -= 1
y -= 1
if not same(x,y):
unite(x,y)
for i in range(n):
root(i)
par = list(set(par))
print(len(par))
return
#F
def F():
n = I()
return
#Solve
if __name__ == "__main__":
E()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(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
n,m = LI()
par = [i for i in range(n)]
rank = [0]*n
for i in range(m):
x,y,z = LI()
x -= 1
y -= 1
if root(x) != root(y):
unite(x,y)
s = set([root(i) for i in range(n)])
print((len(s)))
return
#Solve
if __name__ == "__main__":
solve()
| p03045 |
n,m=list(map(int, input().split()))
tree=[[] for _ in range(n)]
for i in range(m):
x,y,w = list(map(int,input().split()))
tree[x-1].append(y-1)
tree[y-1].append(x-1)
singles = [ i for i in range(n) if tree[i]==[]]
visited=[False]*n
for i in singles:
visited[i] = True
ans=len(singles)
from collections import deque
while False in visited:
ans+=1
start = visited.index(False)
visited[start]=True
q=deque([(start,togo) for togo in tree[start]])
while q:
parent,x = q.pop()
visited[x]=True
for y in tree[x]:
if not visited[y]:
q.append((x,y))
# print(parent,x,q)
# print(visited,ans)
print(ans) | def main():
import sys
input = sys.stdin.readline
n,m=list(map(int, input().split()))
tree=[[] for _ in range(n)]
for i in range(m):
x,y,w = list(map(int,input().split()))
tree[x-1].append(y-1)
tree[y-1].append(x-1)
singles = [ i for i in range(n) if tree[i]==[]]
visited=[False]*n
for i in singles:
visited[i] = True
ans=len(singles)
from collections import deque
while False in visited:
ans+=1
start = visited.index(False)
visited[start]=True
q=deque([(start,togo) for togo in tree[start]])
while q:
parent,x = q.pop()
visited[x]=True
for y in tree[x]:
if not visited[y]:
q.append((x,y))
# print(parent,x,q)
# print(visited,ans)
print(ans)
if __name__ == '__main__':
main() | p03045 |
n,m=list(map(int,input().split()))
#初期値が0の辞書
from collections import defaultdict
xyz = defaultdict(lambda: set([]))
for _ in range(m):
x,y,z=list(map(int,input().split()))
xyz[x].add(y)
xyz[y].add(x)
no_checked=[0]*n
cnt=0
for i in range(1,n+1):
if no_checked[i-1]==0:
cnt+=1
temp=set([i])
no_checked[i-1]=1
while len(list(temp))>0:
v=temp.pop()
for item in xyz[v]:
if no_checked[item-1]==0:
no_checked[item-1]=1
temp.add(item)
xyz[item].remove(v)
#print(i,no_checked)
print(cnt)
| import sys
sys.setrecursionlimit(1000000)
n,m=list(map(int,input().split()))
#初期値が0の辞書
from collections import defaultdict
xyz = defaultdict(lambda: set([]))
for _ in range(m):
x,y,z=list(map(int,input().split()))
xyz[x].add(y)
xyz[y].add(x)
no_checked=[0]*n
def DFS(x):
global no_checked
global xyz
no_checked[x-1]=1
for item in xyz[x]:
if no_checked[item-1]==0:
DFS(item)
cnt=0
for i in range(1,n+1):
if no_checked[i-1]==0:
cnt+=1
DFS(i)
#print(i,no_checked)
print(cnt)
| p03045 |
class UnionFind:
def __init__(self, size):
self.data = [-1 for _ in range(size)]
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, M = [int(i) for i in input().split()]
uf = UnionFind(N + 1)
for x, y, z in [[int(i) for i in input().split()] for _ in range(M)]:
uf.union(x, y)
s = set()
for i in range(1, N + 1):
s.add(uf.find(i))
print((len(s))) | class UnionFind:
def __init__(self, size):
self.data = [-1 for _ in range(size)]
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, M, *XYZ = list(map(int, open(0).read().split()))
uf = UnionFind(N + 1)
for x, y, _ in zip(*[iter(XYZ)] * 3):
uf.union(x, y)
print((len({uf.find(i + 1) for i in range(N)})))
| p03045 |
class UFT(): #Union-find tree class
def __init__(self, N):
self.tree = [int(i) for i in range(N)]
self.rank = [0 for i in range(N)]
def find(self, a):
if self.tree[a] == a: return a
else:
self.tree[a] = self.find(self.tree[a])
return self.tree[a]
def unite(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b: return
if self.rank[a] < self.rank[b]: self.tree[a] = b
else:
self.tree[b] = a
if self.rank[a] == self.rank[b]: self.rank[a] += 1
N, M = list(map(int, input().split()))
parent = UFT(N)
for i in range(M):
x, y, z = list(map(int, input().split()))
parent.unite(x-1, y-1)
for i in range(N):
parent.find(i)
print((len(set(parent.tree)))) | import sys
class UFT: #Union-find tree class
def __init__(self, N):
self.tree = [int(i) for i in range(N)]
self.rank = [0 for i in range(N)]
def find(self, a):
if self.tree[a] == a: return a
else:
self.tree[a] = self.find(self.tree[a])
return self.tree[a]
def unite(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b: return
if self.rank[a] < self.rank[b]: self.tree[a] = b
else:
self.tree[b] = a
if self.rank[a] == self.rank[b]: self.rank[a] += 1
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
parent = UFT(N)
for i in range(M):
x, y, z = list(map(int, input().split()))
parent.unite(x-1, y-1)
for i in range(N):
parent.find(i)
print((len(set(parent.tree))))
return 0
if __name__ == "__main__":
solve() | p03045 |
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
#Union Find
#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):
x, y, z = [int(x) for x in input().split()]
unite(x - 1, y - 1)
A = set()
for i in range(n):
A.add(find(i))
print((len(A)))
| import sys
input = lambda : sys.stdin.readline().rstrip()
n, m = list(map(int, input().split()))
#Union Find
#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):
x, y, z = list(map(int, input().split()))
unite(x - 1, y - 1)
ans = 0
for i in range(n):
if find(i) == i:
ans += 1
print(ans) | p03045 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.