input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
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) # この変数xに格納されているものは必ず根のノード
y = self.find(y) # この変数yに格納されているものは必ず根のノード
if x == y:
return # もし同じ親ならば何も起こらない
if self.parents[x] > self.parents[y]: # それぞれ、要素の個数が負で格納されている
# yのグループの方が要素が多いの場合（yの方が値が小さいということは、負の世界では値が大きいため）
x, y = y, x # 必ずxの方が要素が多い状態にする
self.parents[x] += self.parents[y] # 負の値だが、これでいい
self.parents[y] = x # yは親ではなくなったため、新しい親であるxの値を正でもつ
def size(self, x):
return -self.parents[self.find(x)] # 親まで辿ればグループの大きさが負で格納されているため、それにマイナスをつけてreturnする
def same(self, x, y):
return self.find(x) == self.find(y) # 親が同じならTrueが返却される
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 in range(self.n) if self.find(i) < 0]
def group_counts(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()))
graph = [[] for _ in range(N)] # 隣接行列
brige_info = []
for _ in range(M):
a, b = [int(x)-1 for x in list(map(int, input().split()))]
brige_info.append((a, b))
# graph[a].append(b)
# graph[b].append(a)
ans = [int(N*(N-1))//2]*M
uf = UnionFind(N)
for i in reversed(list(range(1, M))):
if uf.same(brige_info[i][0], brige_info[i][1]):
ans[i-1] = ans[i] # その橋を繋いでも不便さは改善されなかった、何も変わらない
continue
ans[i-1] = ans[i] - uf.size(brige_info[i][0]) * uf.size(brige_info[i][1])
uf.union(brige_info[i][0], brige_info[i][1])
for i in range(M):
print((ans[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 size(self, x):
return -self.parents[self.find(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 # 処理を行う上で、必ずxのグループの要素数の方が多くあってほしい
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
N, M = list(map(int, input().split()))
brige = []
for _ in range(M):
a, b = [int(x)-1 for x in input().split()]
brige.append((a, b))
uf = UnionFind(N)
ans = [int(N*(N-1)//2)]*M
for i in reversed(list(range(1, M))):
if uf.same(brige[i][0], brige[i][1]):
ans[i-1] = ans[i]
else:
ans[i-1] = ans[i] - uf.size(brige[i][0]) * uf.size(brige[i][1])
uf.union(brige[i][0], brige[i][1])
for i in range(M):
print((ans[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, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1) # 木の高さ
self.n = [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 find_n(self, x):
return self.n[self.find(x)]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.n[y] = self.n[x] + self.n[y]
else:
self.par[y] = x
self.n[x] = self.n[x] + self.n[y]
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 main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab):
px = uf.find(x)
py = uf.find(y)
if px != py:
p -= uf.find_n(px) * uf.find_n(py)
uf.unite(px, py)
ans.append(p)
for a in reversed(ans[:-1]):
print(a)
main()
| 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, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1) # 木の高さ
self.n = [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 find_n(self, x):
return self.n[self.find(x)]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.n[y] = self.n[x] + self.n[y]
else:
self.par[y] = x
self.n[x] = self.n[x] + self.n[y]
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 main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab):
px = uf.find(x)
py = uf.find(y)
if px != py:
#p -= uf.find_n(px) * uf.find_n(py)
p -= uf.n[px] * uf.n[py]
uf.unite(px, py)
ans.append(p)
for a in reversed(ans[:-1]):
print(a)
main()
| p03108 |
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
tb = []
while True:
if self.parents[x] < 0:
for i in tb:
self.parents[i] = x
return x
else:
tb.append(x)
x = 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
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab.reverse()
ans = []
nC2 = n * (n - 1) // 2
uf = UnionFind(n)
for a, b in ab:
c = nC2
for v in uf.parents:
if v < -1:
c -= v * (v + 1) // 2
ans.append(c)
uf.union(a-1, b-1)
ans.reverse()
for ai in ans:
print(ai)
| def xC2(x):
if x == 1:
return 0
else:
return x * (x-1) // 2
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
if self.parents[x] > self.parents[y]:
x, y = y, x
nx, ny = - self.parents[x], - self.parents[y]
self.parents[x] += self.parents[y]
self.parents[y] = x
return xC2(nx + ny) - xC2(nx) - xC2(ny)
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab.reverse()
ans = [xC2(n)]
uf = UnionFind(n)
for a, b in ab:
ans.append(ans[-1] - uf.union(a-1, b-1))
ans.reverse()
for ai in ans[1:]:
print(ai)
| p03108 |
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input():
return sys.stdin.readline().rstrip()
def main():
class UnionFind():
def __init__(self,n):
self.par=[i for i in range(n)]
self.siz=[1]*n
def root(self,x):
while self.par[x]!=x:
x=self.par[x]
return x
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x==y:
return False
if self.siz[x]<self.siz[y]:
x,y=y,x
self.siz[x]+=self.siz[y]
self.par[y]=x
return True
def is_same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return self.siz[self.root(x)]
N,M=list(map(int,input().split()))
Q=[]
for _ in range(M):
Q.append(tuple([int(x)-1 for x in input().split()]))
uf=UnionFind(N)
l_ans=[]
ans=N*(N-1)//2
for _ in range(M):
l_ans.append(ans)
a,b=Q.pop()
siz_a,siz_b=uf.size(a),uf.size(b)
if uf.unite(a,b):
ans-=siz_a*siz_b
for _ in range(M):
print((l_ans.pop()))
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input():
return sys.stdin.readline().rstrip()
def main():
class UnionFind():
def __init__(self,n):
self.par=[i for i in range(n)]
self.siz=[1]*n
def root(self,x):
while self.par[x]!=x:
self.par[x]=self.par[self.par[x]]
x=self.par[x]
return x
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x==y:
return False
if self.siz[x]<self.siz[y]:
x,y=y,x
self.siz[x]+=self.siz[y]
self.par[y]=x
return True
def is_same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return self.siz[self.root(x)]
N,M=list(map(int,input().split()))
Q=[]
for _ in range(M):
Q.append(tuple([int(x)-1 for x in input().split()]))
uf=UnionFind(N)
l_ans=[]
ans=N*(N-1)//2
for _ in range(M):
l_ans.append(ans)
a,b=Q.pop()
siz_a,siz_b=uf.size(a),uf.size(b)
if uf.unite(a,b):
ans-=siz_a*siz_b
for _ in range(M):
print((l_ans.pop()))
if __name__ == '__main__':
main()
| p03108 |
N, M = list(map(int, input().split()))
lis = [[x, -1] for x in range(1, N + 1)]
Blis = [list(map(int, input().split())) for _ in range(M)]
inc = int(N*(N - 1)/2)
ans = [x for x in range(M)]
ans[M - 1] = inc
def root(a):
if lis[a - 1][1] < 0:
return lis[a - 1][0]
else:
k = root(lis[a - 1][1])
lis[a - 1][1] = k
return k
def size(a):
return -lis[root(a) - 1][1]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
lis[A - 1][1] += lis[B - 1][1]
lis[B - 1][1] = A
for i in reversed(list(range(0, M))):
if root(Blis[i][0]) != root(Blis[i][1]):
ans[i - 1] = ans[i] - size(Blis[i][0])*size(Blis[i][1])
else:
ans[i - 1] = ans[i]
connect(Blis[i][0], Blis[i][1])
ans[M - 1] = inc
for i in range(M):
print((ans[i])) | N, M = list(map(int, input().split()))
lis = [[x, -1] for x in range(1, N + 1)]
Blis = [list(map(int, input().split())) for _ in range(M)]
inc = int(N*(N - 1)/2)
ans = [x for x in range(M)]
ans[M - 1] = inc
def root(a):
if lis[a - 1][1] < 0:
return lis[a - 1][0]
else:
k = root(lis[a - 1][1])
lis[a - 1][1] = k
return k
def size(a):
return -lis[root(a) - 1][1]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
lis[A - 1][1] += lis[B - 1][1]
lis[B - 1][1] = A
for i in reversed(list(range(1, M))):
if root(Blis[i][0]) != root(Blis[i][1]):
ans[i - 1] = ans[i] - size(Blis[i][0])*size(Blis[i][1])
connect(Blis[i][0], Blis[i][1])
else:
ans[i - 1] = ans[i]
for i in range(M):
print((ans[i])) | p03108 |
N, M = list(map(int, input().split()))
lis = [[x, -1] for x in range(1, N + 1)]
Blis = [list(map(int, input().split())) for _ in range(M)]
inc = int(N*(N - 1)/2)
ans = [x for x in range(M)]
ans[M - 1] = inc
def root(a):
if lis[a - 1][1] < 0:
return lis[a - 1][0]
else:
k = root(lis[a - 1][1])
lis[a - 1][1] = k
return k
def size(a):
return -lis[root(a) - 1][1]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
lis[A - 1][1] += lis[B - 1][1]
lis[B - 1][1] = A
for i in reversed(list(range(1, M))):
if root(Blis[i][0]) != root(Blis[i][1]):
ans[i - 1] = ans[i] - size(Blis[i][0])*size(Blis[i][1])
connect(Blis[i][0], Blis[i][1])
else:
ans[i - 1] = ans[i]
for i in range(M):
print((ans[i])) | N, M = list(map(int, input().split()))
Parent = [-1 for x in range(N + 5)]
lis = [list(map(int, input().split())) for _ in range(M)]
ini = int(N*(N - 1)/2)
ans = [x for x in range(M)]
ans[M - 1] = ini
def root(a):
if Parent[a] < 0:
return a
else:
k = root(Parent[a])
Parent[a] = k
return k
def size(a):
return -Parent[root(a)]
def connect(a, b):
A = root(a)
B = root(b)
if A == B:
return None
else:
if size(A) < size(B):
A, B = B, A
Parent[A] += Parent[B]
Parent[B] = A
for i in reversed(list(range(1, M))):
ans[i - 1] = ans[i]
if root(lis[i][0]) != root(lis[i][1]):
ans[i - 1] -= size(lis[i][0])*size(lis[i][1])
connect(lis[i][0], lis[i][1])
for i in range(M):
print((ans[i])) | p03108 |
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
AB.reverse()
island = [[i+1] for i in range(N)]
ans = []
for m in range(M):
count = 0
for i in range(len(island)):
for j in range(i+1, len(island)):
count += len(island[i]) * len(island[j])
ans.append(count)
A, B = AB.pop(0)
idxs = [None, None] # A, B
for idx in range(len(island)):
if A in island[idx]:
idxs[0] = idx
if B in island[idx]:
idxs[1] = idx
if None not in idxs:
break
if idxs[0] != idxs[1]:
island[idxs[0]].extend(island[idxs[1]])
del island[idxs[1]]
ans.reverse()
[print(ans[i]) for i in range(M)]
| def find(idx):
global tree
while True:
if tree[idx].root == True:
return tree[idx].prev, tree[idx].size
else:
idx = tree[idx].prev
class Union_Find:
def __init__(self, prev):
self.root = True
self.size = 1
self.prev = prev
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
AB.reverse()
ans = [(N*(N-1))//2]
tree = {i:Union_Find(i) for i in range(1, N+1)}
for A, B in AB[:-1]:
root_A, size_A = find(A)
root_B, size_B = find(B)
if root_A == root_B:
ans.append(ans[-1])
else:
if size_A > size_B:
x, y = root_B, root_A
else:
x, y = root_A, root_B
tree[x].root = False
tree[x].prev = y
tree[y].size += tree[x].size
ans.append(ans[-1] - size_A * size_B)
[print(max(0, i)) for i in ans[::-1]]
| p03108 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
self.count = [1] * (n + 1)
# find
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# union
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.count[y] += self.count[x]
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.count[x] += self.count[y]
# size
def size(self, x):
return self.count[self.par[x]]
# same
def issame(self, x, y):
return self.find(x) == self.find(y)
n,m=list(map(int,input().split()))
a=[tuple(map(int,input().split())) for i in range(m)]
b = [(j,i)for j in range(1,n+1) for i in range(j+1,n+1)]
U=UnionFind(n)
dis=[0]
cn=0
for i,j in reversed(a):
if U.issame(i,j)==True:
dis.append(cn)
else:
cn+=U.size(i)*U.size(j)
dis.append(cn)
U.union(i, j)
M=int(n*(n-1)/2)
for x in reversed(dis[:-1]):
print((M-x)) | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
self.count = [1] * (n + 1)
# find
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# union
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.count[y] += self.count[x]
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.count[x] += self.count[y]
# size
def size(self, x):
return self.count[self.par[x]]
# same
def issame(self, x, y):
return self.find(x) == self.find(y)
n,m=list(map(int,input().split()))
a=[tuple(map(int,input().split())) for i in range(m)]
U=UnionFind(n)
dis=[0]
cn=0
for i,j in reversed(a):
if U.issame(i,j)==True:
dis.append(cn)
else:
cn+=U.size(i)*U.size(j)
dis.append(cn)
U.union(i, j)
M=int(n*(n-1)/2)
for x in reversed(dis[:-1]):
print((M-x))
| p03108 |
class UnionFind:
def __init__(self,n):
*self.table,=range(n)
self.rank=[1]*n
def root(self,x):
if self.table[x]==x:
return x
else:
self.table[x]=self.root(self.table[x])
return self.table[x]
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x!=y:
if self.rank[x]<self.rank[y]:
x,y=y,x
self.rank[x]+=self.rank[y]
self.table[y]=x
def same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return self.rank[self.root(x)]
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=UnionFind(n)
a=[n*~-n//2]
for x,y in e[::-1]:
x,y=x-1,y-1
t=a[-1]
if not u.same(x,y):
t-=u.size(x)*u.size(y)
a.append(t)
u.unite(x,y)
print(*a[::-1],sep='\n')
| def root(x):
if table[x]==x:
return x
else:
table[x]=root(table[x])
return table[x]
def unite(x,y):
x=root(x)
y=root(y)
if x!=y:
if rank[x]<rank[y]:
x,y=y,x
rank[x]+=rank[y]
table[y]=x
def same(x,y):
return root(x)==root(y)
def size(x):
return rank[root(x)]
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
*table,=range(n)
rank=[1]*n
a=[n*~-n//2]
for x,y in e[::-1]:
x,y=x-1,y-1
t=a[-1]
if not same(x,y):
t-=size(x)*size(y)
a.append(t)
unite(x,y)
print(*a[::-1],sep='\n')
| p03108 |
def r(x):
while u[x]>=0:x=u[x]
return x
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=[-1]*n
a=[n*~-n//2]
for x,y in e[::-1]:
t=a[-1]
x,y=r(x-1),r(y-1)
if x!=y:
t-=u[x]*u[y]
u[x]+=u[y]
u[y]=x
a.append(t)
print(*a[::-1],sep='\n')
| def r(x):
while u[x]>=0:x=u[x]
return x
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=[-1]*n
a=[n*~-n//2]
for x,y in e[::-1]:
t=a[-1]
x,y=sorted((r(x-1),r(y-1)))
if x!=y:
t-=u[x]*u[y]
u[x]+=u[y]
u[y]=x
a.append(t)
print(*a[::-1],sep='\n')
| p03108 |
def r(x):
while u[x]>=0:x=u[x]
return x
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=[-1]*n
a=[n*~-n//2]
for x,y in e[::-1]:
t=a[-1]
x,y=sorted((r(x-1),r(y-1)))
if x!=y:
t-=u[x]*u[y]
u[x]+=u[y]
u[y]=x
a.append(t)
print(*a[::-1],sep='\n')
| def r(x):
while u[x]>=0:x=u[x]
return x
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()];u=[-1]*-~n;a=[n*~-n//2]
for x,y in e[::-1]:
t=a[-1];x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a.append(t)
print(*a[::-1],sep='\n')
| p03108 |
r=lambda x:x if u[x]<0else r(u[x])
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=[-1]*-~n
a=[n*~-n//2]
for x,y in e[::-1]:
t=a[-1];x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=[t]
print(*a[::-1],sep='\n')
| r=lambda x:x if u[x]<0else r(u[x])
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=[-1]*-~n
t=n*~-n//2
a=[t]
for x,y in e[::-1]:
x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=[t]
print(*a[::-1],sep='\n')
| p03108 |
r=lambda x:x if u[x]<0else r(u[x])
(n,m),_,*e=[map(int,t.split())for t in open(0).readlines()]
u=[-1]*-~n
t=n*~-n//2
a=[t]
for x,y in e[::-1]:
x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=[t]
print(*a[::-1],sep='\n')
| r=lambda x:x if u[x]<0else r(u[x])
n,m,*e=map(int,open(0).read().split())
u=[-1]*-~n
t=n*~-n//2
a=[t]
for x,y in zip(e[-2:1:-2],e[:1:-2]):
x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=[t]
print(*a[::-1],sep='\n')
| p03108 |
r=lambda x:x if u[x]<0else r(u[x])
n,m,*e=map(int,open(0).read().split())
u=[-1]*-~n
t=n*~-n//2
a=t,
for x,y in zip(e[-2:1:-2],e[:1:-2]):
x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=t,
print(*a[::-1],sep='\n')
| r=lambda x:x if u[x]<0else r(u[x])
n,m,*e=map(int,open(0).read().split())
u=[-1]*-~n
t=n*~-n//2
a=[t]
for x,y in zip(e[-2:1:-2],e[:1:-2]):
x,y=sorted((r(x),r(y)))
if x!=y:t-=u[x]*u[y];u[x]+=u[y];u[y]=x
a+=t,
print(*a[::-1],sep='\n')
| p03108 |
N, M =list(map(int, input().split()))
a, b = [], []
for i in range(M):
a_i, b_i = list(map(int, input().split()))
a.append(a_i -1)
b.append(b_i -1)
class UnionFind:
def __init__(self, n):
self.p = {}
self.r = {}
self.s = {}
for i in range(n):
self.p[i] = i # 親,グループ番号
self.r[i] = 1
self.s[i] = 1 # サイズ、連結数
def find(self, n):
path = []
while n != self.p[n]:
path.append(n)
n = self.p[n]
for m in path:
self.p[m] = n
return n
def union(self, a, b):
ap = self.find(a)
bp = self.find(b)
if self.r[ap] > self.r[bp]:
self.p[bp] = ap
size = self.s[bp] + self.s[ap]
self.s[ap] = size
elif self.r[bp] > self.r[ap]:
self.p[ap] = bp
size = self.s[bp] + self.s[ap]
self.s[bp] = size
elif ap != bp:
self.p[ap] = bp
self.r[bp] += 1
size = self.s[bp] + self.s[ap]
self.s[bp] = size
def size(self, n):
np = self.find(n)
return self.s[np]
s = UnionFind(N)
ans = (N*(N-1)) // 2
anss = [ans]
for i in range(M):
j = M - i - 1
if s.find(a[j]) != s.find(b[j]):
ans -= s.size(a[j]) * s.size(b[j])
s.union(a[j], b[j])
if i != M-1:
anss.append(ans)
sort_ans = sorted(anss)
for i in range(len(sort_ans)):
print((sort_ans[i])) | class UnionFind:
def __init__(self, n):
self.p = [i for i in range(n)]
self.s = [1 for i in range(n)]
def find(self, x):
if x == self.p[x]:
return x
else:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, a, b):
ap = self.find(a)
bp = self.find(b)
if ap != bp:
mini = min(ap ,bp)
maxi = max(ap, bp)
self.p[maxi] = mini
size = self.s[bp] + self.s[ap]
self.s[bp] = size
self.s[ap] = size
return True
else:
return False
def size(self, n):
np = self.find(n)
return self.s[np]
N, M =list(map(int, input().split()))
a, b = [], []
for i in range(M):
a_i, b_i = list(map(int, input().split()))
a.append(a_i -1)
b.append(b_i - 1)
s = UnionFind(N)
ans = (N*(N-1)) // 2
anss = [ans]
for i in range(M):
j = M - i - 1
if s.find(a[j]) != s.find(b[j]):
ans -= s.size(a[j]) * s.size(b[j])
s.union(a[j], b[j])
if i != M-1:
anss.append(ans)
sort_ans = sorted(anss)
for i in range(len(sort_ans)):
print((sort_ans[i])) | p03108 |
# coding:utf-8
import sys
from collections import deque, defaultdict
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
# UnionFind
class UnionFind:
# 負: ルートで値は木のサイズを表す
# 正: 子で値は次のノードを表す
def __init__(self, size: int) -> None:
self.nodes = [-1] * size # 初期状態では全てのノードがルート
def find(self, x: int) -> int:
if self.nodes[x] < 0:
return x
else:
self.nodes[x] = self.find(self.nodes[x])
return self.nodes[x]
def unite(self, x: int, y: int) -> bool:
rx, ry = self.find(x), self.find(y)
if rx == ry:
return False
if self.size(x) < self.size(y):
rx, ry = ry, rx
self.nodes[rx] += self.nodes[ry]
self.nodes[ry] = rx
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return - self.nodes[self.find(x)]
def main():
n, m = LI()
uf = UnionFind(n)
res = deque()
res.append(n * (n - 1) // 2)
AB = [LI_() for _ in range(m)]
AB.reverse()
for a, b in AB:
if uf.same(a, b):
res.append(res[-1])
continue
tmp = res[-1] - uf.size(a) * uf.size(b)
if tmp < 0:
tmp = 0
res.append(tmp)
uf.unite(a, b)
res.reverse()
res.popleft()
print(*res, sep='\n')
main()
| # coding:utf-8
import sys
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
def main():
n, m = LI()
AB = [LI_() for _ in range(m)]
AB.reverse()
# マージテク
par = [i for i in range(n)] # 連結しているグループのリーダ
node = [set([i]) for i in range(n)] # グループに所属しているノードの集合
def merge(x, y):
# 既に連結済みなら何もしない
if par[x] == par[y]:
return 0
x, y = par[x], par[y]
size_x, size_y = len(node[x]), len(node[y])
# 小さいグループを大きいグループにマージする. O(log(n))
if size_x < size_y:
x, y = y, x
# ノードの移動とリーダの更新
while node[y]:
v = node[y].pop()
par[v] = x
node[x].add(v)
# (xの連結数)*(yの連結数)だけ不満度が解消される
return size_x * size_y
res = [n * (n - 1) // 2]
for a, b in AB:
sub = merge(a, b)
res.append(res[-1] - sub)
res.pop()
res.reverse()
print(*res, sep='\n')
main()
| p03108 |
N,M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(M)]
AB.reverse() # 逆から考える
ans_list = [-1 for i in range(M)]
ans_list[M-1] = N*(N-1)//2
par = [i for i in range(N+1)]
rank = [0 for i in range(N+1)]
cnt = [1 for i in range(N+1)]
# 木の根を求める
def root(x):
if par[x] == x: # 根の時
return x
else:
par[x] = root(par[x]) # 経路圧縮
return par[x]
# xとyの属する集合を併合(ランク有)
def unite(x,y):
x = root(x)
y = root(y)
if x == y:
return
if rank[x] < rank[y]:
par[x] = y
cnt[y] += cnt[x]
else:
par[y] = x
cnt[x] += cnt[y]
if rank[x] == rank[y]:
rank[x] += 1
for i in range(M-1):
a,b = AB[i][0],AB[i][1]
# 答えはans_list[M-2-i]を書き換える
if root(a) == root(b):
ans_list[M-2-i] = ans_list[M-1-i]
continue
else:
ans_list[M-2-i] = ans_list[M-1-i] - cnt[root(a)]*cnt[root(b)]
unite(a,b)
print(('\n'.join(map(str,ans_list))))
| # cnt->size
N,M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(M)]
AB.reverse() # 逆から考える
ans_list = [-1 for i in range(M)]
ans_list[M-1] = N*(N-1)//2
# parent(親)
par = [i for i in range(N+1)]
# rank(深さ)
rank = [0 for i in range(N+1)]
# 同グループの頂点数
size = [1 for i in range(N+1)]
# 木の根を求める
def root(x):
if par[x] == x: # 根の時
return x
else:
par[x] = root(par[x]) # 経路圧縮
return par[x]
# xとyの属する集合を併合(ランク有)
def unite(x,y):
x = root(x)
y = root(y)
if x == y:
return
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
for i in range(M-1):
a,b = AB[i][0],AB[i][1]
# 答えはans_list[M-2-i]を書き換える
if root(a) == root(b):
ans_list[M-2-i] = ans_list[M-1-i]
continue
else:
ans_list[M-2-i] = ans_list[M-1-i] - size[root(a)]*size[root(b)]
unite(a,b)
print(('\n'.join(map(str,ans_list))))
| p03108 |
import sys
class AlgUnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
sys.setrecursionlimit(2000)
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, m = list(map(int, input().rstrip('\n').split()))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(m)]
uf = AlgUnionFind(n)
t = n * (n - 1) // 2
ans = []
for i in range(m):
a, b = ab[-i-1]
ans.append(t)
if not uf.same(a-1, b-1):
t -= uf.size(a-1) * uf.size(b-1)
uf.union(a-1, b-1)
ans.reverse()
print(*ans, sep="\n")
if __name__ == '__main__':
solve()
| import sys
#https://note.nkmk.me/python-union-find/
class AlgUnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, m = list(map(int, input().rstrip('\n').split()))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(m)]
t = n * (n - 1) // 2
uf = AlgUnionFind(n)
pt = []
for i in range(m):
pt.append(t)
a, b = ab[-i-1]
if not uf.same(a-1, b-1):
t -= (uf.size(a-1) * uf.size(b-1))
uf.union(a-1, b-1)
pt.reverse()
print(*pt, sep="\n")
if __name__ == '__main__':
solve()
| p03108 |
import sys
#https://note.nkmk.me/python-union-find/
class AlgUnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, m = list(map(int, input().rstrip('\n').split()))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(m)]
t = n * (n - 1) // 2
uf = AlgUnionFind(n)
pt = []
for i in range(m):
pt.append(t)
a, b = ab[-i-1]
if not uf.same(a-1, b-1):
t -= (uf.size(a-1) * uf.size(b-1))
uf.union(a-1, b-1)
pt.reverse()
print(*pt, sep="\n")
if __name__ == '__main__':
solve()
| import sys
#https://note.nkmk.me/python-union-find/
class AlgUnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n, m = list(map(int, readline().split()))
ab = [list(map(int, readline().split())) for _ in range(m)]
for i in range(m):
ab[i][0] -= 1
ab[i][1] -= 1
ans = []
uf = AlgUnionFind(n)
cnt = 0
for i in range(m):
if i == 0:
ans.append(n * (n - 1) // 2)
else:
ans.append(n * (n - 1) // 2 - cnt)
a, b = ab[-i-1]
if not uf.same(a, b):
cnt += uf.size(a) * uf.size(b)
uf.union(a, b)
ans.reverse()
print(*ans, sep="\n")
if __name__ == '__main__':
solve()
| p03108 |
class UnionFind(object):
def __init__(self, n=1):
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):
"""
x が属するグループを探索
"""
# xが根だったら自分自身をreturnする
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 と 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):
"""
x と y が同じグループかどうか
"""
return self.find(x) == self.find(y)
def get_size(self, x):
"""
x が属するグループの要素数
"""
x = self.find(x)
return self.size[x]
def main():
N, M = list(map(int, input().split()))
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = list(map(int, input().split()))
uni = UnionFind(N)
ans = [None] * M
ans[M-1] = N * (N - 1) // 2
for i in range(M - 1, 0, -1):
x = A[i] - 1
y = B[i] - 1
# 辺でつなげても元々同じグループに属していた場合、変化はしない
if uni.is_same(x, y):
ans[i - 1] = ans[i]
else:
ans[i - 1] = ans[i] - (uni.get_size(x) * uni.get_size(y))
uni.union(x, y)
for a in ans:
print(a)
main() | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.parents[self.find(x)]
def main():
N, M = list(map(int, input().split()))
bridges = []
for _ in range(M):
A, B = list(map(int, input().split()))
A -= 1
B -= 1
bridges.append((A,B))
ans = [0] * M
ans[M-1] = N * (N - 1) // 2
uni = UnionFind(N)
for i in range(M-1,0,-1):
a, b = bridges[i]
if not uni.same(a, b):
ans[i-1] = ans[i] - (uni.size(a) * uni.size(b))
uni.union(a,b)
else:
ans[i-1] = ans[i]
for a in ans:
print(a)
if __name__ == "__main__":
main() | p03108 |
# -*- coding: utf-8 -*-
"""
D - Decayed Bridges
https://atcoder.jp/contests/abc120/tasks/abc120_d#
"""
import sys
class DisjointSet(object):
def __init__(self, n):
self.rank = []
self.p = []
self.size = []
for i in range(n+1):
self.makeSet(i)
def makeSet(self, x):
self.p.insert(x, x)
self.rank.insert(x, 0)
self.size.insert(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.size[self.p[x]] += self.size[self.p[y]]
self.p[y] = self.findSet(x)
else:
self.size[self.p[y]] += self.size[self.p[x]]
self.p[x] = self.findSet(y)
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def findSet(self, x):
if x != self.p[x]:
self.p[x] = self.findSet(self.p[x])
return self.p[x]
def solve(bridges, N, M):
ans = [(N**2 - N)//2]
d = DisjointSet(N)
for f, t in reversed(bridges):
if d.same(f, t):
ans.append(ans[-1])
else:
n1 = d.size[d.p[f]]
n2 = d.size[d.p[t]]
ans.append(ans[-1] - (n1*n2))
d.unite(f, t)
return ans
def main(args):
N, M = list(map(int, input().split()))
bridges = []
for _ in range(M):
f, t = list(map(int, input().split()))
bridges.append([f, t])
ans = solve(bridges, N, M)
for a in (ans[::-1])[1:]:
print(a)
if __name__ == '__main__':
main(sys.argv[1:])
| # -*- coding: utf-8 -*-
"""
D - Decayed Bridges
https://atcoder.jp/contests/abc120/tasks/abc120_d#
AC
"""
import sys
class DisjointSet(object):
def __init__(self, n):
self.rank = [0] * n
self.p = list(range(n))
self.size = [1] * n
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.size[self.p[x]] += self.size[self.p[y]]
self.p[y] = self.findSet(x)
else:
self.size[self.p[y]] += self.size[self.p[x]]
self.p[x] = self.findSet(y)
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def findSet(self, x):
if x != self.p[x]:
self.p[x] = self.findSet(self.p[x])
return self.p[x]
def solve(bridges, N, M):
ans = [(N**2 - N)//2]
d = DisjointSet(N+1)
for f, t in reversed(bridges):
if d.same(f, t):
ans.append(ans[-1])
else:
n1 = d.size[d.p[f]]
n2 = d.size[d.p[t]]
ans.append(ans[-1] - (n1*n2))
d.unite(f, t)
return ans
def main(args):
N, M = list(map(int, input().split()))
bridges = []
for _ in range(M):
f, t = list(map(int, input().split()))
bridges.append([f, t])
ans = solve(bridges, N, M)
for a in (ans[::-1])[1:]:
print(a)
if __name__ == '__main__':
main(sys.argv[1:])
| p03108 |
class UnionFind:
def __init__(self, n):
self.n = n
self.parent = [i for i in range(n)] # 親
self.rank = [1] * n # 木の高さ
self.size = [1] * n # size[i] は i を根とするグループのサイズ
def find(self, x): # 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, y の属する集合を併合する
x = self.find(x)
y = self.find(y)
if x != y:
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 is_same(self, x, y): # x, y が同じ集合に属するか判定する
return self.find(x) == self.find(y)
def group_size(self, x): # x が属する集合の大きさを返す
return self.size[self.find(x)]
def __str__(self): # print 表示用
return '\n'.join('{}: {}'.format(r, self.group_members(r)) for r in self.roots())
N, M = list(map(int, input().split()))
bridge = [list(map(int, input().split())) for _ in range(M)]
ans = [0]*M
uf = UnionFind(N)
# うしろからつないでいく
ans[M-1] = N*(N-1)//2
for i in range(1, M):
A, B = bridge[M-i]
if uf.is_same(A-1, B-1):
ans[M-i-1] = ans[M-i]
else:
ans[M-i-1] = ans[M-i] - uf.group_size(A-1) * uf.group_size(B-1)
uf.unite(A-1, B-1)
for a in ans:
print(a)
| class UnionFind:
def __init__(self, n):
self.n = n
self.parent = [i for i in range(n)] # 親
self.rank = [1] * n # 木の高さ
self.size = [1] * n # size[i] は i を根とするグループのサイズ
def find(self, x): # 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, y の属する集合を併合する
x = self.find(x)
y = self.find(y)
if x != y:
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 is_same(self, x, y): # x, y が同じ集合に属するか判定する
return self.find(x) == self.find(y)
def group_size(self, x): # x が属する集合の大きさを返す
return self.size[self.find(x)]
def __str__(self): # print 表示用
return '\n'.join('{}: {}'.format(r, self.group_members(r)) for r in self.roots())
N, M = list(map(int, input().split()))
bridge = [list(map(int, input().split())) for _ in range(M)]
ans = [0]*M
uf = UnionFind(N)
# うしろからつないでいく
ans[M-1] = N*(N-1)//2
for i in range(M-2, -1, -1):
A, B = bridge[i+1]
if uf.is_same(A-1, B-1):
ans[i] = ans[i+1]
else:
ans[i] = ans[i+1] - uf.group_size(A-1) * uf.group_size(B-1)
uf.unite(A-1, B-1)
for a in ans:
print(a)
| p03108 |
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
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にする
x, y = y, x
self.parents[x] += self.parents[y] #xの要素数はyの要素数ぶん増える
self.parents[y] = x #yをxの子にする
def size(self, x): #xの属するグループの要素数
return -self.parents[self.find(x)]
def same(self, x, y): #同じグループか判定
return self.find(x) == self.find(y)
def members(self, x): #xの属するグループの要素一覧
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self): #根の一覧
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self): #グループ個数
return len(self.roots())
def all_group_members(self): #根とその要素の辞書配列
return {r: self.members(r) for r in self.roots()}
def __str__(self): #print用
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
U=UnionFind(n)
A=[n*(n-1)//2]
V=[]
for i in range(m):
a,b=list(map(int,input().split()))
V.append([a-1,b-1])
V=list(reversed(V))
for i in range(m):
if i==m-1:
continue
U.union(V[i][0],V[i][1])
con=0 #便利さ
for r in U.roots():
s=U.size(r)
if s>1:
con+=s*(s-1)//2
A.append(n*(n-1)//2-con)
A=reversed(A)
for a in A:
print(a) | import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
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にする
x, y = y, x
self.parents[x] += self.parents[y] #xの要素数はyの要素数ぶん増える
self.parents[y] = x #yをxの子にする
def size(self, x): #xの属するグループの要素数
return -self.parents[self.find(x)]
def same(self, x, y): #同じグループか判定
return self.find(x) == self.find(y)
def members(self, x): #xの属するグループの要素一覧
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self): #根の一覧
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self): #グループ個数
return len(self.roots())
def all_group_members(self): #根とその要素の辞書配列
return {r: self.members(r) for r in self.roots()}
def __str__(self): #print用
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m=list(map(int,input().split()))
U=UnionFind(n)
A=[n*(n-1)//2]
V=[]
for i in range(m):
a,b=list(map(int,input().split()))
V.append([a-1,b-1])
V=list(reversed(V))
for i in range(m):
if i==m-1:
continue
a=V[i][0]
b=V[i][1]
if not U.same(a,b):
s=U.size(a)
t=U.size(b)
u=s+t
U.union(a,b)
d=u*(u-1)//2-s*(s-1)//2-t*(t-1)//2
A.append(A[-1]-d)
else:
A.append(A[-1])
A=reversed(A)
for a in A:
print(a) | p03108 |
class unionfind:
def __init__(self, n):
self.parent = list(range(n))
def find(self, i):
if self.parent[i] != i: self.parent[i] = self.find(self.parent[i])
return self.parent[i]
def unite(self, i, j):
i = self.find(i)
j = self.find(j)
if i != j: self.parent[i] = j
def issame(self, i, j):
return self.find(i) == self.find(j)
def groups(self):
r = list(range(len(self.parent)))
return [[j for j in r if self.issame(j, i)] for i in r if i == self.parent[i]]
@staticmethod
def isconnected(l, u = None):
nw, nh = len(l), len(l[0])
rw, rh = list(range(nw)), list(range(nh))
if not u: u = unionfind(nw * nh)
f = -1
for i in rw:
for j in rh:
if not l[i][j]: continue
if f < 0: f = i + j * nw
if j > 0 and l[i][j] == l[i][j - 1]: u.unite(i + j * nw, i + j * nw - nw)
if i > 0 and l[i][j] == l[i - 1][j]: u.unite(i + j * nw, i + j * nw - 1)
return f >= 0 and all([u.issame(f, i + j * nw) for i in rw for j in rh if l[i][j]])
@staticmethod
def isconnectedlist(nw, nh, lst):
l = [[False] * nw for j in range(nh)]
for i, j in lst: l[i][j] = True
return unionfind.isconnected(l)
def culc(x):
return int(x * (x-1) //2)
N , M = list(map(int, input().split()))
ans_lst = []
lst = []
for i in range(M):
A , B = list(map( int , input().split()))
lst.append([A-1 , B-1] )
cu = unionfind(N)
maxroute = culc(N)
temp = maxroute
for ls in reversed(lst):
if temp == 0 :
ans_lst.append(temp)
continue
temp = maxroute
for subg in cu.groups():
if len(subg) > 1:
temp -= culc(len(subg))
ans_lst.append(temp)
cu.unite(ls[0] , ls[1])
for y in reversed(ans_lst):
print(y) | #学習用
def root(x):
# xが根であれば
if x == p[x]:
# xを返す
return x
# xが根でなければp[x]の根をp[x]に設定する
p[x] = y = root(p[x])
# p[x]の根を返却する
return y
def unite(x, y):
# xとyの根を取得する
px = root(x); py = root(y)
# xとyの根が同じならば
if px == py:
# 根が同じならば、0を返す
return 0
# yの根がxの根より大きければ、
if px < py:
# yの根の位置のp[]を、xの根にする
p[py] = px
# xの根の位置のサイズszを、yの根の位置のサイズだけ加算する
sz[px] += sz[py]
else:
# yの根がxの根より小さければ
# xの根の位置のp[]を、yの根を指すようにする
p[px] = py
sz[py] += sz[px]
# 根が異なっていた＝結合した場合は、1を返却する
return 1
N , M = list(map(int, input().split()))
*p , = list(range(N))
sz = [1] * N
E = []
for i in range(M):
a , b = list(map(int, input().split()))
E.append((a-1, b-1))
ans = [None] * M
E.reverse()
res = 0
ans[-1] = "%d\n" % (N*(N-1)//2)
for i , (a,b) in enumerate(E[:-1]):
sa = sz[root(a)]; sb = sz[root(b)]
if unite(a , b):
sc = sz[root(a)]
res += sc*(sc-1)//2 - sa*(sa-1)//2 - sb*(sb-1)//2
ans[-2-i] = "%d\n" % (N*(N-1)//2 -res)
open(1, 'w').writelines(ans) | p03108 |
import collections
class UnionFind:
def __init__(self, n):
self.par =[i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
#decayed briges
n,m=list(map(int,input().split()))
lists=[0 for i in range(m)]
Alists=[]
Alists.append(n*(n-1)//2)
for i in range(m):
a,b=list(map(int,input().split()))
lists[i]=(a,b)
A=UnionFind(n)
lists=lists[::-1]
c=n*(n-1)//2
Alist=[]
for j in lists:
a,b=j[0],j[1]
par=dict(collections.Counter(A.par))
if A.find(a)!=A.find(b):
c-=(par[A.find(a)]*par[A.find(b)])
else:
pass
A.union(a,b)
for _ in range(n+1):
A.find(_)
Alists.append(c)
Alists=Alists[::-1]
for k in Alists[1:]:
print(k)
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * (n+1)
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
class UnionFindLabel(UnionFind):
def __init__(self, labels):
assert len(labels) == len(set(labels))
self.n = len(labels)
self.parents = [-1] * self.n
self.d = {x: i for i, x in enumerate(labels)}
self.d_inv = {i: x for i, x in enumerate(labels)}
def find_label(self, x):
return self.d_inv[super().find(self.d[x])]
def union(self, x, y):
super().union(self.d[x], self.d[y])
def size(self, x):
return super().size(self.d[x])
def same(self, x, y):
return super().same(self.d[x], self.d[y])
def members(self, x):
root = self.find(self.d[x])
return [self.d_inv[i] for i in range(self.n) if self.find(i) == root]
def roots(self):
return [self.d_inv[i] for i, x in enumerate(self.parents) if x < 0]
#decayed briges
n,m=list(map(int,input().split()))
lists=[0 for i in range(m)]
Alists=[]
Alists.append(n*(n-1)//2)
for i in range(m):
#計算量O(M)
a,b=list(map(int,input().split()))
lists[i]=(a,b)
A=UnionFind(n)
lists=lists[::-1]
c=n*(n-1)//2
Alist=[]
for j in lists:
a,b=j[0],j[1]
if A.find(a)!=A.find(b):
c=c-A.size(a)*A.size(b)
A.union(a,b)
Alists.append(c)
Alists=Alists[::-1]
for k in Alists[1:]:
print(k)
| p03108 |
N,M=list(map(int, input().split()))
#島、橋
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if (x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
#rnkが大きい方に結合
elif (self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
L=[]
for i in range(M):
a,b=list(map(int, input().split()))
L.append((a-1,b-1))
uni=UnionFind(N)
ans=[0]*M
L=reversed(L)
for i,t in enumerate(L):
a,b=t
ca=uni.Count(a)
cb=uni.Count(b)
if uni.isSameGroup(a,b):
ans[-(i+1)]=0
else:
ans[-(i+1)]=uni.Count(a)*uni.Count(b)
uni.Unite(a,b)
final=[0]*M
final[0]=ans[0]
#print(ans)
for i in range(1,M):
final[i]=final[i-1]+ans[i]
for f in final:
print(f)
| N,M=list(map(int, input().split()))
B=[]
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if (x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
#rnkが大きい方に結合
elif (self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
for i in range(M):
a,b=list(map(int, input().split()))
B.append((a-1,b-1))
B=B[::-1]
uni=UnionFind(N)
now=N*(N-1)//2
ans=[]
for t in B:
ans.append(now)
a,b=t
if uni.isSameGroup(a,b):
uni.Unite(a,b)
else:
A=uni.Count(a)
B=uni.Count(b)
now-=(A*B)
uni.Unite(a,b)
for a in ans[::-1]:
print(a)
| p03108 |
N,M=list(map(int,input().split()))
path=[]
for i in range(M):
a,b=list(map(int,input().split()))
path.append([a-1,b-1])
class UnionFind():
#負の値はルートで集合の個数
#正の値は次の要素を返す
def __init__(self,size):
self.table = [-1 for _ in range(size)]
self.member_num = [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)
m1=self.member_num[s1]
m2=self.member_num[s2]
if s1 != s2:#根が異なる場合
if self.table[s1] != self.table[s2]:#グラフの高さが異なる場合
if self.table[s1] < self.table[s2]:
self.table[s2] = s1
self.member_num[s1]=m1+m2
return [m1,m2]
else:
self.table[s1] = s2
self.member_num[s2]=m1+m2
return [m1,m2]
else:
#グラフの長さが同じ場合,どちらを根にしても変わらない
#その際,グラフが1長くなることを考慮する
self.table[s1] = -1
self.table[s2] = s1
self.member_num[s1] = m1+m2
return [m1,m2]
return [0,0]
uf=UnionFind(N)
path=path[::-1]
count = 0
ans = [N*(N-1)//2]
for i in range(M):
a,b=path[i]
m1,m2 = uf.union(a,b)
count+=m1*m2
ans.append(N*(N-1)//2 - count)
ans=ans[:-1]
ans=ans[::-1]
for i in range(M):
print((ans[i])) |
N,M=list(map(int,input().split()))
path=[]
for i in range(M):
a,b=list(map(int,input().split()))
path.append([a-1,b-1])
class UnionFind():
#負の値はルートで集合の個数
#正の値は次の要素を返す
def __init__(self,size):
self.table = [-1 for _ in range(size)]
self.member_num = [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)
m1=self.member_num[s1]
m2=self.member_num[s2]
if s1 != s2:#根が異なる場合
if m1 != m2:#グラフの高さが異なる場合
if m1 < m2:
self.table[s1] = s2
self.member_num[s2]=m1+m2
return [m1,m2]
else:
self.table[s2] = s1
self.member_num[s1]=m1+m2
return [m1,m2]
else:
#グラフの長さが同じ場合,どちらを根にしても変わらない
#その際,グラフが1長くなることを考慮する
self.table[s1] = -1
self.table[s2] = s1
self.member_num[s1] = m1+m2
return [m1,m2]
return [0,0]
uf=UnionFind(N)
path=path[::-1]
count = 0
ans = [N*(N-1)//2]
for i in range(M):
a,b=path[i]
m1,m2 = uf.union(a,b)
count+=m1*m2
ans.append(N*(N-1)//2 - count)
ans=ans[:-1]
ans=ans[::-1]
for i in range(M):
print((ans[i])) | p03108 |
from math import factorial
def combination(n, r): # n個からr個選ぶ場合の数
if n < r:
return 0
else:
return factorial(n)//(factorial(r) * factorial(n-r))
class UnionFind():
def __init__(self, n):
self.nodes = [-1] * n # nodes[x]: 負なら、絶対値が木の要素数
def get_root(self, x):
# nodes[x]が負ならxが根
if self.nodes[x] < 0:
return x
# 根に直接つなぎ直しつつ、親を再帰的に探す
else:
self.nodes[x] = self.get_root(self.nodes[x])
return self.nodes[x]
def unite(self, x, y):
root_x = self.get_root(x)
root_y = self.get_root(y)
# 根が同じなら変わらない
# if root_x == root_y:
# pass
if root_x != root_y:
# 大きい木の方につないだほうが計算量が減る
if self.nodes[root_x] < self.nodes[root_y]:
big_root = root_x
small_root = root_y
else:
small_root = root_x
big_root = root_y
self.nodes[big_root] += self.nodes[small_root]
self.nodes[small_root] = big_root
def solve_uncomfort(self, combi_n):
sum = 0
for n in self.nodes:
if n < 0:
n = abs(n)
sum += combination(abs(n), 2)
return combi_n-sum
def main():
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)
uf = UnionFind(N+1)
get_root, unite, nodes = uf.get_root, uf.unite, uf.nodes
ans = []
combi_n = combination(N, 2)
for i in reversed(list(range(M))):
ans.append(uf.solve_uncomfort(combi_n))
unite(A[i], B[i])
print(('\n'.join(map(str, ans[::-1]))))
if __name__ == '__main__':
main()
| from math import factorial
def combination(n, r): # n個からr個選ぶ場合の数
if n < r:
return 0
else:
return factorial(n)//(factorial(r) * factorial(n-r))
class UnionFind():
def __init__(self, n):
self.nodes = [-1] * n # nodes[x]: 負なら、絶対値が木の要素数
def get_root(self, x):
# nodes[x]が負ならxが根
if self.nodes[x] < 0:
return x
# 根に直接つなぎ直しつつ、親を再帰的に探す
else:
self.nodes[x] = self.get_root(self.nodes[x])
return self.nodes[x]
def unite(self, x, y):
root_x = self.get_root(x)
root_y = self.get_root(y)
# 根が同じなら変わらない
# if root_x == root_y:
# pass
if root_x != root_y:
# 大きい木の方につないだほうが計算量が減る
if self.nodes[root_x] < self.nodes[root_y]:
big_root = root_x
small_root = root_y
else:
small_root = root_x
big_root = root_y
self.nodes[big_root] += self.nodes[small_root]
self.nodes[small_root] = big_root
def main():
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)
uf = UnionFind(N+1)
get_root, unite, nodes = uf.get_root, uf.unite, uf.nodes
uncomfort = (combination(N, 2))
ans = [uncomfort]
for i in reversed(list(range(M))):
if get_root(A[i]) != get_root(B[i]):
uncomfort -= abs(nodes[get_root(A[i])] * nodes[get_root(B[i])])
ans.append(uncomfort)
unite(A[i], B[i])
# print(ans)
print(('\n'.join(map(str, ans[-2::-1]))))
if __name__ == '__main__':
main()
| p03108 |
n,m=list(map(int,input().split()))
ab=[[0,0] for i in range(m)]
for i in range(m):
ab[i][0],ab[i][1]=list(map(int,input().split()))
import sys
sys.setrecursionlimit(10**9) #再帰の上限をあげる
root=[-1 for i in range(n+1)] #自分が親なら自身の番号を、そうでないなら（元）親の番号を示す
def r(x): #親は誰？
if root[x]<0:
return x
else:
root[x]=r(root[x])
return root[x]
ans=n*(n-1)//2
d=[n*(n-1)//2]
for i in range(1,m+1):
a,b=ab[-i][0],ab[-i][1]
a=r(a)
b=r(b)
a,b=min(a,b),max(a,b)
if a!=b:
ans-=root[a]*root[b]
root[a]+=root[b]
root[b]=a
d.append(ans)
for i in range(m):
print((d[-2-i]))
| import sys
input=sys.stdin.readline #文字列入力はするな！！
n,m=list(map(int,input().split()))
ab=[[0,0] for i in range(m)]
for i in range(m):
ab[i][0],ab[i][1]=list(map(int,input().split()))
sys.setrecursionlimit(10**9) #再帰の上限をあげる
root=[-1 for i in range(n+1)] #自分が親なら自身の番号を、そうでないなら（元）親の番号を示す
def r(x): #親は誰？
if root[x]<0:
return x
else:
root[x]=r(root[x])
return root[x]
ans=n*(n-1)//2
d=[n*(n-1)//2]
for i in range(1,m+1):
a,b=ab[-i][0],ab[-i][1]
a=r(a)
b=r(b)
a,b=min(a,b),max(a,b)
if a!=b:
ans-=root[a]*root[b]
root[a]+=root[b]
root[b]=a
d.append(ans)
for i in range(m):
print((d[-2-i]))
| p03108 |
N, M = list(map(int, input().split()))
L = [list(map(int, input().split())) for _ in range(M)]
X = [set([i]) for i in range(1,N+1)]
C = [0]
for a, b in L[::-1]:
xa = [x for x in X if a in x][0]
xb = [x for x in X if b in x][0]
if(len(xa ^ xb)!=0):
C.append(C[-1]+len(xa)*len(xb))
X.remove(xa)
X.remove(xb)
X.append(xa | xb)
else:
C.append(C[-1])
for c in C[:-1][::-1]:
print((N*(N-1)//2-c)) | N, M = list(map(int, input().split()))
L = [list(map(int, input().split())) for _ in range(M)]
X = [set([i]) for i in range(1,N+1)]
par = list(range(N+1))
rank = [0] * (N+1)
size = [1] * (N+1)
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return
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
return
C = [0]
for a, b in L[::-1]:
xa = find(a)
xb = find(b)
if xa == xb:
C.append(C[-1])
else:
C.append(C[-1] + size[xa] * size[xb])
unite(xa, xb)
for c in C[:-1][::-1]:
print((N*(N-1)//2-c)) | p03108 |
class uf_tree:
def __init__(self, n):
self._size = n
self.sizes = [1] * n
self.par = list(range(n))
def find(self, x):
if x == self.par[x]:
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
self._size -= 1
x, y = self.find(x), self.find(y)
if x == y:
return
if self.sizes[x] < self.sizes[y]:
x, y = y, x
self.par[y] = x
self.sizes[x] += self.sizes[y]
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.sizes[self.find(x)]
def com(x):
return x*(x-1)//2
n, m = map(int, input().split())
AB = [ list(map(int, input().split())) for _ in range(m) ]
ans = []
benri = 0
uf = uf_tree(n+1)
benri = 0
for a, b in AB[::-1]:
ans += [ com(n) - benri ]
if uf.same(a, b):
continue
a_benri = com(uf.size(a) )
b_benri = com(uf.size(b) )
uf.unite(a, b)
sum_benri = com( uf.size(a) )
benri += sum_benri - a_benri - b_benri
print (*ans[::-1], sep="\n")
| import sys
input = sys.stdin.readline
class uf_tree:
def __init__(self, n):
self._size = n
self.sizes = [1] * n
self.par = list(range(n))
def find(self, x):
if x == self.par[x]:
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
self._size -= 1
x, y = self.find(x), self.find(y)
if x == y:
return
if self.sizes[x] < self.sizes[y]:
x, y = y, x
self.par[y] = x
self.sizes[x] += self.sizes[y]
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.sizes[self.find(x)]
def com(x):
return x*(x-1)//2
n, m = map(int, input().split())
AB = [ list(map(int, input().split())) for _ in range(m) ]
ans = []
benri = 0
uf = uf_tree(n+1)
for a, b in AB[::-1]:
ans += [ com(n) - benri ]
if uf.same(a, b):
continue
a_benri = com(uf.size(a) )
b_benri = com(uf.size(b) )
uf.unite(a, b)
sum_benri = com( uf.size(a) )
benri += sum_benri - a_benri - b_benri
print (*ans[::-1], sep="\n")
| p03108 |
#%%
class Graph:
def __init__(self,n):
'''Generate graph. n is the number of islands in the world.'''
self.numIslands = n
self.union = {}
self.nextUnionKey = 1
self.isolatedPath = int(n * (n-1) / 2)
def getUnionId(self,island):
'''returns union ID of the input island if the island belongs to any union'''
for key in self.union:
if island in self.union[key]:
return key
return None
def addBridge(self,f,t):
'''unite unions if f and t are in different unions
add new union if neither f nor t are in a union
add f or t to a union if and only if one of them belongs to a union
finally manage and return self.isolatedPath
'''
f_union = self.getUnionId(f)
t_union = self.getUnionId(t)
if f_union:
if t_union:
if f_union != t_union:
# merge union
self.isolatedPath -= len(self.union[f_union]) * len(self.union[t_union])
self.union[f_union] += self.union[t_union]
del self.union[t_union]
else:
pass
else:
self.isolatedPath -= len(self.union[f_union])
self.union[f_union].append(t)
else:
if t_union:
self.isolatedPath -= len(self.union[t_union])
self.union[t_union].append(f)
else:
self.isolatedPath -= 1
self.union[self.nextUnionKey] = [t,f]
self.nextUnionKey += 1
return self.isolatedPath
def __str__(self):
return str(self.union)
#%%
n,m = list(map(int, input().split()))
bridges = []
for _ in range(m):
bridges.append(list(map(int, input().split())))
bridges.reverse()
world = Graph(n)
ans = [world.isolatedPath]
for i, bridge in enumerate(bridges):
ans.append(world.addBridge(bridge[0], bridge[1]))
ans.pop()
for a in ans[::-1]:
print(a)
| N, M = list(map(int, input().split()))
AB = []
for _ in range(M):
a, b = list(map(int, input().split()))
AB.append((a-1, b-1))
class UnionFind():
def __init__(self, n):
# negative if parent
# if parent, absolute value represents the number of nodes in the union
# if child, value represents the parent node to it
self.parent = [-1 for _ in range(n)]
def root(self, x):
if self.parent[x] < 0:
return x
else:
# recursively trace a parent node until it gets to a root while updating every node so that they are directly connected to their common parent
self.parent[x] = self.root(self.parent[x])
return self.parent[x]
def size(self, x):
return -1 * self.parent[self.root(x)]
def union(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return False
else:
size_x = - self.size(x)
size_y = - self.size(y)
# make sure y is shorter so that always shorter tree(y) is atached to longer tree(x)
if size_x > size_y:
x, y = y, x
self.parent[x] += self.parent[y]
self.parent[y] = x
return size_x, size_y
n_solo = N * (N - 1) // 2
ans = [n_solo]
uf = UnionFind(N)
for a, b in reversed(AB):
united = uf.union(uf.root(a), uf.root(b))
if united:
n_solo -= united[0] * united[1]
ans.append(n_solo)
for a in reversed(ans[:-1]):
print(a)
| p03108 |
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
group = [i for i in range(n)]
islands = {i: [i] for i in range(n)}
ret = [0] * m + [n * (n - 1) // 2]
for i in range(m - 1, -1, -1):
a, b = ab[i]
ga, gb = group[a - 1], group[b - 1]
if ga == gb:
ret[i] = ret[i + 1]
else:
ret[i] = ret[i + 1] - len(islands[ga]) * len(islands[gb])
islands[ga] += islands[gb]
for j in islands[gb]:
group[j] = ga
for i in range(1, m + 1):
print((ret[i])) | n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
group = [i for i in range(n)]
islands = {i: [i] for i in range(n)}
ret = [0] * m + [n * (n - 1) // 2]
for i in range(m - 1, -1, -1):
a, b = ab[i]
ga, gb = group[a - 1], group[b - 1]
if ga == gb:
ret[i] = ret[i + 1]
else:
la, lb = len(islands[ga]), len(islands[gb])
ret[i] = ret[i + 1] - la * lb
if la > lb:
for j in islands[gb]:
group[j] = ga
islands[ga].append(j)
else:
for j in islands[ga]:
group[j] = gb
islands[gb].append(j)
for i in range(1, m + 1):
print((ret[i])) | p03108 |
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
group = [i for i in range(n)]
islands = {i: [i] for i in range(n)}
ret = [0] * m + [n * (n - 1) // 2]
for i in range(m - 1, -1, -1):
a, b = ab[i]
ga, gb = group[a - 1], group[b - 1]
if ga == gb:
ret[i] = ret[i + 1]
else:
la, lb = len(islands[ga]), len(islands[gb])
ret[i] = ret[i + 1] - la * lb
if la > lb:
for j in islands[gb]:
group[j] = ga
islands[ga].append(j)
else:
for j in islands[ga]:
group[j] = gb
islands[gb].append(j)
for i in range(1, m + 1):
print((ret[i])) | import sys
sys.setrecursionlimit(100000)
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
parent = [i for i in range(n)]
count = [1 for i in range(n)]
def root(i):
if i == parent[i]:
return i
parent[i] = root(parent[i])
return parent[i]
def merge(i, j):
parent[j] = i
count[i] += count[j]
ret = [0] * m + [n * (n - 1) // 2]
for i in range(m - 1, -1, -1):
a, b = ab[i]
ra, rb = root(a - 1), root(b - 1)
if ra == rb:
ret[i] = ret[i + 1]
else:
ret[i] = ret[i + 1] - count[ra] * count[rb]
merge(ra, rb)
for i in range(1, m + 1):
print((ret[i])) | p03108 |
def getN():
return int(eval(input()))
def getMN():
a = input().split()
b = [int(i) for i in a]
return b[0],b[1]
def getlist():
a = input().split()
b = [int(i) for i in a]
return b
from collections import Counter
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.size = [1 for i in range(n)]
self.rank = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.size[x] += self.size[y]
self.size[y] = 0
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n,m = getMN()
bridges = []
for i in range(m):
a,b = getMN()
bridges.append([a,b])
bridges.reverse()
uf = UnionFind(n)
answers = []
for query in bridges:
x,y = query
if not uf.same_check(x-1,y-1):
uf.union(x-1,y-1)
ans = 0
for si in uf.size:
ans += si * (n-si)
answers.append(ans//2)
for fa in answers[:-1][::-1]:
print(fa)
print((n*(n-1)//2)) | def getN():
return int(eval(input()))
def getMN():
a = input().split()
b = [int(i) for i in a]
return b[0],b[1]
def getlist():
a = input().split()
b = [int(i) for i in a]
return b
from collections import Counter
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.size = [1 for i in range(n)]
self.rank = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.size[x] += self.size[y]
self.size[y] = 0
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n,m = getMN()
bridges = []
for i in range(m):
a,b = getMN()
bridges.append([a,b])
bridges.reverse()
uf = UnionFind(n)
ans = n*(n-1)//2
answers = [ans]
for query in bridges:
x,y = query
if not uf.same_check(x-1,y-1):
#print(uf.size,x,y)
ans -= uf.size[uf.find(x-1)]*uf.size[uf.find(y-1)]
#print(uf.find(x-1))
uf.union(x-1,y-1)
answers.append(ans)
for fa in answers[:-1][::-1]:
print(fa)
| p03108 |
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
def LILI(n): return [LI() for _ in range(n)]
INF = 10 ** 18
MOD = 10 ** 9 + 7
'''
独立なグラフがいくつかできていく。
求めるもの：グラフ1にある頂点と2にある頂点の combinaton, 1と3のcombination,……2と3のcombination…… の総和を求めるのを繰り返す。
union-findで行けそうだがN, Mどちらも10**5なので間に合わなさそう。
最終的にはすべて独立となり、答えはnC2となる。
ということで nC2 からはじめてどんどん union していけばいいのでは。
union する2つのグループの頂点数の積を引いていけば良いのかな。
'''
import collections
import itertools
import operator
class UnionFind:
def __init__(self, elems=None):
class KeyDict(dict): # dict + キーがないときは dict[key] = key として key を返す。
def __missing__(self, key):
self[key] = key
return key
self.parent = KeyDict() # キーがなければ孤立点→自身が key（parent[key]=key）
self.rank = collections.defaultdict(int) # 木の高さ。デフォルトでは 0。経路圧縮すると本来は rank が下がるが、その効果は無視している。
self.children_num = collections.defaultdict(lambda: 1) # その点を含む子の数。根の値しか信用できない。
if elems is not None:
for elem in elems:
_, _ = self.parent[elem], self.rank[elem]
def find(self, x): # あるキーの根を探す。
if self.parent[x] == x:
# self.children_num[x] = self.children_num[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) # x の根を求める。
y = self.find(y) # y の根を求める。
if x == y: # もともと同一の木
return
if self.rank[x] < self.rank[y]: # rank （木の高さ）の低いほうを高いほうに繋げる。
self.parent[x] = y # x の親を y にする。
self.children_num[y] += self.children_num[x]
else:
self.parent[y] = x
self.children_num[x] += self.children_num[y]
if self.rank[x] == self.rank[y]: # 同じ高さの木だったら片方の rank を1つ上げておく。
self.rank[x] += 1
def are_same(self, x, y):
return self.find(x) == self.find(y)
def grouper(self):
roots = [(x, self.find(x_par)) for x, x_par in list(self.parent.items())]
root = operator.itemgetter(1)
for _, group in itertools.groupby(sorted(roots, key=root), root):
yield [x for x, _ in group]
def number_of_vertices(self, x):
x = self.find(x)
return self.children_num[x]
def main():
N, M = LI()
visited = [False]*(N+1)
uf = UnionFind()
ans_rev = [0]*(M+1)
ans_rev[0] = N * (N-1) // 2 # N_C_2
A_li, B_li = [], []
for i in range(0, M):
A, B = LI()
A_li.append(A)
B_li.append(B)
for i, (A, B) in enumerate(reversed(list(zip(A_li, B_li)))):
if not uf.are_same(A, B):
ans_rev[i+1] = ans_rev[i] - uf.number_of_vertices(A) * uf.number_of_vertices(B)
else:
ans_rev[i+1] = ans_rev[i]
uf.unite(A, B)
for i in reversed(ans_rev[:-1]):
print(i)
main() | import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
def LILI(n): return [LI() for _ in range(n)]
INF = 10 ** 18
MOD = 10 ** 9 + 7
'''
独立なグラフがいくつかできていく。
求めるもの：グラフ1にある頂点と2にある頂点の combinaton, 1と3のcombination,……2と3のcombination…… の総和を求めるのを繰り返す。
union-findで行けそうだがN, Mどちらも10**5なので間に合わなさそう。
最終的にはすべて独立となり、答えはnC2となる。
ということで nC2 からはじめてどんどん union していけばいいのでは。
union する2つのグループの頂点数の積を引いていけば良いのかな。
'''
import collections
import itertools
import operator
class UnionFind:
def __init__(self, elems=None):
class KeyDict(dict): # dict + キーがないときは dict[key] = key として key を返す。
def __missing__(self, key):
self[key] = key
return key
self.parent = KeyDict() # キーがなければ孤立点→自身が key（parent[key]=key）
self.rank = collections.defaultdict(int) # 木の高さ。デフォルトでは 0。経路圧縮すると本来は rank が下がるが、その効果は無視している。
self.size_ = collections.defaultdict(lambda: 1) # 根に属する頂点の個数。根の値しか信用できない。
if elems is not None:
for elem in elems:
_, _ = self.parent[elem], self.rank[elem]
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) # x の根を求める。
y = self.find(y) # y の根を求める。
if x == y: # もともと同一の木なら何もしない。
return
if self.rank[x] < self.rank[y]: # rank （木の高さ）の低いほうを高いほうに繋げたい。
x, y = y, x
self.parent[y] = x # x の親を y にする。
self.size_[x] += self.size_[y]
if self.rank[x] == self.rank[y]: # 同じ高さの木だったら片方の rank を1つ上げておく。
self.rank[x] += 1
def are_same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.size_[self.find(x)]
def grouper(self):
roots = [(x, self.find(x_par)) for x, x_par in list(self.parent.items())]
root = operator.itemgetter(1)
for _, group in itertools.groupby(sorted(roots, key=root), root):
yield [x for x, _ in group]
def main():
N, M = LI()
visited = [False]*(N+1)
uf = UnionFind()
ans_rev = [0]*(M+1)
ans_rev[0] = N * (N-1) // 2 # N_C_2
A_li, B_li = [], []
for i in range(0, M):
A, B = LI()
A_li.append(A)
B_li.append(B)
for i, (A, B) in enumerate(reversed(list(zip(A_li, B_li)))):
if not uf.are_same(A, B):
ans_rev[i+1] = ans_rev[i] - uf.size(A) * uf.size(B)
else:
ans_rev[i+1] = ans_rev[i]
uf.unite(A, B)
for i in reversed(ans_rev[:-1]):
print(i)
main() | p03108 |
N, M = [int(_) for _ in input().split()]
AB = [[int(_) for _ in input().split()] for _ in range(M)]
UF = list(range(N + 1))
SIZE = [0] + [1] * N # 1-indexed
def find(x):
if UF[x] != x:
UF[x] = find(UF[x])
return UF[x]
def unite(x, y):
m = min(find(x), find(y))
SIZE[m] = SIZE[find(x)] + SIZE[find(y)]
UF[find(x)] = m
UF[find(y)] = m
def is_same(x, y):
return find(x) == find(y)
def scan_uf():
for i in range(len(UF)):
find(i)
ans = [N * (N - 1) // 2]
for a, b in AB[::-1]:
if not is_same(a, b):
ans += [ans[-1] - SIZE[find(a)] * SIZE[find(b)]]
unite(a, b)
else:
ans += [ans[-1]]
print(*ans[-2::-1], sep='\n')
| N, M = [int(_) for _ in input().split()]
AB = [[int(_) for _ in input().split()] for _ in range(M)]
UF = list(range(N + 1))
SIZE = [0] + [1] * N # 1-indexed
def find(x):
if UF[x] != x:
UF[x] = find(UF[x])
return UF[x]
def unite(x, y):
X, Y = find(x), find(y)
SX,SY=SIZE[X],SIZE[Y]
m = min(X,Y)
SIZE[m] = SX + SY
SIZE[X+Y-m]=0
UF[X+Y-m] = m
def is_same(x, y):
return find(x) == find(y)
def scan_uf():
for i in range(len(UF)):
find(i)
ans = [N * (N - 1) // 2]
for a, b in AB[::-1]:
if not is_same(a, b):
ans += [ans[-1] - SIZE[find(a)] * SIZE[find(b)]]
unite(a, b)
else:
ans += [ans[-1]]
print(*ans[-2::-1], sep='\n')
| p03108 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N,M=list(map(int, input().split()))
B=[tuple(map(int, input().split())) for _ in range(M)]
P=list(range(N+1))
C=[1 for _ in range(N+1)]
C[0] = 0
def root(x):
if P[x]==x: return x
P[x] = root(P[x])
return P[x]
def unite(a,b):
ra = root(a)
rb = root(b)
C[ra] += C[rb]
C[rb] = 0
P[rb] = ra
def same(a,b):
return root(a) == root(b)
def count(x):
return C[root(x)]
ans=[0]*(M+1)
ans[M] = N * (N-1)
for i in range(M-1,-1,-1):
a,b = B[i]
if same(a,b):
ans[i] = ans[i+1]
continue
ans[i] = ans[i+1] - count(a) * count(b)
unite(a,b)
for i in range(1,M+1):
print((ans[i] - ans[0])) | import sys
input = sys.stdin.readline
N,M=list(map(int, input().split()))
B=[tuple(map(int, input().split())) for _ in range(M)]
P=list(range(N+1))
C=[1 for _ in range(N+1)]
C[0] = 0
def root(x):
t = x
stack = []
while P[t] != t:
stack.append(t)
t = P[t]
for c in stack: P[c] = t
return t
def unite(a,b):
ra = root(a)
rb = root(b)
C[ra] += C[rb]
C[rb] = 0
P[rb] = ra
def same(a,b):
return root(a) == root(b)
def count(x):
return C[root(x)]
ans=[0]*(M+1)
ans[M] = N * (N-1)
for i in range(M-1,-1,-1):
a,b = B[i]
if same(a,b):
ans[i] = ans[i+1]
continue
ans[i] = ans[i+1] - count(a) * count(b)
unite(a,b)
for i in range(1,M+1):
print((ans[i] - ans[0])) | p03108 |
'''
https://atcoder.jp/contests/abc120/tasks/abc120_d
'''
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
def same(x,y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
#xが属するグループの要素全てを返す
def members(x, n):
root = find(x)
return [i for i in range(n) if find(i) == root]
#全ての根の要素を返す
def roots():
return [i for i, x in enumerate(par) if x < 0]
n,m = list(map(int, input().split()))
edge = [list(map(int, input().split())) for _ in range(m)]
par = [-1]*n
res = [n*(n-1)//2]
for a,b in edge[m-1:0:-1]:
unite(a-1,b-1)
root = roots()
if len(root)==1:
res.append(0)
else:
total = 0
for x, y in combinations(root, 2):
total += size(x)*size(y)
res.append(total)
for i in res[::-1]:
print(i)
if __name__ == '__main__':
main() | '''
https://atcoder.jp/contests/abc120/tasks/abc120_d
'''
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
def same(x,y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
#xが属するグループの要素全てを返す
def members(x, n):
root = find(x)
return [i for i in range(n) if find(i) == root]
#全ての根の要素を返す
def roots():
return [i for i, x in enumerate(par) if x < 0]
n,m = list(map(int, input().split()))
edge = [list(map(int, input().split())) for _ in range(m)]
par = [-1]*n
res = []
total = n*(n-1)//2
for a,b in edge[::-1]:
a -= 1
b -= 1
res.append(total)
if same(a,b):
continue
else:
total -= size(a)*size(b)
unite(a,b)
for i in res[::-1]:
print(i)
if __name__ == '__main__':
main() | p03108 |
N, M = list(map(int, input().split()))
A, B = [], []
g = {}
for i in range(1, N+1):
g[i] = []
for _ in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
g[a].append(b)
g[b].append(a)
def dfs(graph, start):
visited = []
stack = []
stack.append(start)
result = []
while len(stack) > 0:
next = stack.pop()
if next in visited:
continue
result.append(next)
visited.append(next)
for nei in graph[next]:
stack.append(nei)
return result
def wfs(graph, start):
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 graph[next_city]:
queue.append(nei)
return result
for i in range(M):
ans = 0
g[A[i]].remove(B[i])
g[B[i]].remove(A[i])
for j in range(1, N+1):
# print(wfs(g, j))
for k in range(j, N+1):
if k not in wfs(g, j):
ans += 1
print(ans)
| class UnionFind():
# 初期化
# 全てのノードの親は -1 とする
def __init__(self, n):
self.par = [-1] * n
# xがどのグループに属しているか調べる
def root(self, x):
# xが親のとき
if self.par[x] < 0:
return x
# xの親がさらに親をもつとき、それをxの親とする
else:
self.par[x] = self.root(self.par[x])
return self.par[x]
# 自分のいるグループの頂点数を調べる
def size(self, x):
return -self.par[self.root(x)]
# xとyをくっつける
def connect(self, x, y):
x = self.root(x)
y = self.root(y)
# すでにくっついていたらくっつけない
if x == y:
return
# 大きい方(x)に小さい方(y)をくっつける
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
N, M = list(map(int, input().split()))
A, B = [], []
for _ in range(M):
a, b = list(map(int, input().split()))
# インデックスをずらす
A.append(a-1)
B.append(b-1)
uni = UnionFind(N)
ans = [N * (N-1) // 2]
for i in range(M-1, 0, -1):
ans.append(ans[-1])
# 繋がっていないグループがつながったとき
if uni.root(A[i]) != uni.root(B[i]):
ans[-1] -= uni.size(A[i]) * uni.size(B[i])
uni.connect(A[i], B[i])
for item in reversed(ans):
print(item)
| p03108 |
from sys import setrecursionlimit
#setrecursionlimit(10**5)
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納
# par[x]=xの時そのノードは根
self.par = [i for i in range(n + 1)]
# rank
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 check(self, x, y):
# 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 -1
# rankの小さいものを大きいほうにくっつける
if self.rank[x] < self.rank[y]:
self.par[x] = y
temp = self.size[x]
self.size[y] += temp
temp1 = self.size[y]
else:
self.par[y] = x
temp = self.size[y]
self.size[x] += temp
temp1 = self.size[x]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
return (temp, temp1)
def count_group(self):
return len({self.find(x) for x in range(1, n + 1)})
n, m = map(int,input().split())
ab = [list(map(int,input().split())) for i in range(m)]
uf = UnionFind(n)
inc = [n * (n - 1) // 2] * m
for i in range(m - 1):
a, b = ab[- i - 1]
rec = uf.union(a, b)
if rec == -1:
inc[-i-2] = inc[-i-1]
continue
temp = rec[1] - rec[0]
inc[-i-2] = max(inc[-i-1] - temp * rec[0], 0)
#print(uf.size,inc,rec,temp)
print(*inc, sep = '\n')
| from sys import setrecursionlimit
#setrecursionlimit(10**5)
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納
# par[x]=xの時そのノードは根
self.par = [i for i in range(n + 1)]
# rank
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 check(self, x, y):
# 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
# rankの小さいものを大きいほうにくっつける
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 count_group(self, n):
return len({self.find(x) for x in range(1, n + 1)})
def com_2(n):
if n == 1:return 0
return n * (n - 1) // 2
n, m = map(int,input().split())
ab = [list(map(int,input().split())) for i in range(m)]
ab = ab[::-1]
uf = UnionFind(n)
rec = [n * (n - 1) // 2] * m
for i in range(m - 1):
a, b = ab[i]
if uf.check(a, b):
rec[i + 1] = rec[i]
continue
a_size = uf.size[uf.find(a)]
b_size = uf.size[uf.find(b)]
temp = com_2(a_size) + com_2(b_size) - com_2(a_size + b_size)
rec[i + 1] = rec[i] + temp
uf.union(a, b)
rec = rec[::-1]
print(*rec, sep='\n')
| p03108 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
'''
要素xが属するグループの根を返す
'''
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
'''
要素xが属するグループと要素yが属するグループとを併合する
'''
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が属するグループのサイズ（要素数）を返す
'''
return -self.parents[self.find(x)]
def same(self, x, y):
'''
要素x, yが同じグループに属するかどうかを返す
'''
return self.find(x) == self.find(y)
def members(self, x):
'''
要素xが属するグループに属する要素をリストで返す
'''
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
'''
各要素の親要素の番号を格納するリスト
'''
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
'''
グループの数を返す
'''
return len(self.roots())
def all_group_members(self):
'''
{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
'''
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = map(int, input().split())
AB = reversed([list(map(int, input().split())) for i in range(M)])
ans = []
last = N * (N-1) // 2
ans.append(last)
G = UnionFind(N)
for A, B in AB:
G.union(A-1, B-1)
groups = G.all_group_members()
cnt = 0
for _, group in groups.items():
m = len(group)
cnt += m * (m-1) // 2
ans.append(last - cnt)
ans = ans[:-1]
print(*ans[::-1], sep='\n')
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
'''
要素xが属するグループの根を返す
'''
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
'''
要素xが属するグループと要素yが属するグループとを併合する
'''
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が属するグループのサイズ（要素数）を返す
'''
return -self.parents[self.find(x)]
def same(self, x, y):
'''
要素x, yが同じグループに属するかどうかを返す
'''
return self.find(x) == self.find(y)
def members(self, x):
'''
要素xが属するグループに属する要素をリストで返す
'''
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
'''
各要素の親要素の番号を格納するリスト
'''
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
'''
グループの数を返す
'''
return len(self.roots())
def all_group_members(self):
'''
{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
'''
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = map(int, input().split())
AB = reversed([list(map(int, input().split())) for _ in range(M)])
ans = []
last = N * (N-1) // 2
ans.append(last)
G = UnionFind(N)
for A, B in AB:
A, B = A-1, B-1
if G.same(A, B):
ans.append(ans[-1])
else:
a_size = G.size(A)
b_size = G.size(B)
ans.append(ans[-1] - (a_size * b_size))
G.union(A, B)
ans = ans[:-1]
print(*ans[::-1], sep='\n')
| p03108 |
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:
while self.parent[x] >= 0:
if self.parent[self.parent[x]] >= 0:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
# self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return 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)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| 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:
while self.parent[x] >= 0 and self.parent[self.parent[x]] >= 0:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
# self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return (x if self.parent[x] < 0 else 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)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| p03108 |
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:
while self.parent[x] >= 0 and self.parent[self.parent[x]] >= 0:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
# self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return (x if self.parent[x] < 0 else 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)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| import sys
input = sys.stdin.readline
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
elif self.parent[self.parent[x]] < 0:
return self.parent[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)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| p03108 |
import sys
input = sys.stdin.readline
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
elif self.parent[self.parent[x]] < 0:
return self.parent[x]
else:
self.parent[self.parent[x]] = self.parent[x] = self.root(self.parent[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)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1 for i in range(size)]#非負なら親ノード，負ならグループの要素数
def root(self, x): #root(x): xの根ノードを返す．
px=self.parent[x]
if px < 0:
return x
ppx=self.parent[px]
if ppx < 0:
return px
self.parent[px] = self.parent[x] = self.root(ppx) #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)]
n,m=[int(i) for i in input().split()]
A=[[int(i)-1 for i in input().split()] for _ in range(m)]
ans = [0]*(m+1)
a = n*(n-1)//2
ans[0] = a
uf = UnionFind(n)
for i in range(m):
j = m-i-1
v1 = A[j][0]
v2 = A[j][1]
# print(v1,v2)
if not uf.issame(v1,v2):
# print(uf.parent)
a -= uf.size(v1) * uf.size(v2)
uf.merge(v1,v2)
ans[i+1]=a
for i in range(m):
print((ans[m-i-1]))
| p03108 |
n,m=list(map(int,input().split()))
list_p=[]
for i in range(0,m):
a,b=list(map(int,input().split()))
list_p.append([a,b])
list_p.reverse()
group=[]
count=[]
group.append(list_p[0])
count.append(0)
for i in range(1,m):
number=0
index=0
ifa=0
ifb=0
for j in group:
number=number+len(j)*(len(j)-1)//2
if list_p[i][0] in j:
ifa=1
placea=index
if list_p[i][1] in j:
ifb=1
placeb=index
index=index+1
count.append(number)
if ifa==0 and ifb==0:
group.append(list_p[i])
elif ifa==1 and ifb==0:
group[placea].append(list_p[i][1])
elif ifa==0 and ifb==1:
group[placeb].append(list_p[i][0])
elif ifa==1 and ifb==1:
if placea==placeb:
pass
else:
group[placea].extend(group[placeb])
group.pop(placeb)
x=n*(n-1)//2
count.reverse()
for i in count:
print((x-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)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y]=self.size[x]+self.size[y]
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.size[x]=self.size[x]+self.size[y]
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
def Size(self,x):
return self.size[self.find(x)]
n,m=list(map(int,input().split()))
a_list=[]
b_list=[]
for i in range(m):
a,b=list(map(int,input().split()))
a_list.append(a)
b_list.append(b)
ans=[n*(n-1)//2]
U=UnionFind(n)
for i in range(m-1,0,-1):
if U.same_check(a_list[i],b_list[i]):
ans.append(ans[-1])
else:
ans.append(ans[-1]-U.Size(a_list[i])*U.Size(b_list[i]))
U.union(a_list[i],b_list[i])
for i in range(m-1,-1,-1):
print((ans[i]))
| p03108 |
class Unionfind():
def __init__(self, progsize):
self.table = [-1 for _ in range(progsize)]
self.size = [1 for _ in range(progsize)]
def find(self, x):
while(self.table[x] >= 0):
x = self.table[x]
return x
def union(self, x, y):
xl = self.find(x)
yl = self.find(y)
if xl != yl:
if self.table[xl] <= self.table[yl]:
self.table[yl] = xl
self.table[xl] -= 1
self.size[xl] += self.size[yl]
else:
self.table[xl] = yl
self.table[yl] -= 1
self.size[yl] += self.size[xl]
n, m = [int(x) for x in input().split()]
b = []
for i in range(m):
b.append(tuple(int(x) - 1 for x in input().split()))
r = []
t = n*(n-1)//2
ds = Unionfind(n)
for i in range(m):
q, p = b[-i-1]
r.insert(0, t)
qq, pp = ds.find(p), ds.find(q)
if pp != qq:
t -= ds.size[pp] * ds.size[qq]
ds.union(p, q)
for x in r:
print(x) | class Unionfind():
def __init__(self, progsize):
self.table = [-1 for _ in range(progsize)]
self.size = [1 for _ in range(progsize)]
def find(self, x):
while(self.table[x] >= 0):
x = self.table[x]
return x
def union(self, x, y):
xl = self.find(x)
yl = self.find(y)
if xl != yl:
if self.table[xl] <= self.table[yl]:
self.table[yl] = xl
self.table[xl] -= 1
self.size[xl] += self.size[yl]
else:
self.table[xl] = yl
self.table[yl] -= 1
self.size[yl] += self.size[xl]
n, m = list(map(int, input().split()))
bridge = [tuple(map(int, input().split())) for _ in range(m)]
bridge.reverse()
uf = Unionfind(n)
cur = n * (n-1) // 2
ans = [cur]
for a, b in bridge:
ap = uf.find(a-1)
bp = uf.find(b-1)
if ap != bp:
cur -= uf.size[ap] * uf.size[bp]
uf.union(a-1, b-1)
ans.append(cur)
for a in reversed(ans[0:m]):
print(a) | p03108 |
class DisjointSet():
def __init__(self, n):
self._p = [x for x in range(n)]
self._size = [-1 for x in range(n)]
def find(self, p):
while p != self._p[p]:
p = self._p[p]
return p
def union(self, p, q):
pp, qq = self.find(p), self.find(q)
if pp != qq:
if self._size[pp] > self._size[qq]:
self._p[qq] = pp
self._size[pp] += self._size[qq]
else:
self._p[pp] = qq
self._size[qq] += self._size[pp]
def size(self, p):
return self._size[self.find(p)]
n, m = [int(x) for x in input().split()]
b = [tuple([int(x) - 1 for x in input().split()]) for _ in range(m)]
b.reverse()
r = []
t = n*(n-1)//2
ds = DisjointSet(n)
for q, p in b:
r.append(t)
qq, pp = ds.find(p), ds.find(q)
if pp != qq:
t -= ds.size(pp) * ds.size(qq)
ds.union(p, q)
for x in reversed(r):
print(x) | class DisjointSet():
def __init__(self, n):
self._p = [x for x in range(n)]
self._size = [-1 for x in range(n)]
self._rank = [0 for x in range(n)]
def find(self, p):
while p != self._p[p]:
p = self._p[p]
return p
def union(self, p, q):
pp, qq = self.find(p), self.find(q)
if pp != qq:
if self._rank[pp] > self._rank[qq]:
self._p[qq] = pp
self._rank[pp] += 1
self._size[pp] += self._size[qq]
else:
self._p[pp] = qq
self._rank[qq] += 1
self._size[qq] += self._size[pp]
def size(self, p):
return self._size[self.find(p)]
n, m = [int(x) for x in input().split()]
b = [tuple([int(x) - 1 for x in input().split()]) for _ in range(m)]
b.reverse()
r = []
t = n*(n-1)//2
ds = DisjointSet(n)
for q, p in b:
r.append(t)
qq, pp = ds.find(p), ds.find(q)
if pp != qq:
t -= ds.size(pp) * ds.size(qq)
ds.union(p, q)
for x in reversed(r):
print(x) | p03108 |
import sys
# import math
# import bisect
# import copy
# import heapq
# from collections import deque
# import decimal
# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
# ===CODE===
def main():
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n, m = list(map(int, input().split()))
ans = 0
d = []
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
d.append((a, b))
d.reverse()
ans = []
que = UnionFind(n)
for i in range(m):
tmp = list(que.parents)
cnt = 0
l = len(tmp)
for j in range(l):
if tmp[j] > -1:
continue
for k in range(j + 1, l):
if tmp[k] > -1:
continue
cnt += tmp[j] * tmp[k]
ans.append(cnt)
que.union(d[i][0], d[i][1])
ans.reverse()
for tmp_a in ans:
print(tmp_a)
if __name__ == '__main__':
main()
| import sys
# import math
# import bisect
# import copy
# import heapq
# from collections import deque
# import decimal
# sys.setrecursionlimit(100001)
# INF = sys.maxsize
# MOD = 10 ** 9 + 7
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
# ===CODE===
def main():
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n, m = list(map(int, input().split()))
d = []
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
d.append((a, b))
d.reverse()
ans = []
a = n*(n-1)//2
que = UnionFind(n)
for i in range(m):
ans.append(a)
x,y = d[i]
if not que.same(x,y):
a -= que.size(x)*que.size(y)
que.union(x,y)
ans.reverse()
for tmp_a in ans:
print(tmp_a)
if __name__ == '__main__':
main()
| p03108 |
import sys
readline = sys.stdin.readline
N, M = map(int, input().split())
ab = [tuple(map(lambda x: int(x) - 1, readline().split())) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1] * size
self.number = [1] * 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]
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in ab[1:][::-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)
print(*ans[::-1], sep="\n")
| import sys
readline = sys.stdin.readline
N, M = map(int, input().split())
ab = [tuple(map(int, readline().split())) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1] * (size + 1)
self.number = [1] * (size + 1)
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]
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in ab[1:][::-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)
print(*ans[::-1], sep="\n")
| p03108 |
n, m = map(int, input().split())
ls = [list(map(int, input().split())) for _ in range(m)]
nodes = [[i, [i], 1] for i in range(n + 1)]
res = [n * (n - 1) // 2]
for a, b in reversed(ls):
x = nodes[a][0]
y = nodes[b][0]
if x == y:
res.append(res[-1])
else:
if x > y:
x, y = y, x
res.append(res[-1] - nodes[x][2] * nodes[y][2])
nodes[x][1] += nodes[y][1]
nodes[x][2] += nodes[y][2]
for z in nodes[x][1]:
nodes[z][0] = x
print(*reversed(res[:-1]), sep='\n')
| n, m = map(int, input().split())
ls = [list(map(int, input().split())) for _ in range(m)]
parents = list(range(n + 1))
ranks = [0 for _ in range(n + 1)]
def find(x):
if parents[x] == x:
return x
parents[x] = find(parents[x])
return parents[x]
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return
if ranks[x] < ranks[y]:
parents[x] = y
else:
parents[y] = x
if ranks[x] == ranks[y]:
ranks[x] += 1
res = [n * (n - 1) // 2]
nums = [1 for _ in range(n + 1)]
for a, b in reversed(ls):
aa = find(a)
bb = find(b)
if aa == bb:
res.append(res[-1])
else:
res.append(res[-1] - nums[aa] * nums[bb])
nums[aa] = nums[bb] = nums[aa] + nums[bb]
unite(aa, bb)
print(*reversed(res[:-1]), sep='\n')
| p03108 |
n, m = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
class UnionFind:
def __init__(self, n):
self.n = n
self.p = [e for e in range(n)]
self.rank = [0] * n
self.size = [1] * n
def same(self, u, v):
return self.find_set(u) == self.find_set(v)
def unite(self, u, v):
self.link(self.find_set(u), self.find_set(v))
def find_set(self, u):
if u != self.p[u]:
self.p[u] = self.find_set(self.p[u])
return self.p[u]
def link(self, u, v):
if self.rank[u] > self.rank[v]:
self.p[v] = u
self.size[u] += self.size[v]
else:
self.p[u] = v
self.size[v] += self.size[u]
if self.rank[u] == self.rank[v]:
self.rank[v] += 1
def update_p(self):
for u in range(self.n):
self.find_set(u)
def get_size(self, u):
return self.size[self.find_set(u)]
uf = UnionFind(n)
sm = n * (n - 1) // 2
ans = [sm]
for a, b in ab[-1:0:-1]:
a -= 1
b -= 1
if not uf.same(a, b):
sm -= uf.get_size(a) * uf.get_size(b)
uf.unite(a, b)
ans.append(sm)
print(*ans[::-1], sep="\n")
| n, m = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
class UnionFind:
def __init__(self, n):
self.n = n
self.p = [e for e in range(n)]
self.rank = [0] * n
self.size = [1] * n
def same(self, u, v):
return self.find_set(u) == self.find_set(v)
def unite(self, u, v):
u = self.find_set(u)
v = self.find_set(v)
if u == v:
return
if self.rank[u] > self.rank[v]:
self.p[v] = u
self.size[u] += self.size[v]
else:
self.p[u] = v
self.size[v] += self.size[u]
if self.rank[u] == self.rank[v]:
self.rank[v] += 1
def find_set(self, u):
if u != self.p[u]:
self.p[u] = self.find_set(self.p[u])
return self.p[u]
def update_p(self):
for u in range(self.n):
self.find_set(u)
def get_size(self, u):
return self.size[self.find_set(u)]
uf = UnionFind(n)
sm = n * (n - 1) // 2
ans = [sm]
for a, b in ab[-1:0:-1]:
a -= 1
b -= 1
if not uf.same(a, b):
sm -= uf.get_size(a) * uf.get_size(b)
uf.unite(a, b)
ans.append(sm)
print(*ans[::-1], sep="\n")
| p03108 |
(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
#print(A)
#print(B)
for i in range(M-1):
# print(parent)
j = M-1-i
bA, dA = boss(A[j])
bB, dB = boss(B[j])
# print(A[j],B[j],bA,bB)
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]))
| (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
def boss(n):
if parent[n] < 0:
return n
else:
b = boss(parent[n])
parent[n] = b
return b
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 = boss(A[j])
bB = boss(B[j])
if bA != bB:
if P[bA] < P[bB]:
(bA, bB) = (bB, bA)
parent[bB] = bA
S -= P[bA]*P[bB]
P[bA] += P[bB]
ans[j-1] = S
for i in range(M):
print((ans[i])) | p03108 |
N,M = [int(x) for x in input().split()]
map = [[0 for j in range(N+1)] for i in range(N+1)]
li_e = []
def dfs(v,li_gr,flg):
if(not flg[v]):
flg[v] = True
li_gr.append(v)
for u,exist in enumerate(map[v]):
if(exist == 1 and not flg[u]):
dfs(u,li_gr,flg)
for i in range(M):
A,B = [int(x) for x in input().split()]
map[A][B] = 1
map[B][A] = 1
li_e.append((A,B))
for i in range(M):
flg = [False]*(N+1)
li_gr = []
A = li_e[i][0]
B = li_e[i][1]
map[A][B] = 0
map[B][A] = 0
for j in range(1,N+1):
if(not flg[j]):
li_gr.append([])
dfs(j,li_gr[-1],flg)
ans = 0
grps = len(li_gr)
for p in range(grps):
for q in range(p+1,grps):
ans += len(li_gr[p])*len(li_gr[q])
print(ans)
| import sys
#sys.setrecursionlimit(1000000)
class UnionFind():
def __init__(self,n):
self.parent = [-1 for _ in range(n)]
def size(self,x):
return -self.parent[self.find(x)]
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 = self.find(x)
y = self.find(y)
if(x == y):
return False
if(self.size(x)<self.size(y)):
self.parent[y]+=self.parent[x]
self.parent[x]=y
else:
self.parent[x]+=self.parent[y]
self.parent[y]=x
return True
def same(self,x,y):
return self.find(x)==self.find(y)
N,M = [int(x) for x in input().split()]
A = [0]*M
B = [0]*M
ans = [0]*M
for i in range(M):
A[i],B[i] = [int(x) for x in input().split()]
ans[M-1] = int(N*(N-1)/2)
uni = UnionFind(N)
for i in range(M-1,0,-1):
ans[i-1]=ans[i]
if(not uni.same(A[i]-1,B[i]-1)):
ans[i-1]-=uni.size(A[i]-1)*uni.size(B[i]-1)
uni.unite(A[i]-1,B[i]-1)
for i in ans:
print(i)
| p03108 |
class UnionFind:
def __init__(self, n):
self.data=[-1 for i in range(n)]
def root(self,x):
if self.data[x]<0:
return x
else:
self.data[x]=self.root(self.data[x])
return self.data[x]
def uni(self,x,y):
x=self.root(x)
y=self.root(y)
if(x==y):
return
if self.data[y]<self.data[x]:
x,y=y,x
self.data[x]+= self.data[y]
self.data[y] = x
def same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return -self.data[self.root(x)]
n,m=map(int,input().split())
data=[]
for i in range(m):
a,b=map(int,input().split())
data.append((a,b))
data=data[::-1]
tmp=0
for i in range(n):
tmp+=i
ans=[tmp]
uf=UnionFind(n)
for i in range(m):
a,b=data[i]
if not uf.same(a-1,b-1):
x,y=uf.size(a-1),uf.size(b-1)
uf.uni(a-1,b-1)
ans.append(ans[-1]-x*y)
else:
ans.append(ans[-1])
print(*ans[:-1][::-1],sep='\n')
| import sys
sys.setrecursionlimit(100000)
input=lambda : sys.stdin.readline().rstrip('\n')
class UnionFind:
def __init__(self, n):
self.data=[-1 for i in range(n)]
def root(self,x):
if self.data[x]<0:
return x
else:
self.data[x]=self.root(self.data[x])
return self.data[x]
def uni(self,x,y):
x=self.root(x)
y=self.root(y)
if(x==y):
return
if self.data[y]<self.data[x]:
x,y=y,x
self.data[x]+= self.data[y]
self.data[y] = x
def same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return -self.data[self.root(x)]
n,m=map(int,input().split())
data=[]
for i in range(m):
a,b=map(int,input().split())
data.append((a,b))
data=data[::-1]
tmp=0
for i in range(n):
tmp+=i
ans=[tmp]
uf=UnionFind(n)
for i in range(m):
a,b=data[i]
if not uf.same(a-1,b-1):
x,y=uf.size(a-1),uf.size(b-1)
uf.uni(a-1,b-1)
ans.append(ans[-1]-x*y)
else:
ans.append(ans[-1])
print(*ans[:-1][::-1],sep='\n')
| p03108 |
N,M=map(int,input().split())
#Union-Find
par=[i for i in range(N)]
siz=[1 for _ in range(N)]
rank=[0 for _ in range(N)]
root=set()
def find(x):
if(par[x]==x):
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
a=find(a)
b=find(b)
if(a==b):
return 0
else:
if rank[a]>rank[b]:
par[b]=a
if b in root:
root.remove(b)
root.add(a)
siz[a]+=siz[b]
else:
par[a]=b
if a in root:
root.remove(a)
root.add(b)
siz[b]+=siz[a]
if rank[a]==rank[b]:
rank[b]+=1
def size(a):
return siz[find(a)]
def same(a,b):
return find(a)==find(b)
p=N*(N-1)//2
edge=[]
for i in range(M):
a,b=map(lambda x:int(x)-1,input().split())
edge.append([a,b])
ans=[p]
for i in reversed(range(1,M)):
res=0
union(edge[i][0],edge[i][1])
for x in root:
s=size(x)
res+=s*(s-1)//2
ans.append(max(p-res,0))
print(*ans[::-1],sep='\n')
| N,M=map(int,input().split())
#Union-Find
par=[i for i in range(N)]
siz=[1 for _ in range(N)]
rank=[0 for _ in range(N)]
root=set()
def find(x):
if(par[x]==x):
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
a=find(a)
b=find(b)
if(a==b):
return 0
else:
if rank[a]>rank[b]:
par[b]=a
if b in root:
root.remove(b)
root.add(a)
siz[a]+=siz[b]
else:
par[a]=b
if a in root:
root.remove(a)
root.add(b)
siz[b]+=siz[a]
if rank[a]==rank[b]:
rank[b]+=1
def size(a):
return siz[find(a)]
def same(a,b):
return find(a)==find(b)
edge=[]
for i in range(M):
a,b=map(lambda x:int(x)-1,input().split())
edge.append([a,b])
p=N*(N-1)//2
res=[p]
for i in reversed(range(1,M)):
if(not same(edge[i][0],edge[i][1])):
p=p-size(edge[i][0])*size(edge[i][1])
union(edge[i][0],edge[i][1])
res.append(p)
print(*res[::-1],sep='\n')
| p03108 |
import sys
from itertools import combinations
input = sys.stdin.readline
class UnionFind:
"""Union Find class.
"Path compression" and "Union by rank" are used.
References:
<https://en.wikipedia.org/wiki/Disjoint-set_data_structure>
"""
def __init__(self, N):
self.N = N
self.__make_set()
self.elem = {i: set([i]) for i in range(1, N + 1)}
def __make_set(self):
self.parent = list(range(self.N + 1))
self.rank = [0] * (self.N + 1)
def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
if x_root == y_root:
return
x_rank = self.rank[x_root]
y_rank = self.rank[y_root]
if x_rank > y_rank:
self.parent[y_root] = x_root
self.union_elem(y_root, x_root)
elif x_rank < y_rank:
self.parent[x_root] = y_root
self.union_elem(x_root, y_root)
else:
self.parent[y_root] = x_root
self.rank[x_root] += 1
self.union_elem(y_root, x_root)
def union_elem(self, src_root, dst_root):
self.elem[dst_root] |= self.elem[src_root]
del self.elem[src_root]
def elem_counts(self):
return [len(s) for s in list(self.elem.values())]
def main():
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()))
uf = UnionFind(N)
ans = [0] * M
for i in reversed(list(range(M))):
ans[i] = sum(a * b for a, b in combinations(uf.elem_counts(), r=2))
uf.union(A[i], B[i])
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| import sys
from itertools import combinations
input = sys.stdin.readline
class UnionFind:
"""Union Find class.
"Path compression" and "Union by rank" are used.
References:
<https://en.wikipedia.org/wiki/Disjoint-set_data_structure>
"""
def __init__(self, N):
self.N = N
self.__make_set()
def __make_set(self):
self._parent = list(range(self.N + 1))
self._rank = [0] * (self.N + 1)
self._size = [1] * (self.N + 1)
def find(self, x):
if self._parent[x] != x:
self._parent[x] = self.find(self._parent[x])
return self._parent[x]
def union(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
if x_root == y_root:
return
x_rank = self._rank[x_root]
y_rank = self._rank[y_root]
if x_rank > y_rank:
self._parent[y_root] = x_root
self._size[x_root] += self._size[y_root]
elif x_rank < y_rank:
self._parent[x_root] = y_root
self._size[y_root] += self._size[x_root]
else:
self._parent[y_root] = x_root
self._rank[x_root] += 1
self._size[x_root] += self._size[y_root]
def same_set(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self._size[self.find(x)]
def main():
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()))
uf = UnionFind(N)
ans = [0] * M
ans[-1] = N * (N - 1) // 2
for i in reversed(list(range(M - 1))):
a, b = A[i + 1], B[i + 1]
if uf.same_set(a, b):
ans[i] = ans[i + 1]
else:
ans[i] = ans[i + 1] - uf.size(a) * uf.size(b)
uf.union(a, b)
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| p03108 |
# 逆順に見ていく
# M本の橋が全て崩落した状態=全ての島が行き来できない=不便さ:N*(N-1)//2
# 橋ができたら、UnionFindで一つに島グループとしてつなぐ
# 新たにできた橋が、今まで別の島グループだったときは
# 二つの島グループの間の組み合わせの数だけ不便さが減る
# 島グループ1の数 * 島グループ2の数だけ不便さが減る
# 新たにできた島グループが同じ島グループだったときは何も変わらない
import sys
readline=sys.stdin.readline
# 0-indexed
class UnionFind:
N=0
parent=None
size=None
def __init__(self,N):
self.N=N
self.parent=[i for i in range(self.N)]
self.size=[1]*self.N
def root(self,x):
while x!=self.parent[x]:
self.parent[x]=self.parent[self.parent[x]]
x=self.parent[x]
return 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.size[x]>self.size[y]:
# 大きい方にくっつける
self.parent[y]=x
self.size[x]+=self.size[y]
else:
self.parent[x]=y
self.size[y]+=self.size[x]
def get_group_size(self,x):
return self.size[self.root(x)]
def get_roots(self):
r=set()
for i in range(self.N):
r.add(root(i))
return r
def show_parent(self):
print((self.parent))
def show_size(self):
print((self.size))
N,M=list(map(int,readline().split()))
UF=UnionFind(N)
ans=[N*(N-1)//2]
decay=[None]*M
for i in range(M):
a,b=list(map(int,readline().split()))
decay[M-1-i]=[a-1,b-1]
# decayは逆順になっている
for i in range(M):
a,b=decay[i]
if UF.same(a,b):
ans+=[ans[-1]]
else:
asize=UF.get_group_size(a)
bsize=UF.get_group_size(b)
ans+=[ans[-1]-asize*bsize]
UF.unite(a,b)
for i in range(len(ans)-2,-1,-1):
print((ans[i]))
| import sys
readline = sys.stdin.readline
class UnionFind:
N=0
parent=None
size=None
def __init__(self,N):
self.N=N
self.parent=[i for i in range(self.N)]
self.size=[1]*self.N
def root(self,x):
while x!=self.parent[x]:
self.parent[x]=self.parent[self.parent[x]]
x=self.parent[x]
return 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.size[x]>self.size[y]:
# 大きい方にくっつける
self.parent[y]=x
self.size[x]+=self.size[y]
else:
self.parent[x]=y
self.size[y]+=self.size[x]
def get_group_size(self,x):
return self.size[self.root(x)]
def get_roots(self):
r=set()
for i in range(self.N):
r.add(self.root(i))
return r
def show_parent(self):
print(self.parent)
def show_size(self):
print(self.size)
N,M = map(int,readline().split())
bridges = [tuple(map(int,readline().split())) for i in range(M)]
# 順に崩落していく = 最後に崩落するものから順に建設されていくと考える
# 最初の不便さは(N * (N - 1)) // 2
# 新たにa,bの間に橋が繋がると、[aが属していた島々 * bが属していた島々]だけ不便さが減る
UF = UnionFind(N)
ans = [0] * M
num = (N * (N - 1)) // 2
for i in range(len(bridges) - 1, -1, -1):
ans[i] = num
a,b = bridges[i]
a,b = a - 1,b - 1
if not UF.same(a,b):
num -= UF.get_group_size(a) * UF.get_group_size(b)
UF.unite(a,b)
print(*ans, sep = "\n")
| p03108 |
import sys
sys.setrecursionlimit(65536)
N,M=list(map(int, input().split()))
bridge=[[int(x) for x in input().split()] for _ in range(M)]
uf=[i for i in range(N+1)]
nc=[1 for i in range(N+1)]
def find(i):
if uf[i] == i:
return i
else:
uf[i] = find(uf[i])
return uf[i]
def union(i, j):
gi, gj = find(i), find(j)
if gi != gj:
uf[gi] = gj
diff = nc[gj] * nc[gi]
nc[gj] += nc[gi]
return diff
return 0
su = N*(N-1)//2
ans = [-1]*M
for i in range(M-1, -1, -1):
ans[i] = su
x,y = bridge[i]
su -= union(x, y)
for p in ans:
print(p)
| import sys
sys.setrecursionlimit(65536)
N,M=list(map(int, input().split()))
bridge=[[int(x) for x in input().split()] for _ in range(M)]
uf=[i for i in range(N+1)]
nc=[1 for i in range(N+1)]
def find(i):
if uf[i] == i:
return i
else:
uf[i] = find(uf[i])
return uf[i]
def union(i, j):
gi, gj = find(i), find(j)
if gi != gj:
uf[gi] = gj
diff = nc[gj] * nc[gi]
nc[gj] += nc[gi]
return diff
return 0
su = N*(N-1)//2
ans = [-1]*M
for i in range(M-1, -1, -1):
ans[i] = su
x,y = bridge[i]
su -= union(x, y)
print(("\n".join(map(str, ans))))
| p03108 |
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()))
d = [0]*(n+1)
for i in range(1,n+1):
d[i] = i
s = [0] + [1]*n
g=[ [0] ]*(n+1)
for i in range(1,n+1):
g[i] = [i]
g[0] = []
#print(g)
#quit()
c = n*(n-1)//2
ans = []
ans.append(c)
for i in range(1,m)[::-1]:
x = d[a[i]]
y = d[b[i]]
x,y = max(x,y),min(x,y)
if x == y:
ans.append(c)
continue
c -= s[x]*s[y]
#print(c, "x")
ans.append(c)
s[x] += s[y]
#s[y] = 0
for i in g[y]:
d[i] = x
g[x] += g[y]
#g[y] = []
for t in ans[::-1]:
print(t)
| 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()))
d = [0]*(n+1)
for i in range(1,n+1):
d[i] = i
g=[ [0] ]*(n+1)
for i in range(1,n+1):
g[i] = [i]
g[0] = []
#print(g)
#quit()
c = n*(n-1)//2
ans = []
ans.append(c)
for i in range(1,m)[::-1]:
x = d[a[i]]
y = d[b[i]]
x,y = max(x,y),min(x,y)
if x == y:
ans.append(c)
continue
c -= len(g[x])*len(g[y])
ans.append(c)
for i in g[y]:
d[i] = x
g[x] += g[y]
for t in ans[::-1]:
print(t)
| p03108 |
import queue
n, m = list(map(int, input().split()))
bridges = [list(map(int, input().split())) for _ in range(m)]
nodes = [[] for _ in range(n)] # いける島のリスト
ans = n*(n-1)//2
ans_list = []
q = queue.Queue()
for i in range(m):
ans_list.append(ans)
# 順番に橋をかけていく
a, b = bridges[-(i+1)]
if not a in nodes[b-1]:
nodes[b-1].append(a)
nodes[a-1].append(b)
ans -= 1
q.put((a,b))
q.put((b,a))
while not q.empty():
# print(nodes)
a,b = list(map(int, q.get()))
for j in nodes[a-1]:
if not j in nodes[b-1] and j != b:
nodes[b-1].append(j)
nodes[j-1].append(b)
ans -= 1
q.put((j,b))
for j in nodes[b-1]:
if not j in nodes[a-1] and j != a:
nodes[a-1].append(j)
nodes[j-1].append(a)
ans -= 1
q.put((j,a))
# print(nodes)
for i in range(m):
print((ans_list[-i-1]))
| class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
n, m = list(map(int, input().split()))
bridges = [list(map(int, input().split())) for _ in range(m)]
nodes = [[] for _ in range(n)] # いける島のリスト
ans = n*(n-1)//2
ans_list = []
u = UnionFind(n)
for i in range(m):
ans_list.append(ans)
# 順番に橋をかけていく
a, b = bridges[-(i+1)]
if u.isSameGroup(a, b):
continue
else:
ans -= u.Count(a)*u.Count(b)
u.Unite(a, b)
# print(nodes)
for i in range(m):
print((ans_list[-i-1]))
| p03108 |
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
class UfNode():
def __init__(self, id):
self.parent = None
self.id = id
self._size = 1
@property
def size(self):
if not self.parent:
return self._size
else:
return self.root()._size
def root(self):
if not self.parent:
return self
else:
return self.parent.root()
def sizeup(self, n):
if not self.parent:
self._size += n
else:
self.root().sizeup(n)
def unite(self, target):
sr = self.root().id
tr = target.root().id
if sr == tr:
return False
elif sr > tr:
target.sizeup(self.size)
self.root().parent = target.root()
else:
self.sizeup(target.size)
target.root().parent = self.root()
class UfTree():
def __init__(self, maxnum):
self.parent = [None for _ in range(maxnum)]
self._size = [1 for _ in range(maxnum)]
self.rank = [0 for _ in range(maxnum)]
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
path = []
while True:
if self.parent[cur] is None:
for i in path: # 経路圧縮
self.parent[i] = cur
return cur
else:
path.append(cur)
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
rra = self.rank[ra]
rrb = self.rank[rb]
if rra <= rrb:
r1, r2 = ra, rb
if rra == rrb:
self.rank[ra] += 1
else:
r1, r2 = rb, ra
self._size[r1] += self._size[r2]
self.parent[r2] = r1 # r1のほうが根になる
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
nroot = {}
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
if __name__ == "__main__":
main()
| mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
class UfNode():
def __init__(self, id):
self.parent = None
self.id = id
self._size = 1
@property
def size(self):
if not self.parent:
return self._size
else:
return self.root()._size
def root(self):
if not self.parent:
return self
else:
return self.parent.root()
def sizeup(self, n):
if not self.parent:
self._size += n
else:
self.root().sizeup(n)
def unite(self, target):
sr = self.root().id
tr = target.root().id
if sr == tr:
return False
elif sr > tr:
target.sizeup(self.size)
self.root().parent = target.root()
else:
self.sizeup(target.size)
target.root().parent = self.root()
class UfTree():
def __init__(self, maxnum):
self.parent = [None for _ in range(maxnum)]
self._size = [1 for _ in range(maxnum)]
self.rank = [0 for _ in range(maxnum)]
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
path = []
while True:
if self.parent[cur] is None:
for i in path: # 経路圧縮
self.parent[i] = cur
return cur
else:
path.append(cur)
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra # r1のほうが根になる
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
nroot = {}
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
if __name__ == "__main__":
main()
| p03108 |
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = [None for _ in range(maxnum)]
self._size = [1 for _ in range(maxnum)]
self.rank = [0 for _ in range(maxnum)]
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
path = []
while True:
if self.parent[cur] is None:
for i in path: # 経路圧縮
self.parent[i] = cur
return cur
else:
path.append(cur)
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| p03108 |
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
import time
from bisect import bisect_left, insort_left, bisect_right
import sys
input = sys.stdin.readline
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| p03108 |
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
import time
from bisect import bisect_left, insort_left, bisect_right
import sys
input = sys.stdin.readline
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().rstrip().split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq
import time
from bisect import bisect_left, insort_left, bisect_right
import sys
input = sys.stdin.readline
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is True or ans is False:
YesNo(ans)
elif ans is not None:
print(ans)
def solve():
N, M = iip(False)
AB = iipt(M)
AB.reverse()
uf = UfTree(N)
benlist = [0]
cur = 0
for a, b in AB:
a -= 1
b -= 1
c1 = uf.size(a)
c2 = uf.size(b)
uf.unite(a, b)
if c2 != uf.size(a):
cur += c1*c2
benlist.append(cur)
t = benlist.pop()
benlist.reverse()
#print(benlist)
ans = [t - i for i in benlist]
split_print_enter(ans)
#####################################################ライブラリ集ここから
def kiriage_warizan(a, b):
return -(-a//b)
def iip(listed=True): # 数字のinputをlistで受け取る
d = input().rstrip("\n").split()
try:
ret = [int(i) for i in d]
except:
ret = [int(i) if i in _NUMINT_ALL else i for i in d]
if len(ret) == 1:
return ret[0]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only=True): # 縦向きに並んでいるデータをリストに落とし込む(iip利用)
ret = []
for i in range(l):
ret.append(iip(listed=listed))
return ret
def saidai_kouyakusuu(A): # 最大公約数
l = len(A)
while True:
m = min(A)
mx = max(A)
if m == mx:
return m
for i in range(l):
if A[i] % m == 0:
A[i] = m
else:
A[i] %= m
def make_graph_edge_flat(N): # グラフ作成のための辺をリストで返す
ret = []
for i in range(N-1):
a, b, c = iip()
a -= 1
b -= 1
ret[a].append((b, c))
ret[b].append((a, c))
return ret
def sort_tuples(l, index): # タプルのリストを特定のインデックスでソートする
if isinstance(l, list):
l.sort(key=lambda x: x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x: x[index])
def count_elements(l): # リストの中身の個数を種類分けして辞書で返す
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def safeget(l, index, default="exception"): # listの中身を取り出す時、listからはみ出たり
if index >= len(l): # マイナスインデックスになったりするのを防ぐ
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。配列の長さは", len(l), "です"]))
else:
return default
elif index < 0:
if default == "exception":
raise Exception("".join(["safegetに不正な値 ", index, "が渡されました。負の値は許可されていません"]))
else:
return default
else:
return l[index]
def sortstr(s): # 文字列をソートする
return "".join(sorted(s))
def iip_ord(startcode="a"): # 文字列を数字の列に変換する(数字と文字は1:1対応)
if isinstance(startcode, str):
startcode = ord(startcode)
return [ord(i) - startcode for i in eval(input())]
def YesNo(s): # TrueFalseや1, 0をYesNoに変換する
if s:
print("Yes")
else:
print("No")
def fprint(s): # リストを平たくしてprintする(二次元リストを見やすくしたりとか)
for i in s:
print(i)
def bitall(N): # ビット全探索用のインデックスを出力
ret = []
for i in range(2 ** N):
a = []
for j in range(N):
a.append(i % 2)
i //= 2
ret.append(a)
return ret
def split_print_space(s): # リストの中身をスペース区切りで出力する
print((" ".join([str(i) for i in s])))
def split_print_enter(s): # リストの中身を改行区切りで出力する
print(("\n".join([str(i) for i in s])))
def soinsuu_bunkai(n): # 素因数分解
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False): # nCrをmodを使って計算する
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod): # modnにおける逆元を計算
return power(n, mod - 2)
def power(n, p, mod_=mod): # 繰り返し二乗法でn**p % modを計算
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
def nibutan_func(func, target, left, right, side="left"): # 関数を二分探索
l = left
r = right
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if func(x) == target:
return x
elif func(x) > target:
r = x
else:
l = x
if side == "left" or func(x) == target:
return l
else:
return r
def nibutan_list(list_, target, side="left"): # リストを二分探索
if not isinstance(list_, list):
list_ = list(list_)
l = 0
r = len(list_)
x = (l + r) // 2
while r-l > 1:
x = (l+r)//2
if list_[x] == target:
return x
elif list_[x] > target:
r = x
else:
l = x
if side == "left" or list_[x] == target:
return l
else:
return r
class UfTree():
def __init__(self, maxnum):
self.parent = list(range(maxnum))
self._size = [1] * maxnum
self.rank = [0] * maxnum
def size(self, a):
return self._size[self.root(a)]
def root(self, a):
rank = 0
cur = a
while True:
if self.parent[cur] == cur:
#for i in path: # 経路圧縮
# self.parent[i] = cur
return cur
else:
self.parent[cur] = self.parent[self.parent[cur]]
cur = self.parent[cur]
rank += 1
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return self
self._size[ra] += self._size[rb]
self.parent[rb] = ra
return self
if __name__ == "__main__":
main()
| p03108 |
N, M = [int(x) for x in input().split()]
bridge = [[int(x) for x in input().split()] for x in range(M)]
par = [int(x) for x in range(N+1)] # 所属グループ
gn = [1 for _ in range(N+1)]
def group(i):
if par[i] == i:
return i
else:
return group(par[i])
def group_num(i): # order(NlogN)?
counter = 0
for j in range(N+1):
if group(j) == i:
counter += 1
return counter
ans = [int(N*(N-1)/2)]
for i, b in enumerate(bridge[::-1]): # O(M)
g0 = group(b[0])
g1 = group(b[1])
# print(i)
if g0 > g1:
ans.append(int(ans[-1] - gn[g0]*gn[g1]))
par[g0] = g1
gn[g1] += gn[g0]
gn[g0] = 0
par[g0] = g1
elif g0 < g1:
ans.append(int(ans[-1] - gn[g0]*gn[g1]))
par[g1] = g0
gn[g0] += gn[g1]
gn[g1] = 0
else:
ans.append(ans[-1])
# print(par)
# print([group(x) for x in par])
for x in ans[::-1][1:]:
print(x)
| N, M = [int(x) for x in input().split()]
bridge = [[int(x) for x in input().split()] for x in range(M)]
par = [int(x) for x in range(N+1)] # 所属グループ
gn = [1 for _ in range(N+1)] # 各グループサイズ
def group(i):
if par[i] == i:
return i
else:
par[i] = group(par[i])
return par[i]
ans = [int(N*(N-1)/2)]
for i, b in enumerate(bridge[::-1]): # O(M)
g0 = group(b[0])
g1 = group(b[1])
if g0 > g1:
ans.append(int(ans[-1] - gn[g0]*gn[g1]))
par[g0] = g1
gn[g1] += gn[g0]
gn[g0] = 0
elif g0 < g1:
ans.append(int(ans[-1] - gn[g0]*gn[g1]))
par[g1] = g0
gn[g0] += gn[g1]
gn[g1] = 0
else:
ans.append(ans[-1])
for x in ans[::-1][1:]:
print(x)
| p03108 |
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.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)
s = n*(n-1)//2
ans = [0]*m
for i in range(m-1,-1,-1):
if uf.find(ab[i][0]-1) != uf.find(ab[i][1]-1):
s -= uf.size(ab[i][0]-1)*uf.size(ab[i][1]-1)
uf.union(ab[i][0]-1,ab[i][1]-1)
ans[i-1] = s
ans[m-1] = n*(n-1)//2
for i in ans:
print(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)
q = []
for i in range(m):
a,b = list(map(int,input().split()))
q.append([a-1,b-1])
ans = n*(n-1)//2
l = []
for i in range(m-1,-1,-1):
a,b = q[i]
l.append(ans)
if not uf.same(a,b):
ans -= uf.size(a)*uf.size(b)
uf.union(a,b)
for i in l[::-1]:
print(i) | p03108 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
class UnionFind:
# Reference: https://note.nkmk.me/python-union-find/
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 main():
N, M, *AB = map(int, read().split())
count = N * (N - 1) // 2
ans = [count]
uf = UnionFind(N)
for a, b in zip(reversed(AB[::2]), reversed(AB[1::2])):
a -= 1
b -= 1
if not uf.same(a, b):
count -= uf.size(a) * uf.size(b)
uf.union(a, b)
ans.append(count)
print(*reversed(ans[:-1]), sep='\n')
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
class UnionFind:
# Reference: https://note.nkmk.me/python-union-find/
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 main():
N, M, *AB = map(int, read().split())
AB = list(reversed(AB[2:]))
count = N * (N - 1) // 2
ans = [count]
uf = UnionFind(N)
for a, b in zip(AB[::2], AB[1::2]):
a -= 1
b -= 1
if not uf.same(a, b):
count -= uf.size(a) * uf.size(b)
uf.union(a, b)
ans.append(count)
print('\n'.join(map(str, reversed(ans))), sep='\n')
return
if __name__ == '__main__':
main()
| p03108 |
n,m=map(int,input().split())
A=[]
par=[-1]*n
def find(x):
if par[x]<0:
return x
else:
par[x]=find(par[x])
return par[x]
def unite(x,y):
x=find(x)
y=find(y)
if x==y:
return False
else:
if par[x]>par[y]:
x,y=y,x
par[x]+=par[y]
par[y]=x
return True
def same(x,y):
return find(x)==find(y)
def size(x):
return -par[find(x)]
for i in range(m):
a,b=map(int,input().split())
A.append([a,b])
A=A[::-1]
ans=n*(n-1)//2
Ans=[ans]
for i in range(m):
a,b=A[i]
if not same(a-1,b-1):
ans-=(size(a-1)*size(b-1))
Ans.append(ans)
unite(a-1,b-1)
Ans=Ans[::-1][1:]
print(*Ans,sep="\n")
| import sys
input=lambda: sys.stdin.readline().rstrip()
n,m=list(map(int,input().split()))
par=[-1]*n
def find(x):
if par[x]<0:
return x
else:
par[x]=find(par[x])
return par[x]
def unite(x,y):
x=find(x)
y=find(y)
if x==y:
return False
else:
if par[x]>par[y]:
x,y=y,x
par[x]+=par[y]
par[y]=x
return True
def same(x,y):
return find(x)==find(y)
def size(x):
return -par[find(x)]
AB=[]
for i in range(m):
AB.append(tuple(int(i)-1 for i in input().split()))
Ans=[n*(n-1)//2]
for i in range(m)[::-1]:
a,b=AB[i]
if same(a,b):
Ans.append(Ans[-1])
else:
Ans.append(Ans[-1]-size(a)*size(b))
unite(a,b)
Ans=Ans[::-1][1:]
for a in Ans:
print(a) | 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=[list(map(int,input().split())) for i in range(m)]
ans=[]
ans.append(n*(n-1)//2)
uf=UnionFind(n)
for a,b in ab[::-1]:
if not uf.same(a-1,b-1):
sizea=uf.size(a-1)
sizeb=uf.size(b-1)
ans.append(ans[-1]-sizea*sizeb)
else:
ans.append(ans[-1])
uf.union(a-1,b-1)
for i in ans[::-1][1:]:
print(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()))
ab = []
uf = UnionFind(n+1)
for i in range(m):
a,b = list(map(int, input().split()))
ab.append((a,b))
ans = []
huben = n*(n-1)//2
for a,b in ab[::-1]:
ans.append(huben)
if not uf.same(a,b):
huben -= uf.size(a)*uf.size(b)
uf.union(a,b)
for aa in ans[::-1]:
print(aa) | p03108 |
# ユニオンファインド
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def cmb(n, r):
if (r < 0 or r > n):
return 0
r=min(r,n-r)
return g1[n] * g2[r] * g2[n - r] % mod
def comb(n):
x=1
y=1
for i in range(2):
x*=(n-i)
y*=(i+1)
return x//y
n,m = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(m)]
b = [[] for i in range(n)]
uf = UnionFind(n)
ans=[]
x=comb(n)
for i in range(m):
ans.append(x)
if uf.same(a[m-i-1][0]-1,a[m-i-1][1]-1):
uf.union(a[m-i-1][0]-1,a[m-i-1][1]-1)
else:
x-=uf.size(a[m-i-1][0]-1)*uf.size(a[m-i-1][1]-1)
uf.union(a[m-i-1][0]-1,a[m-i-1][1]-1)
for i in range(m):
print((ans[-1-i])) | import sys
input = sys.stdin.readline
# ユニオンファインド
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m= list(map(int, input().split()))
a= [list(map(int, input().split())) for i in range(m)]
uf = UnionFind(n)
ans1=[n*(n-1)//2]
ans=n*(n-1)//2
for i in range(m-1,0,-1):
a[i][0]-=1
a[i][1]-=1
x=uf.size(a[i][0])
z=uf.size(a[i][1])
uf.union(a[i][0],a[i][1])
y=uf.size(a[i][0])
if x==y:
ans1.append(ans)
else:
ans-=(y*(y-1)-x*(x-1)-z*(z-1))//2
ans1.append(ans)
ans1.sort()
for i in ans1:
print(i) | p03108 |
class UnionFind:
def __init__(self, n):
self.n = n
self.par = [-1 for _ in range(n)]
#マイナスが根を表す
#数字はグループのノード数（サイズ）を表す
#初期状態では、全てのノードが根で、サイズは1
def same(self, x, y):
return self.root(x)==self.root(y)
def root(self, x):
if self.par[x]<0:
return x
self.par[x] = self.root(self.par[x])
#再帰的に根を求め、根に直接繋いで高速化（辺の縮約）
return self.par[x]
def unite(self,x,y):
x = self.root(x)
y = self.root(y)
if x == y:
return
if self.par[x] > self.par[y]:
x,y = y,x
#木のバランスに偏りが生じると計算量が増えるので、
#サイズが小さいグループを大きいグループの下に繋げる
self.par[x] += self.par[y]
#下に繋ぐグループのサイズを上のグループに加算
self.par[y] = x
#親を更新
def size(self,x):
return -self.par[self.root(x)]
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab.reverse()
uf = UnionFind(n)
res = []
tmp = n * (n - 1) // 2
#全く繋がっていない状態からスタート（逆算していく方が簡単）
for a,b in ab:
res.append(tmp)
a -= 1
b -= 1
if uf.same(a,b):
continue
sa = uf.size(a)
sb = uf.size(b)
tmp -= sa * sb
#aとbを繋げることで、aグループのサイズ * bグループのサイズの島の組が新たに行き来可能となる
uf.unite(a,b)
res.reverse()
#本来の順番に戻す
for r in res:
print(r) | n, m = list(map(int, input().split()))
AB = [[int(i) for i in input().split()] for i in range(m)]
class UnionFind:
def __init__(self, n):
self.n = n
self.par = [-1 for _ in range(n)]
def same(self, x, y):
return self.root(x)==self.root(y)
def root(self, x):
if self.par[x]<0:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self,x,y):
x = self.root(x)
y = self.root(y)
if x == y:
return
if self.par[x] > self.par[y]:
x,y = y,x
self.par[x] += self.par[y]
self.par[y] = x
def size(self,x):
return -self.par[self.root(x)]
uf = UnionFind(n)
C = []
tmp = n * (n - 1) // 2
for i in range(m - 1, -1, -1):
C.append(tmp)
a, b = AB[i]
a -= 1
b -= 1
if uf.same(a, b):
continue
else:
tmp -= uf.size(a) * uf.size(b)
uf.unite(a, b)
#print(C)
C.reverse()
for c in C:
print(c) | p03108 |
N,M=list(map(int,input().split()))
AB=[[0,0] for i in range(M)]
for i in range(M):
AB[i][0],AB[i][1]=list(map(int,input().split()))
par=[i for i in range(N+1)]
rank=[1 for i in range(N+1)]
def Union_Find_find(x):
global par
if par[x]==x:
return x
else:
return Union_Find_find(par[x])
def Union_Find_unite(x,y):
global par
x=Union_Find_find(x)
y=Union_Find_find(y)
if x!=y:
par[y]=x
rank[x]=rank[x]+rank[y]
rank[y]=1
for p in range(len(par)):
if par[p]==y:
par[p]=x
def Union_Find_same(x,y):
global par
return Union_Find_find(x)==Union_Find_find(y)
def ncr(n):
return n*(n-1)//2
res=[]
res.append(ncr(N))
for i in reversed(list(range(M))):
A,B=AB[i][0],AB[i][1]
if res[-1]!=0:
if not(Union_Find_same(A,B)):
res.append(res[-1]-rank[par[A]]*rank[par[B]])
Union_Find_unite(A,B)
else:
res.append(res[-1])
if res[-1]==0:
res.append(0)
for i in reversed(list(range(M))):
print((res[i]))
| N,M=list(map(int,input().split()))
AB=[[0,0] for i in range(M)]
for i in range(M):
AB[i][0],AB[i][1]=list(map(int,input().split()))
par=[i for i in range(N+1)]
rank=[1 for i in range(N+1)]
hight=[1 for i in range(N+1)]
def Union_Find_find(x):
global par,rank,hight
if par[x]==x:
return x
else:
return Union_Find_find(par[x])
def Union_Find_unite(x,y):
global par,rank,hight
x=Union_Find_find(x)
y=Union_Find_find(y)
if x!=y:
if hight[x]>hight[y]:
par[y]=x
rank[x]=rank[x]+rank[y]
rank[y]=rank[x]
else:
par[x]=y
rank[x]=rank[x]+rank[y]
rank[y]=rank[x]
if hight[x]==hight[y]:
hight[y]+=1
def Union_Find_same(x,y):
global par,rank,hight
return Union_Find_find(x)==Union_Find_find(y)
def ncr(n):
return n*(n-1)//2
res=[]
res.append(ncr(N))
for i in reversed(list(range(M))):
A,B=AB[i][0],AB[i][1]
if res[-1]!=0:
if Union_Find_same(A,B):
res.append(res[-1])
else:
res.append(res[-1]-rank[Union_Find_find(A)]*rank[Union_Find_find(B)])
Union_Find_unite(A,B)
else:
res.append(0)
for i in reversed(list(range(M))):
print((res[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())
def combinations_count(n, r):
if n<=1:
return 0
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
import math
from collections import deque
n, m = list(map(int, input().split()))
ms = [list(map(int, input().split())) for _ in range(m)]
ms.reverse()
combs = combinations_count(n, 2)
res = deque([combs])
uf = UnionFind(n)
for i in ms[:-1]:
size_l = uf.size(i[0]-1)
size_r = uf.size(i[1]-1)
uf.union(i[0]-1,i[1]-1)
size_n = uf.size(i[0]-1)
tmp = 0
if not (size_l==size_r==size_n):
combs -= combinations_count(size_n, 2) - combinations_count(size_l, 2) - combinations_count(size_r, 2)
res.appendleft(combs)
else:
res.appendleft(combs)
for i in res:
print(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())
def combinations_count(n, r):
if n<=1:
return 0
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
import math
from collections import deque
n, m = list(map(int, input().split()))
ms = [list(map(int, input().split())) for _ in range(m)]
ms.reverse()
combs = combinations_count(n, 2)
res = deque([combs])
uf = UnionFind(n)
for i in ms[:-1]:
if not (uf.same(i[0]-1,i[1]-1)):
combs -= uf.size(i[0]-1)*uf.size(i[1]-1)
res.appendleft(combs)
uf.union(i[0] - 1, i[1] - 1)
for i in res:
print(i) | p03108 |
import sys
sys.setrecursionlimit(99999)
def find_index_by_value(a, val):
for i, items in enumerate(a):
if val in items:
return i
return -1
def num_reachable(n):
return n * (n - 1) // 2
n, m = list(map(int, input().split()))
edges = []
for _ in range(m):
a, b = list(map(int, input().split()))
edges.append((a, b))
size = [1 for _ in range(n + 1)]
group = [i for i in range(n + 1)]
find_group = lambda x: x if x == group[x] else find_group(group[x])
ans = []
not_reachable = n * (n - 1) // 2
reachable_node = []
ans.append(not_reachable)
count = not_reachable
reachable = 0
for _ in range(m - 1):
a, b = edges.pop()
if count > 0:
ra = find_group(a)
rb = find_group(b)
if rb != ra:
s_ra = size[ra]
s_rb = size[rb]
new_size = s_ra + s_rb
reachable += num_reachable(new_size) - num_reachable(s_ra) - num_reachable(s_rb)
size[ra] = new_size
group[rb] = ra
count = not_reachable - reachable
ans.append(count)
for _ in range(len(ans)):
print((ans.pop()))
| def find_index_by_value(a, val):
for i, items in enumerate(a):
if val in items:
return i
return -1
def num_reachable(n):
return n * (n - 1) // 2
n, m = list(map(int, input().split()))
edges = []
for _ in range(m):
a, b = list(map(int, input().split()))
edges.append((a, b))
size = [1 for _ in range(n + 1)]
group = [i for i in range(n + 1)]
def find_group(x):
c = []
p = x
while True:
pp = group[p]
if pp == p:
break
else:
c.append(p)
p = pp
for i in c:
group[i] = pp
return pp
# find_group = lambda x: x if x == group[x] else find_group(group[x])
ans = []
not_reachable = n * (n - 1) // 2
reachable_node = []
ans.append(not_reachable)
count = not_reachable
reachable = 0
for _ in range(m - 1):
a, b = edges.pop()
if count > 0:
ra = find_group(a)
rb = find_group(b)
if rb != ra:
s_ra = size[ra]
s_rb = size[rb]
new_size = s_ra + s_rb
reachable += num_reachable(new_size) - num_reachable(s_ra) - num_reachable(s_rb)
size[ra] = new_size
group[rb] = ra
count = not_reachable - reachable
ans.append(count)
for _ in range(len(ans)):
print((ans.pop())) | p03108 |
import sys
input = sys.stdin.readline
def comb(n,r):
r = min(r,n-r)
result = 1
for i in range(n-r+1,n+1):
result *= i
for i in range(1,r+1):
result //= i
return result
class Unionfind:
__slots__ = ['nodes']
def __init__(self, n):
self.nodes = [-1]*n
def root(self, x):
if self.nodes[x] < 0:
return x
else:
root_x = self.root(self.nodes[x])
self.nodes[x] = root_x
return root_x
def unite(self, x, y):
x = self.root(x); y = self.root(y)
if x == y:
return
rank_x = -self.nodes[x]; rank_y = -self.nodes[y]
if rank_x < rank_y:
x, y = y, x
self.nodes[x] += self.nodes[y]
self.nodes[y] = x
def same(self, x, y):
return self.root(x) == self.root(y)
def rank(self, x):
return -self.nodes[self.root(x)]
N,M = list(map(int,input().split()))
info = [list(map(int,input().split())) for i in range(M)]
uf = Unionfind(N)
ans_list = [comb(N,2)]
ans = comb(N,2)
for A,B in info[:0:-1]:
A -= 1; B -= 1
if not uf.same(A,B):
ans -= uf.rank(A) * uf.rank(B)
uf.unite(A,B)
ans_list.append(ans)
for e in ans_list[::-1]:
print(e) | import sys
input = sys.stdin.readline
# 組み合わせ n_C_r
def comb(n,r):
r = min(r,n-r)
result = 1
for i in range(n-r+1,n+1):
result *= i
for i in range(1,r+1):
result //= i
return result
class Unionfind:
__slots__ = ['nodes','size']
def __init__(self, n):
self.nodes = list(range(n))
self.size = [1]*n
def root(self, x):
if self.nodes[x] == x:
return x
else:
root_x = self.root(self.nodes[x])
self.nodes[x] = root_x
return root_x
def unite(self, x, y):
x = self.root(x); y = self.root(y)
if x == y:
return
if self.size[x] < self.size[y]:
x, y = y, x
self.size[x] += self.size[y]
self.nodes[y] = x
def same(self, x, y):
return self.root(x) == self.root(y)
N,M = list(map(int,input().split()))
info = [[int(e)-1 for e in input().split()] for _ in range(M)]
uf = Unionfind(N)
out = []
ans = comb(N,2)
out.append(ans)
for A,B in info[::-1]:
if not uf.same(A,B):
ans -= uf.size[uf.root(A)] * uf.size[uf.root(B)]
uf.unite(A,B)
out.append(ans)
for q in out[-2::-1]:
print(q) | p03108 |
from sys import stdin
def input():
return stdin.readline()[:-1]
#おまじない。
n,m=list(map(int,input().split()))
AB=[list(map(int,input().split())) for i in range(m)]
from itertools import combinations
#union-find召喚
par=[-1]*n
def find(x):
if par[x]<0:
return x
else:
par[x]=find(par[x])
return par[x] #ここ覚えていなかった
def unite(x,y):
x=find(x)
y=find(y)
if x==y:
False
else:
if par[x]>par[y]:#sizeの大きいほうがxにしたい
x,y=y,x
par[x]+=par[y]
par[y]=x
return True
def same(x,y):
return find(x)==find(y)
def size(x):
return -par[find(x)]
comb=list(combinations(list(range(n)),2))
ans=[]
for i in range(m):
count=0
num=m-i-1
unite(AB[num][0]-1,AB[num][1]-1)
for kumiawase in comb:
if same(kumiawase[0],kumiawase[1]):
count+=1
ans.append(count)
ans=list(reversed(ans))
for i in range(len(ans)-1):
print((ans[0]-ans[i+1]))
print((ans[0])) | n, m = map(int, input().split())
par = [-1] * (n + 1)
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def size(x):
X = find(x)
return -par[X]
def unite(x, y):
if find(x) == find(y):
return False
X = find(x)
Y = find(y)
if size(X) < size(Y):
x, y = y, x
X = find(x)
Y = find(y)
par[X] += par[Y]
par[Y] = X
return True
def is_same(x, y):
return find(x) == find(y)
def calc(a):
return a * (a - 1) // 2
goukei = calc(n)
ans = [-1] * (m + 1)
ans[-1] = calc(n)
cnt = 0
AB = [list(map(int, input().split())) for _ in range(m)]
for i in range(m - 1, -1, -1):
a, b = AB[i]
if is_same(a, b):
ans[i] = goukei - cnt
else:
A = size(a)
B = size(b)
cnt += calc(A + B) - calc(A) - calc(B)
unite(a, b)
ans[i] = goukei - cnt
print(*ans[1::], sep="\n")
| p03108 |
class UF_tree:
def __init__(self, n):
self.root = [-1] * (n + 1) # -1ならそのノードが根,で絶対値が木の要素数
self.rank = [0] * (n + 1)
def find(self, x): # xの根となる要素番号を返す
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def isSame(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
elif self.rank[x] < self.rank[y]:
self.root[y] += self.root[x]
self.root[x] = y
else:
self.root[x] += self.root[y]
self.root[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getNodeLen(self, x):
return -self.root[self.find(x)]
n, m = map(int, input().split())
bridge = [list(map(int, input().split())) for _ in range(m)]
bridge = bridge[::-1]
uf = UF_tree(n)
ans = [0] * (m + 1)
ans[0] = n * (n - 1) // 2
for i in range(m):
x, y = bridge[i]
if uf.isSame(x, y):
ans[i + 1] = ans[i]
continue
tmp = uf.getNodeLen(x) * uf.getNodeLen(y)
uf.unite(x, y)
ans[i + 1] = ans[i] - tmp
ans = ans[::-1][1:]
print(*ans, sep="\n")
| import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
class UF_tree:
def __init__(self, n):
self.root = [-1] * (n + 1) # -1ならそのノードが根,で絶対値が木の要素数
self.rank = [0] * (n + 1)
def find(self, x): # xの根となる要素番号を返す
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def isSame(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
elif self.rank[x] < self.rank[y]:
self.root[y] += self.root[x]
self.root[x] = y
else:
self.root[x] += self.root[y]
self.root[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getNodeLen(self, x):
return -self.root[self.find(x)]
if __name__ == "__main__":
N, M = map(int, input().split())
AB = tuple(tuple(map(int, input().split())) for _ in range(M))
score = N * (N - 1) // 2
ans = [score]
uf = UF_tree(N)
for a, b in AB[::-1]:
if uf.isSame(a, b):
ans.append(score)
continue
x = uf.getNodeLen(a)
y = uf.getNodeLen(b)
uf.unite(a, b)
score -= x * y
ans.append(score)
ans.reverse()
print(*ans[1:], sep="\n")
| p03108 |
S = input()[:: -1]
mod = 10 ** 9 + 7
dp = [[0 for _ in range(13)] for _ in range(len(S) + 1)]
if S[0] == "?":
for k in range(10):
dp[1][k % 13] += 1
else:
dp[1][int(S[0]) % 13] += 1
tmp = 1
for i in range(2, len(S) + 1):
tmp *= 10
for j in range(13):
if dp[i - 1][j] > 0:
if S[i - 1] == "?":
for k in range(10):
dp[i][(tmp * k + j) % 13] += dp[i - 1][j]
else:
dp[i][(tmp * int(S[i - 1]) + j) % 13] += dp[i - 1][j]
print((dp[len(S)][5] % mod)) | S = input()[:: -1]
mod = 10 ** 9 + 7
dp = [[0 for _ in range(13)] for _ in range(len(S) + 1)]
if S[0] == "?":
for k in range(10):
dp[1][k % 13] += 1
else:
dp[1][int(S[0]) % 13] += 1
tmp = 1
for i in range(2, len(S) + 1):
tmp *= 10
tmp %= 13
for j in range(13):
if dp[i - 1][j] > 0:
if S[i - 1] == "?":
for k in range(10):
dp[i][(tmp * k + j) % 13] += dp[i - 1][j] % mod
else:
dp[i][(tmp * int(S[i - 1]) + j) % 13] += dp[i - 1][j] % mod
print((dp[len(S)][5] % mod)) | p02960 |
import sys
mod = 10**9 + 7
S = sys.stdin.readline().strip()
S = S[::-1]
ls = len(S)
dp = [0] * 13
dp[0] = 1
for i in range(ls):
ndp = [0] * 13
# print("S", S[i])
for j in range(13):
if S[i] == "?":
for k in range(10):
r = k * pow(10, i, 13) + j
r %= 13
ndp[r] += dp[j]
ndp[r] %= mod
else:
n = int(S[i])
r = n * pow(10, i, 13) + j
r %= 13
ndp[r] += dp[j]
ndp[r] %= mod
# print(ndp)
dp = ndp
print((dp[5])) | import sys
mod = 10**9 + 7
S = sys.stdin.readline().strip()
S = S[::-1]
ls = len(S)
dp = [0] * 13
dp[0] = 1
for i in range(ls):
ndp = [0] * 13
# print("S", S[i])
for j in range(13):
if dp[j] == 0:
continue
digit = pow(10, i, 13)
if S[i] == "?":
for k in range(10):
r = k * digit + j
r %= 13
ndp[r] += dp[j]
ndp[r] %= mod
else:
n = int(S[i])
r = n * digit + j
r %= 13
ndp[r] += dp[j]
ndp[r] %= mod
# print(ndp)
dp = ndp
print((dp[5])) | p02960 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
#from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [LI()for i in range(n)]
inf = 10**17
mod = 10**9 + 7
s=input().rstrip()
l=len(s)
dp=[[0 for i in range(13)] for i in range(l)]
#dp[0]=[1 for i in range(13)]
i=0
u=s[0]
if u!="?":
k=(int(u)*10**(l-1))%13
dp[0][k]+=1
else:
for g in range(10):
k=(g*10**(l-1))%13
dp[0][k]+=1
#print(dp)
for i in range(l-1):
u=s[i+1]
t=(10**(l-i-2))%13
for j in range(13):
if u!="?":
k=(j+int(u)*t)%13
dp[i+1][k]+=dp[i][j]
else:
for g in range(10):
k=(j+g*t)%13
dp[i+1][k]+=dp[i][j]
#print(dp)
print((dp[l-1][5]%mod))
| import sys,math,copy
def main():
# import numpy as np
input = sys.stdin.readline
S = ''.join(reversed(input().strip()))
# dp = np.zeros((13), dtype=int)
# dp_ = np.zeros((13), dtype=int)
dp = [0] * 13
dp_ = [0] * 13
mod13_list = [i % 13 for i in range(12 ** 2 + 1)]
list10 = list(range(10))
list13 = list(range(13))
divisor = 10 ** 9 + 7
dp_[0] = 1
mul = 1
for i in range(len(S)):
s = S[i]
if s == '?':
for d in list10:
m = mod13_list[(d * mul)]
for pm in list13:
dp[mod13_list[(pm+m)]] += dp_[pm]
else:
si = int(s)
m = mod13_list[(si * mul)]
for pm in list13:
dp[mod13_list[(pm+m)]] = dp_[pm]
# dp_ = dp % divisor
# dp = dp * 0 # np.zeros((13), dtype=int)
for j in list13:
dp_[j] = dp[j] % divisor
dp[j] = 0
mul = mod13_list[(mul * 10)]
print((dp_[5]))
if __name__ == '__main__':
main()
| p02960 |
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [ModInt(0) for _ in range(13)]
if S[0] == '?':
for i in range(10):
dp[0][i] = ModInt(1)
else:
dp[0][int(S[0])] = ModInt(1)
for i in range(1,N):
if S[i] == '?':
for j in range(13):
for k in range(10):
dp[i][(j * 10 + k) % 13 ] += dp[i-1][j]
else:
for j in range(13):
dp[i][ (j* 10 + int(S[i])) % 13 ] += dp[i-1][j]
print(dp[len(S)-2][5])
pass
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [0 for _ in range(13)]
if S[0] == '?':
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(S[0])] = 1
for i in range(1,N):
if S[i] == '?':
for j in range(13):
for k in range(10):
dp[i][(j * 10 + k) % 13 ] = (dp[i][(j * 10 + k) % 13 ] + dp[i-1][j]) % MOD
else:
for j in range(13):
dp[i][ (j* 10 + int(S[i])) % 13 ] = (dp[i][ (j* 10 + int(S[i])) % 13 ] + dp[i-1][j]) % MOD
print(dp[len(S)-2][5])
pass
if __name__ == '__main__':
main()
| p02960 |
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [0 for _ in range(13)]
if S[0] == '?':
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(S[0])] = 1
for i in range(1,N):
if S[i] == '?':
for j in range(13):
for k in range(10):
dp[i][(j * 10 + k) % 13 ] = (dp[i][(j * 10 + k) % 13 ] + dp[i-1][j]) % MOD
else:
for j in range(13):
dp[i][ (j* 10 + int(S[i])) % 13 ] = (dp[i][ (j* 10 + int(S[i])) % 13 ] + dp[i-1][j]) % MOD
print(dp[len(S)-2][5])
pass
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [0 for _ in range(13)]
if S[0] == '?':
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(S[0])] = 1
for i in range(1,N):
if S[i] == '?':
R = range(10)
else:
R = [int(S[i])]
for j in range(13):
for k in R:
dp[i][(j * 10 + k) % 13 ] = (dp[i][(j * 10 + k) % 13 ] + dp[i-1][j])
for j in range(13):
dp[i][j] %= MOD
print(dp[len(S)-2][5])
pass
if __name__ == '__main__':
main()
| p02960 |
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [0 for _ in range(13)]
if S[0] == '?':
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(S[0])] = 1
for i in range(1,N):
if S[i] == '?':
R = range(10)
else:
R = [int(S[i])]
for j in range(13):
for k in R:
dp[i][(j * 10 + k) % 13 ] = (dp[i][(j * 10 + k) % 13 ] + dp[i-1][j])
# for j in range(13):
# dp[i][j] %= MOD
print(dp[len(S)-2][5] % MOD)
pass
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
if S[0] == '?':
R = range(10)
else:
R = [int(S[0])]
for i in R:
dp[0][i] = 1
for i in range(1,N):
if S[i] == '?':
R = range(10)
else:
R = [int(S[i])]
for j in range(13):
for k in R:
dp[i][(j * 10 + k) % 13 ] = (dp[i][(j * 10 + k) % 13 ] + dp[i-1][j])
for j in range(13):
dp[i][j] %= MOD
print(dp[N-1][5])
if __name__ == '__main__':
main()
| p02960 |
mod = 10 ** 9 + 7
S = input()[::-1]
W = [1, 10, 9, 12, 3, 4]
dp = [[0] * 13 for _ in range(len(S))]
for i, s in enumerate(S):
if i == 0:
if s == "?":
for j in range(10):
dp[0][j] = 1
else:
dp[0][int(s)] = 1
continue
if s == "?":
for n in range(10):
r = (n * W[i % 6]) % 13
for j in range(13):
dp[i][(j + r) % 13] = (dp[i][(j + r) % 13] + dp[i - 1][j]) % mod
else:
n = int(s)
r = (n * W[i % 6]) % 13
for j in range(13):
dp[i][(j + r) % 13] = (dp[i][(j + r) % 13] + dp[i - 1][j]) % mod
print((dp[len(S) - 1][5]))
|
mod = 10 ** 9 + 7
S = input()[::-1]
W = [1, 10, 9, 12, 3, 4]
dp = [[0] * 13 for _ in range(len(S))]
for i, s in enumerate(S):
if i == 0:
if s == "?":
for j in range(10):
dp[0][j] = 1
else:
dp[0][int(s)] = 1
continue
w = W[i % 6]
if s == "?":
for n in range(10):
r = (n * w) % 13
for j in range(13):
dp[i][(j + r) % 13] = (dp[i][(j + r) % 13] + dp[i - 1][j]) % mod
else:
n = int(s)
r = (n * w) % 13
for j in range(13):
dp[i][(j + r) % 13] = (dp[i][(j + r) % 13] + dp[i - 1][j]) % mod
print((dp[len(S) - 1][5]))
| p02960 |
# import sys
# fin = sys.stdin.readline
MOD = 10 ** 9 + 7
S = input()[::-1]
dp = [[0] * 13 for _ in range(len(S) + 1)]
dp[0][0] = 1
for i, c in enumerate(S, start=1):
base = 10 ** (i - 1) % 13
if c != '?':
d = int(c) * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
else:
for d in range(10):
d = d * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
print((dp[-1][5]))
| # import sys
# fin = sys.stdin.readline
MOD = 10 ** 9 + 7
S = input()[::-1]
dp = [[0] * 13 for _ in range(len(S) + 1)]
dp[0][0] = 1
for i, c in enumerate(S, start=1):
base = pow(10, i - 1, 13)
if c != '?':
d = int(c) * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
else:
for d in range(10):
d = d * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
print((dp[-1][5]))
| p02960 |
# import sys
# fin = sys.stdin.readline
MOD = 10 ** 9 + 7
S = input()[::-1]
dp = [[0] * 13 for _ in range(len(S) + 1)]
dp[0][0] = 1
base = 1
for i, c in enumerate(S, start=1):
if c != '?':
d = int(c) * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
else:
for d in range(10):
d = d * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
base = base * 10 % 13
print((dp[-1][5]))
| import sys
fin = sys.stdin.readline
MOD = 10 ** 9 + 7
S = fin().rstrip("\n")[::-1]
dp = [[0] * 13 for _ in range(len(S) + 1)]
dp[0][0] = 1
base = 1
for i, c in enumerate(S, start=1):
if c != '?':
d = int(c) * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
else:
for d in range(10):
d = d * base % 13
for r in range(13):
c = (d + r) % 13
dp[i][c] += dp[i - 1][r]
dp[i][c] %= MOD
base = base * 10 % 13
print((dp[-1][5]))
| p02960 |
# standart input
# n = int(input())
# a = list(map(int, input().split()))
N = 13
MOD = 10 ** 9 + 7
s = input()[::-1]
dp = [0 for i in range(N)]
nextdp = [0 for i in range(N)]
zeros = [0 for i in range(N)]
dp[0] = 1
for i, si in enumerate(s):
nextdp = zeros[:]
r = 10 ** i % N
for j in range(10):
jj = j
if si == "?":
pass
# c = (j * 10 ** i) % N
elif j == 0:
jj = int(si)
else:
break
for k in range(N):
l = (k + r * jj) % N
nextdp[l] = (nextdp[l] + dp[k]) % MOD
dp = nextdp[:]
print((dp[5]))
| # standart input
# n = int(input())
# a = list(map(int, input().split()))
N = 13
MOD = 10 ** 9 + 7
s = input()[::-1]
dp = [0 for i in range(N)]
nextdp = [0 for i in range(N)]
zeros = [0 for i in range(N)]
dp[0] = 1
r = 1
for i, si in enumerate(s):
nextdp = zeros[:]
for j in range(10):
jj = j
if si == "?":
pass
# c = (j * 10 ** i) % N
elif j == 0:
jj = int(si)
else:
break
for k in range(N):
l = (k + r * jj) % N
nextdp[l] = (nextdp[l] + dp[k]) % MOD
dp = nextdp
r = r * 10 % N
print((dp[5]))
| p02960 |
import sys
input = sys.stdin.readline
def main():
S = input().strip()
N = len(S)
A = []
for c in S:
A.append(-1 if c == "?" else int(c))
dp = [[0]*13 for _ in range(N+1)]
dp[0][0] = 1
for n in range(N):
c = A[N-n-1]
for i in range(10):
m = i*10**n
if c == -1 or c == i:
for j in range(13):
dp[n+1][(j + m)%13] += dp[n][j]
for i in range(13):
dp[n+1][i] %= 10**9+7
print((dp[N][5]))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
S = input().strip()
N = len(S)
dp = [[0]*13 for _ in range(N+1)]
dp[0][0] = 1
m = 1
for n in range(N):
c = S[N-n-1]
if c == "?":
for i in range(10):
for j in range(13):
dp[n+1][(j + i*m)%13] += dp[n][j]
else:
k = int(c)
for j in range(13):
dp[n+1][(j + k*m)%13] += dp[n][j]
for i in range(13):
dp[n+1][i] %= 10**9+7
m = m * 10 % 13
print((dp[N][5]))
if __name__ == '__main__':
main()
| p02960 |
import sys
input = sys.stdin.readline
def main():
mod = 10**9+7
S = input().strip()
N = len(S)
dp = [[0]*13 for _ in range(N+1)]
dp[0][0] = 1
for n in range(N):
c = S[N-n-1]
m = 10**n % 13
for i in range(10):
if c == "?" or int(c) == i:
for j in range(13):
dp[n+1][(j + i*m) % 13] += dp[n][j] % mod
print((dp[N][5] % mod))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
mod = 10**9+7
S = input().strip()
N = len(S)
dp = [[0]*13 for _ in range(N+1)]
dp[0][0] = 1
m = 1
for n in range(N):
c = S[N-n-1]
for i in range(10):
if c == "?" or int(c) == i:
for j in range(13):
dp[n+1][(j + i*m) % 13] += dp[n][j] % mod
m = m * 10 % 13
print((dp[N][5] % mod))
if __name__ == '__main__':
main()
| p02960 |
from heapq import heappush, heappop
import re
from collections import deque
import sys
import math
input = sys.stdin.readline
def int_raw():
return int(eval(input()))
def ss_raw():
return input().split()
def ints_raw():
return tuple(map(int, ss_raw()))
DIV = 10**9+7
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def ncr(n, r, mod=DIV):
r = min(r, n-r)
ret = 1
for i in range(1, r+1):
ret = ret * (n-i+1) % mod
ret = ret * mod_inv(i, mod) % mod
return ret
def main():
S = input().rstrip("\n")
dp = [[0 for i in range(13)] for i in range(len(S)+1)]
dp [0][0] = 1
modi = 1%13
for i in range(1,len(S)+1):
modi = (10**(i-1)) %13
s = S[len(S)-i]
if s!= '?':
mod_q = (int(s)*modi)%13
for k in range(13):
dp[i][(k+mod_q) % 13] = (dp[i][(k+mod_q) % 13]+dp[i-1][k]) % DIV
else:
for j in range(10):
mod_q = (j*modi) % 13
for k in range(13):
dp[i][(k+mod_q) % 13] = (dp[i]
[(k+mod_q) % 13]+dp[i-1][k]) % DIV
modi = (modi*10)%13
return dp[len(S)][5]
print((main()))
| from heapq import heappush, heappop
import re
from collections import deque
import sys
import math
input = sys.stdin.readline
def int_raw():
return int(eval(input()))
def ss_raw():
return input().split()
def ints_raw():
return tuple(map(int, ss_raw()))
DIV = 10**9+7
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def ncr(n, r, mod=DIV):
r = min(r, n-r)
ret = 1
for i in range(1, r+1):
ret = ret * (n-i+1) % mod
ret = ret * mod_inv(i, mod) % mod
return ret
def main():
S = input().rstrip("\n")
dp = [[0 for i in range(13)] for i in range(len(S)+1)]
dp [0][0] = 1
modi = 1%13
for i in range(1,len(S)+1):
s = S[len(S)-i]
if s!= '?':
mod_q = (int(s)*modi)%13
for k in range(13):
dp[i][(k+mod_q) % 13] = (dp[i][(k+mod_q) % 13]+dp[i-1][k]) % DIV
else:
for j in range(10):
mod_q = (j*modi) % 13
for k in range(13):
dp[i][(k+mod_q) % 13] = (dp[i]
[(k+mod_q) % 13]+dp[i-1][k]) % DIV
modi = (modi*10)%13
return dp[len(S)][5]
print((main()))
| p02960 |
from collections import defaultdict
s = input()[::-1]
mod = 13
p = 10 ** 9 + 7
dic = defaultdict(int)
dic[0] = 1
for i in range(len(s)):
tmp = defaultdict(int)
if s[i] == "?":
for j in range(10):
d = j * 10 ** i % mod
for k, v in list(dic.items()):
tmp[(k + d) % mod] += v
tmp[(k + d) % mod] %= p
else:
d = int(s[i]) * 10 ** i % mod
for k, v in list(dic.items()):
tmp[(k + d) % mod] = v
tmp[(k + d) % mod] %= p
dic = tmp
print((dic[5] % p))
| from collections import defaultdict
s = input()[::-1]
mod = 13
p = 10 ** 9 + 7
dic = defaultdict(int)
dic[0] = 1
for i in range(len(s)):
tmp = defaultdict(int)
if s[i] == "?":
for j in range(10):
d = j * pow(10, i, mod)
for k, v in list(dic.items()):
tmp[(k + d) % mod] += v
tmp[(k + d) % mod] %= p
else:
d = int(s[i]) * pow(10, i, mod)
for k, v in list(dic.items()):
tmp[(k + d) % mod] = v
dic = tmp
print((dic[5] % p))
| p02960 |
from collections import defaultdict
s = input()[::-1]
mod = 13
p = 10 ** 9 + 7
dic = defaultdict(int)
dic[0] = 1
for i in range(len(s)):
tmp = defaultdict(int)
if s[i] == "?":
for j in range(10):
d = j * pow(10, i, mod)
for k, v in list(dic.items()):
tmp[(k + d) % mod] += v
tmp[(k + d) % mod] %= p
else:
d = int(s[i]) * pow(10, i, mod)
for k, v in list(dic.items()):
tmp[(k + d) % mod] = v
dic = tmp
print((dic[5] % p))
| s = input()[::-1]
mod = 13
p = 10 ** 9 + 7
dp = [[0] * 13 for _ in range(len(s) + 1)]
dp[0][0] = 1
for i in range(len(s)):
if s[i] == "?":
for j in range(10):
d = j * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
dp[i + 1][(k + d) % mod] %= p
else:
d = int(s[i]) * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
print((dp[-1][5]))
| p02960 |
s = input()[::-1]
mod = 13
p = 10 ** 9 + 7
dp = [[0] * 13 for _ in range(len(s) + 1)]
dp[0][0] = 1
for i in range(len(s)):
if s[i] == "?":
for j in range(10):
d = j * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
dp[i + 1][(k + d) % mod] %= p
else:
d = int(s[i]) * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
print((dp[-1][5]))
| p = 10 ** 9 + 7
def main():
s = input()[::-1]
mod = 13
dp = [[0] * 13 for _ in range(len(s) + 1)]
dp[0][0] = 1
for i in range(len(s)):
if s[i] == "?":
for j in range(10):
d = j * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
dp[i + 1][(k + d) % mod] %= p
else:
d = int(s[i]) * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
print((dp[-1][5]))
if __name__ == '__main__':
main() | p02960 |
p = 10 ** 9 + 7
def main():
s = input()[::-1]
mod = 13
dp = [[0] * 13 for _ in range(len(s) + 1)]
dp[0][0] = 1
for i in range(len(s)):
if s[i] == "?":
for j in range(10):
d = j * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
dp[i + 1][(k + d) % mod] %= p
else:
d = int(s[i]) * pow(10, i, mod)
for k in range(13):
dp[i + 1][(k + d) % mod] += dp[i][k]
print((dp[-1][5]))
if __name__ == '__main__':
main() | def main():
s = input()[::-1]
mod = 13
p = 10 ** 9 + 7
dp = [0] * mod
dp[0] = 1
for i, ss in enumerate(s):
tmp = [0] * mod
if ss == "?":
for j in range(10):
d = j * pow(10, i, mod)
for k in range(mod):
tmp[(k + d) % mod] += dp[k]
tmp[(k + d) % mod] %= p
else:
d = int(ss) * pow(10, i, mod)
for k in range(mod):
tmp[(k + d) % mod] += dp[k]
dp = tmp
print((dp[5]))
if __name__ == '__main__':
main()
| p02960 |
#!/usr/bin/python3
# -*- coding:utf-8 -*-
MAX = 10**9 + 7
def main():
s = input().strip()
p = 13
dp = [[0]*p for _ in range(len(s))]
if s[-1] == '?':
dp[0][:10] = [1] * 10
else:
dp[0][int(s[-1])] = 1
for i, c in enumerate(s[::-1][1:], 1):
if c == '?':
for c in range(10):
for j in range(p):
dp[i][(int(c) * (10 ** i) + j) % p] += (dp[i-1][j] % MAX)
else:
for j in range(p):
dp[i][(int(c) * (10 ** i) + j) % p] += (dp[i-1][j] % MAX)
print((dp[-1][5] % MAX))
if __name__=='__main__':
main()
| #!/usr/bin/python3
# -*- coding:utf-8 -*-
MAX = 10**9 + 7
def main():
s = input().strip()
p = 13
dp = [[0]*p for _ in range(len(s))]
remains = [[0]*p for _ in range(6)]
for i in range(6):
for j in range(p):
remains[i][j] = ((10 ** i) * j) % p
if s[-1] == '?':
dp[0][:10] = [1] * 10
else:
dp[0][int(s[-1])] = 1
for i, c in enumerate(s[::-1][1:], 1):
if c == '?':
for c in range(10):
for j in range(p):
dp[i][(remains[i%6][c] + j) % p] += (dp[i-1][j] % MAX)
else:
c = int(c)
for j in range(p):
dp[i][(remains[i%6][c] + j) % p] += (dp[i-1][j] % MAX)
print((dp[-1][5] % MAX))
if __name__=='__main__':
main()
| p02960 |
def main():
S = {i:s for i, s in enumerate(input()[::-1])}
MOD = 10**9 + 7
DP_table = {(i, j):0 for i in range(1, len(S)+1) for j in range(13)}
digit = S[0]
if digit == '?':
for i in range(10):
DP_table[(1, i)] = 1
else:
#DP_table[(1, int(digit))] = 1
if digit == '0':
DP_table[(1, 0)] = 1
elif digit == '1':
DP_table[(1, 1)] = 1
elif digit == '2':
DP_table[(1, 2)] = 1
elif digit == '3':
DP_table[(1, 3)] = 1
elif digit == '4':
DP_table[(1, 4)] = 1
elif digit == '5':
DP_table[(1, 5)] = 1
elif digit == '6':
DP_table[(1, 6)] = 1
elif digit == '7':
DP_table[(1, 7)] = 1
elif digit == '8':
DP_table[(1, 8)] = 1
else:
DP_table[(1, 9)] = 1
multiplier = 1
for i in range(1, len(S)):
digit = S[i]
multiplier = multiplier * 10 % 13
if digit == '?':
for j in range(10):
for k in range(13):
DP_table[(i + 1, (j * multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '0':
for k in range(13):
DP_table[(i + 1, k % 13)] += DP_table[(i, k)]
elif digit == '1':
for k in range(13):
DP_table[(i + 1, (multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '2':
for k in range(13):
DP_table[(i + 1, (2 * multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '3':
for k in range(13):
DP_table[(i + 1, (3 * multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '4':
for k in range(13):
DP_table[(i + 1, (4 * multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '5':
for k in range(13):
DP_table[(i + 1, (5 * multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '6':
for k in range(13):
DP_table[(i + 1, (6 * multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '7':
for k in range(13):
DP_table[(i + 1, (7 * multiplier + k) % 13)] += DP_table[(i, k)]
elif digit == '8':
for k in range(13):
DP_table[(i + 1, (8 * multiplier + k) % 13)] += DP_table[(i, k)]
else:
for k in range(13):
DP_table[(i + 1, (9 * multiplier + k) % 13)] += DP_table[(i, k)]
for j in range(13):
DP_table[(i + 1, j)] %= MOD
print((DP_table[(len(S), 5)]))
if __name__ == "__main__":
main() | def main():
S = {i:s for i, s in enumerate(input()[::-1])}
MOD = 10**9 + 7
DP_table = [[0 for i in range(13)] for j in range(len(S))]
digit = S[0]
if digit == '?':
for i in range(10):
DP_table[0][i] = 1
else:
DP_table[0][int(digit)] = 1
multiplier = 1
for i in range(1, len(S)):
digit = S[i]
multiplier = multiplier * 10 % 13
if digit == '?':
for j in range(10):
for k in range(13):
DP_table[i][(j * multiplier + k) % 13] += DP_table[i-1][k]
else:
digit = int(digit)
for k in range(13):
DP_table[i][(digit * multiplier + k) % 13] += DP_table[i-1][k]
for j in range(13):
DP_table[i][j] %= MOD
print((DP_table[len(S)-1][5]))
if __name__ == "__main__":
main()
| p02960 |
# Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
S = input().rstrip()
mod = 10**9+7
# dp[i][j] : 上から i 桁までの数字で, 13で割ったあまりが j になる場合の数
dp = [[0 for _ in range(13)] for _ in range(len(S))]
# 初期化
if S[0] == "?":
for i in range(10):
dp[0][i] += 1
else:
dp[0][int(S[0])] = 1
# dp更新
for i in range(1,len(S)):
if S[i] == "?":
for j in range(13):
for k in range(10):
dp[i][(j*10 + k) % 13] += dp[i-1][j]
dp[i][(j*10 + k) % 13] %= mod
else:
for j in range(13):
dp[i][(j*10 + int(S[i])) % 13] += dp[i-1][j]
dp[i][(j*10 + int(S[i])) % 13] %= mod
print((dp[-1][5])) | # PyPy3 (2.4.0)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
S = input().rstrip()
mod = 10**9+7
# dp[i][j] : 上から i 桁までの数字で, 13で割ったあまりが j になる場合の数
dp = [[0 for _ in range(13)] for _ in range(len(S))]
# 初期化
if S[0] == "?":
for i in range(10):
dp[0][i] += 1
else:
dp[0][int(S[0])] = 1
# dp更新
for i in range(1,len(S)):
if S[i] == "?":
for j in range(13):
for k in range(10):
dp[i][(j*10 + k) % 13] += dp[i-1][j]
dp[i][(j*10 + k) % 13] %= mod
else:
for j in range(13):
dp[i][(j*10 + int(S[i])) % 13] += dp[i-1][j]
dp[i][(j*10 + int(S[i])) % 13] %= mod
print((dp[-1][5])) | p02960 |
# 解説AC
MOD = 10**9 + 7
def main():
S = [s for s in input()[::-1]]
N = len(S)
dp = [[0]*13 for i in range(N+1)]
dp[0][0] = 1
for i in range(N):
for j in range(13):
if S[i] != "?":
a = int(S[i])
ne = ((a*pow(10, i, 13))+j) % 13
dp[i+1][ne] += dp[i][j]
dp[i+1][ne] %= MOD
else:
for k in range(10):
ne = ((k*pow(10, i, 13))+j) % 13
dp[i+1][ne] += dp[i][j]
dp[i+1][ne] %= MOD
print((dp[N][5] % MOD))
if __name__ == '__main__':
main()
| # 解説AC
MOD = 10**9 + 7
def main():
S = [s for s in input()[::-1]]
N = len(S)
dp = [[0]*13 for i in range(N+1)]
dp[0][0] = 1
d = 1
for i in range(N):
for j in range(13):
if S[i] != "?":
a = int(S[i])
ne = ((a*d)+j) % 13
dp[i+1][ne] += dp[i][j]
dp[i+1][ne] %= MOD
else:
for k in range(10):
ne = ((k*d)+j) % 13
dp[i+1][ne] += dp[i][j]
dp[i+1][ne] %= MOD
d *= 10
d %= 13
print((dp[N][5] % MOD))
if __name__ == '__main__':
main()
| p02960 |
d=[0]*13
d[0]=1
mul=1
mulmod=1
t=input()[::-1]
mod=10**9+7
zero=[0]*13
for c in t:
e=zero[:]
if c=="?":
for i in range(10):
for j in range(13):
k=(i*mul+j)%13
e[k]+=d[j]
e[k]%=mod
else:
for j in range(13):
k=(int(c)*mul+j)%13
e[k]+=d[j]
e[k]%=mod
d=e
mul=10*mul%13
print((d[5]))
| d=[0]*13
d[0]=1
m=1
mmod=1
t=input()[::-1]
mod=10**9+7
zero=[0]*13
for c in t:
e=zero[:]
if c=="?":
for i in range(10):
for j in range(13):
k=(i*m+j)%13
e[k]+=d[j]
e[k]%=mod
else:
for j in range(13):
k=(int(c)*m+j)%13
e[k]+=d[j]
e[k]%=mod
d=e
m=10*m%13
print((d[5]))
| p02960 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.