input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
H, W, N = list(map(int, input().split()))
Y = [W+100]*(H+1)
P = [[] for i in range(W+1)]
for i in range(N):
x, y = list(map(int, input().split()))
if x < y:
continue
Y[x-y] = min(Y[x-y], y-1)
P[y-1].append(x-1)
base = 0
ans = H
for y in range(W):
while Y[base] == y:
base += 1
xmin = y + base
for x in P[y]:
if xmin <= x:
ans = min(x, ans)
print(ans) | readline = open(0).readline
write = open(1, 'w').write
H, W, N = list(map(int, readline().split()))
Y = [W+1]*(H+1)
P = [[] for i in range(W+1)]
for i in range(N):
x, y = list(map(int, readline().split()))
if x < y:
continue
Y[x-y] = min(Y[x-y], y-1)
P[y-1].append(x-1)
base = 0
ans = H
for y in range(W):
while Y[base] == y:
base += 1
xmin = y + base
for x in P[y]:
if xmin <= x:
ans = min(x, ans)
write("%d\n" % ans) | p03203 |
h, w, n = list(map(int, input().split()))
xy = sorted([list(map(int, input().split())) for _ in range(n)])
dx = 0
dy = 0
for x, y in xy:
x -= dx
y -= dy
if x == y:
dx += x-1
dy += y-2
elif y < x:
print((dx+x-1))
break
else:
print(h) | import sys
input = sys.stdin.readline
def main():
h, w, n = list(map(int, input().split()))
xy = sorted([list(map(int, input().split())) for _ in range(n)])
dx = 0
dy = 0
for x, y in xy:
x -= dx
y -= dy
if x == y:
dx += x-1
dy += y-2
elif y < x:
print((dx+x-1))
break
else:
print(h)
if __name__ == "__main__":
main() | p03203 |
x,y,num = list(map(int, input().split()))
gaiz = []
zen_gaiz = [[] for _ in range(x)]
kaisu = x
for _ in range(num):
xg,yg = list(map(int,input().split()))
if xg >= yg:
zen_gaiz[xg-1].append(yg)
if xg != yg:
gaiz.append((xg,yg))
if len(gaiz) ==0:
print(kaisu)
else:
finish = False
for gai in sorted(gaiz, key=lambda x: x[0]):
hidari = [gai[0]-1, gai[1]]
while True:
if hidari[1]==1:
kaisu = gai[0]-1
finish=True
break
for g in zen_gaiz:
if hidari[1] in zen_gaiz[hidari[0]-1]:
break
else:
hidari[0]-=1
hidari[1]-=1
continue
break
if finish:
break
print(kaisu)
| x,y,num = list(map(int, input().split()))
gaiz = [x]*x
kaisu = x
for _ in range(num):
xg,yg = list(map(int,input().split()))
if xg >= yg:
sa = xg-yg
if yg < gaiz[sa]:
gaiz[sa]=(yg)
if len(gaiz) ==0:
print(kaisu)
else:
for num,(maegai,gai) in enumerate(zip(gaiz[:-1],gaiz[1:])):
if maegai>gai and num+gai < kaisu:
kaisu = num+gai
print(kaisu) | p03203 |
# 解説 AC
# 参考1: https://twitter.com/rickytheta/status/1175412019006074880
# 参考2: https://maspypy.com/atcoder-%E5%8F%82%E5%8A%A0%E6%84%9F%E6%83%B3-2019-09-21agc-038
mod = 998244353
max_A = 10**6
N = int(eval(input()))
A = list(map(int, input().split()))
is_prime = [False, True, False, False, False, True] * (max_A//6+1)
del is_prime[max_A+1:]
is_prime[1:4] = False, True, True
for i in range(5, int(max_A**0.5)+1):
if is_prime[i]:
is_prime[i*i::i] = [False] * (max_A//i-i+1)
primes = [p for p, is_p in enumerate(is_prime) if is_p] # max_A 以下の素数のリスト
g = [0] * (max_A+1)
for a in A:
g[a] += a
for p in primes:
# 倍数集合の高速ゼータ変換みたいなやつ O((max_A)loglog(max_A))
# 参考: http://noshi91.hatenablog.com/entry/2018/12/27/121649
# 大量に約数列挙みたいなことをするときはこれで高速化できる場合が多そう？（みんぷろ 2018 本戦 A - Uncommon など）
for k in range(max_A//p, 0, -1):
g[k] += g[k*p]
g = [v * v % mod for v in g]
for p in primes:
for k, g_kp in enumerate(g[p::p], 1):
g[k] -= g_kp
modinv = [0, 1]
for i in range(2, max_A+1):
modinv.append(mod - mod//i * modinv[mod%i] % mod)
ans = sum((gg * minv % mod for gg, minv in zip(g, modinv)))
ans %= mod
ans -= sum(A)
ans *= modinv[2]
ans %= mod
print(ans)
| def main():
mod = 998244353
max_A = 10**6
N = int(eval(input()))
A = list(map(int, input().split()))
is_prime = [False, True, False, False, False, True] * (max_A//6+1)
del is_prime[max_A+1:]
is_prime[1:4] = False, True, True
for i in range(5, int(max_A**0.5)+1):
if is_prime[i]:
is_prime[i*i::i] = [False] * (max_A//i-i+1)
primes = [p for p, is_p in enumerate(is_prime) if is_p] # max_A 以下の素数のリスト
g = [0] * (max_A+1)
for a in A:
g[a] += a
for p in primes:
# 倍数集合の高速ゼータ変換みたいなやつ O((max_A)loglog(max_A))
# 参考: http://noshi91.hatenablog.com/entry/2018/12/27/121649
# 大量に約数列挙みたいなことをするときはこれで高速化できる場合が多そう？（みんぷろ 2018 本戦 A - Uncommon など）
for k in range(max_A//p, 0, -1):
g[k] += g[k*p]
g = [v * v % mod for v in g]
for p in primes:
for k, g_kp in enumerate(g[p::p], 1):
g[k] -= g_kp
modinv = [0, 1]
for i in range(2, max_A+1):
modinv.append(mod - mod//i * modinv[mod%i] % mod)
ans = sum((gg * minv % mod for gg, minv in zip(g, modinv)))
ans %= mod
ans -= sum(A)
ans *= modinv[2]
ans %= mod
print(ans)
main()
| p02905 |
def main():
mod = 998244353
max_A = 10**6
N = int(eval(input()))
A = list(map(int, input().split()))
is_prime = [False, True, False, False, False, True] * (max_A//6+1)
del is_prime[max_A+1:]
is_prime[1:4] = False, True, True
for i in range(5, int(max_A**0.5)+1):
if is_prime[i]:
is_prime[i*i::i] = [False] * (max_A//i-i+1)
primes = [p for p, is_p in enumerate(is_prime) if is_p] # max_A 以下の素数のリスト
g = [0] * (max_A+1)
for a in A:
g[a] += a
for p in primes:
# 倍数集合の高速ゼータ変換みたいなやつ O((max_A)loglog(max_A))
# 参考: http://noshi91.hatenablog.com/entry/2018/12/27/121649
# 大量に約数列挙みたいなことをするときはこれで高速化できる場合が多そう？（みんぷろ 2018 本戦 A - Uncommon など）
for k in range(max_A//p, 0, -1):
g[k] += g[k*p]
g = [v * v % mod for v in g]
for p in primes:
for k, g_kp in enumerate(g[p::p], 1):
g[k] -= g_kp
modinv = [0, 1]
for i in range(2, max_A+1):
modinv.append(mod - mod//i * modinv[mod%i] % mod)
ans = sum((gg * minv % mod for gg, minv in zip(g, modinv)))
ans %= mod
ans -= sum(A)
ans *= modinv[2]
ans %= mod
print(ans)
main()
| # 解説 AC
# 参考1: https://twitter.com/rickytheta/status/1175412019006074880
# 参考2: https://maspypy.com/atcoder-%E5%8F%82%E5%8A%A0%E6%84%9F%E6%83%B3-2019-09-21agc-038
def make_prime_checker(n):
is_prime = [False, True, False, False, False, True] * (n//6+1)
del is_prime[n+1:]
is_prime[1:4] = False, True, True
for i in range(5, int(n**0.5)+1):
if is_prime[i]:
is_prime[i*i::i] = [False] * (n//i-i+1)
return is_prime
def make_modinv_list(n, mod=10**9+7):
# 0 から n までの mod 逆元のリストを返す O(n)
modinv = [0, 1]
for i in range(2, n+1):
modinv.append(mod - mod//i * modinv[mod%i] % mod)
return modinv
def main():
mod = 998244353
max_A = 10**6
N = int(eval(input()))
A = list(map(int, input().split()))
# nまでの自然数が素数かどうかを表すリストを返す O(nloglogn)
primes = [p for p, is_prime in enumerate(make_prime_checker(max_A)) if is_prime] # max_A 以下の素数のリスト
g = [0] * (max_A+1)
for a in A:
g[a] += a
for p in primes:
# 倍数集合の高速ゼータ変換みたいなやつ O((max_A)loglog(max_A))
# 参考: http://noshi91.hatenablog.com/entry/2018/12/27/121649
# 大量に約数列挙みたいなことをするときはこれで高速化できる場合が多そう？（みんぷろ 2018 本戦 A - Uncommon など）
for k in range(max_A//p, 0, -1):
g[k] += g[k*p]
# この時点で g[d] = Σ_{d|a} a (A の要素のうち d の倍数であるものの総和)
g = [v * v % mod for v in g]
# この時点で
# g[d] = (Σ_{d|a} a)(Σ_{d|b} b)
# = Σ_{(d|a)∧(d|b)} ab
# = Σ_{d | gcd(a,b)} ab
# この式変形天才すぎないか？（これを使った一連の操作を gcd 畳み込み というらしい？）
for p in primes:
# 倍数集合の高速メビウス変換みたいなやつ O((max_A)loglog(max_A))
# for k in range(1, max_A//p+1):
# g[k] -= g[k*p] # 包除原理ヤバい
for k, g_kp in enumerate(g[p::p], 1): # 高速化（ゼータ変換の方は途中で g が変化するので高速化できない）
g[k] -= g_kp # 包除原理ヤバい
# この時点で g[d] = Σ_{gcd(a,b)=d} ab
modinv_list = make_modinv_list(max_A, mod)
ans = sum((gg * minv % mod for gg, minv in zip(g, modinv_list)))
ans %= mod
# この時点で
# ans = Σ_d ( Σ_{gcd(a,b)=d} ab/d )
# = Σ_d ( Σ_{gcd(a,b)=d} lcm(a,b) )
# = Σ_a Σ_b lcm(a,b)
ans -= sum(A)
ans *= modinv_list[2]
ans %= mod
# この時点で ans = Σ_{i<j} lcm(a,b)
print(ans)
main()
| p02905 |
import sys
readline = sys.stdin.readline
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: list(map(int, readline().split()))
nl = lambda: list(map(int, readline().split()))
def make_modinv_list(n, mod=10**9+7):
inv_list = [0]*(n+1)
inv_list[1] = 1
for i in range(2, n+1):
inv_list[i] = (mod - mod//i * inv_list[mod%i] % mod)
return inv_list
def solve():
mod = 998244353
n = ni()
a = nl()
m = max(a)
s = -sum(a) % mod
l = [0]*(m+1)
for x in a:
l[x] += x
a = make_modinv_list(m, mod)
sieve = [1]*(m+1)
sieve[0] = sieve[1] = 0
for i in range(2, m+1):
if sieve[i]:
for j in range(m//i, 0, -1):
sieve[j*i] = 0
l[j] += l[j*i]
sieve[i] = 1
for i in range(m+1):
l[i] = l[i] * l[i] % mod
for i in range(2, m+1):
if sieve[i]:
for j in range(1, m//i + 1):
l[j] = (l[j] - l[j*i]) % mod
for i in range(1, m+1):
if l[i]:
s = (s + l[i] * a[i]) % mod
print((s * a[2] % mod))
return
solve() | import sys
readline = sys.stdin.readline
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: list(map(int, readline().split()))
nl = lambda: list(map(int, readline().split()))
def primes(n):
is_prime = [True] * (n + 1)
is_prime[0] = is_prime[1] = False
for i in range(2, int((n+1)**0.5)+1):
if is_prime[i]:
for j in range(i *2, n + 1, i):
is_prime[j] = False
res = [i for i in range(n+1) if is_prime[i]]
return res
def make_modinv_list(n, mod=10**9+7):
inv_list = [0]*(n+1)
inv_list[1] = 1
for i in range(2, n+1):
inv_list[i] = (mod - mod//i * inv_list[mod%i] % mod)
return inv_list
def solve():
mod = 998244353
n = ni()
a = nl()
m = max(a)
s = -sum(a) % mod
l = [0]*(m+1)
for x in a:
l[x] += x
a = make_modinv_list(m, mod)
pr = primes(m)
for i in pr:
for j in range(m//i, 0, -1):
l[j] += l[j*i]
for i in range(m+1):
l[i] = l[i] * l[i] % mod
for i in pr:
for j in range(1, m//i + 1):
l[j] = (l[j] - l[j*i]) % mod
for i in range(1, m+1):
if l[i]:
s = (s + l[i] * a[i]) % mod
print((s * a[2] % mod))
return
solve()
| p02905 |
import sys
sys.setrecursionlimit(4100000)
n=int(eval(input()))
A=[int(x) for x in input().split()]
import itertools
#import fractions
from functools import lru_cache
#com = list(itertools.combinations(A, 2))
res = 0
waru=998244353
@lru_cache(maxsize=None)
def gcd(a,b):
if b == 0:
return a
return gcd(b,a % b)
@lru_cache(maxsize=None)
def lcm(x,y):
r = (x * y) // gcd(x, y) % waru
return r
@lru_cache(maxsize=None)
def goukei(i,j):
if j < n-1:
return lcm(A[i],A[j]) + goukei(i,j+1)
else:
return lcm(A[i],A[j])
for i in range(n-1):
res += goukei(i,i+1)
#for a, b in com:
#res += lcm(a,b)
print((res % waru))
| import sys
sys.setrecursionlimit(4100000)
n=int(eval(input()))
A=[int(x) for x in input().split()]
import itertools
#import fractions
from functools import lru_cache
#com = list(itertools.combinations(A, 2))
res = 0
waru=998244353
def gcd(a,b):
if b == 0:
return a
return gcd(b,a % b)
@lru_cache(maxsize=None)
def lcm(x,y):
r = (x * y) // gcd(x, y) % waru
return r
@lru_cache(maxsize=None)
def goukei(i,j):
if j < n-1:
return lcm(A[i],A[j]) + goukei(i,j+1)
else:
return lcm(A[i],A[j])
i=n-2
while i >= 0:
res += goukei(i,i+1)
i-=1
#for i in range(n-1):
#res += goukei(i,i+1)
#for a, b in com:
#res += lcm(a,b)
print((res % waru))
| p02905 |
# coding: utf-8
# Your code here!
SIZE=1000003; MOD=998244353 #ここを変更する
SIZE += 1
inv = [0]*SIZE # inv[j] = j^{-1} mod MOD
inv[1] = 1
for i in range(2,SIZE):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
import sys
#sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n = int(eval(input()))
a = [int(i) for i in readline().split()]
num = [0]*SIZE
db = [0]*SIZE
for i in a:
num[i] += i
db[i] += i*i
db[i] %= MOD
def zeta(a,n):
sieve = [True]*(n+1)
for p in range(2,n):
if sieve[p]:
for k in range(n//p,0,-1):
sieve[k*p] = False
a[k] += a[k*p]
a[k] %= MOD
return a
def meb(a,n):
sieve = [True]*(n+1)
for p in range(2,n):
if sieve[p]:
for k in range(1,n):
if k*p >= n: break
sieve[k*p] = False
a[k] -= a[k*p]
a[k] %= MOD
return a
#n = 1000000
n = 1000001
#zn = [i*i for i in zeta(num,n)]
#zdb = zeta(db,n)
#print(zn[:20])
#print(zdb[:20])
zn = [i*i for i in zeta(num,n)]
zdb = zeta(db,n)
ans = [i-j for i,j in zip(zn, zdb)]
#ans = [i*i-j for i,j in zip(zeta(num,n), zeta(db,n))]
#print(ans[:20])
#print(meb(ans,n)[:20])
res = 0
for i,c in enumerate(meb(ans,n)):
res = (res + c*inv[i])%MOD
print((res*inv[2]%MOD))
| # coding: utf-8
# Your code here!
SIZE=1000001; MOD=998244353 #ここを変更する
SIZE += 1
inv = [0]*SIZE # inv[j] = j^{-1} mod MOD
inv[1] = 1
for i in range(2,SIZE):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
import sys
#sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n = int(eval(input()))
a = [int(i) for i in readline().split()]
num = [0]*1000001
db = [0]*1000001
for i in a:
num[i] += i
db[i] += i*i
db[i] %= MOD
def zeta(a,n):
sieve = [True]*(n+1)
for p in range(2,n):
if sieve[p]:
for k in range(n//p,0,-1):
sieve[k*p] = False
a[k] += a[k*p]
a[k] %= MOD
return a
def meb(a,n):
sieve = [True]*(n+1)
for p in range(2,n):
if sieve[p]:
for k in range(1,n):
if k*p >= n: break
sieve[k*p] = False
a[k] -= a[k*p]
a[k] %= MOD
return a
#n = 1000000
n = 1000000
#zn = [i*i for i in zeta(num,n)]
#zdb = zeta(db,n)
#print(zn[:20])
#print(zdb[:20])
zn = [i*i for i in zeta(num,n)]
zdb = zeta(db,n)
ans = [i-j for i,j in zip(zn, zdb)]
#ans = [i*i-j for i,j in zip(zeta(num,n), zeta(db,n))]
#print(ans[:20])
#print(meb(ans,n)[:20])
res = 0
for i,c in enumerate(meb(ans,n+1)):
res = (res + c*inv[i])%MOD
print((res*inv[2]%MOD))
| p02905 |
# coding: utf-8
# Your code here!
SIZE=1000001; MOD=998244353 #ここを変更する
SIZE += 1
inv = [0]*SIZE # inv[j] = j^{-1} mod MOD
inv[1] = 1
for i in range(2,SIZE):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
import sys
#sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n = int(eval(input()))
a = [int(i) for i in readline().split()]
num = [0]*1000001
db = [0]*1000001
for i in a:
num[i] += i
db[i] += i*i
db[i] %= MOD
def zeta(a,n):
sieve = [True]*(n+1)
for p in range(2,n):
if sieve[p]:
for k in range(n//p,0,-1):
sieve[k*p] = False
a[k] += a[k*p]
a[k] %= MOD
return a
def meb(a,n):
sieve = [True]*(n+1)
for p in range(2,n):
if sieve[p]:
for k in range(1,n):
if k*p >= n: break
sieve[k*p] = False
a[k] -= a[k*p]
a[k] %= MOD
return a
#n = 1000000
n = 1000000
#zn = [i*i for i in zeta(num,n)]
#zdb = zeta(db,n)
#print(zn[:20])
#print(zdb[:20])
zn = [i*i for i in zeta(num,n)]
zdb = zeta(db,n)
ans = [i-j for i,j in zip(zn, zdb)]
#ans = [i*i-j for i,j in zip(zeta(num,n), zeta(db,n))]
#print(ans[:20])
#print(meb(ans,n)[:20])
res = 0
for i,c in enumerate(meb(ans,n+1)):
res = (res + c*inv[i])%MOD
print((res*inv[2]%MOD))
| # coding: utf-8
# Your code here!
def Eratosthenes(N): #N以下の素数のリストを返す
N+=1
is_prime_list = [True]*N
m = int(N**0.5)+1
for i in range(3,m,2):
if is_prime_list[i]:
is_prime_list[i*i::2*i]=[False]*((N-i*i-1)//(2*i)+1)
return [2] + [i for i in range(3,N,2) if is_prime_list[i]]
#aを破壊的にgcd-zetaする
def zeta_gcd(a,primes):
n = len(a)-1
for p in primes:
for i in range(n//p,0,-1):
a[i] += a[p*i]
a[i] %= MOD
# return a
#aを破壊的にgcd-mobiusする
def mobius_gcd(a,primes):
n = len(a)
for p in primes:
for i in range(1,n):
if i*p >= n: break
a[i] -= a[p*i]
a[i] %= MOD
# return a
################################################
#################################################
SIZE=1000001; MOD=998244353 #ここを変更する
SIZE += 1
inv = [0]*SIZE # inv[j] = j^{-1} mod MOD
inv[1] = 1
for i in range(2,SIZE):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
################################################
#################################################
import sys
#sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n = int(eval(input()))
a = [int(i) for i in readline().split()]
num = [0]*SIZE
for i in a: num[i] += i
primes = Eratosthenes(SIZE)
zeta_gcd(num,primes)
ans = [i*i for i in num]
mobius_gcd(ans,primes)
res = 0
for i,c in enumerate(ans):
res = (res + c*inv[i])%MOD
for i in a:
res = (res-i)%MOD
print((res*inv[2]%MOD))
| p02905 |
# -*- coding: utf-8 -*-
import sys
import os
import math
N = int(eval(input()))
alphabet = 'abcdefghijklmnopqrstuvwxyz'
def encode(s, alpha, beta):
t = []
for c in s:
if c == ' ':
t.append(c)
else:
gamma = ord(c) - 97
v = (alpha * gamma + beta) % 26
w = alphabet[v]
t.append(w)
return ''.join(t)
for i in range(N):
s = input().strip()
for a in range(26):
for b in range(26):
encoded = encode(s, a, b)
if 'that' in encoded or 'this' in encoded:
print(encoded) | # -*- coding: utf-8 -*-
import sys
import os
import math
N = int(eval(input()))
alphabet = 'abcdefghijklmnopqrstuvwxyz'
def encode(s, alpha, beta):
t = []
for c in s:
if c == ' ':
t.append(c)
else:
gamma = ord(c) - 97
v = (alpha * gamma + beta) % 26
w = alphabet[v]
t.append(w)
return ''.join(t)
for i in range(N):
s = input().strip()
for a in range(0, 26):
for b in range(0, 26):
encoded_this = encode('this', a, b)
encoded_that = encode('that', a, b)
if encoded_this in s or encoded_that in s:
encoded_alphabet = encode(alphabet, a, b)
table = str.maketrans(encoded_alphabet, alphabet)
dst = s.translate(table)
print(dst) | p00040 |
dict = ["a","b","c","d","e","f","g","h","i","j","k","l","m",\
"n","o","p","q","r","s","t","u","v","w","x","y","z"]
lsalpha = [1,3,5,7,9,11,15,17,19,21,23,25]
n = int(input())
for roop in range(n):
code = input()
for alpha in lsalpha:
flag = 0
for beta in range(26):
decode = ""
for chara in code:
if chara != " ":
f = dict.index(chara)
for i in range(26):
if (alpha*i + beta)%26 == f:
dechara = dict[i]
break
decode += dechara
else:
decode += " "
if decode.count("that") > 0 or decode.count("this") > 0:
flag = 1
break
if flag == 1:
break
print(decode) | dict = ["a","b","c","d","e","f","g","h","i","j","k","l","m",\
"n","o","p","q","r","s","t","u","v","w","x","y","z"]
lsalpha = [1,3,5,7,9,11,15,17,19,21,23,25]
def decode(alpha, beta, code):
msg = ""
for chara in code:
if chara != " ":
f = dict.index(chara)
for i in range(26):
if (alpha*i + beta)%26 == f:
dechara = dict[i]
break
msg += dechara
else:
msg += " "
return msg
n = int(input())
for roop in range(n):
code = input()
for alpha in lsalpha:
flag = 0
for beta in range(26):
msg = decode(alpha, beta, code)
if msg.count("that") > 0 or msg.count("this") > 0:
flag = 1
break
if flag == 1:
break
print(msg) | p00040 |
A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(L1,L2,msg):
x=[]
for c in msg:
if 'a'<=c<='z':
c = L2[L1.index(c)]
x.append(c)
return "".join(x)
def affine(msg, key):
a,b = key
L = [A2Z[(i*a+b)%26] for i in range(26)]
L = "".join(L)
return decode(A2Z,L,msg)
def rot(msg, a):
if a==0: return msg
a = a % 26
L = A2Z[a:]+A2Z[:a]
return decode(A2Z,L,msg)
def find(msg):
c0=ord('t')
i = 3
while True:
x = affine(msg,[i,0])
a = (c0-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return [i,a]
i += 2
n = eval(input())
for i in range(n):
msg = input()
for w in msg.split():
if len(w)==4:
key = find(w)
if key!=[]: break
print(affine(msg,key)) | A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(L1,L2,msg):
x=[]
for c in msg:
if 'a'<=c<='z':
c = L2[L1.index(c)]
x.append(c)
return "".join(x)
def affine(msg, key):
a,b = key
L = [A2Z[(i*a+b)%26] for i in range(26)]
L = "".join(L)
return decode(A2Z,L,msg)
def rot(msg, a):
if a==0: return msg
a = a % 26
L = A2Z[a:]+A2Z[:a]
return decode(A2Z,L,msg)
def find(msg):
c0=ord('t')
for i in range(26):
x = affine(msg,[i,0])
a = (c0-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return [i,a]
return []
n = eval(input())
for i in range(n):
msg = input()
for w in msg.split():
if len(w)==4:
key = find(w)
if key!=[]: break
print(affine(msg,key)) | p00040 |
import string
A2Z="abcdefghijklmnopqrstuvwxyz"
R=list(range(26))
def decode(msg,L):
x=""
for c in msg: x+=(L[A2Z.index(c)] if "a"<=c<="z" else c)
return x
def affine(msg, a, b):
L="".join([A2Z[(i*a+b)%26]for i in R])
s = decode(msg,L)
return s
def rot(msg, a):
a = a % 26
L = A2Z[a:]+A2Z[:a]
s = decode(msg,L)
return s
def checkkey(s):
c0="t"
for i in R:
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = eval(input())
while n:
n-=1
s = input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print(affine(s,a,b)) | A2Z="abcdefghijklmnopqrstuvwxyz"
def affine(msg, a, b):
s=""
for c in msg: s+=(A2Z[(A2Z.index(c)*a+b)%26] if "a"<=c<="z" else c)
return s
def rot(msg, a):
a = a % 26
L = A2Z[a:]+A2Z[:a]
s=""
for c in msg: s+=(L[A2Z.index(c)] if "a"<=c<="z" else c)
return s
def checkkey(s):
c0="t"
for i in range(26):
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = eval(input())
while n:
n-=1
s = input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print(affine(s,a,b)) | p00040 |
D = [[-1,0],[0,1],[1,0],[0,-1]]
def s(N):
used = [[False]*N+[True] for _ in range(N)]+[[True]*(N+1)]
ret = [[" "]*N for _ in range(N)]
q = [(0,N-1,0)]
used[N-1][0] = used[N-1][1] = True
while len(q) != 0:
d,y,x = q.pop(0)
ret[y][x] = "#"
sy,sx = D[d]
ry,rx = D[(d+1)%4]
if not used[y+sy][x+sx]:
q.append((d,y+sy,x+sx))
used[y+sy][x+sx] = used[y+ry][x+rx] = True
elif not used[y+ry][x+rx]:
q.append(((d+1)%4,y+ry,x+rx))
used[y+ry][x+rx] = True
return ret
n = eval(input())
while True:
n -= 1
N = eval(input())
print("\n".join(["".join(a) for a in s(N)]))
if n == 0:
break
print() | D = [[-1,0],[0,1],[1,0],[0,-1]]
def s(N):
used = [[False]*N+[True] for _ in range(N)]+[[True]*(N+1)]
ret = [[" "]*N for _ in range(N)]
d,y,x = 0,N-1,0
used[N-1][0] = used[N-1][1] = True
while True:
ret[y][x] = "#"
sy,sx = D[d]
ry,rx = D[(d+1)%4]
if not used[y+sy][x+sx]:
used[y+sy][x+sx] = used[y+ry][x+rx] = True
d,y,x = d,y+sy,x+sx
elif not used[y+ry][x+rx]:
used[y+ry][x+rx] = True
d,y,x = (d+1)%4,y+ry,x+rx
else:
break
return ret
n = eval(input())
while True:
n -= 1
N = eval(input())
print("\n".join(["".join(a) for a in s(N)]))
if n == 0:
break
print() | p00141 |
def mincos(n,ab):
aball=[]
aball+=[(ab[i][0],i+1,'a') for i in range(n)]
aball+=[(ab[i][1],i+1,'b') for i in range(n)]
aball.sort()
ans1=sum([i[0] for i in aball[:n]])
hen=aball[n][0]
hen2=aball[n+1][0]
d=[]
t=None
hantei=True
for i,c,mab in aball[:n]:
if t!=None and t!=mab:
hantei=False
if c in d:
print(ans1)
exit()
d+=[c]
t=mab
if hantei:
print(ans1)
exit()
ans2=[]
for i,c,aorb in aball[:n]:
if aball[n][1]!=c:
ans2+=[ans1-i+hen]
else:
ans2+=[ans1-i+hen2]
print((min(ans2)))
exit()
n=int(eval(input()))
print((mincos(n,[list(map(int,input().split())) for i in range(n)]))) | def mincos(n,ab):
aball=[]
aball+=[(ab[i][0],i+1,'a') for i in range(n)]
aball+=[(ab[i][1],i+1,'b') for i in range(n)]
aball.sort()
ans1=sum([i[0] for i in aball[:n]])
hen=aball[n][0]
hen2=aball[n+1][0]
d=set()
t=None
hantei=True
for i,c,mab in aball[:n]:
if t!=None and t!=mab:
hantei=False
if c in d:
print(ans1)
exit()
d.add(c)
t=mab
if hantei:
print(ans1)
exit()
ans2=[]
for i,c,aorb in aball[:n]:
if aball[n][1]!=c:
ans2+=[ans1-i+hen]
else:
ans2+=[ans1-i+hen2]
print((min(ans2)))
exit()
n=int(eval(input()))
print((mincos(n,[list(map(int,input().split())) for i in range(n)]))) | p03233 |
import sys,random
input=sys.stdin.readline
N=int(eval(input()))
A=[-1]*N;B=[-1]*N
for i in range(N):
A[i],B[i]=list(map(int,input().split()))
ans=min(sum(A),sum(B))
temp=[(A[i],i) for i in range(N)]+[(B[i],i) for i in range(N)]
temp.sort()
#print(temp)
data=[0]*N
for i in range(N):
val,id=temp[i]
data[id]+=1
S=sum(temp[i][0] for i in range(N))
for i in range(N):
if data[i]==2:
test=S
ans=min(ans,test)
elif data[i]==1:
if temp[N-1][1]!=i:
test=S+max(A[i],B[i])-temp[N-1][0]
else:
test=S+max(A[i],B[i])-temp[N-2][0]
ans=min(ans,test)
print(ans)
| import sys;input=sys.stdin.readline;N=int(eval(input()));A=[-1]*N;B=[-1]*N
for i in range(N):
A[i],B[i]=list(map(int,input().split()))
ans=min(sum(A),sum(B));temp=[(A[i],i) for i in range(N)]+[(B[i],i) for i in range(N)];temp.sort();data=[0]*N
for i in range(N):data[temp[i][1]]+=1
S=sum(temp[i][0] for i in range(N))
if max(data)==2:
print(S)
else:
for i in range(N):ans=min(ans,S+max(A[i],B[i])-temp[N-1-(temp[N-1][1]==i)][0]);
print(ans)
| p03233 |
N,A,B=list(map(int,input().split()));M=998244353;P=N+1;f=1;F=[1]*P;I=[1]*P;z=0;R=range
for n in R(1,P):F[n]=f=f*n%M
I[N]=i=pow(f,M-2,M)
for n in R(N,1,-1):I[n-1]=i=i*n%M
for k in R(min(A+1,N-B)if N-B-A else A+1):Q=N-B-k-1;z=(z+(B-k)*F[B+k-1]*I[B]*I[k]*F[Q+A-k]*I[Q]*I[A-k])%M
print((z if B else 1)) | N,A,B=list(map(int,input().split()));M=998244353;P=N+1;f=1;F=[1]*P;I=[1]*P;z=0;R=range
for n in R(1,P):F[n]=f=f*n%M
I[N]=i=pow(f,M-2,M)
for n in R(N,1,-1):I[n-1]=i=i*n%M
for k in R(min(A+1,N-B)if N-B-A else A+1):Q=N-B-k-1;z+=(B-k)*F[B+k-1]*I[B]*I[k]*F[Q+A-k]*I[Q]*I[A-k]
print((z%M if B else 1)) | p02878 |
n, m = list(map(int, input().split()))
pros = sorted([list(map(int, input().split())) for _ in range(m)])
index = 0
covered = 0
right = 0
ans = 0
while True:
a, b = pros[index]
if a > covered + 1:
covered = right
ans += 1
continue
else:
right = max(right, b)
index += 1
if covered == n:
print(ans)
break
if index == m:
covered = right
ans += 1
print((ans if covered == n else "Impossible"))
break
| n, m = list(map(int, input().split()))
pros = sorted([list(map(int, input().split())) for _ in range(m)])
index = 0
covered = 0
right = 0
ans = 0
while True:
a, b = pros[index]
if a > covered + 1:
if covered == right:
print("Impossible")
break
covered = right
ans += 1
continue
else:
right = max(right, b)
index += 1
if covered == n:
print(ans)
break
if index == m:
covered = right
ans += 1
print((ans if covered == n else "Impossible"))
break
| p01523 |
import sys
sys.setrecursionlimit(4000)
n = int(eval(input()))
p = [float(x) for x in input().split()]
dp = [[0]*(n+1) for i in range(n)]
dp[0][0] = 1-p[0]
dp[0][1] = p[0]
for i in range(n-1):
for j in range(i+2):
dp[i+1][j] += dp[i][j]*(1-p[i+1])
dp[i+1][j+1] += dp[i][j]*p[i+1]
ans = 0
for i in range(n//2+1, n+1):
ans += dp[n-1][i]
print(ans) | n = int(eval(input()))
p = [float(x) for x in input().split()]
dp = [[0]*(i+2) for i in range(n)]
dp[0][0] = 1-p[0]
dp[0][1] = p[0]
for i in range(1, n):
for j in range(i+2):
if j == 0:
dp[i][j] = dp[i-1][j]*(1-p[i])
continue
if j == i+1:
dp[i][j] = dp[i-1][j-1]*p[i]
continue
dp[i][j] = dp[i-1][j-1]*p[i]+dp[i-1][j]*(1-p[i])
ans = 0
for i in range(n//2+1, n+1):
ans += dp[n-1][i]
print(ans) | p03168 |
n = int(eval(input()))
a = list(map(float, input().split()))
dp = [[0]*(n+1) for i in range(n+1)]
dp[0][0] = 1
for i in range(1,n+1):
dp[0][i] = 0
dp[i][0] = dp[i-1][0] * (1 - a[i-1])
for i in range(1, n+1):
for j in range(1, n+1):
dp[i][j] = dp[i-1][j-1] * a[i-1] + dp[i-1][j] * (1 - a[i-1])
ans = 0
for i in range(n // 2 + 1 , n+1):
ans += dp[n][i]
print(ans)
| n = int(input())
a = list(map(float, input().split()))
dp = [[0]*(n+1) for i in range(n+1)]
dp[0][0] = 1
for i in range(1,n+1):
dp[0][i] = 0
dp[i][0] = dp[i-1][0] * (1 - a[i-1])
for i in range(1, n+1):
for j in range(1, n+1):
dp[i][j] = dp[i-1][j-1] * a[i-1] + dp[i-1][j] * (1 - a[i-1])
ans = 0
for i in range(n // 2 + 1 , n+1):
ans += dp[n][i]
print(ans) | p03168 |
n=int(eval(input()))
import math
p=list(map(float,input().split()))
dp=[[0]*(n) for i in range(n+1)]
dp[0][0]=(1-p[0])
for i in range(1,n):
dp[0][i]=round(dp[0][i-1]*(1-p[i]),10)
# print(dp[0][1],1-p[2],dp[0][1]*(1-p[2]))
for i in range(1,n+1):
for j in range(i-1,n):
if j==0:
temp1=1
temp2=0
else:
temp1=dp[i-1][j-1]
temp2=dp[i][j-1]
dp[i][j]=temp1*p[j]+temp2*(1-p[j])
dp[i][j]=round(dp[i][j],10)
ans=0
# print(dp)
for i in range(n//2+1,n+1):
ans+=dp[i][n-1]
print(ans)
| n=int(eval(input()))
import math
p=list(map(float,input().split()))
for i in range(n):
p[i]=p[i]*100
dp=[[0]*(n) for i in range(n+1)]
dp[0][0]=(100-p[0])/100
for i in range(1,n):
dp[0][i]=dp[0][i-1]*(100-p[i])/100
# print(dp[0][1],1-p[2],dp[0][1]*(1-p[2]))
for i in range(1,n+1):
for j in range(i-1,n):
if j==0:
temp1=1
temp2=0
else:
temp1=dp[i-1][j-1]
temp2=dp[i][j-1]
dp[i][j]=temp1*p[j]/100+temp2*(100-p[j])/100
dp[i][j]=dp[i][j]
ans=0
# print(dp)
for i in range(n//2+1,n+1):
ans+=dp[i][n-1]
print(ans)
| p03168 |
N = int(eval(input()))
P = list(map(float,input().split()))
dp = [[0 for j in range(N+1)] for i in range(N)]#i+1枚目までのコインを投げたときにj枚表が出る確率
dp[0][0] = 1-P[0]
dp[0][1] = P[0]
for i in range(1,N):
dp[i][0] = dp[i-1][0]*(1-P[i])
for i in range(1,N):
for j in range(1,N+1):
dp[i][j] = dp[i-1][j-1]*P[i]+dp[i-1][j]*(1-P[i])
ans = 0
for j in range(-(-N//2),N+1):
ans += dp[N-1][j]
print(ans) | N = int(eval(input()))
P = list(map(float, input().split()))
dp = [0 for _ in range(N + 1)]
dp[0] = 1
for i in range(N):
p = P[i]
for j in range(N)[::-1]:
dp[j + 1] += dp[j] * p
dp[j] *= 1 - p
print((sum(dp[N // 2 + 1:]))) | p03168 |
N = int(eval(input()))
p = list(map(float, input().split()))
# i-1 まで見たときに表が j 枚出る確率
dp = [[0]*(N+1) for _ in range(N+1)]
dp[0][0] = 1
for i in range(1, N+1):
for j in range(N+1):
dp[i][j] += (1-p[i-1])*dp[i-1][j]
if j >= 1:
dp[i][j] += p[i-1]*dp[i-1][j-1]
print((sum([dp[N][j] for j in range((N+1)//2, N+1)]))) | N = int(eval(input()))
p = list(map(float, input().split()))
# i-1 まで見たときに表が j 枚出る確率
dp = [[0]*(N+1) for _ in range(N+1)]
dp[0][0] = 1
for i in range(1, N+1):
for j in range(N+1):
dp[i][j] += (1-p[i-1])*dp[i-1][j]
if j >= 1:
dp[i][j] += p[i-1]*dp[i-1][j-1]
print((sum([dp[N][N-j] for j in range((N+1)//2)]))) | p03168 |
N = int(eval(input()))
P = list(map(float, input().split()))
dp = [0] * (N + 1)
dp[0] = 1
for i in range(1, N + 1):
tmp = dp
dp = [0] * (N + 1)
for j in range(N):
if j < N:
dp[j + 1] += tmp[j] * P[i - 1]
dp[j] += tmp[j] * (1 - P[i - 1])
num = 0
for i in range(N // 2 + 1, N + 1):
num += dp[i]
print(num)
| N = int(eval(input()))
P = list(map(float, input().split()))
# dp = [[0] * (N + 1) for i in range(N + 1)]
# dp[0][0] = 1.0
# for i in range(1, N + 1):
# for j in range(N):
# if j < N:
# dp[i][j + 1] += dp[i - 1][j] * P[i - 1]
# dp[i][j] += dp[i - 1][j] * (1 - P[i - 1])
#
# num = 0
# for i in range(N // 2 + 1, N + 1):
# num += dp[N][i]
#
# print(num)
dp = [0] * (N + 1)
dp[0] = 1
for i in range(1, N + 1):
tmp = dp
dp = [0] * (N + 1)
for j in range(N):
if j < N:
dp[j + 1] += tmp[j] * P[i - 1]
dp[j] += tmp[j] * (1 - P[i - 1])
num = 0
for i in range(N // 2 + 1, N + 1):
num += dp[i]
print(num)
| p03168 |
N = int(eval(input()))
P = list(map(float, input().split()))
# dp = [[0] * (N + 1) for i in range(N + 1)]
# dp[0][0] = 1.0
# for i in range(1, N + 1):
# for j in range(N):
# if j < N:
# dp[i][j + 1] += dp[i - 1][j] * P[i - 1]
# dp[i][j] += dp[i - 1][j] * (1 - P[i - 1])
#
# num = 0
# for i in range(N // 2 + 1, N + 1):
# num += dp[N][i]
#
# print(num)
dp = [0] * (N + 1)
dp[0] = 1
for i in range(1, N + 1):
tmp = dp
dp = [0] * (N + 1)
for j in range(N):
if j < N:
dp[j + 1] += tmp[j] * P[i - 1]
dp[j] += tmp[j] * (1 - P[i - 1])
num = 0
for i in range(N // 2 + 1, N + 1):
num += dp[i]
print(num)
| N = int(eval(input()))
P = list(map(float, input().split()))
dp = [0] * (N + 1)
dp[0] = 1
for i in range(1, N + 1):
tmp = dp
dp = [0] * (N + 1)
for j in range(N):
if j < N:
dp[j + 1] += tmp[j] * P[i - 1]
dp[j] += tmp[j] * (1 - P[i - 1])
num = 0
for i in range(N // 2 + 1, N + 1):
num += dp[i]
print(num)
| p03168 |
N = int(eval(input()))
P = list(map(float, input().split()))
"""
dp[i][j]: i枚投げた時にj枚表の確率
"""
dp = [[0] * (N+1) for _ in range(N+1)]
dp[1][0] = 1 - P[0]
dp[1][1] = P[0]
for i in range(1, N+1):
for j in range(1, N+1):
dp[i][j] += dp[i-1][j-1] * P[i-1]
dp[i][j-1] += dp[i-1][j-1] * (1-P[i-1])
ans = 0
for i in range(N+1):
if N//2 < i:
ans += dp[N][i]
print(ans)
| import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
P = list(map(float, input().split()))
dp = [[0] * (N+1) for _ in range((N+1))]
dp[0][0] = 1
for i in range(1, N+1):
for j in range(i+1):
dp[i][j] = dp[i-1][j]*(1-P[i-1]) + dp[i-1][j-1]*P[i-1]
print((sum(dp[N][N//2+1:])))
if __name__ == '__main__':
main() | p03168 |
# coding: utf-8
import sys
input = sys.stdin.readline
def f2(n, p):
dp = [ 0.0 ] * (n + 1)
dp[0] = 1.0
# pprint.pprint(dp, width = 50)
for i in range(n):
dp_ = list(dp)
pi_ = 1 - p[i]
for j in range(n + 1):
dp[j] = dp_[j - 1] * p[i] + dp_[j] * pi_
# pprint.pprint(dp, width = 50)
return(sum(dp[n // 2 + 1:]))
n = int(eval(input())) # n: odd, 1 <= n <= 2999
p = list(map(float, input().split())) # 0 < pi[i] < 1
print((f2(n, p)))
| # coding: utf-8
import sys
input = sys.stdin.readline
def f3(n, p):
dp = [ 0.0 ] * (n + 1)
dp[0] = 1.0
for i in range(n):
pi_ = 1 - p[i]
dp = [dp[j - 1] * p[i] + dp[j] * pi_ \
for j in range(n + 1)]
return(sum(dp[n // 2 + 1:]))
n = int(eval(input())) # n: odd, 1 <= n <= 2999
p = list(map(float, input().split())) # 0 < pi[i] < 1
print((f3(n, p)))
| p03168 |
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation
"""Module docstring
"""
import functools
import heapq
import itertools
import logging
import math
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
def prob(i, values):
result = 1
idx = 0
for idx, v in enumerate(values):
i, rest = divmod(i, 2)
if rest == 1:
result *= v
else:
result *= 1 - v
idx += 1
return result
def solve(values, nb):
LOG.debug((values))
dp = [[0] * (nb + 1) for _ in range(nb // 2 + 1)]
dp[0][0] = 1
for j in range(1, nb + 1):
dp[0][j] = dp[0][j - 1] * (1 - values[j - 1])
total = dp[0][-1]
for i in range(1, nb // 2 + 1):
for j in range(1, nb + 1):
dp[i][j] = (
dp[i - 1][j - 1] * values[j - 1] + (1 - values[j - 1]) * dp[i][j - 1]
)
total += dp[i][-1]
# LOG.debug(("\n" + "\n".join(map(str, dp))))
return 1 - total
def do_job():
"Do the work"
LOG.debug("Start working")
# first line is number of test cases
N = int(eval(input()))
values = list(map(float, input().split()))
# values = []
# for _ in range(N):
# values.append(input().split())
result = solve(values, N)
# 6 digits float precision {:.6f} (6 is the default value)
print(("{:.10g}".format(result)))
def configure_log():
"Configure the log output"
log_formatter = logging.Formatter("L%(lineno)d - " "%(message)s")
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(log_formatter)
LOG.addHandler(handler)
LOG = None
# for interactive call: do not add multiple times the handler
if not LOG:
LOG = logging.getLogger("template")
configure_log()
def main(argv=None):
"Program wrapper."
if argv is None:
argv = sys.argv[1:]
parser = ArgumentParser()
parser.add_argument(
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="run as verbose mode",
)
args = parser.parse_args(argv)
if args.verbose:
LOG.setLevel(logging.DEBUG)
do_job()
return 0
if __name__ == "__main__":
import doctest
doctest.testmod()
sys.exit(main())
class memoized:
"""Decorator that caches a function's return value each time it is called.
If called later with the same arguments, the cached value is returned, and
not re-evaluated.
"""
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args):
try:
return self.cache[args]
except KeyError:
value = self.func(*args)
self.cache[args] = value
return value
except TypeError:
# uncachable -- for instance, passing a list as an argument.
# Better to not cache than to blow up entirely.
return self.func(*args)
def __repr__(self):
"""Return the function's docstring."""
return self.func.__doc__
def __get__(self, obj, objtype):
"""Support instance methods."""
return functools.partial(self.__call__, obj)
| #!/usr/bin/env python3
# vim: set fileencoding=utf-8
# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation
"""Module docstring
"""
import functools
import heapq
import itertools
import logging
import math
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
def prob(i, values):
result = 1
idx = 0
for idx, v in enumerate(values):
i, rest = divmod(i, 2)
if rest == 1:
result *= v
else:
result *= 1 - v
idx += 1
return result
def solve(values, nb):
LOG.debug((values))
dp = [[0] * (nb + 1) for _ in range(nb // 2 + 1)]
dp[0][0] = 1
for j in range(1, nb + 1):
dp[0][j] = dp[0][j - 1] * (1 - values[j - 1])
total = dp[0][-1]
for i in range(1, nb // 2 + 1):
for j in range(i, nb + 1):
dp[i][j] = (
dp[i - 1][j - 1] * values[j - 1] + (1 - values[j - 1]) * dp[i][j - 1]
)
total += dp[i][-1]
# LOG.debug(("\n" + "\n".join(map(str, dp))))
return 1 - total
def do_job():
"Do the work"
LOG.debug("Start working")
# first line is number of test cases
N = int(eval(input()))
values = list(map(float, input().split()))
# values = []
# for _ in range(N):
# values.append(input().split())
result = solve(values, N)
# 6 digits float precision {:.6f} (6 is the default value)
print(("{:.10g}".format(result)))
def configure_log():
"Configure the log output"
log_formatter = logging.Formatter("L%(lineno)d - " "%(message)s")
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(log_formatter)
LOG.addHandler(handler)
LOG = None
# for interactive call: do not add multiple times the handler
if not LOG:
LOG = logging.getLogger("template")
configure_log()
def main(argv=None):
"Program wrapper."
if argv is None:
argv = sys.argv[1:]
parser = ArgumentParser()
parser.add_argument(
"-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="run as verbose mode",
)
args = parser.parse_args(argv)
if args.verbose:
LOG.setLevel(logging.DEBUG)
do_job()
return 0
if __name__ == "__main__":
import doctest
doctest.testmod()
sys.exit(main())
class memoized:
"""Decorator that caches a function's return value each time it is called.
If called later with the same arguments, the cached value is returned, and
not re-evaluated.
"""
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args):
try:
return self.cache[args]
except KeyError:
value = self.func(*args)
self.cache[args] = value
return value
except TypeError:
# uncachable -- for instance, passing a list as an argument.
# Better to not cache than to blow up entirely.
return self.func(*args)
def __repr__(self):
"""Return the function's docstring."""
return self.func.__doc__
def __get__(self, obj, objtype):
"""Support instance methods."""
return functools.partial(self.__call__, obj)
| p03168 |
def f(n):
ps = list(map(float, input().split()))
ans = 0
for b in range(2 ** n):
if format(b, "b").count("1") > n // 2:
pi = 1
for i in range(n):
if b & 1:
pi *= ps[i]
else:
pi *= 1 - ps[i]
b = b >> 1
ans += pi
print(ans)
n = int(eval(input()))
f(n)
| def f(n):
ps = list(map(float, input().split()))
dp = [[1] * (n + 1) for _ in range(n + 1)]
dpi1 = dp[0]
for i, p in enumerate(ps):
i+=1
dpi = dp[i]
dpi[0] = dpi1[0] * (1 - p)
for j in range(1, i):
dpi[j] = dpi1[j - 1] * p + dpi1[j] * (1 - p)
dpi[i] = dpi1[i - 1] * p
dpi1 = dpi
print((sum(dp[-1][n // 2 + 1:])))
n = int(eval(input()))
f(n)
| p03168 |
#Educational DP Contest
#I-Coins
n = int(eval(input()))
lst1 = list(map(float,input().split()))
#dp table
dp = [[0.0]*(n+1) for _ in range(n+1)] #確率を0で初期化(2次元)
dp[0][0] = 1.0 #0番目は存在しないので1で初期化(単位元のような感じ。乗算だから単位元は1)
#process1
#dp[i][j]は、i回までのコインを投げて、j枚が表の確率。
#つまり、ループの内側が表の確率、外側がコインの枚数となる
#但し、i回までのコインでi枚以上の表は出ないので、jのループはi迄とする。
"""
図にするとこんなかんじ(1列目は実際に起きる数字ではない)
[[1.0, 0.0, 0.0, 0.0],
[0.7, 0.3, 0.0, 0.0], #0.7で裏,0.3で表
[0.28, 0.54, 0.18, 0.0],
[0.056, 0.33, 0.468, 0.144]] #0.056+0.33で裏、0.468+0.144で表
"""
for i in range(1,n+1):
for j in range(i+1):
dp[i][j] = dp[i-1][j]*(1-lst1[i-1])
if j > 0:
dp[i][j] += dp[i-1][j-1]*lst1[i-1]
#output process
#問題はdp[i][j] >= 0.5となる確率なので、j>= 0.5 = 表の枚数/全体の枚数
#となるj以上の確率の合計が答え(ちなみに、任意のdp[i]の合計sum(dp[i]) == 1となる)
ans = 0.0
for i in range((n+1)//2,n+1): #j(表が出る枚数)が半分以上のところから全部のところまでの確率の合計
ans += dp[-1][i]
print(ans) | #Educational DP Contest
#I-Coins
n = int(eval(input()))
lst1 = list(map(float,input().split()))
#dp table
dp = [[0.0]*(n+1) for _ in range(n+1)] #確率を0で初期化(2次元)
dp[0][0] = 1.0 #0番目は存在しないので1で初期化(単位元のような感じ。乗算だから単位元は1)
#process1
#dp[i][j]は、i回までのコインを投げて、j枚が表の確率。
#つまり、ループの内側がn回表の確率、外側がコインの枚数となる
#但し、i回までのコインでi枚以上の表は出ないので、jのループはi迄とする。
"""
図にするとこんなかんじ
0回表,1回表,2回表...
0枚目[[1.0, 0.0, 0.0, 0.0],
1枚目[0.7, 0.3, 0.0, 0.0], #0.7で1枚中0枚が表,0.3で1枚中1枚が表
2枚目[0.28, 0.54, 0.18, 0.0],
3枚目[0.056, 0.33, 0.468, 0.144]] #0.056+0.33で半分未満が表、0.468+0.144で半分以上が表
"""
for i in range(1,n+1):
for j in range(i+1): #jはピラミッド状に増えていく
dp[i][j] = dp[i-1][j]*(1-lst1[i-1]) #裏になる確率
if j > 0: #j-1を参照できるなら
dp[i][j] += dp[i-1][j-1]*lst1[i-1] #表になる確率
#output process
#問題はdp[i][j] >= 0.5となる確率なので、j>= 0.5 = 表の枚数/全体の枚数
#となるj以上の確率の合計が答え(ちなみに、任意のdp[i]の合計sum(dp[i]) == 1となる)
ans = 0.0
for i in range((n+1)//2,n+1): #j(表が出る枚数)が半分以上のところから全部のところまでの確率の合計
ans += dp[-1][i]
print(ans) | p03168 |
N = int(eval(input()))
p = [0] + list(input().split())
for i in range(1, N+1):
item = p[i].replace('0.', '')
p[i] = int(item)
dp = [[0 for a in range(3100)] for b in range(3100)]
#dp[i][j] = i枚目までのコインを投げて，表の個数がj枚である確率 * (10**(2*i))
dp[1][0] = 100-p[1]
dp[1][1] = p[1]
for i in range(2, N + 1):
for j in range(i+1):
dp[i][j] = dp[i-1][j-1] * p[i] + dp[i-1][j] * (100-p[i])
#dp[i][j] = i-1枚目までで表がj-1かつi回目で表 ＋ i-1回目までで表がj枚かつi回目で裏（MECE）
#print(i, j, dp[i][j])
#プログラムの仕組み上，iが一つ進むと，100 * 100 = 10**4 ずつスケールが大きくなっていく
ans = 0
for k in range(-(-N//2), N+1):
ans += dp[N][k]
print((ans/10**(2 * N))) | N = int(eval(input()))
p = [0] + list(map(float, input().split()))
#print(p)
dp = [[0 for a in range(3100)] for b in range(3100)]
#dp[i][j] = i枚目までのコインを投げて，表の個数がj枚である確率
dp[1][0] = 1-p[1]
dp[1][1] = p[1]
for i in range(2, N + 1):
for j in range(i+1):
dp[i][j] = (dp[i-1][j-1] * p[i] + dp[i-1][j] * (1-p[i]))
#dp[i][j] = i-1枚目までで表がj-1かつi回目で表 ＋ i-1回目までで表がj枚かつi回目で裏（MECE）
#print(i, j, dp[i][j])
ans = 0
for k in range(-(-N//2), N+1):
ans += dp[N][k]
print(ans) | p03168 |
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
#from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.buffer.readline().strip().decode()
def mdata(): return list(map(float, data().split()))
out=sys.stdout.write
#sys.setrecursionlimit(100000)
INF=int(1e9)
mod=int(1e9)+7
n=int(data())
P=list(mdata())
dp=[0]*(n//2+2)
dp[1]=1
for i in range(n):
dp1=dp.copy()
for j in range(1,len(dp)):
k=dp[j-1]*(1-P[i])+dp[j]*(P[i])
dp1[j]=k
dp=dp1.copy()
print((sum(dp)))
| from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
#from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.buffer.readline().strip().decode()
def mdata(): return list(map(float, data().split()))
out=sys.stdout.write
#sys.setrecursionlimit(100000)
INF=int(1e9)
mod=int(1e9)+7
n=int(data())
P=list(mdata())
dp=[0]*(n//2+2)
dp[1]=1
for i in range(n):
dp1=dp[:]
for j in range(1,len(dp)):
k=dp[j-1]*(1-P[i])+dp[j]*(P[i])
dp1[j]=k
dp=dp1[:]
print((sum(dp)))
| p03168 |
# -*- coding: utf-8 -*-
# from collections import deque
from sys import setrecursionlimit
setrecursionlimit(1000000)
# INF = float("inf")
# d = deque()
# ---Input---#
n = int(eval(input()))
# n, k = map(int, input().split())
p = list(map(float, input().split()))
p = [-1] + p
memo = [[-1 for _ in [0] * (n + 1)] for _ in [0] * (n + 1)]
memo[0][0] = 1
for i in range(len(p))[1:]:
memo[0][i] = 0
memo[i][0] = memo[i - 1][0] * (1 - p[i])
memo[0][0] = 1
def dp(i, j):
if memo[i][j] == -1:
memo[i][j] = dp(i - 1, j) * (1 - p[i]) + dp(i - 1, j - 1) * p[i]
return memo[i][j]
ans = 0
tar = int(n / 2) + 1
for i in range(n + 1)[tar:]:
ans += dp(n, i)
print(("{}".format(ans)))
| # -*- coding: utf-8 -*-
# from collections import deque
from sys import setrecursionlimit
setrecursionlimit(1000000)
# INF = float("inf")
# d = deque()
# ---Input---#
n = int(eval(input()))
# n, k = map(int, input().split())
p = list(map(float, input().split()))
p = [-1] + p
memo = [[-1 for _ in [0] * (n + 1)] for _ in [0] * (n + 1)]
memo[0][0] = 1
for i in range(len(p))[1:]:
memo[0][i] = 0
memo[i][0] = memo[i - 1][0] * (1 - p[i])
memo[0][0] = 1
def dp(i, j):
if memo[i][j] == -1:
memo[i][j] = dp(i - 1, j) * (1 - p[i]) + dp(i - 1, j - 1) * p[i]
return memo[i][j]
ans = 0
tar = int(n / 2) + 1
for i in range(n + 1):
dp(i, i)
dp(i, n)
for i in range(n + 1)[tar:]:
ans += dp(n, i)
print(("{}".format(ans)))
| p03168 |
n=int(eval(input()))
p=list(map(float,input().split()))
#dp[i][j] i tells u i coins from 0, j tells u j heads
#dp[n+1][n+1]
dp=[[0 for i in range(0,n+1)]for j in range(n+1)]
dp[0][0]=1.0
# for i in range(1,n+1):
# dp[0][i]=0.0
for i in range(1,n+1):
for j in range(0,n+1):
if(j==0):
dp[i][j]=(1.0-p[i-1])*dp[i-1][j]
else:
dp[i][j]=p[i-1]*dp[i-1][j-1]+(1.0-p[i-1])*dp[i-1][j]
k=(n//2)+1
ans=0.0
for i in range(k,n+1):
ans+=dp[n][i]
print(ans)
| n=int(eval(input()))
p=list(map(float,input().split()))
#dp[i][j] i tells u i coins from 0, j tells u j heads
#dp[n+1][n+1]
dp=[[0 for i in range(n+1)]for j in range(n+1)]
dp[0][0]=1.0
# for i in range(1,n+1):
# dp[0][i]=0.0
for i in range(1,n+1):
for j in range(0,n+1):
if(j==0):
dp[i][j]=(1.0-p[i-1])*dp[i-1][j]
else:
dp[i][j]=p[i-1]*dp[i-1][j-1]+(1.0-p[i-1])*dp[i-1][j]
k=(n//2)+1
ans=0.0
for i in range(k,n+1):
ans+=dp[n][i]
print(ans)
| p03168 |
N = int(eval(input()))
p = list(map(float, input().split()))
dp = [[0.0 for i in range(N+1)] for j in range(N+1)]
dp[0][0] = 1.0
for i in range(N):
for j in range(N):
dp[i+1][j+1] += dp[i][j] * p[i]
dp[i+1][j] += dp[i][j] * (1 - p[i])
temp = (N+1) // 2
ans = 0
for i in range(temp, N+1):
ans += dp[N][i]
print(ans) | N = int(eval(input()))
p = list(map(float, input().split()))
dp = [[0.0 for i in range(N+1)] for _ in range(N+1)]
dp[0][0] = 1.0
for i in range(N):
for j in range(i+1):
# 表が出る
dp[i+1][j+1] += dp[i][j] * p[i]
# 裏が出る
dp[i+1][j] += dp[i][j] * (1 - p[i])
temp = (N+1)//2
print((sum(dp[-1][temp:]))) | p03168 |
import collections
N = int(eval(input()))
A = list(map(float,input().split()))
K = N//2 + 1
dp = [[0 for _ in range(N + 1) ] for _ in range(N + 1)]
if N == 0:
print((0))
exit
dp[0][0] = 1
ans = 0
for i in range(1,N+1):
for j in range(i+1):
if j - 1 < 0:
dp[i][j] = dp[i-1][j]*(1-A[i-1])
else:
dp[i][j] = dp[i-1][j-1]*A[i-1] + dp[i-1][j]*(1-A[i-1])
#print(dp)
for i in range(K,len(dp[N])):
ans+=dp[N][i]
print(ans)
| import collections
N = int(eval(input()))
A = list(map(float,input().split()))
K = N//2 + 1
dp = [[0 for _ in range(N + 1) ] for _ in range(N + 1)]
if N == 0:
print((0))
exit
dp[0][0] = 1
ans = 0
for i in range(1,N+1):
for j in range(i+1):
if j - 1 < 0:
dp[i][j] = dp[i-1][j]*(1-A[i-1])
else:
dp[i][j] = dp[i-1][j-1]*A[i-1] + dp[i-1][j]*(1-A[i-1])
for i in range(K,len(dp[N])):
ans+=dp[N][i]
print(ans)
| p03168 |
from collections import defaultdict as dd
n=int(eval(input()))
l=list(map(float,input().split()))
dp=[[0]*(n+1) for i in range(n+1)]
dp[0][0]=1
for i in range(1,n+1):
for j in range(n+1):
if(j==0):
dp[i][j]=dp[i-1][j]*(1.0-l[i-1])
else:
dp[i][j]=dp[i-1][j]*(1.0-l[i-1])+dp[i-1][j-1]*l[i-1]
ans=0
for i in range(n//2+1,n+1):
ans+=dp[n][i]
print(ans) | import sys
input=sys.stdin.readline
from collections import defaultdict as dd
n=int(eval(input()))
l=list(map(float,input().split()))
dp=[[0]*(n+1) for i in range(n+1)]
dp[0][0]=1
for i in range(1,n+1):
for j in range(n+1):
if(j==0):
dp[i][j]=dp[i-1][j]*(1.0-l[i-1])
else:
dp[i][j]=dp[i-1][j]*(1.0-l[i-1])+dp[i-1][j-1]*l[i-1]
ans=0
for i in range(n//2+1,n+1):
ans+=dp[n][i]
print(ans) | p03168 |
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return list(map(fn, readline().split()))
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
N = gete(int)
# p = tuple(geta(lambda s: int(s.decode()[2:])))
p = tuple(geta(float))
cur = [0] * (N + 1)
cur[0] = 1
for i, pi in enumerate(p, 1):
upd = [0] * (N + 1)
qi = 1 - pi
upd[0] = cur[0] * qi
for j in range(1, i + 1):
upd[j] = cur[j - 1] * pi + cur[j] * qi
cur = upd
print((sum(cur[N // 2 + 1:])))
if __name__ == "__main__":
main() | import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return list(map(fn, readline().split()))
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
N = gete(int)
# p = tuple(geta(lambda s: int(s.decode()[2:])))
p = tuple(geta(float))
dp = [[0] * (i + 2) for i in range(N + 1)]
dp[0][0] = 1
for i, pi in enumerate(p, 1):
qi = 1 - pi
dpi = dp[i]
dpi1 = dp[i - 1]
dpi[0] = dpi1[0] * qi
for j in range(1, i + 1):
dpi[j] = dpi1[j - 1] * pi + dpi1[j] * qi
print((sum(dp[N][N // 2 + 1:])))
if __name__ == "__main__":
main() | p03168 |
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def ifn(): return float(eval(input())) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def fmn(): return list(map(float, input().split())) #浮動小数点map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
MOD = 10**9+7
N = iin()
p = fln()
dp = [[0 for _ in range(N+1)] for _ in range(N+1)]
dp[0][0] = 1
for i in range(N):
for j in range(N):
dp[i+1][j+1] += dp[i][j]*p[i]
dp[i+1][j] += dp[i][j]*(1-p[i])
ans = 0.0
for i in range(N//2+1, N+1):
ans += dp[N][i]
print(ans)
| import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def ifn(): return float(eval(input())) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def fmn(): return list(map(float, input().split())) #浮動小数点map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def add_mod(a,b): return (a+b) % MOD
N = iin()
p = fln()
dp = [[0 for _ in range(N+1)] for _ in range(N+1)]
dp[0][0] = 1
for i in range(N):
for j in range(i+1):
dp[i+1][j] += dp[i][j] * (1-p[i])
dp[i+1][j+1] += dp[i][j] * p[i]
ans = 0.0
for i in range(N//2+1, N+1):
ans += dp[N][i]
print(ans)
| p03168 |
#!/usr/bin/env python3
# from pprint import pprint
def recur(parr, curp, curi, heads):
# if dp[curi][heads] != -1:
# return dp[curi][heads]
if curi >= len(parr):
if heads >= len(parr)//2 + 1:
return curp
else:
return 0
return (recur(parr, curp*parr[curi], curi+1, heads+1)
+ recur(parr, curp*(1-parr[curi]), curi+1, heads))
n = int(eval(input()))
parr = [float(i) for i in input().split(' ')]
# print(recur(parr, 1, 0, 0))
dp = [[0]*(n+1) for i in range(n+1)]
dp[0][0] = 1
for i in range(1, n+1):
for j in range(i, -1, -1):
# heads
heads = dp[i-1][j-1] if j > 0 else 0
# tails
tails = dp[i-1][j]
dp[i][j] = heads*parr[i-1] + tails*(1-parr[i-1])
print((sum(dp[n][n//2+1:])))
| #!/usr/bin/env python3
# from pprint import pprint
def recur(parr, curp, curi, heads):
# if dp[curi][heads] != -1:
# return dp[curi][heads]
if curi >= len(parr):
if heads >= len(parr)//2 + 1:
return curp
else:
return 0
return (recur(parr, curp*parr[curi], curi+1, heads+1)
+ recur(parr, curp*(1-parr[curi]), curi+1, heads))
n = int(eval(input()))
parr = [float(i) for i in input().split(' ')]
# print(recur(parr, 1, 0, 0))
dp = [0]*(n+1)
dp[0] = 1
for i in range(n):
for j in range(i+1, -1, -1):
# heads
heads = dp[j-1] if j > 0 else 0
# tails
tails = dp[j]
dp[j] = heads*parr[i-1] + tails*(1-parr[i-1])
print((sum(dp[n//2+1:])))
| p03168 |
N = int(eval(input()))
P = list(map(float, input().split()))
def solve():
dp = [[0]*(N+1) for _ in range(N+1)]
dp[0][0] = 1
for i in range(1,N+1):
dp[i][0] = dp[i-1][0]*(1-P[i-1])
for i in range(1,N+1):
for j in range(1,i+1):
dp[i][j] = dp[i-1][j-1]*P[i-1]+dp[i-1][j]*(1-P[i-1])
ans = sum(dp[-1][(N+2)//2:])
return ans
print((solve())) | N = int(eval(input()))
P = list(map(float, input().split()))
def solve():
dp = [[0]*(i+2) for i in range(N+1)]
dp[0][0] = 1
for i in range(1,N+1):
dp[i][0] = dp[i-1][0]*(1-P[i-1])
for i in range(1,N+1):
for j in range(1,i+1):
dp[i][j] = dp[i-1][j-1]*P[i-1]+dp[i-1][j]*(1-P[i-1])
ans = sum(dp[-1][(N+2)//2:])
return ans
print((solve())) | p03168 |
N=int(eval(input()))
*p,=list(map(float,input().split()))
dp=[[0 for _ in range(N+1)] for _ in range(N+1)]
dp[0][0]=1
for i in range(1,N+1):
for j in range(N+1):
if j:
dp[i][j]=dp[i-1][j]*(1-p[i-1])+dp[i-1][j-1]*p[i-1]
else:
dp[i][j]=dp[i-1][j]*(1-p[i-1])
t=N//2+1 if N%2 else N//2
ans=0
for i in range(t,N+1):
ans+=dp[N][i]
print(ans) | N=int(eval(input()))
*p,=list(map(float,input().split()))
dp=[[0]*(N+1) for _ in range(N+1)]
dp[0][0]=1
for i in range(1,N+1):
for j in range(N+1):
dp[i][j]=dp[i-1][j]*(1-p[i-1])
if j:dp[i][j]+=dp[i-1][j-1]*p[i-1]
print((sum(dp[N][i] for i in range(N+1) if 2*i>=N))) | p03168 |
N = int(eval(input()))
p = list(map(float,input().split()))
dp = [[0]*(N+1) for i in range(N)]
dp[0][0] = 1-p[0]
dp[0][1] = p[0]
for i in range(1,N):
dp[i][0] = (1-p[i])*dp[i-1][0]
for j in range(1,i+2):
dp[i][j] = dp[i-1][j-1]*p[i] + dp[i-1][j]*(1-p[i])
print((sum(dp[-1][(N+1)//2:]))) | N = int(eval(input()))
p = list(map(float,input().split()))
dp = [[0.0]*(N+1) for i in range(N+1)]
dp[0][0] = 1.0
for i in range(1,N+1):
for j in range(0,N+1):
dp[i][j] = dp[i-1][j-1]*(p[i-1]) + dp[i-1][j]*(1-p[i-1])
res = 0.0
for i in range((N+1)//2,N+1):
res += dp[-1][i]
print(res) | p03168 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
LI = lambda : [float(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
p = [0.0] + LI()
dp = [[0 for _ in range(N+1)] for _ in range(N+1)]
dp[0][0] = 1
for i in range(1,N+1):
for j in range(0,i+1):
if j > 0: dp[i][j] = dp[i-1][j-1] * p[i]
dp[i][j] += dp[i-1][j] * (1-p[i])
print((sum(dp[-1][N//2+1:])))
| import sys,queue,math,copy,itertools,bisect,collections,heapq
LI = lambda : [float(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
p = [0.0] + LI()
dp = [[0] * (N+1) for _ in range(N+1)]
dp[0][0] = 1
for i in range(1,N+1):
for j in range(0,i+1):
if j > 0: dp[i][j] = dp[i-1][j-1] * p[i]
dp[i][j] += dp[i-1][j] * (1-p[i])
print((sum(dp[-1][N//2+1:])))
| p03168 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
LI = lambda : [float(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
p = [0.0] + LI()
dp = [[0] * (N+1) for _ in range(N+1)]
dp[0][0] = 1
for i in range(1,N+1):
for j in range(0,i+1):
if j > 0: dp[i][j] = dp[i-1][j-1] * p[i]
dp[i][j] += dp[i-1][j] * (1-p[i])
print((sum(dp[-1][N//2+1:])))
| import sys,queue,math,copy,itertools,bisect,collections,heapq
LI = lambda : [float(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
p = LI()
dp = [[0] * (N+1) for _ in range(N+1)]
dp[0][0] = 1
for i in range(1,N+1):
for j in range(0,i+1):
if j > 0: dp[i][j] = dp[i-1][j-1] * p[i-1]
dp[i][j] += dp[i-1][j] * (1-p[i-1])
print((sum(dp[-1][N//2+1:])))
| p03168 |
n=int(eval(input()))
p=[]
for i in input().split():
p+=[int(i.split(".")[1])]
dp=[[0]*(n+1) for _ in range(n+1)]
dp[0][0]=1
for i in range(n):
dp[i+1][0]=dp[i][0]*(100-p[i])
for j in range(i+1):
dp[i+1][j+1]=dp[i][j]*p[i]+dp[i][j+1]*(100-p[i])
print((sum([dp[n][i] for i in range((n+1)//2,n+1)])/pow(100,n))) | n=int(eval(input()))
p=list(map(float,input().split()))
dp=[[0]*(n+1) for _ in range(n+1)]
dp[0][0]=1
for i in range(n):
dp[i+1][0]=dp[i][0]*(1-p[i])
for j in range(i+1):
dp[i+1][j+1]=dp[i][j]*p[i]+dp[i][j+1]*(1-p[i])
print((sum([dp[n][i] for i in range((n+1)//2,n+1)]))) | p03168 |
# 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 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 eval(input())
n = II()
P = LF()
# dp[i]: i枚のコインが表になる確率
dp = [1]
# 調和級数
# O(NlogN)
for i in range(n):
tmp = [0] * (i + 2)
p = P[i]
q = 1 - P[i]
for j in range(i + 1):
tmp[j] += dp[j] * q
tmp[j + 1] += dp[j] * p
dp = tmp
print((sum(dp[n // 2 + 1:])))
| # 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 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 eval(input())
def main():
n = II()
P = LF()
# dp[i]: i枚のコインが表になる確率
dp = [1]
# 調和級数
# O(NlogN)
for i in range(n):
tmp = [0] * (i + 2)
p = P[i]
q = 1 - P[i]
for j in range(i + 1):
tmp[j] += dp[j] * q
tmp[j + 1] += dp[j] * p
dp = tmp
return sum(dp[n // 2 + 1:])
print((main()))
| p03168 |
#import
#import math
#import numpy as np
N = int(eval(input()))
#= input()
#= map(int, input().split())
p = list(map(float, input().split()))
#= [input(), input()]
#= [list(map(int, input().split())) for _ in range(N)]
#= {i:[] for i in range(N)}
dp = [[0.0] * (N + 1) for _ in range(N + 1)]
dp[0][0] = 1
for i, p in enumerate(p, 1):
pp = 1 - p
for j in range(i + 1):
if j == 0:
dp[i][j] = dp[i - 1][j] * pp
elif j == i:
dp[i][j] = dp[i - 1][j - 1] * p
else:
dp[i][j] = dp[i - 1][j - 1] * p + dp[i - 1][j] * pp
res = 0.0
n = N // 2 + 1
for cnt in dp[-1][n:]:
res += cnt
print(res) | import sys
input = sys.stdin.readline
#import math
#import numpy as np
N = int(eval(input()))
#= input()
#= map(int, input().split())
p = list(map(float, input().split()))
#= [input(), input()]
#= [list(map(int, input().split())) for _ in range(N)]
#= {i:[] for i in range(N)}
dp = [[0.0] * (N + 1) for _ in range(N + 1)]
dp[0][0] = 1
for i, p in enumerate(p, 1):
pp = 1 - p
dpi = dp[i - 1]
for j in range(i + 1):
if j == 0:
dp[i][j] = dpi[j] * pp
elif j == i:
dp[i][j] = dpi[j - 1] * p
else:
dp[i][j] = dpi[j - 1] * p + dpi[j] * pp
res = 0.0
n = N // 2 + 1
for cnt in dp[-1][n:]:
res += cnt
print(res) | p03168 |
import sys
input=sys.stdin.readline
n=int(eval(input()))
P=tuple(map(float,input().split()))
DP=[[0]*(n+1) for _ in range(n+1)]
DP[0][0]=1
for i in range(1,n+1):
DP[i][0]=DP[i-1][0]*(1-P[i-1])
for i in range(1,n+1):
for j in range(1,i+1):
DP[i][j]=DP[i-1][j-1]*P[i-1]+DP[i-1][j]*(1-P[i-1])
ans=0
for i in range(n//2+1,n+1):
ans+=DP[-1][i]
print(ans) | import sys
input=sys.stdin.readline
n=int(eval(input()))
P=tuple(map(float,input().split()))
DP=[[0]*(n+1) for _ in range(n+1)]
DP[0][0]=1
for i in range(1,n+1):
for j in range(i+1):
DP[i][j]=DP[i-1][j]*(1-P[i-1])
if j:
DP[i][j]+=DP[i-1][j-1]*P[i-1]
ans=0
for i in range(n//2+1,n+1):
ans+=DP[-1][i]
print(ans) | p03168 |
import sys
input=sys.stdin.readline
n=int(eval(input()))
P=tuple(map(float,input().split()))
DP=[[0]*(n+1) for _ in range(n+1)]
DP[0][0]=1
for i in range(1,n+1):
for j in range(i+1):
DP[i][j]=DP[i-1][j]*(1-P[i-1])
if j:
DP[i][j]+=DP[i-1][j-1]*P[i-1]
ans=0
for i in range(n//2+1,n+1):
ans+=DP[-1][i]
print(ans) | import sys
input=sys.stdin.readline
n=int(eval(input()))
P=tuple(map(float,input().split()))
DP=[[0.0]*(n+1) for _ in range(n+1)]
DP[0][0]=1.0
for i in range(1,n+1):
for j in range(i+1):
DP[i][j]=DP[i-1][j]*(1-P[i-1])
if j:
DP[i][j]+=DP[i-1][j-1]*P[i-1]
ans=0.0
for i in range(n//2+1,n+1):
ans+=DP[-1][i]
print(ans) | p03168 |
n = int(eval(input()))
p = list(map(float, input().split()))
dp = [[0]*(n+1) for _ in range(n+1)]
dp[0][0] = 1
for i in range(1, n+1):
for j in range(n+1):
dp[i][j] += dp[i-1][j-1]*p[i-1]
dp[i][j] += dp[i-1][j]*(1-p[i-1])
print((sum(dp[-1][-(-n//2):])))
| n = int(eval(input()))
p = list(map(float, input().split()))
dp = [[0]*(n+1) for _ in range(n+1)]
dp[0][0] = 1
for i in range(1, n+1):
for j in range(n+1):
dp[i][j] = dp[i-1][j-1]*p[i-1]+dp[i-1][j]*(1-p[i-1])
print((sum(dp[-1][-(-n//2):])))
| p03168 |
N = int(eval(input()))
P = list(map(float, input().split()))
dp = [[0] * 3010 for _ in range(3010)]
dp[0][1] = 1
dp[0][0] = 1
# dp[i][j] iまでのコインを使って、j枚の表が出る確率
for i in range(N):
for j in range(i+1):
dp[i+1][j+1] += dp[i][j] * P[i]
dp[i+1][j] += dp[i][j] * (1-P[i])
print((sum(dp[N][N//2+1:])))
| N = int(eval(input()))
P = list(map(float, input().split()))
dp = [[0] * 3010 for _ in range(3010)]
dp[0][0] = 1
# dp[i][j] iまでのコインを使って、j枚の表が出る確率
for i in range(N):
for j in range(i+1):
dp[i+1][j+1] += dp[i][j] * P[i]
dp[i+1][j] += dp[i][j] * (1-P[i])
print((sum(dp[N][N//2+1:])))
| p03168 |
N = int(eval(input()))
p = list(map(float, input().split()))
dp = [[0]*(N+1) for i in range(N)]
# iまで見たときに表の枚数がj枚の確率
dp[0][0] = 1 - p[0]
dp[0][1] = p[0]
for i in range(1, N):
for j in range(N+1):
dp[i][j] = dp[i-1][j]*(1-p[i])
if j > 0:
dp[i][j] += dp[i-1][j-1]*p[i]
ans = sum(dp[-1][N//2 + 1:])
print(ans)
| def main():
N = int(eval(input()))
p = tuple(map(float, input().split()))
dp = [0 for i in range(N+1)]
# iまで見たときに表の枚数がj枚の確率
dp[0] = 1 - p[0]
dp[1] = p[0]
for i in range(1, N):
for j in range(i+1, -1, -1):
dp[j] = dp[j]*(1-p[i]) + dp[j-1]*p[i]
# else:
# dp[j] = dp[j]*(1-p[i])
ans = sum(dp[N//2 + 1:])
print(ans)
main()
| p03168 |
import sys
input=sys.stdin.readline
N=int(eval(input()))
p=list(map(float,input().split()))
dp=[[0]*(N+1)for _ in range(N+1)]
for i in range(N+1):
for j in range(N+1):
if i==0 and j==0:
dp[i][j]=1
elif i==0:
continue
elif j==0:
dp[i][j]=dp[i-1][j]*(1-p[i-1])
else:
dp[i][j]=(dp[i-1][j]*(1-p[i-1]))+(dp[i-1][j-1]*p[i-1])
ans=0
for j in range(((N//2)+1),N+1):
ans+=dp[N][j]
print(ans)
| import sys
input=sys.stdin.readline
N=int(eval(input()))
p=list(map(float,input().split()))
dp=[[0]*(N+1)for _ in range(N+1)]
for i in range(N+1):
for j in range(N+1):
if i==0 and j==0:
dp[i][j]=1
elif j==0:
dp[i][j]=dp[i-1][j]*(1-p[i-1])
elif i>=j:
dp[i][j]=(dp[i-1][j]*(1-p[i-1]))+(dp[i-1][j-1]*p[i-1])
ans=0
for j in range(((N//2)+1),N+1):
ans+=dp[N][j]
print(ans) | p03168 |
import sys
def main():
N=int(sys.stdin.readline())
p=[float(x) for x in sys.stdin.readline().split()]
dp=[[0 for _ in range(N+1)] for _ in range(N+1)]
dp[0][0]=1.0
for i in range(1,N+1):
dp[i][0]=dp[i-1][0]*(1-p[i-1])
for j in range(1,i+1):dp[i][j]=dp[i-1][j-1]*p[i-1]+dp[i-1][j]*(1-p[i-1])
print((sum(dp[N][N//2+1:])))
if __name__=='__main__':main()
| import sys
def main():
N=int(sys.stdin.readline())
p=[float(x) for x in sys.stdin.readline().split()]
dp=[0 for _ in range(N+1)]
dp[0]=1.0
for i in range(1,N+1):
for j in range(i,0,-1):dp[j]=dp[j-1]*p[i-1]+dp[j]*(1-p[i-1])
dp[0]=dp[0]*(1-p[i-1])
print((sum(dp[N//2+1:])))
if __name__=='__main__':main()
| p03168 |
n=int(eval(input()))
p=list(map(float,input().split()))
mid=(n+2)//2
dp=[[0]*(n+1) for i in range(n)]
dp[0][0]=1-p[0]
dp[0][1]=p[0]
for i in range(n-1):
for j in range(n+1):
if dp[i][j]!=0:
#表が出るとき
dp[i+1][j+1]+=dp[i][j]*p[i+1]
#裏
dp[i+1][j]+=dp[i][j]*(1-p[i+1])
print((sum(dp[-1][mid:]))) | n=int(eval(input()))
p=list(map(float,input().split()))
dp=[[0]*(n+1) for i in range(n)]
for i in range(n):
for j in range(n+1):
if i==0:
dp[0][0]=1-p[i]
dp[0][1]=p[i]
else:
#表が出る
if dp[i-1][j-1]!=0:
dp[i][j]+=dp[i-1][j-1]*p[i]
#裏
dp[i][j-1]+=dp[i-1][j-1]*(1-p[i])
print((sum(dp[-1][int(n/2)+1:])))
#print(dp)
| p03168 |
n = int(eval(input()))
probs = [float(c) for c in input().split()]
dp = [[0] * (n+1) for _ in range(n+1)]
dp[0][0] = 1
for coin in range(1, n+1):
for heads in range(n+1):
dp[coin][heads] = dp[coin-1][heads] * (1 - probs[coin-1])
if heads > 0:
dp[coin][heads] += dp[coin-1][heads-1] * probs[coin-1]
ans = 0
for i in range(n//2 + 1, n+1):
ans += dp[n][i]
print(ans) | n = int(eval(input()))
probs = [float(c) for c in input().split()]
dp = [0] * (n+1)
dp[0] = 1
for coin in range(n):
for heads in reversed(list(range(n+1))):
dp[heads] = dp[heads] * (1 - probs[coin-1])
if heads > 0:
dp[heads] += dp[heads-1] * probs[coin-1]
ans = 0
for heads in range(n+1):
tails = n - heads
if heads > tails:
ans += dp[heads]
print(ans) | p03168 |
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
# import heapq
import decimal
# import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
naf = lambda: list(map(float, sys.stdin.readline().split()))
n = ni()
p = naf()
dp = [[0 for _ in range(n + 1)] for __ in range(n + 1)]
dp[0][0] = 1
# dp[i][j] : pのうちi個めまでを投げて、表がj個出る確率
for i in range(n):
for j in range(n):
dp[i + 1][j + 1] += dp[i][j] * p[i]
dp[i + 1][j] += dp[i][j] * (1 - p[i])
print((sum(dp[n][(n + 1) // 2:])))
if __name__ == '__main__':
main()
| import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
# import heapq
import decimal
# import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
naf = lambda: list(map(float, sys.stdin.readline().split()))
n = ni()
p = naf()
dp = [[0 for _ in range(n + 1)] for __ in range(n + 1)]
dp[0][0] = 1
# dp[i][j] : pのうちi個めまでを投げて、表がj個出る確率
for i in range(n):
for j in range(i+1):
dp[i + 1][j + 1] += dp[i][j] * p[i]
dp[i + 1][j] += dp[i][j] * (1 - p[i])
print((sum(dp[n][(n + 1) // 2:])))
if __name__ == '__main__':
main()
| p03168 |
# @author
import sys
class ICoins:
def solve(self):
n = int(eval(input()))
p = [float(_) for _ in input().split()]
dp = [[0.0] * (n + 1) for _ in range(n + 1)]
# dp[i][j] probability of having i heads after j tosses
dp[0][0] = 1
for j in range(1, n + 1):
for i in range(j + 1):
dp[i][j] = dp[i][j - 1] * (1 - p[j - 1])
if i > 0:
dp[i][j] += dp[i - 1][j - 1] * p[j - 1]
ans = 0
for i in range(n + 1):
if i > n - i:
ans += dp[i][n]
print(ans)
solver = ICoins()
input = sys.stdin.readline
solver.solve()
| # @author
import sys
class ICoins:
def solve(self):
n = int(eval(input()))
p = [float(_) for _ in input().split()]
dp = [0.0] * (n + 1)
# dp[i][j] probability of having i heads after j tosses
dp[0] = 1
for j in range(1, n + 1):
for i in range(j, 0, -1):
dp[i] = dp[i] * (1 - p[j - 1]) + dp[i - 1] * p[j - 1]
dp[0] = dp[0] * (1 - p[j - 1])
ans = 0
for i in range(n + 1):
if i > n - i:
ans += dp[i]
print(ans)
solver = ICoins()
input = sys.stdin.readline
solver.solve()
| p03168 |
from pprint import pprint
n=int(eval(input()))
p=list(map(float,input().split()))
dp=[[0]*(n+1) for _ in range(n+1)]
dp[1][0]=1-p[0]
dp[1][1]=p[0]
for i in range(1,n):
dp[i+1][0]=dp[i][0]*(1-p[i])
for j in range(n):
dp[i+1][j+1]=dp[i][j+1]*(1-p[i])+dp[i][j]*p[i]
print((sum(dp[n][(n//2+1):])))
# pprint(dp) | n=int(eval(input()))
p=list(map(float,input().split()))
dp=[[0]*(n+1) for _ in range(n+1)]
dp[1][0]=1-p[0]
dp[1][1]=p[0]
for i in range(2,n+1):
for j in range(n+1):
dp[i][j]=dp[i-1][j]*(1-p[i-1])+dp[i-1][j-1]*p[i-1]
print((sum(dp[n][(n//2+1):]))) | p03168 |
import sys
# input処理を高速化する
input = sys.stdin.readline
def main():
N = int(eval(input()))
lst_p = list(map(float, input().split()))
# dp[i][j] := 最初の i 枚のコインを投げたときに、表が j 枚となる確率
# 次のコインが表: dp[i+1][j+1] += dp[i][j]∗p[i]
# 次のコインが裏: dp[i+1][j] += dp[i][j]∗(1.0−p[i])
dp = [[0] * (N+1) for i in range(N+1)]
# 初期条件
dp[0][0] = 1.0
for i in range(N):
for j in range(N):
dp[i+1][j+1] += dp[i][j] * lst_p[i]
dp[i+1][j] += dp[i][j] * (1.0 - lst_p[i])
ans = 0
for i in range((N+1)//2, N+1):
ans += dp[N][i]
print(ans)
main() | n = int(eval(input()))
p = list(map(float, input().split()))
dp = [[0]*(n+1) for _ in range(n+1)]
dp[0][0] = 1
# dp[i][j]:i番目以前の商品を見たときに表の枚数がj枚となる確率の和
for i in range(1,n+1):
for j in range(i+1):
dp[i][j] = dp[i-1][j]*(1-p[i-1])
if j>0:
dp[i][j] += dp[i-1][j-1]*p[i-1]
ans = sum(dp[n][(n+1)//2:])
print(ans) | p03168 |
import bisect
import heapq
import sys
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)
class V:
def __init__(self, f):
self.f = f
self.v = None
def __str__(self):
return str(self.v)
def ud(self, n):
if self.v is None:
self.v = n
else:
self.v = self.f(self.v, n)
def get(self):
return self.v
def read_values():
return list(map(int, input().split()))
def read_list():
return list(read_values())
def f(x, X, VX):
visit_node = [set(), set()]
visit_link = set()
q = queue.Queue()
q.put((0, x))
while not q.empty():
ps = q.get()
if ps in visit_node:
continue
p, s = ps
visit_node[p].add(s)
VX[p][s] = True
for t in X[p][s]:
l = (s, t) if p == 0 else (t, s)
if l in visit_link:
continue
visit_link.add(l)
if t in visit_node[1 - p]:
continue
q.put((1 - p, t))
return len(visit_node[0]) * len(visit_node[1]) - len(visit_link)
def main():
N = int(eval(input()))
X = {}
Y = {}
for _ in range(N):
x, y = read_values()
x -= 1
y -= 1
X.setdefault(x, set()).add(y)
Y.setdefault(y, set()).add(x)
VX = [False] * (10 ** 5)
VY = [False] * (10 ** 5)
res = 0
for x in list(X.keys()):
if VX[x]:
continue
if len(X[x]) < 2:
continue
res += f(x, [X, Y], [VX, VY])
for y in list(Y.keys()):
if VY[y]:
continue
if len(Y[y]) < 2:
continue
res += f(y, [Y, X], [VY, VX])
print(res)
if __name__ == "__main__":
main()
| import bisect
import heapq
import sys
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)
class V:
def __init__(self, f):
self.f = f
self.v = None
def __str__(self):
return str(self.v)
def ud(self, n):
if self.v is None:
self.v = n
else:
self.v = self.f(self.v, n)
def get(self):
return self.v
def read_values():
return list(map(int, input().split()))
def read_list():
return list(read_values())
def f(x, X, VX):
visit_node = [set(), set()]
visit_link = set()
q = queue.Queue()
q.put((0, x))
while not q.empty():
p, s = q.get()
if s in visit_node[p]:
continue
visit_node[p].add(s)
VX[p][s] = True
for t in X[p][s]:
l = (s, t) if p == 0 else (t, s)
if l in visit_link:
continue
visit_link.add(l)
if t in visit_node[1 - p]:
continue
q.put((1 - p, t))
return len(visit_node[0]) * len(visit_node[1]) - len(visit_link)
def main():
N = int(eval(input()))
X = {}
Y = {}
for _ in range(N):
x, y = read_values()
x -= 1
y -= 1
X.setdefault(x, set()).add(y)
Y.setdefault(y, set()).add(x)
VX = [False] * (10 ** 5)
VY = [False] * (10 ** 5)
res = 0
for x in list(X.keys()):
if VX[x]:
continue
res += f(x, [X, Y], [VX, VY])
for y in list(Y.keys()):
if VY[y]:
continue
res += f(y, [Y, X], [VY, VX])
print(res)
if __name__ == "__main__":
main()
| p02998 |
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x):
return -self.root[self.Find_Root(x)]
m = 100010
uf = UnionFind(m*2)
n = int(eval(input()))
for i in range(n):
x,y = list(map(int,input().split()))
y = y+m
uf.Unite(x,y)
lx = {}
ly = {}
ans = 0
for i in range(m):
rx = uf.Find_Root(i)
lx[rx] = lx.get(rx,0)+1
ry = uf.Find_Root(i+m)
ly[ry] = ly.get(ry,0)+1
for i in range(m*2):
ans += lx.get(i,0)*ly.get(i,0)
print((ans-n)) | import sys
sys.setrecursionlimit(10**5)
m = 100005
visited = [False]*(m*2)
cnt = [0,0]
def dfs(i):
visited[i] = True
cnt[i//m] = cnt[i//m]+1
for j in to[i]:
if not visited[j]:
dfs(j)
input = sys.stdin.readline
n = int(eval(input()))
to = [[] for _ in range(m*2)]
for _ in range(n):
x,y = list(map(int,input().split()))
y = y+m
to[x].append(y)
to[y].append(x)
ans = 0
for i in range(m):
if not visited[i]:
cnt = [0,0]
dfs(i)
ans = ans + cnt[0]*cnt[1]
print((ans-n)) | p02998 |
N = int(eval(input()))
points = []
for i in range(0, N):
points.append(list(map(int, input().split(' '))))
abcd = set(sum(points, []))
count = 0
for a in abcd:
for b in abcd:
for c in abcd:
for d in abcd:
if a == c and b == d:
continue
p = []
if [a, b] not in points:
p.append([a, b])
if [a, d] not in points:
p.append([a, d])
if [c, b] not in points:
p.append([c, b])
if [c, d] not in points:
p.append([c, d])
if len(p) == 1:
count += 1
points.append(p[0])
print(count) | N = int(eval(input()))
points = []
for i in range(0, N):
points.append(list(map(int, input().split(' '))))
X = dict()
Y = dict()
count = 0
for p in points:
if p[0] not in list(X.keys()):
X[p[0]] = []
X[p[0]].append(p[1])
if p[1] not in list(Y.keys()):
Y[p[1]] = []
Y[p[1]].append(p[0])
while len(list(X.items())) > 0:
item = list(X.items())[0]
del X[item[0]]
queue = [item]
point_dict = {'x': [], 'y': []}
queue_is_x = [True]
while len(queue) > 0:
item = queue.pop(0)
is_x = queue_is_x.pop(0)
if is_x:
point_dict['x'].append(item[0])
for i in item[1]:
if i in list(Y.keys()):
queue.append((i, Y[i]))
queue_is_x.append(False)
del Y[i]
else:
point_dict['y'].append(item[0])
for i in item[1]:
if i in list(X.keys()):
queue.append((i, X[i]))
queue_is_x.append(True)
del X[i]
# print((point_dict['x']))
# print(len((point_dict['x'])))
# print((point_dict['y']))
# print(len((point_dict['y'])))
count += len(set(point_dict['x'])) * len(set(point_dict['y']))
print((count - len(points))) | p02998 |
class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
complexity:
init: O(n)
find, unite, same: O(alpha(n))
used in SRM505 div.2 900, ATC001 A, DSL1A(AOJ)
"""
def __init__(self, n):
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
M = 10 ** 5
uft = UnionFindTree(N + 2 * M)
for i in range(N):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
uft.unite(i, x + N)
uft.unite(i, y + N + M)
x_dict, y_dict = dict(), dict()
for x in range(N, M + N):
par_x = uft.find(x)
x_dict[par_x] = x_dict.get(par_x, 0) + 1
for y in range(N + M, N + 2 * M):
par_y = uft.find(y)
y_dict[par_y] = y_dict.get(par_y, 0) + 1
ans = -N
for r in list(x_dict.keys()):
ans += x_dict.get(r, 0) * y_dict.get(r, 0)
print(ans)
| class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
complexity:
init: O(n)
find, unite, same: O(alpha(n))
used in SRM505 div.2 900, ATC001 A, DSL1A(AOJ)
"""
def __init__(self, n):
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
M = 10 ** 5
uft = UnionFindTree(2 * M)
for _ in range(N):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
uft.unite(x, y + M)
x_dict, y_dict = dict(), dict()
for x in range(M):
par_x = uft.find(x)
x_dict[par_x] = x_dict.get(par_x, 0) + 1
for y in range(M, 2 * M):
par_y = uft.find(y)
y_dict[par_y] = y_dict.get(par_y, 0) + 1
ans = -N
for r in list(x_dict.keys()):
ans += x_dict.get(r, 0) * y_dict.get(r, 0)
print(ans)
| p02998 |
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
edges = defaultdict(list)
for _ in range(N):
x, y = LI()
edges[x].append(-y)
edges[-y].append(x)
visited = defaultdict(int)
if max(len(li) for li in list(edges.values())) == 2 and N == 10 ** 5:
return (N * N) - N
def solve(v):
visited[v] = 1
ret = [v]
for u in edges[v]:
if not visited[u]:
ret += solve(u)
return ret
ans = -N
for node in edges:
if not visited[node]:
li = solve(node)
m, p = 0, 0
for z in li:
if z < 0:
m += 1
else:
p += 1
ans += m * p
return ans
print((main())) | import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx != 0 and gy != 0: # merge
if gx == gy:
continue
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
m, p = 0, 0
for xy in xys:
if xy < 0:
m += 1
else:
p += 1
ans += m * p
return ans
print((main())) | p02998 |
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx != 0 and gy != 0 and gx != gy: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(1 for xy in xys if xy > 0)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx != 0 and gy != 0 and gx != gy: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = len([1 for xy in xys if xy > 0])
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | p02998 |
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for _ in range(N):
x, y = LI()
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx != 0 and gy != 0: # merge
if gx == gy:
continue
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx != 0 and gy != 0: # merge
if gx == gy:
continue
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | p02998 |
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx != 0 and gy != 0: # merge
if gx == gy:
continue
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx == gy != 0:
continue
elif gx != 0 and gy != 0: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | p02998 |
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = [None] * (10 ** 5 * 2 + 1)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx == gy is not None:
continue
elif gx is not None is not gy: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx == gy != 0:
continue
elif gx != 0 and gy != 0: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
elif gx != 0:
xy2g[y] = gx
g2xy[gx].add(y)
elif gy != 0:
xy2g[x] = gy
g2xy[gy].add(x)
else:
g = x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | p02998 |
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx == gy != 0:
continue
elif gx != 0 and gy != 0: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
elif gx != 0:
xy2g[y] = gx
g2xy[gx].add(y)
elif gy != 0:
xy2g[x] = gy
g2xy[gy].add(x)
else:
g = x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx == 0 or gy == 0:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
elif gx != gy: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
ans = -N
for xys in list(g2xy.values()):
nx = sum(xy > 0 for xy in xys)
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | p02998 |
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx == 0 or gy == 0:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
elif gx != gy: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
ans = -N
for xys in list(g2xy.values()):
nx, ny = 0, 0
for xy in xys:
if xy > 0:
nx += 1
else:
ny += 1
ans += nx * ny
return ans
print((main())) | import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def YesNo(x): return 'Yes' if x else 'No'
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 eval(input())
from collections import defaultdict
def main():
N = II()
xy = []
for _ in range(N):
xy.append(LI())
xy2g = defaultdict(int)
g2xy = defaultdict(set)
for x, y in xy:
y = -y
gx = xy2g[x]
gy = xy2g[y]
if gx != gy and gx != 0 and gy != 0: # merge
if len(g2xy[gx]) < len(g2xy[gy]):
gx, gy = gy, gx
for xy in g2xy[gy]:
xy2g[xy] = gx
g2xy[gx] |= g2xy[gy]
g2xy[gy].clear()
else:
g = gx or gy or x
xy2g[x] = xy2g[y] = g
g2xy[g] |= {x, y}
ans = -N
for xys in list(g2xy.values()):
nx = 0
for xy in xys:
if xy > 0:
nx += 1
ny = len(xys) - nx
ans += nx * ny
return ans
print((main())) | p02998 |
from bisect import bisect_left
from collections import defaultdict
N = int(eval(input()))
points = list(tuple(map(int,input().split())) for _ in range(N))
xty = defaultdict(list)
ytx = defaultdict(list)
for x,y in points:
xty[x].append(y)
ytx[y].append(x)
area = 0
X = set()
Y = set()
for x,y in points:
if x in X or y in Y:
continue
stack_x = [x]
stack_y = [y]
dx = set()
dy = set()
while stack_x or stack_y:
while stack_x:
x = stack_x.pop()
dx.add(x)
for y in xty[x]:
if y not in dy:
stack_y.append(y)
while stack_y:
y = stack_y.pop()
dy.add(y)
for x in ytx[y]:
if x not in dx:
stack_x.append(x)
X |= dx
Y |= dy
area += len(dx)*len(dy)
print((area-len(points))) | from bisect import bisect_left
from collections import defaultdict
N = int(eval(input()))
points = list(tuple(map(int,input().split())) for _ in range(N))
xty = defaultdict(list)
ytx = defaultdict(list)
for x,y in points:
xty[x].append(y)
ytx[y].append(x)
area = 0
X = set()
Y = set()
for x,y in points:
if x in X or y in Y:
continue
stack_x = [x]
stack_y = [y]
dx = set()
dy = set()
while stack_x or stack_y:
while stack_x:
x = stack_x.pop()
if x not in dx:
dx.add(x)
for y in xty[x]:
if y not in dy:
stack_y.append(y)
while stack_y:
y = stack_y.pop()
if y not in dy:
dy.add(y)
for x in ytx[y]:
if x not in dx:
stack_x.append(x)
X |= dx
Y |= dy
area += len(dx)*len(dy)
print((area-len(points))) | p02998 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def read_int():
return int(input())
def read_int_n():
return tuple(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, XY):
g = [[] for _ in range((10**5)*2)]
offset = 10**5
cs = set()
for x, y in XY:
x -= 1
y = y - 1 + offset
g[x].append(y)
g[y].append(x)
cs.add(x)
cs.add(y)
ans = 0
while cs:
error_print(len(cs))
q = set([cs.pop()])
done = set()
done_c = set()
while q:
v = q.pop()
for u in g[v]:
if v >= offset:
e = (u, v)
else:
e = (v, u)
if e not in done:
q.add(u)
done.add(e)
done_c.add(u)
done_c.add(v)
xn = set()
yn = set()
for v, u in done:
for z in (v, u):
if z >= offset:
yn.add(z)
else:
xn.add(z)
ans += (len(xn) * len(yn)) - len(done)
cs -= done_c
return ans
def main():
N = read_int()
XY = [read_int_n() for _ in range(N)]
print(slv(N, XY))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, XY):
from collections import defaultdict
g = defaultdict(set)
yo = 10**6
V = set()
for x, y in XY:
y += yo
g[x].add(y)
g[y].add(x)
V.add(x)
V.add(y)
rem = set(v for v in V)
done = set()
ans = 0
while rem:
u = rem.pop()
s = [u]
done.add(u)
xs = set()
ys = set()
if u >= yo:
ys.add(u)
else:
xs.add(u)
while s:
u = s.pop()
if u >= yo:
ys.add(u)
else:
xs.add(u)
for v in g[u]:
if v in done:
continue
s.append(v)
done.add(v)
rem -= xs
rem -= ys
e = 0
for u in xs:
e += len(g[u])
ans += len(xs) * len(ys) - e
return ans
def main():
N = read_int()
XY = [read_int_n() for _ in range(N)]
print(slv(N, XY))
if __name__ == '__main__':
main()
| p02998 |
import sys
sys.setrecursionlimit(10**6)
def dfs(x, al):
global cntx, cnty
if (al, x) in used:
return
used.add((al, x))
if al == 0:
cntx += 1
else:
cnty += 1
for xy in to[al][x]:
dfs(xy, 1 - al)
return
n = int(eval(input()))
to = [{}, {}]
for _ in range(n):
x, y = list(map(int, input().split()))
to[0].setdefault(x, [])
to[1].setdefault(y, [])
to[0][x] += [y]
to[1][y] += [x]
used = set()
ans = 0
for x in list(to[0].keys()):
if (0, x) in used: continue
cntx = 0
cnty = 0
dfs(x, 0)
ans += cntx * cnty
print((ans - n))
| def get_group(x):
g = group[x]
if g == x:
return x
group[g] = re = get_group(g)
return re
def unite(x, y):
gx = get_group(x)
gy = get_group(y)
if gx != gy:
dx = depth[gx]
dy = depth[gy]
if dy > dx:
gx, gy = gy, gx
group[gy] = gx
if dx == dy:
depth[gx] += 1
n = int(eval(input()))
group = {}
depth = {}
edge = []
for _ in range(n):
x, y = list(map(int, input().split()))
group.setdefault(x, x)
group.setdefault(-y, -y)
depth.setdefault(x, 1)
depth.setdefault(-y, 1)
edge += [[x, -y]]
for x, y in edge:
unite(x, y)
cnt = {}
for k in list(group.keys()):
g = get_group(k)
cnt.setdefault(g, [0, 0])
if k > 0:
cnt[g][0] += 1
else:
cnt[g][1] += 1
ans = 0
for cx, cy in list(cnt.values()):
ans += cx * cy
print((ans - n))
| p02998 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
""" 根を見つける関数を定義（同時にxを直接根にくっつける操作も行う）"""
tmp = []
parents = self.parents
while parents[x] >= 0:
tmp.append(x)
x = parents[x]
for y in tmp:
parents[y] = x
return 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):
""" xとyが同じ根の子かを判定 """
return self.find(x) == self.find(y)
def size(self, x):
""" x の根の parent（= 要素数）を返す """
return -self.parents[self.find(x)]
def members(self, x):
""" xが属するグループの要素をリストとして返す O(N)"""
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
""" 全ての根の要素をリストとして返す O(N)"""
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
""" グループの数を返す O(1)"""
return len(self.roots())
def size_list(self):
""" 各グループの要素数のリストを返す(根の番号は返さない) O(N)"""
return [-x for x in self.parents if x < 0]
def all_group_members(self):
""" {根:[根の子(根を含む)のリスト],...}を辞書で返す """
res = dict()
for i in range(self.n):
x = self.find(i)
res[x] = res.get(x,[]) + [i]
return {r: res[r] for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
##############################################################################################################
import sys
input = sys.stdin.readline
N = int(eval(input()))
U = UnionFind(2*N)
P = [[] for _ in range(N)]
code1, code2 = {}, {}
for i in range(N):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
if a not in code1:
code1[a]=i
if b not in code2:
code2[b]=i+N
U.union(code1[a],code2[b])
res = 0
for a in list(U.all_group_members().values()):
x, y = 0, 0
for b in a:
if b<N: x += 1
else: y += 1
res += x*y
print((res-N)) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
""" 根を見つける関数を定義（同時にxを直接根にくっつける操作も行う）"""
tmp = []
parents = self.parents
while parents[x] >= 0:
tmp.append(x)
x = parents[x]
for y in tmp:
parents[y] = x
return 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):
""" xとyが同じ根の子かを判定 """
return self.find(x) == self.find(y)
def size(self, x):
""" x の根の parent（= 要素数）を返す """
return -self.parents[self.find(x)]
def members(self, x):
""" xが属するグループの要素をリストとして返す O(N)"""
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
""" 全ての根の要素をリストとして返す O(N)"""
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
""" グループの数を返す O(1)"""
return len(self.roots())
def size_list(self):
""" 各グループの要素数のリストを返す(根の番号は返さない) O(N)"""
return [-x for x in self.parents if x < 0]
def all_group_members(self):
""" {根:[根の子(根を含む)のリスト],...}を辞書で返す """
res = [[] for _ in range(self.n)]
for i in range(self.n):
x = self.find(i)
res[x].append(i)
return {r: res[r] for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
##############################################################################################################
import sys
input = sys.stdin.readline
N = int(eval(input()))
U = UnionFind(2*N)
P = [[] for _ in range(N)]
code1, code2 = {}, {}
for i in range(N):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
if a not in code1:
code1[a]=i
if b not in code2:
code2[b]=i+N
U.union(code1[a],code2[b])
res = 0
for a in list(U.all_group_members().values()):
x, y = 0, 0
for b in a:
if b<N: x += 1
else: y += 1
res += x*y
print((res-N)) | p02998 |
import os
import sys
from collections import defaultdict
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
class UnionFind:
def __init__(self, size=None, nodes=None):
"""
size か nodes どっちか指定。
nodes は set、size は list を使う。
set の最悪計算量は O(N) なので size 指定のほうが若干速い
:param int size:
:param collections.Iterable nodes:
"""
assert size is not None or nodes is not None
if size is not None:
self._parents = [i for i in range(size)]
self._ranks = [0 for _ in range(size)]
self._sizes = [1 for _ in range(size)]
else:
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
def unite(self, x, y):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:return:
"""
x = self.find(x)
y = self.find(y)
if x == y:
return
# rank が小さい方が下
if self._ranks[x] > self._ranks[y]:
# x が root
self._parents[y] = x
self._sizes[x] += self._sizes[y]
else:
# y が root
self._parents[x] = y
self._sizes[y] += self._sizes[x]
if self._ranks[x] == self._ranks[y]:
self._ranks[y] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
self._parents[x] = self.find(self._parents[x])
return self._parents[x]
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
class WeightedUnionFind:
def __init__(self, size=None, nodes=None):
"""
size か nodes どっちか指定。
nodes は set、size は list を使う。
set の最悪計算量は O(N) なので size 指定のほうが若干速い
:param int size:
:param collections.Iterable nodes:
"""
assert size is not None or nodes is not None
if size is not None:
self._parents = [i for i in range(size)]
self._ranks = [0 for _ in range(size)]
self._sizes = [1 for _ in range(size)]
# 直近の親からの重み。root なら 0
self._weights = [0 for _ in range(size)]
else:
self._parents = {k: k for k in nodes}
self._ranks = {k: 0 for k in nodes}
self._sizes = {k: 1 for k in nodes}
# 直近の親からの重み。root なら 0
self._weights = {k: 0 for k in nodes}
def unite(self, x, y, w):
"""
x が属する木と y が属する木を併合
:param x:
:param y:
:param w: x と y の重みの差; (重み y) - (重み x)
:return:
"""
rx = self.find(x)
ry = self.find(y)
if rx == ry:
return
# rank が小さい方が下
if self._ranks[rx] > self._ranks[ry]:
# x が root
self._parents[ry] = rx
self._sizes[rx] += self._sizes[ry]
# root 間の重みに変換
self._weights[ry] = w + self._weights[x] - self._weights[y]
else:
# y が root
self._parents[rx] = ry
self._sizes[ry] += self._sizes[rx]
# root 間の重みに変換
self._weights[rx] = -w + self._weights[y] - self._weights[x]
if self._ranks[rx] == self._ranks[ry]:
self._ranks[ry] += 1
def find(self, x):
"""
x が属する木の root
:param x:
:return:
"""
if self._parents[x] == x:
return x
root = self.find(self._parents[x])
self._weights[x] += self._weights[self._parents[x]]
self._parents[x] = root
return root
def size(self, x):
"""
x が属する木のノード数
:param x:
:return:
"""
return self._sizes[self.find(x)]
def weight(self, x):
"""
:param x:
:return:
"""
# 経路圧縮
self.find(x)
return self._weights[x]
def diff(self, x, y):
"""
(y の重み) - (x の重み)
:param x:
:param y:
:return:
"""
if self.find(x) == self.find(y):
return self._weights[y] - self._weights[x]
return float("inf")
N = int(sys.stdin.readline())
X, Y = list(zip(*[list(map(int, sys.stdin.readline().split())) for _ in range(N)]))
yx = defaultdict(lambda: set())
xy = defaultdict(lambda: set())
for x, y in zip(X, Y):
xy[x].add(y)
yx[y].add(x)
# x が同じである y をまとめる
uf = UnionFind(size=10 ** 5 + 1)
for ys in list(xy.values()):
yli = list(ys)
for y1, y2 in zip(yli[1:], yli[:-1]):
uf.unite(y1, y2)
# まとめた y をキーに x をまとめ直す
yx2 = defaultdict(lambda: set())
for y, xs in list(yx.items()):
root = uf.find(y)
yx2[root] |= xs
# y の数 * x の数だけ作れる
ans = 0
for y, xs in list(yx2.items()):
ans += uf.size(y) * len(xs)
# すでにある頂点は消す
ans -= N
print(ans)
| import os
import sys
from collections import defaultdict
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
N = int(sys.stdin.readline())
X, Y = list(zip(*[list(map(int, sys.stdin.readline().split())) for _ in range(N)]))
yx = defaultdict(lambda: set())
xy = defaultdict(lambda: set())
for x, y in zip(X, Y):
xy[x].add(y)
yx[y].add(x)
def connected(x=None, y=None, xret=None, yret=None):
xret = xret if xret else set()
yret = yret if yret else set()
if x is not None:
for y in xy[x]:
if y in yret:
continue
yret.add(y)
xret, yret = connected(y=y, xret=xret, yret=yret)
if y is not None:
for x in yx[y]:
if x in xret:
continue
xret.add(x)
xret, yret = connected(x=x, xret=xret, yret=yret)
return xret, yret
x_counted = set()
y_counted = set()
# X と Y の二部グラフで、連結であるすべての組に辺を張る
ans = 0
for x in list(xy.keys()):
if x in x_counted:
continue
xs, ys = connected(x=x)
# 辺数
ans += len(xs) * len(ys)
x_counted |= xs
y_counted |= ys
# すでにある辺が重複してる
ans -= N
print(ans)
| p02998 |
class UnionFind :
def __init__(self, size) :
self.parent = list(range(size))
self.height = [0] * size
self.size = [1] * size
self.component = size
def root(self, index) :
if self.parent[index] == index : # 根の場合
return index
rootIndex = self.root(self.parent[index]) # 葉の場合親の根を取得
self.parent[index] = rootIndex # 親の付け直し
return rootIndex
def union(self, index1, index2) : # 結合
root1 = self.root(index1)
root2 = self.root(index2)
if root1 == root2 : # 連結されている場合
return
self.component -= 1 # 連結成分を減らす
if self.height[root1] < self.height[root2] :
self.parent[root1] = root2 # root2に結合
self.size[root2] += self.size[root1]
else :
self.parent[root2] = root1 # root1に結合
self.size[root1] += self.size[root2]
if self.height[root1] == self.height[root2] :
self.height[root1] += 1
return
def isSameRoot(self, index1, index2) :
return self.root(index1) == self.root(index2)
def sizeOfSameRoot(self, index) :
return self.size[self.root(index)]
def getComponent(self) :
return self.component
N = int(eval(input()))
R = 10**5 + 10
IXY = []
for i in range(N):
x, y = list(map(int, input().split()))
IXY.append((i, x, y))
X = [[] for _ in range(R)]
Y = [[] for _ in range(R)]
for i, x, y in IXY:
X[x].append(i)
Y[y].append(i)
tree = UnionFind(N)
for x in X:
for fr, to in zip(x, x[1:]):
tree.union(fr, to)
for y in Y:
for fr, to in zip(y, y[1:]):
tree.union(fr, to)
G = [[0, set(), set()] for _ in range(N)]
for i, x, y in IXY:
r = tree.root(i)
G[r][0] += 1
G[r][1].add(x)
G[r][2].add(y)
ans = 0
for grp in G:
if grp[0] < 3:
continue
x = len(grp[1])
y = len(grp[2])
A = x * y
ans += max(0, A - grp[0])
print(ans)
| class UnionFind:
def __init__(self, size):
self.parent = list(range(size))
self.height = [0] * size
self.size = [1] * size
self.componentCount = size
def root(self, index):
if self.parent[index] == index: # 根の場合
return index
rootIndex = self.root(self.parent[index]) # 葉の場合親の根を取得
self.parent[index] = rootIndex # 親の付け直し
return rootIndex
def union(self, index1, index2): # 結合
root1 = self.root(index1)
root2 = self.root(index2)
if root1 == root2: # 連結されている場合
return
self.componentCount -= 1 # 連結成分を減らす
if self.height[root1] < self.height[root2]:
self.parent[root1] = root2 # root2に結合
self.size[root2] += self.size[root1]
else:
self.parent[root2] = root1 # root1に結合
self.size[root1] += self.size[root2]
if self.height[root1] == self.height[root2]:
self.height[root1] += 1
return
def isSameRoot(self, index1, index2):
return self.root(index1) == self.root(index2)
def sizeOfSameRoot(self, index):
return self.size[self.root(index)]
from collections import defaultdict
N = int(eval(input()))
XY = [tuple(map(int, input().split())) for _ in range(N)]
xGrp = defaultdict(list)
yGrp = defaultdict(list)
for i, (x, y) in enumerate(XY):
xGrp[x].append(i)
yGrp[y].append(i)
tree = UnionFind(N)
for grp in list(xGrp.values()):
for l, r in zip(grp, grp[1:]):
tree.union(l, r)
for grp in list(yGrp.values()):
for l, r in zip(grp, grp[1:]):
tree.union(l, r)
xGrpList = defaultdict(set)
yGrpList = defaultdict(set)
for i, (x, y) in enumerate(XY):
xGrpList[tree.root(i)].add(x)
yGrpList[tree.root(i)].add(y)
ans = 0
for i in range(N):
if i != tree.root(i):
continue
X, Y = xGrpList[i], yGrpList[i]
if len(X) + len(Y) < 3:
continue
A = len(X) * len(Y)
ans += A - tree.sizeOfSameRoot(i)
print(ans)
| p02998 |
import sys
# DFSの再帰限界を増やす
sys.setrecursionlimit(10**6)
N = int(eval(input()))
nmax = 100001
# nmax = 10
# 第一成分にx,第二成分にyをぶち込んでいく。(二部グラフなので)
xys = [[[] for i in range(nmax)] for j in range(2)]
used = [[0 for i in range(nmax)] for j in range(2)]
# 読み込み
for _ in range(N):
x, y = list(map(int, input().split()))
xys[0][x].append(y)
xys[1][y].append(x)
# print(xys)
# 座標の切り替えをx = 1 or 0と1-xで行うのか、うまい！
# よく考えたらtrue/falseをひっくり返しているだけか。
def dfs(i, el=0):
# el=0->x, el=1->y
for i in xys[el][i]:
if not used[1-el][i]:
used[1-el][i] = True
dfs(i, 1-el)
cnt[1-el] += 1
ans = 0
for i in range(nmax):
# まだ行ったことがなくて空じゃないところ
if xys[0][i] != [] and used[0][i] == 0:
used[0][i] = 1
cnt = [1,0]
dfs(i,0)
ans += cnt[0]*cnt[1]
print((ans-N))
| from collections import deque
N = int(eval(input()))
nmax = 2*10**5
nhalf = 10**5
G = [[] for i in range(nmax)]
for i in range(N):
x,y = list(map(int,input().split()))
G[x-1].append(nhalf+y-1)
G[nhalf+y-1].append(x-1)
used = [False] * nmax
ans = 0
# 全探索
for i in range(nhalf):
# 見つかったノードからBFS
if G[i] != [] and not used[i]:
cnt_1 = 0 #前半の連結
cnt_2 = 0 #後半の連結
q = deque([i])
used[i] = True # 始めどこから行くか
while len(q) > 0:
a = q.popleft()
if a < nhalf:
cnt_2 += 1
else:
cnt_1 += 1
Vs = G[a]
# print(Vs)
for u in Vs: # 頂点以外の要素がグラフにあるときはここ
if not used[u]:
q.append(u)
# なにか処理を書きたいときはここに書く
used[u] = True
ans += cnt_1*cnt_2
print((ans-N)) | p02998 |
class UnionFind:
def __init__(self, n):
self.v = [-1 for _ in range(n)]
def find(self, x):
if self.v[x] < 0: # (負)は根
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if -self.v[x] < -self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
def root(self, x):
return self.v[x] < 0
def size(self, x):
return -self.v[self.find(x)]
mx = 10 ** 5 + 10
n = int(eval(input()))
uf = UnionFind(mx * 2)
for _ in range(n):
x, y = list(map(int, input().split()))
uf.unite(x, y + mx)
vx = [0] * (mx * 2)
vy = [0] * (mx * 2)
for i in range(mx):
root = uf.find(i)
vx[root] += 1
for i in range(mx, mx * 2):
root = uf.find(i)
vy[root] += 1
ans = -n
for xx, yy in zip(vx, vy):
ans += xx * yy
print(ans)
| # https://drken1215.hatenablog.com/entry/2019/06/23/004700
# https://tjkendev.github.io/procon-library/python/union_find/union_find.html
def main():
import sys
input = sys.stdin.readline
MX = 10 ** 5 + 10
*p, = [r for r in range(MX * 2)]
def root(x):
if x == p[x]:
return x
p[x] = y = root(p[x])
return y
def unite(x, y):
px = root(x)
py = root(y)
if px == py:
return 0
if px < py:
p[py] = px
else:
p[px] = py
return 1
n = int(eval(input()))
for _ in range(n):
x, y = (int(x) - 1 for x in input().split()) # [1,)->[0,)
unite(x, y + MX)
xs = [0] * (MX * 2)
ys = [0] * (MX * 2)
for r in range(MX):
xs[root(r)] += 1
for r in range(MX, MX * 2):
ys[root(r)] += 1
ans = -n
for r in range(MX * 2):
ans += xs[r] * ys[r]
print(ans)
if __name__ == '__main__':
main()
| p02998 |
def main():
from collections import deque
import sys
input = sys.stdin.readline
M = 10 ** 5
N = int(eval(input()))
g = tuple(set() for _ in range(M * 2))
for _ in range(N):
x, y = (int(x) - 1 for x in input().split()) # 一律に移動
g[x].add(y + M)
g[y + M].add(x)
visited = [0] * (M * 2)
ans = 0
for s in range(M * 2):
if visited[s]: continue
visited[s] = 1
dq = deque()
dq.append(s)
sz = 0
x = 0
e = 0
while dq:
v = dq.popleft()
sz += 1
if v < M:
x += 1
for u in g[v]:
e += 1
if visited[u]: continue
visited[u] = 1
dq.append(u)
ans += (sz - x) * x - (e // 2)
# ans += (sz - x) * x - (sz - 1) # sz-1は木に限られるのでWA
print(ans)
if __name__ == '__main__':
main()
| def main():
from collections import deque
import sys
input = sys.stdin.readline
M = 10 ** 5
N = int(eval(input()))
g = tuple(set() for _ in range(M * 2))
for _ in range(N):
x, y = (int(x) - 1 for x in input().split()) # 一律に移動
g[x].add(y + M)
g[y + M].add(x)
visited = [0] * (M * 2)
ans = 0
for s in range(M * 2): # xとy+Mのsetの方が確認する数は減る?
if visited[s]: continue
visited[s] = 1
dq = deque()
dq.append(s)
sz = 0
x = 0
while dq:
v = dq.popleft()
sz += 1
if v < M:
x += 1
for u in g[v]:
if visited[u]: continue
visited[u] = 1
dq.append(u)
ans += (sz - x) * x
ans -= N
print(ans)
if __name__ == '__main__':
main()
# 連結成分ごとに
# x,yの二部グラフを完全二部グラフにする
# cnt(x)*cnt(y)-既存の辺数の総和
# 最後にN引けばよい
| p02998 |
def main():
from collections import deque
import sys
input = sys.stdin.readline
M = 10 ** 5
N = int(eval(input()))
g = tuple(set() for _ in range(M * 2))
for _ in range(N):
x, y = (int(x) - 1 for x in input().split()) # 一律に移動
g[x].add(y + M)
g[y + M].add(x)
visited = [0] * (M * 2)
ans = 0
for s in range(M * 2): # xとy+Mのsetの方が確認する数は減る?
if visited[s]: continue
visited[s] = 1
dq = deque()
dq.append(s)
sz = 0
x = 0
while dq:
v = dq.popleft()
sz += 1
if v < M:
x += 1
for u in g[v]:
if visited[u]: continue
visited[u] = 1
dq.append(u)
ans += (sz - x) * x
ans -= N
print(ans)
if __name__ == '__main__':
main()
# 連結成分ごとに
# x,yの二部グラフを完全二部グラフにする
# cnt(x)*cnt(y)-既存の辺数の総和
# 最後にN引けばよい
| def main():
from collections import deque
import sys
input = sys.stdin.readline
M = 10 ** 5
N = int(eval(input()))
g = tuple(set() for _ in range(M * 2))
ps = set()
for _ in range(N):
x, y = (int(x) - 1 for x in input().split()) # 一律に移動
g[x].add(y + M)
g[y + M].add(x)
ps.add(x)
ps.add(y + M)
visited = [0] * (M * 2)
ans = 0
for s in ps:
if visited[s]: continue
visited[s] = 1
dq = deque()
dq.append(s)
sz = 0
x = 0
while dq:
v = dq.popleft()
sz += 1
if v < M:
x += 1
for u in g[v]:
if visited[u]: continue
visited[u] = 1
dq.append(u)
ans += (sz - x) * x
ans -= N
print(ans)
if __name__ == '__main__':
main()
# 連結成分ごとに
# x,yの二部グラフを完全二部グラフにする
# cnt(x)*cnt(y)-既存の辺数の総和
# 最後にN引けばよい
| p02998 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
s = S()
for i in range(len(s)-1):
if s[i] == s[i+1]:
print("Bad")
quit()
print("Good")
return
#B
def B():
n,l = LI()
a = [i+l for i in range(n)]
ans = sum(a)
m = n+l-1
for i in a[::-1]:
if i < 0:break
m = min(m,i)
ans -= m
print(ans)
return
#C
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
def C():
a,b,c,d = LI()
g = gcd(c,d)
l = c*d//g
sc = b//c-(a-1)//c
sd = b//d-(a-1)//d
sl = b//l-(a-1)//l
print((b-a+1-sc-sd+sl))
return
#D
def D():
n = I()
w = LIR(n)
w.sort(key = lambda x: x[1])
t = 0
for a,b in w:
if t+a > b:
print("No")
quit()
t += a
print("Yes")
return
#E
def E():
n,k = LI()
if k == 0:
m = (n*(n-1))//2
print(m)
for i in range(1,n+1):
for j in range(i+1,n+1):
print((i,j))
else:
if k > ((n-1)*(n-2))//2:
print((-1))
else:
ans = []
for i in range(2,n+1):
ans.append((1,i))
m = ((n-1)*(n-2))//2
for i in range(2,n+1):
for j in range(i+1,n+1):
if m == k:break
ans.append((i,j))
m -= 1
if m == k:break
print((len(ans)))
for i,j in ans:
print((i,j))
return
#F
def F():
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
v = defaultdict(list)
h = defaultdict(list)
par = defaultdict(int)
rank = defaultdict(int)
for i in range(n):
a,b = LI()
v[a].append(b)
h[b].append(a)
par[a] = a
rank[a] = 0
h = list(h.values())
for l in h:
for i in range(len(l)-1):
x = l[i]
y = l[i+1]
if root(x) != root(y):
unite(x,y)
h = defaultdict(list)
for i in list(par.keys()):
par[i] = root(par[i])
h[par[i]].append(i)
h = list(h.values())
ans = 0
for k in h:
f = defaultdict(lambda : 0)
l = []
m = 0
for i in k:
for j in v[i]:
if not f[j]:
m += 1
f[j] = 1
for i in k:
ans += m-len(v[i])
print(ans)
return
#Solve
if __name__ == "__main__":
F()
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
s = S()
for i in range(len(s)-1):
if s[i] == s[i+1]:
print("Bad")
quit()
print("Good")
return
#B
def B():
n,l = LI()
a = [i+l for i in range(n)]
ans = sum(a)
m = n+l-1
for i in a[::-1]:
if i < 0:break
m = min(m,i)
ans -= m
print(ans)
return
#C
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
def C():
a,b,c,d = LI()
g = gcd(c,d)
l = c*d//g
sc = b//c-(a-1)//c
sd = b//d-(a-1)//d
sl = b//l-(a-1)//l
print((b-a+1-sc-sd+sl))
return
#D
def D():
n = I()
w = LIR(n)
w.sort(key = lambda x: x[1])
t = 0
for a,b in w:
if t+a > b:
print("No")
quit()
t += a
print("Yes")
return
#E
def E():
n,k = LI()
if k == 0:
m = (n*(n-1))//2
print(m)
for i in range(1,n+1):
for j in range(i+1,n+1):
print((i,j))
else:
if k > ((n-1)*(n-2))//2:
print((-1))
else:
ans = []
for i in range(2,n+1):
ans.append((1,i))
m = ((n-1)*(n-2))//2
for i in range(2,n+1):
for j in range(i+1,n+1):
if m == k:break
ans.append((i,j))
m -= 1
if m == k:break
print((len(ans)))
for i,j in ans:
print((i,j))
return
#F
def F():
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
v = defaultdict(list)
h = defaultdict(list)
par = defaultdict(int)
rank = defaultdict(int)
for i in range(n):
a,b = LI()
v[a].append(b)
h[b].append(a)
par[a] = a
rank[a] = 0
h = list(h.values())
for l in h:
for i in range(len(l)-1):
x = l[i]
y = l[i+1]
if root(x) != root(y):
unite(x,y)
h = defaultdict(list)
for i in list(par.keys()):
par[i] = root(par[i])
h[par[i]].append(i)
h = list(h.values())
ans = 0
for k in h:
f = defaultdict(lambda : 0)
m = 0
for i in k:
for j in v[i]:
if not f[j]:
m += 1
f[j] = 1
for i in k:
ans += m-len(v[i])
print(ans)
return
#Solve
if __name__ == "__main__":
F()
| p02998 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
s = S()
for i in range(len(s)-1):
if s[i] == s[i+1]:
print("Bad")
quit()
print("Good")
return
#B
def B():
n,l = LI()
a = [i+l for i in range(n)]
ans = sum(a)
m = n+l-1
for i in a[::-1]:
if i < 0:break
m = min(m,i)
ans -= m
print(ans)
return
#C
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
def C():
a,b,c,d = LI()
g = gcd(c,d)
l = c*d//g
sc = b//c-(a-1)//c
sd = b//d-(a-1)//d
sl = b//l-(a-1)//l
print((b-a+1-sc-sd+sl))
return
#D
def D():
n = I()
w = LIR(n)
w.sort(key = lambda x: x[1])
t = 0
for a,b in w:
if t+a > b:
print("No")
quit()
t += a
print("Yes")
return
#E
def E():
n,k = LI()
if k == 0:
m = (n*(n-1))//2
print(m)
for i in range(1,n+1):
for j in range(i+1,n+1):
print((i,j))
else:
if k > ((n-1)*(n-2))//2:
print((-1))
else:
ans = []
for i in range(2,n+1):
ans.append((1,i))
m = ((n-1)*(n-2))//2
for i in range(2,n+1):
for j in range(i+1,n+1):
if m == k:break
ans.append((i,j))
m -= 1
if m == k:break
print((len(ans)))
for i,j in ans:
print((i,j))
return
#F
def F():
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
v = defaultdict(list)
h = defaultdict(list)
par = defaultdict(int)
rank = defaultdict(int)
for i in range(n):
a,b = LI()
v[a].append(b)
h[b].append(a)
par[a] = a
rank[a] = 0
h = list(h.values())
for l in h:
for i in range(len(l)-1):
x = l[i]
y = l[i+1]
if root(x) != root(y):
unite(x,y)
h = defaultdict(list)
for i in list(par.keys()):
par[i] = root(par[i])
h[par[i]].append(i)
h = list(h.values())
ans = 0
for k in h:
f = defaultdict(lambda : 0)
m = 0
for i in k:
for j in v[i]:
if not f[j]:
m += 1
f[j] = 1
for i in k:
ans += m-len(v[i])
print(ans)
return
#Solve
if __name__ == "__main__":
F()
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
s = S()
for i in range(len(s)-1):
if s[i] == s[i+1]:
print("Bad")
quit()
print("Good")
return
#B
def B():
n,l = LI()
a = [i+l for i in range(n)]
ans = sum(a)
m = n+l-1
for i in a[::-1]:
if i < 0:break
m = min(m,i)
ans -= m
print(ans)
return
#C
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
def C():
a,b,c,d = LI()
g = gcd(c,d)
l = c*d//g
sc = b//c-(a-1)//c
sd = b//d-(a-1)//d
sl = b//l-(a-1)//l
print((b-a+1-sc-sd+sl))
return
#D
def D():
n = I()
w = LIR(n)
w.sort(key = lambda x: x[1])
t = 0
for a,b in w:
if t+a > b:
print("No")
quit()
t += a
print("Yes")
return
#E
def E():
n,k = LI()
if k == 0:
m = (n*(n-1))//2
print(m)
for i in range(1,n+1):
for j in range(i+1,n+1):
print((i,j))
else:
if k > ((n-1)*(n-2))//2:
print((-1))
else:
ans = []
for i in range(2,n+1):
ans.append((1,i))
m = ((n-1)*(n-2))//2
for i in range(2,n+1):
for j in range(i+1,n+1):
if m == k:break
ans.append((i,j))
m -= 1
if m == k:break
print((len(ans)))
for i,j in ans:
print((i,j))
return
#F
def F():
n = I()
v = defaultdict(list)
l = []
f = defaultdict(lambda : 1)
for i in range(n):
x,y = LI()
y += 100001
v[x].append(y)
v[y].append(x)
if f[x]:
f[x] = 0
l.append(x)
if f[y]:
f[y] = 0
l.append(y)
ans = 0
bfs = defaultdict(lambda : 1)
q = deque()
for i in l:
if bfs[i]:
bfs[i] = 0
q.append(i)
nx = (i < 100001)
ny = 1-nx
while q:
x = q.popleft()
for y in v[x]:
if bfs[y]:
bfs[y] = 0
q.append(y)
k = (y < 100001)
nx += k
ny += (1-k)
ans += nx*ny
print((ans-n))
return
#Solve
if __name__ == "__main__":
F()
| p02998 |
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N = ri()
to = defaultdict(list)
V = 100005
X = []
for i in range(N):
x, y = rl()
X.append(x)
y += V
to[x].append(y)
to[y].append(x)
visited = set()
nx, ny = 0, 0
def dfs(n):
global nx, ny
if n in visited: return
visited.add(n)
if n < V:
nx += 1
else:
ny += 1
for m in to[n]:
dfs(m)
ans = 0
for x in X:
if x in visited: continue
nx, ny = 0, 0
dfs(x)
ans += nx*ny
print((ans-N))
| import sys, math
from collections import defaultdict, deque, Counter
# from bisect import bisect_left, bisect_right
# from itertools import combinations, permutations, product
# from heapq import heappush, heappop
# from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N = ri()
to = defaultdict(list)
V = 100005
X = []
for i in range(N):
x, y = rl()
X.append(x)
y += V
to[x].append(y)
to[y].append(x)
ans = 0
visited = {}
for x in X:
if x in visited: continue
nx, ny = 0, 0
queue = deque()
queue.append(x)
visited[x] = 1
while queue:
n = queue.pop()
if n < V:
nx += 1
else:
ny += 1
for m in to[n]:
if m in visited:
continue
visited[m] = 1
queue.append(m)
ans += nx*ny
print((ans-N))
| p02998 |
from collections import Counter
class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
MAX = 10 ** 5 + 10
uf = UnionFind(2 * MAX)
N, *XY = list(map(int, open(0).read().split()))
for x, y in zip(*[iter(XY)] * 2):
uf.union(x, y + MAX)
X = Counter(uf.find(i) for i in range(MAX))
Y = Counter(uf.find(i) for i in range(MAX, MAX * 2))
res = sum(X[i] * Y[i] for i in range(MAX * 2))
print((res - N))
| from collections import Counter
class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
def main():
MAX = 10 ** 5 + 1
uf = UnionFind(2 * MAX)
N, *XY = list(map(int, open(0).read().split()))
for x, y in zip(*[iter(XY)] * 2):
uf.union(x, y + MAX)
X = Counter(uf.find(i) for i in range(MAX))
Y = Counter(uf.find(i) for i in range(MAX, MAX * 2))
res = sum(X[i] * Y[i] for i in range(MAX * 2))
print((res - N))
if __name__ == '__main__':
main()
| p02998 |
from collections import Counter
def main():
class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
MAX = 10 ** 5 + 1
uf = UnionFind(2 * MAX)
N, *XY = list(map(int, open(0).read().split()))
for x, y in zip(*[iter(XY)] * 2):
uf.union(x, y + MAX)
X = Counter(uf.find(i) for i in range(MAX))
Y = Counter(uf.find(i) for i in range(MAX, MAX * 2))
res = sum(X[i] * Y[i] for i in range(MAX * 2))
print((res - N))
if __name__ == '__main__':
main()
| from collections import Counter
def main():
MAX = 10 ** 5 + 1
data = [-1] * (2 * MAX)
def find(x):
if data[x] < 0:
return x
else:
data[x] = find(data[x])
return data[x]
def union(x, y):
x, y = find(x), find(y)
if x != y:
if data[y] < data[x]:
x, y = y, x
data[x] += data[y]
data[y] = x
return (x != y)
N, *XY = list(map(int, open(0).read().split()))
for x, y in zip(*[iter(XY)] * 2):
union(x, y + MAX)
X = Counter(find(i) for i in range(MAX))
Y = Counter(find(i) for i in range(MAX, MAX * 2))
res = sum(X[i] * Y[i] for i in range(MAX * 2))
print((res - N))
if __name__ == '__main__':
main() | p02998 |
from collections import Counter
def main():
MAX = 10 ** 5 + 1
data = [-1] * (2 * MAX)
def find(x):
if data[x] < 0:
return x
else:
data[x] = find(data[x])
return data[x]
def union(x, y):
x, y = find(x), find(y)
if x != y:
if data[y] < data[x]:
x, y = y, x
data[x] += data[y]
data[y] = x
return (x != y)
N, *XY = list(map(int, open(0).read().split()))
for x, y in zip(*[iter(XY)] * 2):
union(x, y + MAX)
X = Counter(find(i) for i in range(MAX))
Y = Counter(find(i) for i in range(MAX, MAX * 2))
res = sum(X[i] * Y[i] for i in range(MAX * 2))
print((res - N))
if __name__ == '__main__':
main() | def main():
MAX = 10 ** 5 + 1
data = [-1] * (2 * MAX)
def find(x):
if data[x] < 0:
return x
else:
data[x] = find(data[x])
return data[x]
def union(x, y):
x, y = find(x), find(y)
if x != y:
if data[y] < data[x]:
x, y = y, x
data[x] += data[y]
data[y] = x
return (x != y)
N, *XY = list(map(int, open(0).read().split()))
for x, y in zip(*[iter(XY)] * 2):
union(x, y + MAX)
X = [0] * (MAX * 2)
Y = [0] * (MAX * 2)
for i in range(MAX):
X[find(i)] += 1
for i in range(MAX, MAX * 2):
Y[find(i)] += 1
res = sum(X[i] * Y[i] for i in range(MAX * 2))
print((res - N))
if __name__ == '__main__':
main()
| p02998 |
class UnionFind(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, x_zahyou, y_zahyou,parent=None, value=None):
self.group_id_ = group_id
self.x_zahyou = x_zahyou
self.y_zahyou = y_zahyou
self.parent_ = parent
self.value = value
self.rank_ = 1
def __str__(self):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.rank_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
root = self.root()
return root.group_id_
def rank(self):
root = self.root()
return root.rank_
def unite(self, unite_node):
root = self.root()
unite_root = unite_node.root()
if root.group_id_ != unite_root.group_id_:
if root.rank() > unite_root.rank():
unite_root.parent_ = root
root.rank_ = max(root.rank_, unite_root.rank_ + 1)
root.x_zahyou= root.x_zahyou | unite_root.x_zahyou
root.y_zahyou= root.y_zahyou | unite_root.y_zahyou
else:
root.parent_ = unite_root
unite_root.rank_ = max(root.rank_ + 1, unite_root.rank_)
unite_root.x_zahyou= root.x_zahyou | unite_root.x_zahyou
unite_root.y_zahyou= root.y_zahyou | unite_root.y_zahyou
N = int(eval(input()))
X = []
Y = []
node_list = []
for i in range(N):
x, y = list(map(int,input().split()))
X += [[i,x]]
Y += [[i,y]]
node_list += [UnionFind(i,set([x]),set([y]))]
X.sort(key=lambda x: x[1])
Y.sort(key=lambda x: x[1])
for i in range(N-1):
if X[i][1] == X[i+1][1] :
node_list[X[i][0]].unite(node_list[X[i+1][0]])
if Y[i][1] == Y[i+1][1] :
node_list[Y[i][0]].unite(node_list[Y[i+1][0]])
chouten = 0
for i in range(N):
if node_list[i].is_root():
chouten += len(node_list[i].x_zahyou) * len(node_list[i].y_zahyou)
print((chouten - N)) | class UnionFind(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, x_zahyou, y_zahyou,parent=None, value=None):
self.group_id_ = group_id
self.x_zahyou = x_zahyou
self.y_zahyou = y_zahyou
self.parent_ = parent
self.value = value
self.rank_ = 1
def __str__(self):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.rank_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
root = self.root()
return root.group_id_
def rank(self):
root = self.root()
return root.rank_
def unite(self, unite_node):
root = self.root()
unite_root = unite_node.root()
if root.group_id_ != unite_root.group_id_:
if root.rank() > unite_root.rank():
unite_root.parent_ = root
root.rank_ = max(root.rank_, unite_root.rank_ + 1)
root.x_zahyou += unite_root.x_zahyou
root.y_zahyou += unite_root.y_zahyou
else:
root.parent_ = unite_root
unite_root.rank_ = max(root.rank_ + 1, unite_root.rank_)
unite_root.x_zahyou+= root.x_zahyou
unite_root.y_zahyou+= root.y_zahyou
N = int(eval(input()))
X = []
Y = []
node_list = []
for i in range(N):
x, y = list(map(int,input().split()))
X += [[i,x]]
Y += [[i,y]]
node_list += [UnionFind(i,[x],[y])]
X.sort(key=lambda x: x[1])
Y.sort(key=lambda x: x[1])
for i in range(N-1):
if X[i][1] == X[i+1][1] :
node_list[X[i][0]].unite(node_list[X[i+1][0]])
if Y[i][1] == Y[i+1][1] :
node_list[Y[i][0]].unite(node_list[Y[i+1][0]])
chouten = 0
for i in range(N):
if node_list[i].is_root():
chouten += len(set(node_list[i].x_zahyou)) * len(set(node_list[i].y_zahyou))
print((chouten - N)) | p02998 |
N = int(eval(input()))
COR = [tuple((list(map(int, input().split())))) for _ in range(N)]
class Group:
def __init__(self, x, y):
self.n = 1
self.x = {x: None}
self.y = {y: None}
def insertx(self, x):
self.x[x] = None
self.n += 1
def inserty(self, y):
self.y[y] = None
self.n += 1
def new_cor_n(self):
if self.n == 0:
return 0
return len(self.x) * len(self.y) - self.n
def join(self, group):
self.n += group.n
for x in group.x:
self.x[x] = None
for y in group.y:
self.y[y] = None
group.n = 0
if N <= 2:
print((0))
else:
xg, yg = {}, {}
group_list = []
for xi, yi in COR:
if xi in xg:
group1 = xg[xi]
if yi in yg:
group1.n += 1
group2 = yg[yi]
if group2 is group1:
pass
else:
for xk in group2.x:
xg[xk] = group1
for yk in group2.y:
yg[yk] = group1
group1.join(group2)
else:
yg[yi] = group1
group1.inserty(yi)
elif yi in yg:
group = yg[yi]
xg[xi] = group
group.insertx(xi)
else:
new_group = Group(xi, yi)
xg[xi] = new_group
yg[yi] = new_group
group_list.append(new_group)
s = 0
for group in group_list:
s += group.new_cor_n()
print(s) | # import sys
# sys.setrecursionlimit(20000)
N = int(eval(input()))
COR = [tuple((list(map(int, input().split())))) for _ in range(N)]
class Group:
def __init__(self):
self.n = 0
self.x = 0
self.y = 0
self.xy = {}
def new_cor_n(self):
return self.x * self.y - self.n
def grouping(group, x, xcor, ycor):
x_list = []
group.x += 1
for y in xcor[x][0]:
if (x, y) not in group.xy:
group.n += 1
group.xy[(x, y)] = None
if ycor[y][1]:
continue
ycor[y][1] = True
group.y += 1
for x_ in ycor[y][0]:
if (x_, y) not in group.xy:
group.n += 1
group.xy[(x_, y)] = None
if xcor[x_][1]:
continue
xcor[x_][1] = True
x_list.append(x_)
return x_list
if N <= 2:
print((0))
else:
xcor, ycor = {}, {}
for xi, yi in COR:
if xi in xcor:
xcor[xi][0].append(yi)
else:
xcor[xi] = [[yi], False]
if yi in ycor:
ycor[yi][0].append(xi)
else:
ycor[yi] = [[xi], False]
group_list = []
for i, v in list(xcor.items()):
if v[1]:
continue
group = Group()
group_list.append(group)
xcor[i][1] = True
x_list = [i]
while True:
new_x_list = []
for x in x_list:
new_x_list += grouping(group, x, xcor, ycor)
if new_x_list == []:
break
x_list = new_x_list
s = 0
for group in group_list:
s += group.new_cor_n()
print(s)
| p02998 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
XY = [list(map(int, input().split())) for _ in range(N)]
MAX = 10**5
Xs = [[] for _ in range(MAX+1)]
Ys = [[] for _ in range(MAX+1)]
for i, (x, y) in enumerate(XY):
Xs[x].append(i)
Ys[y].append(i)
ans = 0
checked = [False]*N
for i in range(N):
if checked[i]: continue
q = [i]
checked[i] = True
X = set()
Y = set()
c = 0
while q:
qq = []
for p in q:
x, y = XY[p]
X.add(x)
Y.add(y)
c += 1
for ni in Xs[x]:
if not checked[ni]:
checked[ni] = True
qq.append(ni)
for ni in Ys[y]:
if not checked[ni]:
checked[ni] = True
qq.append(ni)
q = qq
ans += len(X)*len(Y)-c
print(ans) | import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
XY = [list(map(int, input().split())) for _ in range(N)]
MAX = 10**5
Xs = [[] for _ in range(MAX+1)]
Ys = [[] for _ in range(MAX+1)]
for i, (x, y) in enumerate(XY):
Xs[x].append(i)
Ys[y].append(i)
ans = 0
checked = [False]*N
for i in range(N):
if checked[i]: continue
q = [i]
checked[i] = True
X = set()
Y = set()
c = 0
while q:
qq = []
for p in q:
x, y = XY[p]
X.add(x)
Y.add(y)
c += 1
for ni in Xs[x]:
if not checked[ni]:
checked[ni] = True
qq.append(ni)
for ni in Ys[y]:
if not checked[ni]:
checked[ni] = True
qq.append(ni)
q = qq
ans += len(X)*len(Y)-c
print(ans)
if __name__ == "__main__":
main() | p02998 |
N = int(eval(input()))
XY = [tuple(map(int,input().split())) for i in range(N)]
V = 10**5+5
class UnionFind:
def __init__(self,N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.size_x = [1 - i//V for i in range(N)]
self.size_y = [i//V for i in range(N)]
def root(self,a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
self.size_x[rb] += self.size_x[ra]
self.size_y[rb] += self.size_y[ra]
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]: self.rank[ra] += 1
self.size_x[ra] += self.size_x[rb]
self.size_y[ra] += self.size_y[rb]
uf = UnionFind(V*2)
for x,y in XY:
uf.unite(x,y+V)
for i in range(V*2):
uf.root(i)
ans = 0
used = set()
for i in range(V*2):
r = uf.root(i)
if r in used: continue
used.add(r)
ans += uf.size_x[r] * uf.size_y[r]
ans -= N
print(ans) | N = int(eval(input()))
XY = [tuple(map(int,input().split())) for i in range(N)]
class UnionFind:
def __init__(self,N):
self.parent = [i for i in range(N)]
self._size = [1] * N
self.count = 0
def root(self,a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self._size[ra] < self._size[rb]: ra,rb = rb,ra
self._size[ra] += self._size[rb]
self.parent[rb] = ra
self.count += 1
def size(self,a):
return self._size[self.root(a)]
M = 10**5
uf = UnionFind(2*M)
for x,y in XY:
a,b = x-1,y-1+M
if uf.is_same(a,b): continue
uf.unite(a,b)
for i in range(2*M):
uf.root(i)
rt = []
for i in range(2*M):
rt.append(uf.root(i))
from collections import Counter
xr = Counter(rt[:M])
yr = Counter(rt[M:])
ans = 0
for k,v in list(xr.items()):
ans += yr[k] * v
ans -= N
print(ans) | p02998 |
n = int(eval(input()))
xy = [list(map(int, input().split())) for _ in range(n)]
xtoy = {}
ytox = {}
for x, y in xy:
if x not in xtoy:
xtoy[x] = []
xtoy[x].append(y)
if y not in ytox:
ytox[y] = []
ytox[y].append(x)
ret = 0
while len(xtoy) > 0:
x = next(iter(xtoy))
xs = set()
ys = set()
xs.add(x)
q = [(x, None)]
while len(q) > 0:
(xx, yy) = q.pop(0)
if xx is not None:
for y in xtoy.pop(xx):
if y not in ys:
ys.add(y)
q.append((None, y))
if yy is not None:
for x in ytox.pop(yy):
if x not in xs:
xs.add(x)
q.append((x, None))
ret += len(xs) * len(ys)
print((ret - n))
| import sys
sys.setrecursionlimit(100000)
n = int(eval(input()))
xy = [list(map(int, input().split())) for _ in range(n)]
xtoy = {}
ytox = {}
for x, y in xy:
if x not in xtoy:
xtoy[x] = [y]
else:
xtoy[x].append(y)
if y not in ytox:
ytox[y] = [x]
else:
ytox[y].append(x)
def doit(x, xs, ys, xtoy, ytox):
ret = 0
if x in xtoy:
xs.add(x)
yl = xtoy.pop(x)
ret += len(yl)
for y in yl:
ret += doit(y, ys, xs, ytox, xtoy)
return ret
ret = 0
while len(xtoy) > 0:
x = next(iter(xtoy))
xs = set()
ys = set()
num = doit(x, xs, ys, xtoy, ytox)
ret += len(xs) * len(ys) - num // 2
print(ret) | p02998 |
# coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, n,xy):
self.parent = list(range(n))#親ノード
self.size = [1]*n #グループの要素数
self.xval = [{x} for x,y in xy]
self.yval = [{y} for x,y in xy]
def root(self, x): #root(x): xの根ノードを返す．
while self.parent[x] != x:
x, self.parent[x] = self.parent[x], self.parent[self.parent[x]]
return x
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x, y = self.root(x), self.root(y)
if x == y:
return False
if self.size[x] < self.size[y]:
self.size[y] += self.size[x] #yの要素数を更新
self.parent[x] = y #xをyにつなぐ
self.xval[y].update(self.xval[x])
self.yval[y].update(self.yval[x])
else:
self.size[x] += self.size[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
self.xval[x].update(self.xval[y])
self.yval[x].update(self.yval[y])
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.size[self.root(x)]
n = int(eval(input()))
xy = [[int(i) for i in input().split()] for j in range(n)]
UF = UnionFind(n,xy)
xval = dict()
yval = dict()
for i,(x,y) in enumerate(xy):
if y in yval:
UF.merge(i,yval[y])
else:
yval[y] = i
if x in xval:
UF.merge(i,xval[x])
else:
xval[x] = i
ans = -n
for i,pi in enumerate(UF.parent):
if i==pi:
ans += len(UF.xval[pi]) * len(UF.yval[pi])
#print(xval,yval)
print(ans)
| # coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))#親ノード
self.size = [1]*n #グループの要素数
def root(self, x): #root(x): xの根ノードを返す．
while self.parent[x] != x:
x, self.parent[x] = self.parent[x], self.parent[self.parent[x]]
return x
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x, y = self.root(x), self.root(y)
if x == y:
return False
if self.size[x] < self.size[y]:
self.size[y] += self.size[x] #yの要素数を更新
self.parent[x] = y #xをyにつなぐ
else:
self.size[x] += self.size[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.size[self.root(x)]
n = int(eval(input()))
xy = [[int(i) for i in input().split()] for j in range(n)]
UF = UnionFind(n)
xval = dict()
yval = dict()
for i,(x,y) in enumerate(xy):
if y in yval:
UF.merge(i,yval[y])
else:
yval[y] = i
if x in xval:
UF.merge(i,xval[x])
else:
xval[x] = i
xcon = dict()
ycon = dict()
for i in range(n):
pi = UF.root(i)
x,y = xy[i]
if pi in xcon:
xcon[pi].add(x)
else:
xcon[pi] = {x}
if pi in ycon:
ycon[pi].add(y)
else:
ycon[pi] = {y}
ans = -n
#print(xcon,ycon)
for key, val in list(xcon.items()):
ans += len(val) * len(ycon[key])
#print(UF.parent)
#print(xval,yval)
print(ans)
| p02998 |
import sys
input = sys.stdin.readline
class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, x, y, parent=None):
self.group_id_ = group_id
self.parent_ = parent
self.size_ = 1
self.rank_ = 1
self.x_ = {x}
self.y_ = {y}
def __str__(self):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, size: {}, rank: {}, x: {}, y: {})"
return template.format(self.group_id_, self.parent_, self.size_,
self.rank_, self.x_, self.y_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
root = self.root()
return root.group_id_
def rank(self):
root = self.root()
return root.rank_
def get_size(self):
root = self.root()
return root.size_
def get_count(self):
root = self.root()
if len(root.x_) == 1 or len(root.y_) == 1:
return 0
return len(root.x_) * len(root.y_) - root.size_
def unite(self, unite_node):
root = self.root()
unite_root = unite_node.root()
if root.group_id_ != unite_root.group_id_:
if root.rank() > unite_root.rank():
unite_root.parent_ = root
root.rank_ = max(root.rank_, unite_root.rank_ + 1)
root.size_ += unite_root.size_
root.x_ = root.x_ | unite_root.x_
root.y_ = root.y_ | unite_root.y_
else:
root.parent_ = unite_root
unite_root.rank_ = max(root.rank_ + 1, unite_root.rank_)
unite_root.size_ += root.size_
unite_root.x_ = root.x_ | unite_root.x_
unite_root.y_ = root.y_ | unite_root.y_
N = int(eval(input()))
xy_array = [list(map(int, input().split())) for i in range(N)]
# print(xy_array)
node_array = [UnionFindNode(i, xy[0], xy[1]) for i, xy in enumerate(xy_array)]
for i in range(N):
for j in range(i, N):
if xy_array[i][0] == xy_array[j][0] or xy_array[i][1] == xy_array[j][1]:
node_array[i].unite(node_array[j])
# print("\n".join(list(map(str, node_array))))
# print("\n".join(list(map(lambda x: str(x.root()), node_array))))
ans = 0
for node in node_array:
if node.is_root():
# print("root")
ans += node.get_count()
print(ans) | import sys
input = sys.stdin.readline
class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, x, y, parent=None):
self.group_id_ = group_id
self.parent_ = parent
self.size_ = 1
self.rank_ = 1
def __str__(self):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, size: {}, rank: {})"
return template.format(self.group_id_, self.parent_, self.size_,
self.rank_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
root = self.root()
return root.group_id_
def rank(self):
root = self.root()
return root.rank_
def get_size(self):
root = self.root()
return root.size_
def unite(self, unite_node):
root = self.root()
unite_root = unite_node.root()
if root.group_id_ != unite_root.group_id_:
if root.rank() > unite_root.rank():
unite_root.parent_ = root
root.rank_ = max(root.rank_, unite_root.rank_ + 1)
root.size_ += unite_root.size_
else:
root.parent_ = unite_root
unite_root.rank_ = max(root.rank_ + 1, unite_root.rank_)
unite_root.size_ += root.size_
N = int(eval(input()))
xy_array = []
for i in range(N):
x, y = list(map(int, input().split()))
xy_array.append([i, x, y])
# print(xy_array)
node_array = [UnionFindNode(xy[0], xy[1], xy[2]) for xy in xy_array]
xsort_array = sorted(xy_array, key=lambda x: x[1])
for i in range(N - 1):
if xsort_array[i][1] == xsort_array[i + 1][1]:
node_array[xsort_array[i][0]].unite(node_array[xsort_array[i + 1][0]])
ysort_array = sorted(xy_array, key=lambda x: x[2])
for i in range(N - 1):
if ysort_array[i][2] == ysort_array[i + 1][2]:
node_array[ysort_array[i][0]].unite(node_array[ysort_array[i + 1][0]])
# print("\n".join(list(map(str, node_array))))
# print("\n".join(list(map(lambda x: str(x.root()), node_array))))
ans = 0
xy_group = [[set(), set()] for i in range(N)]
for node, xy in zip(node_array, xy_array):
group = node.find()
xy_group[group][0].add(xy[1])
xy_group[group][1].add(xy[2])
ans = 0
for i, xy in enumerate(xy_group):
if len(xy[0]) <= 1 or len(xy[1]) <= 1:
continue
ans += len(xy[0]) * len(xy[1]) - node_array[i].get_size()
print(ans)
| p02998 |
import sys
input = sys.stdin.readline
inpl = lambda: list(map(int,input().split()))
from collections import defaultdict
class UnionFind:
def __init__(self, N=None):
if N is None or N < 1:
self.parent = defaultdict(lambda: -1)
else:
self.parent = [-1]*int(N)
def root(self, n):
if self.parent[n] < 0:
return n
else:
m = self.root(self.parent[n])
self.parent[n] = m
return m
def merge(self, m, n):
rm = self.root(m)
rn = self.root(n)
if rm != rn:
if -self.parent[rm] < -self.parent[rn]:
rm, rn = rn, rm
self.parent[rm] += self.parent[rn]
self.parent[rn] = rm
def size(self, n):
return -self.parent[self.root(n)]
def connected(self, m, n):
return self.root(m) == self.root(n)
def groups(self):
if isinstance(self.parent,list):
return list([x<0 for x in self.parent]).count(True)
else: # self.parent: defaultdict
return list([x<0 for x in list(self.parent.values())]).count(True)
class CountUp:
def __init__(self, start=0):
self.index = start-1
def __call__(self):
self.index += 1
return self.index
Xi = defaultdict(CountUp())
Yi = defaultdict(CountUp())
N = int(eval(input()))
xy = []
for _ in range(N):
x, y = inpl()
xi = Xi[x]
yi = Yi[y]
xy.append((xi,yi))
Nx = len(Xi)
Ny = len(Yi)
Nxy = Nx + Ny
uf = UnionFind(Nx+Ny)
for xi, yi in xy:
uf.merge(xi,yi+Nx)
gi = defaultdict(CountUp())
Ng = uf.groups()
edges = [0]*Ng
nx = [0]*Ng
ny = [0]*Ng
for i in range(Nx):
nx[gi[uf.root(i)]] += 1
for i in range(Nx,Nxy):
ny[gi[uf.root(i)]] += 1
for xi, yi in xy:
edges[gi[uf.root(xi)]] += 1
ans = 0
for g in range(Ng):
ans += nx[g]*ny[g] - edges[g]
print(ans) | import sys
input = sys.stdin.readline
inpl = lambda: list(map(int,input().split()))
from collections import defaultdict
class UnionFind:
def __init__(self, N=None):
if N is None or N < 1:
self.parent = defaultdict(lambda: -1)
else:
self.parent = [-1]*int(N)
def root(self, n):
if self.parent[n] < 0:
return n
else:
m = self.root(self.parent[n])
self.parent[n] = m
return m
def merge(self, m, n):
rm = self.root(m)
rn = self.root(n)
if rm != rn:
if -self.parent[rm] < -self.parent[rn]:
rm, rn = rn, rm
self.parent[rm] += self.parent[rn]
self.parent[rn] = rm
def size(self, n):
return -self.parent[self.root(n)]
def connected(self, m, n):
return self.root(m) == self.root(n)
def groups(self):
if isinstance(self.parent,list):
return list([x<0 for x in self.parent]).count(True)
else: # self.parent: defaultdict
return list([x<0 for x in list(self.parent.values())]).count(True)
class CountUp:
def __init__(self, start=0):
self.index = start-1
def __call__(self):
self.index += 1
return self.index
N = int(eval(input()))
uf = UnionFind()
for _ in range(N):
x, y = inpl()
uf.merge(2*x+1,2*y)
Ng = uf.groups()
nx = [0]*Ng
ny = [0]*Ng
gi = defaultdict(CountUp())
for k in list(uf.parent.keys()):
if k % 2:
nx[gi[uf.root(k)]] += 1
else:
ny[gi[uf.root(k)]] += 1
ans = sum([ nx[g]*ny[g] for g in range(Ng) ]) - N
print(ans) | p02998 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
XY = [[set() for i in range(10**5+1)] for j in range(2)]
is_visited_x = [True] * (10**5 + 1)
for i in range(N):
x, y = list(map(int, input().split()))
is_visited_x[x] = False
XY[0][x].add(y)
XY[1][y].add(x)
def dfs(x):
global is_visited_x
is_visited_x[x] = True
stack = [[x], []]
idx = 0
num_e = 0
num_xy = [1, 0]
parent = 0
while stack[0] or stack[1]:
node = stack[idx][-1]
children = XY[idx][node]
if children:
child = children.pop()
XY[idx-1][child].remove(node) # 今来た道を削除
num_e += 1
if child in stack[idx-1]:
continue
stack[idx-1].append(child)
num_xy[idx-1] += 1
is_visited_x[child] += idx
idx = (idx + 1) % 2
else:
stack[idx].pop()
idx = (idx + 1) % 2
return num_e, num_xy
ans = 0
for x in range(1, 10**5+1):
if is_visited_x[x]:
continue
num_e, num_xy = dfs(x)
ans += num_xy[0]*num_xy[1] - num_e
print(ans) | # reference -> https://atcoder.jp/contests/abc131/submissions/10358162
import sys
sys.setrecursionlimit(100000)
# 再帰的に連結部分の辺の数を求める
# 同じ辺を2回ずつ数えるので、最終的には2で割る
def solve(x, x_set, y_set, x2y, y2x):
num_e = 0
if x in x2y:
x_set.add(x)
yl = x2y.pop(x)
num_e += len(yl)
for y in yl:
num_e += solve(y, y_set, x_set, y2x, x2y)
return num_e
N = int(eval(input()))
X2Y = {}
Y2X = {}
for i in range(N):
x, y = list(map(int, input().split()))
if x in X2Y:
X2Y[x].append(y)
else:
X2Y[x] = [y]
if y in Y2X:
Y2X[y].append(x)
else:
Y2X[y] = [x]
ans = 0
while X2Y:
x = next(iter(X2Y)) # まだスタートに選んでいないxを取り出す
x_set = set() # 上のxと連結であるxの集合
y_set = set() # 上のxと連結であるyの集合
num_e = solve(x, x_set, y_set, X2Y, Y2X)
ans += len(x_set)*len(y_set) - num_e//2
print(ans) | p02998 |
N, K = list(map(int, input().split()))
h = list(map(int, input().split()))
DP = [0]
for i in range(N-1):
act = float("inf")
for k in range(K):
if i-k < 0 : continue
act = min(DP[-1-k] + abs(h[i-k]-h[i+1]) , act)
DP += [act]
print((DP[-1])) | # B Frog 2
n, k = list(map(int, input().split()))
h_list = [int(x) for x in input().split()]
dp = [float('Inf')] * n
dp[0] = 0
for i in range(n):
for j in range(1,k+1,1):
if i - j < 0:
continue
dp[i] = min(dp[i], dp[i-j] + abs(h_list[i-j]-h_list[i]))
print((dp[n-1])) | p03161 |
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
INF = 10**5
# DP = [INF] * ((10**5)+10)
DP = [None] * ((10**5)+10)
# DP = [None] * (N+1)
DP[0] = 0
for i in range(1, N):
a = []
for j in range(1, K+1):
if 0 <= i-j < N:
v = DP[i-j] + abs(H[i-j] - H[i])
a.append(v)
DP[i] = min(a)
# print(DP)
print((DP[N-1])) | N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
INF = 10**5
DP = [INF] * ((10**5)+10)
# DP = [None] * ((10**5)+10)
# DP = [None] * (N+1)
DP[0] = 0
for i in range(1, N):
a = []
for j in range(1, K+1):
if 0 <= i-j < N:
v = DP[i-j] + abs(H[i-j] - H[i])
a.append(v)
DP[i] = min(a)
# print(DP)
print((DP[N-1])) | p03161 |
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
INF = 10**5
DP = [INF] * ((10**5)+10)
# DP = [None] * ((10**5)+10)
# DP = [None] * (N+1)
DP[0] = 0
for i in range(1, N):
a = []
for j in range(1, K+1):
if 0 <= i-j < N:
v = DP[i-j] + abs(H[i-j] - H[i])
a.append(v)
DP[i] = min(a)
# print(DP)
print((DP[N-1])) | N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
INF = 10**6
# DP = [INF] * N
# DP = [INF] * ((10**5)+10)
DP = [float('inf')] * N
DP[0] = 0
# for i in range(1, N):
# for j in range(1, K+1):
# if 0 <= i - j < N:
# DP[i] = min(DP[i], DP[i-j] + abs(H[i-j] - H[i]))
for i in range(1, N):
for j in range(1, K + 1):
# if 0 <= i - j < N:
if i - j < 0:
break
DP[i] = min(DP[i], DP[i - j] + abs(H[i] - H[i - j]))
print((DP[N-1]))
# print(DP) | p03161 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.