input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n = int(eval(input()))
a,b=[],[]
for i in range(n):
x,y = list(map(int,input().split()))
a.append(x)
b.append(y)
a=list(reversed(a))
b=list(reversed(b))
OK=0
for i in range(n):
A=a[i]+OK
if A<b[i]:
ok=b[i]-A
if A==b[i]:
continue
else:
ok=-(-A//b[i])*b[i]-A
OK+=ok
print(OK)
| n = int(eval(input()))
a,b=[],[]
for i in range(n):
x,y = list(map(int,input().split()))
a.append(x)
b.append(y)
a=list(reversed(a))
b=list(reversed(b))
OK=0
for i in range(n):
A=a[i]+OK
if A==b[i]:
continue
else:
ok=-(-A//b[i])*b[i]-A
OK+=ok
print(OK)
| p03821 |
n = int(eval(input()))
ab = [list(map(int, input().split())) for i in range(n)][::-1]
ans = 0
for a, b in ab:
tmp = a
while tmp % b != 0:
tmp += 1
for i in range(n):
ab[i][0] += tmp - a
ans += tmp - a
print(ans) | n = int(eval(input()))
ab = [list(map(int, input().split())) for i in range(n)][::-1]
ans = 0
for a, b in ab:
a += ans
# 負の剰余。
ans += -a % b
print(ans) | p03821 |
def slove():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
ab = [list(map(int, (str(i) + " " + input().rstrip('\n')).split())) for i in range(n)]
ab.sort(reverse=True)
cnt = 0
for i, a, b in ab:
if (a + cnt) % b != 0:
cnt += (b - (a + cnt) % b)
print(cnt)
if __name__ == '__main__':
slove()
| def slove():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(n)]
t = 0
for i in range(n-1, -1, -1):
while True:
if (ab[i][0] + t) % ab[i][1] == 0:
break
else:
t += (ab[i][1] - (ab[i][0] + t) % ab[i][1])
print(t)
if __name__ == '__main__':
slove()
| p03821 |
def slove():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(n)]
t = 0
for i in range(n-1, -1, -1):
while True:
if (ab[i][0] + t) % ab[i][1] == 0:
break
else:
t += (ab[i][1] - (ab[i][0] + t) % ab[i][1])
print(t)
if __name__ == '__main__':
slove()
| def slove():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(n)]
t = 0
for i in range(n):
a, b = ab[-i-1]
a += t
if a % b != 0:
t += ((a + b - 1) // b * b - a)
print(t)
if __name__ == '__main__':
slove()
| p03821 |
N = int(eval(input()))
src = [list(map(int,input().split())) for i in range(N)]
ans = 0
for a,b in reversed(src):
r = (ans+a) % b
if r == 0: continue
ans += (b-r)
print(ans)
| N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N)]
ans = 0
for a,b in reversed(src):
a += ans
ans += (b-a)%b
print(ans) | p03821 |
N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N)]
ans = 0
for a,b in src[::-1]:
ans += (-(a+ans))%b
print(ans) | N = int(eval(input()))
AB = [tuple(map(int,input().split())) for i in range(N)]
z = 0
for a,b in AB[::-1]:
z += -(z+a)%b
print(z) | p03821 |
n = int(eval(input()))
a = []
b = []
for i in range(n):
A, B = list(map(int, input().split()))
a.append(A)
b.append(B)
ans = 0
a = a[::-1]
b = b[::-1]
for i in range(n):
if a[i] % b[i] == 0:
continue
p = (a[i] // b[i] + 1) * b[i] - a[i]
ans += p
for j in range(i, n):
a[j] += p
print(ans) | n = int(eval(input()))
a = []
b = []
for i in range(n):
A, B = list(map(int, input().split()))
a.append(A)
b.append(B)
ans = 0
a = a[::-1]
b = b[::-1]
for i in range(n):
a[i] += ans
if a[i] % b[i] == 0:
continue
ans += (a[i] // b[i] + 1) * b[i] - a[i]
print(ans) | p03821 |
n = int(eval(input()))
a = []
b = []
for i in range(n):
A, B = list(map(int, input().split()))
a.append(A)
b.append(B)
ans = 0
a = a[::-1]
b = b[::-1]
for i in range(n):
a[i] += ans
if a[i] % b[i] == 0:
continue
ans += (a[i] // b[i] + 1) * b[i] - a[i]
print(ans) | n = int(eval(input()))
a = []
b = []
for i in range(n):
A, B = list(map(int, input().split()))
a.append(A)
b.append(B)
a.reverse()
b.reverse()
ans = 0
for i in range(n):
if (a[i] + ans) % b[i]:
ans += b[i] - (a[i] + ans) % b[i]
print(ans) | p03821 |
N = int(eval(input()))
ablist = []
for _ in range(N):
ab = list(map(int, input().split()))
ablist.append(ab)
ans = 0
for a, b in ablist[::-1]:
a += ans
if a % b == 0:
continue
else:
ans += (b - a % b)
print(ans)
| N = int(eval(input()))
ABlist = [tuple(map(int, input().split())) for _ in range(N)]
ans = 0
for a, b in ABlist[::-1]:
a += ans
if a % b == 0:
continue
else:
ans += (b - a % b)
print(ans)
| p03821 |
n=int(eval(input()))
A,B=[],[]
for _ in range(n):
a,b=list(map(int,input().split()))
A.append(a)
B.append(b)
ans=0
for i in range(n-1,-1,-1):
a,b=A[i],B[i]
a+=ans
ans+=b-a%b if a%b else 0
print(ans) | n=int(eval(input()))
A,B=[],[]
for _ in range(n):
a,b=list(map(int,input().split()))
A.append(a)
B.append(b)
ans=0
for a,b in zip(A[::-1],B[::-1]):
a+=ans
ans+=b-a%b if a%b else 0
print(ans) | p03821 |
n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for a, b in reversed(ab):
r = (ans+a) % b
if r != 0:
ans += b - r
print(ans) | n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for a, b in reversed(ab):
a += ans
ans += (-a) % b
print(ans) | p03821 |
n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for a, b in reversed(ab):
while (a+ans) % b != 0:
ans += 1
print(ans) | n = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for a, b in reversed(ab):
if (a + ans) % b != 0:
ans += b - (a + ans) % b
print(ans) | p03821 |
N, *AB = list(map(int, open(0).read().split()))
ans = 0
for i in range(N):
index = N - 1 - i
a = AB[index * 2 + 0] + ans
b = AB[index * 2 + 1]
remainder = a % b
ans += (b - remainder) % b
print(ans)
| def main():
N, *AB = list(map(int, open(0).read().split()))
ans = 0
for i in range(N):
index = N - 1 - i
a = AB[index * 2 + 0] + ans
b = AB[index * 2 + 1]
remainder = a % b
ans += (b - remainder) % b
print(ans)
if __name__ == "__main__":
main()
| p03821 |
def main():
N, *AB = list(map(int, open(0).read().split()))
ans = 0
for i in range(N):
index = N - 1 - i
a = AB[index * 2 + 0] + ans
b = AB[index * 2 + 1]
remainder = a % b
ans += (b - remainder) % b
print(ans)
if __name__ == "__main__":
main()
| def main():
N, *AB = list(map(int, open(0).read().split()))
ans = 0
for i in range(N - 1, -1, -1):
a = AB[i * 2 + 0]
b = AB[i * 2 + 1]
ans += (b - a - ans) % b
print(ans)
if __name__ == "__main__":
main()
| p03821 |
a = int(eval(input()))
ar = []
for i in range(a):
l = list(map(int,input().split(" ")))
ar.insert(0,l)
count = 0
for r in ar:
x = r[0] + count
y = r[1]
m = x % y
if m != 0:
count += y - m
print(count) | a = int(eval(input()))
ar = []
for i in range(a):
l = list(map(int,input().split(" ")))
ar.append(l)
ar.reverse()
count = 0
for r in ar:
x = r[0] + count
y = r[1]
m = x % y
if m != 0:
count += y - m
print(count) | p03821 |
n = int(eval(input()))
ABs = [list(map(int, input().split())) for i in range(n)]
ABs = [i for i in reversed(ABs)]
As,Bs = [],[]
for i in range(n):
As.append(ABs[i][0])
Bs.append(ABs[i][1])
cnt = 0
for i in range(n):
plus = 0 if As[i] % Bs[i] == 0 else Bs[i] - As[i] % Bs[i]
As[i:] = list([x + plus for x in As[i:]])
cnt += plus
print(cnt) | n = int(eval(input()))
ABs = [list(map(int, input().split())) for i in range(n)]
cnt = 0
for i in range(n):
plus = 0 if (ABs[n-i-1][0] + cnt) % ABs[n-i-1][1] == 0 else ABs[n-i-1][1] - (ABs[n-i-1][0] + cnt) % ABs[n-i-1][1]
cnt += plus
print(cnt) | p03821 |
n = int(eval(input()))
ans = 0
ab = [tuple(map(int,input().split())) for i in range(n)]
a,b = [],[]
for ai,bi in ab:
a.append(ai)
b.append(bi)
c = 0
for i in reversed(list(range(n))):
a[i] += c
while(a[i]%b[i]):
c+=1
a[i]+=1
print(c) | n = int(eval(input()))
ans = 0
a, b = [], []
for i in range(n):
ai, bi = list(map(int, input().split()))
a.append(ai)
b.append(bi)
c = 0
for i in reversed(list(range(n))):
a[i] += c
x = a[i] % b[i]
if x:
if a[i] < b[i]:
c += b[i] - a[i]
elif a[i] > b[i]:
c += b[i] - x
print(c)
| p03821 |
N = int(eval(input()))
import math
A = []
B = []
for i in range(N):
a, b = list(map(int,input().split()))
A.append(int(a))
B.append(int(b))
count=0
for i in range(N):
#print(i,A[N-1-i],B[N-1-i])
if A[N-1-i]%B[N-1-i]==0:
n=0
elif A[N-1-i]>B[N-1-i]:
n=math.ceil(A[N-1-i]/B[N-1-i])*B[N-1-i]-A[N-1-i]
elif A[N-1-i]<B[N-1-i]:
n= B[N-1-i]-A[N-1-i]
count +=n
#print(n)
for j in range(N-i):
A[j]+=n
#print(A)
#print(B)
print(count) | N = int(eval(input()))
import math
A = []
B = []
for i in range(N):
a, b = list(map(int,input().split()))
A.append(int(a))
B.append(int(b))
n=0
for i in range(N):
#print(i,A[N-1-i]+n,B[N-1-i]+n)
if (A[N-1-i]+n)%(B[N-1-i])==0:
n+=0
elif A[N-1-i]+n>B[N-1-i]:
n+=math.ceil((A[N-1-i]+n)/B[N-1-i])*(B[N-1-i])-A[N-1-i]-n
#print('!',n,math.ceil((A[N-1-i]+n)/(B[N-1-i])))
elif A[N-1-i]+n<B[N-1-i]:
n+= B[N-1-i]-A[N-1-i]-n
#print(n)
#count +=n
#print(n)
#for j in range(N-i):
#A[j]+=n
print(n) | p03821 |
# https://atcoder.jp/contests/agc009/tasks/agc009_a
n=int(eval(input()))
ab=[tuple(map(int,input().split())) for _ in range(n)]
ans=0
for a,b in reversed(ab):
a+=ans
res=a%b
if res:
ans+=b-res
print(ans) | # https://atcoder.jp/contests/agc009/tasks/agc009_a
import sys
input=sys.stdin.readline
n=int(eval(input()))
ab=[tuple(map(int,input().split())) for _ in range(n)]
ans=0
for a,b in reversed(ab):
a+=ans
res=a%b
if res:
ans+=b-res
print(ans) | p03821 |
N = int(eval(input()))
A = [0]*N
B = [0]*N
for i in range(N):
a, b = list(map(int, input().split()))
A[i] = a
B[i] = b
ans = 0
for i in range(N-1,-1,-1):
A[i] += ans
ans += B[i]*((A[i]+B[i]-1)//B[i]) - A[i]
print(ans)
| import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [0]*N
B = [0]*N
for i in range(N):
a, b = list(map(int, input().split()))
A[i] = a
B[i] = b
ans = 0
for i in range(N-1,-1,-1):
A[i] += ans
if A[i]%B[i] != 0:
ans += B[i]-(A[i]%B[i])
print(ans)
| p03821 |
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
AB = [0] * N
for i in range(N):
AB[i] = list(map(int, input().split()))
n_press = 0
for A, B in reversed(AB):
_, r, = divmod(A + n_press, B)
n_press += B - r if r > 0 else 0
ans = n_press
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
AB = [0] * N
for i in range(N):
AB[i] = list(map(int, input().split()))
n_press = 0
for A, B in reversed(AB):
r = (A + n_press) % B
n_press += B - r if r > 0 else 0
ans = n_press
print(ans)
if __name__ == "__main__":
main()
| p03821 |
n=int(eval(input()))
a=[0 for _ in range(n)]
b=[0 for _ in range(n)]
for i in range(n):
a[i],b[i] = list(map(int,input().split()))
cnt=0
for i in range(n):
i=n-1-i
while (a[i]+cnt)%b[i]!=0:
cnt+=1
print(cnt)
| n=int(eval(input()))
a=[0 for _ in range(n)]
b=[0 for _ in range(n)]
for i in range(n):
a[i],b[i] = list(map(int,input().split()))
cnt=0
for i in range(n):
i=n-1-i
if (a[i]+cnt)%b[i]!=0:
cnt+=b[i]-(a[i]+cnt)%b[i]
print(cnt) | p03821 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = 0
for i in reversed(list(range(N))):
if (ans + A[i]) % B[i] != 0:
ans += ((ans + A[i]) // B[i] + 1) * B[i] - (ans + A[i])
print(ans) | import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = 0
for i in reversed(list(range(N))):
t = (ans + A[i]) % B[i]
if t != 0:
ans += B[i] - t
print(ans) | p03821 |
n = int(eval(input()))
aa = [0]*n
bb = [0]*n
for i in range(n):
aa[i],bb[i] = list(map(int, input().split()))
ans = 0
for i in range(1,n+1):
cnt = 0
if aa[-i] % bb[-i] > 0:
cnt = ((aa[-i] - 1) // bb[-i] +1) * bb[-i] - aa[-i]
# print(aa[-i], bb[-i], cnt, aa)
ans += cnt
aa = list([x + cnt for x in aa])
print(ans) | n = int(eval(input()))
aa = [0]*n
bb = [0]*n
for i in range(n):
aa[i],bb[i] = list(map(int, input().split()))
ans = 0
for i in range(1,n+1):
cnt = 0
cur = aa[-i] + ans
if cur % bb[-i] > 0:
cnt = ((cur - 1) // bb[-i] +1) * bb[-i] - cur
# print(cur, bb[-i], cnt, aa)
ans += cnt
print(ans) | p03821 |
N=int(eval(input()))
x=[]
for i in range(N):
a,b=list(map(int,input().split()))
x.append([a,b])
x=x[::-1]
ans=0
for i in range(N):
if x[i][0]%x[i][1]!=0:
cnt=x[i][1]-x[i][0]%x[i][1]
ans+=cnt
for j in range(i+1,N):
x[j][0]+=cnt
cnt=0
print(ans) | N=int(eval(input()))
r=[]
bi=[]
for i in range(N):
a,b=list(map(int,input().split()))
bi.append(b)
if a%b==0:
r.append(0)
else:
r.append(b-a%b)
push=0
bi=bi[::-1]
r=r[::-1]
for i in range(N):
if i==0:
push=r[i]
else:
push+=(r[i]-push)%bi[i]
print(push) | p03821 |
n = int(eval(input()))
AB = [[int(i) for i in input().split()] for i in range(n)]
ans = 0
for i in range(n - 1, -1, -1):
tmp = AB[i][0] % AB[i][1]
if tmp == 0:
x = tmp
else:
x = AB[i][1] - tmp
ans += x
if i > 0:
for j in range(i - 1, -1, -1):
AB[j][0] += x
#print(AB, x, ans)
print(ans) | n = int(eval(input()))
AB = [[int(i) for i in input().split()] for i in range(n)]
acc = 0
for i in range(n - 1, -1, -1):
tmp = AB[i][0] % AB[i][1]
if tmp == 0:
x = tmp
else:
x = AB[i][1] - tmp
acc += x
if i > 0:
AB[i - 1][0] += acc
#print(AB, x, acc)
print(acc) | p03821 |
N = int(eval(input()))
a = list(map(int, input().split()))
aa = [ai - i-1 for i,ai in enumerate(a)]
def tri_search(f:"f(x:float)->float", left, right, iter=100)->float:
for _ in range(iter):
ml = (left*2 + right) / 3
mr = (left + right*2) / 3
if f(ml) < f(mr):
right = mr
else:
left = ml
# print(left, right)
return (right + left) / 2
def f(x):
ret = 0
x = round(x)
for aai in aa:
ret += abs(aai - x)
return ret
b = tri_search(f, -10**9, 10**9)
print((f(b)))
| N = int(eval(input()))
a = list(map(int, input().split()))
aa = [ai - i-1 for i,ai in enumerate(a)]
def tri_search(f:"f(x:float)->float", left, right, iter=100)->float:
for _ in range(iter):
ml = (left*2 + right) / 3
mr = (left + right*2) / 3
if f(ml) < f(mr):
right = mr
else:
left = ml
# print(left, right)
return (right + left) / 2
def f(x):
ret = 0
x = int(x+0.5)
for aai in aa:
ret += abs(aai - x)
return ret
b = tri_search(f, -10**9, 10**9)
print((min(f(b), f(b+1), f(b-1))))
| p03311 |
n = int(eval(input()))
a= [int(i) for i in input().split()]
for i in range(len(a)):
a[i]-=i+1
import math
#import statistics
#b=statistics.median(a)
b=math.floor(sum(a)/n)
def p(b,k):
s=0
t=0
for i in a:
s+=abs(i-b)
t+=abs(i-b-1)
if s>t:
if k==-1:
print(t)
else:
return p(b+1,1)
elif s==t:
print(s)
else:
if k==1:
print(s)
else:
return p(b-1,-1)
p(b,0)
| n = int(eval(input()))
a= [int(i) for i in input().split()]
for i in range(len(a)):
a[i]-=i+1
aa=sorted(a)
if n%2==0:
b=(aa[int(n/2-1)]+aa[int(n/2)])/2
else:
b=aa[int((n-1)/2)]
s=0
for i in aa:
s+=abs(i-b)
print((int(s)))
| p03311 |
def makelist(n, m):
return [[0 for _ in range(m)] for _ in range(n)]
N = int(eval(input()))
A = list(map(int, input().split()))
def check(b):
res = 0
for i in range(N):
res += abs(A[i] - (b+(i+1)))
#print(b, res)
return res
def ternarySearchInt(small, big):
# 初期条件
if small == big:
return small
elif big - small == 1:
if check(small) <= check(big):
return small
else:
return big
def func(small, big):
midl = (big + small) // 2
midr = midl + 1
if big - small == 2: # 終了条件
mid = midl
if check(small) <= check(mid):
if check(small) <= check(big):
return small
else:
return big
else:
if check(mid) <= check(big):
return mid
else:
return big
else:
if check(midl) >= check(midr):
return func(midl, big)
else:
return func(small, midr)
return func(small, big)
ans = ternarySearchInt(-int(1e9), int(1e9))
#print(check(0))
print((check(ans)))
| N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
A[i] -= i+1
A.sort()
mid = A[N//2]
ans = 0
for i in range(N):
ans += abs(A[i] - mid)
print(ans)
| p03311 |
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N = I()
A = LI()
for i in range(N):
A[i] -= i+1
A.sort()
def f(x):
return sum(abs(A[i]-x) for i in range(N))
print((f((A[(N-1)//2]+A[N//2])//2)))
# 中間値
| import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
A = LI()
for i in range(N):
A[i] -= i+1
A.sort()
x = A[N//2]
y = A[(N-1)//2]
z = (x+y)//2
print((sum(abs(A[i]-z) for i in range(N))))
| p03311 |
n=int(eval(input()))
arr=list(map(int,input().split()))
pc=0
mc=0
zc=0
p=[]
m=[]
for i in range(n):
arr[i]-=(i+1)
if arr[i]>0:
pc+=1
p.append(arr[i])
elif arr[i]<0:
mc+=1
m.append(arr[i])
else:
zc+=1
p=sorted(p)
m=sorted(m,reverse=True)
diff=0
while 1:
if pc+zc>=mc and mc+zc>=pc:
print((sum(p)+abs(sum(m))+diff))
break
else:
if pc+zc<mc:
diff+=abs(m[0])*(pc+zc)
tm=[]
tmp=abs(m[0])
pc+=zc
zc=0
for i in range(mc):
m[i]=m[i]+tmp
if m[i]!=0:
tm.append(m[i])
else:
mc-=1
zc+=1
m=tm
else:
diff+=p[0]*(mc+zc)
tp=[]
tmp=p[0]
mc+=zc
zc=0
for i in range(pc):
p[i]=p[i]-tmp
if p[i]!=0:
tp.append(p[i])
else:
pc-=1
zc+=1 | n=int(eval(input()))
arr=list(map(int,input().split()))
for i in range(n):
arr[i]=arr[i]-(i+1)
arr=sorted(arr)
if n%2==1:
m=arr[n//2]
ans=0
for i in range(n):
ans=ans+abs(arr[i]-m)
print(ans)
else:
m1=arr[n//2]
m2=arr[n//2-1]
ans1=0
ans2=0
for i in range(n):
ans1=ans1+abs(arr[i]-m1)
ans2=ans2+abs(arr[i]-m2)
print((min(ans1,ans2))) | p03311 |
import math
N=int(input().strip())
a=list(map(int, input().strip().split(' ')))
for i in range(N):
a[i]=a[i]-(i+1)
b=sum(a)/N
ans1=0
ans2=0
for i in range(N):
ans1+=abs(a[i]-math.floor(sum(a)/N))
for i in range(N):
ans2+=abs(a[i]-math.ceil(sum(a)/N))
print((min(ans1,ans2))) | N=int(input().strip())
a=list(map(int, input().strip().split(' ')))
for i in range(N):
a[i]=a[i]-i
a.sort()
m=a[(N-1)//2]
ans=0
for i in range(N):
ans+=abs(a[i]-m)
print(ans) | p03311 |
N = int(eval(input()))
A = list(map(int, input().split()))
A = [A[i]-(i+1) for i in range(N)]
ans = 10 ** 9
#print (min(A))
for i in range(min(A), max(A)+1):
b = [abs(A[j]-i) for j in range(N)]
# print (sum(b))
# print (b)
ans = min(ans, sum(b))
print (ans) | #平均値に近づけるという考え方が間違い-->中央値に近づける
N = int(eval(input()))
A = list(map(int, input().split()))
A = [A[i]-(i+1) for i in range(N)]
A.sort()
center1 = A[N//2]
if N == 1:
center2 = 10 ** 9
else:
center2 = A[(N+2)//2]
ans1 = 0
for i in range(N):
ans1 +=abs(A[i]-center1)
ans2 = 0
for j in range(N):
ans2 += abs(A[j]-center2)
print((min(ans1, ans2))) | p03311 |
N = int(eval(input()))
A = list(map(int,input().split()))
from bisect import bisect_left
Ans = 0
pans = 0
low,high = -(10**5),10**9
for i in range(120):
anslow,anshigh = 0,0
for i in range(N):
anslow += abs(A[i]-(i+low))
anshigh += abs(A[i]-(i+high))
if anshigh > anslow:
high=(high+low)//2
else:
low=(high+low)//2
Ans = min(anshigh,anslow)
print(Ans) | N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(N):
A[i] -= i
A.sort()
Ans = 0
mi = len(A)//2 # 中央値のindex
for i in range(N):
Ans += abs(A[i]-A[mi])
print(Ans)
| p03311 |
def bisect(l, r):
while l < r:
m = (l + r) // 2
s1 = sum(abs(am - m) for am in aam)
s2 = sum(abs(am - m - 1) for am in aam)
if s1 < s2:
r = m
else:
l = m + 1
return l
n = int(eval(input()))
aaa = list(map(int, input().split()))
aam = [a - i - 1 for i, a in enumerate(aaa)]
aas = sum(aam)
b = bisect(int(-1e9), int(1e9))
print((sum(abs(am - b) for am in aam)))
| n = int(eval(input()))
aaa = list(map(int, input().split()))
aam = [a - i - 1 for i, a in enumerate(aaa)]
aam.sort()
b = aam[n // 2]
print((sum(abs(am - b) for am in aam)))
| p03311 |
n = int(eval(input()))
a = [int(x) for x in input().split()]
for i in range(n):
a[i] -= i+1
def hoge(b):
v = 0
for x in a:
v += abs(x-b)
return v
tmp = float('inf')
for x in set(a):
if hoge(x) < tmp:
tmp = hoge(x)
print(tmp) | n = int(eval(input()))
a = [int(x) for x in input().split()]
for i in range(n):
a[i] -= i+1
#中央値を求める
a.sort()
if len(a) % 2 == 0:
c = (a[len(a)//2] + a[len(a)//2-1]) // 2
else:
c = a[len(a)//2]
def hoge(b):
v = 0
for x in a:
v += abs(x-b)
return v
print((hoge(c))) | p03311 |
N = int(eval(input()))
A = list(map(int,input().split()))
B = sorted(A[i] - i - 1 for i in range(N))
def sad(b):
return sum(abs(A[i] - i - 1 - b)for i in range(N))
print((min(sad(B[N//2]),sad(B[min(N//2+1,N-1)]))))
| N=int(eval(input()))
B=sorted(int(x)-i-1 for i,x in enumerate(input().split()))
def sad(x):
return sum(abs(b-x)for b in B)
print((sad(B[N//2])))
| p03311 |
eval(input());S=sorted(int(x)-i-1 for i,x in enumerate(input().split()))
print((sum(abs(S[len(S)//2]-s)for s in S)))
| _,a=open(0)
S=sorted(int(x)-i for i,x in enumerate(a.split()))
print((sum(abs(S[len(S)//2]-s)for s in S))) | p03311 |
N = int(eval(input()))
A = list(map(int, input().split()))
A_i = [A[i] - i - 1 for i in range(N)]
A_i.sort()
if N % 2 == 1:
b = A_i[N // 2]
ans = 0
for a in A_i:
ans += abs(a - b)
print(ans)
else:
b1 = A_i[N // 2]
b2 = A_i[N // 2 - 1]
ans1 = 0
ans2 = 0
for a in A_i:
ans1 += abs(a - b1)
ans2 += abs(a - b2)
print((min(ans1, ans2)))
| N = int(eval(input()))
A = list(map(int, input().split()))
A_i = [A[i] - i - 1 for i in range(N)]
A_i.sort()
b = A_i[N // 2]
ans = 0
for a in A_i:
ans += abs(a - b)
print(ans)
| p03311 |
N = int(eval(input()))
A = list(map(int, input().split()))
A_i = [A[i] - i - 1 for i in range(N)]
A_i.sort()
b = A_i[N // 2]
ans = 0
for a in A_i:
ans += abs(a - b)
print(ans)
| import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A = [a - i - 1 for i, a in enumerate(A)]
A.sort()
i = N // 2
b = A[i]
ans = 0
for a in A:
ans += abs(a - b)
print(ans)
if __name__ == "__main__":
main()
| p03311 |
import statistics
n = int(eval(input()))
x = list(map(int, input().split()))
for i in range(n):
x[i] -= i+1
b = statistics.median(x)
ans = 0
for i in range(n):
ans += abs(x[i] - b)
print((int(ans)))
| from statistics import median
n = int(eval(input()))
a = list(map(int, input().split()))
for i in range(n):
a[i] -= i+1
med = median(a)
ans = 0
for i in range(n):
ans += abs(a[i] - med)
print((int(ans))) | p03311 |
n = int(eval(input()))
a = list(map(int, input().split()))
sub = []
for i in range(n):
sub.append(a[i] - i - 1)
sub.sort()
def geta(b):
un=0
for i in range(n):
un+=abs(sub[i]-b)
return un
med = sub[n//2]
ans=geta(med)
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
sub = []
for i in range(n):
sub.append(a[i] - i - 1)
sub.sort()
def geta(b):
un=0
for i in range(n):
un+=abs(sub[i]-b)
return un
med = sub[n//2]
ans=10**20
for i in range(med-1,med+1):
num = geta(i)
if ans > num:
ans=num
print(ans) | p03311 |
n = int(eval(input()))
l = list(map(int,input().split()))
m = []
for i in range(n):
m.append(l[i]-i)
b = set(m)
max = 0
index = 0
for i in b:
if max < m.count(i):
max = m.count(i)
index = i
ans = 0
for i in range(n):
ans += abs(l[i]-index-i)
print(ans)
| n = int(eval(input()))
l = list(map(int,input().split()))
m = []
for i in range(n):
m.append(l[i]-i-1)
m.sort()
index = n//2
b = m[index]
ans = 0
for i in range(n):
ans += abs(l[i]-b-i-1)
print(ans)
| p03311 |
N = int(eval(input()))
A = list(map(int, input().split()))
A_dash = []
for i, A_i in enumerate(A):
A_dash.append(A_i - (i))
A_dash.sort()
tmp_ans = sum(A_dash)
ans = 0
left, right = min(A_dash), max(A_dash)
mid = (left+right)//2
ans_left, ans_mid, ans_right = 0, 0, 0
for A_dash_i in A_dash:
ans_left += abs(A_dash_i - (mid-1))
ans_mid += abs(A_dash_i - (mid))
ans_right += abs(A_dash_i - (mid+1))
while not (ans_left >= ans_mid and ans_mid <= ans_right):
mid = (left+right)//2
ans_left, ans_mid, ans_right = 0, 0, 0
for A_dash_i in A_dash:
ans_left += abs(A_dash_i - (mid-1))
ans_mid += abs(A_dash_i - (mid))
ans_right += abs(A_dash_i - (mid+1))
if ans_left < ans_mid:
right = (left+right)//2
else:
left = (left+right)//2
print(ans_mid)
| N = int(eval(input()))
A = list(map(int, input().split()))
A_dash = []
for i, A_i in enumerate(A):
A_dash.append(A_i-(i+1))
A_dash.sort()
med = A_dash[N//2]
ans = 0
for i, A_i in enumerate(A_dash):
ans += abs(A_i - (med))
print(ans) | p03311 |
n = int(eval(input()))
a = list(map(int, input().split()))
def sadness(b):
sad = 0
for i, e in enumerate(a):
i += 1
sad += abs(e - (b + i))
return sad
left, right = -10**9, 10**9 + 1
while right - left > 1:
mid = (left + right) // 2
if sadness(mid) > sadness(mid + 1):
left = mid
else:
right = mid
# for b in range(-20, 20):
# print(b,sadness(b))
print((min(sadness(left), sadness(right))))
| n = int(eval(input()))
a = list(map(int, input().split()))
def sadness(b):
sad = 0
for i, e in enumerate(a):
i += 1
sad += abs(e - (b + i))
return sad
d = []
for i, e in enumerate(a):
i += 1
d.append(e - i)
d.sort()
if len(d) % 2 == 1:
print((sadness(d[len(d) // 2])))
else:
print((min(sadness(d[len(d) // 2]), sadness(d[len(d) // 2 + 1]))))
| p03311 |
def main():
from decimal import Decimal
N = int(eval(input()))
*A, = list(map(Decimal, input().split()))
A = [x - i for i, x in enumerate(A, start=1)]
A.sort()
median = -1
if N % 2 == 1:
median = A[N // 2]
else:
median = (A[N // 2 - 1] + A[N // 2]) / 2 # ->ここで0.5が生じても偶数個足し合わせてintに戻る
ans = sum([abs(x - median) for x in A])
print((int(ans)))
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
A = [x - i for i, x in enumerate(map(int, input().split()), start=1)]
A.sort()
m = A[N // 2] # 個数の偶奇によらず、この点は絶対値の総和を最小にする
ans = sum(abs(x - m) for x in A)
print(ans)
if __name__ == '__main__':
main()
| p03311 |
#!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] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
n = I()
a = LI()
for i in range(n):
a[i] -= i+1
a.sort()
ans = float("inf")
for b in a:
m = 0
for i in range(n):
m += abs(a[i]-b)
ans = min(ans,m)
print(ans)
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
C()
| #!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] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
n = I()
a = LI()
for i in range(n):
a[i] -= i+1
a.sort()
b = sum(a)//n
ans = 0
for i in range(n):
ans += abs(a[i]-b)
ans2 = 0
b += 1
for i in range(n):
ans2 += abs(a[i]-b)
ans3 = 0
b = a[n//2]
for i in range(n):
ans3 += abs(a[i]-b)
print((min(ans,ans2,ans3)))
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
C()
| p03311 |
import sys
import math
N = int(eval(input()))
A = [int(x) for x in input().split()]
A2 = [a - i - 1 for i, a in enumerate(A)]
B = sorted(A2)
i1 = int(N/2) - 1
i2 = int(N/2)
b1 = B[i1]
b2 = B[i2]
def calcSad(A2, b):
sum = 0
for i in A2:
sum += abs(i - b)
return sum
sum = 99999999999999999999999
for b in range(b1, b2+1):
s = calcSad(B, b)
sum = min(sum, s)
print(sum)
sys.exit(0)
| import sys
import math
N = int(eval(input()))
A = [int(x) for x in input().split()]
A2 = [a - i - 1 for i, a in enumerate(A)]
B = sorted(A2)
b = B[int(N/2)]
A3 = [abs(a - b) for a in A2]
print((sum(A3)))
sys.exit(0)
| p03311 |
N=int(eval(input()))
A=list(map(int,input().split()))
minb=min(min(A),max(A)-N)
maxb=max(max(A),min(A)+N)
ans=float('inf')
for b in range(minb,maxb+1):
d=0
for i in range(N):
d+=abs(A[i]-(b+i))
ans=min(ans,d)
print(ans) | N=int(eval(input()))
A=list(map(int,input().split()))
B=[]
for i in range(N):
B.append(A[i]-(i+1))
B.sort()
b=B[N//2]
ans=0
for i in range(N):
ans+=abs(B[i]-b)
print(ans) | p03311 |
# coding: utf-8
import math
n = int(eval(input()))
#x, y = map(int,input().split())
A = list(map(int,input().split()))
ans = 0
B= []
for i in range(n):
B.append(A[i]-(i+1))
B.sort()
if n==1:
m=B[0]
m2=B[0]
else:
m = B[n//2]
m2=B[n//2+1]
tmp1=0
tmp2=0
#print(m,m2)
for i in range(n):
tmp1 += abs(A[i]-(i+1)-m)
tmp2 += abs(A[i]-(i+1)-m2)
print((min(tmp1, tmp2))) | # coding: utf-8
n = int(eval(input()))
A = list(map(int,input().split()))
L=[]
for i in range(n):
L.append(A[i]-(i+1))
L.sort()
#print(L)
if n==1:
b1=L[0]
b2=L[0]
elif n==2:
b1=L[0]
b2=L[1]
else:
b1=L[n//2]
b2=L[n//2-1]
ans=0
cnt1=0
cnt2=0
for i in range(n):
cnt1+=abs(L[i]-b1)
cnt2+=abs(L[i]-b2)
print((min(cnt1,cnt2))) | p03311 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n = int(readline())
a = list(map(int, readline().split()))
a = sorted(x - i for i, x in enumerate(a))
low = (len(a) + 1) // 2 - 1
high = len(a) // 2
print((sum(a[high:]) - sum(a[:low + 1])))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, *a = list(map(int, read().split()))
a = sorted(aa - i for i, aa in enumerate(a))
print((sum(a[n // 2:]) - sum(a[:(n + 1) // 2])))
| p03311 |
def main(n,a):
a=sorted([a[i]-i for i in range(n)])
m0=a[n//2]
m1=a[n//2-1]
ans0,ans1=0,0
for i in range(n):
ans0+=abs(a[i]-m0)
ans1+=abs(a[i]-m1)
print((min(ans0,ans1)))
if __name__=='__main__':
import sys
input = sys.stdin.readline
n=int(eval(input()))
a=list(map(int,input().split()))
main(n,a)
| n=int(eval(input()))
a=list(map(int,input().split()))
a=[x-i-1 for i,x in enumerate(a)]
a.sort()
b=a[n//2]
print((sum([abs(x-b) for x in a]))) | p03311 |
n=int(eval(input()))
l=list(map(int,input().split()))
l=[x-i-1 for i,x in enumerate(l)]
ans=10**9
for i in l:
cal=[abs(x-i) for x in l]
ans=min(ans,sum(cal))
print(ans) | n=int(eval(input()))
l=list(map(int,input().split()))
l=sorted([x-i-1 for i,x in enumerate(l)])
x=l[n//2]
print((sum([abs(i-x) for i in l]))) | p03311 |
#coding:utf-8
n = int(eval(input()))
nums = sorted([num - i for i, num in enumerate(list(map(int,input().split())), 1)])
sums = [None for i in range(n)]
sums[0] = nums[0]
allv = sum(nums)
minv = nums[0] * (2 - n) - 2 * sums[0] + allv
for i in range(n-1):
sums[i+1] = sums[i] + nums[i+1]
for b in range(nums[i], nums[i+1]+1):
p = b * (2*(i+1) - n) -2 * sums[i] + allv
minv = min(minv,p)
print(minv) | #coding:utf-8
n = int(eval(input()))
nums = sorted([num - i for i, num in enumerate(list(map(int,input().split())), 1)])
sums = [None for i in range(n)]
sums[0] = nums[0]
allv = sum(nums)
minv = nums[0] * (2 - n) - 2 * sums[0] + allv
for i in range(n-1):
sums[i+1] = sums[i] + nums[i+1]
p = nums[i] * (2*(i+1) - n) -2 * sums[i] + allv
minv = min(minv,p)
print(minv)
| p03311 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
a = list(map(int, input().rstrip('\n').split()))
for i in range(n):
a[i] -= i + 1
a.sort()
t = a[n // 2]
mt = 0
for v in a:
mt += abs(t - v)
print(mt)
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
a = list(map(int, readline().split()))
for i in range(n):
a[i] -= i + 1
a.sort()
t = 0
for v in a:
t += abs(a[n // 2] - v)
print(t)
if __name__ == '__main__':
solve()
| p03311 |
N = int(eval(input()))
src = list(map(int,input().split()))
mem = [a-i-1 for i,a in enumerate(src)]
center = sorted(mem)[N//2]
ans = 0
for a in mem:
ans += abs(a - center)
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
B = [a-i for i,a in enumerate(A)]
B.sort()
m = B[N//2]
ans = 0
for b in B:
ans += abs(m-b)
print(ans) | p03311 |
a = int(eval(input()))
b = list(map(int,input().split()))
for i in range(a):
b[i] -= i + 1
b.sort()
s = 0
co = 0
ss = 0
coco = 0
cococo = 0
summ = 0
su = 0
bb = 0
for i in range(a):
if b[i] < 0:
co += 1
elif b[i] > 0:
coco += 1
else:
cococo += 1
su += abs(b[i])
if co > coco:
while su != 0:
bb = 0
for i in range(a):
b[i] += 1
bb += abs(b[i])
if bb > su:
print(su)
break
su = bb
bb = 0
elif coco >= co:
while su != 0:
for i in range(a):
b[i] -= 1
bb += abs(b[i])
if bb > su:
print(su)
break
su = bb
bb = 0
if su == 0:
print((0)) | a = int(eval(input()))
b = list(map(int,input().split()))
for i in range(a):
b[i] -= i + 1
b.sort()
su = 0
c = b[(a - 1) // 2]
for i in range(a):
su += abs(b[i] - c)
print(su) | p03311 |
import math
N=int(eval(input()))
A=list(map(int,input().split()))
B=[A[i]-i for i in range(N)]
B.sort()
temp=0
if N%2==0:
ans = B[N//2]
ans2= B[N//2 -1]
temp=0
for j in range(N):
temp+= abs(B[j] - ans)
temp2=0
for j in range(N):
temp2+= abs(B[j] - ans2)
ans= min(temp,temp2)
else:
ans = B[N//2]
temp=0
for j in range(N):
temp+= abs(B[j] - ans )
ans=temp
print(ans)
| import math
N=int(eval(input()))
A=list(map(int,input().split()))
B=[A[i]-(i+1) for i in range(N)]
B.sort()
temp=0
if N%2==0:
ans = B[N//2]
ans2= B[N//2 -1]
temp=0
for j in range(N):
temp+= abs(B[j] - ans)
temp2=0
for j in range(N):
temp2+= abs(B[j] - ans2)
ans= min(temp,temp2)
else:
ans = B[N//2]
temp=0
for j in range(N):
temp+= abs(B[j] - ans )
ans=temp
print(ans)
| p03311 |
def func(A,b):
s=0
for i in range(len(A)):
s+=abs(A[i]-(b+i))
return s
N=int(eval(input()))
A=[int(i) for i in input().split(' ')]
MIN=None
for b in range(min(A[0],A[-1]-len(A)),max(A[-1],A[0]+len(A))):
if MIN==None:
MIN=func(A,b)
elif MIN>func(A,b):
MIN=func(A,b)
print(MIN) | N=int(eval(input()))
A=[int(i) for i in input().split(' ')]
for i in range(len(A)):
A[i]-=i+1
A.sort()
if len(A)%2==1:
b=A[(len(A)-1)//2]
else:
b=A[(len(A))//2-1]
s=0
for i in range(len(A)):
s+=abs(A[i]-b)
print(s) | p03311 |
from statistics import median
n=int(eval(input()))
a=list(map(int,input().split()))
mid=0
l=[]
for i in range(n):
l+=[a[i]-i-1]
mid=median(l)
ans=0
for i in range(n):
ans+=abs(a[i]-(mid+i+1))
print((int(ans))) | from statistics import median
n=int(eval(input()))
a=list(map(int,input().split()))
mid=0
l=[]
for i in range(n):
l+=[a[i]-i-1]
mid=median(l) if n%2!=0 else sorted(l)[n//2]
ans=0
for i in range(n):
ans+=abs(a[i]-(mid+i+1))
print((int(ans)))
| p03311 |
N = int(eval(input()))
A = list(map(int,input().split()))
answer = 0
r = 0
flag = 0
gear = 0
for i in range(N) :
A[i] = A[i]-(i+1)
if A[i] <= 0 :
r += 1
answer += abs(A[i])
if r == N :
gear += 1
while flag == 0 :
p = 0
q = 0
if gear == 0 :
for j in range(N) :
A[j] = A[j]-1
if A[j] <= 0 :
q += 1
p += abs(A[j])
else :
for j in range(N) :
A[j] = A[j]+1
if A[j] >= 0 :
q += 1
p += abs(A[j])
if p < answer :
answer = p
if q == N :
flag += 1
print(answer)
| N = int(eval(input()))
A = list(map(int,input().split()))
answer = 0
for i in range(N) :
A[i]-= i+1
A = sorted(A)
if N % 2 != 0 :
a = A[N//2]
else :
a = (A[N//2]+A[N//2-1])//2
for j in range(N) :
A[j] -= a
answer += abs(A[j])
print(answer)
| p03311 |
N = int(eval(input()))
A = list(map(int,input().split()))
B = []
for i in range(N):
B.append(A[i]-i-1)
B.sort()
med = N // 2
grief = 0
for i in range(N):
grief += abs(B[i]-B[med])
print((str(grief))) | N = int(eval(input()))
A = list(map(int,input().split()))
B = []
for i in range(N):
A[i] -= i+1
A.sort()
#for i in range(N):
# B.append(A[i]-i-1)
#B.sort()
med = N // 2
grief = 0
for i in range(N):
grief += abs(A[i]-A[med])
#for i in range(N):
# grief += abs(B[i]-B[med])
print((str(grief))) | p03311 |
import statistics
N = int(eval(input()))
A = list(map(int, input().split()))
A = [a - i for i, a in enumerate(A, 1)]
b = statistics.median(A)
ans = int(sum([abs(a-b) for a in A]))
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted([a - i for i, a in enumerate(A, 1)])
b = A[(N - 1)//2]
ans = sum([abs(a-b) for a in A])
print(ans) | p03311 |
N = int(eval(input()))
A = list(map(int,input().split()))
L = []
for i in range(N):
L.append(A[i]-i-1)
L.sort()
k = 0
if (N%2 == 0):
k = (L[(N//2)-1]+L[N//2])/2
else:
k = L[N//2]
ans = 0
for i in range(N):
ans += abs(L[i]-k)
print((int(ans))) | N = int(eval(input()))
A = list(map(int,input().split()))
L = [0]*N
for i in range(N):
L[i] = A[i]-i-1
L.sort()
S = 0
if len(L)%2 != 0:
k = L[len(L)//2]
for i in range(len(L)):
S += abs(L[i]-k)
else:
k = (L[len(L)//2-1]+L[len(L)//2])//2
for i in range(len(L)):
S += abs(L[i]-k)
print(S)
| p03311 |
n,a,b=map(int,input().split())
s=input()
ans=list('No'for _ in range(n))
c=a+b
for i in range(n):
if ans[:i].count('Yes')<c:
if s[i]=='a':
ans[i]='Yes'
if s[i]=='b' and s[:i].count('b')<b:
ans[i]='Yes'
print(*ans,sep='\n')
| n,a,b=map(int,input().split())
s=input()
ans=list('No'for _ in range(n))
c=a+b
countY=0
countb=0
for i in range(n):
if countY<c:
if s[i]=='a':
ans[i]='Yes'
countY+=1
if s[i]=='b' and countb<b:
ans[i]='Yes'
countY+=1
countb+=1
print(*ans,sep='\n')
| p03971 |
from sys import stdin
from math import ceil, floor
n, a, b = [int(x) for x in stdin.readline().rstrip().split()]
s = list(stdin.readline().rstrip())
d = 0
e = 0
for i in range(n):
if d < a + b and s[i] == "a":
print("Yes")
d += 1
elif d < a + b and e < b and s[i] == "b":
print("Yes")
d += 1
e += 1
else:
print("No") | from sys import stdin
from math import ceil, floor
n,a,b = [int(x) for x in stdin.readline().rstrip().split()]
s=list(stdin.readline().rstrip())
c=a+b
d=e=0
for i in range(n):
if d<c and s[i]=="a":
print("Yes")
d+=1
elif d<c and e<b and s[i]=="b":
print("Yes")
d+=1
e+=1
else:
print("No") | p03971 |
n,a,b = map(int,input().split())
s = input()
ans = ["0"]*n
bcnt = 0
for i in range(n):
if s[i] == "a":
if ans.count("Yes") < a+b:
ans[i] = "Yes"
else:
ans[i] = "No"
elif s[i] == "b":
bcnt += 1
if ans.count("Yes") < a+b and bcnt <= b:
ans[i] = "Yes"
else:
ans[i] = "No"
else:
ans[i] = "No"
print(*ans,sep='\n')
| n,a,b = map(int,input().split())
s = input()
ans = ["0"]*n
acnt = 0
bcnt = 0
for i in range(n):
if s[i] == "a":
if acnt < a+b:
acnt += 1
ans[i] = "Yes"
else:
ans[i] = "No"
elif s[i] == "b":
bcnt += 1
if acnt < a+b and bcnt <= b:
acnt += 1
ans[i] = "Yes"
else:
ans[i] = "No"
else:
ans[i] = "No"
print(*ans,sep='\n')
| p03971 |
#!/usr/bin/env python3
import sys
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# 要素xが属するグループの根を返す
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve(N: int, M: int, A: "List[int]", B: "List[int]"):
answer = [(N*(N-1))//2]
uf = UnionFind(N)
for i in range(M-1,0,-1):
if uf.same(A[i]-1,B[i]-1):
answer.append(answer[-1])
continue
else:
answer.append(answer[-1]-uf.size(A[i]-1)*uf.size(B[i]-1))
uf.union(A[i]-1,B[i]-1)
for aa in answer[::-1]:
print(aa)
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
A = [int()] * (M) # type: "List[int]"
B = [int()] * (M) # type: "List[int]"
for i in range(M):
A[i] = int(next(tokens))
B[i] = int(next(tokens))
solve(N, M, A, B)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
input = sys.stdin.readline
def INT(): return int(eval(input()))
def MAP(): return list(map(int,input().split()))
def LI(): return 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())
def main():
N,M=MAP()
edges = []
for _ in range(M):
a,b = MAP()
edges.append((a-1,b-1))
# グループ数C2が
answer = [0]*M
answer[M-1] = N*(N-1)//2
uf = UnionFind(N)
for i in range(M-1,0,-1):
a,b = edges[i]
if uf.same(a,b):
answer[i-1] = answer[i]
continue
answer[i-1] = answer[i]-uf.size(a)*uf.size(b)
uf.union(a,b)
for i in range(M):
print((answer[i]))
return
if __name__ == '__main__':
main()
| p03108 |
class UnionFind(object):
def __init__(self, n):
self.par = [-1] * n
def find(self, x):
if self.par[x] < 0:
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 False
else:
if self.par[x] > self.par[y]:
x, y = y, x
self.par[x] += self.par[y]
self.par[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.par[self.find(x)]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.par) if x < 0]
def group_count(self):
return len(self.roots())
N, M = list(map(int, input().split()))
uf = UnionFind(N)
# 最後は全部つながってない
# うしろから順番につなぐ
edges = []
for _ in range(M):
ai, bi = list(map(int, input().split()))
ai, bi = ai - 1, bi - 1
edges.append((ai, bi))
edges.reverse()
ans = [N * (N - 1) // 2]
for (ai, bi) in edges:
u1 = uf.group_count()
if not uf.same(ai, bi):
ans.append(ans[-1] - uf.size(ai) * uf.size(bi))
else:
ans.append(ans[-1])
uf.unite(ai, bi)
for a in ans[::-1][1:]:
print(a) | class UnionFind(object):
def __init__(self, n):
self.par = [-1] * n
def find(self, x):
if self.par[x] < 0:
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 False
else:
if self.par[x] > self.par[y]:
x, y = y, x
self.par[x] += self.par[y]
self.par[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.par[self.find(x)]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.par) if x < 0]
def group_count(self):
return len(self.roots())
N, M = list(map(int, input().split()))
uf = UnionFind(N)
# 最後は全部つながってない
# うしろから順番につなぐ
edges = []
for _ in range(M):
ai, bi = list(map(int, input().split()))
ai, bi = ai - 1, bi - 1
edges.append((ai, bi))
edges.reverse()
ans = [N * (N - 1) // 2]
for (ai, bi) in edges:
if not uf.same(ai, bi):
ans.append(ans[-1] - uf.size(ai) * uf.size(bi))
else:
ans.append(ans[-1])
uf.unite(ai, bi)
for a in ans[::-1][1:]:
print(a) | p03108 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
AB = [list([int(x)-1 for x in input().split()]) for _ in range(M)][::-1]
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 [-x for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
uf = UnionFind(N)
ans = []
for a, b in AB:
roots = uf.roots()
ans.append(sum([i*(N-i) for i in roots]))
uf.union(a, b)
for a in ans[::-1]:
print((a//2)) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
AB = [list([int(x)-1 for x in input().split()]) for _ in range(M)][::-1]
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 [-x for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
uf = UnionFind(N)
ans = []
cnt = N*(N-1)//2
for a, b in AB:
ans.append(cnt)
if uf.same(a, b):
continue
cnt -= uf.size(a)*uf.size(b)
uf.union(a, b)
for a in ans[::-1]:
print(a) | p03108 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
AB = [list([int(x)-1 for x in input().split()]) for _ in range(M)][::-1]
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 [-x for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
uf = UnionFind(N)
ans = []
cnt = N*(N-1)//2
for a, b in AB:
ans.append(cnt)
if uf.same(a, b):
continue
cnt -= uf.size(a)*uf.size(b)
uf.union(a, b)
for a in ans[::-1]:
print(a) | 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()}
uf = UnionFind(N)
AB = [list(mapint()) for _ in range(M)][::-1]
ans = [0]*M
ans[0] = N*(N-1)//2
groups = N*(N-1)//2
for i in range(M-1):
a, b = AB[i]
if not uf.same(a-1, b-1):
a_size = uf.size(a-1)
b_size = uf.size(b-1)
uf.union(a-1, b-1)
groups -= a_size*b_size
ans[i+1] = groups
for a in ans[::-1]:
print(a) | p03108 |
n, m = [int(i) for i in input().split() ]
br = list([])
for i in range(m):
x = [int(i) for i in input().split() ]
br.append(x)
inc = int((n*(n-1))/2)
can = [set([i]) for i in range(n+1)]
ans = list([inc])
for b in br[:0:-1] :
tmp = 0
#new0 = (can[b[1]]|{b[1]}) - can[b[0]]
#new1 = (can[b[0]]|{b[0]}) - can[b[1]]
new0 = can[b[1]] - can[b[0]]
new1 = can[b[0]] - can[b[1]]
tmp += (len(new0) + len(new1))
can[b[0]] = can[b[0]] | new0
for x in new0-{b[1]}:
#tmp += len(can[b[0]]-can[x])
#can[x] = can[x]|can[b[0]]
z = can[b[0]]-can[x]
tmp += len(z)
can[x] |= z
can[b[1]] = can[b[1]] | new1
for x in new1-{b[0]}:
#tmp += len(can[b[1]]-can[x])
#can[x] = can[x]|can[b[1]]
z = can[b[1]]-can[x]
tmp += len(z)
can[x] |= z
inc -= int(tmp/2)
ans.append(inc)
if inc == 0:
break
while len(ans) < m:
ans.append(0)
for i in ans[::-1]:
print(i) | n, m = [int(i) for i in input().split() ]
br = list([])
for i in range(m):
x = [int(i) for i in input().split() ]
br.append(x)
inc = int((n*(n-1))/2)
can = [set([i]) for i in range(n+1)]
ans = list([inc])
for b in br[:0:-1] :
if b[1] not in can[b[0]]:
inc -= len(can[b[0]]) * len(can[b[1]])
z = can[b[0]]|can[b[1]]
for x in z:
can[x] = z
ans.append(inc)
if inc == 0:
break
while len(ans) < m:
ans.append(0)
for i in ans[::-1]:
print(i) | p03108 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
self.size = [1] * (n + 1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.find(self.par[x])
def sizeCheck(self, x):
x = self.find(x)
return self.size[x]
def sameCheck(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
n, m = map(int, input().split())
bridge = []
for i in range(m):
bridge.append(list(map(int, input().split())))
ans = [int(n * (n - 1) / 2)]
uf = UnionFind(n)
index = m - 1
while index > 0:
li = bridge[index]
if uf.sameCheck(li[0], li[1]):
ans = [ans[0]] + ans
index -= 1
else:
s0 = uf.sizeCheck(li[0])
s1 = uf.sizeCheck(li[1])
uf.union(li[0], li[1])
ans = [ans[0] - s0 * s1] + ans
index -= 1
print(*ans, sep = "\n")
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
self.size = [1] * (n + 1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.find(self.par[x])
def sizeCheck(self, x):
x = self.find(x)
return self.size[x]
def sameCheck(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
n, m = map(int, input().split())
bridge = []
for i in range(m):
bridge.append(list(map(int, input().split())))
ans = [0] * m
ans[m - 1] = int(n * (n - 1) / 2)
uf = UnionFind(n)
index = m - 1
while index > 0:
li = bridge[index]
if uf.sameCheck(li[0], li[1]):
ans[index - 1] = ans[index]
index -= 1
else:
s0 = uf.sizeCheck(li[0])
s1 = uf.sizeCheck(li[1])
uf.union(li[0], li[1])
ans[index - 1] = ans[index] - s0 * s1
index -= 1
print(*ans, sep = "\n")
| p03108 |
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)
n,m = list(map(int,input().split()))
Bridge = [list(map(int,input().split())) for i in range(m)]
uf = UnionFind(n)
Inconvenience = [n*(n-1)//2]
for b in reversed(Bridge):
if not uf.same(b[0]-1,b[1]-1):
Inconvenience += [Inconvenience[-1]-uf.size(b[0]-1)*uf.size(b[1]-1)]
uf.union(b[0]-1,b[1]-1)
else:
Inconvenience += [Inconvenience[-1]]
Inconvenience.pop()
for i in reversed(Inconvenience):
print(i) | 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)]
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
bridge = [tuple(map(int, input().split())) for _ in range(M)]
uf = UnionFind(N)
inc = N * (N - 1) // 2
ans = [inc]
for a, b in reversed(bridge):
if uf.find(a - 1) != uf.find(b - 1):
la = uf.len(a - 1)
lb = uf.len(b - 1)
uf.unite(a - 1, b - 1)
lab = uf.len(a - 1)
inc += la * (la - 1) // 2 + lb * (lb - 1) // 2 - lab * (lab - 1) // 2
ans.append(inc)
print(('\n'.join(map(str, ans[:-1][::-1])))) | p03108 |
# ABC120D - Decayed Bridges
class UnionFind:
__slots__ = ["size", "first_idx", "parent", "rank"]
def __init__(self, size: int, first_idx: int = 0) -> None:
self.size = size
self.first_idx = first_idx
self.parent = list(range(size + first_idx))
self.rank = [0] * (size + first_idx)
def find(self, x: int) -> int:
"""Find the group (root) of vertex x"""
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are in the same group or not."""
return self.find(x) == self.find(y)
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y."""
x, y = self.find(x), self.find(y)
if x == y:
return
# unite a smaller one to a bigger one in order to balance trees
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
@property
def groups(self) -> int:
"""Return the number of groups."""
return len({self.find(x) for x in range(self.first_idx, self.size + self.first_idx)})
# the below is a bit faster because it doesn't reconnect
# return sum(i == j for i, j in enumerate(self.parent[self.first_idx:], self.first_idx))
def count_unreachable_islands(size: int, tree: UnionFind) -> int:
reachable_count = sum(tree.is_same(i, j) for i in range(1, size + 1) for j in range(i + 1, size + 1))
return size * (size - 1) // 2 - reachable_count
def main():
N, M, *AB = list(map(int, open(0).read().split()))
uf = UnionFind(N, 1)
ans = []
for a, b in zip(*[iter(AB[::-1])] * 2):
ans.append(count_unreachable_islands(N, uf))
uf.unite(a, b)
print(("\n".join(map(str, ans[::-1]))))
if __name__ == "__main__":
main()
| # ABC120D - Decayed Bridges
class UnionFind:
__slots__ = ["size", "first_idx", "parents"]
def __init__(self, size: int, first_index: int = 0) -> None:
self.size = size
self.first_idx = first_index
self.parents = [-1] * (size + first_index)
def find(self, x: int) -> int:
"""Find the group (root) of vertex x"""
if self.parents[x] < 0:
return x
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def is_same(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are in the same group or not."""
return self.find(x) == self.find(y)
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y."""
x, y = self.find(x), self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def get_size(self, x: int) -> int:
"""Get the size of the group vertex x belongs"""
return self.parents[self.find(x)]
@property
def groups(self) -> int:
"""Return the number of groups."""
return len({self.find(x) for x in range(self.first_idx, self.size + self.first_idx)})
def main():
N, M, *AB = list(map(int, open(0).read().split()))
uf = UnionFind(N, 1)
current_unreachable = N * (N - 1) // 2
ans = []
for a, b in zip(*[iter(AB[::-1])] * 2):
ans.append(current_unreachable)
if not uf.is_same(a, b):
current_unreachable -= uf.get_size(a) * uf.get_size(b)
uf.unite(a, b)
print(("\n".join(map(str, ans[::-1]))))
if __name__ == "__main__":
main()
| p03108 |
n, m = list(map(int, input().split()))
ab = []
for _ in range(m):
a, b = list(map(int, input().split()))
ab.append((a-1, b-1))
uni = [set([i]) for i in range(n)]
start = (n * (n - 1)) // 2
blis = [start]
for a, b in ab[::-1]:
ap = a
bp = b
while isinstance(uni[ap], int):
_ap = uni[ap]
uni[ap] = _ap
ap = _ap
while isinstance(uni[bp], int):
_bp = uni[bp]
uni[bp] = _bp
bp = _bp
_ap = uni[ap]
_bp = uni[bp]
if _ap.intersection(_bp) == set():
start -= len(_ap) * len(_bp)
if ap != bp:
uni[ap] = uni[ap].union(uni[bp])
uni[bp] = ap
blis.append(start)
for p in blis[::-1][1:]:
print(p)
| def comb(n):
return n*(n+1)//2
class UnionFind:
def __init__(self, N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
self.size = [1] * N
self.connection = 0
def root(self, a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self, a, b):
return self.root(a) == self.root(b)
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return
self.connection -= (comb(self.size[ra]) + comb(self.size[rb]))
self.connection += comb(self.size[ra] + self.size[rb])
if self.rank[ra] < self.rank[rb]:
self.size[rb] += self.size[ra]
self.parent[ra] = rb
else:
self.size[ra] += self.size[rb]
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]:
self.rank[ra] += 1
self.count += 1
n, m = list(map(int, input().split()))
uni = UnionFind(n)
remain = [comb(n-1)]
abl = []
for _ in range(m):
a, b = list(map(int, input().split()))
abl.append((a-1, b-1))
for a, b in abl[::-1]:
uni.unite(a, b)
remain.append(remain[0] - uni.connection)
for r in reversed(remain[:-1]):
print(r) | p03108 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
class UnionFind():
def __init__(self, n):
self.n = n
# parents[i]: 要素iの親要素の番号
# 要素iが根の場合、parents[i] = -(そのグループの要素数)
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
# 要素xが属するグループの要素数を返す
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
# 要素xが属するグループに属する要素をリストで返す
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
# 全ての根の要素をリストで返す
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
# グループの数を返す
def group_count(self):
return len(self.roots())
# 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
# print()での表示用
# all_group_members()をprintする
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = MAP()
L = [LIST() for i in range(M)]
graph = defaultdict(list)
tree = UnionFind(N)
group = tree.group_count()
# print(group)
d = group * (group - 1) // 2
# ans = [0] * M
ans = []
ans.append(d)
for a, b in L[::-1]:
e = deepcopy(d)
tree.union(a-1, b-1)
r = tree.all_group_members()
# print(r)
for k, v in r.items():
if len(v) > 1:
e -= len(v) * (len(v) - 1) // 2
ans.append(e)
ans = ans[:-1]
ans = ans[::-1]
print(*ans, sep="\n")
# tree[b-1].append(a-1)
# group = tree.group_count()
# print(group)
# print(group * (group - 1) // 2)
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
class UnionFind():
def __init__(self, n):
self.n = n
# parents[i]: 要素iの親要素の番号
# 要素iが根の場合、parents[i] = -(そのグループの要素数)
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
# 要素xが属するグループの要素数を返す
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
# 要素xが属するグループに属する要素をリストで返す
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
# 全ての根の要素をリストで返す
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
# グループの数を返す
def group_count(self):
return len(self.roots())
# 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
# print()での表示用
# all_group_members()をprintする
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = MAP()
L = [LIST() for i in range(M)]
graph = defaultdict(list)
tree = UnionFind(N)
d = N * (N - 1) // 2
# ans = [0] * M
ans = []
ans.append(d)
for a, b in L[::-1]:
# e = deepcopy(d)
if not tree.same(a-1, b-1):
d -= tree.size(a-1) * tree.size(b-1)
tree.union(a-1, b-1)
ans.append(d)
ans = ans[:-1]
ans = ans[::-1]
print(*ans, sep="\n")
# tree[b-1].append(a-1)
# group = tree.group_count()
# print(group)
# print(group * (group - 1) // 2)
| p03108 |
#!/usr/bin/env python3
import sys
class UnionFind():
def __init__(self, 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 main():
N, M = map(int, input().split())
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = map(int, input().split())
ans = [0] * M
ans[-1] = N * (N-1) // 2
# 逆順に橋が出来ると不便さが変わるか調べる
uf = UnionFind(N)
for i in range(M-1):
# aとbが連結か調べる
a, b = A[M-1-i]-1, B[M-1-i]-1
if uf.find(a) == uf.find(b):
ans[M-i-2] = ans[M-i-1]
else:
ans[M-i-2] = ans[M-i-1] - abs(uf.parents[uf.find(a)]) * abs(uf.parents[uf.find(b)])
uf.union(a, b)
[print(a) for a in ans]
if __name__ == '__main__':
main()
| class UnionFind():
def __init__(self, n):
self.parents = list(range(n))
self.size = [1] * n
def find(self, x):
if self.parents[x] == x:
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:
if self.size[x] < self.size[y]:
x, y = y, x
self.parents[y] = x
self.size[x] += self.size[y]
N, M = map(int, input().split())
ab = [list(map(lambda x: int(x)-1, input().split())) for _ in range(M)]
uf = UnionFind(N)
now = N*(N-1)//2
ans = [now]
for i in range(M-1):
a = ab[M - i - 1][0]
b = ab[M - i - 1][1]
pa = uf.find(a)
pb = uf.find(b)
if pa != pb:
now -= uf.size[pa] * uf.size[pb]
uf.union(a, b)
ans.append(now)
[print(a) for a in ans[::-1]]
| p03108 |
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 group_count(self):
temp = [(-self.parents[i])*(-self.parents[i]-1)//2 for i in range(len(self.parents)) if self.parents[i] < -1]
a = sum(temp)
if a == init:
end = True
return a
else:
return a
N,M = (int(x) for x in input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
uf = UnionFind(N)
init = N*(N-1)//2
ans = []
temp = []
end = False
b = 0
for i in range(1, M+1):
if b == init:
ans.append(0)
else:
uf.union((AB[-i][0]-1), (AB[-i][1]-1))
b = uf.group_count()
ans.append(init-b)
for i in range(1, M):
print((ans[-i-1]))
print(init) | 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 0
if self.parents[x] > self.parents[y]:
x, y = y, x
a = self.parents[x]
b = self.parents[y]
self.parents[x] += self.parents[y]
self.parents[y] = x
return(a*b)
N,M = (int(x) for x in input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
uf = UnionFind(N)
init = N*(N-1)//2
ans = []
temp = init
for i in range(1, M+1):
temp -= uf.union((AB[-i][0]-1), (AB[-i][1]-1))
ans.append(temp)
for i in range(1, M):
print((ans[-i-1]))
print(init) | p03108 |
n,m=list(map(int,input().split()))
bridge=[[] for i in range(m)]
iland=[[i+1] for i in range(n)]
for i in range(m):
bridge[i]=list(map(int,input().split()))
ans=[0 for i in range(m+1)]
ans[0]=int((n-1)*n/2)
k=1
for i in reversed(bridge):
ans[k]=ans[k-1]
for j in range(len(iland)):
if i[0] in iland[j]:
temp=j
break
for j in range(len(iland)):
if i[1] in iland[j]:
if temp!=j:
ans[k]=ans[k-1]-len(iland[j])*len(iland[temp])
iland[temp].extend(iland[j])
del iland[j]
break
if ans[k]==0:
ans[k:]=[0 for l in range(m-k)]
break
k+=1
for i in range(m):
print((ans[m-1-i])) | n,m=list(map(int,input().split()))
bridge=[[] for i in range(m)]
leader=[i for i in range(n+1)]
member=[1 for i in range(n+1)]
for i in range(m):
bridge[i]=list(map(int,input().split()))
ans=[0 for i in range(m+1)]
ans[0]=int((n-1)*n/2)
k=1
for i in reversed(bridge):
le0=leader[i[0]]
le1=leader[i[1]]
while le0!=leader[le0]:
le0=leader[le0]
leader[i[0]]=le0
while le1!=leader[le1]:
le1=leader[le1]
leader[i[1]]=le1
if le0!=le1:
ans[k]=ans[k-1]-member[le0]*member[le1]
if member[le0]>=member[le1]:
member[le0]+=member[le1]
leader[le1]=le0
else:
member[le1]+=member[le0]
leader[le0]=le1
else:
ans[k]=ans[k-1]
if ans[k]==0:
ans[k:]=[0 for l in range(m-k)]
break
k+=1
for i in range(m):
print((ans[m-1-i])) | p03108 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = list(map(int, input().split()))
root = []
for i in range(M):
a, b = list(map(int, input().split()))
root.append((a-1,b-1))
uf = UnionFind(N)
ans_list = []
ans = N*(N-1)//2
ans_list.append(ans)
for a, b in reversed(root[1:]):
if uf.same(a,b):
ans_list.append(ans)
continue
a_nakama = len(uf.members(a))
b_nakama = len(uf.members(b))
ans = ans - a_nakama*b_nakama
uf.union(a,b)
ans_list.append(ans)
for ans in reversed(ans_list):
print(ans)
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = list(map(int, input().split()))
root = []
for i in range(M):
a, b = list(map(int, input().split()))
root.append((a-1,b-1))
uf = UnionFind(N)
ans_list = []
ans = N*(N-1)//2
ans_list.append(ans)
for a, b in reversed(root[1:]):
if uf.same(a,b):
ans_list.append(ans)
continue
a_nakama = uf.size(a)
b_nakama = uf.size(b)
ans = ans - a_nakama*b_nakama
uf.union(a,b)
ans_list.append(ans)
for ans in reversed(ans_list):
print(ans)
| p03108 |
import sys
from heapq import heappush, heappop
def input(): return sys.stdin.readline().strip()
class UnionFind():
"""
https://note.nkmk.me/python-union-find/
DFSの上位互換と考えて良い
２要素x, yがpath-connectedかどうかをlogオーダーで判定する（螺旋本の14.1節参照）
さらに連結成分の要素数がO(1)で取得可能なように改造してある
"""
def __init__(self, n):
"""
要素数をnとして、各ノードを0,1,...,(n-1)の番号で管理する
parentsは各ノードの属する木の根を表す
ただし根ノードのparentには(その木のノード数)*(-1)を格納する
"""
self.n = n
self.parents = [-1] * n
def find(self, x):
"""
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, yのそれぞれ属する木Tx, Tyの根同士を繋ぐ
このとき木の要素数が小さい方を大きい方に繋ぐ（rankではなくsizeを用いる）
"""
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):
"""
xの属する木の要素数を返す
根の親を要素数の(-1)倍で定めておいたおかげでO(1)で取得可能
"""
return -self.parents[self.find(x)]
def same(self, x, y):
"""
xとyがpath-connectedかを判定する
"""
return self.find(x) == self.find(y)
def members(self, x):
"""
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()))
bridge = []
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
bridge.append((a, b))
# unionfindは辺の追加しかできないので、後ろからやっていく
tree = UnionFind(N)
inconv = []
for _ in range(M):
pair = 0
for v in tree.roots():
num = tree.size(v)
pair += (N - num) * num
inconv.append(pair // 2)
a, b = bridge.pop()
tree.union(a, b)
for _ in range(M):
x = inconv.pop()
print(x)
if __name__ == "__main__":
main()
| import sys
def input(): return sys.stdin.readline().strip()
class UnionFind():
"""
https://note.nkmk.me/python-union-find/
DFSの上位互換と考えて良い
２要素x, yがpath-connectedかどうかをlogオーダーで判定する（螺旋本の14.1節参照）
さらに連結成分の要素数がO(1)で取得可能なように改造してある
"""
def __init__(self, n):
"""
要素数をnとして、各ノードを0,1,...,(n-1)の番号で管理する
parentsは各ノードの属する木の根を表す
ただし根ノードのparentには(その木のノード数)*(-1)を格納する
"""
self.n = n
self.parents = [-1] * n
def find(self, x):
"""
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, yのそれぞれ属する木Tx, Tyの根同士を繋ぐ
このとき木の要素数が小さい方を大きい方に繋ぐ（rankではなくsizeを用いる）
"""
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):
"""
xの属する木の要素数を返す
根の親を要素数の(-1)倍で定めておいたおかげでO(1)で取得可能
"""
return -self.parents[self.find(x)]
def same(self, x, y):
"""
xとyがpath-connectedかを判定する
"""
return self.find(x) == self.find(y)
def members(self, x):
"""
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()))
bridge = []
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
bridge.append((a, b))
# unionfindは辺の追加しかできないので、後ろからやっていく
tree = UnionFind(N)
inconv = [N * (N - 1) // 2]
for _ in range(M - 1):
a, b = bridge.pop()
if tree.same(a, b):
inconv.append(inconv[-1])
else:
num_a = tree.size(a)
num_b = tree.size(b)
inconv.append(inconv[-1] - num_a * num_b)
tree.union(a, b)
for _ in range(M):
x = inconv.pop()
print(x)
if __name__ == "__main__":
main()
| p03108 |
#16:50
n,m = list(map(int,input().split()))
a = []
for _ in range(m):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
a.append([x,y])
a.reverse()
scr = n * (n-1) // 2
pre = [-1 for _ in range(n)]
cnt = [1 for _ in range(n)]
ans = []
for i in range(m):
ans.append(scr)
X,Y = a[i]
while pre[X] != -1:
X = pre[X]
while pre[Y] != -1:
Y = pre[Y]
x,y = min(X,Y), max(X,Y)
if x != y:
scr -= cnt[x] * cnt[y]
pre[y] = x
cnt[x] = cnt[x] + cnt[y]
#print(pre)
#print(cnt)
ans.reverse()
for i in range(m):
print((ans[i])) | #16:50
n,m = list(map(int,input().split()))
a = []
for _ in range(m):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
a.append([x,y])
a.reverse()
scr = n * (n-1) // 2
pre = [-1 for _ in range(n)]
cnt = [1 for _ in range(n)]
ans = []
for i in range(m):
ans.append(scr)
X,Y = a[i]
while pre[X] != -1:
X = pre[X]
while pre[Y] != -1:
Y = pre[Y]
x,y = min(X,Y), max(X,Y)
if x != y:
scr -= cnt[x] * cnt[y]
pre[y] = x
cnt[x] = cnt[x] + cnt[y]
#print(pre)
#print(cnt)
ans.reverse()
for z in ans:
print(z) | p03108 |
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 cnt(self):
return sum([uf.size(i)*(uf.size(i)-1)//2 for i in self.roots()])
######
N,M = list(map(int,input().split()))
ansal = int(N*(N-1)/2)
uf = UnionFind(N)
ans = [ansal]
pp = []
for i in range(M):
pp.append(list(map(int,input().split())))
for i in range(M,1,-1):
uf.union(pp[i-1][0]-1, pp[i-1][1]-1)
ans.append(ansal - uf.cnt())
for i in range(len(ans)):
print((ans[-(i+1)])) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.ans = n*(n-1)//2
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
sx = self.size(x)
sy = self.size(y)
self.ans += sx*(sx-1)//2 + sy*(sy-1)//2
self.ans -= (sx+sy)*(sx+sy-1)//2
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 cnt(self):
return sum([uf.size(i)*(uf.size(i)-1)//2 for i in self.roots()])
######
N,M = list(map(int,input().split()))
ansal = int(N*(N-1)/2)
uf = UnionFind(N)
ans = [uf.ans]
pp = [list(map(int,input().split())) for i in range(M)]
for i in range(M,1,-1):
uf.union(pp[i-1][0]-1, pp[i-1][1]-1)
ans.append(uf.ans)
for i in range(M-1,-1,-1):
print((ans[i])) | p03108 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.ans = n*(n-1)//2
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
sx = self.size(x)
sy = self.size(y)
self.ans += sx*(sx-1)//2 + sy*(sy-1)//2
self.ans -= (sx+sy)*(sx+sy-1)//2
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 cnt(self):
return sum([uf.size(i)*(uf.size(i)-1)//2 for i in self.roots()])
######
N,M = list(map(int,input().split()))
ansal = int(N*(N-1)/2)
uf = UnionFind(N)
ans = [uf.ans]
pp = [list(map(int,input().split())) for i in range(M)]
for i in range(M,1,-1):
uf.union(pp[i-1][0]-1, pp[i-1][1]-1)
ans.append(uf.ans)
for i in range(M-1,-1,-1):
print((ans[i])) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.ans = n*(n-1)//2
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
sx = self.size(x)
sy = self.size(y)
self.ans += sx*(sx-1)//2 + sy*(sy-1)//2
self.ans -= (sx+sy)*(sx+sy-1)//2
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
######
N,M = list(map(int,input().split()))
uf = UnionFind(N)
ans = [uf.ans]
pp = [list(map(int,input().split())) for i in range(M)]
for i in range(M,1,-1):
uf.union(pp[i-1][0]-1, pp[i-1][1]-1)
ans.append(uf.ans)
for i in range(M-1,-1,-1):
print((ans[i])) | p03108 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.ans = n*(n-1)//2
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
sx = self.size(x)
sy = self.size(y)
self.ans += sx*(sx-1)//2 + sy*(sy-1)//2
self.ans -= (sx+sy)*(sx+sy-1)//2
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
######
N,M = list(map(int,input().split()))
uf = UnionFind(N)
ans = [uf.ans]
pp = [list(map(int,input().split())) for i in range(M)]
for i in range(M,1,-1):
uf.union(pp[i-1][0]-1, pp[i-1][1]-1)
ans.insert(0,uf.ans)
for i in ans:
print(i) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.ans = n*(n-1)//2
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
sx = self.size(x)
sy = self.size(y)
self.ans += sx*(sx-1)//2 + sy*(sy-1)//2
self.ans -= (sx+sy)*(sx+sy-1)//2
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
######
N,M = list(map(int,input().split()))
uf = UnionFind(N)
ans = [uf.ans]
pp = [list(map(int,input().split())) for i in range(M)]
for i in range(M,1,-1):
uf.union(pp[i-1][0]-1, pp[i-1][1]-1)
ans.append(uf.ans)
print(('\n'.join(map(str, reversed(ans))))) | p03108 |
class UnionFind():
#https://note.nkmk.me/python-union-find/
#note.nkmk.me 2019-08-18
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())
# 初期入力
import sys
#input = sys.stdin.readline #文字列では使わない
N,M = map(int, input().split())
bridge =[]
for i in range(M):
a,b = map(int, input().split())
bridge.append((a,b))
all =N*(N-1)//2 #行き来できる島の組み合わせ
#i 番目の橋が崩落した直後の不便さ＝i+1番目がまだ残っているときの不便さ
# ⇒最後の橋から順番に作り、できた時の不便さ
inconvenience =[]
uf =UnionFind(N)
ans_pre =all
ans =[ans_pre]
x_bf =[1]
y_bf =[1]
for i in range(M-1,0,-1):
#くっつける前のa,b島のつながり
a,b =bridge[i]
x_bf =uf.members(a-1)
y_bf =uf.members(b-1)
if uf.same(a-1,b-1):
x1 =len(x_bf) *(len(x_bf) -1) //2
y1 =0
else:
x1 =len(x_bf) *(len(x_bf) -1) //2
y1 =len(y_bf) *(len(y_bf) -1) //2
#くっつけてから変化分を引く
uf.union(a-1,b-1)
x_af =uf.members(a-1)
x2 =len(x_af) *(len(x_af) -1)//2
addx =x2 -x1-y1
ans_pre -= addx
ans.append(ans_pre)
[print(i) for i in ans[::-1]]
| class UnionFind():
#https://note.nkmk.me/python-union-find/
#note.nkmk.me 2019-08-18
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())
# 初期入力
import sys
input = sys.stdin.readline #文字列では使わない
N,M = map(int, input().split())
bridge =[]
for i in range(M):
a,b = map(int, input().split())
bridge.append((a,b))
all =N*(N-1)//2 #行き来できる島の組み合わせ
ans =[0]*(M-1) +[all]
#print(ans)
#i 番目の橋が崩落した直後の不便さ＝i+1番目がまだ残っているときの不便さ
# ⇒最後の橋から順番に作り、できた時の不便さ
uf =UnionFind(N)
for i in range(M-1,0,-1):
a,b =bridge[i]
#事前につながっているかどうかで場合分け
if uf.same(a-1,b-1):
ans[i-1] =ans[i]
#くっつけてから変化分を引く
else:
x_a =uf.size(a-1)
x_b =uf.size(b-1)
connection_bfo =x_a*(x_a -1)//2 +x_b*(x_b -1)//2
connection_aft =(x_a +x_b) *(x_a +x_b -1)//2
ans[i-1] =ans[i] -connection_aft +connection_bfo
uf.union(a-1,b-1)
[print(i) for i in ans]
| p03108 |
N,M = list(map(int,input().split()))
Bridge = [[int(x)-1 for x in input().split()] for _ in range(M)]
Igr = [{i} for i in range(N)]
Inconv = [N*(N-1)//2] * (M+1)
for i in range(M):
A = Bridge[M-1-i][0]
B = Bridge[M-1-i][1]
if B in Igr[A]:
Inconv[M-1-i] = Inconv[M-i]
else:
Inconv[M-1-i] = Inconv[M-i]-(len(Igr[A])*len(Igr[B]))
Ngr = Igr[A] | Igr[B]
for x in list(Ngr):
Igr[x] = Ngr
for i in range(1,M+1):
print((Inconv[i]))
| N,M = list(map(int,input().split()))
Bridge = [[int(x)-1 for x in input().split()] for _ in range(M)]
Parent = [-1] * N
Size = [1] * N
def Pr(x):
if Parent[x] == -1:
return x
else:
return Pr(Parent[x])
Igr = [{i} for i in range(N)]
Inconv = [N*(N-1)//2] * (M+1)
for i in range(M):
A = Bridge[M-1-i][0]
B = Bridge[M-1-i][1]
if Pr(A) == Pr(B):
Inconv[M-1-i] = Inconv[M-i]
else:
Inconv[M-1-i] = Inconv[M-i]-(Size[Pr(A)]*Size[Pr(B)])
if Size[Pr(A)]<Size[Pr(B)]:
P = B
C = A
else:
P = A
C = B
Size[Pr(P)] = Size[Pr(P)] + Size[Pr(C)]
Parent[Pr(C)] = Pr(P)
for i in range(1,M+1):
print((Inconv[i]))
| p03108 |
from queue import Queue
def disintegration_Bridge(index):
ConnectMatrix[index[0]][index[1]] = '0'
ConnectMatrix[index[1]][index[0]] = '0'
def Calculate_inconveniece(group):
if len(group) == 1:
return 0
else:
Mysum = 0
group_count = len(group)
for i in range(group_count):
num_group1 = len(group[i])
for j in range(i + 1, group_count):
Mysum += num_group1 * len(group[j])
return Mysum
n, m = list(map(int, input().split()))
a = [input().split() for i in range(m)]
a = [(int(i[0]), int(i[1])) for i in a]
ConnectMatrix = [['0' for i in range(n + 1)] for j in range(n + 1)]
for bridge in a:
ConnectMatrix[bridge[1]][bridge[0]] = '1'
ConnectMatrix[bridge[0]][bridge[1]] = '1'
for i in a:
# 橋の崩落
disintegration_Bridge(i)
mydic = ['0' for i in range(n + 1)]
root = [[i for i in range(n + 1) if ConnectMatrix[j][i] == '1'] for j in range(n + 1)]
group = []
q = Queue()
counter = 0
for index in range(1, n + 1):
if mydic[index] == '1':
continue
q.put(index)
mydic[index] = '1'
group.append([index])
while not q.empty():
focus = q.get()
for j in root[focus]:
if type(j) == int:
if mydic[j] == '0':
mydic[j] = '1'
group[counter].append(j)
q.put(j)
else:
for node in j:
if mydic[node] == '0':
mydic[node] = '1'
q.put(node)
group[counter].append(j)
counter += 1
# print(group)
print((Calculate_inconveniece(group)))
|
def Calculate_inconveniece(group):
if len(group) == 1:
return 0
else:
Mysum = 0
group_count = len(group)
for i in range(group_count):
num_group1 = len(group[i])
for j in range(i + 1, group_count):
Mysum += num_group1 * len(group[j])
return Mysum
def Conect_island(index, group):
right = index[0]
left = index[1]
right_index = [i for i in range(len(group)) if right in group[i]][0]
left_index = [i for i in range(len(group)) if left in group[i]][0]
if right_index == left_index:
return group
else:
temp = group[right_index]
group[left_index] += temp
del(group[right_index])
return group
n, m = list(map(int, input().split()))
a = [input().split() for i in range(m)]
a = [(int(i[0]), int(i[1])) for i in a]
group = [[i]for i in range(1, n+1)]
ans =[]
for idnex in range(1, len(a) + 1):
# print(Calculate_inconveniece(group))
ans.append(Calculate_inconveniece(group))
x = a[-idnex]
group = Conect_island(x, group)
# print(x)
for i in range(1, len(a) + 1):
print((ans[-i])) | p03108 |
n, m = list(map(int, input().split()))
bridge = list()
for i in range(0, m):
a, b = list(map(int, input().split()))
bridge.append([a - 1, b - 1])
bridge = bridge[1:]
bridge = reversed(bridge)
result = []
groups = []
value = n * (n - 1) // 2
result.append(value)
def find_group(v):
for i, a in enumerate(groups):
if v in a:
return i
return -1
for b in bridge:
if value <= 0:
result.append(0)
continue
b1 = find_group(b[0])
b2 = find_group(b[1])
if b1 < 0 and b2 < 0:
groups.append(b)
value -= 1
elif b1 == b2:
pass
elif b1 >= 0 and b2 >= 0:
value -= (len(groups[b1]) * len(groups[b2]))
if b1 < b2:
groups[b1].extend(groups[b2])
del groups[b2]
else:
groups[b2].extend(groups[b1])
del groups[b1]
elif b1 >= 0:
value -= len(groups[b1])
groups[b1].append(b[1])
else:
value -= len(groups[b2])
groups[b2].append(b[0])
result.append(max(value, 0))
result = reversed(result)
for r in result:
print(r)
| n, m = list(map(int, input().split()))
bridge = list()
for i in range(0, m):
a, b = list(map(int, input().split()))
bridge.append([a - 1, b - 1])
bridge = bridge[1:]
bridge = reversed(bridge)
result = []
parent = [-1] * n
size = [1] * n
def root(v):
p = parent[v]
if p >= 0:
return root(p)
return v
value = n * (n - 1) // 2
result.append(value)
for b in bridge:
if value <= 0:
result.append(0)
continue
p0 = root(b[0])
p1 = root(b[1])
if p0 == p1:
result.append(value)
continue
s0 = size[p0]
s1 = size[p1]
if p0 < p1:
parent[p1] = p0
size[p0] += size[p1]
else:
parent[p0] = p1
size[p1] += size[p0]
value -= s0 * s1
result.append(max(value, 0))
result = reversed(result)
for r in result:
print(r) | p03108 |
from copy import deepcopy as dc
N, Q = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(Q)][: : -1]
res = [N * (N - 1) // 2]
mod = 2305843009213693951
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)]
class Factorial:
def __init__(self, n, mod):
self.f=[1]
for i in range(1, n + 1):
self.f.append(self.f[-1] * i % mod)
self.i=[pow(self.f[-1], mod - 2, mod)]
for i in range(1, n + 1)[: : -1]:
self.i.append(self.i[-1] * i % mod)
self.i.reverse()
def factorial(self, i):
return self.f[i]
def ifactorial(self, i):
return self.i[i]
def combi(self, n, k):
return self.f[n] * self.i[n - k] % mod * self.i[k] % mod
uf = UnionFind(N)
f = Factorial(N * (N - 1) // 2, 2305843009213693951)
check = set()
for b in A:
uf.Unite(b[0], b[1])
check.add(b[0])
check.add(b[1])
tempch = dc(check)
convenience = 0
for i in tempch:
inc = uf.root[i]
if inc < -1:
if -inc > N * (N - 1) // 2:
convenience += 1
else:
convenience += f.combi(-inc, 2)
else:
check.discard(i)
res.append(N * (N - 1) // 2 - convenience)
for i in range(Q - 1, -1, -1):
print((res[i])) | N, Q = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(Q)]
res = [0] * (Q - 1) + [N * (N - 1) // 2]
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)
convenience = [0] * (N + 1)
for i in range(Q - 1, 0, -1):
res[i - 1] = res[i]
if uf.Find_Root(A[i][0]) != uf.Find_Root(A[i][1]):
res[i - 1] -= uf.Count(A[i][0]) * uf.Count(A[i][1])
a, b = uf.Count(A[i][0]), uf.Count(A[i][1])
uf.Unite(A[i][0], A[i][1])
#print(uf.root, res, a, b)
for i in range(Q):
print((res[i])) | p03108 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.sizes = [1] * (n+1)
self.root = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.root[x] = -1
self.sizes[y] += self.sizes[x]
else:
self.par[y] = x
self.root[y] = -1
self.sizes[x] += self.sizes[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.sizes[find(x)]
n, m = list(map(int, input().split()))
lst = [list(map(int, input().split())) for _ in range(m)]
all_comb = n*(n-1)/2
a = UnionFind(n)
ans = [all_comb]
for pair in reversed(lst):
if a.same_check(pair[0], pair[1]):
pass
else:
a.union(pair[0], pair[1])
count = 0
for i in range(n+1):
if a.root[i] == 1:
size = a.sizes[i]
count += size * (size-1) / 2
ans.append(all_comb - count)
for i in reversed(ans[:-1]):
print((int(i))) | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.sizes = [1] * (n+1)
self.root = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.root[x] = -1
self.sizes[y] += self.sizes[x]
else:
self.par[y] = x
self.root[y] = -1
self.sizes[x] += self.sizes[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.sizes[find(x)]
n, m = list(map(int, input().split()))
lst = [list(map(int, input().split())) for _ in range(m)]
all_comb = n*(n-1)/2
a = UnionFind(n)
ans = [all_comb]
for pair in reversed(lst):
if a.same_check(pair[0], pair[1]):
ans.append(ans[-1])
pass
else:
ans.append(ans[-1] - a.sizes[a.find(pair[0])]*a.sizes[a.find(pair[1])])
a.union(pair[0], pair[1])
for i in reversed(ans[:-1]):
print((int(i))) | p03108 |
import collections
def main():
n, m = list(map(int, input().split()))
bridge = [[0, 0]]*m
for i in range(m):
bridge[i] = list(map(int, input().split()))
inconveniences = [0]*(m+1)
inconveniences[m] = (n*(n-1))//2
islands = collections.defaultdict(list)
stack = []
for i in range(m-1, -1, -1):
if inconveniences[i+1] == 0:
break
does_route_exist = False
for island in islands[bridge[i][0]]:
if island == bridge[i][1]:
does_route_exist = True
break
if does_route_exist:
inconvenience[i] = inconveniences[i+1]
continue
islands[bridge[i][0]].append(bridge[i][1])
islands[bridge[i][1]].append(bridge[i][0])
stack.append(bridge[i][0])
is_visited = [False]*(n+1)
total = 0
for s in stack:
is_visited[s] = True
island_pair = 0
queue = collections.deque([s])
while queue:
for island in islands[queue.popleft()]:
if is_visited[island]:
continue
queue.append(island)
is_visited[island] = True
island_pair += 1
total += (island_pair*(island_pair+1))//2
inconveniences[i] = inconveniences[m] - total
for i in range(1, m+1):
print((inconveniences[i]))
if __name__ == '__main__':
main() | def main():
n, m = list(map(int, input().split()))
bridge = [[0, 0]]*m
for i in range(m):
bridge[i] = list(map(int, input().split()))
inconveniences = [0]*(m+1)
inconveniences[m] = (n*(n-1))//2
union_find = [[i, 0, 1] for i in range(n+1)]
for i in range(m-1, -1, -1):
if inconveniences[i+1] == 0:
break
if same(union_find, bridge[i][0], bridge[i][1]):
inconveniences[i] = inconveniences[i+1]
continue
rx = root(union_find, bridge[i][0])
ry = root(union_find, bridge[i][1])
inconveniences[i] = inconveniences[i+1] - union_find[rx][2]*union_find[ry][2]
unite(union_find, bridge[i][0], bridge[i][1])
for i in range(1, m+1):
print((inconveniences[i]))
def root(union_find, val:int) -> int:
if union_find[val][0] == val:
return val
return root(union_find, union_find[val][0])
def same(union_find, x:int, y:int) -> bool:
rx = root(union_find, x)
ry = root(union_find, y)
return rx == ry
def unite(union_find, x:int, y:int):
rx = root(union_find, x)
ry = root(union_find, y)
if rx == ry:
return
if union_find[rx][1] < union_find[ry][1]:
union_find[rx][0] = ry
union_find[ry][2] += union_find[rx][2]
else:
union_find[ry][0] = rx
union_find[rx][2] += union_find[ry][2]
if union_find[rx][1] == union_find[ry][1]:
union_find[rx][1] += 1
if __name__ == '__main__':
main() | p03108 |
import sys
input = sys.stdin.readline
from collections import deque
sys.setrecursionlimit(10000000)
N,M=list(map(int,input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
to = [[] for _ in range(N+1)]
def dfs(v, p):
count=1
for u in to[v]:
if u == p or done[u] == 1: continue
done[u] = 1
#print(v,u)
count += dfs(u, v)
return count
ans=0
sum = N*(N-1)/2
ans_list=[]
ans_list.append(sum)
for i in reversed(list(range(1,M))):
done = [0]*(N+1)
done[AB[i][0]] = 1
v1 = dfs(AB[i][0], -1)
if done[AB[i][1]] == 1:
v2 = 0
else:
done[AB[i][1]] = 1
v2 = dfs(AB[i][1], -1)
to[AB[i][0]].append(AB[i][1])
to[AB[i][1]].append(AB[i][0])
ans+=v1*v2
ans_list.append(sum-ans)
for i in reversed(list(range(M))):
print((int(ans_list[i]))) | import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, N):
self.Parent = [-1]*(N+1)
#Aの親を探す。このときParent[A]は親の値からグループサイズに変わる。探索の最適化
def root(self, A):
if self.Parent[A] < 0: return A
self.Parent[A] = self.root(self.Parent[A])
return self.Parent[A]
#Aが属しているグループのサイズを求める
def size(self, A):
return -self.Parent[self.root(A)]
def connect(self,A,B):
A = self.root(A)
B = self.root(B)
if A == B: return False
if self.size(A) < self.size(B): A,B = B,A
self.Parent[A] += self.Parent[B]
self.Parent[B] = A
return True
N,M = list(map(int,input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
Uni = UnionFind(N)
ans = [-1]*(M)
ans[M-1] = N*(N-1)//2
for i in reversed(list(range(1,M))):
ans[i-1] = ans[i]
if Uni.root(AB[i][0]) != Uni.root(AB[i][1]):
ans[i-1] -= Uni.size(AB[i][0])*Uni.size(AB[i][1])
Uni.connect(AB[i][0], AB[i][1])
for i in range(M):
print((ans[i]))
| p03108 |
def readln():
return list(map(int, input().split()))
N, M = readln()
AB = [readln() for _ in range(M)]
A = [ab[0]-1 for ab in AB[::-1]]
B = [ab[1]-1 for ab in AB[::-1]]
class UnionFind:
def __init__(self, N):
self.N = N # ノード数
# 親ノードをしめす。負は自身が親ということ。
self.parent = [-1] * N # idxが各ノードに対応。
def root(self, A):
# print(A)
# ノード番号を受け取って一番上の親ノードの番号を帰す
if (self.parent[A] < 0):
return A
self.parent[A] = self.root(self.parent[A]) # 経由したノードすべての親を上書き
return self.parent[A]
def size(self, A):
# ノード番号を受け取って、そのノードが含まれている集合のサイズを返す。
return -self.parent[self.root(A)]
def concat(self, A, B):
# ノード番号を2つ受け取って、そのノード同士をつなげる処理を行う。
# 引数のノードを直接つなぐ代わりに、親同士を連結する処理にする。
A = self.root(A)
B = self.root(B)
# すでにくっついている場合
if (A == B):
return False
# 大きい方に小さい方をくっつけたほうが処理が軽いので大小比較
if (self.size(A) < self.size(B)):
A, B = B, A
# くっつける
self.parent[A] += self.parent[B] # sizeの更新
self.parent[B] = A # self.rootが呼び出されればBにくっついてるノードもすべて親がAだと上書きされる
return True
ans = [N * (N - 1) // 2]
uni = UnionFind(N)
for a, b in zip(A, B):
if uni.root(a) == uni.root(b):
ans.append(ans[-1])
else:
ans.append(ans[-1] - uni.size(a) * uni.size(b))
uni.concat(a, b)
for a in ans[-2::-1]:
print(a)
| def readln():
import sys
input = sys.stdin.readline
return list(map(int, input().split()))
N, M = readln()
AB = [readln() for _ in range(M)]
A = [ab[0]-1 for ab in AB[::-1]]
B = [ab[1]-1 for ab in AB[::-1]]
class UnionFind:
def __init__(self, N):
self.N = N # ノード数
# 親ノードをしめす。負は自身が親ということ。
self.parent = [-1] * N # idxが各ノードに対応。
def root(self, A):
# print(A)
# ノード番号を受け取って一番上の親ノードの番号を帰す
if (self.parent[A] < 0):
return A
self.parent[A] = self.root(self.parent[A]) # 経由したノードすべての親を上書き
return self.parent[A]
def size(self, A):
# ノード番号を受け取って、そのノードが含まれている集合のサイズを返す。
return -self.parent[self.root(A)]
def concat(self, A, B):
# ノード番号を2つ受け取って、そのノード同士をつなげる処理を行う。
# 引数のノードを直接つなぐ代わりに、親同士を連結する処理にする。
A = self.root(A)
B = self.root(B)
# すでにくっついている場合
if (A == B):
return False
# 大きい方に小さい方をくっつけたほうが処理が軽いので大小比較
if (self.size(A) < self.size(B)):
A, B = B, A
# くっつける
self.parent[A] += self.parent[B] # sizeの更新
self.parent[B] = A # self.rootが呼び出されればBにくっついてるノードもすべて親がAだと上書きされる
return True
ans = [N * (N - 1) // 2]
uni = UnionFind(N)
for a, b in zip(A, B):
if uni.root(a) == uni.root(b):
ans.append(ans[-1])
else:
ans.append(ans[-1] - uni.size(a) * uni.size(b))
uni.concat(a, b)
for a in ans[-2::-1]:
print(a)
| p03108 |
import sys
read = sys.stdin.readline
def readln():
return list(map(int, read().split()))
N, M = readln()
AB = [readln() for _ in range(M)]
A = [ab[0]-1 for ab in AB[::-1]]
B = [ab[1]-1 for ab in AB[::-1]]
class UnionFind:
def __init__(self, N):
self.N = N # ノード数
# 親ノードをしめす。負は自身が親ということ。
self.parent = [-1] * N # idxが各ノードに対応。
def root(self, A):
# print(A)
# ノード番号を受け取って一番上の親ノードの番号を帰す
if (self.parent[A] < 0):
return A
self.parent[A] = self.root(self.parent[A]) # 経由したノードすべての親を上書き
return self.parent[A]
def size(self, A):
# ノード番号を受け取って、そのノードが含まれている集合のサイズを返す。
return -self.parent[self.root(A)]
def concat(self, A, B):
# ノード番号を2つ受け取って、そのノード同士をつなげる処理を行う。
# 引数のノードを直接つなぐ代わりに、親同士を連結する処理にする。
A = self.root(A)
B = self.root(B)
# すでにくっついている場合
if (A == B):
return False
# 大きい方に小さい方をくっつけたほうが処理が軽いので大小比較
if (self.size(A) < self.size(B)):
A, B = B, A
# くっつける
self.parent[A] += self.parent[B] # sizeの更新
self.parent[B] = A # self.rootが呼び出されればBにくっついてるノードもすべて親がAだと上書きされる
return True
ans = [N * (N - 1) // 2]
uni = UnionFind(N)
for a, b in zip(A, B):
if uni.root(a) == uni.root(b):
ans.append(ans[-1])
else:
ans.append(ans[-1] - uni.size(a) * uni.size(b))
uni.concat(a, b)
for a in ans[-2::-1]:
print(a)
| import sys
read = sys.stdin.readline
def readln():
return list(map(int, read().split()))
N, M = readln()
A = []
B = []
for _ in range(M):
a, b = readln()
A.append(a-1)
B.append(b-1)
# AB = [readln() for _ in range(M)]
# A = [ab[0]-1 for ab in AB[::-1]]
# B = [ab[1]-1 for ab in AB[::-1]]
A.reverse()
B.reverse()
class UnionFind:
def __init__(self, N):
self.N = N # ノード数
# 親ノードをしめす。負は自身が親ということ。
self.parent = [-1] * N # idxが各ノードに対応。
def root(self, A):
# print(A)
# ノード番号を受け取って一番上の親ノードの番号を帰す
if (self.parent[A] < 0):
return A
self.parent[A] = self.root(self.parent[A]) # 経由したノードすべての親を上書き
return self.parent[A]
def size(self, A):
# ノード番号を受け取って、そのノードが含まれている集合のサイズを返す。
return -self.parent[self.root(A)]
def concat(self, A, B):
# ノード番号を2つ受け取って、そのノード同士をつなげる処理を行う。
# 引数のノードを直接つなぐ代わりに、親同士を連結する処理にする。
A = self.root(A)
B = self.root(B)
# すでにくっついている場合
if (A == B):
return False
# 大きい方に小さい方をくっつけたほうが処理が軽いので大小比較
if (self.size(A) < self.size(B)):
A, B = B, A
# くっつける
self.parent[A] += self.parent[B] # sizeの更新
self.parent[B] = A # self.rootが呼び出されればBにくっついてるノードもすべて親がAだと上書きされる
return True
ans = [N * (N - 1) // 2]
uni = UnionFind(N)
for a, b in zip(A, B):
if uni.root(a) == uni.root(b):
ans.append(ans[-1])
else:
ans.append(ans[-1] - uni.size(a) * uni.size(b))
uni.concat(a, b)
for a in ans[-2::-1]:
print(a)
| p03108 |
import sys
input = sys.stdin.readline
def Find(x, par):
if par[x] < 0:
return x
else:
# 経路圧縮
par[x] = Find(par[x], par)
return par[x]
def Unite(x, y, par, rank):
x = Find(x, par)
y = Find(y, par)
if x != y:
# rankの低い方を高い方につなげる
if rank[x] < rank[y]:
par[y] += par[x]
par[x] = y
else:
par[x] += par[y]
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
def Same(x, y, par):
return Find(x, par) == Find(y, par)
def Size(x, par):
return -par[Find(x, par)]
n, m = list(map(int, input().split()))
L = [[0, 0] for _ in range(m)]
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
L[i][0] = a
L[i][1] = b
par = [-1]* n
rank = [0]*n
ans = n*(n-1)//2
anss = [0]*m
for i in reversed(list(range(m))):
anss[i] = ans
a = L[i][0]
b = L[i][1]
if not Same(a, b, par):
ans = max(0, ans-Size(a, par)*Size(b, par))
Unite(a, b, par, rank)
#print(par)
for i in range(m):
print((anss[i]))
| import sys
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
X = []
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
X.append((a, b))
X.reverse()
def Find(x, par):
if par[x] < 0:
return x
else:
par[x] = Find(par[x], par)
return par[x]
def Unite(x, y, par, rank):
x = Find(x, par)
y = Find(y, par)
if x != y:
if rank[x] < rank[y]:
par[y] += par[x]
par[x] = y
else:
par[x] += par[y]
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
def Same(x, y, par):
return Find(x, par) == Find(y, par)
def Size(x, par):
return -par[Find(x, par)]
temp = n*(n-1)//2
ans = [0]*m
par = [-1]* n
rank = [0]*n
for i in range(m):
a, b = X[i]
ans[i] = temp
if Same(a, b, par):
continue
else:
pre_a = Size(a, par)
pre_b = Size(b, par)
Unite(a, b, par, rank)
temp -= pre_a*pre_b
#if temp <= 0:
#temp = 0
ans.reverse()
#print(ans)
for i in range(len(ans)):
print((ans[i])) | p03108 |
N, M = list(map(int, input().split()))
AB = []
for i in range(M):
A, B = list(map(int, input().split()))
AB.append([A, B, i])
AB_ = AB[::-1]
#print(AB)
#print(AB_)
ma = N * (N-1) // 2
path = []
subs = [0]
for i in range(len(AB_)):
f0 = -1
f1 = -1
sub = 0
for p in range(len(path)):
if AB_[i][0] in path[p]:
path[p] += [AB_[i][1]]
f0 = p
elif AB_[i][1] in path[p]:
path[p] += [AB_[i][0]]
f1 = p
if (f0 > -1) and (f1 > -1):
#print("@", path[f0] + path[f1])
s = list(set(path[f0] + path[f1]))
if f0 > f1:
path.pop(f0)
path.pop(f1)
path.append(s)
elif f1 > f0:
path.pop(f1)
path.pop(f0)
path.append(s)
if (f0 == -1) and (f1 == -1):
path.append([AB_[i][0], AB_[i][1]])
for p in range(len(path)):
sub += len(list(set(path[p]))) * (len(list(set(path[p])))-1) // 2
subs.append(sub)
#print(subs)
for i in range(2, len(subs)+1):
print((ma-subs[-i])) |
class UnionFind:
def __init__(self, N):
self.parents = [i for i in range(N)]
self.sizes = [1 for _ in range(N)]
# 木の根をまとめる, 頂点 v が属するグループ番号を得る (O(α(n)))
def root(self, x):
if self.parents[x] == x:
return x # 根
else:
self.parents[x] = self.root(self.parents[x]) # 経路圧縮
return self.parents[x]
# xとyが同じ集合に属するか否か
def is_same(self, x, y):
return self.root(x) == self.root(y)
# xとyの属する集合を併合, 頂点 u が属するグループと頂点 v が属するグループを併合し、同じグループにする (O(α(n)))
def unite(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.sizes[x] < self.sizes[y]:
x, y = y, x
self.sizes[x] += self.sizes[y]
self.parents[y] = x
return True
# 頂点 v が属するグループと同じグループに属する頂点数を得る (O(1))
def size(self, x):
return self.sizes[self.root(x)]
N, M = list(map(int, input().split()))
tree = UnionFind(N)
AB = []
for _ in range(M):
a, b = list(map(int, input().split()))
AB.append([a, b])
AB = AB[::-1]
tree = UnionFind(N)
ans = [N*(N-1)//2]
for i in range(M):
a, b = AB[i]
a, b = tree.root(a-1), tree.root(b-1)
if a != b:
ans.append(ans[-1] - tree.size(a)*tree.size(b))
else:
ans.append(ans[-1])
tree.unite(a, b)
ans = ans[:M][::-1]
for i in range(M):
print((ans[i])) | p03108 |
# Union-Find木（サイズ付き）
class UnionFind():
def __init__(self, n): # n要素で初期化 初めは全ての頂点が別々の木の根
self.parent = [None] * n # 親
self.rank = [None] * n # 木の深さ
self._size = [1] * n # 要素が属する集合の大きさ（根の要素のみ参照すること）
for i in range(n):
self.parent[i] = i
self.rank[i] = 0
# 木の根を求める
def root_of(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.root_of(self.parent[x]) # 経路圧縮して親が変わる
return self.parent[x]
# xとyの属する集合を併合
def unite(self, x, y):
rx = self.root_of(x)
ry = self.root_of(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]: # ランクの小さい木から大きい木の根に辺を張る
self.parent[rx] = ry # rxをryの子とする
self._size[ry] += self._size[rx]
elif self.rank[rx] == self.rank[ry]:
self.parent[ry] = rx
self.rank[rx] += 1
self._size[rx] += self._size[ry]
else:
self.parent[ry] = rx
self._size[rx] += self._size[ry]
# 同じ集合に属するかどうか
def is_same(self, x, y):
return self.root_of(x) == self.root_of(y)
# 頂点xが属する集合のサイズ
def size(self, x):
return self._size[self.root_of(x)]
# 入力
N, M = [int(x) for x in input().split()]
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = [int(x) - 1 for x in input().split()]
# 島同士が全く繋がっていない状態からスタート
# M-1番目, M-2番目, ..., , 2番目, 1番目の橋の順に橋をかけていく
inconv = [-1] * (M - 1) + [N * (N - 1) // 2] # 不便さ
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
# i番目の橋をかける
if not uf.is_same(A[i], B[i]):
size_a = uf.size(A[i]) # A[i]が属する集合の大きさ
size_b = uf.size(B[i]) # B[i]が属する集合の大きさ
inconv[i - 1] = inconv[i] - size_a * size_b
uf.unite(A[i], B[i])
else:
inconv[i - 1] = inconv[i]
for i in range(M):
print((inconv[i]))
| # Union-Find木（サイズ付き）
class UnionFind():
def __init__(self, n): # n要素で初期化 初めは全ての頂点が別々の木の根
self.parent = [None] * n # 親
self.rank = [None] * n # 木の深さ
self._size = [1] * n # 要素が属する集合の大きさ（根の要素のみ参照すること）
for i in range(n):
self.parent[i] = i
self.rank[i] = 0
# 木の根を求める
def root_of(self, x):
children = [x]
while self.parent[x] != x:
x = self.parent[x]
children.append(x)
for ch in children: # 根の子供として張りなおす
self.parent[ch] = x
return x
# xとyの属する集合を併合
def unite(self, x, y):
rx = self.root_of(x)
ry = self.root_of(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]: # ランクの小さい木から大きい木の根に辺を張る
self.parent[rx] = ry # rxをryの子とする
self._size[ry] += self._size[rx]
elif self.rank[rx] == self.rank[ry]:
self.parent[ry] = rx
self.rank[rx] += 1
self._size[rx] += self._size[ry]
else:
self.parent[ry] = rx
self._size[rx] += self._size[ry]
# 同じ集合に属するかどうか
def is_same(self, x, y):
return self.root_of(x) == self.root_of(y)
# 頂点xが属する集合のサイズ
def size(self, x):
return self._size[self.root_of(x)]
# 入力
N, M = [int(x) for x in input().split()]
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = [int(x) - 1 for x in input().split()]
# 島同士が全く繋がっていない状態からスタート
# M-1番目, M-2番目, ..., , 2番目, 1番目の橋の順に橋をかけていく
inconv = [-1] * (M - 1) + [N * (N - 1) // 2] # 不便さ
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
# i番目の橋をかける
if not uf.is_same(A[i], B[i]):
size_a = uf.size(A[i]) # A[i]が属する集合の大きさ
size_b = uf.size(B[i]) # B[i]が属する集合の大きさ
inconv[i - 1] = inconv[i] - size_a * size_b
uf.unite(A[i], B[i])
else:
inconv[i - 1] = inconv[i]
for i in range(M):
print((inconv[i])) | p03108 |
# Union-Find木を使って書き直し
# Union-Find木（サイズ付き）
class UnionFind():
def __init__(self, n): # n要素で初期化 初めは全ての頂点が別々の木の根
self.parent = [None] * n # 親
self.rank = [None] * n # 木の深さ
self._size = [1] * n # 要素が属する集合の大きさ（根の要素のみ参照すること）
for i in range(n):
self.parent[i] = i
self.rank[i] = 0
# 木の根を求める
def root_of(self, x):
children = [x]
while self.parent[x] != x:
x = self.parent[x]
children.append(x)
for ch in children: # 根の子供として張りなおす
self.parent[ch] = x
return x
# xとyの属する集合を併合
def unite(self, x, y):
rx = self.root_of(x)
ry = self.root_of(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]: # ランクの小さい木から大きい木の根に辺を張る
self.parent[rx] = ry # rxをryの子とする
self._size[ry] += self._size[rx]
else:
self.parent[ry] = rx
self._size[rx] += self._size[ry]
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
# 同じ集合に属するかどうか
def is_same(self, x, y):
return self.root_of(x) == self.root_of(y)
# 頂点xが属する集合のサイズ
def size(self, x):
return self._size[self.root_of(x)]
# 入力
N, M = [int(x) for x in input().split()]
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = [int(x) - 1 for x in input().split()]
# 島同士が全く繋がっていない状態からスタート
# M-1番目, M-2番目, ..., , 2番目, 1番目の橋の順に橋をかけていく
inconv = [-1] * (M - 1) + [N * (N - 1) // 2] # 不便さ
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
# i番目の橋をかける
if not uf.is_same(A[i], B[i]):
size_a = uf.size(A[i]) # A[i]が属する集合の大きさ
size_b = uf.size(B[i]) # B[i]が属する集合の大きさ
inconv[i - 1] = inconv[i] - size_a * size_b
uf.unite(A[i], B[i])
else:
inconv[i - 1] = inconv[i]
for i in range(M):
print((inconv[i]))
| # 20-08-12再トライ
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.rank = [0] * n
self.par = list(range(n))
self._size = [1] * n # 木の根のみ有効、集合に属する要素数
def find(self, x):
ch = []
while self.par[x] != x:
ch.append(x)
x = self.par[x]
for c in ch:
self.par[c] = x
return x
def union(self, x, y):
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
if self.rank[rx] >= self.rank[ry]:
self.par[ry] = rx
self._size[rx] += self._size[ry]
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
else:
self.par[rx] = ry
self._size[ry] += self._size[rx]
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self._size[self.find(x)]
N, M = [int(x) for x in input().split()]
E = [tuple(int(x) - 1 for x in input().split()) for _ in range(M)]
inconv = [0] * M
inconv[M - 1] = N * (N - 1) // 2
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
a = E[i][0]
b = E[i][1]
inconv[i - 1] = inconv[i]
if uf.same(a, b):
continue
inconv[i - 1] -= uf.size(a) * uf.size(b)
uf.union(a, b)
for i in range(M):
print((inconv[i])) | p03108 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.