input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
n,m=list(map(int,input().split()))
z=n*(n-1)//2
l=[-1]*n
a=[1]*n
b=[input().split() for _ in range(m)]
c=[0]*m+[z]
def r(s):
t=l[s]
return s if t<0 else r(t)
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
if x!=y:
l[x]=y
l=list([y if w==x else w for w in l])
z-=a[x]*a[y]
a[y]+=a[x]
c[i]=z
for x in c[1:]:
print(x) | import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
n,m=list(map(int,input().split()))
z=n*(n-1)//2
l=[-1]*n
a=[1]*n
b=[input().split() for _ in range(m)]
c=[0]*m+[z]
d=[i for i in range(n)]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
if x!=y:
l[x]=d[y]
d[y]=d[x]
z-=a[x]*a[y]
a[y]+=a[x]
c[i]=z
for x in c[1:]:
print(x) | p03108 |
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
n,m=list(map(int,input().split()))
z=n*(n-1)//2
l=[-1]*n
a=[1]*n
b=[input().split() for _ in range(m)]
c=[0]*m+[z]
d=[i for i in range(n)]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
if x!=y:
l[x]=y
d[y]=d[x]
z-=a[x]*a[y]
a[y]+=a[x]
c[i]=z
for x in c[1:]:
print(x) | import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
n,m=list(map(int,input().split()))
z=n*(n-1)//2
l=[-1]*n
a=[1]*n
b=[input().split() for _ in range(m)]
c=[0]*m+[z]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
if x!=y:
s,t=a[x],a[y]
z-=s*t
if s<t:
l[x]=y
a[y]+=s
else:
l[y]=x
a[x]+=t
c[i]=z
for x in c[1:]:
print(x) | p03108 |
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
n,m=list(map(int,input().split()))
z=n*(n-1)//2
l=[-1]*n
a=[1]*n
b=[input().split() for _ in range(m)]
c=[0]*m+[z]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
for i in range(m-1,-1,-1):
x,y=[r(int(w)-1) for w in b[i]]
if x!=y:
z-=a[x]*a[y]
l[x]=y
a[y]+=a[x]
c[i]=z
for x in c[1:]:
print(x) | import sys
sys.setrecursionlimit(100000)
input=sys.stdin.readline
n,m=list(map(int,input().split()))
z=n*(n-1)//2
l=[-1]*n
a=[1]*n
b=[input().split() for _ in range(m)]
c=[0]*m+[z]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
if x!=y:
s,t=a[x],a[y]
z-=s*t
if s<t:
l[x]=y
a[y]+=s
else:
l[y]=x
a[x]+=t
c[i]=z
for x in c[1:]:
print(x) | p03108 |
n,m=list(map(int,input().split()))
l=[-1]*n
b=[input().split() for _ in range(m)]
c=[0]*m+[n*(n-1)//2]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
s,t=0,0
if x!=y:
s,t=l[x],l[y]
if s>t:
l[x]=y
l[y]+=s
else:
l[y]=x
l[x]+=t
c[i]=c[i+1]-s*t
for x in c[1:]:
print(x) | import sys
n,m=list(map(int,input().split()))
l=[-1]*n
b=[sys.stdin.readline().split() for _ in range(m)]
c=[0]*m+[n*(n-1)//2]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
s,t=0,0
if x!=y:
s,t=l[x],l[y]
if s>t:
l[x]=y
l[y]+=s
else:
l[y]=x
l[x]+=t
c[i]=c[i+1]-s*t
for x in c[1:]:
print(x) | p03108 |
import sys
n,m=list(map(int,input().split()))
l=[-1]*n
b=[sys.stdin.readline().split() for _ in range(m)]
c=[0]*m+[n*(n-1)//2]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,-1,-1):
x,y=list(map(f,b[i]))
s,t=0,0
if x!=y:
s,t=l[x],l[y]
if s>t:
l[x]=y
l[y]+=s
else:
l[y]=x
l[x]+=t
c[i]=c[i+1]-s*t
for x in c[1:]:
print(x) | import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
l=[-1]*n
z=n*(n-1)//2
b=[input().split() for _ in range(m)]
c=[0]*m+[z]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m)[::-1]:
x,y=list(map(f,b[i]))
if x!=y:
s,t=l[x],l[y]
z-=s*t
if s>t:
l[x]=y
l[y]+=s
else:
l[y]=x
l[x]+=t
c[i]=z
for x in c[1:]:
print(x) | p03108 |
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
l=[-1]*n
z=n*(n-1)//2
b=[input().split() for _ in range(m)]
c=[0]*(m-1)+[z]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,0,-1):
x,y=list(map(f,b[i]))
if x!=y:
s,t=l[x],l[y]
z-=s*t
if s<t:
l[y]=x
l[x]+=t
else:
l[x]=y
l[y]+=s
c[i-1]=z
for x in c:
print(x) | import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
l=[-1]*n
z=n*(n-1)//2
b=[input().split() for _ in range(m)]
c=[0]*(m-1)+[z]
def r(s):
t=l[s]
if t<0:
return s
else:
l[s]=r(t)
return l[s]
def f(s):
return r(int(s)-1)
for i in range(m-1,0,-1):
x,y=list(map(f,b[i]))
if x!=y:
s,t=l[x],l[y]
z-=s*t
if s>t:
l[x]=y
l[y]+=s
else:
l[y]=x
l[x]+=t
c[i-1]=z
for x in c:
print(x) | 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()))
uf = UnionFind(n)
bridges = []
for i in range(m):
ai,bi = list(map(int,input().split()))
bridges.append((ai,bi))
bridges = bridges[::-1]
answers = []
for i in range(m):
ans = 1
for j in uf.roots():
x = uf.size(j)
ans += x*(n-x)
ans //= 2
answers.append(ans)
uf.union(bridges[i][0]-1,bridges[i][1]-1)
answers = answers[::-1]
for i in range(m):
print((answers[i])) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m = list(map(int,input().split()))
uf = UnionFind(n)
bridges = []
for i in range(m):
ai,bi = list(map(int,input().split()))
bridges.append((ai,bi))
bridges = bridges[::-1]
ans = n*(n-1)//2
answers = [ans]
for i in range(m):
x,y = bridges[i][0]-1,bridges[i][1]-1
if not uf.same(x,y):
ans -= uf.size(x) * uf.size(y)
answers.append(ans)
uf.union(x,y)
answers = answers[::-1]
for i in range(1,m+1):
print((answers[i])) | p03108 |
#!/usr/bin/python3
# -*- coding:utf-8 -*-
class UnionFindTree:
def __init__(self, n):
self.nodes = [-1]*n
def find(self, x):
parents = []
while True:
parent = self.nodes[x]
if parent < 0:
for p in parents:
self.nodes[p] = x
return x
else:
x = parent
def unite(self, x, y):
xp = self.find(x)
yp = self.find(y)
self.nodes[xp] += self.nodes[yp]
self.nodes[yp] = xp
def size(self, x):
return -self.nodes[self.find(x)]
def main():
n, m = list(map(int, input().split()))
edges = []
for _ in range(m):
a, b = [int(x)-1 for x in input().split()]
edges.append((a, b))
uftree = UnionFindTree(n)
scores = []
for a, b in edges[::-1]:
ap = uftree.find(a)
bp = uftree.find(b)
if ap != bp:
scores.append(uftree.size(ap) * uftree.size(bp))
uftree.unite(a, b)
else:
scores.append(0)
sum = 0
for score in scores[::-1]:
sum += score
print(sum)
if __name__=='__main__':
main()
| #!/usr/bin/python3
# -*- coding:utf-8 -*-
class UnionFindTree:
def __init__(self, n):
self.nodes = [-1]*n
def find(self, x):
parent = self.nodes[x]
if parent < 0:
return x
else:
self.nodes[x] = self.find(self.nodes[x])
return self.nodes[x]
def unite(self, x, y):
xp = self.find(x)
yp = self.find(y)
if self.nodes[xp] > self.nodes[yp]:
xp, yp = yp, xp
self.nodes[xp] += self.nodes[yp]
self.nodes[yp] = xp
def size(self, x):
return -self.nodes[self.find(x)]
def main():
n, m = list(map(int, input().split()))
edges = []
for _ in range(m):
a, b = [int(x)-1 for x in input().split()]
edges.append((a, b))
uftree = UnionFindTree(n)
scores = []
for a, b in edges[::-1]:
ap = uftree.find(a)
bp = uftree.find(b)
if ap != bp:
scores.append(uftree.size(ap) * uftree.size(bp))
uftree.unite(a, b)
else:
scores.append(0)
sum = 0
for score in scores[::-1]:
sum += score
print(sum)
if __name__=='__main__':
main()
| p03108 |
n,m=list(map(int,input().split()))
par=[-1]*n
def find(n):
if par[n]<0:
return n
else:
par[n]=find(par[n])
return par[n]
def union(x,y):
x,y=find(x),find(y)
if x!=y:
if x>y:
x,y=y,x
par[x]+=par[y]
par[y]=x
M=[]
for i in range(m):
a,b=list(map(int,input().split()))
M.append([a,b])
ANS=[n*(n-1)//2]
for i in reversed(list(range(1,m))):
s=n*(n-1)//2
a,b=M[i][0],M[i][1]
union(a-1,b-1)
for i in range(n):
if par[i]<-1:
s-=par[i]*(par[i]+1)//2
ANS.append(s)
for ans in ANS[::-1]:
print(ans) | n,m=list(map(int,input().split()))
par=[-1]*n
def find(n):
if par[n]<0:
return n
else:
par[n]=find(par[n])
return par[n]
def union(x,y,s):
x,y=find(x),find(y)
if x!=y:
if x>y:
x,y=y,x
s-=par[x]*par[y]
par[x]+=par[y]
par[y]=x
return s
M=[]
for i in range(m):
a,b=list(map(int,input().split()))
M.append([a,b])
ANS=[n*(n-1)//2]
s=n*(n-1)//2
for i in reversed(list(range(1,m))):
a,b=M[i][0],M[i][1]
s=union(a-1,b-1,s)
ANS.append(s)
for ans in ANS[::-1]:
print(ans)
| p03108 |
class Unionfind(): # 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 = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
uf = Unionfind(n)
ans, cnt = [], n * (n - 1) // 2
for a, b in ab[::-1]:
ans.append(max(cnt, 0))
if not uf.same(a - 1, b - 1):
cnt -= uf.size(a - 1) * uf.size(b - 1)
uf.union(a - 1, b - 1)
print(*ans[::-1], sep='\n')
| class Unionfind(): # 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)]
n, m = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
uf = Unionfind(n)
ans, cnt = [], n * (n - 1) // 2
for a, b in ab[::-1]:
ans.append(max(cnt, 0))
if uf.find(a - 1) != uf.find(b - 1):
cnt -= uf.size(a - 1) * uf.size(b - 1)
uf.union(a - 1, b - 1)
print(*ans[::-1], sep='\n')
| p03108 |
N,M=[int(x) for x in input().split()]
I=[[] for n in range(N)]
ans = int(N * (N-1) / 2)
E=[]
result=[]
def visit(i,V):
if(V[i]==0):
V[i]=1
total=1;
for n in I[i]:
if(V[n]==0):
total+=visit(n,V)
return total
else:
return 0
for m in range(M):
A,B=[int(x) for x in input().split()]
E.append((A-1,B-1))
for m in range(M):
result.append(ans)
if(ans>0):
A,B=E.pop()
V=[0 for n in range(N)]
Wa=visit(A,V)
Wb=visit(B,V)
ans=ans-(Wa*Wb)
I[A].append(B)
I[B].append(A)
for r in reversed(result):
print(r)
| N,M=[int(x) for x in input().split()]
G=[-1] * N
W=[0] * N
E=[]
result=[]
ans = int(N * (N-1) / 2)
def union(i,j):
gi=find(i)
gj=find(j)
if(gi!=gj):
if W[gi] > W[gj]:
G[gi]+=G[gj]
G[gj]=gi
else:
G[gj]+=G[gi]
G[gi]=gj
if W[gi]==W[gj]:
W[gj]+=1
def find(i):
if G[i]<0:
return i;
else:
G[i]=find(G[i])
return G[i]
for m in range(M):
A,B=[int(x) for x in input().split()]
E.append((A-1,B-1))
for m in range(M):
result.append(ans)
if(ans>0):
A,B=E.pop()
ga,gb=find(A),find(B)
if (ga!=gb):
ans=ans-(G[ga]*G[gb])
union(A,B)
for r in reversed(result):
print(r)
| p03108 |
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ans = [n*(n-1)//2]
remains = set(range(1, n+1))
sets = []
for i in range(m-1):
a, b = ab[-(i+1)]
if a in remains and b in remains:
sets.append(set([a, b]))
remains.remove(a)
remains.remove(b)
ans.append(ans[i] - 1)
elif a not in remains and b in remains:
for i_set in range(len(sets)):
if a in sets[i_set]:
size_a = len(sets[i_set])
sets[i_set].add(b)
remains.remove(b)
ans.append(ans[i] - size_a)
break
elif a in remains and b not in remains:
for i_set in range(len(sets)):
if b in sets[i_set]:
size_b = len(sets[i_set])
sets[i_set].add(a)
remains.remove(a)
ans.append(ans[i] - size_b)
break
else:
i_set_a, i_set_b = None, None
for i_set in range(len(sets)):
if a in sets[i_set]:
i_set_a = i_set
size_a = len(sets[i_set])
if b in sets[i_set]:
i_set_b = i_set
size_b = len(sets[i_set])
if i_set_a is not None and i_set_b is not None:
break
if i_set_a == i_set_b:
ans.append(ans[i])
else:
sets[i_set_a] = sets[i_set_a].union(sets[i_set_b])
sets.pop(i_set_b)
ans.append(ans[i] - size_a*size_b)
# print(sets, remains)
for a in ans[::-1]:
print(a)
| import sys
sys.setrecursionlimit(100000)
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)][::-1]
par, sizes = [-1]*(n+1), [1]*(n+1)
def find(i):
if par[i] < 0:
return i
else:
par[i] = find(par[i])
return par[i]
ans = [n*(n-1)//2]
for i in range(m-1):
a, b = ab[i]
pa, pb = find(a), find(b)
if pa != pb:
ans.append(ans[i] - sizes[pa]*sizes[pb])
par[pa] = pb
sizes[pb] += sizes[pa]
else:
ans.append(ans[i])
# print(par, sizes)
for ans_ in ans[::-1]:
print(ans_) | p03108 |
from collections import Counter
maxn = 100000
n , m = list(map(int, input().split()))
par = [0] * n
rank = [0] * n
#初期化
for i in range(n):
par[i] = i
rank[i] = 0
#判定(一番上野根を求める)
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x])
return par[x]
#結合
def unite(x , y):
rx = find(x)
ry = find(y)
if rx == ry:
return
if rank[rx] < rank[ry]:
par[rx] = ry
elif rank[rx] > rank[ry]:
par[ry] = rx
else:
par[ry] = x
rank[rx] += 1
a = [0] * m
b = [0] * m
for i in range(m):
a[i],b[i] = list(map(int,input().split()))
a[i] -= 1
b[i] -= 1
nn = [0]*(maxn+1)
for i in range(maxn+1):
nn[i] = i * (i-1) // 2
dis = [0]*m
for i in range(m-1,-1,-1):
ans = n*(n-1) // 2
l = [find(j) for j in range(n)]
ll = Counter(l)
values, counts = list(zip(*ll.most_common()))
for j in counts:
ans -= nn[j]
dis[i] = ans
unite(a[i],b[i])
for i in range(m):
print((dis[i])) | maxn = 100000
n , m = list(map(int, input().split()))
par = [0] * n
rank = [0] * n
siz = [1] * n
#初期化
for i in range(n):
par[i] = i
rank[i] = 0
#判定(一番上野根を求める)
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x])
return par[x]
#結合
def unite(x , y):
rx = find(x)
ry = find(y)
if rx == ry:
return
if rank[rx] < rank[ry]:
par[rx] = ry
siz[ry] += siz[rx]
siz[rx] = 0
elif rank[rx] > rank[ry]:
par[ry] = rx
siz[rx] += siz[ry]
siz[ry] = 0
else:
par[ry] = x
siz[rx] += siz[ry]
siz[ry] = 0
rank[rx] += 1
a = [0] * m
b = [0] * m
for i in range(m):
a[i],b[i] = list(map(int,input().split()))
a[i] -= 1
b[i] -= 1
nn = [0]*(maxn+1)
for i in range(maxn+1):
nn[i] = i * (i-1) // 2
dis = [0]*m
ans = n*(n-1) // 2
dis[m-1] = ans
for i in range(m-1,0,-1):
if find(a[i]) == find(b[i]):
dis[i-1] = ans
else:
ans -= (siz[find(a[i])] * siz[find(b[i])])
dis[i-1] = ans
unite(a[i],b[i])
for i in range(m):
print((dis[i])) | p03108 |
N,M=list(map(int,input().split()))
tree=[[]for i in range(N)]
bridge=[]
for i in range(M):
A,B=list(map(int,input().split()))
tree[A-1].append(B-1)
tree[B-1].append(A-1)
bridge.append((A,B))
ans=[]
All=N*(N-1)//2
for a,b in bridge:
ischecked=[0]*N
tree[a-1].pop(0)
tree[b-1].pop(0)
x=0
for i in range(N):
if ischecked[i]==1:
continue
count=0
q=[i]
while q:
now=q.pop()
if ischecked[now]==1:
continue
ischecked[now]=1
q.extend(tree[now])
count+=1
x+=count*(count-1)//2
ans.append(All-x)
for i in ans:
print(i) | N,M=list(map(int,input().split()))
bridge=[]
size=[1]*(N+1)
tree=list(range(N+1))
def find(a):
x=tree[a]
if a==x:
return a
y=find(x)
tree[a]=y
return y
for i in range(M):
A,B=list(map(int,input().split()))
bridge.append((A,B))
Ans=N*(N-1)//2
ans=[]
for a,b in bridge[::-1]:
aroot=find(a)
broot=find(b)
if aroot==broot:
ans.append(Ans)
continue
ans.append(Ans)
sa=size[aroot]
sb=size[broot]
Ans-=sa*sb
if sa>sb:
tree[broot]=aroot
size[aroot]+=sb
else:
tree[aroot]=broot
size[broot]+=sa
for i in ans[::-1]:
print(i) | p03108 |
import sys
sys.setrecursionlimit(2000)
n, m = map(int, input().split())
bridge = list(map(int, sys.stdin.read().split()))
total = n*(n-1)//2
ans =[total]
u = [-1]*(n+1)
size = [1]*(n+1)
rank = [1]*(n+1)
def check(x, y):
return find(x) != find(y)
def find(x):
if u[x] < 0 :
u[x] = x
return x
else:
return u[x]
for x , y in zip(bridge[-2::-2],bridge[::-2]):
if check(x, y):
X = find(x)
Y = find(y)
total -= size[X] * size[Y]
ans += [total]
if rank[X] == rank[Y]:
u = [Y if x == X else x for x in u]
rank =[x+1 if u[i] == Y else x for i, x in enumerate(rank)]
else:
if rank[X] > rank[Y]:
X, Y = Y, X
rank =[x+1 if u[i] == X else x for i, x in enumerate(rank)]
u = [Y if x == X else x for x in u]
size[Y] += size[X]
else:
ans += [total]
print(*ans[-2::-1], sep="\n")
| import sys
n , m, *e = map(int,sys.stdin.read().split())
total = n*(n-1)//2
ans =[total]
u = [-1]*(n+1)
def find(x):
if u[x] < 0 :
return x
else:
return find(u[x])
for x , y in zip(e[-2:1:-2],e[:1:-2]):
x = find(x)
y = find(y)
x, y = sorted((x, y))
if x != y:
total -= u[x] * u[y]
u[x] += u[y]
u[y] = x
ans += [total]
print(*ans[::-1], sep="\n")
| p03108 |
import math
def comb(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n, m = list(map(int, input().split()))
c = []
for i in range(m):#h:高さ
c.append([int(m) for m in input().split()])
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
self.rank = [0] * (n + 1)
self.le = [set() for i in range(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):
# 根を探す
self.le[self.find(x)].add(x)
self.le[self.find(y)].add(y)
x = self.find(x)
y = self.find(y)
# 木の高さを比較し、低いほうから高いほうに辺を張る
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.le[x] = self.le[x] | self.le[y]
self.le[y] = self.le[y] | self.le[x]
else:
self.par[y] = x
self.le[y] = self.le[y] | self.le[x]
self.le[x] = self.le[x] | self.le[y]
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return len(self.le[self.find(x)])
ansli = [((n - 1) * n) // 2]
alln = ((n - 1) * n) // 2
setn = set()
u = UnionFind(n)
aq = 0
for i in range(m - 1, 0, -1):
if c[i][0] not in setn and c[i][1] not in setn:
u.union(c[i][0], c[i][1])
setn.add(c[i][0])
setn.add(c[i][1])
aq += 1
elif c[i][0] in setn and c[i][1] not in setn:
aq += u.size(c[i][0])
u.union(c[i][0], c[i][1])
setn.add(c[i][1])
elif c[i][0] not in setn and c[i][1] in setn:
aq += u.size(c[i][1])
u.union(c[i][0], c[i][1])
setn.add(c[i][0])
else:
if u.same_check(c[i][0], c[i][1]):
u.union(c[i][0], c[i][1])
else:
aq += u.size(c[i][1]) * u.size(c[i][0])
u.union(c[i][0], c[i][1])
ansli.append(alln - aq)
for i in reversed(list(range(m))):
print((ansli[i])) | n, m = list(map(int, input().split()))
c = []
for i in range(m):#h:高さ
c.append([int(m) for m in input().split()])
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
self.par = [-1 for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
self.rank = [0] * (n + 1)
# 検索
# 根ならその番号を返す
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 union(self, x, y):
# 根を探す
x = self.find(x)
y = self.find(y)
#if x != y:
# 木の高さを比較し、低いほうから高いほうに辺を張る
if self.par[x] < self.par[y]:
self.par[x] += self.par[y]
self.par[y] = x
else:
self.par[y] += self.par[x]
self.par[x] = y
# 木の高さが同じなら片方を1増やす
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.par[self.find(x)]
ansli = [((n - 1) * n) // 2]
alln = ((n - 1) * n) // 2
setn = set()
u = UnionFind(n)
aq = 0
for i in range(m - 1, 0, -1):
if c[i][0] not in setn and c[i][1] not in setn:
u.union(c[i][0], c[i][1])
setn.add(c[i][0])
setn.add(c[i][1])
aq += 1
elif c[i][0] in setn and c[i][1] not in setn:
aq += u.size(c[i][0])
u.union(c[i][0], c[i][1])
setn.add(c[i][1])
elif c[i][0] not in setn and c[i][1] in setn:
aq += u.size(c[i][1])
u.union(c[i][0], c[i][1])
setn.add(c[i][0])
else:
if u.same_check(c[i][0], c[i][1]):
pass
else:
aq += u.size(c[i][1]) * u.size(c[i][0])
u.union(c[i][0], c[i][1])
ansli.append(alln - aq)
for i in reversed(list(range(m))):
print((ansli[i])) | p03108 |
import sys
input = sys.stdin.readline
#木の根を求める
def find(x):
if par[x] == x:
return x
else:
return find(par[x])
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
size[y] += size[x]
else:
par[y] = x
size[x] += size[y]
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
########################################
#初期化
n,m = list(map(int,input().split()))
par = [0]*n #親
for i in range(n):
par[i] = i
rank = [1]*n #深さ
size = [1]*n #size[i]:iを根とするグループのサイズ
edge2 = [[0] for i in range(m)]
for i in range(m):
edge2[i] = list(map(int,input().split()))
edge = [[0] for i in range(m)]
for i in range(m):
edge[i] = [edge2[m-1-i][0]-1,edge2[m-1-i][1]-1]
res = []
for i in range(m):
fi = find(edge[i][0])
se = find(edge[i][1])
if fi == se:
res.append(0)
else:
res.append(size[fi]*size[se])
unite(fi,se)
ass = 0
for i in range(m):
ass += res[m-1-i]
print(ass)
| import sys
input = sys.stdin.readline
#木の根を求める
def find(x):
if par[x] == x:
return x
else:
return find(par[x])
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
size[y] += size[x]
else:
par[y] = x
size[x] += size[y]
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
########################################
#初期化
n,m = list(map(int,input().split()))
par = [0]*n #親
for i in range(n):
par[i] = i
rank = [1]*n #深さ
size = [1]*n #size[i]:iを根とするグループのサイズ
edge = [tuple(map(int,input().split())) for i in range(m)]
edge = edge[::-1]
for i in range(m):
edge[i] = (edge[i][0]-1,edge[i][1]-1)
res = []
for i in range(m):
fi = find(edge[i][0])
se = find(edge[i][1])
if fi == se:
res.append(0)
else:
res.append(size[fi]*size[se])
unite(fi,se)
ass = 0
for i in range(m):
ass += res[m-1-i]
print(ass)
| p03108 |
import sys
input = sys.stdin.readline
#木の根を求める
def find(x):
if par[x] == x:
return x
else:
return find(par[x])
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x != y:
#xとyの属している集合が異なる時
if rank[x] < rank[y]:
par[x] = y
size[y] += size[x]
else:
par[y] = x
size[x] += size[y]
if rank[x]==rank[y]:
rank[x] += 1
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
########################################
#初期化
n,m = list(map(int,input().split()))
par = [0]*n #親
for i in range(n):
par[i] = i
rank = [1]*n #深さ
size = [1]*n #size[i]:iを根とするグループのサイズ
edge = [tuple(map(int,input().split())) for i in range(m)]
edge = edge[::-1]
for i in range(m):
edge[i] = (edge[i][0]-1,edge[i][1]-1)
res = []
for i in range(m):
fi = find(edge[i][0])
se = find(edge[i][1])
if fi == se:
res.append(0)
else:
res.append(size[fi]*size[se])
unite(fi,se)
ass = 0
for i in range(m):
ass += res[m-1-i]
print(ass)
| #Union Find
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
#根なら-size,子なら親の頂点
par = [-1]*n
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x != y:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
edge = [tuple(map(int,input().split())) for i in range(m)]
edge = edge[::-1]
for i in range(m):
edge[i] = (edge[i][0]-1,edge[i][1]-1)
res = []
for i in range(m):
fi = find(edge[i][0])
se = find(edge[i][1])
if fi == se:
res.append(0)
else:
res.append(size(fi)*size(se))
unite(fi,se)
ass = 0
for i in range(m):
ass += res[m-1-i]
print(ass) | p03108 |
import collections
N, M = list(map(int, input().split()))
bridges = reversed([[int(i) for i in input().split()] for i in range(M)])
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
_y = self.par[y]
for i in range(N):
if self.par[i] == _y: self.par[i] = x
def is_same(self, x, y):
return self.find(x) == self.find(y)
def solve():
uf = UnionFind(N)
ans = [str(N * (N - 1) // 2)]
for bridge in bridges:
uf.union(bridge[0] - 1, bridge[1] - 1)
C = collections.Counter(uf.par)
n = N
a = 0
for c in list(C.values()):
n -= c
a += n * c
ans.append(str(a))
ans.pop(-1)
return '\n'.join(reversed(ans))
print((solve()))
| class UnionFind:
def __init__(self, size):
self.parent = [-1 for i in range(size)]#非負なら親ノード，負ならグループの要素数
def root(self, x): #root(x): xの根ノードを返す．
if self.parent[x] < 0:
return x
else:
self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return self.parent[x]
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.parent[x] > self.parent[y]: #xの要素数がyの要素数より「小さい」とき入れ替える
x,y=y,x
self.parent[x] += self.parent[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return -self.parent[self.root(x)]
def solve():
N, M = list(map(int, input().split()))
bridges = [[int(i) - 1 for i in input().split()] for i in range(M)]
ans = [N * (N - 1) // 2]
uf = UnionFind(N)
for bridge in reversed(bridges):
A, B = bridge
if uf.issame(A, B):
ans.append(ans[-1])
else:
ans.append(ans[-1] - uf.size(A) * uf.size(B))
uf.merge(A, B)
ans.pop(-1)
return '\n'.join(map(str, reversed(ans)))
print((solve()))
| 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()))
AB = []
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
AB.append((a, b))
AB = AB[::-1]
uf = UnionFind(N)
ans = [0]
comb = N * (N - 1) // 2
for a, b in AB:
uf.union(a, b)
cnt = 0
# print(uf.all_group_members())
for v in list(uf.all_group_members().values()):
if 1 < len(v):
d = len(v)
cnt += d * (d - 1) // 2
ans.append(cnt)
ans = ans[:-1][::-1]
for x in ans:
print((comb - x)) | 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)
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()))
AB = []
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
AB.append((a, b))
AB = AB[::-1]
uf = UnionFind(N)
ans = []
comb = N * (N - 1) // 2
tmp = comb
for a, b in AB:
tmp -= uf.union(a, b)
# print(cnt)
ans.append(tmp)
# print(ans)
ans = ans[:-1][::-1]
# print(ans)
for x in ans:
print(x)
print(comb) | p03108 |
class UnionFind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
self.Maxroot = -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]
if self.root[x] < self.Maxroot:
self.Maxroot = self.root[x]
self.root[y] = x
else:
self.root[y] += self.root[x]
if self.root[y] < self.Maxroot:
self.Maxroot = self.root[y]
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)] * (-1)
N, M = list(map(int, input().split()))
a, b = [],[]
for _ in range(M):
at, bt = list(map(int, input().split()))
a.append(at)
b.append(bt)
solve = UnionFind(N)
ans = [0]
for i in reversed(list(range(M))):
tmp = 0
solve.Unite(a[i], b[i])
for i in range(1,N+1):
if solve.root[i] < -1:
t = solve.root[i]*(-1)
tmp += t*(t-1)//2
ans.append(tmp)
tot = N*(N-1)//2
for i in range(1,len(ans)):
print((tot-ans[-(i+1)])) | class UnionFind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
self.Maxroot = -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]
if self.root[x] < self.Maxroot:
self.Maxroot = self.root[x]
self.root[y] = x
else:
self.root[y] += self.root[x]
if self.root[y] < self.Maxroot:
self.Maxroot = self.root[y]
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)] * (-1)
N, M = list(map(int, input().split()))
a, b = [],[]
for _ in range(M):
at, bt = list(map(int, input().split()))
a.append(at)
b.append(bt)
solve = UnionFind(N)
ans = [0]
for i in reversed(list(range(M))):
ca,cb = a[i],b[i]
if solve.isSameGroup(ca,cb):
ans.append(ans[-1])
continue
num_group_a = solve.Count(ca)
num_group_b = solve.Count(cb)
tmp = num_group_a * num_group_b
solve.Unite(ca, cb)
ans.append(ans[-1]+tmp)
tot = N*(N-1)//2
for i in range(2,M+2):
print((tot-ans[-i])) | p03108 |
#!/usr/bin/env python3
from itertools import product
def main():
n, m = list(map(int, input().split()))
a = []
b = []
for _ in range(m):
ai, bi = list(map(int, input().split()))
a.append(ai-1)
b.append(bi-1)
# 不便さのMAX
result = [n * (n-1) // 2]
chained = [{i} for i in range(n)]
for j in range(m):
i = m - 1 - j
ai = a[i]
bi = b[i]
if ai not in chained[bi]:
next_val = result[-1]
for ac, bc in product(chained[ai], chained[bi]):
chained[ac].add(bc)
chained[bc].add(ac)
next_val -= 1
result.append(next_val)
else:
result.append(result[-1])
result.reverse()
for v in result[1:]:
print(v)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
from itertools import product
def main():
n, m = list(map(int, input().split()))
a = []
b = []
for _ in range(m):
ai, bi = list(map(int, input().split()))
a.append(ai-1)
b.append(bi-1)
# 不便さのMAX
result = [n * (n-1) // 2]
labels = [i for i in range(n)]
groups = {}
for i in range(n):
groups[i] = {i}
for j in range(m):
i = m - 1 - j
ai = a[i]
bi = b[i]
if labels[ai] != labels[bi]:
next_val = result[-1]
label_a = labels[ai]
label_b = labels[bi]
next_val -= len(groups[label_a]) * len(groups[label_b])
result.append(next_val)
groups[label_a] |= groups[label_b]
for bx in groups[label_b]:
labels[bx] = labels[ai]
del groups[label_b]
else:
result.append(result[-1])
result.reverse()
for v in result[1:]:
print(v)
if __name__ == '__main__':
main()
| p03108 |
import math
def P(n, r):
return math.factorial(n)//math.factorial(n-r)
def C(n, r):
return P(n, r)//math.factorial(r)
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 __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)
query = [list(map(int, input().split())) for _ in range(M)]
ans = C(N,2)
ans_arr = [0]*M
ans_arr[M-1] = ans
for i in range(M-1):
A, B = query[M-1-i][0]-1, query[M-1-i][1]-1
if not uf.same(A,B):
a_members = len(uf.members(A))
b_members = len(uf.members(B))
uf.union(A,B)
ans -= a_members * b_members
ans_arr[M-2-i] = ans
for i in ans_arr:
print(i) | import math
def P(n, r):
return math.factorial(n)//math.factorial(n-r)
def C(n, r):
return P(n, r)//math.factorial(r)
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 __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)
query = [list(map(int, input().split())) for _ in range(M)]
ans = C(N,2)
ans_arr = [0]*M
ans_arr[M-1] = ans
for i in range(M-1):
A, B = query[M-1-i][0]-1, query[M-1-i][1]-1
if not uf.same(A,B):
ans -= uf.size(A) * uf.size(B)
ans_arr[M-2-i] = ans
uf.union(A,B)
for i in ans_arr:
print(i) | p03108 |
N, M = list(map(int, input().split()))
ab = [tuple([int(x)-1 for x in input().split()]) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1 for _ in range(size)]
self.number = [1 for _ in range(size)]
def find(self, x):
while self.rank[x] >= 0:
x = self.rank[x]
return x
def union(self, s1, s2):
if s1 == s2:
return
if self.rank[s1] == self.rank[s2]:
self.rank[s1] -= 1
self.rank[s2] = s1
self.number[s1] += self.number[s2]
elif self.rank[s1] < self.rank[s2]:
self.rank[s2] = s1
self.number[s1] += self.number[s2]
else:
self.rank[s1] = s2
self.number[s2] += self.number[s1]
def main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab[1:]):
px = uf.find(x)
py = uf.find(y)
if px != py:
p -= uf.number[px] * uf.number[py]
uf.union(px, py)
ans.append(p)
for a in reversed(ans):
print(a)
main() | import sys
N, M = list(map(int, input().split()))
ab = [tuple([int(x)-1 for x in sys.stdin.readline().split()]) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1 for _ in range(size)]
self.number = [1 for _ in range(size)]
def find(self, x):
while self.rank[x] >= 0:
x = self.rank[x]
return x
def union(self, s1, s2):
if s1 == s2:
return
if self.rank[s1] == self.rank[s2]:
self.rank[s1] -= 1
self.rank[s2] = s1
self.number[s1] += self.number[s2]
elif self.rank[s1] < self.rank[s2]:
self.rank[s2] = s1
self.number[s1] += self.number[s2]
else:
self.rank[s1] = s2
self.number[s2] += self.number[s1]
def main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab[1:]):
px = uf.find(x)
py = uf.find(y)
if px != py:
p -= uf.number[px] * uf.number[py]
uf.union(px, py)
ans.append(p)
for a in reversed(ans):
print(a)
main() | p03108 |
import sys
from itertools import combinations
# https://ikatakos.com/pot/programming_algorithm/data_structure/union_find_tree
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
self.n = n
self.max_inconvenience = n * (n - 1) // 2
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def inconvenience(self):
res = self.max_inconvenience
for i, j in combinations(list(range(self.n)), 2):
if self.find(i, j):
res -= 1
return res
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
def main():
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
bridges = [tuple([int(x) - 1 for x in input().split()]) for _ in range(m)]
ans = [0] * m
ans[-1] = n * (n - 1) // 2
uf = UnionFind(n)
for i in range(m - 2, -1, -1):
uf.union(*bridges[i + 1])
ans[i] = uf.inconvenience()
for i in range(m):
print((ans[i]))
if __name__ == "__main__":
main()
| import sys
from itertools import combinations
# https://ikatakos.com/pot/programming_algorithm/data_structure/union_find_tree
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
self.n = n
self.inconvenience = n * (n - 1) // 2
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
self.inconvenience -= d1 * d2
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def main():
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
bridges = [tuple([int(x) - 1 for x in input().split()]) for _ in range(m)]
ans = [0] * m
ans[-1] = n * (n - 1) // 2
uf = UnionFind(n)
for i in range(m - 2, -1, -1):
uf.union(*bridges[i + 1])
ans[i] = uf.inconvenience
for i in range(m):
print((ans[i]))
if __name__ == "__main__":
main()
| p03108 |
import sys
from itertools import combinations
# https://ikatakos.com/pot/programming_algorithm/data_structure/union_find_tree
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
self.n = n
self.inconvenience = n * (n - 1) // 2
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
self.inconvenience -= d1 * d2
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def main():
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
bridges = [tuple([int(x) - 1 for x in input().split()]) for _ in range(m)]
ans = [0] * m
ans[-1] = n * (n - 1) // 2
uf = UnionFind(n)
for i in range(m - 2, -1, -1):
uf.union(*bridges[i + 1])
ans[i] = uf.inconvenience
for i in range(m):
print((ans[i]))
if __name__ == "__main__":
main()
| import sys
from itertools import combinations
# https://ikatakos.com/pot/programming_algorithm/data_structure/union_find_tree
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
self.n = n
self.inconvenience = n * (n - 1) // 2
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
self.inconvenience -= d1 * d2
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def main():
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
bridges = [tuple([int(x) - 1 for x in input().split()]) for _ in range(m)]
ans = [0] * m
ans[-1] = n * (n - 1) // 2
uf = UnionFind(n)
for i in range(m - 2, -1, -1):
uf.union(*bridges[i + 1])
ans[i] = uf.inconvenience
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| p03108 |
n,m = list(map(int, input().split()))
bridges = []
for i in range(m):
bridges.append([int(x) for x in input().split()])
'''
g = list(range(n+1))
ng = [1 for _ in range(n+1)]
gl = [[i] for i in range(n+1)]
ans = []
unconf = n*(n-1)//2
ans.append(unconf)
for x in reversed(bridges):
a,b = x
if g[a] != g[b]:
tmp = ng[g[a]] * ng[g[b]]
ng[g[a]] = ng[g[a]]+ng[g[b]]
gl[g[a]] = gl[g[a]] + gl[g[b]]
for y in gl[g[b]]:
g[y] = g[a]
unconf -= tmp
ans.append(unconf)
else:
ans.append(unconf)
ans.reverse()
ans.pop(0)
for x in ans:
print(x)
'''
def root(par, ifpar, a):
while ifpar[a] != 1:
a = par[a]
return a
def unite(cnt, par, ifpar, npar, ra, rb):
if cnt % 2 == 0:
npar[ra] = npar[ra] + npar[rb]
par[rb] = ra
ifpar[rb] = 0
else:
npar[rb] = npar[rb] + npar[ra]
par[ra] = rb
ifpar[ra] = 0
par = list(range(n+1))
ifpar = [1 for _ in range(n+1)]
npar = [1 for _ in range(n+1)]
ans = []
unconf = n*(n-1)//2
ans.append(unconf)
cnt = 0
for x in reversed(bridges):
a,b = x
ra = root(par, ifpar, a)
rb = root(par, ifpar, b)
if ra != rb:
tmp = npar[ra] * npar[rb]
unite(cnt, par, ifpar, npar, ra, rb)
unconf -= tmp
ans.append(unconf)
cnt += 1
ans.reverse()
ans.pop(0)
for x in ans:
print(x)
| n,m = list(map(int, input().split()))
bridges = []
for i in range(m):
bridges.append([int(x) for x in input().split()])
'''
g = list(range(n+1))
ng = [1 for _ in range(n+1)]
gl = [[i] for i in range(n+1)]
ans = []
unconf = n*(n-1)//2
ans.append(unconf)
for x in reversed(bridges):
a,b = x
if g[a] != g[b]:
tmp = ng[g[a]] * ng[g[b]]
ng[g[a]] = ng[g[a]]+ng[g[b]]
gl[g[a]] = gl[g[a]] + gl[g[b]]
for y in gl[g[b]]:
g[y] = g[a]
unconf -= tmp
ans.append(unconf)
else:
ans.append(unconf)
ans.reverse()
ans.pop(0)
for x in ans:
print(x)
'''
def root(par, ifpar, a):
while ifpar[a] != 1:
a = par[a]
return a
def unite(cnt, par, ifpar, npar, depth, ra, rb):
if depth[ra] >= depth[rb]:
npar[ra] = npar[ra] + npar[rb]
par[rb] = ra
ifpar[rb] = 0
if depth[ra] == depth[rb]:
depth[ra] += 1
else:
npar[rb] = npar[rb] + npar[ra]
par[ra] = rb
ifpar[ra] = 0
par = list(range(n+1))
ifpar = [1 for _ in range(n+1)]
npar = [1 for _ in range(n+1)]
depth = [1 for _ in range(n+1)]
ans = []
unconf = n*(n-1)//2
ans.append(unconf)
cnt = 0
for x in reversed(bridges):
a,b = x
ra = root(par, ifpar, a)
rb = root(par, ifpar, b)
if ra != rb:
tmp = npar[ra] * npar[rb]
unite(cnt, par, ifpar, npar, depth, ra, rb)
unconf -= tmp
ans.append(unconf)
cnt += 1
ans.reverse()
ans.pop(0)
for x in ans:
print(x) | p03108 |
import math
from collections import defaultdict
from collections import deque
class UnionFindTree:
'''
Union Find Tree
'''
def __init__(self):
self.p = {}
self.rank = {}
def make(self, x):
self.p[x] = x
self.rank[x] = 0
def find(self, x):
if x in self.p:
if self.p[x] != x:
# 経路圧縮
self.p[x] = self.find(self.p[x])
return self.p[x]
return None
def same(self, x, y):
return self.find(x) == self.find(y)
def unite(self, x, y):
return self._unite(self.find(x), self.find(y))
def _unite(self, x, y):
if self.rank[x] < self.rank[y]:
self.p[x] = y
return y
else:
self.p[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
return x
_ncr = {}
def ncr(n, r):
if n < r:
return 0
k = "{}:{}".format(n, r)
if k not in _ncr:
_ncr[k] = math.factorial(n) // (math.factorial(n - r) *
math.factorial(r))
return _ncr[k]
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(M)]
utf = UnionFindTree()
for n in range(1, N + 1):
utf.make(n)
h = {}
ans = deque([])
total = ncr(N, 2)
now = 0
for i in range(M):
ans.appendleft(total)
a, b = ab[M - i - 1]
x, y = utf.find(a), utf.find(b)
a = utf.unite(x, y)
if x != y:
nx, ny = h.get(x, 1), h.get(y, 1)
n = nx + ny
total += ncr(nx, 2) + ncr(ny, 2)
total -= ncr(n, 2)
h[x] = 1
h[y] = 1
h[a] = n
for v in ans:
print(v) | from collections import defaultdict
from collections import deque
class UnionFindTree:
def __init__(self):
self.p = {}
self.rank = {}
def make(self, x):
self.p[x] = x
self.rank[x] = 0
def find(self, x):
if x in self.p:
if self.p[x] != x:
# 経路圧縮
self.p[x] = self.find(self.p[x])
return self.p[x]
return None
def same(self, x, y):
return self.find(x) == self.find(y)
def unite(self, x, y):
return self._unite(self.find(x), self.find(y))
def _unite(self, x, y):
if self.rank[x] < self.rank[y]:
self.p[x] = y
return y
else:
self.p[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
return x
def nc2(n):
return (n * (n - 1)) >> 1
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(M)]
utf = UnionFindTree()
for n in range(1, N + 1):
utf.make(n)
h = {}
ans = deque([])
total = nc2(N)
now = 0
for i in range(M):
ans.appendleft(total)
a, b = ab[M - i - 1]
x, y = utf.find(a), utf.find(b)
a = utf.unite(x, y)
if x != y:
nx, ny = h.get(x, 1), h.get(y, 1)
n = nx + ny
total += nc2(nx) + nc2(ny)
total -= nc2(n)
h[x] = 1
h[y] = 1
h[a] = n
for v in ans:
print(v) | p03108 |
import sys
sys.setrecursionlimit(100000)
N,M=list(map(int,input().split()))
AB=[list(map(int,input().split())) for _ in range(M)]
AB.reverse()
par=list(range(1,N+1))
size=[1]*N
ans=[(N-1)*N//2]*M
def spar(n):
if par[n-1]==n:
return n
else:
return spar(par[n-1])
for i in range(0,M-1):
A,B=AB[i]
pa,pb=spar(par[A-1]),spar(par[B-1])
if pa==pb:
ans[i+1]=ans[i]
else:
ans[i+1]=ans[i]-size[pa-1]*size[pb-1]
sa,sb=size[pa-1],size[pb-1]
size[pa-1]+=sb
size[pb-1]+=sa
par[pa-1]=pa
par[pb-1]=pa
for i in reversed(ans):
print(i) | import sys
sys.setrecursionlimit(100000)
N,M=list(map(int,input().split()))
AB=[list(map(int,input().split())) for _ in range(M)]
AB.reverse()
par=list(range(1,N+1))
size=[1]*N
ans=[(N-1)*N//2]*M
def spar(n):
if par[n-1]==n:
return n
else:
par[n-1]=spar(par[n-1])
return par[n-1]
for i in range(0,M-1):
A,B=AB[i]
pa,pb=spar(par[A-1]),spar(par[B-1])
if pa==pb:
ans[i+1]=ans[i]
else:
ans[i+1]=ans[i]-size[pa-1]*size[pb-1]
sa,sb=size[pa-1],size[pb-1]
size[pa-1]+=sb
size[pb-1]+=sa
par[pa-1]=pa
par[pb-1]=pa
for i in reversed(ans):
print(i) | p03108 |
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)})
n,m=map(int,input().split())
ab=[]
for _ in range(m):
ab.append(list(map(int,input().split())))
ab = ab[::-1]
tree=UnionFind(n)
from itertools import combinations
anss=[]
for a,b in ab:
ans=0
for i,j in combinations(range(n),2):
ans += not tree.is_same(i,j)
anss.append(ans)
a -=1
b -=1
tree.unite(a,b)
print(*anss[::-1], sep="\n")
| 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)})
n,m=map(int,input().split())
ab=[]
for _ in range(m):
ab.append(list(map(int,input().split())))
ab = ab[::-1]
tree=UnionFind(n)
ans = (n*(n-1)//2)
res=[ans]
for a,b in ab[:-1]:
a -=1
b -=1
if tree.is_same(a,b):
pass
else:
ans -= tree.get_size(a)*tree.get_size(b)
res.append(ans)
tree.unite(a,b)
print(*[max(0,i) for i in res[::-1]], sep="\n")
| p03108 |
from itertools import combinations
n,m = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(m)]
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 roots(self):
return [i for i,x in enumerate(self.parents) if x < 0]
ans = [n*(n-1)//2]
island = Unionfind(n)
for a,b in reversed(AB[1:]):
island.union(a-1,b-1)
num = [island.size(r) for r in island.roots()]
cnt = 0
for v,w in combinations(num,2):
cnt += v*w
ans.append(cnt)
for a in reversed(ans):
print(a)
| n,m = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(m)]
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)
ans = [n*(n-1)//2]
island = Unionfind(n)
for a,b in reversed(AB[1:]):
if island.same(a-1,b-1):
cnt = ans[-1]
else:
cnt = ans[-1]-island.size(a-1)*island.size(b-1)
island.union(a-1,b-1)
ans.append(cnt)
for a in reversed(ans):
print(a)
| p03108 |
sn,bn=list(map(int,input().split(" ")))
fubensa=[int(sn*(sn-1)/2)]
if bn>1:
br=[]
for _ in range(bn):
br.append(list(map(int, input().split(" "))))
br=br[::-1]
sg=[0 for n in range(sn+1)]
sg[br[0][0]]=1
sg[br[0][1]]=1
gn=1
fubensa.append(fubensa[0]-1)
sgc=[0,2]
for bri in range(1,bn-1):
si1=br[bri][0]
si2=br[bri][1]
sg1=sg[si1]
sg2=sg[si2]
if sg1+sg2==0:
gn+=1
sg[si1],sg[si2]=gn,gn
sgc.append(2)
fubensa.append(fubensa[bri]-1)
elif sg1==0:
fubensa.append(fubensa[bri] - sgc[sg2])
sg[si1]=sg2
sgc[sg2]+=1
elif sg2==0:
fubensa.append(fubensa[bri] - sgc[sg1])
sg[si2]=sg1
sgc[sg1] += 1
elif sg1!=sg2:
fubensa.append(fubensa[bri] - sgc[sg1]*sgc[sg2])
if sgc[sg1]<sgc[sg2]:
sg1,sg2=sg2,sg1
sgc[sg1]+=sgc[sg2]
sg=[sg1 if x==sg2 else x for x in sg]
else:
fubensa.append(fubensa[bri])
for x in fubensa[::-1]:
print(x) | sn,bn=map(int,input().split(" "))
fu=[int(sn*(sn-1)/2)]
gr_si=[n for n in range(sn+1)]
siL_gr=[[n] for n in range(sn+1)]
siL_br=[]
for _ in range(bn):
siL_br.append(list(map(int, input().split(" "))))
siL_br=siL_br[::-1]
for bri in range(bn-1):
si1,si2=siL_br[bri]
gr1 = gr_si[si1]
gr2 = gr_si[si2]
if gr1==gr2:
fu.append(fu[bri])
else:
lengr1 = len(siL_gr[gr1])
lengr2 = len(siL_gr[gr2])
if lengr1<lengr2:
gr1,gr2=gr2,gr1
fu.append(fu[bri]-lengr1*lengr2)
for si in siL_gr[gr2]:
gr_si[si]=gr1
siL_gr[gr1]+=siL_gr[gr2]
siL_gr[gr2]=[]
print(*fu[::-1],sep="\n")
| p03108 |
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)]
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(m)]
uf=UnionFind(n)
ans=[0]*m
ans.append((n*(n-1))//2)
for i in range(m-1,-1,-1):
if uf.isSameGroup(ab[i][0],ab[i][1]):
ans[i]=ans[i+1]
else:
ans[i]=ans[i+1]-uf.Count(ab[i][0])*uf.Count(ab[i][1])
uf.Unite(ab[i][0],ab[i][1])
for i in range(1,m+1):
print((ans[i]))
| 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)]
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(m)]
uf=UnionFind(n)
ans=[0]*m
ans.append((n*(n-1))//2)
for i in range(m-1,-1,-1):
a,b=ab[i][0],ab[i][1]
if uf.isSameGroup(a,b):
ans[i]=ans[i+1]
else:
ans[i]=ans[i+1]-uf.Count(a)*uf.Count(b)
uf.Unite(a,b)
for i in range(1,m+1):
print((ans[i]))
| p03108 |
# https://atcoder.jp/contests/abc120/tasks/abc120_d
class UnionFind():
def __init__(self,n):
self.n = n
self.parents = [-1]*n
def find(self,x):
if self.parents[x] < 0:
return x
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def members(self, x): # 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 [list(self.members(r)) for r in self.roots()]
from itertools import combinations
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
data = [list(map(int, input().split())) for _ in range(M)]
tree = UnionFind(N)
res = []
for a, b in reversed(data):
a -= 1
b -= 1
tree.union(a, b)
islands = tree.all_group_members()
A = []
for i in range(len(islands)):
A.append(len(islands[i]))
inconv = 0
for p, q in combinations(A, 2):
inconv += p*q
res.append(inconv)
res.pop() # 橋が落ちる前の最初の状態については出力しない
for a in reversed(res):
print(a)
print((N*(N-1)//2)) # 全ての道が切れた時の不便さを最後に追加
'''
4 5
1 2
3 4
1 3
2 3
1 4
''' | # https://atcoder.jp/contests/abc120/tasks/abc120_d
class UnionFind():
def __init__(self,n):
self.n = n
self.parents = [-1]*n
def find(self,x):
if self.parents[x] < 0:
return x
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): # xの根のparent（= 要素数）を返す
return -self.parents[self.find(x)]
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 [list(self.members(r)) for r in self.roots()]
from itertools import combinations
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
data = [list(map(int, input().split())) for _ in range(M)]
tree = UnionFind(N)
res = []
inconv = N*(N-1)//2
for a, b in reversed(data): # O(M)
a -= 1
b -= 1
if tree.find(a) != tree.find(b):
inconv -= tree.size(a)*tree.size(b)
tree.union(a, b)
res.append(inconv)
res.pop() # 橋が落ちる前の最初の状態については出力しない
for a in reversed(res):
print(a)
print((N*(N-1)//2)) # 全ての道が切れた時の不便さを最後に追加
'''
4 5
1 2
3 4
1 3
2 3
1 4
''' | p03108 |
import sys
class UnionFind():
def __init__(self, num):
self.par = [-1]*num
self.size = [1]*num
def find(self, x):
if self.par[x] < 0:
return x
else:
x = self.par[x]
return self.find(x)
def union(self, x, y):
rx = self.find(x)
ry = self.find(y)
if rx != ry:
if self.par[rx] < self.par[ry]:
self.par[ry] = rx
self.size[rx] += self.size[ry]
elif self.par[rx] > self.par[ry]:
self.par[rx] = ry
self.size[ry] += self.size[rx]
else:
self.par[rx] -= 1
self.par[ry] = rx
self.size[rx] += self.size[ry]
return
def inpl(): return list(map(int, input().split()))
input = sys.stdin.readline
N, M = inpl()
Edge = [list([int(x) - 1 for x in input().split()]) for _ in range(M)]
UF = UnionFind(N)
ic = N*(N-1)//2
Ans = []
for i, (a, b) in enumerate(Edge[::-1]):
Ans.append(ic)
ra = UF.find(a)
rb = UF.find(b)
if ra != rb:
ic -= UF.size[ra]*UF.size[rb]
UF.union(a, b)
for a in Ans[::-1]:
print(a)
| import sys
class UnionFind():
def __init__(self, num):
self.par = [-1]*num
def find(self, x):
if self.par[x] < 0:
return x
else:
x = self.par[x]
return self.find(x)
def union(self, x, y):
rx = self.find(x)
ry = self.find(y)
prx = self.par[rx]
pry = self.par[ry]
if rx != ry:
if prx <= pry:
self.par[ry] = rx
self.par[rx] += pry
else:
self.par[rx] = ry
self.par[ry] += prx
return
def inpl(): return list(map(int, input().split()))
input = sys.stdin.readline
N, M = inpl()
Edge = [list([int(x) - 1 for x in input().split()]) for _ in range(M)]
UF = UnionFind(N)
ic = N*(N-1)//2
Ans = []
for i, (a, b) in enumerate(Edge[::-1]):
Ans.append(ic)
ra = UF.find(a)
rb = UF.find(b)
if ra != rb:
ic -= UF.par[ra]*UF.par[rb]
UF.union(a, b)
for a in Ans[::-1]:
print(a)
| p03108 |
# https://atcoder.jp/contests/abc120/tasks/abc120_d
import itertools
import collections
import bisect
import sys
input = sys.stdin.readline
# Union find
class UnionFind():
#負の値の場合根を表す。絶対値はツリーの高さ
#正の値は次の要素を返す、根まで続く
def __init__(self,size):
self.table = [-1 for _ in range(size)]
self.size_table = [1 for _ in range(size)]
# 集合の代表を求める
def find(self, x):
while self.table[x] >= 0:
# 根に来た時,self.table[根のindex]は負の値なのでx = 根のindexで値が返される。
x = self.table[x]
return x
# 併合
def union(self, x, y):
s1 = self.find(x) # 根のindex,table[s1]がグラフの高さ
s2 = self.find(y)
if s1 != s2: # 根が異なる場合
if self.table[s1] != self.table[s2]: # グラフの高さが異なる場合
if self.table[s1] < self.table[s2]:
self.table[s2] = s1
self.size_table[s1] += self.size_table[s2]
else:
self.table[s1] = s2
self.size_table[s2] += self.size_table[s1]
else:
# グラフの長さが同じ場合,どちらを根にしても変わらない
# その際,グラフが1長くなることを考慮する
self.table[s1] += -1
self.table[s2] = s1
self.size_table[s1] += self.size_table[s2]
return
def size(self, x):
return self.size_table[self.find(x)]
def main():
N, M = list(map(int, input().split()))
bridges = [list(map(int, input().split())) for _ in range(M)]
bridges = list([[i-1 for i in l] for l in bridges])
# print(bridges)
fuben = N * (N-1) // 2
answers = []
uf = UnionFind(N)
for j in range(len(bridges)-1, 0, -1):
br = bridges[j]
if uf.find(br[0]) == uf.find(br[1]): # もともと繋がってる
answers.insert(0, fuben)
else: # 新しく繋がる
b1 = uf.size(br[0])
b2 = uf.size(br[1])
fuben = fuben - b1 * b2
answers.insert(0, fuben)
uf.union(br[0], br[1])
# print(answers)
for a in answers:
print(a)
# 最後
print((N * (N-1) // 2))
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/abc120/tasks/abc120_d
import itertools
import collections
import bisect
import sys
input = sys.stdin.readline
# Union find
class UnionFind():
#負の値の場合根を表す。絶対値はツリーの高さ
#正の値は次の要素を返す、根まで続く
def __init__(self,size):
self.table = [-1 for _ in range(size)]
self.size_table = [1 for _ in range(size)]
# 集合の代表を求める
def find(self, x):
while self.table[x] >= 0:
# 根に来た時,self.table[根のindex]は負の値なのでx = 根のindexで値が返される。
x = self.table[x]
return x
# 併合
def union(self, x, y):
s1 = self.find(x) # 根のindex,table[s1]がグラフの高さ
s2 = self.find(y)
if s1 != s2: # 根が異なる場合
if self.table[s1] != self.table[s2]: # グラフの高さが異なる場合
if self.table[s1] < self.table[s2]:
self.table[s2] = s1
self.size_table[s1] += self.size_table[s2]
else:
self.table[s1] = s2
self.size_table[s2] += self.size_table[s1]
else:
# グラフの長さが同じ場合,どちらを根にしても変わらない
# その際,グラフが1長くなることを考慮する
self.table[s1] += -1
self.table[s2] = s1
self.size_table[s1] += self.size_table[s2]
return
def size(self, x):
return self.size_table[self.find(x)]
def main():
N, M = list(map(int, input().split()))
bridges = [list(map(int, input().split())) for _ in range(M)]
bridges = list([[i-1 for i in l] for l in bridges])
# print(bridges)
fuben = N * (N-1) // 2
answers = []
uf = UnionFind(N)
for j in range(len(bridges)-1, 0, -1):
br = bridges[j]
if uf.find(br[0]) != uf.find(br[1]): # 新しく繋がってる
fuben -= (uf.size(br[0]) * uf.size(br[1]))
answers.append(fuben)
uf.union(br[0], br[1])
# print(answers)
for a in reversed(answers):
print(a)
# 最後
print((N * (N-1) // 2))
if __name__ == '__main__':
main()
| p03108 |
from collections import deque
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
self.size = [1]*n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
else:
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
def same_check(self, x, y):
return self.find(x) == self.find(y)
def tree_size(self, x):
return self.size[self.find(x)]
N, M = list(map(int, input().split()))
bridge = [[int(_) for _ in input().split()] for _ in range(M)]
uf = UnionFind(N+1)
anslist = deque()
ans = N*(N-1)//2
anslist.append(ans)
for i in range(M-1):
island1 = bridge[M-i-1][0]
island2 = bridge[M-i-1][1]
if uf.find(island1) != uf.find(island2):
ans -= uf.tree_size(island1) * uf.tree_size(island2)
anslist.append(ans)
uf.unite(bridge[M-i-1][0], bridge[M-i-1][1])
for _ in range(M):
print((anslist.pop())) | from collections import deque
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
self.size = [1]*n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
else:
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
def same_check(self, x, y):
return self.find(x) == self.find(y)
def tree_size(self, x):
return self.size[self.find(x)]
N, M = list(map(int, input().split()))
bridge = [[int(_) for _ in input().split()] for _ in range(M)]
uf = UnionFind(N+1)
anslist = deque()
ans = N*(N-1)//2
anslist.append(ans)
for i in range(M-1):
island1 = bridge[M-i-1][0]
island2 = bridge[M-i-1][1]
if uf.find(island1) != uf.find(island2):
ans -= uf.tree_size(island1) * uf.tree_size(island2)
anslist.append(ans)
uf.unite(bridge[M-i-1][0], bridge[M-i-1][1])
for _ in range(M):
print((anslist.pop())) | p03108 |
#!/usr/bin/env python3
import sys
# refered to
# rank : http://at274.hatenablog.com/entry/2018/02/02/173000
# size : abc120 kaisetsu
class UnionFind:
def __init__(self, n):
# par = Parent Number or NoV
self.par = [-1] * (n+1)
# rank = Tree Height
self.rank = [0] * (n+1)
# 自分が所属する集合の数を返す
def size(self, x):
return -1*self.par[self.find(x)]
# 根なら番号を返す
def find(self, x):
if(self.par[x] < 1):
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
# 親が同じか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
# 根を探す
x = self.find(x)
y = self.find(y)
# もう繋がれている
if(x == y):
return False
# つなぎ替える
if(self.size(x) < self.size(y)):
x,y = y,x
# xのサイズを更新
self.par[x] += self.par[y]
# yのサイズ(おやばんごう)をxに
self.par[y] = x
return True
from operator import mul
from functools import reduce
def solve(N: int, M: int, A: "List[int]", B: "List[int]"):
ans = [0] * (M+1)
for i in range(M):
uf = UnionFind(N)
for j in reversed(list(range(i+1, M))):
uf.union(A[j], B[j])
if(uf.same_check(A[i], B[i])):
ans[i+1] = ans[i]
else:
ans[i+1] = ans[i] + uf.size(A[i]) * uf.size(B[i])
for i in ans[1:M+1]:
print(i)
return
# Generated by 1.1.3 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
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
# refered to
# rank : http://at274.hatenablog.com/entry/2018/02/02/173000
# size : abc120 kaisetsu
class UnionFind:
def __init__(self, n):
# par = Parent Number or NoV
self.par = [-1] * (n+1)
# rank = Tree Height
self.rank = [0] * (n+1)
# 自分が所属する集合の数を返す
def size(self, x):
return -1*self.par[self.find(x)]
# 根なら番号を返す
def find(self, x):
if(self.par[x] < 1):
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
# 親が同じか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
# 根を探す
x = self.find(x)
y = self.find(y)
# もう繋がれている
if(x == y):
return False
# つなぎ替える
if(self.size(x) < self.size(y)):
x,y = y,x
# xのサイズを更新
self.par[x] += self.par[y]
# yのサイズ(おやばんごう)をxに
self.par[y] = x
return True
def solve(N: int, M: int, A: "List[int]", B: "List[int]"):
ans = [0] * (M)
uf = UnionFind(N)
ans[M-1] = int(N*(N-1)/2)
for i in reversed(list(range(1,M))):
if(not uf.same_check(A[i], B[i])):
ans[i-1] = ans[i] - uf.size(A[i])*uf.size(B[i])
else:
ans[i-1] = ans[i]
uf.union(A[i], B[i])
for i in ans:
print(i)
return
# Generated by 1.1.3 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
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()
| p03108 |
#!/usr/bin/env python3
import sys
# refered to
# rank : http://at274.hatenablog.com/entry/2018/02/02/173000
# size : abc120 kaisetsu
class UnionFind:
def __init__(self, n):
# par = Parent Number or NoV
self.par = [-1] * (n+1)
# rank = Tree Height
self.rank = [0] * (n+1)
# Returns the number of sets to which x belongs
def size(self, x):
return -1*self.par[self.find(x)]
def size_list(self):
return [x*(-1) for x in self.par[1:] if x < 0]
# Returns number if root
def find(self, x):
if(self.par[x] < 1):
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
# Are the parents of x and y the same?
def same_check(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
# find root
x = self.find(x)
y = self.find(y)
# Already x connect to y
if(x == y):
return False
# Reconnect
if(self.size(x) < self.size(y)):
x,y = y,x
# update x size
self.par[x] += self.par[y]
# set parent number of y to x
self.par[y] = x
return True
def root_nodes(self):
return [-i for i in self.par[1:] if i <= -1]
def solve(N: int, M: int, A: "List[int]", B: "List[int]"):
import math
def combination(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
ans = []
uf = UnionFind(N)
ans.append((N-1)*N//2)
for i in range(M-1, 0, -1):
uf.union(A[i], B[i])
r = uf.root_nodes()
tans = sum([x*(N-x) for x in r])//2
ans.append(tans)
for i in reversed(list(range(len(ans)))):
print((ans[i]))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
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
# refered to
# rank : http://at274.hatenablog.com/entry/2018/02/02/173000
# size : abc120 kaisetsu
class UnionFind:
def __init__(self, n):
# par = Parent Number or NoV
self.par = [-1] * (n+1)
# rank = Tree Height
self.rank = [0] * (n+1)
# Returns the number of sets to which x belongs
def size(self, x):
return -1*self.par[self.find(x)]
def size_list(self):
return [x*(-1) for x in self.par[1:] if x < 0]
# Returns number if root
def find(self, x):
if(self.par[x] < 1):
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
# Are the parents of x and y the same?
def same_check(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
# find root
x = self.find(x)
y = self.find(y)
# Already x connect to y
if(x == y):
return False
# Reconnect
if(self.size(x) < self.size(y)):
x,y = y,x
# update x size
self.par[x] += self.par[y]
# set parent number of y to x
self.par[y] = x
return True
# def root_nodes(self):
# return [-i for i in self.par[1:] if i <= -1]
def solve(N: int, M: int, A: "List[int]", B: "List[int]"):
ans = []
uf = UnionFind(N)
ans.append((N-1)*N//2)
for i in range(M-1, 0, -1):
if uf.find(A[i]) != uf.find(B[i]):
ans.append(max(0, ans[-1]-uf.size(A[i])*uf.size(B[i])))
uf.union(A[i], B[i])
else:
ans.append(ans[-1])
for i in reversed(list(range(len(ans)))):
print((ans[i]))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
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()
| p03108 |
tmp=input().split(" ")
n = int(tmp[0])
m = int(tmp[1])
node_groups = [ i for i in range(n)]
group_nodes = [ [i] for i in range(n)]
edges = []
for i in range(m):
tmp=input().split(" ")
edges.append([int(tmp[0])-1, int(tmp[1])-1])
hubensa_list = [0] * (m + 1)
hubensa_list[m] = n*(n-1)//2
for i in range(m-1, 0, -1):
edge = edges[i]
# print("edge: ", edge)
# print("node_groups: ", node_groups)
node_1 = edge[0]
node_2 = edge[1]
node_1_group = node_groups[node_1]
node_2_group = node_groups[node_2]
if node_1_group == node_2_group:
hubensa_list[i] = hubensa_list[i+1]
continue
group_of_node_1 = group_nodes[node_1_group]
group_of_node_2 = group_nodes[node_2_group]
len_1 = len(group_of_node_1)
len_2 = len(group_of_node_2)
group_nodes[node_2_group] = None
group_of_node_1.extend(group_of_node_2)
for j in group_of_node_2:
# print("group_update: ",j, node_1_group)
node_groups[j] = node_1_group
# 不便さをだす
hubensa_list[i] = hubensa_list[i+1] - (len_1 * len_2)
for i in range(1, m+1):
print((hubensa_list[i])) | import sys
sys.setrecursionlimit(100000)
tmp=input().split(" ")
n = int(tmp[0])
m = int(tmp[1])
node_groups = [ i for i in range(n)]
group_sizes = [ 1 for _ in range(n)]
edges = []
for i in range(m):
tmp=input().split(" ")
edges.append([int(tmp[0])-1, int(tmp[1])-1])
hubensa_list = [0] * (m + 1)
hubensa_list[m] = n*(n-1)//2
def root(i):
if node_groups[i] == i:
#print(i, "is root.")
return i
else:
#_1 = node_groups[i]
node_groups[i] = root(node_groups[i])
#_2 = node_groups[i]
#print ("root: ", _1, _2)
return node_groups[i]
def same(a, b):
return root(a) == root(b)
def size(i):
return group_sizes[root(i)]
def unite(a, b):
a = root(a)
b = root(b)
if a == b:
return
group_sizes[a] += size(b)
node_groups[b] = a
for i in range(m-1, -1, -1):
edge = edges[i]
# print("edge: ",edge)
#print("node_groups: ", node_groups)
node_1 = edge[0]
node_2 = edge[1]
root_1 = root(node_1)
root_2 = root(node_2)
if root_1 == root_2:
hubensa_list[i] = hubensa_list[i+1]
continue
# 不便さをだす
hubensa_list[i] = hubensa_list[i+1] - (size(root_1) * size(root_2))
unite(root_1, root_2)
#print("node_groups: ", node_groups)
for i in range(1, m+1):
print((hubensa_list[i])) | p03108 |
from collections import Counter
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 all_group_members_comb(self):
tmp = 0
self_roots = self.roots()
for r in self_roots:
len_member = len(self.members(r))
if len_member > 1:
tmp += len_member * (len_member-1) / 2
return tmp
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(M)]
uf = UnionFind(N)
N_comb = N*(N-1)/2
ans = [N_comb]
for i in range(1,M):
a,b = ab[-i]
uf.union(a-1,b-1)
ans.append(N_comb - uf.all_group_members_comb())
ans.sort()
for i in range(M):
print((int(ans[i]))) | from collections import Counter
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
tmp = abs(self.parents[x]) * (abs(self.parents[x])-1) / 2 + abs(self.parents[y]) * (abs(self.parents[y])-1) / 2
self.parents[x] += self.parents[y]
self.parents[y] = x
return abs(self.parents[x]) * (abs(self.parents[x])-1) / 2 - tmp
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 all_group_members_comb(self):
tmp = 0
self_roots = self.roots()
for r in self_roots:
len_member = len(self.members(r))
if len_member > 1:
tmp += len_member * (len_member-1) / 2
return tmp
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(M)]
uf = UnionFind(N)
N_comb = N*(N-1)/2
ans = [N_comb]
for i in range(1,M):
a,b = ab[-i]
N_comb -= uf.union(a-1,b-1)
ans.append(N_comb)
ans.sort()
for i in range(M):
print((int(ans[i]))) | p03108 |
def find(tab, a):
if tab[a]==-1:
return a
tab[a] = find(tab, tab[a])
return tab[a]
def union(tab, a, b):
p1, p2 = find(tab, a), find(tab, b)
if p1 != p2:
tab[p1] = p2
def count(tab, a):
ans = 0
parent = find(tab, a)
for b in range(len(tab)):
if find(tab, b) == parent:
ans += 1
return ans
N, M = [int(a) for a in input().split(" ")]
ABs = [[int(a) for a in input().split(" ")] for i in range(M)]
tab = [-1]*N
arr = []
for a, b in reversed(ABs):
pa, pb = (find(tab, a-1), find(tab, b-1))
if pa!=pb:
na = count(tab, pa)
nb = count(tab, pb)
dn = ((na+nb)*(na+nb-1)//2)-(na*(na-1)//2)-(nb*(nb-1)//2)
arr.append(dn)
else:
arr.append(0)
union(tab, a-1, b-1)
acc = 0
for cp in reversed(arr):
acc += cp
print(acc)
| import sys
sys.setrecursionlimit(100000)
def find(tab, a):
if tab[0][a]==a:
return a
tab[0][a] = find(tab, tab[0][a])
return tab[0][a]
def union(tab, a, b):
p1, p2 = (find(tab, a), find(tab, b))
if p1 != p2:
tab[0][p1] = p2
tab[1][p2] += tab[1][p1]
def size(tab, a):
return tab[1][a]
N, M = [int(a) for a in input().split(" ")]
ABs = [[int(a) for a in input().split(" ")] for i in range(M)]
tab = [[i for i in range(N)], [1 for i in range(N)]]
arr = []
for a, b in reversed(ABs):
a, b = (a-1, b-1)
pa, pb = (find(tab, a), find(tab, b))
na, nb = (size(tab, pa), size(tab, pb))
if pa!=pb:
dn = ((na+nb)*(na+nb-1)//2)-(na*(na-1)//2)-(nb*(nb-1)//2)
arr.append(dn)
union(tab, a, b)
else:
arr.append(0)
acc = 0
for cp in reversed(arr):
acc += cp
print(acc)
| p03108 |
class UnionFind():
'''
@properties
parents:
- 各要素の親要素の番号を格納するリスト
- 要素が根の場合はそのグループの要素数を格納する
'''
def __init__(self,n):
self.n = n
self.parents = [-1] * n
def __str__(self):
return '\n'.join('{}: {}'.format(r,self.members(r)) for r in self.roots())
def find(self,x):
if self.parents[x] < 0: #初期値の場合
return x
else:
self.parents[x] = self.find(self.parents[x]) #どの根に紐づいているかを判断する
return self.parents[x]
def union(self,x,y):
x = self.find(x) #どの根に紐づいているかを判断する
y = self.find(y) #どの根に紐づいているかを判断する
if x == y: #同じ根に紐づいている場合は何もしない
return
if self.parents[x] > self.parents[y]:
x,y = y,x
self.parents[x] += self.parents[y] #根の個数を増やす。。？
self.parents[y] = x #根を変更する
def members(self,x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x < 0 ]
def weighted_roots_sizes(self):
return [ self.size(i) for i,x in enumerate(self.parents) if x < -1 ]
def size(self,x):
return -self.parents[self.find(x)]
N,M = list(map(int,input().split(' ')))
bridges = [ list(map(int,input().split(' '))) for _ in range(M) ]
uf = UnionFind(N)
base_num = N * (N-1) //2
output_list = [0]*(M+1)
output_list[M] = base_num
for i in reversed(list(range(M))):
bridge_from = bridges[i][0] - 1
bridge_to = bridges[i][1] - 1
uf.union(bridge_from,bridge_to)
current_amount = 0
for size in uf.weighted_roots_sizes():
current_amount += size * (size -1) //2
output_list[i] = base_num - current_amount
for i in range(1,M+1):
print((output_list[i]))
| class UnionFind():
'''
@properties
parents:
- 各要素の親要素の番号を格納するリスト
- 要素が根の場合はそのグループの要素数を格納する
'''
def __init__(self,n):
self.n = n
self.parents = [-1] * n
def __str__(self):
return '\n'.join('{}: {}'.format(r,self.members(r)) for r in self.roots())
def find(self,x):
if self.parents[x] < 0: #初期値の場合
return x
else:
self.parents[x] = self.find(self.parents[x]) #どの根に紐づいているかを判断する
return self.parents[x]
def union(self,x,y):
x = self.find(x) #どの根に紐づいているかを判断する
y = self.find(y) #どの根に紐づいているかを判断する
if x == y: #同じ根に紐づいている場合は何もしない
return
if self.parents[x] > self.parents[y]:
x,y = y,x
self.parents[x] += self.parents[y] #根の個数を増やす。。？
self.parents[y] = x #根を変更する
def members(self,x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x < 0 ]
def weighted_roots_sizes(self):
return [ self.size(i) for i,x in enumerate(self.parents) if x < -1 ]
def size(self,x):
return -self.parents[self.find(x)]
N,M = list(map(int,input().split(' ')))
bridges = [ list(map(int,input().split(' '))) for _ in range(M) ]
uf = UnionFind(N)
base_num = N * (N-1) //2
output_list = [0]*(M+1)
output_list[M] = base_num
for i in reversed(list(range(M))):
bridge_from = bridges[i][0] - 1
bridge_to = bridges[i][1] - 1
current_amount = 0
if uf.find(bridge_from) == uf.find(bridge_to):
output_list[i] = output_list[i+1]
continue
output_list[i] = output_list[i+1] - uf.size(bridge_from) * uf.size(bridge_to)
uf.union(bridge_from,bridge_to)
for i in range(1,M+1):
print((output_list[i]))
| p03108 |
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
self.parent = [i for i in range(n + 1)]
# 木の高さを格納する（初期状態では0）
self.rank = [0] * (n + 1)
# 木の要素数
self.size = [1] * (n + 1)
self.score = n * (n - 1) // 2
# 検索
def find(self, x):
if self.parent[x] == x: # 根ならその番号を返す
return x
else: # 走査していく過程で親を書き換える
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
# 併合
def union(self, x, y):
# 根を探す
parent_x = self.find(x)
parent_y = self.find(y)
if(parent_x != parent_y):
if self.rank[parent_x] == self.rank[parent_y]:
# 木の高さが同じなら片方を1増やす
self.rank[parent_x] += 1 # ここのxとyはどちらでも良い
elif self.rank[parent_x] < self.rank[parent_y]:
# 木の高さを比較し、低いほうから高いほうに辺を張る
parent_x, parent_y = parent_y, parent_x
self.score -= self.size[parent_x] * self.size[parent_y]
self.parent[parent_y] = parent_x
self.size[parent_x] += self.size[parent_y]
def getsize(self, x):
return self.size[self.find(x)]
def same_check(self, x, y): # 同じ集合に属するか判定
return self.find(x) == self.find(y)
def main():
N, M = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for i in range(M)]
uni = UnionFind(N)
score_list = []
for i in range(1, M + 1, 1):
inp = AB[::-1][i - 1]
score_list.append(uni.score)
uni.union(inp[0] - 1, inp[1] - 1)
print(*score_list[::-1], sep="\n")
if __name__ == "__main__":
main()
| class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
self.parent = [i for i in range(n + 1)]
# 木の高さを格納する（初期状態では0）
self.rank = [0] * (n + 1)
# 木の要素数
self.size = [1] * (n + 1)
self.score = n * (n - 1) // 2
# 検索
def find(self, x):
if self.parent[x] == x: # 根ならその番号を返す
return x
else: # 走査していく過程で親を書き換える
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
# 併合
def union(self, x, y):
# 根を探す
parent_x = self.find(x)
parent_y = self.find(y)
if(parent_x != parent_y):
if self.rank[parent_x] == self.rank[parent_y]:
# 木の高さが同じなら片方を1増やす
self.rank[parent_x] += 1 # ここのxとyはどちらでも良い
elif self.rank[parent_x] < self.rank[parent_y]:
# 木の高さを比較し、低いほうから高いほうに辺を張る
parent_x, parent_y = parent_y, parent_x
self.score -= self.size[parent_x] * self.size[parent_y]
self.parent[parent_y] = parent_x
self.size[parent_x] += self.size[parent_y]
def getsize(self, x):
return self.size[self.find(x)]
def same_check(self, x, y): # 同じ集合に属するか判定
return self.find(x) == self.find(y)
def main():
N, M = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for i in range(M)]
uni = UnionFind(N)
score_list = []
for i in range(M-1, -1, -1):
inp = AB[i]
score_list.append(uni.score)
uni.union(inp[0], inp[1])
print(*score_list[::-1], sep="\n")
if __name__ == "__main__":
main()
| p03108 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
# A = [ int(input()) for _ in range(N) ]
##############################
class UnionFind:
def __init__(self, N):
self.rank = [0] * N
self.parent = [i for i in range(N)]
self.n = N
self.size = [1 for i in range(N)]
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if (x == y):
return
if (self.rank[x] < self.rank[y]):
self.parent[x] = y
self.size[y] += self.size[x]
else:
self.parent[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def get_parents(self):
count = 0
for i in range(self.n):
if self.find(i) == i:
count += 1
return count
def get_size(self, x):
root = self.find(x)
return self.size[root]
N, M = map(int, input().split())
A = []
B = []
for i in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
A.append(a)
B.append(b)
uf = UnionFind(N)
ans = [0] * M
huben = (N*(N-1)) // 2
i = M-1
while i >= 0:
ans[i] = huben
if not uf.same(A[i], B[i]):
huben -= uf.get_size(A[i]) * uf.get_size(B[i])
uf.unite(A[i], B[i])
i -= 1
print(*ans, sep="\n")
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
# A = [ int(input()) for _ in range(N) ]
##############################
class UnionFind:
def __init__(self, N):
self.rank = [0] * N
self.parent = [i for i in range(N)]
self.n = N
self.size = [1 for i in range(N)]
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if (x == y):
return
if (self.rank[x] < self.rank[y]):
self.parent[x] = y
self.size[y] += self.size[x]
else:
self.parent[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def get_parents(self):
count = 0
for i in range(self.n):
if self.find(i) == i:
count += 1
return count
def get_size(self, x):
root = self.find(x)
return self.size[root]
N, M = map(int, input().split())
A = []
B = []
for i in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
A.append(a)
B.append(b)
uf = UnionFind(N)
ans = [0] * M
i = M-1
ans[i] = (N*(N-1)) // 2
while i > 0:
if not uf.same(A[i], B[i]):
ans[i-1] = ans[i] - (uf.get_size(A[i]) * uf.get_size(B[i]))
uf.unite(A[i], B[i])
else:
ans[i-1] = ans[i]
i -= 1
print(*ans, sep="\n")
| p03108 |
#sizeありversion
class DisjointSet:
def __init__(self):
self.rank = {}
self.p = {}
self._size = {}
def makeSet(self, x):
self.p[x] = x
self.rank[x] = 0
self._size[x] = 1
def same(self, x, y):
return self.findSet(x) == self.findSet(y)
def unite(self, x, y):
self.link(self.findSet(x), self.findSet(y))
def link(self, x, y):
if(self.rank[x] > self.rank[y]):
self.p[y] = x
self._size[x] += self._size[y]
self._size[y] = 0
else:
self.p[x] = y
self._size[y] += self._size[x]
self._size[x] = 0
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
#頂点xが属するグループと同じグループに属する頂点数を得る
def size(self, x):
return self._size[self.findSet(x)]
def findSet(self, x):
if(x != self.p[x]):
self.p[x] = self.findSet(self.p[x])
return self.p[x]
N, M = list(map(int, input().split()))
l = [[int(i) for i in input().split()] for i in range(M)]
ds = DisjointSet()
for i in range(N):
ds.makeSet(i+1)
ans = [0] * M
ans[M-1] = N * (N - 1) // 2
for i in range(M-1, 0, -1):
a, b = l[i]
if ds.same(a, b):
ans[i-1] = ans[i]
else:
x = ds.size(a)
y = ds.size(b)
ans[i-1] = ans[i] - x * y
ds.unite(a, b)
for a in ans:
print(a) | #sizeありversion
class DisjointSet:
def __init__(self):
self.rank = {}
self.p = {}
self._size = {}
def makeSet(self, x):
self.p[x] = x
self.rank[x] = 0
self._size[x] = 1
def same(self, x, y):
return self.findSet(x) == self.findSet(y)
def unite(self, x, y):
self.link(self.findSet(x), self.findSet(y))
def link(self, x, y):
if(self.rank[x] > self.rank[y]):
self.p[y] = x
self._size[x] += self._size[y]
##self._size[y] = 0
else:
self.p[x] = y
self._size[y] += self._size[x]
#self._size[x] = 0
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
#頂点xが属するグループと同じグループに属する頂点数を得る
def size(self, x):
return self._size[self.findSet(x)]
def findSet(self, x):
if(x != self.p[x]):
self.p[x] = self.findSet(self.p[x])
return self.p[x]
N, M = list(map(int, input().split()))
l = [[int(i) for i in input().split()] for i in range(M)]
ds = DisjointSet()
for i in range(N):
ds.makeSet(i+1)
ans = [0] * M
ans[M-1] = N * (N - 1) // 2
for i in range(M-1, 0, -1):
a, b = l[i]
if ds.same(a, b):
ans[i-1] = ans[i]
else:
x = ds.size(a)
y = ds.size(b)
ans[i-1] = ans[i] - x * y
ds.unite(a, b)
for a in ans:
print(a) | p03108 |
class Union:
def __init__(self, num):
self.T = [-1 for i in range(num)]
def root(self, x):
if self.T[x] < 0: return x
return self.root(self.T[x])
def size(self, x):
return -self.T[self.root(x)]
def merge(self, x, y):
a = self.root(x)
b = self.root(y)
if a == b: return False
if self.size(a) < self.size(b): a, b = b, a
self.T[a] += self.T[b]
self.T[b] = a
return True
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
AB.reverse()
uni = Union(N + 1)
L = []
Ans = N * (N - 1) // 2
for i in AB:
L.append(Ans)
if uni.root(i[0]) != uni.root(i[1]):
Ans -= uni.size(i[0]) * uni.size(i[1])
uni.merge(i[0], i[1])
for i in L[::-1]:
print(i) | class Union:
def __init__(self, num):
self.T = [-1 for i in range(num)]
def root(self, x):
if self.T[x] < 0: return x
return self.root(self.T[x])
def size(self, x):
return -self.T[self.root(x)]
def merge(self, x, y):
a = self.root(x)
b = self.root(y)
if a == b: return False
if self.size(a) < self.size(b): a, b = b, a
self.T[a] += self.T[b]
self.T[b] = a
return True
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
AB.reverse()
uni = Union(N + 1)
L = []
Ans = N * (N - 1) // 2
for i in AB:
L.append(Ans)
a = uni.root(i[0])
b = uni.root(i[1])
if a != b:
Ans -= uni.size(a) * uni.size(b)
uni.merge(i[0], i[1])
for i in L[::-1]:
print(i) | p03108 |
N, M = list(map(int, input().split()))
B = [list(map(int, input().split())) for _ in range(M)]
pt = []
G = [0 for x in range(N+1)]
C = [1 for x in range(N+1)]
def find(x):
while G[x] != 0:
x = G[x]
return x
cnt = 0
while len(B):
x, y = B.pop()
wx = find(x)
wy = find(y)
if wx is wy:
pt.append(0)
else:
pt.append(C[wx] * C[wy])
C[wx] += C[wy]
G[wy] = wx
#print(G)
cnt = 0
for _ in range(M):
cnt += pt.pop()
print(cnt)
| N, M = list(map(int, input().split()))
B = [list(map(int, input().split())) for _ in range(M)]
pt = []
G = [[None, 1] for x in range(N+1)]
def find(x):
n = G[x]
c = []
while not n[0] is None:
c.append(n)
n = n[0]
for ci in c:
ci[0] = n
return n
cnt = 0
while len(B):
x, y = B.pop()
wx = find(x)
wy = find(y)
if wx is wy:
pt.append(0)
else:
pt.append(wx[1] * wy[1])
wx[1] += wy[1]
wy[0] = wx
#print(G)
cnt = 0
for _ in range(M):
cnt += pt.pop()
print(cnt)
| 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, *X = list(map(int,open(0).read().split()))
uf = UnionFind(N + 1)
S = N * (N - 1) // 2
r = [S]
while X:
b, a = X.pop(), X.pop()
if not uf.same(a, b):
S -= uf.size(a) * uf.size(b)
r.append(S)
uf.union(a, b)
for a in r[-2::-1]:
print(a) | def find(x):
if P[x] < 0:
return x
else:
P[x] = find(P[x])
return P[x]
N, M, *X = list(map(int,open(0).read().split()))
P = [-1] * (N + 1)
S = N * (N - 1) // 2
r = [S]
while X:
b, a = find(X.pop()), find(X.pop())
if a != b:
S -= P[a] * P[b]
if P[a] > P[b]:
a, b = b, a
P[a] += P[b]
P[b] = a
r.append(S)
for a in r[-2::-1]:
print(a) | p03108 |
def find(x):
if P[x] < 0:
return x
else:
P[x] = find(P[x])
return P[x]
N, M, *X = list(map(int,open(0).read().split()))
P = [-1] * (N + 1)
S = N * (N - 1) // 2
r = [S]
while X:
b, a = find(X.pop()), find(X.pop())
if a != b:
S -= P[a] * P[b]
if P[a] > P[b]:
a, b = b, a
P[a] += P[b]
P[b] = a
r.append(S)
for a in r[-2::-1]:
print(a) | def find(x):
if P[x] < 0:
return x
else:
P[x] = find(P[x])
return P[x]
N, M, *X = map(int,open(0).read().split())
P = [-1] * (N + 1)
S = N * (N - 1) // 2
r = [S]
while X:
b, a = find(X.pop()), find(X.pop())
if a != b:
S -= P[a] * P[b]
if P[a] > P[b]:
a, b = b, a
P[a] += P[b]
P[b] = a
r.append(S)
r.pop()
print(*reversed(r), sep='\n')
| p03108 |
from functools import reduce
from operator import mul
def cmb(n,r):
r = min(r, n-r)
if r==0: return 1
if r<0: return 0
over = reduce(mul, list(range(n, n-r, -1)))
under = reduce(mul, list(range(1,r+1)))
return over//under
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.size = [1]*n
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
return
elif self.rank[y]<self.rank[x]:
self.par[y] = x
self.size[x] += self.size[y]
else:
self.par[y] = x
self.size[x] += self.size[y]
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
def count(self, x):
return self.size[x]
N, M = list(map(int, input().split()))
bridge = []
u = UnionFind(N)
m = cmb(N,2)
ans = [m]
for i in range(M):
A, B = list(map(int, input().split()))
bridge += [(A,B)]
for i in range(M-1,0,-1):
a, b = bridge[i]
if u.same(a-1,b-1):
ans += [m]
continue
pa = u.find(a-1)
pb = u.find(b-1)
m -= u.count(pa)*u.count(pb)
ans += [m]
u.unit(a-1,b-1)
for i in range(M-1,-1,-1):
print((ans[i]))
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.size = [1]*n
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
return
elif self.rank[y]<self.rank[x]:
self.par[y] = x
self.size[x] += self.size[y]
else:
self.par[y] = x
self.size[x] += self.size[y]
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
def count(self, x):
return self.size[x]
N, M, *L = list(map(int, open(0).read().split()))
u = UnionFind(N+1)
m = N*(N-1)//2
ans = []
for a, b in zip(*[iter(L[::-1])]*2):
ans += [m]
A = u.find(a)
B = u.find(b)
if A!=B:
na = u.count(A)
nb = u.count(B)
u.unit(a,b)
m -= na*nb
print(('\n'.join(map(str,ans[::-1])))) | p03108 |
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
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(int,input().split())
uf=UnionFind(n)
now=n*(n-1)//2
g=[]
ans=[now]
now=n*(n-1)//2
for i in range(m):
a,b=map(int,input().split())
g.append((a-1,b-1))
#print(g)
g=g[::-1]
for a,b in g:
now-=uf.size(a)*uf.size(b)*(1-uf.same(a,b))
ans.append(now)
uf.union(a,b)
ans=ans[:-1][::-1]
print(*ans,sep="\n")
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
#2320
#import numpy as np
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=MI()
e=[]
for _ in range(m):
a,b=MI()
a-=1
b-=1
e.append([a,b])
#print(e)
UF=UnionFind(n)
ans=[]
tmp=n*(n-1)//2
for li in reversed(e):
ans.append(tmp)
a=li[0]
b=li[1]
if UF.same(a,b):
continue
aa=UF.parents[UF.find(a)]
bb=UF.parents[UF.find(b)]
#print(a,b,aa,bb)
tmp-=aa*bb
UF.union(a,b)
print(("\n".join(str(i) for i in ans[::-1])))
if __name__ == "__main__":
main() | p03108 |
import sys
input = sys.stdin.readline
class Node:
def __init__(self):
self.is_root = True
self.parent = None
self.child_num = 0
def root_node(self):
node = self
while not node.is_root:
node = node.parent
return node
def main():
N, M = list(map(int, input().split()))
nodes = [Node() for i in range(N)]
ab = [list(map(int, input().split())) for i in range(M)]
inc = (N * (N-1)) // 2
ans = [inc]
for i in range(M-1, -1, -1):
a, b = ab[i]
a -= 1
b -= 1
root_a = nodes[a].root_node()
root_b = nodes[b].root_node()
if root_a == root_b:# もともと連結成分だった場合
ans.append(inc)
else:# 新たに連結成分になった場合
# if root_b.child_num > root_a.child_num:
# tmp = root_a
# root_a = root_b
# root_b = tmp
inc -= (root_a.child_num + 1) * (root_b.child_num + 1)
ans.append(inc)
root_b.is_root = False
root_b.parent = root_a
root_a.child_num += root_b.child_num + 1
for i in range(M-1, -1, -1):
print((ans[i]))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
class Node:
def __init__(self):
self.is_root = True
self.parent = None
self.child_num = 0
def root_node(self):
node = self
while not node.is_root:
node = node.parent
return node
def main():
N, M = list(map(int, input().split()))
nodes = [Node() for i in range(N)]
ab = [list(map(int, input().split())) for i in range(M)]
inc = (N * (N-1)) // 2
ans = [inc]
for i in range(M-1, -1, -1):
a, b = ab[i]
a -= 1
b -= 1
root_a = nodes[a].root_node()
if root_a != nodes[a]:
nodes[a].parent = root_a
root_b = nodes[b].root_node()
if root_b != nodes[b]:
nodes[b].parent = root_b
if root_a == root_b:# もともと連結成分だった場合
ans.append(inc)
else:# 新たに連結成分になった場合
# if root_b.child_num > root_a.child_num:
# tmp = root_a
# root_a = root_b
# root_b = tmp
inc -= (root_a.child_num + 1) * (root_b.child_num + 1)
ans.append(inc)
root_b.is_root = False
root_b.parent = root_a
root_a.child_num += root_b.child_num + 1
for i in range(M-1, -1, -1):
print((ans[i]))
if __name__ == "__main__":
main()
| p03108 |
import sys
input = sys.stdin.readline
class Node:
def __init__(self):
self.is_root = True
self.parent = None
self.child_num = 0
def root_node(self):
node = self
while not node.is_root:
node = node.parent
return node
def main():
N, M = list(map(int, input().split()))
nodes = [Node() for i in range(N)]
ab = [list(map(int, input().split())) for i in range(M)]
inc = (N * (N-1)) // 2
ans = [inc]
for i in range(M-1, -1, -1):
a, b = ab[i]
a -= 1
b -= 1
root_a = nodes[a].root_node()
if root_a != nodes[a]:
nodes[a].parent = root_a
root_b = nodes[b].root_node()
if root_b != nodes[b]:
nodes[b].parent = root_b
if root_a == root_b:# もともと連結成分だった場合
ans.append(inc)
else:# 新たに連結成分になった場合
# if root_b.child_num > root_a.child_num:
# tmp = root_a
# root_a = root_b
# root_b = tmp
inc -= (root_a.child_num + 1) * (root_b.child_num + 1)
ans.append(inc)
root_b.is_root = False
root_b.parent = root_a
root_a.child_num += root_b.child_num + 1
for i in range(M-1, -1, -1):
print((ans[i]))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
class Node:
def __init__(self):
self.is_root = True
self.parent = None
self.child_num = 0
def root_node(self):
node = self
while not node.is_root:
node = node.parent
return node
def main():
N, M = list(map(int, input().split()))
nodes = [Node() for i in range(N)]
ab = [list(map(int, input().split())) for i in range(M)]
inc = (N * (N-1)) // 2
ans = [inc]
for i in range(M-1, -1, -1):
a, b = ab[i]
a -= 1
b -= 1
root_a = nodes[a].root_node()
if root_a != nodes[a]:
nodes[a].parent = root_a
root_b = nodes[b].root_node()
if root_b != nodes[b]:
nodes[b].parent = root_b
if root_a == root_b:# もともと連結成分だった場合
ans.append(inc)
else:# 新たに連結成分になった場合
if root_b.child_num > root_a.child_num:
tmp = root_a
root_a = root_b
root_b = tmp
inc -= (root_a.child_num + 1) * (root_b.child_num + 1)
ans.append(inc)
root_b.is_root = False
root_b.parent = root_a
root_a.child_num += root_b.child_num + 1
for i in range(M-1, -1, -1):
print((ans[i]))
if __name__ == "__main__":
main()
| p03108 |
import sys
input_int = lambda:int(eval(input()))
input_ints = lambda:list(map(int,input().split()))
input_ints_list = lambda:list(input_ints())
input_str = lambda:eval(input())
input_strs = lambda:input().split()
input_lines = lambda n,f:[f() for _ in range(n)]
import functools,fractions
gcd = lambda a:functools.reduce(fractions.gcd,a) # 最大公約数（リスト）
lcm_base = lambda a,b:(a*b)//fractions.gcd(a,b) # 最小公倍数(2値)
lcm = lambda a:functools.reduce(lcm_base,a,1) # 最小公倍数(リスト)
import itertools
permutations = lambda a,n:itertools.permutations(a,n) # 順列
combinations = lambda a,n:itertools.combinations(a,n) # 組み合わせ
product = lambda a,b:itertools.product(a,b) # 二つのリストの直積
init_array_1dim = lambda v,n:[v for _ in range(n)]
init_array_2dim = lambda v,n,m:[[v for _ in range(n)] for _ in range(m)]
import math
# 四捨五入はround
ceil = lambda a:math.ceil(a) # 切り上げ
floor = lambda a:math.floor(a) # 切り捨て
class UnionFind(object):
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
x = self.find(x)
return self.size[x]
# グラフで全部到達できる経路が何個あるか
def dfs_graph(v,n,graph,visited):
if all(visited):return 1 # 全部到達できたら1を返す
ans = 0
for i in range(n):
if not graph[v][i]:continue # 結ぶ線がないときはスキップ
if visited[i]:continue # 到達済みだったらスキップ
visited[i] = True
ans += dfs_graph(i,n,graph,visited)
visited[i] = False
return ans
# ワーシャルフロイド（グラフの要素数、グラフ）
def warshall_floyd(n,graph):
d = init_array_2dim(float("inf"),n,n)
# 初期化
for i in range(n):
d[i][i] = 0
for j in range(n):
if graph[i][j]:d[i][j] = 1
# 距離算出
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
# グラフを初期化（グラフの要素数、グラフの線の両端、有向無向）
def init_graph(n,a,directed=False):
visited = init_array_1dim(False,n)
graph = init_array_2dim(False,n,n)
for e in a:
graph[e[0]-1][e[1]-1] = True
if not directed:graph[e[1]-1][e[0]-1] = True # 無向グラフの場合
return visited,graph
def solution():
# ここに実装
N,M = input_ints()
AB = input_lines(M,input_ints_list)
ans = []
count = N*(N-1)//2 # 線一つもない時は2つ選んだ組み合わせ数
uf = UnionFind(N)
# 線を後ろから追加していく感じで処理を進める
while(AB):
ans.insert(0,count)
a,b = AB.pop()
if not uf.is_same(a-1,b-1):
count -= uf.get_size(a-1)*uf.get_size(b-1)
uf.union(a-1,b-1)
for _ans in ans:
print(_ans)
if __name__ == '__main__':
solution() | import sys
input_int = lambda:int(eval(input()))
input_ints = lambda:list(map(int,input().split()))
input_ints_list = lambda:list(input_ints())
input_str = lambda:eval(input())
input_strs = lambda:input().split()
input_lines = lambda n,f:[f() for _ in range(n)]
import functools,fractions
gcd = lambda a:functools.reduce(fractions.gcd,a) # 最大公約数（リスト）
lcm_base = lambda a,b:(a*b)//fractions.gcd(a,b) # 最小公倍数(2値)
lcm = lambda a:functools.reduce(lcm_base,a,1) # 最小公倍数(リスト)
import itertools
permutations = lambda a,n:itertools.permutations(a,n) # 順列
combinations = lambda a,n:itertools.combinations(a,n) # 組み合わせ
product = lambda a,b:itertools.product(a,b) # 二つのリストの直積
init_array_1dim = lambda v,n:[v for _ in range(n)]
init_array_2dim = lambda v,n,m:[[v for _ in range(n)] for _ in range(m)]
import math
# 四捨五入はround
ceil = lambda a:math.ceil(a) # 切り上げ
floor = lambda a:math.floor(a) # 切り捨て
class UnionFind(object):
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
x = self.find(x)
return self.size[x]
# グラフで全部到達できる経路が何個あるか
def dfs_graph(v,n,graph,visited):
if all(visited):return 1 # 全部到達できたら1を返す
ans = 0
for i in range(n):
if not graph[v][i]:continue # 結ぶ線がないときはスキップ
if visited[i]:continue # 到達済みだったらスキップ
visited[i] = True
ans += dfs_graph(i,n,graph,visited)
visited[i] = False
return ans
# ワーシャルフロイド（グラフの要素数、グラフ）
def warshall_floyd(n,graph):
d = init_array_2dim(float("inf"),n,n)
# 初期化
for i in range(n):
d[i][i] = 0
for j in range(n):
if graph[i][j]:d[i][j] = 1
# 距離算出
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
# グラフを初期化（グラフの要素数、グラフの線の両端、有向無向）
def init_graph(n,a,directed=False):
visited = init_array_1dim(False,n)
graph = init_array_2dim(False,n,n)
for e in a:
graph[e[0]-1][e[1]-1] = True
if not directed:graph[e[1]-1][e[0]-1] = True # 無向グラフの場合
return visited,graph
def solution():
# ここに実装
N,M = input_ints()
AB = input_lines(M,input_ints_list)
ans = []
count = N*(N-1)//2 # 線一つもない時は2つ選んだ組み合わせ数
uf = UnionFind(N)
# 線を後ろから追加していく感じで処理を進める
while(AB):
ans.append(count)
a,b = AB.pop()
if not uf.is_same(a-1,b-1):
count -= uf.get_size(a-1)*uf.get_size(b-1)
uf.union(a-1,b-1)
ans.reverse()
for _ans in ans:
print(_ans)
if __name__ == '__main__':
solution() | p03108 |
import sys
sys.setrecursionlimit(10 ** 7)
class UnionFind:
def __init__(self, size: int):
self.parent = [-1 for _ in range(size)]
self.size = [1 for _ in range(size)]
def unite(self, x, y):
px = self.find(x)
py = self.find(y)
if px != py:
if self.parent[px] > self.parent[py]:
self.parent[py] = px
self.parent[px] -= 1
self.size[px] += self.size[py]
self.size[py] = 0
else:
self.parent[px] = py
self.parent[py] -= 1
self.size[py] += self.size[px]
self.size[px] = 0
return
def find(self, x: int) -> int:
if self.parent[x] < 0:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main():
# input
N, M = map(int, input().split())
brs = [list(map(int, input().split())) for _ in range(M)]
# solve
# ref: http://drken1215.hatenablog.com/entry/2019/03/03/224600
# ref: https://atcoder.jp/contests/abc120/submissions/4450601
uf = UnionFind(N)
ans = [N*(N-1)//2]
for i in range(M-1, 0, -1):
a, b = brs[i][0], brs[i][1]
a, b = a-1, b-1
p1 = uf.find(a)
p2 = uf.find(b)
if p1 != p2:
ans.append(ans[-1] - uf.size[p1]*uf.size[p2])
else:
ans.append(ans[-1])
uf.unite(p1, p2)
return ans
print(*list(reversed(main())), sep="\n")
| class UnionFind:
def __init__(self, size: int):
self.parent = [-1 for _ in range(size)]
def unite(self, x, y):
px = self.find(x)
py = self.find(y)
if px == py:
return
if self.size(px) > self.size(py):
px, py = py, px
self.parent[py] += self.parent[px]
self.parent[px] = py
return
def find(self, x: int) -> int:
if self.parent[x] < 0:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def size(self, x):
return -self.parent[self.find(x)]
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main():
# input
N, M = map(int, input().split())
A, B = [], []
for _ in range(M):
a, b = map(int, input().split())
A.append(a-1)
B.append(b-1)
# solve
# ref: http://drken1215.hatenablog.com/entry/2019/03/03/224600
# ref: https://atcoder.jp/contests/abc120/submissions/4450601
uf = UnionFind(N)
ans = [N*(N-1)//2]
for i in range(M-1, 0, -1):
p1 = uf.find(A[i])
p2 = uf.find(B[i])
if p1 != p2:
ans.append(ans[-1] - uf.size(p1)*uf.size(p2))
else:
ans.append(ans[-1])
uf.unite(p1, p2)
return ans
print(*list(reversed(main())), sep="\n")
| p03108 |
import collections as co
import copy as cp
L = co.deque()
N, M = list(map(int, input().split()))
def check(n, x, done):
try:
if n in dic[x]:
return True
else:
if x in done or len(dic[x]) == 0:
return False
done.add(x)
for j in dic[x]:
if j in done:
continue
if check(n, j, cp.copy(done)):
return True
except:
return False
for i in range(M):
L.append(list(map(int, input().split())))
for i in range(M):
L.popleft()
dic = {}
cnt = 0
for j in range(len(L)):
dic.setdefault(L[j][0], set())
dic[L[j][0]].add(L[j][1])
dic.setdefault(L[j][1], set())
dic[L[j][1]].add(L[j][0])
for key in [i+1 for i in range(N)]:
for n in range(key+1, N+1):
done = set()
if check(n, key, done):
continue
else:
cnt += 1
print(cnt) | import collections as co
L = co.deque()
N, M = list(map(int, input().split()))
def check(n, x, done):
try:
if n in dic[x]:
return True
else:
if x in done or len(dic[x]) == 0:
return False
done.add(x)
for j in dic[x]:
if j in done:
continue
if check(n, j, done):
return True
except:
return False
for i in range(M):
L.append(list(map(int, input().split())))
for i in range(M):
L.popleft()
dic = {}
cnt = 0
for j in range(len(L)):
dic.setdefault(L[j][0], set())
dic[L[j][0]].add(L[j][1])
dic.setdefault(L[j][1], set())
dic[L[j][1]].add(L[j][0])
for key in [i+1 for i in range(N)]:
for n in range(key+1, N+1):
done = set()
if check(n, key, done):
continue
else:
cnt += 1
print(cnt) | p03108 |
N, M = [int(i) for i in input().split()]
parent = [i for i in range(N+1)]
node_num = [1 for i in range(N+1)]
def find(x):
if parent[x] == x:
return x
else:
parent[x] = find(parent[x])
return parent[x]
def find_for(x):
while parent[x] != x:
x = parent[x]
return x
bridge = []
for i in range(M):
A, B = [int(i) for i in input().split()]
bridge.append([A, B])
bridge = bridge[::-1]
ans_rev = [N*(N-1)//2]
combi = 0
for i in range(M-1):
A, B = bridge[i]
r_A = find_for(A)
r_B = find_for(B)
if r_A != r_B:
parent[r_B] = r_A
combi += node_num[r_B] * node_num[r_A]
node_num[r_A] += node_num[r_B]
ans_rev.append(N*(N-1)//2-combi)
ans = ans_rev[::-1]
print(*ans, sep="\n")
| import sys
sys.setrecursionlimit(10**6)
N, M = [int(i) for i in input().split()]
parent = [i for i in range(N+1)]
node_num = [1 for i in range(N+1)]
def find(x):
if parent[x] == x:
return x
else:
parent[x] = find(parent[x])
return parent[x]
bridge = []
for i in range(M):
A, B = [int(i) for i in input().split()]
bridge.append([A, B])
bridge = bridge[::-1]
ans_rev = [N*(N-1)//2]
combi = 0
for i in range(M-1):
A, B = bridge[i]
r_A = find(A)
r_B = find(B)
if r_A != r_B:
parent[r_B] = r_A
combi += node_num[r_B] * node_num[r_A]
node_num[r_A] += node_num[r_B]
ans_rev.append(N*(N-1)//2-combi)
ans = ans_rev[::-1]
print(*ans, sep="\n")
| p03108 |
#D問題再チャレンジ
#Union Find
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
#print([x,y])
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] = self.size[x] + self.size[y]
self.size[x] = 0
else:
self.par[y] = x
if x != y:
self.size[x] = self.size[x] + self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n)
con = [0] * (m+1)#convenience
x = [0] * (m+1)
y = [0] * (m+1)
con[m] = 0
for i in range(1,m+1):
x[i], y[i] = list(map(int, input().split()))
#print([x,y])
for j in range(m-1,0,-1):
#print([x[j+1],y[j+1]])
uf.union(x[j+1],y[j+1])
for k in range(1,n+1):
s = uf.size[k]
con[j] = con[j] + int(s*(s-1) / 2)
#print(uf.size)
N = int(n * (n-1) / 2)
for i in range(1,m+1):
print((N-con[i])) | 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)
self.con = [0] * (m+1)#convenience
# 検索
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, j):
x = self.find(x)
y = self.find(y)
if x != y:
self.con[j] = self.con[j+1] + self.size[x] * self.size[y]
else:
self.con[j] = self.con[j+1]
#print([x,y])
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] = self.size[x] + self.size[y]
self.size[x] = 0
else:
self.par[y] = x
if x != y:
self.size[x] = self.size[x] + self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n)
x = [0] * (m+1)
y = [0] * (m+1)
for i in range(1,m+1):
x[i], y[i] = list(map(int, input().split()))
#print([x,y])
for j in range(m-1,0,-1):
#print([x[j+1],y[j+1]])
uf.union(x[j+1],y[j+1],j)
#print(uf.size)
#print(uf.con)
N = int(n * (n-1) / 2)
for i in range(1,m+1):
print((N-uf.con[i]))
| p03108 |
#要素の根を探す関数
def find_root(n):
while(parts[n-1][0]!=n-1):
n=parts[n-1][0]+1
return tuple(parts[n-1])
#入力を受け取る
N,M=list(map(int,input().split()))
AB=[list(map(int,input().split())) for i in range(M)]
#partsの1つ目は根の番号、2つ目は深さ、3つ目は接続されている要素数
parts=[[i,1,1] for i in range(N)]
#全部壊れた時の不便度はN(N-1)
ans=[N*(N-1)//2]
#橋の数-1だけ処理を行う（橋が全部かかっているときは不便度0なので）
for i in range(M-1):
#一番最後に壊れた橋を探す
ab=AB.pop()
#それぞれの要素の根を探す
a=find_root(ab[0])
b=find_root(ab[1])
#木構造が浅い方をaとする
if a[1]<=b[1]:
a,b=a,b
else:
b,a=a,b
#根が同一ならば処理不要
if a[0]==b[0]:
ans.append(ans[-1])
#根が違うのであれば、以後木をくっつける処理を行う
else:
#要素x個の木と要素y個の木が繋がれば不便度はxyだけ減る
ans.append(ans[-1]-a[2]*b[2])
#bの根にaを接続する
parts[b[0]][0]=parts[a[0]][0]
#接続後のaの深さは(aの深さ)と(bの深さ+1)の大きい方
parts[a[0]][1]=max(parts[a[0]][1],parts[b[0]][1]+1)
#aの要素数+bの要素数が接続後のaの要素数
parts[a[0]][2]+=parts[b[0]][2]
#答えを出力
for i in reversed(ans):
print(i) | #要素の根を探す関数
def find_root(n):
while(parts[n-1][0]!=n-1):
n=parts[n-1][0]+1
return tuple(parts[n-1])
#入力を受け取る
N,M=list(map(int,input().split()))
AB=[list(map(int,input().split())) for i in range(M)]
#partsの1つ目は根の番号、2つ目は深さ、3つ目は接続されている要素数
parts=[[i,1,1] for i in range(N)]
#全部壊れた時の不便度はN(N-1)
ans=[N*(N-1)//2]
#橋の数-1だけ処理を行う（橋が全部かかっているときは不便度0なので）
for i in range(M-1):
#一番最後に壊れた橋を探す
ab=AB.pop()
#それぞれの要素の根を探す
a=find_root(ab[0])
b=find_root(ab[1])
#木構造が深い方をaとする
if a[1]>=b[1]:
a,b=a,b
else:
b,a=a,b
#根が同一ならば処理不要
if a[0]==b[0]:
ans.append(ans[-1])
#根が違うのであれば、以後木をくっつける処理を行う
else:
#要素x個の木と要素y個の木が繋がれば不便度はxyだけ減る
ans.append(ans[-1]-a[2]*b[2])
#bの根にaを接続する
parts[b[0]][0]=parts[a[0]][0]
#接続後のaの深さは(aの深さ)と(bの深さ+1)の大きい方
parts[a[0]][1]=max(parts[a[0]][1],parts[b[0]][1]+1)
#aの要素数+bの要素数が接続後のaの要素数
parts[a[0]][2]+=parts[b[0]][2]
#答えを出力
for i in reversed(ans):
print(i) | p03108 |
#要素の根を探す関数
def find_root(n,parts):
root=[]
n=n-1
#根をnとして返す
while(parts[n][0]!=n):
root.append(n)
n=parts[n][0]
#途中で見つけた要素は全てnに繋ぐことで経路圧縮
for i in root:
parts[i][0]=n
#partsをタプルで返す
return tuple(parts[n])
#入力を受け取る
N,M=list(map(int,input().split()))
AB=[list(map(int,input().split())) for i in range(M)]
#partsの1つ目は根の番号、2つ目は深さ、3つ目は接続されている要素数
parts=[[i,1,1] for i in range(N)]
ans=[N*(N-1)//2]
#橋の数-1だけ処理を行う（橋が全部かかっているときは不便度0なので）
for i in range(M-1):
#一番最後に壊れた橋を探す
ab=AB.pop()
#それぞれの要素の根を探す
a=find_root(ab[0],parts)
b=find_root(ab[1],parts)
#木構造が深い方をaとする
if a[1]>=b[1]:
a,b=a,b
else:
b,a=a,b
#根が同一ならば処理不要
if a[0]==b[0]:
ans.append(ans[-1])
#根が違うのであれば、以後木をくっつける処理を行う
else:
#要素x個の木と要素y個の木が繋がれば不便度はxyだけ減る
ans.append(ans[-1]-a[2]*b[2])
#bの根にaを接続する
parts[b[0]][0]=parts[a[0]][0]
#接続後のaの深さは(aの深さ)と(bの深さ+1)の大きい方
parts[a[0]][1]=max(parts[a[0]][1],parts[b[0]][1]+1)
#aの要素数+bの要素数が接続後のaの要素数
parts[a[0]][2]+=parts[b[0]][2]
#答えを出力
for i in reversed(ans):
print(i) | #要素の根を探す関数
def find_root(n,parts):
n=n-1
#partsをタプルで返す
if parts[n][0]==n:
return tuple(parts[n])
else:
return find_root(parts[n][0]+1,parts)
#入力を受け取る
N,M=list(map(int,input().split()))
AB=[list(map(int,input().split())) for i in range(M)]
#partsの1つ目は根の番号、2つ目は深さ、3つ目は接続されている要素数
parts=[[i,1,1] for i in range(N)]
ans=[N*(N-1)//2]
#橋の数-1だけ処理を行う（橋が全部かかっているときは不便度0なので）
for i in range(M-1):
#一番最後に壊れた橋を探す
ab=AB.pop()
#それぞれの要素の根を探す
a=find_root(ab[0],parts)
b=find_root(ab[1],parts)
#木構造が深い方をaとする
if a[1]>=b[1]:
a,b=a,b
else:
b,a=a,b
#根が同一ならば処理不要
if a[0]==b[0]:
ans.append(ans[-1])
#根が違うのであれば、以後木をくっつける処理を行う
else:
#要素x個の木と要素y個の木が繋がれば不便度はxyだけ減る
ans.append(ans[-1]-a[2]*b[2])
#bの根にaを接続する
parts[b[0]][0]=parts[a[0]][0]
#接続後のaの深さは(aの深さ)と(bの深さ+1)の大きい方
parts[a[0]][1]=max(parts[a[0]][1],parts[b[0]][1]+1)
#aの要素数+bの要素数が接続後のaの要素数
parts[a[0]][2]+=parts[b[0]][2]
#答えを出力
for i in reversed(ans):
print(i) | p03108 |
import itertools
[N, M] = list(map(int, input().split(' ')))
bridge_list = []
for _ in range(M):
[a, b] = list(map(int, input().split(' ')))
bridge_list.append((a - 1, b - 1))
# print(bridge_list)
convenience_list = []
inconvenience_list = list(itertools.combinations(list(range(N)), 2))
# print(inconvenience_list)
inconvenience_num_list = [len(inconvenience_list)]
for bridge in bridge_list[:0:-1]:
if not inconvenience_list:
break
if bridge in inconvenience_list:
convenience_list.append(bridge)
inconvenience_list.remove(bridge)
deleted = True
while deleted:
deleted = False
if not inconvenience_list:
break
del_list = []
for inconvenience in inconvenience_list:
if inconvenience[0] in bridge:
via_is = bridge[1 - bridge.index(inconvenience[0])]
via_bridge = (inconvenience[1], via_is) if inconvenience[1] < via_is else (via_is, inconvenience[1])
# print(inconvenience)
# print(via_bridge)
if via_bridge in convenience_list:
# print(convenience_list)
convenience_list.append(inconvenience)
del_list.append(inconvenience)
deleted = True
elif inconvenience[1] in bridge:
via_is = bridge[1 - bridge.index(inconvenience[1])]
via_bridge = (inconvenience[0], via_is) if inconvenience[0] < via_is else (via_is, inconvenience[0])
# print(inconvenience)
# print(via_bridge)
if via_bridge in convenience_list:
# print(convenience_list)
convenience_list.append(inconvenience)
del_list.append(inconvenience)
deleted = True
# print(deleted)
if not deleted:
for del_value in del_list:
inconvenience_list.remove(del_value)
break
for conv_bridge in convenience_list:
if not inconvenience_list:
break
del_list = []
for inconvenience in inconvenience_list:
if inconvenience[0] in conv_bridge:
via_is = conv_bridge[1 - conv_bridge.index(inconvenience[0])]
via_bridge = (inconvenience[1], via_is) if inconvenience[1] < via_is else (via_is, inconvenience[1])
# print(inconvenience)
# print(via_bridge)
if via_bridge in convenience_list:
# print(convenience_list)
convenience_list.append(inconvenience)
del_list.append(inconvenience)
deleted = True
elif inconvenience[1] in conv_bridge:
via_is = conv_bridge[1 - conv_bridge.index(inconvenience[1])]
via_bridge = (inconvenience[0], via_is) if inconvenience[0] < via_is else (via_is, inconvenience[0])
# print(inconvenience)
# print(via_bridge)
if via_bridge in convenience_list:
# print(convenience_list)
convenience_list.append(inconvenience)
del_list.append(inconvenience)
deleted = True
# print(deleted)
for del_value in del_list:
inconvenience_list.remove(del_value)
# print()
inconvenience_num_list.append(len(inconvenience_list))
if len(inconvenience_num_list) < M:
for _ in range(M - len(inconvenience_num_list)):
inconvenience_num_list.append(0)
for value in inconvenience_num_list[::-1]:
print(value)
| class UnionFindNode(object):
def __init__(self, group_id, parent=None, value=None):
self.group_id = group_id
self.parent_ = parent
self.value = value
self.size_ = 1
def __str__(self):
return "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})".format(self.group_id, self.parent_,
self.value, self.size_)
def is_root(self):
return not self.parent_
def parent(self):
parent = self
while parent.parent_:
parent = parent.parent_
return parent
def find(self):
parent = self.parent()
return parent.group_id
def size(self):
parent = self.parent()
return parent.size_
def unite(self, unite_node):
parent = self.parent()
unite_parent = unite_node.parent()
if parent.group_id != unite_parent.group_id:
unite_parent.parent_ = parent
parent.size_ = parent.size_ + unite_parent.size_
[N, M] = list(map(int, input().split(' ')))
bridge_list = []
for _ in range(M):
[a, b] = list(map(int, input().split(' ')))
bridge_list.append((a - 1, b - 1))
node_list = [UnionFindNode(i) for i in range(N)]
combination_num = N * (N - 1) // 2
combination_list = [combination_num]
for bridge in bridge_list[:0:-1]:
# print(bridge)
if node_list[bridge[0]].find() != node_list[bridge[1]].find():
combination_num = combination_num - node_list[bridge[0]].size() * node_list[bridge[1]].size()
node_list[bridge[0]].unite(node_list[bridge[1]])
combination_list.append(combination_num)
# print(combination_num)
for value in combination_list[::-1]:
print(value) | 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 unite(self,x,y):
x = self.find(x)
y = self.find(y)
if x==y:
return
if self.parents[x]>self.parents[y]:
x,y=y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x<0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for _ in range(m)]
ans=[0]*m
ans[-1]=n*(n-1)//2
uf=UnionFind(n)
for i in range(m-1,0,-1):
ai=ab[i][0]-1
bi=ab[i][1]-1
if uf.same(ai,bi):
ans[i-1]=ans[i]
else:
ans[i-1]=ans[i]-uf.size(ai)*uf.size(bi)
uf.unite(ai,bi)
print(('\n'.join(map(str,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 unite(self,x,y):
x = self.find(x)
y = self.find(y)
if x==y:
return
if self.parents[x]>self.parents[y]:
x,y=y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x<0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(m)]
uf=UnionFind(n)
ans=[0]*m
ans[-1]=n*(n-1)//2
for i in range(1,m)[::-1]:
a,b=ab[i][0]-1,ab[i][1]-1
if uf.same(a,b):
ans[i-1]=ans[i]
else:
ans[i-1]=ans[i]-uf.size(a)*uf.size(b)
uf.unite(a,b)
print(('\n'.join(map(str,ans)))) | p03108 |
import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
class UnionFind:
def __init__(self, n):
"""
コンストラクタ
:要素数 n:
"""
self.n = n
# 添字x: 値yとすると・・
# root以外の場合： 要素xは集合yに所属する。
# rootの場合 ： 集合xの要素数はy個である。(負数で保持する)
self.parents = [-1] * n
def getroot(self, x):
"""
所属する集合(ルートの番号)を取得する。
:調査する要素 x:
"""
# 値が負数 = ルートに到達したので、ルート木の番号を返す。
if self.parents[x] < 0:
return x
else:
# 値が正数 = ルートに到達していない場合、さらに親の情報を確認する。
# 下の行は経路圧縮の処理。
self.parents[x] = self.getroot(self.parents[x])
return self.parents[x]
def union(self, x, y):
"""
2つの要素が所属する集合をを同じ集合に結合する。
:結合する要素(1つ目) x:
:結合する要素(2つ目) y:
"""
# 既に同じ集合に存在するなら何もせず終了。
x = self.getroot(x)
y = self.getroot(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:
"""
# 添え字[root]には、要素数が負数で格納されている。そのため、取得する際は-反転する。
return -self.parents[self.getroot(x)]
def is_same(self, x, y):
return self.getroot(x) == self.getroot(y)
def members(self, x):
"""
指定した集合に属する要素を取得する。size()と比較して速度が圧倒的に遅いので注意。
:調査する集合 x:
"""
root = self.getroot(x)
return [i for i in range(self.n) if self.getroot(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
# 実装を行う関数
def resolve(test_def_name=""):
n, m = list(map(int, input().split()))
ab_s = [list(map(int, input().split())) for i in range(m)]
# uf 作成(要素数を+1しているのは添え字と島番号を合わせるため)
uf = UnionFind(n + 1)
convenient_val = [0 for i in range(m)]
# 逆に考える・・橋が増えるごとに、便利さはどれくらい上がる?
for cnt, ab in enumerate(reversed(ab_s)):
if cnt > 0:
size0 = uf.size(ab[0])
size1 = uf.size(ab[1])
if uf.is_same(ab[0], ab[1]):
convenient_val[cnt] = convenient_val[cnt - 1] - (size0 * (size0 - 1) // 2)
pass
else:
convenient_val[cnt] = convenient_val[cnt - 1] - (size0 * (size0 - 1) // 2) - (size1 * (size1 - 1) // 2)
pass
uf.union(ab[0], ab[1])
convenient_val[cnt] += uf.size(ab[0]) * (uf.size(ab[0]) - 1) // 2
max_convenient = n * (n-1) // 2
for cnt, i in enumerate(reversed(convenient_val)):
if cnt == 0:
continue
print((max_convenient - i))
print(max_convenient)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """4 5
1 2
3 4
1 3
2 3
1 4"""
output = """0
0
4
5
6"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """6 5
2 3
1 2
5 6
3 4
4 5"""
output = """8
9
12
14
15"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """2 1
1 2"""
output = """1"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def tes_t_1original_1(self):
test_input = """データ"""
output = """データ"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
class UnionFind:
def __init__(self, n):
"""
コンストラクタ
:要素数 n:
"""
self.n = n
# 添字x: 値yとすると・・
# root以外の場合： 要素xは集合yに所属する。
# rootの場合 ： 集合xの要素数はy個である。(負数で保持する)
self.parents = [-1] * n
def getroot(self, x):
"""
所属する集合(ルートの番号)を取得する。
:調査する要素 x:
"""
# 値が負数 = ルートに到達したので、ルート木の番号を返す。
if self.parents[x] < 0:
return x
else:
# 値が正数 = ルートに到達していない場合、さらに親の情報を確認する。
# 下の行は経路圧縮の処理。
self.parents[x] = self.getroot(self.parents[x])
return self.parents[x]
def union(self, x, y):
"""
2つの要素が所属する集合をを同じ集合に結合する。
:結合する要素(1つ目) x:
:結合する要素(2つ目) y:
"""
# 既に同じ集合に存在するなら何もせず終了。
x = self.getroot(x)
y = self.getroot(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:
"""
# 添え字[root]には、要素数が負数で格納されている。そのため、取得する際は-反転する。
return -self.parents[self.getroot(x)]
def is_same(self, x, y):
return self.getroot(x) == self.getroot(y)
def members(self, x):
"""
指定した集合に属する要素を取得する。size()と比較して速度が圧倒的に遅いので注意。
:調査する集合 x:
"""
root = self.getroot(x)
return [i for i in range(self.n) if self.getroot(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
# 実装を行う関数
def resolve(test_def_name=""):
n, m = list(map(int, input().split()))
ab_s = [list(map(int, input().split())) for i in range(m)]
# uf 作成(要素数を+1しているのは添え字と島番号を合わせるため)
uf = UnionFind(n + 1)
convenient_val = [0 for i in range(m)]
for cnt, ab in enumerate(reversed(ab_s)):
if cnt > 0:
size0 = uf.size(ab[0])
size1 = uf.size(ab[1])
if uf.is_same(ab[0], ab[1]):
convenient_val[cnt] = convenient_val[cnt - 1] - (size0 * (size0 - 1) // 2)
else:
convenient_val[cnt] = convenient_val[cnt - 1] - (size0 * (size0 - 1) // 2) - (size1 * (size1 - 1) // 2)
uf.union(ab[0], ab[1])
convenient_val[cnt] += uf.size(ab[0]) * (uf.size(ab[0]) - 1) // 2
convenient_val.reverse()
for cnt, i in enumerate(convenient_val):
if cnt == 0:
continue
print((convenient_val[0] - i))
print((convenient_val[0]))
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """4 5
1 2
3 4
1 3
2 3
1 4"""
output = """0
0
4
5
6"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """6 5
2 3
1 2
5 6
3 4
4 5"""
output = """8
9
12
14
15"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """2 1
1 2"""
output = """1"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def tes_t_1original_1(self):
test_input = """データ"""
output = """データ"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| p03108 |
class UnionFindTree:
'''
Union Find木の実装
ランクは無視する
'''
def __init__(self, n):
'''ノード数nで初期化'''
# nodes[i] == i すなわち各ノードは自身が根
self.nodes = list(range(n))
def isSameTree(self, idxA, idxB):
return self.root(idxA) == self.root(idxB)
def union(self, idxA, idxB):
'''ノードAを含む木とノードBを含む木を結合'''
a = self.root(idxA)
b = self.root(idxB)
# b番目のノードの根をaにする
if a != b:
self.nodes[b] = a
def root(self, idx):
'''ノードの根番号と深さを探索し、経路圧縮を行う'''
# 探索
root_idx = idx
while root_idx != self.nodes[root_idx]:
root_idx = self.nodes[root_idx]
# 経路圧縮
_idx = idx
while root_idx != _idx:
_idx, self.nodes[_idx] = self.nodes[_idx], root_idx
return _idx
###========================
N, M = list(map(int, input().split()))
A = []
B = []
for i in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
tree = UnionFindTree(N)
def hubensa(tree):
n = len(tree.nodes)
cnt = 0
for i in range(n):
for j in range(i+1, n):
if not tree.isSameTree(i, j):
cnt += 1
return cnt
hubensa_list = [None] * M
last_changed = True
for i in range(M-1, -1, -1):
if tree.isSameTree(A[i]-1, B[i]-1):
if last_changed:
last_changed = False
hubensa_list[i] = hubensa(tree)
else:
hubensa_list[i] = hubensa_list[i+1]
else:
hubensa_list[i] = hubensa(tree)
last_changed = True
tree.union(A[i]-1, B[i]-1)
for x in hubensa_list:
print(x) | class UnionFindTree:
'''
Union Find木の実装
ランクは無視する
'''
def __init__(self, n):
'''ノード数nで初期化'''
# nodes[i] < 0 すなわち各ノードは自身が根
# 根の値はその木の要素数の符号反転したもの
self.nodes = [-1] * n
def is_root(self, idx):
'''根ならTrue、根以外ならFalse'''
return self.nodes[idx] < 0
def is_same_group(self, idxA, idxB):
return self.root(idxA) == self.root(idxB)
def size(self, idx):
'''ノードを含むグループのノード数を返す'''
return -self.nodes[self.root(idx)]
def union(self, idxA, idxB):
'''ノードAを含む木とノードBを含む木を結合'''
a = self.root(idxA)
b = self.root(idxB)
size_a = self.size(idxA)
size_b =self.size(idxB)
# b番目のノードの根をaにする
if a != b:
self.nodes[b] = a
self.nodes[a] -= size_b
def root(self, idx):
'''ノードの根番号を返す。途中で経路圧縮を行う'''
# 探索
_idx = idx
while not self.is_root(_idx):
_idx = self.nodes[_idx]
root_idx = _idx
# 経路圧縮
_idx = idx
while root_idx != _idx:
tmp = _idx
_idx = self.nodes[_idx]
self.nodes[tmp] = root_idx
return root_idx
###========================
N, M = list(map(int, input().split()))
A = []
B = []
for i in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
tree = UnionFindTree(N)
hubensa_list = [None] * M
hubensa_list[M-1] = N * (N-1) // 2
for i in range(M-2, -1, -1):
if tree.is_same_group(A[i+1]-1, B[i+1]-1):
hubensa_list[i] = hubensa_list[i+1]
else:
sa = tree.size(A[i+1]-1)
sb = tree.size(B[i+1]-1)
hubensa_list[i] = hubensa_list[i+1] - sa * sb
tree.union(A[i+1]-1, B[i+1]-1)
for x in hubensa_list:
print(x) | p03108 |
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [0] * size
self.num = self.parent
def unite(self, n1, n2):
rank, parent, num = self.rank, self.parent, self.num
root, root_2 = self.find(n1), self.find(n2)
if rank[root] > rank[root_2]:
pass
elif rank[root] < rank[root_2]:
root_2, root = root, root_2
else:
rank[root] += 1
num[root] += num[root_2]
parent[root_2] = root
return root
def find(self, n0):
if self.parent[n0] < 0:
return n0
else:
ret = self.find(self.parent[n0])
# self.parent[n0] = ret
return ret
n, m = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for _ in range(m)]
ans = n * (n - 1) // 2
t = UnionFind(n + 1)
v = []
for a, b in reversed(ab):
v.append(ans)
root_a = t.find(a)
root_b = t.find(b)
if root_a == root_b:
pass
else:
ans -= t.num[root_a] * t.num[root_b]
t.unite(a, b)
for x in reversed(v):
print(x)
| class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [0] * size
self.num = self.parent
def unite(self, n1, n2):
rank, parent, num = self.rank, self.parent, self.num
root, root_2 = self.find(n1), self.find(n2)
if rank[root] > rank[root_2]:
pass
elif rank[root] < rank[root_2]:
root_2, root = root, root_2
else:
rank[root] += 1
num[root] += num[root_2]
parent[root_2] = root
return root
def find(self, n0):
if self.parent[n0] < 0:
return n0
else:
ret = self.find(self.parent[n0])
self.parent[n0] = ret
return ret
n, m = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for _ in range(m)]
ans = n * (n - 1) // 2
t = UnionFind(n + 1)
v = []
for a, b in reversed(ab):
v.append(ans)
root_a = t.find(a)
root_b = t.find(b)
if root_a == root_b:
pass
else:
ans -= t.num[root_a] * t.num[root_b]
t.unite(a, b)
for x in reversed(v):
print(x)
| p03108 |
import sys
input = sys.stdin.readline
def readlines(n):
for _ in range(n):
a, b = list(map(int, input().split()))
yield a, b
def main():
n, m = list(map(int, input().split()))
bridges = list(readlines(m))
tree = list(range(n+1))
rank = [1] * (n+1)
def root(v):
while tree[v] != v:
tree[v] = tree[tree[v]]
v = tree[v]
return v
fuben = n*(n-1)//2
for a, b in bridges[::-1]:
x = root(a)
y = root(b)
if x == y:
yield str(fuben)
continue
yield str(fuben)
fuben -= rank[x]*rank[y]
if rank[x] < rank[y]:
tree[x] = y
rank[y] += rank[x]
else:
tree[y] = x
rank[x] += rank[y]
print(("\n".join(reversed(list(main())))))
| import sys
input = sys.stdin.readline
def readlines(n):
for _ in range(n):
a, b = list(map(int, input().split()))
yield a, b
n, m = list(map(int, input().split()))
bridges = list(readlines(m))
tree = list(range(n+1))
rank = [1] * (n+1)
def root(v):
while tree[v] != v:
tree[v] = tree[tree[v]]
v = tree[v]
return v
def main():
fuben = n*(n-1)//2
for a, b in bridges[::-1]:
x = root(a)
y = root(b)
if x == y:
yield str(fuben)
continue
yield str(fuben)
fuben -= rank[x]*rank[y]
if rank[x] < rank[y]:
tree[x] = y
rank[y] += rank[x]
else:
tree[y] = x
rank[x] += rank[y]
print(("\n".join(reversed(list(main())))))
| p03108 |
class UnionFind():
# コンストラクタ
def __init__(self, n):
# 要素数
self.n = n
# parents[i]: 要素iの親要素の番号
# 要素iが根の場合、parents[i] = -(そのグループの要素数)
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]
# 要素xが属するグループと要素yが属するグループとを併合する
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)]
# 要素x,yが同じグループに属するかどうかを返す
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 = list(map(int,input().split()))
AB = [[int(i) for i in input().split()] for _ in range(M)]
uf = UnionFind(N)
from collections import deque
answer = deque([N*(N-1)//2])
for A,B in AB[::-1]:
A -= 1
B -= 1
if uf.same(A,B):
answer.appendleft(answer[0])
else:
answer.appendleft(answer[0] - uf.size(A) * uf.size(B))
uf.union(A,B)
for i in range(1,M+1):
print((answer[i])) | class UnionFind():
# コンストラクタ
def __init__(self, n):
# 要素数
self.n = n
# parents[i]: 要素iの親要素の番号
# 要素iが根の場合、parents[i] = -(そのグループの要素数)
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]
# 要素xが属するグループと要素yが属するグループとを併合する
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)]
# 要素x,yが同じグループに属するかどうかを返す
def same(self, x, y):
return self.find(x) == self.find(y)
N,M = map(int,input().split())
AB = [[int(i)-1 for i in input().split()] for _ in range(M)]
UF = UnionFind(N)
from collections import deque
ans = deque([N*(N-1)//2])
for A,B in AB[::-1]:
if UF.same(A,B):
ans.appendleft(ans[0])
else:
ans.appendleft(ans[0] - UF.size(A) * UF.size(B))
UF.union(A,B)
# 崩壊する前の情報はいらない
ans.popleft()
print(*ans, sep="\n")
| p03108 |
class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
# 正==子: 根の頂点番号 / 負==根: 連結頂点数
def find(self, x):
if self.parent[x] < 0:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return False
else:
if self.size(x) < self.size(y):
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
x = self.find(x)
return -self.parent[x]
n, m = map(int, input().split())
bridges = []
for _ in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
bridges.append((a, b))
uf = UnionFind(n)
incnv = (n - 1) * n // 2
ans = [None] * m
for i in range(m - 1, -1, -1):
a, b = bridges[i]
ans[i] = incnv
if not uf.same(a, b):
x = uf.size(a)
incnv += x * (x - 1) // 2
x = uf.size(b)
incnv += x * (x - 1) // 2
uf.unite(a, b)
x = uf.size(a)
incnv -= x * (x - 1) // 2
print(*ans, sep='\n')
| class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
# 正==子: 根の頂点番号 / 負==根: 連結頂点数
def find(self, x):
if self.parent[x] < 0:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return False
else:
if self.size(x) < self.size(y):
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
x = self.find(x)
return -self.parent[x]
def main():
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
g = tuple(reversed(tuple((int(x) - 1 for x in input().split()) for _ in range(m))))
t = n * (n - 1) // 2
ret = [t] # 最後反転
uf = UnionFind(n)
for a, b in g[:-1]:
if not uf.same(a, b):
t -= uf.size(a) * uf.size(b)
ret.append(t)
uf.unite(a, b)
ret.reverse()
print(*ret, sep='\n')
if __name__ == '__main__':
main()
| p03108 |
class UnionFind:
def __init__(self, n):
self.v = [-1] * n
def find(self, x):
if self.v[x] < 0:
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
else:
if self.v[x] > self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.v[self.find(x)]
def main():
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
collapse_schedule = []
for _ in range(M):
A, B = (int(x) - 1 for x in input().split())
collapse_schedule.append((A, B))
collapse_schedule.reverse()
uf = UnionFind(N)
def evaluate(size):
return size * (size - 1) // 2
all_dropped = evaluate(N)
curr = all_dropped
ret = [-1] * M
ret[-1] = all_dropped
for i, (a, b) in zip(reversed(range(M - 1)), collapse_schedule):
if not uf.same(a, b):
sa, sb = uf.size(a), uf.size(b)
ea, eb = evaluate(sa), evaluate(sb)
curr += ea + eb
uf.unite(a, b)
sa = uf.size(a)
ea = evaluate(sa)
curr -= ea
ret[i] = curr
print(*ret, sep='\n')
if __name__ == '__main__':
main()
| class UnionFind:
def __init__(self, n):
self.v = [-1] * n
def find(self, x):
if self.v[x] < 0:
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
else:
if self.v[x] > self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.v[self.find(x)]
def main():
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
es = []
for _ in range(M):
a, b = (int(x) - 1 for x in input().split())
es.append((a, b))
es.reverse()
es.pop()
uf = UnionFind(N)
ans = [N * (N - 1) // 2]
t = ans[-1]
for a, b in es:
if not uf.same(a, b):
t -= uf.size(a) * uf.size(b)
ans.append(t)
uf.unite(a, b)
ans.reverse()
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| p03108 |
import sys
sys.setrecursionlimit(10**9)
from collections import Counter
from itertools import permutations, combinations,combinations_with_replacement,product
from collections import defaultdict
input = sys.stdin.readline
icase=0
if icase==0:
n,m=list(map(int,input().split()))
a=[0]*m
b=[0]*m
for i in range(m):
ai,bi=list(map(int,input().split()))
a[i]=ai-1
b[i]=bi-1
elif icase==1:
n,m=4,5
a=[0, 2, 0, 1, 0]
b=[1, 3, 2, 2, 3]
elif icase==2:
n,m=6,5
a=[1, 0, 4, 2, 3]
b=[2, 1, 5, 3, 4]
elif icase==3:
n,m=26,25
a=[13, 13, 7, 1, 20, 0, 2, 3, 5, 13, 0, 0, 16, 3, 1, 15, 13, 13, 16, 9, 13, 8, 12, 6, 8]
b=[14, 18, 25, 20, 24, 19, 13, 13, 21, 22, 14, 4, 23, 25, 10, 17, 17, 20, 20, 14, 21, 9, 22, 9, 11]
elif icase==4:
f=open(r"C:\Users\nishi\999atcoder\q100\q087\testcase_01_in.dat")
ll=f.readline()
n,m=list(map(int,ll.split()))
a=[0]*m
b=[0]*m
for i in range(m):
ll=f.readline()
ai,bi=list(map(int,ll.split()))
a[i]=ai-1
b[i]=bi-1
f.close()
pair=[i for i in range(n)]
def root(x):
if x==pair[x]:
return x
else:
tmp=root(pair[x])
pair[x]=tmp
return tmp
def unite(x,y):
x=root(x)
y=root(y)
if x==y:
return
elif x>y:
pair[x]=y
else:
pair[y]=x
def q087():
c2[d1]+=1
if c2[d2]>0:
c2[d2]-=1
# if c2[d2]==0:
# del c2[d2]
if c2[d3]>0:
c2[d3]-=1
# if c2[d3]==0:
# del c2[d3]
# print(c1)
# print(c2)
q=[]
for c2k,c2v in list(c2.items()):
if c2v==0:
q.append(c2k)
while q:
del c2[q.pop()]
# print(c2)
def q087_2(c2):
c3=[]
for c2k,c2v in list(c2.items()):
c3.append((c2k,c2k*c2v))
c=0
# for i in range(len(c3)):
for i,c3i in enumerate(c3):
c+=c3i[1]*(c3i[1]-c3i[0])//2
# for j in range(i+1,len(c3)):
for j,c3j in enumerate(c3[0:i]):
c+=c3i[1]*c3j[1]
return c,c2
cc=[]
c1=[1]*n
c2=defaultdict(int)
c2[1]=n
c=n
pair=[i for i in range(n)]
for i in range(m-1):
#------------------------
rta=root(a[m-i-1])
rtb=root(b[m-i-1])
if c1[rta]>=n or c1[rtb]>=n:
cc.append(0)
continue
if rta<rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rta]+=c1[rtb]
c1[rtb]=0
d1=c1[rta]
# pair[rtb]=rta
unite(a[m-i-1],b[m-i-1])
elif rta>rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rtb]+=c1[rta]
c1[rta]=0
d1=c1[rtb]
# pair[rta]=rtb
unite(a[m-i-1],b[m-i-1])
else:
cc.append(c)
continue
#-------------------------------
q087()
# c3=[]
# c=0
c,c2=q087_2(c2)
cc.append(c)
#-------------------------------
for i in range(m-2,-1,-1):
print((cc[i]))
print((n*(n-1)//2)) | import sys
sys.setrecursionlimit(10**9)
from collections import Counter
from itertools import permutations, combinations,combinations_with_replacement,product
from collections import defaultdict
input = sys.stdin.readline
icase=0
if icase==0:
n,m=list(map(int,input().split()))
a=[0]*m
b=[0]*m
for i in range(m):
ai,bi=list(map(int,input().split()))
a[i]=ai-1
b[i]=bi-1
elif icase==1:
n,m=4,5
a=[0, 2, 0, 1, 0]
b=[1, 3, 2, 2, 3]
elif icase==2:
n,m=6,5
a=[1, 0, 4, 2, 3]
b=[2, 1, 5, 3, 4]
elif icase==3:
n,m=26,25
a=[13, 13, 7, 1, 20, 0, 2, 3, 5, 13, 0, 0, 16, 3, 1, 15, 13, 13, 16, 9, 13, 8, 12, 6, 8]
b=[14, 18, 25, 20, 24, 19, 13, 13, 21, 22, 14, 4, 23, 25, 10, 17, 17, 20, 20, 14, 21, 9, 22, 9, 11]
elif icase==4:
f=open(r"C:\Users\nishi\999atcoder\q100\q087\testcase_01_in.dat")
ll=f.readline()
n,m=list(map(int,ll.split()))
a=[0]*m
b=[0]*m
for i in range(m):
ll=f.readline()
ai,bi=list(map(int,ll.split()))
a[i]=ai-1
b[i]=bi-1
f.close()
pair=[i for i in range(n)]
def root(x):
if x==pair[x]:
return x
else:
tmp=root(pair[x])
pair[x]=tmp
return tmp
def unite(x,y):
x=root(x)
y=root(y)
if x==y:
return
elif x>y:
pair[x]=y
else:
pair[y]=x
def q087():
cc=[]
c1=[1]*n
c2=defaultdict(int)
c2[1]=n
c=n
# pair=[i for i in range(n)]
for i in range(m-1):
#------------------------
rta=root(a[m-i-1])
rtb=root(b[m-i-1])
if c1[rta]>=n or c1[rtb]>=n:
cc.append(0)
continue
if rta<rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rta]+=c1[rtb]
c1[rtb]=0
d1=c1[rta]
# pair[rtb]=rta
unite(a[m-i-1],b[m-i-1])
elif rta>rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rtb]+=c1[rta]
c1[rta]=0
d1=c1[rtb]
# pair[rta]=rtb
unite(a[m-i-1],b[m-i-1])
else:
cc.append(c)
continue
c2[d1]+=1
if c2[d2]>0:
c2[d2]-=1
# if c2[d2]==0:
# del c2[d2]
if c2[d3]>0:
c2[d3]-=1
# if c2[d3]==0:
# del c2[d3]
# print(c1)
# print(c2)
q=[]
for c2k,c2v in list(c2.items()):
if c2v==0:
q.append(c2k)
while q:
del c2[q.pop()]
# print(c2)
c3=[]
for c2k,c2v in list(c2.items()):
c3.append((c2k,c2k*c2v))
c=0
# for i in range(len(c3)):
for i,c3i in enumerate(c3):
c+=c3i[1]*(c3i[1]-c3i[0])//2
# for j in range(i+1,len(c3)):
for j,c3j in enumerate(c3[0:i]):
c+=c3i[1]*c3j[1]
cc.append(c)
for i in range(m-2,-1,-1):
print((cc[i]))
print((n*(n-1)//2))
#-------------------------------
q087()
#-------------------------------
| p03108 |
import sys
sys.setrecursionlimit(10**9)
from collections import defaultdict
input = sys.stdin.readline
icase=0
if icase==0:
n,m=list(map(int,input().split()))
a=[0]*m
b=[0]*m
for i in range(m):
ai,bi=list(map(int,input().split()))
a[i]=ai-1
b[i]=bi-1
pair=[i for i in range(n)]
def root(x):
if x==pair[x]:
return x
else:
tmp=root(pair[x])
pair[x]=tmp
return tmp
def unite(x,y):
x=root(x)
y=root(y)
if x==y:
return
elif x>y:
pair[x]=y
else:
pair[y]=x
def q087():
cc=[]
c1=[1]*n
c2=defaultdict(int)
c2[1]=n
c=n
for i in range(m-1):
rta=root(a[m-i-1])
rtb=root(b[m-i-1])
if c1[rta]>=n or c1[rtb]>=n:
cc.append(0)
continue
if rta<rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rta]+=c1[rtb]
c1[rtb]=0
d1=c1[rta]
pair[rtb]=rta
# unite(a[m-i-1],b[m-i-1])
elif rta>rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rtb]+=c1[rta]
c1[rta]=0
d1=c1[rtb]
pair[rta]=rtb
# unite(a[m-i-1],b[m-i-1])
else:
cc.append(c)
continue
c2[d1]+=1
if c2[d2]>0:
c2[d2]-=1
if c2[d3]>0:
c2[d3]-=1
q=[]
for c2k,c2v in list(c2.items()):
if c2v==0:
q.append(c2k)
while q:
del c2[q.pop()]
c3=[]
for c2k,c2v in list(c2.items()):
c3.append((c2k,c2k*c2v))
c=0
for i,c3i in enumerate(c3):
c+=c3i[1]*(c3i[1]-c3i[0])//2
for j,c3j in enumerate(c3[0:i]):
c+=c3i[1]*c3j[1]
cc.append(c)
for i in range(m-2,-1,-1):
print((cc[i]))
print((n*(n-1)//2))
#-------------------------------
q087()
#-------------------------------
| import sys
sys.setrecursionlimit(10**9)
from collections import defaultdict
input = sys.stdin.readline
icase=0
if icase==0:
n,m=list(map(int,input().split()))
a=[0]*m
b=[0]*m
for i in range(m):
ai,bi=list(map(int,input().split()))
a[i]=ai-1
b[i]=bi-1
pair=[i for i in range(n)]
def root(x):
if x==pair[x]:
return x
else:
tmp=root(pair[x])
pair[x]=tmp
return tmp
def unite(x,y):
x=root(x)
y=root(y)
if x==y:
return
elif x>y:
pair[x]=y
else:
pair[y]=x
def q087():
cc=[]
c1=[1]*n
c2=defaultdict(int)
c2[1]=n
c=n
for i in range(m-1):
rta=root(a[m-i-1])
rtb=root(b[m-i-1])
if c1[rta]>=n or c1[rtb]>=n:
cc.append(0)
continue
if rta<rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rta]+=c1[rtb]
c1[rtb]=0
d1=c1[rta]
# pair[rtb]=rta
unite(a[m-i-1],b[m-i-1])
elif rta>rtb:
d2=c1[rta]
d3=c1[rtb]
c1[rtb]+=c1[rta]
c1[rta]=0
d1=c1[rtb]
# pair[rta]=rtb
unite(a[m-i-1],b[m-i-1])
else:
cc.append(c)
continue
c2[d1]+=1
if c2[d2]>0:
c2[d2]-=1
if c2[d3]>0:
c2[d3]-=1
q=[]
for c2k,c2v in list(c2.items()):
if c2v==0:
q.append(c2k)
while q:
del c2[q.pop()]
c3=[]
for c2k,c2v in list(c2.items()):
c3.append((c2k,c2k*c2v))
c=0
for i,c3i in enumerate(c3):
c+=c3i[1]*(c3i[1]-c3i[0])//2
for j,c3j in enumerate(c3[0:i]):
c+=c3i[1]*c3j[1]
cc.append(c)
for i in range(m-2,-1,-1):
print((cc[i]))
print((n*(n-1)//2))
#-------------------------------
q087()
#-------------------------------
| p03108 |
def check_connection(bridge_data, a_bridge, b_bridge):
flg = 1
fin_flg = 0
a_bridge_data = set([a_bridge])
b_bridge_data = set([b_bridge])
pre_a = 1
pre_b = 1
while flg:
flg = 0
for i in range(len(bridge_data)):
bridge_data_now = bridge_data[i]
if bridge_data_now[0] in a_bridge_data:
a_bridge_data.add(bridge_data_now[1])
flg = 1
if bridge_data_now[1] in a_bridge_data:
a_bridge_data.add(bridge_data_now[0])
flg = 1
if bridge_data_now[0] in b_bridge_data:
b_bridge_data.add(bridge_data_now[1])
flg = 1
if bridge_data_now[1] in b_bridge_data:
b_bridge_data.add(bridge_data_now[0])
flg = 1
if len(a_bridge_data | b_bridge_data) < len(a_bridge_data) + len(b_bridge_data):
fin_flg = 1
break
if pre_a == len(a_bridge_data) and pre_b == len(b_bridge_data):
break
else:
pre_a = len(a_bridge_data)
pre_b = len(b_bridge_data)
return fin_flg, a_bridge_data, b_bridge_data
def delete(bridge_data, a_bridge, b_bridge, big_island_data):
flg, a_bridge_data, b_bridge_data = check_connection(bridge_data, a_bridge, b_bridge)
if flg:
return big_island_data
else:
for i in range(len(big_island_data)):
if a_bridge in big_island_data[i]:
big_island_data[i] = a_bridge_data
big_island_data.append(b_bridge_data)
return big_island_data
def calc_ans(big_island_data):
if len(big_island_data) == 1:
print((0))
else:
ans = 0
data = [len(ele) for ele in big_island_data]
for i in range(len(data)):
ans += data[i] * (sum(data) - data[i])
print((int(ans / 2)))
def calc_data(island_num, bridge_num, bridge_data):
big_island_data = [set([i for i in range(1, island_num + 1)])]
for i in range(bridge_num - 1):
delete_bridge = bridge_data[i]
big_island_data = delete(bridge_data[i+1:] , delete_bridge[0], delete_bridge[1], big_island_data)
calc_ans(big_island_data)
calc_ans(['1' for i in range(island_num)])
def main():
island_num, bridge_num = list(map(int, input().split()))
bridge_data = [list(map(int, input().split())) for i in range(bridge_num)]
calc_data(island_num, bridge_num, bridge_data)
if __name__ == '__main__':
main() |
def get_parent(num, parent):
if parent[num] == num:
return num
else:
return get_parent(parent[num], parent)
def calc_change_data(ans, parent, a_parent, b_parent, island_count):
big_parent = max(a_parent, b_parent)
min_parent = min(a_parent, b_parent)
parent[big_parent] = min_parent
ans -= island_count[big_parent] * island_count[min_parent]
island_count[min_parent] += island_count[big_parent]
return ans, parent, island_count
def main():
island_num, bridge_num = list(map(int, input().split()))
bridge_data = [list(map(int, input().split())) for i in range(bridge_num)]
parent = [i for i in range(island_num)]
island_count = [1 for i in range(island_num)]
ans = island_num * (island_num - 1) // 2
ans_data = [ans]
for num_a, num_b in bridge_data[::-1]:
num_a -= 1
num_b -= 1
a_parent = get_parent(num_a, parent)
b_parent = get_parent(num_b, parent)
if a_parent != b_parent:
ans, parent, island_count = calc_change_data(ans, parent, a_parent, b_parent, island_count)
ans_data.append(ans)
for i in range(bridge_num)[::-1]:
print((ans_data[i]))
if __name__ == '__main__':
main() | p03108 |
#!usr/bin/env python3
from collections import defaultdict
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
"""
a,b,c = LI()
print(min(b//a,c))
"""
#B
"""
a,b,k = LI()
i = 1
ans = [1]
while i <= min(a,b):
i += 1
if a%i == 0 and b%i == 0:
ans.append(i)
print(ans[-k])
"""
#C
"""
s = S()
n = len(s)
while len(s)>1:
i = 0
f = True
while s[i] == s[i+1]:
if i+1 == len(s)-1:
f = False
break
i += 1
if not f:break
s.pop(i)
s.pop(i)
print(n-len(s))
"""
#D
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if x == y:
ans.insert(0,ans[0])
return
sx = s[x]
sy = s[y]
if rank[x] < rank[y]:
par[x] = y
s[y] += s[x]
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
s[x] += s[y]
ans.insert(0,ans[0]+sx*sy)
n,m = LI()
v = LIR(m)
v = v[::-1]
par = [i for i in range(n)]
rank = [0 for i in range(n)]
s = [1 for i in range(n)]
k=n*(n-1)//2
ans = [0]
v.pop(-1)
for a,b in v:
if ans[0]==k:
ans.insert(0,k)
continue
a -= 1
b -= 1
unite(a,b)
for i in ans:
print((k-i))
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict
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
"""
a,b,c = LI()
print(min(b//a,c))
"""
#B
"""
a,b,k = LI()
i = 1
ans = [1]
while i <= min(a,b):
i += 1
if a%i == 0 and b%i == 0:
ans.append(i)
print(ans[-k])
"""
#C
"""
s = S()
n = len(s)
while len(s)>1:
i = 0
f = True
while s[i] == s[i+1]:
if i+1 == len(s)-1:
f = False
break
i += 1
if not f:break
s.pop(i)
s.pop(i)
print(n-len(s))
"""
#D
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if x == y:
ans.append(ans[-1])
return
sx = s[x]
sy = s[y]
if rank[x] < rank[y]:
par[x] = y
s[y] += s[x]
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
s[x] += s[y]
ans.append(ans[-1]+sx*sy)
n,m = LI()
v = LIR(m)
v = v[::-1]
par = [i for i in range(n)]
rank = [0 for i in range(n)]
s = [1 for i in range(n)]
k=n*(n-1)//2
ans = [0]
v.pop(-1)
for a,b in v:
if ans[0]==k:
ans.append(k)
continue
a -= 1
b -= 1
unite(a,b)
for i in ans[::-1]:
print((k-i))
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| p03108 |
#!usr/bin/env python3
from collections import defaultdict
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 = [0.0 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
"""
a,b,c = LI()
print(min(b//a,c))
"""
#B
"""
a,b,k = LI()
i = 1
ans = [1]
while i <= min(a,b):
i += 1
if a%i == 0 and b%i == 0:
ans.append(i)
print(ans[-k])
"""
#C
"""
s = list(map(int,S()))
print(2*min(sum(s),len(s)-sum(s)))
"""
#D
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if x == y:
ans.append(ans[-1])
return
sx = s[x]
sy = s[y]
if rank[x] < rank[y]:
par[x] = y
s[y] += sx
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
s[x] += sy
ans.append(ans[-1]+sx*sy)
n,m = LI()
v = LIR(m)
v = v[::-1]
par = [i for i in range(n)]
rank = [0 for i in range(n)]
s = [1 for i in range(n)]
ans = [0]
k = n*(n-1)//2
v.pop(-1)
for a,b in v:
if ans[0] == k:
ans.append(k)
continue
a -= 1
b -= 1
unite(a,b)
for i in ans[::-1]:
print((k-i))
#E
"""
n,a,b = LI()
s = input()
ans = 0
i = 0
while i < n:
j = i+1
if s[i:j] in s[:i]:
while s[i:j] in s[:i]:
j += 1
if j >= n-1:break
j -= 1
print(s[i:j],s[:i])
ans += min(b,a*(j-i+1))
else:
ans += a*(j-i)
i = j
print(ans)
"""
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict
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
"""
a,b,c = LI()
print(min(b//a,c))
"""
#B
"""
a,b,k = LI()
i = 1
ans = [1]
while i <= min(a,b):
i += 1
if a%i == 0 and b%i == 0:
ans.append(i)
print(ans[-k])
"""
#C
"""
s = list(map(int,S()))
print(2*min(sum(s),len(s)-sum(s)))
"""
#D
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if x == y:
ans.append(ans[-1])
return
sx = s[x]
sy = s[y]
if rank[x] < rank[y]:
par[x] = y
s[y] += sx
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
s[x] += sy
ans.append(ans[-1]+sx*sy)
n,m = LI()
v = LIR(m)
v = v[::-1]
par = [i for i in range(n)]
rank = [0 for i in range(n)]
s = [1 for i in range(n)]
ans = [0]
k = n*(n-1)//2
v.pop(-1)
for a,b in v:
if ans[0] == k:
ans.append(k)
continue
a -= 1
b -= 1
unite(a,b)
for i in ans[::-1]:
print((k-i))
#E
"""
n,a,b = LI()
s = input()
ans = 0
i = 0
while i < n:
j = i+1
if s[i:j] in s[:i]:
while s[i:j] in s[:i]:
j += 1
if j >= n-1:break
j -= 1
print(s[i:j],s[:i])
ans += min(b,a*(j-i+1))
else:
ans += a*(j-i)
i = j
print(ans)
"""
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| p03108 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,m = LI()
a = LIR(n)
ans = 0
for i in range(2):
for j in range(2):
for k in range(2):
a.sort(key = lambda x:(-1)**i*x[0]+(-1)**j*x[1]+(-1)**k*x[2])
p = [0,0,0]
for l in range(m):
p[0] += a[l][0]
p[1] += a[l][1]
p[2] += a[l][2]
p = abs(p[0])+abs(p[1])+abs(p[2])
if p > ans:
ans = p
print(ans)
return
#B
def B():
def root(x):
if x == par[x]:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y,su):
x = root(x)
y = root(y)
su += comb_2(s[x])+comb_2(s[y])
if rank[x] < rank[y]:
s[y] += s[x]
su -= comb_2(s[y])
par[x] = y
else:
s[x] += s[y]
su -= comb_2(s[x])
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
return su
def comb_2(a):
return a*(a-1)//2
n,m = LI()
v = LIR(m)
par = [i for i in range(n)]
rank = [0]*n
s = [1]*n
su = comb_2(n)
ans = [su]
for a,b in v[:0:-1]:
a -= 1
b -= 1
if root(a) != root(b):
su = unite(a,b,su)
ans.append(su)
for i in ans[::-1]:
print(i)
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#I
def I_():
return
#Solve
if __name__ == "__main__":
B()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def root(x):
if par[x] == x:
return par[x]
s[par[x]] += s[x]
s[x] = 0
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
s[y] += s[x]
s[x] = 0
else:
par[y] = x
s[x] += s[y]
s[y] = 0
if rank[x] == rank[y]:
rank[x] += 1
n,m = LI()
v = []
for i in range(m):
a,b = LI()
a -= 1
b -= 1
v.append((a,b))
par = [i for i in range(n)]
rank = [0]*n
s = [1]*n
su = n*(n-1) >> 1
ans = [su]
for i,j in v[1:][::-1]:
ri = root(i)
rj = root(j)
if ri != rj:
su -= s[ri]*s[rj]
unite(i,j)
ans.append(su)
for i in ans[::-1]:
print(i)
return
#Solve
if __name__ == "__main__":
solve()
| p03108 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def root(x):
if par[x] == x:
return par[x]
s[par[x]] += s[x]
s[x] = 0
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
s[y] += s[x]
s[x] = 0
else:
par[y] = x
s[x] += s[y]
s[y] = 0
if rank[x] == rank[y]:
rank[x] += 1
n,m = LI()
v = []
for i in range(m):
a,b = LI()
a -= 1
b -= 1
v.append((a,b))
par = [i for i in range(n)]
rank = [0]*n
s = [1]*n
su = n*(n-1) >> 1
ans = [su]
for i,j in v[1:][::-1]:
ri = root(i)
rj = root(j)
if ri != rj:
su -= s[ri]*s[rj]
unite(i,j)
ans.append(su)
for i in ans[::-1]:
print(i)
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def root(x):
if par[x] == x:
return par[x]
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
s[y] += s[x]
s[x] = 0
else:
par[y] = x
s[x] += s[y]
s[y] = 0
if rank[x] == rank[y]:
rank[x] += 1
n,m = LI()
v = []
for i in range(m):
a,b = LI()
a -= 1
b -= 1
v.append((a,b))
par = [i for i in range(n)]
rank = [0]*n
s = [1]*n
su = n*(n-1) >> 1
ans = [su]
for i,j in v[1:][::-1]:
ri = root(i)
rj = root(j)
if ri != rj:
su -= s[ri]*s[rj]
unite(i,j)
ans.append(su)
for i in ans[::-1]:
print(i)
return
#Solve
if __name__ == "__main__":
solve()
| p03108 |
# -*- coding: utf-8 -*-
"""
・ライブラリ確認用
"""
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
from datetime import date
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
# Union-Find木
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
# 1-indexedのままでOK、その場合は[0]は未使用
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
self.rank = [0] * (n+1)
# あるノードを根とする集合に属するノード数
self.size = [1] * (n+1)
# あるノードを根とする集合が木かどうか
self.tree = [True] * (n+1)
# 根の検索(グループ番号と言えなくもない)
def find(self, x):
# 根ならその番号を返す
if self.par[x] == x:
return x
else:
# 走査していく過程で親を書き換える
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
# 根を探す
x = self.find(x)
y = self.find(y)
# 木かどうかの判定用
if x == y:
self.tree[x] = False
return
if not self.tree[x] or not self.tree[y]:
self.tree[x] = self.tree[y] = False
# 木の高さを比較し、低いほうから高いほうに辺を張る
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]
# 木の高さが同じなら片方を1増やす
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# あるノードの属する集合のノード数
def get_size(self, x):
return self.size[self.find(x)]
# 木かどうかの判定
def is_tree(self, x):
return self.tree[self.find(x)]
N,M=MAP()
uf=UnionFind(N)
# 橋が0の時の不便さ
sm=N*(N-1)//2
ans=[0]*(M)
ans[M-1]=sm
edges=[]
for i in range(M):
a,b=MAP()
edges.append((a,b))
# 逆から、1本ずつ橋をつないでいく
for i in range(M-1, 0, -1):
a,b=edges[i]
# 同じグループに属してなければ、不便さに変化がある
if not uf.same(a, b):
# 今回橋が繋がる分、aのグループに属する島数*bのグループに属する島数の不便さを減らす
sm-=uf.get_size(a)*uf.get_size(b)
uf.union(a, b)
ans[i-1]=sm
[print(ans[i]) for i in range(M)]
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class UnionFind:
""" Union-Find木 """
def __init__(self, n):
self.n = n
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
# 1-indexedのままでOK、その場合は[0]は未使用
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
self.rank = [0] * (n+1)
# あるノードを根とする集合に属するノード数
self.size = [1] * (n+1)
# あるノードを根とする集合が木かどうか
self.tree = [True] * (n+1)
def find(self, x):
""" 根の検索(グループ番号と言えなくもない) """
# 根ならその番号を返す
if self.par[x] == x:
return x
else:
# 走査していく過程で親を書き換える
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
""" 併合 """
# 根を探す
x = self.find(x)
y = self.find(y)
# 木かどうかの判定用
if x == y:
self.tree[x] = False
return
if not self.tree[x] or not self.tree[y]:
self.tree[x] = self.tree[y] = False
# 木の高さを比較し、低いほうから高いほうに辺を張る
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]
# 木の高さが同じなら片方を1増やす
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def is_same(self, x, y):
""" 同じ集合に属するか判定 """
return self.find(x) == self.find(y)
def get_size(self, x=None):
if x is not None:
""" あるノードの属する集合のノード数 """
return self.size[self.find(x)]
else:
""" 集合の数 """
res = set()
for i in range(self.n+1):
res.add(self.find(i))
# グループ0の分を引いて返却
return len(res) - 1
def is_tree(self, x):
""" 木かどうかの判定 """
return self.tree[self.find(x)]
N, M = MAP()
AB = []
for i in range(M):
a, b = MAP()
AB.append((a, b))
# 終了状態からUnionFindで復元していく
cur = N * (N-1) // 2
ans = [cur]
uf = UnionFind(N)
for a, b in AB[::-1]:
if not uf.is_same(a, b):
cur -= uf.get_size(a) * uf.get_size(b)
uf.union(a, b)
ans.append(cur)
ans = ans[::-1]
[print(a) for a in ans[1:]]
| p03108 |
n,m=list(map(int,input().split()))
ab=[list(map(int, input().split())) for _ in range(m)]
ab=ab[::-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 [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(n) #初期化
result=[]
for item in ab[0:-1]:
a=item[0]-1
b=item[1]-1
uf.union(a,b)
tmp=uf.all_group_members()
all_iland=n*(n-1)//2
#print(tmp)
for item in list(tmp.keys()):
group_len=len(tmp[item])
all_iland-=group_len*(group_len-1)//2
result.append(all_iland)
for item in result[::-1]:
print(item)
print((n*(n-1)//2))
#uf.union(0, 2)#グループを併合
#uf.find(0) #親要素が変える
| n,m=list(map(int,input().split()))
ab=[list(map(int, input().split())) for _ in range(m)]
ab=ab[::-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 [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(n) #初期化
result=[]
all_iland=n*(n-1)//2
for item in ab[0:-1]:
a=item[0]-1
b=item[1]-1
if uf.same(a,b):
i=1
else:
a_size=uf.size(a)
b_size=uf.size(b)
all_iland+=a_size*(a_size-1)//2+b_size*(b_size-1)//2
uf.union(a,b)
a_size=uf.size(a)
all_iland-=a_size*(a_size-1)//2
result.append(all_iland)
for item in result[::-1]:
print(item)
print((n*(n-1)//2))
#uf.union(0, 2)#グループを併合
#uf.find(0) #親要素が変える
| p03108 |
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M = lr()
AB = [lr() for _ in range(M)]
V = [x for x in range(N+1)]
total = N * (N-1) // 2
def find(A, x):
parent = A[x]
if parent == x: return x
root = find(A, parent)
A[x] = root
return root
def union(A, x, y):
root, second = find(A, x), find(A, y)
if root > second:
second, root = root, second
A[second] = root
conv = 0
answer = []
for a, b in AB[::-1]:
answer.append(total - conv)
root_A = find(V, a); root_B = find(V, b)
if root_A != root_B:
conv += V.count(root_A) * V.count(root_B)
union(V, a, b)
V = [find(V, x) for x in V]
for x in answer[::-1]:
print(x)
| # coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M = lr()
AB = [lr() for _ in range(M)]
V = [x for x in range(N+1)]
total = N * (N-1) // 2
def find(A, x):
parent = A[x]
if parent == x: return x
root = find(A, parent)
A[x] = root
return root
def union(A, x, y):
root, second = find(A, x), find(A, y)
if root > second:
second, root = root, second
A[second] = root
conv = 0
answer = []
group = [1] * (N+1)
for a, b in AB[::-1]:
answer.append(total - conv)
root_A = find(V, a); root_B = find(V, b)
if root_A != root_B:
conv += group[root_A] * group[root_B]
group[root_A] += group[root_B]
group[root_B] = group[root_A]
union(V, a, b)
for x in answer[::-1]:
print(x)
| p03108 |
def comb(n):
return (n * (n - 1)) // 2
def main():
n, m = [int(a) for a in input().split()]
AB = [
[int(a) for a in input().split()]
for _ in range(m)
]
table = {i: (1, set([i])) for i in range(n)} # (便利さ,行ける島集合)
current_benrisa = 0
max_hubensa = comb(n)
reversed_benrisa = []
for ai, bi in reversed(AB):
reversed_benrisa.append(current_benrisa)
s1_benrisa, s1_set = table[ai-1]
s2_benrisa, s2_set = table[bi-1]
if s1_set is s2_set: # 変化なし
continue
new_benri = s1_benrisa + s2_benrisa
new_set = s1_set.union(s2_set)
for t in new_set:
table[t] = (new_benri, new_set)
inc = s1_benrisa * s2_benrisa
current_benrisa += inc
continue
for a in reversed(reversed_benrisa):
print((max_hubensa - a))
if __name__ == '__main__':
main()
| def comb(n):
return (n * (n - 1)) // 2
def main():
n, m = [int(a) for a in input().split()]
AB = [
[int(a) for a in input().split()]
for _ in range(m)
]
table = {i: {i} for i in range(n)} # (便利さ,行ける島集合)
current_benrisa = 0
max_hubensa = comb(n)
reversed_benrisa = []
for ai, bi in reversed(AB):
reversed_benrisa.append(current_benrisa)
s1_set = table[ai - 1]
s2_set = table[bi - 1]
if s1_set is s2_set: # 変化なし
continue
s1_benrisa = len(s1_set)
s2_benrisa = len(s2_set)
# new_benri = s1_benrisa + s2_benrisa
if len(s1_set) > len(s2_set):
s1_set.update(s2_set)
for t in s2_set:
table[t] = s1_set
else:
s2_set.update(s1_set)
for t in s1_set:
table[t] = s2_set
# new_set = s1_set.union(s2_set)
# for t in new_set:
# table[t] = (new_benri, new_set)
inc = s1_benrisa * s2_benrisa
current_benrisa += inc
continue
for a in reversed(reversed_benrisa):
print((max_hubensa - a))
if __name__ == '__main__':
main()
| p03108 |
def comb(n):
return n * (n - 1) // 2
class UnionFind():
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
return False
def subsetall(self):
a = []
for i in range(len(self.table)):
if self.table[i] < 0:
a.append((i, -self.table[i]))
return a
def cost(self):
result = 0
for i in range(len(self.table)):
if self.table[i] < 0:
result += comb(-self.table[i])
return result
N, M = [int(i) for i in input().split()]
A = [0] * M
B = [0] * M
for i in range(M):
A[M - i - 1], B[M - i - 1] = [int(i) - 1 for i in input().split()]
uf = UnionFind(N)
result = comb(N)
lst = [result]
for i in range(M - 1):
uf.union(A[i], B[i])
lst.append(result - uf.cost())
lst.reverse()
for li in lst:
print(li)
| class UnionFind:
def __init__(self, size):
self.data = [-1 for _ in range(size)]
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, M = [int(i) for i in input().split()]
A = [0] * M
B = [0] * M
for i in range(M):
A[M - i - 1], B[M - i - 1] = [int(i) - 1 for i in input().split()]
uf = UnionFind(N)
result = N * (N - 1) // 2
lst = [result]
for i in range(M - 1):
if not uf.same(A[i], B[i]):
result -= uf.size(A[i]) * uf.size(B[i])
lst.append(result)
uf.union(A[i], B[i])
for i in range(M - 1, -1, -1):
print((lst[i]))
| p03108 |
N, M = [int(x) for x in input().split()]
A = []
B = []
for i in range(M):
a, b = [int(x) for x in input().split()]
A.append(a)
B.append(b)
A.reverse()
B.reverse()
import math
Z = N * (N - 1) // 2
L = []
ans = []
for i in range(M):
a, b = A[i], B[i]
ia, ib = -1, -1
for j in range(len(L)):
if a in L[j]:
ia = j
if b in L[j]:
ib = j
if ia == -1 and ib == -1:
L.append({a, b})
elif ib != -1 and ia != -1 and ia != ib:
L[ia] = L[ia].union(L[ib])
del L[ib]
elif ib != -1:
L[ib].add(a)
elif ia != -1:
L[ia].add(b)
else:
print("Error?")
# print(L)
ans.append(Z - sum([(len(x) * (len(x) - 1)) // 2 for x in L]))
ans.reverse()
del ans[0]
ans.append(Z)
for a in ans:
print(a) | import sys
sys.setrecursionlimit(100000)
N, M = [int(x) for x in input().split()]
g = 0
A = []
B = []
for i in range(M):
a, b = [int(x) for x in input().split()]
A.append(a)
B.append(b)
A.reverse()
B.reverse()
# ----- Union Find -----------
PARENT = list(range( N + 1 ))
SIZE = [1] * (N + 1 )
def root(n):
if PARENT[n] == n:
return n
else:
ret = root(PARENT[n])
PARENT[n] = ret
return ret
def same(n1, n2):
return root(n1) == root(n2)
def unite(n1, n2):
n1 = root(n1)
n2 = root(n2)
if n1 == n2:
return
PARENT[n1] = n2
global g
g = g + SIZE[n2] * SIZE[n1]
SIZE[n2] += SIZE[n1]
SIZE[n1] = 0
Z = N * (N - 1) // 2
ans = []
for i in range(M):
a, b = A[i], B[i]
unite(a, b)
# print(PARENT[1:])
# print(SIZE[1:])
# print(g)
# print(Z - g)
ans.append(Z - g)
# print("----")
ans.reverse()
del ans[0]
for a in ans:
print(a)
print(Z)
| p03108 |
import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
ab = [[int(x) for x in input().split()] for _ in range(m)][::-1]
#Union Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
#初期化
#根なら-size,子なら親の頂点
par = [-1]*n
from math import factorial
def cmb(n, k):
return factorial(n) // (factorial(k) * factorial(n - k))
convinience = [0]
for i in ab:
a, b = i
res = convinience[-1]
a -= 1
b -= 1
if find(a) == find(b):
convinience.append(res)
continue
if size(a) > 1:
res -= cmb(size(a), 2)
if size(b) > 1:
res -= cmb(size(b), 2)
unite(a, b)
res += cmb(size(a), 2)
convinience.append(res)
convinience = convinience[1::][::-1] + [0]
ans = [0]
for i in range(m):
ans.append(convinience[i] - convinience[i + 1] + ans[-1])
for i in ans[1:]:
print(i) | import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
ab = [[int(x) for x in input().split()] for _ in range(m)][::-1]
#Union Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
#初期化
#根なら-size,子なら親の頂点
par = [-1]*n
def cmb(n, k):
return n * (n - 1) // 2
convinience = [0]
for i in ab:
a, b = i
res = convinience[-1]
a -= 1
b -= 1
if find(a) == find(b):
convinience.append(res)
continue
if size(a) > 1:
res -= cmb(size(a), 2)
if size(b) > 1:
res -= cmb(size(b), 2)
unite(a, b)
res += cmb(size(a), 2)
convinience.append(res)
convinience = convinience[1::][::-1] + [0]
ans = [0]
for i in range(m):
ans.append(convinience[i] - convinience[i + 1] + ans[-1])
for i in ans[1:]:
print(i)
| p03108 |
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(m)]
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(n)
ans = [n*(n-1)//2]
for a,b in ab[::-1]:
uf.union(a-1, b-1)
tmp = n * (n-1) // 2
for v in list(uf.all_group_members().values()):
l = len(v)
tmp -= l * (l-1) // 2
ans.append(tmp)
for i in ans[-2::-1]:
print(i)
| n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(m)]
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(n)
ans = [n*(n-1)//2]
for a,b in ab[::-1]:
if not uf.same(a-1, b-1):
ans.append(ans[-1] - uf.size(a-1) * uf.size(b-1))
else:
ans.append(ans[-1])
uf.union(a-1, b-1)
for i in ans[-2::-1]:
print(i)
| p03108 |
n, m=list(map(int, input().split()))
a=[0 for i in range(m)]
b=[0 for i in range(m)]
g=[list() for i in range(1+n)]
#print(g)
for i in range(m):
a[i], b[i]=list(map(int, input().split()))
g[a[i]].append(b[i])
g[b[i]].append(a[i])
#print(g)
def Count_n_d(neighbor, start, search):
visited = []
stack = []
stack.append(start)
result = []
while len(stack) > 0:
next_city = stack.pop()
if next_city in visited:
continue
result.append(next_city)
visited.append(next_city)
for nei in neighbor[next_city]:
if nei==search:
return [[]]
stack.append(nei)
if search in result:
return [[]]
else:
return [result]
def Count_n(neighbor, start, search):
visited = []
queue = []
queue.append(start)
result = []
while len(queue) > 0:
next_city = queue.pop(0)
if next_city in visited:
continue
result.append (next_city)
visited.append(next_city)
for nei in neighbor[next_city]:
queue.append(nei)
if search in result:
return [[]]
else:
return [result]
'''
print(g)
#print(Count(1,4,0))
for l in range(1,n+1):
print('l,Count_n(g,l,0),len(Count_n(g,l,0))',l,Count_n(g,l,0),len(Count_n(g,l,0)[0]))
'''
ans=0
for i in range(m):
g[a[i]].remove(b[i])
g[b[i]].remove(a[i])
cnt_a=len(Count_n(g,a[i],b[i])[0])
if cnt_a==0:
0
else:
ans+=cnt_a*len(Count_n_d(g,b[i],0)[0])
print(ans) | import sys
sys.setrecursionlimit(100000)
n, m=list(map(int, input().split()))
a=[0 for i in range(m)]
b=[0 for i in range(m)]
g=[list() for i in range(1+n)]
#print(g)
par=[i for i in range(n)]
cnt_con=[1 for i in range(n)]
def root(x):
if x==par[x]:
return x
else:
par[x]=root(par[x])
return par[x]
def connect(x,y):
#par[x]=root(x)
#par[y]=root(y)
if root(x)==root(y):
0
else:
cnt_con[root(y)]+=cnt_con[root(x)]
par[root(x)]=root(y)
return
for i in range(m):
a[i], b[i]=list(map(int, input().split()))
a[i], b[i]=a[i]-1, b[i]-1
tmp=int(n*(n-1)/2)
ans=[0]*m
ans[-1]=tmp
#ans[0]=0
#print('a,b=',a,b)
for i in range(m-1,-1,-1):
ans[i]=tmp
if root(a[i])==root(b[i]):
0
else:
tmp-=cnt_con[root(a[i])]*cnt_con[root(b[i])]
connect(a[i],b[i])
#print('i,tmp',i,(a[i],b[i]),ans[i],tmp,par,cnt_con)
for i in range(m):
print((ans[i]))
| p03108 |
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
import heapq
import itertools
import operator
inf = float('inf')
def get_int():
return int(eval(input()))
def get_str():
return input().strip()
def get_list_of_int():
return [int(i) for i in input().split()]
def get_char_list():
return list(input().strip())
def get_root(root, x):
y = x
while y != root.get(y, y):
y = root.get(y, y)
return y
# inputs
N, M = 0, 0
A, B = [], []
def set_inputs():
global N, M, A, B
N, M = get_list_of_int()
for _ in range(M):
a, b = get_list_of_int()
A.append(a)
B.append(b)
def main():
set_inputs()
nc2 = N * (N - 1) // 2
inconv = [0] * M
conns = 0
root = dict()
conns_dict = defaultdict(int)
for i in range(1, M+1):
inconv[M-i] = nc2 - conns
if i == M:
break
a, b = A[M-i], B[M-i]
a_root = get_root(root, a)
a_conns = conns_dict[a_root]
b_root = get_root(root, b)
b_conns = conns_dict[b_root]
if a_conns == 0 and b_conns == 0:
root[a] = a
root[b] = a
conns_dict[a] = 2
conns += 1
elif a_conns == 0:
root[a] = b_root
conns_dict[b_root] = b_conns + 1
conns += b_conns
elif b_conns == 0:
root[b] = a_root
conns_dict[a_root] = a_conns + 1
conns += a_conns
elif a_root != b_root:
root[b_root] = a_root
conns_dict[a_root] = a_conns + b_conns
conns += a_conns * b_conns
for i in inconv:
print(i)
if __name__ == '__main__':
main()
| from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
import heapq
import itertools
import operator
inf = float('inf')
def get_int():
return int(eval(input()))
def get_str():
return input().strip()
def get_list_of_int():
return [int(i) for i in input().split()]
def get_char_list():
return list(input().strip())
def get_root(root, x):
y = x
while y != root.get(y, y):
y = root.get(y, y)
z = x
while z != root.get(z, z):
root[z] = y
z = root.get(z, z)
return y
# inputs
N, M = 0, 0
A, B = [], []
def set_inputs():
global N, M, A, B
N, M = get_list_of_int()
for _ in range(M):
a, b = get_list_of_int()
A.append(a)
B.append(b)
def main():
set_inputs()
nc2 = N * (N - 1) // 2
inconv = [0] * M
conns = 0
root = dict()
conns_dict = defaultdict(int)
for i in range(1, M+1):
inconv[M-i] = nc2 - conns
if i == M:
break
a, b = A[M-i], B[M-i]
a_root = get_root(root, a)
a_conns = conns_dict[a_root]
b_root = get_root(root, b)
b_conns = conns_dict[b_root]
if a_conns == 0 and b_conns == 0:
root[a] = a
root[b] = a
conns_dict[a] = 2
conns += 1
elif a_conns == 0:
root[a] = b_root
conns_dict[b_root] = b_conns + 1
conns += b_conns
elif b_conns == 0:
root[b] = a_root
conns_dict[a_root] = a_conns + 1
conns += a_conns
elif a_root != b_root:
root[b_root] = a_root
conns_dict[a_root] = a_conns + b_conns
conns += a_conns * b_conns
for i in inconv:
print(i)
if __name__ == '__main__':
main()
| p03108 |
class UnionFind_size:
def __init__(self, n):
self.par = [i for i in range(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])
# 結合(unite)する関数
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.size[x] < self.size[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
# 同じグループに属するかを判定する関数
def same_check(self, x, y):
return self.find(x) == self.find(y)
# 要素が属する木のサイズを返す関数
def get_size(self, x):
return self.size[self.find(x)]
# グループ数を返す関数
def group_sum(self):
c = 0
for i in range(len(self.par)):
if self.find(i) == i:
c += 1
return c
if __name__ == "__main__":
N,M = list(map(int, input().split()))
uf = UnionFind_size(N)
A, B = [0] * M, [0] * M
for i in range(M):
A[i], B[i] = [int(j) for j in input().split()]
total = int(N * (N-1) / 2)
ans = [total]
for i in range(M-1):
if uf.same_check(A[-(i+1)], B[-(i+1)]):
ans.append(ans[i])
else:
ans.append(ans[i] - uf.get_size(A[-(i+1)]) * uf.get_size(B[-(i+1)]))
uf.unite(A[-(i+1)], B[-(i+1)])
for i in (reversed(ans)):
print(i) | import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
class UnionFind:
def __init__(self, n):
# 初期状態は全要素が根なので、親は自分自身
self.par = [i for i in range(n+1)]
# 集団の要素数(size)を格納する(初期は全て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])
# 結合(unite)する関数
def unite(self, x, y):
# 根を探す
x = self.find(x)
y = self.find(y)
if x == y:
return
# サイズを比較し、小さい方を大きい方に繋げる
if self.size[x] < self.size[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
# 同じグループに属するかを判定する関数
def is_same(self, x, y):
return self.find(x) == self.find(y)
# 要素が属する木のサイズを返す関数
def get_size(self, x):
return self.size[self.find(x)]
# グループ数を返す関数
def group_sum(self):
c = 0
for i in range(len(self.par)):
if self.find(i) == i:
c += 1
return c
def main():
N,M,*ab = list(map(int, read().split()))
E = [(a, b) for a, b in zip(*[iter(ab)]*2)]
pair = N * (N - 1) // 2
ans = []
uf = UnionFind(N)
con = 0
for a, b in reversed(E):
ans.append(pair)
if not uf.is_same(a, b):
n_a = uf.get_size(a)
n_b = uf.get_size(b)
pair -= n_a * n_b
uf.unite(a, b)
print(("\n".join(map(str, ans[::-1]))))
if __name__ == "__main__":
main()
| p03108 |
import itertools
n, m = list(map(int, input().split()))
pair = []
for i in range(m):
pair.append(list(map(int, input().split())))
ans = []
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
u = UnionFind(n)
l = []
for i in range(1, n + 1):
l.append(i)
c = list(itertools.combinations(l, 2))
for i in range(1, m + 1):
count = 0
for j in range(len(c)):
if u.same_check(int(c[j][0]), int(c[j][1])) == False:
count += 1
ans.append(count)
u.union(pair[-i][0], pair[-i][1])
ans.sort()
for i in range(m):
print((ans[i])) | n, m = list(map(int, input().split()))
pair = []
for i in range(m):
pair.append(list(map(int, input().split())))
pair = pair[::-1]
ans = []
ans.append(int(n*(n-1)/2))
class UnionFind:
def __init__(self, n):
self.par = [-1] * (n+1)
self.rank = [0] * (n+1)
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 size(self, x):
return -self.par[self.find(x)]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.size(x) < self.size(y):
x, y = y, x
self.par[x] += self.par[y]
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
return
def same_check(self, x, y):
return self.find(x) == self.find(y)
u = UnionFind(n)
for i in range(len(pair) - 1):
if u.find(pair[i][0]) != u.find(pair[i][1]):
ans.append(max(0, int(ans[i] - u.size(pair[i][0]) * u.size(pair[i][1]))))
else:
ans.append(ans[i])
u.union(pair[i][0], pair[i][1])
ans = ans[::-1]
for i in range(len(ans)):
print((ans[i])) | p03108 |
def top(L, node):
current = node
while L[current] != current:
current = L[current]
return current
def main():
n, m = list(map(int, input().rstrip("\n").split(" ")))
L = [0]
counts = {}
for i in range(1, n + 1):
L.append(i)
counts[i] = 1
edges = []
for j in range(m):
a_b = list(map(int, input().rstrip("\n").split(" ")))
edges.append(a_b)
total = n * (n - 1) // 2
answers = [total]
for a, b in reversed(edges):
a_top = top(L, a)
b_top = top(L, b)
if a_top == b_top:
answers.append(total)
else:
total -= counts[a_top] * counts[b_top]
answers.append(total)
L[b_top] = a_top
counts[a_top] += counts[b_top]
for answer in reversed(answers[:-1]):
print(answer)
if __name__ == '__main__':
main() | def main():
n, m = list(map(int, input().rstrip("\n").split(" ")))
L = [0]
counts = {}
for i in range(1, n + 1):
L.append(i)
counts[i] = 1
edges = []
for j in range(m):
a_b = list(map(int, input().rstrip("\n").split(" ")))
edges.append(a_b)
total = n * (n - 1) // 2
answers = [total]
for a, b in reversed(edges):
current = a
while L[current] != current:
current = L[current]
a_top = current
current = b
while L[current] != current:
current = L[current]
b_top = current
if a_top == b_top:
answers.append(total)
else:
total -= counts[a_top] * counts[b_top]
answers.append(total)
L[b_top] = a_top
L[b] = a_top
L[a] = a_top
counts[a_top] += counts[b_top]
for answer in reversed(answers[:-1]):
print(answer)
if __name__ == '__main__':
main()
| p03108 |
class DisjointSet:
def __init__(self,n):
self.rank = [0]*n
self.parent = [i for i in range(n)]
self.siz = [1]*n
def same(self,x,y):
return self.findSet(x) == self.findSet(y)
def unite(self,x,y):
return self.link(self.findSet(x), self.findSet(y))
def link(self,x,y):
if self.rank[x] > self.rank[y]:
self.parent[y] = x
self.siz[x] += self.siz[y]
else:
self.parent[x] = y
self.siz[y] += self.siz[x]
if self.rank[x] == self.rank[y]: self.rank[y] += 1
def findSet(self,x):
if x != self.parent[x]:
self.parent[x] = self.findSet(self.parent[x])
return self.parent[x]
def size(self,x):
return self.siz[self.findSet(x)]
n,m = list(map(int,input().split()))
brg = [[int(i)-1 for i in input().split()] for _ in range(m)]
cnt = n*(n-1)//2
ans = [0]*m
ds = DisjointSet(n)
for i in range(m)[::-1]:
ans[i] = cnt
a,b = brg[i]
if not ds.same(a,b):
cnt -= ds.size(a)*ds.size(b)
ds.unite(a,b)
print(("\n".join(map(str,ans)))) | class DisjointSet:
def __init__(self,n):
self.parent = [i for i in range(n)]
self.siz = [1]*n
def root(self,x):
if x != self.parent[x]:
self.parent[x] = self.root(self.parent[x])
return self.parent[x]
def same(self,x,y):
return self.root(x) == self.root(y)
def unite(self,x,y):
x = self.root(x)
y = self.root(y)
if x == y:
return
if self.siz[x] < self.siz[y]:
x,y = y,x
self.parent[y] = x
self.siz[x] += self.siz[y]
def size(self,x):
return self.siz[self.root(x)]
n,m = list(map(int,input().split()))
brg = [[int(i)-1 for i in input().split()] for _ in range(m)]
cnt = n*(n-1)//2
ans = [0]*m
ds = DisjointSet(n)
for i in range(m)[::-1]:
ans[i] = cnt
a,b = brg[i]
if not ds.same(a,b):
cnt -= ds.size(a)*ds.size(b)
ds.unite(a,b)
print(("\n".join(map(str,ans)))) | 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()))
abl = []
for _ in range(m):
a,b = list(map(int,input().split()))
abl.append((a,b))
uf = UnionFind(n)
ansl = [0]
for a,b in abl[::-1]:
point = 0
uf.union(a-1, b-1)
for i in list(uf.all_group_members().values()):
point += len(i) * (len(i) - 1) // 2
ansl.append(point)
for i in range(m):
print((ansl[-1] - ansl[m-i-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 [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()))
abl = []
for _ in range(m):
a,b = list(map(int,input().split()))
abl.append((a,b))
uf = UnionFind(n)
ansl = [0]
point = 0
for a,b in abl[::-1]:
if uf.same(a-1, b-1) == False:
before_size1 = uf.size(a-1)
before_size2 = uf.size(b-1)
uf.union(a-1, b-1)
new_size = uf.size(a-1)
point += (new_size * (new_size - 1) // 2) - (before_size1 * (before_size1 - 1) // 2) - (before_size2 * (before_size2 - 1) // 2)
ansl.append(point)
for i in range(m):
print((ansl[-1] - ansl[m-i-1]))
| p03108 |
n,m = [int(i) for i in input().split()]
ab = []
for i in range(m):
ab.append([int(i)-1 for i in input().split()])
def find_index(c,eld):
if c in eld[c]:
return(c,len(eld[c]))
else:
return(eld[c][0],len(eld[eld[c][0]]))
eld = []
for i in range(n):
eld.append([i])
stat = eld
ans = [int(len(eld)*(len(eld)-1)/2)]
for a,b in ab[1:][::-1]:
# print(eld)
a_index,a_size = find_index(a,eld)
b_index,b_size = find_index(b,eld)
# print(a_index,b_index)
if a_index == b_index:
ans.append(ans[-1])
continue
else:
next = a_size * b_size
ans.append(ans[-1] - next)
if a_size >= b_size:
eld[a_index].extend(eld[b_index])
for i in eld[a_index][1:]:
eld[i] = [a_index]
else:
eld[b_index].extend(eld[a_index])
for i in eld[b_index][1:]:
eld[i] = [b_index]
for i in ans[::-1]:
print(i) | n,m = [int(i) for i in input().split()]
ab = []
for i in range(m):
ab.append([int(i)-1 for i in input().split()])
def find_index(c,eld):
if c in eld[c]:
return(c,len(eld[c]))
else:
return(eld[c][0],len(eld[eld[c][0]]))
eld = []
for i in range(n):
eld.append([i])
stat = eld
ans = [int(len(eld)*(len(eld)-1)/2)]
for a,b in ab[1:][::-1]:
# print(eld)
a_index,a_size = find_index(a,eld)
b_index,b_size = find_index(b,eld)
# print(a_index,b_index)
if a_index == b_index:
ans.append(ans[-1])
continue
else:
next = a_size * b_size
ans.append(ans[-1] - next)
if a_size >= b_size:
eld[a_index].extend(eld[b_index])
for i in eld[b_index]:
eld[i] = [a_index]
else:
eld[b_index].extend(eld[a_index])
for i in eld[a_index]:
eld[i] = [b_index]
for i in ans[::-1]:
print(i) | p03108 |
import collections
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
class UnitDict(dict):
def __init__(self, iterable=None, wrapper=lambda x: x):
super().__init__(self)
self.wrapper = wrapper
if iterable is not None:
self.update(iterable)
def __missing__(self, key):
self[key] = self.wrapper(key)
return self[key]
class UnionFind(object):
def __init__(self, nodes=None):
self.par = UnitDict(wrapper=lambda x: x)
self.rank = collections.defaultdict(int)
self.groups = UnitDict(wrapper=lambda x: {x})
if nodes is not None:
for node in nodes:
_, _, _ = self.par[node], self.rank[node], self.groups[node]
def root(self, node):
if self.par[node] == node:
return node
else:
r = self.root(self.par[node])
self.par[node] = r
return r
def are_same(self, node1, node2):
return self.root(node1) == self.root(node2)
def elements(self, node):
return self.groups[self.root(node)]
def size(self, node):
return len(self.elements(node))
def unite(self, node1, node2):
x = self.root(node1)
y = self.root(node2)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
self.par[y] = x
self.groups[x].update(self.groups[y])
self.groups[y].clear()
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def grouper(self):
roots = [x for x in list(self.par.keys())]
groups = []
for root in roots:
if list(self.elements(root)) not in groups:
groups.append(list(self.elements(root)))
return groups
islands = UnionFind(list(range(1, N)))
ans_list = []
last = int(N * (N-1) / 2)
ans_list.append(last)
for i in range(1, M):
if islands.are_same(AB[-i][0], AB[-i][1]):
ans_list.append(ans_list[-1])
else:
ans_list.append(ans_list[-1]-islands.size(AB[-i][0])*islands.size(AB[-i][1]))
islands.unite(AB[-i][0], AB[-i][1])
for i in range(1, len(ans_list)+1):
print((ans_list[-i])) | N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
class UnionFind():
def __init__(self, N):
self.rank = [0] * N
self.par = [i for i in range(N)]
self.counter = [1] * N
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
z = self.counter[x] + self.counter[y]
self.counter[x], self.counter[y] = z, z
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def size(self, x):
x = self.find(x)
return self.counter[x]
def same(self, x, y):
return self.find(x) == self.find(y)
ans_list = []
graph = UnionFind(N)
last = N * (N-1) // 2
ans_list.append(last)
for i in range(M-1, -1, -1):
a, b = AB[i]
if graph.same(a-1, b-1):
ans_list.append(ans_list[-1])
else:
ans_list.append(ans_list[-1] - graph.size(a-1) * graph.size(b-1))
graph.unite(a-1, b-1)
for i in range(M-1, -1, -1):
print((ans_list[i])) | p03108 |
import sys
import collections
n, m = list(map(int, sys.stdin.readline().split()))
p = list(range(n))
r = [1] * n
def li_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def find(x):
global p
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(x, y):
x, y = find(x), find(y)
if y > x:
x, y = y, x
p[y] = x
r[x] += r[y]
r[y] = r[x]
flist = [0] * m
elist = [0] * m
for i in range(m):
flist[i], elist[i] = li_()
flist.reverse()
elist.reverse()
ans = [0] * m
ans[0] = int(n*(n-1)/2)
for i in range(m-1):
a, b = flist[i], elist[i]
if find(a) != find(b):
ans[i + 1] = ans[i] - r[find(a)]*r[find(b)]
union(a, b)
else:
ans[i+1] = ans[i]
if ans[i+1] == 0:
break
for i in range(m):
print((ans[m-i-1]))
|
import sys
import collections
n, m = list(map(int, sys.stdin.readline().split()))
p = list(range(n))
r = [1] * n
def li_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def find(x):
global p
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(x, y):
x, y = find(x), find(y)
if y > x:
x, y = y, x
p[y] = x
r[x] += r[y]
r[y] = r[x]
flist = [0] * m
elist = [0] * m
for i in range(m):
flist[i], elist[i] = li_()
flist.reverse()
elist.reverse()
ans = [0] * m
ans[-1] = int(n*(n-1)/2)
for i in range(m-1):
a, b = flist[i], elist[i]
if find(a) != find(b):
ans[-i-2] = ans[-i-1] - r[find(a)]*r[find(b)]
union(a, b)
else:
ans[-i-2] = ans[-i-1]
if ans[-i-2] == 0:
break
for i in range(m):
print((ans[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 = map(int, input().split())
AB = []
for _ in range(M):
A, B = map(int, input().split())
AB.append((A-1, B-1))
uf = UnionFind(N)
unhappy = [N*(N-1)//2]
for A, B in reversed(AB):
uf.union(A, B)
happy = 0
for i in uf.roots():
temp = uf.size(i)
happy += temp*(temp-1)//2
unhappy.append(N*(N-1)//2 - happy)
print(*reversed(unhappy[:-1]), sep="\n")
| 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 = map(int, input().split())
AB = []
for _ in range(M):
A, B = map(int, input().split())
AB.append((A-1, B-1))
uf = UnionFind(N)
unhappy = [N*(N-1)//2]
def conb(x):
return x*(x-1)//2
for A, B in reversed(AB):
old_ap, old_bp = uf.find(A), uf.find(B)
if old_ap == old_bp:
uf.union(A, B)
unhappy.append(unhappy[-1])
else:
old_happy = conb(uf.size(old_ap)) + conb(uf.size(old_bp))
uf.union(A, B)
new_happy = conb(uf.size(A))
happy = new_happy - old_happy
unhappy.append(unhappy[-1] - happy)
print(*reversed(unhappy[:-1]), sep="\n")
| p03108 |
class UnionFind():
def __init__(self, n):
self.n=n
self.p=[-1]*n
def find(self,x):
if self.p[x]<0:
return x
else:
self.p[x]=self.find(self.p[x])
return self.p[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def unite(self,x,y):
x = self.find(x)
y = self.find(y)
if x==y:
return
if self.p[x]>self.p[y]:
x,y=y,x
self.p[x] += self.p[y]
self.p[y] = x
def members(self,x):
p = self.find(x)
return [i for i in range(self.n) if self.find(i)==p]
def roots(self):
return [i for i,x in enumerate(self.p) if x<0]
def gcount(self):
return len(self.roots())
def uprint(self):
print((self.p))
return
n,m=list(map(int,input().split()))
b=[[int(x) for x in input().split()] for y in range(m)]
u=n*(n-1)//2
s=[]
a=[u]
uf=UnionFind(n)
for i in range(m-1,0,-1):
uf.unite(b[i][0]-1,b[i][1]-1)
t = 0
for j in uf.roots():
n = len(uf.members(j))
t += (n * (n-1)) // 2
a.append(u-t)
a.reverse()
for i in range(len(a)):
print((a[i]))
| n, m = list(map(int, input().split()))
e = [[int(x) for x in input().split()] for _ in range(m)]
u = [-1]*(n+1)
def find(x):
return x if u[x] < 0 else find(u[x])
t = n*(n-1)// 2
s = [t]
for i in range(m-1,0,-1):
a = find(e[i][0])
b = find(e[i][1])
if a > b:
a, b = b, a
if a != b:
t -= u[a]*u[b]
u[a] += u[b]
u[b] = a
s.append(t)
for i in reversed(s):
print(i)
| p03108 |
n,m = list(map(int,input().split()))
isl1,isl2 = [0]*m,[0]*m
for i in range(m):
(isl1[i], isl2[i]) = list(map(int,input().split()))
isl1[i] -= 1
isl2[i] -= 1
boss = [-1]*n
member_number = [1]*n
dpt = [0]*n
ans = [0]*m
s = (n*(n-1))//2
ans[m-1] = s
def search_member(island, boss):
m = 0
while boss[island] >= 0:
island = boss[island]
m += 1
return island,m
for j in range(m-1):
i = m-j-1
island1,island2 = isl1[i],isl2[i]
parent1,m1 = search_member(island1, boss)
parent2,m2 = search_member(island2, boss)
if parent1 != parent2:
if dpt[m1] < dpt[m2]:
(parent1,parent2) = (parent2,parent1)
boss[parent2] = parent1
s -= member_number[parent1]*member_number[parent2]
member_number[parent1] += member_number[parent2]
member_number[parent2] = 0
dpt[parent1] = max(dpt[parent1],dpt[parent2]+1)
ans[i-1] = s
for i in range(m):
print((ans[i])) | #https://atcoder.jp/contests/abc120/submissions/4458925
(N,M) = list(map(int,input().split()))
A = [0]*M
B = [0]*M
for i in range(M):
(A[i], B[i]) = list(map(int,input().split()))
A[i] -= 1
B[i] -= 1
parent = [-1]*N
depth = [0] * N
def boss(n):
d = 0
while parent[n] >= 0:
n = parent[n]
d += 1
return n,d
P = [1]*N
S = (N*(N-1))//2
ans = [0] * M
ans[M-1] = S
for i in range(M-1):
j = M-1-i
bA, dA = boss(A[j])
bB, dB = boss(B[j])
if bA != bB:
if depth[bA] < depth[bB]:
(bA, bB) = (bB, bA)
parent[bB] = bA
S -= P[bA]*P[bB]
P[bA] = P[bA] + P[bB]
P[bB] = 0
depth[bA] = max(depth[bA],depth[bB]+1)
ans[j-1] = S
for i in range(M):
print((ans[i])) | p03108 |
import sys,queue,math
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in input().split()]
_LI = lambda : [int(x)-1 for x in input().split()]
N,M = LI()
B = [_LI() for _ in range(M)]
g = [i for i in range(N)]
c = [1 for _ in range(N)]
def root(x):
if x != g[x]: g[x] = root(g[x])
return g[x]
def union(x,y):
rx = root(x)
ry = root(y)
if rx != ry:
g[ry] = rx
c[rx] += c[ry]
c[ry] = 0
ans = []
B.reverse()
for a,b in B:
ra = root(a)
rb = root(b)
if ra == rb:
ans.append(0)
else:
ans.append(c[ra]*c[rb])
union(ra,rb)
ans.reverse()
x = 0
for a in ans:
x += a
print (x) | import sys,queue,math
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in input().split()]
_LI = lambda : [int(x)-1 for x in input().split()]
N,M = LI()
B = [_LI() for _ in range(M)]
g = [i for i in range(N)]
c = [1 for _ in range(N)]
def root(x):
if x != g[x]: g[x] = root(g[x])
return g[x]
def union(x,y):
rx = root(x)
ry = root(y)
if rx != ry:
if c[ry] > c[rx]: ry,rx = rx,ry
g[ry] = rx
c[rx] += c[ry]
c[ry] = 0
ans = []
B.reverse()
for a,b in B:
ra = root(a)
rb = root(b)
if ra == rb:
ans.append(0)
else:
ans.append(c[ra]*c[rb])
union(ra,rb)
ans.reverse()
x = 0
for a in ans:
x += a
print (x) | p03108 |
#!/usr/bin/env python3
from pprint import pprint
import sys
sys.setrecursionlimit(10 ** 6)
# 辺を取り除くのではなく、辺が無い状態から始めて辺を順にグラフに追加していくことを考える
# 最初は辺が無いので不便さは N * (N-1) / 2
# 辺 u <-> v を追加したとき、頂点 u, v が既に到達可能であるなら、不便さは変わらない
# そうでなければ、不便さは直前の値より size[u] * size[v] だけ小さくなる
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
u, v = list(map(int, input().split()))
# 0-index
edges.append([u-1, v-1])
def root(v):
if parents[v] < 0:
return v
parents[v] = root(parents[v])
return parents[v]
def has_same_root(u, v):
return root(u) == root(v)
# unite by size
def unite(u, v):
u_root = root(u)
v_root = root(v)
if size(u_root) > size(v_root):
u_root, v_root = v_root, u_root
parents[u_root] -= size(v_root)
parents[v_root] = u_root
def size(v):
return -parents[root(v)]
# the parent node of a root node has the size of tree (negative value)
parents = [-1 for v in range(N)]
ans = []
current = N * (N-1) // 2
for i in range(M):
u, v = edges[M-1-i]
# print(f'current = {current}')
# print(f'u = {u}, v = {v}')
# print(f'parents = {parents}')
ans.append(current)
if has_same_root(u, v):
# print('skip')
continue
# print(f'size(u) = {size(u)}, size(v) = {size(v)}')
current -= size(u) * size(v)
unite(u, v)
# print(f'parents = {parents}\n')
for i in reversed(list(range(M))):
print((ans[i]))
| #!/usr/bin/env python3
from pprint import pprint
import sys
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
u, v = list(map(int, input().split()))
edges.append([u-1, v-1])
# どの島も繋がっていないとき、不便さは最大値 N * (N-1) / 2 を取る
# 1 本ずつ減らすのではなく、最悪のケースから順に辺を追加していくことを考える
# ある辺 u <-> v を追加したときに、島の集合 a と島の集合 b が連結になったとすると、
# 不便さは size(a) * size(b) だけ減る
# disjoint set として島を管理し、最悪のケースから各辺を追加したときの不便さを計算すればよい
def has_same_root(u, v):
return root(u) == root(v)
def root(u):
if parents[u] < 0:
return u
parents[u] = root(parents[u])
return parents[u]
def unite(u, v):
# print(f'unite {u}, {v}')
u_root = root(u)
v_root = root(v)
# pprint(parents)
# print(f'u_root = {u_root}, v_root = {v_root}')
# print(f'size(u_root) = {size(u_root)}, size(v_root) = {size(v_root)}')
if size(u_root) > size(v_root):
u_root, v_root = v_root, u_root
parents[u_root] -= size(v_root)
parents[v_root] = u_root
# pprint(parents)
def size(u):
return -parents[root(u)]
parents = [-1 for _ in range(N)]
inconvenience = N * (N-1) // 2
ans = [inconvenience]
for u, v in reversed(edges):
# print(f'\nu = {u}, v = {v}')
if not has_same_root(u, v):
inconvenience -= size(u) * size(v)
unite(u, v)
ans.append(inconvenience)
for i in reversed(list(range(M))):
print((ans[i]))
| p03108 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.