input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
# coding: utf-8
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a + b) * h // 2))
|
print(((int(eval(input())) + int(eval(input()))) * int(eval(input())) // 2))
|
p03997
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a+b)*h//2))
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print((int((a+b)*h/2)))
|
p03997
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a+b)*h//2))
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print((int((a+b)*h/2)))
|
p03997
|
a,b,h=list(map(int,[eval(input()) for i in range(3)]))
print((h*(a+b)//2))
|
a,b,h=list(map(int,[eval(input())for i in[0]*3]));print((h*(a+b)//2))
|
p03997
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
answer = (a + b) * h // 2
print(answer)
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a + b) * h // 2))
|
p03997
|
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
print(((a+b)*c//2))
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a+b)*h//2))
|
p03997
|
a, b, h = (int(eval(input())) for i in range(3))
print((int((a + b) / 2 * h)))
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print((int((a + b) / 2 * h)))
|
p03997
|
print(((int(eval(input()))+int(eval(input())))*int(eval(input()))//2))
|
x=lambda:int(eval(input()))
print(((x()+x())*x()//2))
|
p03997
|
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
a = ii()
b = ii()
h = ii()
print((((a+b)*h)//2))
if __name__ == '__main__':
main()
|
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
a, b, h = ii(), ii(), ii()
print((((a + b) * h) // 2))
if __name__ == '__main__':
main()
|
p03997
|
a, b, h = (int(eval(input())) for u in range(3))
print(((a + b) * h // 2))
|
a, b, h = (int(eval(input())) for u in range(3))
print((int((a + b) * h / 2)))
|
p03997
|
import sys
input = sys.stdin.readline
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
ans = (a+b) * h * 0.5
print((int(ans)))
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
print(((int(readline()) + int(readline())) * int(readline()) // 2))
|
p03997
|
#!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, fractions
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a,b,h=[int(eval(input())) for i in range(3)]
print(((a+b)*h//2))
|
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
a=int(eval(input()))
b=int(eval(input()))
h=int(eval(input()))
print(((a+b)*h//2))
|
p03997
|
a, b, h = [int(eval(input())) for _ in range(3)]
print((int((a+b)*h/2)))
|
a, b, h = [int(eval(input())) for i in range(3)]
print((int((a+b)*h/2)))
|
p03997
|
a=int(eval(input()))
b=int(eval(input()))
h=int(eval(input()))
S=(a+b)*h//2
print(S)
|
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a+b)*h//2))
|
p03997
|
a,b,c,d=eval('['+'int(input()),'*3+'0]');print(((a+b)*c//2))
|
f=lambda:int(eval(input()));print(((f()+f())*f()//2))
|
p03997
|
for i in range(1,10):
s = input().split()
a = list(map(int, s[1:]))
print(s[0], sum(a), a[0]*200+a[1]*300)
|
for _ in range(1,10):
a,b,c = input().split()
b,c = list(map(int, [b,c]))
print(a, b+c, b*200+c*300)
|
p00173
|
N = int(eval(input()))
A = list(map(int, input().split()))
K = sum(A) / sum(range(1, N+1))
D = [A[i+1] - A[i] - K for i in range(-1, N-1)]
for d in D:
if not (d <= 0 and d % N == 0):
print("NO")
break
else:
print("YES")
|
N = int(eval(input()))
A = list(map(int, input().split()))
# 毎回1+2+...+N個の石が取り除かれる
Sum = sum(A)
if Sum % (N * (N + 1) // 2) != 0:
print('NO')
exit()
# 操作回数
K = Sum // (N * (N + 1) // 2)
Diff = [A[i] - A[(i - 1)] for i in range(N)]
# 変化量-1が(N-1)箇所、+(N-1)が一か所を、すべて-1した後に、一か所+1と置き換える
Diff = [d - K for d in Diff]
for d in Diff:
if d < 0:
if d % N != 0:
print('NO')
exit()
else:
K -= abs(d // N)
if K == 0:
print('YES')
else:
print('NO')
|
p03808
|
import heapq
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
for i in range(n):
a[i] *= -1
b.append(a[i])
heapq.heapify(b)
while True:
p = heapq.heappop(b)
q = a.index(p)
for i in range(n):
a[q-i] += n-i
if a[q-i]>0:
print('NO')
exit()
if set(a) == {0}:
print('YES')
exit()
b = [a[i] for i in range(n)]
heapq.heapify(b)
|
n = int(eval(input()))
a = list(map(int, input().split()))
s = sum(a)
if s%(n*(n+1)//2)!=0:
print('NO')
exit()
ss = s//(n*(n+1)//2)
b = [0 for i in range(n)]
# a[i]-a[i-1] = ss-b[i-1]*n
for i in range(n):
b[i-1] = (ss-a[i]+a[i-1])//n
if b[i-1]<0:
print('NO')
exit()
c = [0 for i in range(n)]
for i in range(n):
c[0]+=b[i]*(n-i)
for i in range(1,n):
c[i] = c[i-1] + ss - b[i-1]*n
if a==c:
print('YES')
else:
print('NO')
|
p03808
|
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n = I()
a = LI()
s = 0
for i in a:
s ^= (i%2)
if s:
print("NO")
else:
print("YES")
return
#B
def B():
n = I()
a = LI()
while sum(a) != 0:
b = [0]*2*n
f = [0]*2*n
for i in range(n):
if a[i-1] >= a[i]:
b[i] += 1
b[i+n] -= 1
f[i] += 1
f[i+n] -= 1+n
for i in range(2*n-1):
b[i+1] += b[i]
f[i+1] += f[i]+b[i]
for i in range(n):
f[i] += f[i+n]
a[i] -= f[i]
if a[i] < 0:
print("NO")
return
print("YES")
return
#C
def C():
n = I()
return
#D
def D():
n = I()
return
#E
def E():
n = I()
return
#F
def F():
n = I()
return
#Solve
if __name__ == "__main__":
B()
|
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n = I()
a = LI()
s = 0
for i in a:
s ^= (i%2)
if s:
print("NO")
else:
print("YES")
return
#B
def B():
n = I()
a = LI()
m = n*(n+1)>>1
s = sum(a)
if s%m:
print("NO")
return
k = s//m
b = [k+a[i-1]-a[i] for i in range(n)]
s = 0
for i in b:
if i%n or i < 0:
print("NO")
return
s += i//n
if s == k:
print("YES")
else:
print("NO")
return
#C
def C():
n = I()
return
#D
def D():
n = I()
return
#E
def E():
n = I()
return
#F
def F():
n = I()
return
#Solve
if __name__ == "__main__":
B()
|
p03808
|
N = int(eval(input()))
A = [int(a) for a in input().split()]
RejectStones = N * (N+1) // 2
if sum(A) % RejectStones != 0: print("NO")
else:
TotalOperation = sum(A) // RejectStones
sumcheck = 0
for i in range(N-1):
if (TotalOperation - A[i+1] + A[i]) % N != 0 or TotalOperation < A[i+1] - A[i]:
print("NO")
break
else:
sumcheck += (TotalOperation - A[i+1] + A[i]) // N
else:
if (TotalOperation - A[0] + A[-1]) % N != 0 or TotalOperation < A[0] - A[-1]: print("NO")
else:
sumcheck += (TotalOperation - A[0] + A[-1]) // N
if sumcheck == TotalOperation: print("YES")
else: print("NO")
|
import sys
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = [int(a) for a in input().split()]
totalA = sum(A)
if totalA % (N * (N + 1) // 2) != 0: print("NO")
else:
Op = totalA // (N * (N + 1) // 2)
subA = [A[(i + 1) % N] - A[i] for i in range(N)]
count = 0
for i, a in enumerate(subA):
if (Op - a) % N != 0 or a > Op:
print("NO")
break
else: count += (Op - a) // N
else:
if count == Op: print("YES")
else: print("NO")
return 0
if __name__ == "__main__":
solve()
|
p03808
|
import sys
n = eval(input())
v = list(map(int, input().split(' ')))
startHere = [0 for i in range(n)]
if sum(v) % ((n * (n + 1)) / 2) != 0:
print("NO")
sys.exit()
operations = sum(v) / ((n * (n + 1)) / 2)
for i in range(n):
diff = v[(i + 1) % n] - v[i]
startHere[i] = (operations - diff) / n
contribution = 0
gathered = 0
for i in range(n):
v[i] -= contribution
gathered += startHere[i % n]
contribution += gathered
for i in range(n):
v[i] -= contribution
gathered -= startHere[i % n]
contribution -= startHere[i % n] * n
contribution += gathered
if min(startHere) >= 0 and sum(startHere) == operations and min(v) == 0 and max(v) == 0:
print("YES")
else:
print("NO")
|
import sys
n = eval(input())
v = list(map(int, input().split(' ')))
startHere = [0 for i in range(n)]
if sum(v) % ((n * (n + 1)) / 2) != 0:
print("NO")
sys.exit()
operations = sum(v) / ((n * (n + 1)) / 2)
operationsFound = 0
for i in range(n):
diff = v[(i + 1) % n] - v[i]
if (operations - diff) % n != 0 or operations - diff < 0:
print("NO")
sys.exit()
else:
operationsFound += (operations - diff) / n
if operationsFound == operations:
print("YES")
else:
print("NO")
|
p03808
|
n=int(eval(input()))
lis=list(map(int,input().split()))
num=(n*(n+1))//2
if sum(lis)%num!=0:
print("NO")
exit()
ans=0
for i in range(n):
if abs(lis[i]-lis[i-1]-sum(lis)//num)%n!=0:
print("NO")
exit()
ans+=abs(lis[i]-lis[i-1]-sum(lis)//num)//n
if ans == sum(lis)//num:print("YES")
else:print("NO")
|
n=int(eval(input()))
lis=list(map(int,input().split()))
num=(n*(n+1))//2
ll=sum(lis)
if ll%num!=0:
print("NO")
exit()
ans=0
for i in range(n):
if abs(lis[i]-lis[i-1]-ll//num)%n!=0:
print("NO")
exit()
ans+=abs(lis[i]-lis[i-1]-ll//num)//n
if ans == ll//num:print("YES")
else:print("NO")
|
p03808
|
n,*a=list(map(int,open(0).read().split()))
b,m=sum(a),n*-~n//2
n-=1
c=b//m
f=b%m>0
for i,j in zip(*[iter([a[-1]]+a*2)]*2):
j-=i
if n:
t=min(0,j//n)
f|=c!=j+n*-t-t
print(('YNEOS'[f::2]))
|
n,*a=list(map(int,open(0).read().split()))
q,m=divmod(sum(a),n*-~n//2)
print(('YNEOS'[any((y-x-q)%n+m or y-x>q for x,y in zip(a,a[1:]))::2]))
|
p03808
|
from operator import sub
N = int(eval(input()))
data = list(map(int, input().split()))
step = N * (N+1) // 2
total = sum(data)
#print("-->", total, step)
if total % step:
print("NO")
else:
K = total // step
#print("-->", total, step, K)
datar = [data[i % N] for i in range(-1, N)]
delta = list(map(sub, datar[1:], datar))
#print(*delta)
#print("-->", *list(map(lambda x:(K-x) % N, delta)))
#print("-->", *list(map(lambda x:(K-x) // N, delta)))
if any([(K-x) % N for x in delta]):
print("NO")
else:
ops = list([(K-x) // N for x in delta])
if sum(ops) == K:
for i, v in enumerate(data):
if (i & 1):
vv = sum([ops[(i-k) % N] * (k+1) for k in range(N)])
if v != vv:
print("NO")
break
else:
print("YES")
else:
print("NO")
|
from operator import sub
N = int(eval(input()))
data = list(map(int, input().split()))
step = N * (N+1) // 2
total = sum(data)
#print("-->", total, step)
if total % step:
print("NO")
else:
K = total // step
#print("-->", total, step, K)
datar = [data[i % N] for i in range(-1, N)]
delta = list(map(sub, datar[1:], datar))
#print(*delta)
#print("-->", *list(map(lambda x:(K-x) % N, delta)))
#print("-->", *list(map(lambda x:(K-x) // N, delta)))
if any([(K-x) % N for x in delta]):
print("NO")
elif any([K-x < 0 for x in delta]):
print("NO")
else:
ops = list([(K-x) // N for x in delta])
if sum(ops) == K:
for i, v in enumerate(data[0:1]):
vv = sum([ops[(i-k) % N] * (k+1) for k in range(N)])
if v != vv:
print("NO")
break
else:
print("YES")
else:
print("NO")
|
p03808
|
n = int(eval(input()))
a = list(map(int,input().split()))
s = sum(a)
one = n * (n+1) // 2
if s % one:
print('NO')
exit()
times = s // one
cnt = 0
b = a[1:]+[a[0]]
for i,j in zip(a,b):
dif = j - i
if (times - dif) % n:
print('NO')
exit()
if (times-dif) // n < 0:
print('NO')
exit()
cnt += (times-dif) // n
if times != cnt:
print('NO')
else:
print('YES')
|
N = int(eval(input()))
A = list(map(int,input().split()))
def solve():
q = N * (N + 1) // 2
if sum(A) % q:
return False
times = sum(A) // q
cnt = 0
for i, j in zip(A, A[1:] + [A[0]]):
dif = times + i - j
if dif % N or dif < 0:
return False
cnt += dif // N
return times == cnt
print(('YES' if solve() else 'NO'))
|
p03808
|
while 1:
s1=input().split('"')
if s1[0]==".":
break
s2=input().split('"')
cnt1=0
cnt2=0
flag=0
if len(s1)!=len(s2):
print("DIFFERENT")
else:
i=0
while i<len(s1):
if s1[i]==s2[i]:
cnt1+=1
elif i%2==0:
print("DIFFERENT")
flag=1
break
else:
cnt2+=1
if cnt2>1:
print("DIFFERENT")
break
i+=1
if flag==0 and cnt2==1:
print("CLOSE")
if cnt1==len(s1):
print("IDENTICAL")
|
while 1:
list1=input().split('"')
if list1[0]==".":
break
list2=input().split('"')
cnt1=0
cnt2=0
flag=0
if len(list1)!=len(list2):
print("DIFFERENT")
else:
i=0
while i<len(list1):
if list1[i]==list2[i]:
cnt1+=1
elif i%2==0:
print("DIFFERENT")
flag=1
break
else:
cnt2+=1
if cnt2>1:
print("DIFFERENT")
break
i+=1
if flag==0 and cnt2==1:
print("CLOSE")
if cnt1==len(list1):
print("IDENTICAL")
|
p01102
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
g=a[-1]
def gcd(a,b):
while b:a,b=b,a%b
return a
for i in a:g=gcd(g,i)
if a[-1]<k or k%g!=0:print("IMPOSSIBLE")
else:print("POSSIBLE")
|
def gcd(a,b):
while b:a,b=b,a%b
return a
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
g=a[0]
for i in a[1:]:g=gcd(g,i)
ans="IMPOSSIBLE"
for i in a:
if k>i:continue
if abs(k-i)%g==0:ans="POSSIBLE"
print(ans)
|
p03651
|
def gcd(a,b):
while b:a,b=b,a%b
return a
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
g=a[0]
for i in a[1:]:g=gcd(g,i)
ans="IMPOSSIBLE"
for i in a:
if k>i:continue
if abs(k-i)%g==0:ans="POSSIBLE"
print(ans)
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
def gcd(a,b):
while b:a,b=b,a%b
return a
g=a[0]
for i in a:g=gcd(g,i)
if max(a)>=k and k%g==0:print("POSSIBLE")
else:print("IMPOSSIBLE")
|
p03651
|
def factor(N):
ret = []
i = 2
while N > 1:
if N % i == 0:
ret.append(i)
N //= i
else:
i += 1
return ret
from collections import Counter
def solve(N, K, As):
if K > max(As):
return "IMPOSSIBLE"
factors = [Counter(factor(a)) for a in As]
iter = factors[0]
for f in factors[1:]:
for k, v in list(iter.items()):
if k not in f:
iter[k] = 0
else:
iter[k] = min(v, f[k])
if all([v == 0 for v in list(iter.values())]):
return "POSSIBLE"
else:
d = 1
for k, v in list(iter.items()):
if v != 0:
d *= k ** v
if K % d == 0:
return "POSSIBLE"
return "IMPOSSIBLE"
if __name__ == "__main__":
N, K = tuple(map(int, input().split(" ")))
As = list(map(int, input().split(" ")))
print((solve(N, K, As)))
|
def factor(N):
ret = []
i = 2
while N > 1:
if N % i == 0:
ret.append(i)
N //= i
else:
i += 1
return ret
assert (factor(4) == [2, 2])
assert (factor(2) == [2])
assert (factor(3) == [3])
assert (factor(10) == [2, 5])
from collections import Counter
def solve(N, K, As):
if K > max(As):
return "IMPOSSIBLE"
iter = Counter(factor(min(As)))
for a in As:
for k, v in list(iter.items()):
if a % k != 0:
iter[k] = 0
else:
count = 0
kk = k
while a % kk == 0:
kk *= k
count += 1
iter[k] = min(v, count)
if all([v == 0 for v in list(iter.values())]):
return "POSSIBLE"
else:
d = 1
for k, v in list(iter.items()):
if v != 0:
d *= k ** v
if K % d == 0:
return "POSSIBLE"
return "IMPOSSIBLE"
if __name__ == "__main__":
N, K = tuple(map(int, input().split(" ")))
As = list(map(int, input().split(" ")))
print((solve(N, K, As)))
|
p03651
|
def main():
n, k = (int(i) for i in input().split())
a = [int(i) for i in input().split()]
a.sort()
diff_min = 10**9 + 7
for i in range(n-1):
diff = abs(a[i] - a[i+1])
diff_min = (min(diff_min,diff) if diff != 0 else diff_min)
for i in range(n):
diff_min = (a[i] % diff_min if a[i] % (diff_min) != 0 else diff_min)
for i in range(n):
if a[i] - k >= 0 and (a[i] - k)%diff_min == 0:
print("POSSIBLE")
break
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
main()
|
def main():
N, K = (int(i) for i in input().split())
A = [int(i) for i in input().split()]
A.sort()
maxA = A.pop()
if maxA < K:
return print("IMPOSSIBLE")
if N == 1:
if maxA == K:
return print("POSSIBLE")
else:
return print("IMPOSSIBLE")
g = A[0]
def gcd(x, y):
if y == 0:
return x
while y != 0:
x, y = y, x % y
return x
for a in A[1:]:
g = gcd(g, a)
if (maxA - K) % g == 0:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
main()
|
p03651
|
import math
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
if max(l) < k:
print("IMPOSSIBLE")
exit()
x = l[0]
for i in l:
x = math.gcd(x,i)
if x == 1:
print("POSSIBLE")
else:
for i in l:
if (k-i)%x == 0:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
|
import math
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
if max(l) < k:
print("IMPOSSIBLE")
exit()
x = l[0]
for i in l:
x = math.gcd(x,i)
if k%x:
print("IMPOSSIBLE")
else:
print("POSSIBLE")
|
p03651
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
def gcd(n, m) :
n, m = max(n, m), min(n, m)
if m == 0 :
return n
return gcd(m, n % m)
dis = A[0]
for a in A :
dis = gcd(dis, a)
for a in A :
if a < K :
continue
if (a - K) % dis == 0 :
print('POSSIBLE')
break
else :
print('IMPOSSIBLE')
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
def gcd(n, m):
if m == 0:
return n
return gcd(m, n % m)
G = A[0]
for a in A:
G = gcd(G, a)
for a in A:
if K <= a and (a - K) % G == 0:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
|
p03651
|
N,K = (int(i) for i in input().split())
li = [int(i) for i in input().split()]
li.sort()
max = li[-1]
while(len(li) > 1):
v = li[0]
for i in range(1, len(li)):
li[i] = li[i]%v
for _ in range(li.count(0)):
li.remove(0)
li.sort()
if K <= max:
if K%li[0] == max%li[0]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
|
N,K = (int(i) for i in input().split())
li = [int(i) for i in input().split()]
max = max(li)
b = min(li)
for a in li:
while True:
if a%b == 0:
break
tb = b
b = a%b
a = tb
if K <= max:
if K%b == max%b:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
|
p03651
|
import sys
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
if a[-1] < k:
print('IMPOSSIBLE')
sys.exit(0)
seta = set(a)
if k in seta:
print('POSSIBLE')
sys.exit(0)
def gojoho(l, s):
return s if l % s == 0 else gojoho(s, l % s)
koubaisu = gojoho(a[1], a[0])
for i in a:
koubaisu = gojoho(i, koubaisu)
if k % koubaisu == 0:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def f(l, s):
return s if l % s == 0 else f(s, l % s)
z = f(a[-1], a[0])
for i in a:
z = f(i, z)
if a[-1] >= k and k % z == 0:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
|
p03651
|
# -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, initial=1)
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, K = MAP()
aN =LIST()
# Kがでかいのは論外
if max(aN) < K:
print('IMPOSSIBLE')
exit()
# aN全部の最大公約数を取る
base = aN[0]
for i in range(1, N):
base = gcd(base, aN[i])
if K % base == 0:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
|
# -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, K = MAP()
aN =LIST()
# Kがでかいのは論外
if max(aN) < K:
print('IMPOSSIBLE')
exit()
# aN全部の最大公約数を取る
base = gcd_list(aN)
if K % base == 0:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
|
p03651
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a%b
return a
S_possible = "POSSIBLE"
S_impossible = "IMPOSSIBLE"
if N == 1:
if K == A[0]:
print(S_possible)
else:
print(S_impossible)
else:
gcd_max = gcd(A[0], A[1])
for i in range(N-1):
gcd_current = gcd(A[i], A[i+1])
if gcd_current < gcd_max:
gcd_max = gcd_current
if K % gcd_max == 0 and K <= max(A):
print(S_possible)
else:
print(S_impossible)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
def gcd(a, b):
while b:
a, b = b, a%b
return a
S_possible = "POSSIBLE"
S_impossible = "IMPOSSIBLE"
b = 0
for a in A:
b = gcd(a, b)
if K % b or K > max(A):
print(S_impossible)
else:
print(S_possible)
|
p03651
|
def findGCD(a:int, b:int) -> int:
# バリデーション a,bは0以上
if a <= 0:
raise ValueError("aは0より大きくなければいけません。(a:{})".format(a))
elif b <= 0:
raise ValueError("bは0より大きくなければいけません。(b:{})".format(b))
# ユークリッドの互除法
while 1:
if a%b == 0:
return b
else:
a = a%b
if b%a == 0:
return a
else:
b = b%a
from functools import reduce
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
gcd = reduce(findGCD, a)
if k % gcd == 0 and k <= max(a):
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
def findGCD(a:int, b:int) -> int:
# ユークリッドの互除法
while 1:
if a%b == 0:
return b
else:
a = a%b
if b%a == 0:
return a
else:
b = b%a
from functools import reduce
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
gcd = reduce(findGCD, a)
if k % gcd == 0 and k <= max(a):
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
p03651
|
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
ans = 0
if k in l:
print("POSSIBLE")
exit()
if n == 1:
l[0] == k
la = []
while True:
for i in range(n):
x = l[i] - k
xx = l[i] + k
if x in l or xx in l :
ans = 1
break
else:
if x not in la:
la.append(x)
if xx not in la:
la.append(x)
for j in range(i,n):
a = abs(l[j] - l[i])
if a == k:
ans = 1
break
else:
if a in la:
ans = 1
break
if a not in l:
l.append(a)
x = a - k
xx = a + k
if x in l or xx in l :
ans = 1
break
else:
if x not in la:
la.append(x)
if xx not in la:
la.append(x)
_n = n
n = len(l)
if n == _n:
break
if ans == 1:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
def gcd(a, b):
while b:
a, b = b, a % b
return a
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
m = max(l)
for i in range(1,n):
l[i] = gcd(max(l[i],l[i-1]),min(l[i],l[i-1]))
if k%l[-1] == 0 and k <= m:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
p03651
|
from bisect import bisect_left as bl
def main():
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
if K > max(A):
print("IMPOSSIBLE")
exit()
if K in A:
print("POSSIBLE")
exit()
M = max(A)
E = list([abs(x-K) for x in A])
E = set(E)
C = [A[i+1]-A[i] for i in range(N-1)]
C = set(C)
D = set(A)
if E&D:
print("POSSIBLE")
exit()
for i in range(2,int(M**0.5)+10):
B = set([x%i for x in A])
if len(B) == 1:
print("IMPOSSIBLE")
exit()
print("IMPOSIBLE")
if __name__ == "__main__":
main()
|
def main():
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
if K > max(A):
print("IMPOSSIBLE")
exit()
if K in A:
print("POSSIBLE")
exit()
E = list([abs(x-K) for x in A])
E = set(E)
C = [A[i+1]-A[i] for i in range(N-1)]
C = set(C)
D = set(A)
if E&D:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
if __name__ == "__main__":
main()
|
p03651
|
n, k = list(map(int, input().split()))
A = sorted(map(int, input().split()))
INF = 10**9+1
diff = INF
for x, y in zip(A, A[1:]):
z = abs(x-y)
if z > 0:
diff = min(diff, z)
MAX = A[-1]
ans = False
for a in A:
if a-k < 0:
continue
x, r = divmod((a-k), diff)
if r == 0:
ans = True
break
print(("POSSIBLE" if ans else "IMPOSSIBLE"))
|
n, k = list(map(int, input().split()))
A = sorted(map(int, input().split()))
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
smallest_ball = A[0]
for a in A[1:]:
smallest_ball = gcd(smallest_ball, a)
print(("POSSIBLE" if (A[-1]-k) %
smallest_ball == 0 and k <= A[-1] else "IMPOSSIBLE"))
|
p03651
|
#! cat input | python3 main.py
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
if a[0] == k:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
__import__("sys").exit()
a.sort()
ma = max(a)
def isfact(n):
if n == 2: return True
for i in (2, n**0.5 + 1):
if n % i == 0:
return False
return True
def calcfacts():
r = []
for i in range(2, 10**5):
if isfact(i):
r.append(i)
return r
allfacts = calcfacts()
def prim_fact(n):
facts = []
ti = 0
t = allfacts[ti]
nn = n ** 0.5 + 1
while True:
if n % t == 0:
facts.append(t)
n //= t
else:
ti += 1
t = allfacts[ti]
if t >= n or t > nn:
if n != 1:
facts.append(n)
break
return facts
def f(a, k, ma):
minv = float("inf")
for i, v in enumerate(a[1:]):
if v - a[i] != 0:
minv = min(minv, v - a[i])
minv = min(minv, a[0])
sets = []
setn = set()
for v in a:
s = set(prim_fact(v))
# sets.append(s)
# for i in s: setn.add(i)
# for v in setn:
# for s in sets:
# if v not in s:
# break
# else:
# minv = min(minv, v)
# break
# else:
# return False
if minv == 1:
return False
a = a[:]
for i in range(0, ma + minv, minv):
if i == k:
return False
if i < a[0]:
continue
if i == a[0]:
del a[0]
else:
return False
return True
if ma < k:
print("IMPOSSIBLE")
elif f(a, k, ma):
print("IMPOSSIBLE")
else:
print("POSSIBLE")
|
a, b = list(map(int, input().split()))
array = list(map(int, input().split()))
impossible = "IMPOSSIBLE"
possible = "POSSIBLE"
array = list(set(array))
if len(array) == 1:
if b == array[0]:
print(possible)
else:
print(impossible)
exit(0)
array.sort()
btw = [v1 - v2 for v1, v2 in zip(array[1:], array[0:])]
n = sorted(btw)[0]
same = len(set(btw)) == 1 or all([v % n == 0 for v in btw])
if b in array:
print(possible)
elif array[-1] < b:
print(impossible)
elif same and (b - array[0]) % n == 0:
print(possible)
else:
print(impossible)
|
p03651
|
N, K = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
ans = False
cnt = 0
prev_len = 0
prepre_len = 0
while(1):
if K in A:
ans = True
break
if cnt == 0:
for i in range(len(A)-1):
for j in range(i+1, len(A)):
tmp = abs(A[i] - A[j])
# print(tmp)
if tmp not in A:
A.append(tmp)
else :
for i in range(len(A)-1):
for j in range(prepre_len, len(A)):
tmp = abs(A[i] - A[j])
# print(tmp)
if tmp not in A:
A.append(tmp)
if len(A) == prev_len:
ans = False
break
# print(A)
prepre_len = prev_len
prev_len = len(A)
cnt += 1
if ans == True:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
N, K = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
ans = False
A = sorted(A)
key = 99999999999999
if A[-1] < K:
ans = False
else:
for i in range(2, A[0]+1):
key_flag = True
for a in A:
if a % i !=0:
key_flag = False
break
if key_flag == True:
key = i
break
if key_flag == False:
ans = True
# print(1)
elif K % key == 0:
ans = True
# print(2)
else:
# print(3)
ans = False
if ans == True:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
p03651
|
import sys
from collections import Counter as ct
def factoring(n):
root = int(n ** .5) + 1
arr = []
for i in range(2, root):
while(n % i == 0):
arr.append(i)
n //= i
if n > 1:
arr.append(n)
return ct(arr)
n, k = list(map(int, input().split()))
a = list(sorted(map(int, input().split())))
kp = factoring(k)
ap = list(map(factoring, a))
ap0 = ap[0]
for a_cnt in ap[1:]:
ap0 = ap0 & a_cnt
prod = 1
for p, x in list(ap0.items()):
prod *= p ** x
ans = 'POSSIBLE' if k % prod == 0 and k <= a[-1] else 'IMPOSSIBLE'
print(ans)
|
n, k = list(map(int, input().split()))
ar = list(sorted(map(int, input().split())))
def lcm(x, y):
return x if y == 0 else lcm(y, x % y)
l = ar[0]
for a in ar[1:]:
l = lcm(l, a)
ans = 'POSSIBLE' if k % l == 0 and k <= ar[-1] else 'IMPOSSIBLE'
print(ans)
|
p03651
|
N,K = list(map(int,input().split()))
L = list(map(int,input().split()))
L = sorted(L,reverse=False)
ans = "IMPOSSIBLE"
if L[-1] < K :
ans = "IMPOSSIBLE"
elif (K in L) or (1 in L) :
ans = "POSSIBLE"
else :
for i in range(1,N) :
if L[i] % L[0] != 0 :
ans = "POSSIBLE"
break
for i in range(N) :
if (K + L[i]) in L :
ans = "POSSIBLE"
print(ans)
|
def gcd(a,b) :
while b :
a,b = b, a % b
return a
N,K = list(map(int,input().split()))
L = list(map(int,input().split()))
if len(L) == 1 :
if L[0] == K :
ans = "POSSIBLE"
else :
ans = "IMPOSSIBLE"
else :
for i in range(N-1) :
q = gcd(L[i],L[i+1])
if i == 0 :
p = gcd(L[i],L[i+1])
if q < p :
p = q
if (K % p == 0) and (K <= max(L)) :
ans = "POSSIBLE"
else :
ans = "IMPOSSIBLE"
print(ans)
|
p03651
|
def gcd_(a, b):
if a < b: a, b = b, a
if b == 0: return a
return gcd_(b, a % b)
def gcd_bl(A):
left = [0 for _ in range(N + 1)]
right = [0 for _ in range(N + 1)]
ans = [0 for _ in range(N)]
left[1] = A[0]
for i in range(1, N): left[i + 1] = gcd_(left[i], A[i])
right[-1 - 1] = A[-1]
for i in range(1, N): right[-1 - i - 1] = gcd_(right[-1 - i], A[-1 - i])
for i in range(N): ans[i] = gcd_(left[i], right[i + 1])
return ans
def cin():
in_ = list(map(int,input().split()))
if len(in_) == 1: return in_[0]
else: return in_
def solve():
if N == 1: return A == K
g = gcd_bl(A)
for i in range(N):
if A[i] == K: return 1
elif A[i] > K:
temp = (K - A[i]) / g[i]
if temp == int(temp): return 1
return 0
N, K = cin()
A = cin()
ret = solve()
if ret: print("POSSIBLE")
else: print("IMPOSSIBLE")
|
def gcd_(a, b):
if a < b: a, b = b, a
if b == 0: return a
return gcd_(b, a % b)
def gcd(l):
ans = l[0]
for i in l: ans = gcd_(ans, i)
return ans
def cin():
in_ = list(map(int,input().split()))
if len(in_) == 1: return in_[0]
else: return in_
def solve():
if N == 1: return A == K
g = gcd(A)
m = max(A)
return K <= m and K % g == 0
N, K = cin()
A = cin()
ret = solve()
if ret: print("POSSIBLE")
else: print("IMPOSSIBLE")
|
p03651
|
#!/usr/bin/env python3
import copy
N, K = list(map(int, input().split()))
a_list = list(map(int, input().split()))
a_list = sorted(a_list)
def judge(w_list, k):
w_list = sorted(w_list)
for i in range(len(w_list) - 1):
w_list += [abs(w_list[i] - w_list[i + 1])]
w_list = sorted(list(set(w_list)))
if k in w_list:
return True, w_list
elif 1 in w_list:
return True, w_list
elif abs(w_list[0] - w_list[-1]) < K:
return False, w_list
elif k % 2 == 0 and 2 in w_list:
return True, w_list
else:
for w in w_list:
if w + K in w_list:
return True, w_list
return False, w_list
w_list = a_list
while True:
org_w_list = copy.copy(w_list)
is_ok, w_list = judge(w_list, K)
if is_ok:
break
else:
if abs(w_list[0] - w_list[-1]) < K:
break
if w_list == org_w_list:
break
ans = "POSSIBLE" if is_ok else "IMPOSSIBLE"
print(ans)
|
#!/usr/bin/env python3
import copy
N, K = list(map(int, input().split()))
a_list = list(map(int, input().split()))
a_list = sorted(a_list)
def judge(w_list, k):
w_list = sorted(w_list)
for i in range(len(w_list) - 1):
w_list += [abs(w_list[i] - w_list[i + 1])]
w_list = sorted(list(set(w_list)))
if k in w_list:
return True, w_list
elif 1 in w_list:
return True, w_list
elif abs(w_list[0] - w_list[-1]) < K:
return False, w_list
elif k % 2 == 0 and 2 in w_list:
return True, w_list
else:
ww_list = set([w + K for w in w_list])
if ww_list & set(w_list):
return True, w_list
else:
return False, w_list
w_list = a_list
while True:
org_w_list = copy.copy(w_list)
is_ok, w_list = judge(w_list, K)
if is_ok:
break
else:
if abs(w_list[0] - w_list[-1]) < K:
break
if w_list == org_w_list:
break
ans = "POSSIBLE" if is_ok else "IMPOSSIBLE"
print(ans)
|
p03651
|
"""
KがAの最大公約数の倍数であれば実現可能。そうでなければ実現不可能。
"""
import sys
sys.setrecursionlimit(200000)
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
def gcd(a,b):
return a if b==0 else gcd(b,a%b)
if N ==1:
g = A[0]
else:
g = gcd(A[0],A[1])
for i in range(2,N):
g = gcd(g,A[2])
if K<=max(A) and K%g == 0:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
import sys
sys.setrecursionlimit(200000)
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
def gcd(a,b):
return a if b==0 else gcd(b,a%b)
g = A[0]
for i in range(1,N):
g = gcd(g,A[i])
if K > max(A):
print("IMPOSSIBLE")
exit()
if K % g == 0:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
|
p03651
|
n = int(eval(input()))
alist = [int(s) for s in input().split(" ")]
import copy
a_ans = []
for i in range(n):
atmp = copy.copy(alist)
del atmp[i]
ans = atmp[0]
for a in atmp[1:]:
ans ^= a
a_ans.append(ans)
print((" ".join([str(a) for a in a_ans])))
|
n = int(eval(input()))
alist = [int(s) for s in input().split(" ")]
asum = alist[0]
for a in alist[1:]:
asum ^= a
import copy
a_ans = []
for i in range(n):
asum ^= alist[i]
a_ans.append(asum)
asum ^= alist[i]
print((" ".join([str(a) for a in a_ans])))
|
p02631
|
def combine(a, j):
# combine by xor all elements of a except a[j]
x = 0
n = len(a)
for i in range(n):
if i != j:
x ^= a[i]
return x
def main():
N = int(eval(input()))
a = [int(i) for i in input().split()]
print((' '.join(str(combine(a, j)) for j in range(N))))
main()
|
def main():
N = int(eval(input()))
a = [int(i) for i in input().split()]
x = 0
for i in range(N):
x ^= a[i]
x ^= a[0]
xors = [x]
for i in range(1, N):
x ^= a[i-1]
x ^= a[i]
xors.append(x)
print((' '.join(str(x) for x in xors)))
main()
|
p02631
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = [None]*n
for i in range(n):
buf = 0
for j in range(n):
if i != j:
buf = buf^a[j]
ans[i]=str(buf)
print((' '.join(ans)))
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = [None]*n
all = 0
for i in range(n):
all = all^a[i]
for i in range(n):
ans[i]=str(all^a[i])
print((' '.join(ans)))
|
p02631
|
n = int(eval(input()))
a = [int(i) for i in input().split()]
ans = []
for i in range(n):
temp = 0
for j, aa in enumerate(a):
if j == i:
continue
temp = temp ^ aa
ans.append(temp)
ans = [str(i) for i in ans]
print((" ".join(ans)))
|
n = int(eval(input()))
a = [int(i) for i in input().split()]
ans = []
alld = 0
for aa in a:
alld = alld ^ aa
for aa in a:
ans.append(alld ^ aa)
ans = [str(i) for i in ans]
print((" ".join(ans)))
|
p02631
|
N = int(eval(input()))
a = [int(s) for s in input().split()]
b = a[0]
c = str("")
for i in range(1,N):
b = b ^ a[i]
c = str(b ^ a[0])
for i in range(1, N):
c = c + " " + str(b ^ a[i])
print(c)
|
N = int(eval(input()))
a = [int(s) for s in input().split()]
b = a[0]
c = []
for i in range(1,N):
b = b ^ a[i]
for i in range(N):
c.append(str(b ^ a[i]))
d = ' '.join(c)
print(d)
|
p02631
|
import copy
N = int(eval(input()))
A = list(map(int,input().split()))
result = ['' for _ in range(N)]
for i in range(N//2):
if i < N -2:
s_1 = A[2*i+1]
s_2 = A[2*i]
for j in range(2*i+2, N):
s_1 = s_1 ^ A[j]
s_2 = s_2 ^ A[j]
result[2*i] = str(s_1)
result[2*i+1] = str(s_2)
m = s_1^s_2
for j in range(2*i+2, N):
A[j] = m^A[j]
else:
result.append(str(A[N-1]))
result.append(str(A[N-2]))
break
print((' '.join(result)))
|
import copy
N = int(eval(input()))
A = list(map(int,input().split()))
result = ['' for _ in range(N)]
s = A[0]
for i in range(1,N):
s = s ^ A[i]
for i in range(N):
result[i] = str(s ^ A[i])
print((' '.join(result)))
|
p02631
|
N = int(eval(input()))
A = list(map(int, input().split()))
maxl = len(bin(max(A))[2:])
ans = [['0'] * N for _ in range(maxl)]
for n in range(N):
for d, a in enumerate(bin(A[n])[2:].zfill(maxl)):
ans[d][n] = a
for dn in range(maxl):
n1 = sum([1 for d in ans[dn] if d == '1'])
if n1 % 2 == 1:
for n in range(N):
ans[dn][n] = '0' if ans[dn][n] == '1' else '1'
prt = [int(''.join([ans[d][n] for d in range(maxl)]), 2) for n in range(N)]
print((' '.join(map(str, prt))))
|
N = int(eval(input()))
A = list(map(int, input().split()))
S = 0
for a in A:
S ^= a
print((" ".join([str(S ^ a) for a in A])))
|
p02631
|
n = int(eval(input()))
a = list(map(int,input().split()))
b = []
x = sum(a)
for i in range(n):
m = 0
for j in range(n):
if i == j:
pass
else:
m = m ^ a[j]
b.append(m)
b = list(map(str,b))
print((' '.join(b)))
|
import time
start = time.time()
n = int(eval(input()))
a = list(map(int,input().split()))
b = []
m = 0
for i in range(1,n):
m = m ^ a[i]
b.append(m)
for j in range(1,n):
m = m ^ a[j-1]
m = m ^ a[j]
b.append(m)
b = list(map(str,b))
print((' '.join(b)))
|
p02631
|
n = int(eval(input()))
a = [int(i) for i in input().split()]
pari = [0] * 40
for i in range(40):
for j in a:
pari[i] += (j&(1<<i))>>i
ans = a[:]
for i in range(40):
if pari[i]%2:
for j in range(n):
if a[j]&(1<<i):
ans[j] -= 1<<i
else:
ans[j] += 1<<i
print((' '.join([str(i) for i in ans])))
|
n = int(eval(input()))
a = [int(i) for i in input().split()]
pari = [0] * 30
for i in range(30):
for j in a:
pari[i] += (j&(1<<i))>>i
ans = a[:]
for i in range(30):
if pari[i]%2:
for j in range(n):
if a[j]&(1<<i):
ans[j] -= 1<<i
else:
ans[j] += 1<<i
print((' '.join([str(i) for i in ans])))
|
p02631
|
n = int(eval(input()))
a_list = list(map(int, input().split()))
ans = [0]*n
for i in range(n):
for j,a in enumerate(a_list):
if j != i:
ans[i]=ans[i]^a
ans = " ".join([str(i) for i in ans])
print(ans)
|
n = int(eval(input()))
a_list = list(map(int, input().split()))
base_xor = 0
for i in a_list:
base_xor = base_xor^i
ans = [0]*n
for i in range(n):
ans[i] = a_list[i]^base_xor
ans = " ".join([str(i) for i in ans])
print(ans)
|
p02631
|
n = int(eval(input()))
xor_arr = list(map(int, input().split()))
xor_of_xor = 0
for elm in xor_arr:
xor_of_xor = xor_of_xor ^ elm
scarf_val = [xor_of_xor ^ elm for elm in xor_arr]
print((" ".join(str(x) for x in scarf_val)))
|
n = int(eval(input()))
xor_arr = list(map(int, input().split()))
xor_of_xor = 0
for elm in xor_arr:
xor_of_xor = xor_of_xor ^ elm
scarf_val = [xor_of_xor ^ elm for elm in xor_arr]
print((" ".join(str(x) for x in scarf_val)))
|
p02631
|
N=int(eval(input()))
a=list(map(int,input().split()))
b=a[0]
for i in range(N-1):
b=b^a[i+1]
ans=""
for i in range(N):
if(i<N-1):
ans+=str(b^a[i])+" "
else:
ans+=str(b^a[i])
print(ans)
|
N=int(eval(input()))
a=list(map(int,input().split()))
b=a[0]
for i in range(N-1):
b=b^a[i+1]
x=[0 for i in range(N)]
for i in range(N):
x[i]=b^a[i]
x=list(map(str,x))
ans=' '.join(x)
print(ans)
|
p02631
|
n=int(eval(input()))
a=list(map(int,input().split()))
mx=len(bin(max(a)))
b=["0"*(mx-len(bin(x)))+bin(x)[2:] for x in a]
out=["" for _ in range(n)]
ref=[0 for _ in range(mx-2)]
for j in range(n):
work=b[j]
for i in range(mx-2):
ref[i]+=int(work[i])
ref[i]%=2
for j in range(n):
work=b[j]
for i in range(mx-2):
if int(work[i])==ref[i]:out[j]+="0"
else : out[j]+="1"
c=[str(int(y,2)) for y in out]
print((" ".join(c)))
|
n=int(eval(input()))
a=list(map(int,input().split()))
mx=len(bin(max(a)))
b=["0"*(mx-len(bin(x)))+bin(x)[2:] for x in a]
out=["" for _ in range(n)]
for i in range(mx-2):
tot=0
for j in range(n):
tot+=int(b[j][i])
tot=tot%2
for j in range(n):
if tot==int(b[j][i]):out[j]+="0"
else : out[j]+="1"
c=[str(int(y,2)) for y in out]
print((" ".join(c)))
|
p02631
|
n = int(eval(input()))
A = list(map(int,input().split()))
ans = []
for i in range(n):
tmp = 0
for j in range(n):
if i==j:
continue
tmp=A[j]^tmp
ans.append(tmp)
print((' '.join(map(str,ans))))
|
n = int(eval(input()))
A = list(map(int,input().split()))
xor_sum = 0
for i in range(n):
xor_sum = xor_sum^A[i]
ans = []
for i in range(n):
ans.append(xor_sum^A[i])
print((' '.join(map(str,ans))))
|
p02631
|
def main():
n = int(eval(input()))
a = list(map(int,input().split()))
l = len(format(max(a),'b'))
a = [format(a[i],'0{}b'.format(l)) for i in range(n)]
ans = [[] for i in range(n)]
for i in range(l):
s = 0
for j in range(n):
s+=int(a[j][i])
if s%2!=0:
for j in range(n):
ans[j].append(str((int(a[j][i])+1)%2))
else:
for j in range(n):
ans[j].append(a[j][i])
for i in range(n):
ans[i] = ''.join(ans[i])
ans[i] = str(int(ans[i],2))
print((' '.join(ans)))
if __name__ == "__main__":
main()
|
def main():
n = int(eval(input()))
a = list(map(int,input().split()))
b = a[0] ^ a[1]
for i in range(2,n):
b = b ^ a[i]
ans = []
for i in range(n):
ans.append(b ^ a[i])
ans = list(map(str,ans))
print((' '.join(ans)))
if __name__ == "__main__":
main()
|
p02631
|
from functools import reduce
N = int(input().strip())
A = [int(x) for x in input().strip().split(" ")]
# def calc(A, i):
values = [
str(reduce(lambda x, y: x ^ y, [v[1] for v in [v for v in enumerate(A) if v[0] != i]]))
# calc(A, i)
for i in range(len(A))
]
print((" ".join(values)))
|
from functools import reduce
N = int(input().strip())
A = [int(x) for x in input().strip().split(" ")]
xor = reduce(lambda x, y: x ^ y, A)
print((" ".join([
str(xor ^ a)
for a in A
])))
|
p02631
|
n = int(eval(input()))
a = list(map(int , input().split()))
b = []
for ai in a:
b.append('{:0=30b}'.format(ai))
cnt = []
for j in range(30):
tmp = 0
for i in range(n):
tmp += int(b[i][j])
cnt.append(tmp)
ans = []
for bi in b:
tmp = 0
for i in range(30):
idx = 29 + (-i)
#print(idx)
x = int(bi[i])
if cnt[i] == 0:
continue
if cnt[i] % 2 == 0:
tmp += x << idx
else:
if x == 0:
tmp += 1 << idx
ans.append(tmp)
#print(ans)
print((' '.join(map(str, ans))))
"""
0000010100
0000001011
0000001001
0000011000
0000011010
0000000101
0000000111
0000010110
"""
|
n = int(eval(input()))
a = list(map(int , input().split()))
b = []
s = 0
for ai in a:
s ^= ai
ans = []
for ai in a:
ans.append(s ^ ai)
print((' '.join(map(str, ans))))
|
p02631
|
# -*- coding: utf-8 -*-
def cal_xor(xor_list, rm_ind):
ans = None
for i, xi in enumerate(xor_list):
if i!=rm_ind:
if ans is not None:
ans = ans^xi
else:
ans = xi
return ans
N, = list(map(int, input().split()))
a = list(map(int, input().split()))
ans_str = ''
if N==2:
print(("{} {}".format(a[1], a[0])))
else:
xors = []
for i in range(N//2):
xors.append(a[2*i]^a[2*i+1])
for i, ai in enumerate(a):
sum_xor = cal_xor(xors, i//2)
if i%2==0:
ind = i+1
else:
ind = i-1
ans = sum_xor^a[ind]
ans_str += str(ans)+' '
print((ans_str[:-1]))
|
# -*- coding: utf-8 -*-
def cal_xor(xor_list):
ans = None
for xi in xor_list:
if ans is not None:
ans = ans^xi
else:
ans = xi
return ans
N, = list(map(int, input().split()))
a = list(map(int, input().split()))
ans_str = ''
if N==2:
print(("{} {}".format(a[1], a[0])))
else:
xors = []
for i in range(N//2):
xors.append(a[2*i]^a[2*i+1])
sum_xor = cal_xor(xors)
for i, ai in enumerate(a):
tmp_xor = sum_xor^xors[i//2]
if i%2==0:
ind = i+1
else:
ind = i-1
ans = tmp_xor^a[ind]
ans_str += str(ans)+' '
print((ans_str[:-1]))
|
p02631
|
N = int(eval(input()))
a = list(map(int, input().split()))
ans = [0] * N
bit = 0
for i in range(1, N):
ans[i] = a[i - 1] ^ a[i] ^ ans[i - 1]
bit ^= ans[i]
if bit == a[0]:
print((' '.join(map(str, ans))))
else:
index = 0
for i in range(1, 10 ** 9 + 1):
bit = bit ^ (i - 1) ^ i
if bit == a[0]:
index = i
break
ans[0] = index
for i in range(1, N):
ans[i] = a[i - 1] ^ a[i] ^ ans[i - 1]
bit ^= ans[i]
print((' '.join(map(str, ans))))
|
N = int(eval(input()))
a = list(map(int, input().split()))
S = 0
for i in range(N):
S ^= a[i]
ans = [0] * N
for i in range(N):
ans[i] = S ^ a[i]
print((' '.join(map(str, ans))))
|
p02631
|
from collections import deque
def calcXor(nums):
x=0
for n in nums:
x=x^n
return x
N=int(eval(input()))
A=list(map(int,input().split()))
ans=deque()
for i in range(N):
#print(A[0:i])
x=calcXor(A[0:i])
#print(A[i+1:N])
y=calcXor(A[i+1:N])
ans.append(x^y)
print((" ".join(map(str,ans))))
|
from collections import deque
def calcXor(nums):
x=0
for n in nums:
x=x^n
return x
N=int(eval(input()))
A=list(map(int,input().split()))
A_xor=calcXor(A)
ans=deque()
for a in A:
ans.append(A_xor^a)
#for i in range(N):
#print(A[0:i])
#x=calcXor(A[0:i])
#print(A[i+1:N])
#y=calcXor(A[i+1:N])
#ans.append(x^y)
print((" ".join(map(str,ans))))
|
p02631
|
def mi(): return list(map(int,input().split()))
def lmi(): return list(map(int,input().split()))
def ii(): return int(eval(input()))
def isp(): return input().split()
n=ii()
a=lmi()
S=0
for i in a:
S=S^i
b=[]
for i in a:
a_=S^i
b.append(a_)
print((' '.join(map(str,b))))
|
n=int(eval(input()))
a=list(map(int,input().split()))
s=0
for i in a:
s^=i
t=[]
for i in a:
t_=i^s
t.append(t_)
print((' '.join(map(str,t))))
|
p02631
|
n = int(eval(input()))
a = input().split()
l = [0] * 30
for i in range(n):
a[i] = format(int(a[i]), "030b")
for j in range(30):
l[j] += int(str(a[i])[j])
for i in range(30):
l[i] = l[i] % 2
b = ""
for i in range(30):
b += str(l[i])
b = int(b, 2)
for i in range(n):
a[i] = b ^ int(a[i], 2)
print((" ".join(map(str, a))))
|
n = int(eval(input()))
a = input().split()
l = 0
for i in range(n):
a[i] = int(a[i])
l = l ^ a[i]
for i in range(n):
a[i] = l ^ a[i]
print((" ".join(map(str, a))))
|
p02631
|
# -*- coding: utf-8 -*-
# 入力を整数に変換して受け取る
def input_int():
return int(eval(input()))
# マイナス1した値を返却
def int1(x):
return int(x) - 1
# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
return list(map(int, input().split()))
# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
return tuple(map(int, input().split()))
# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
return tuple(map(int1, input().split()))
def main():
n = int(eval(input()))
a_list = input_to_int_tuple()
ret = ""
for i in range(n):
my = 0
for j, v in enumerate(a_list):
if i == j:
continue
my ^= v
ret += str(my) + " "
print((ret.rstrip()))
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
# 入力を整数に変換して受け取る
def input_int():
return int(eval(input()))
# マイナス1した値を返却
def int1(x):
return int(x) - 1
# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
return list(map(int, input().split()))
# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
return tuple(map(int, input().split()))
# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
return tuple(map(int1, input().split()))
def main():
n = int(eval(input()))
a_list = input_to_int_tuple()
all = 0
for v in a_list:
all ^= v
ret = ""
for v in a_list:
ret += str(all ^ v) + " "
print((ret.rstrip()))
if __name__ == "__main__":
main()
|
p02631
|
n=int(input())
A=list(map(int,input().split()))
L = []
x=0
for a in A:
x ^= a
L.append(x)
R = []
x=0
for a in reversed(A):
x ^= a
R.insert(0, x)
for i in range(n):
x = 0
if i>0:
x^=L[i-1]
if i<n-1:
x^=R[i+1]
print(x, end="")
if i==n-1:
print("")
else:
print(" ",end="")
|
n=int(input())
A=list(map(int,input().split()))
L = []
x=0
for a in A:
x ^= a
L.append(x)
R = []
x=0
for a in reversed(A):
x ^= a
R.append(x)
for i in range(n):
x = 0
if i>0:
x^=L[i-1]
if i<n-1:
x^=R[n-1-(i+1)]
print(x, end="")
if i==n-1:
print("")
else:
print(" ",end="")
|
p02631
|
n = int(input())
a = list(map(int, input().strip().split()))
m = len(bin(max(a))[2:])
t = [0] * (m)
for i in range(n):
bin_str_i = [int(s) for s in list(bin(a[i])[2:])]
l = len(bin_str_i)
for j in range(l):
t[m - j - 1] += bin_str_i[l - j - 1]
x = ''
for j in range(m):
if t[j] % 2 == 0:
x += '0'
else:
x += '1'
x = int(x, 2)
for i in range(n):
ans = a[i] ^ x
if i < n - 1:
print(ans,end=' ')
else:
print(ans)
|
n = int(input())
a = list(map(int, input().strip().split()))
x = 0
for i in range(n):
x = x ^ a[i]
#print(bin(c))
#x = int(x, 2)
for i in range(n):
ans = a[i] ^ x
if i < n - 1:
print(ans,end=' ')
else:
print(ans)
|
p02631
|
N = int(eval(input()))
a = list(map(int, input().split()))
m = max(a)
count = 0
nishin = []
while True:
m, r = divmod(m, 2)
count += 1
if m == 0:
break
for i in range(0, N):
for j in range(0, count):
a[i], r = divmod(a[i], 2)
nishin.append(str(r))
a[i] = ''.join(reversed(nishin))
nishin.clear()
for k in range(0, N):
q = ''
for j in range(0, count):
p = 0
for i in range(0, N):
if i == k:
pass
else:
p += int(a[i][j])
p %= 2
q += str(p)
nishin.append(q)
jusshin = [int(i, 2) for i in nishin]
ans = ''
for i in range(0, N-1):
ans += (str(jusshin[i]) + ' ')
ans += str(jusshin[N-1])
print(ans)
|
N = int(eval(input()))
a = list(map(int, input().split()))
x = 0
for i in range(0, N):
x ^= a[i]
ans = []
for i in range(0, N):
ans.append(str(x ^ a[i]))
print((' '.join(ans)))
|
p02631
|
n=int(eval(input()))
A=list(map(int,input().split()))
ans=[]
for i in range(n):
l=A[:i]+A[i+1:]
sum=0
for a in l:
sum=sum^a
ans.append(sum)
ans=' '.join(map(str,ans))
print(ans)
|
n=int(eval(input()))
A=list(map(int,input().split()))
ans=[]
sum=0
for a in A:
sum=sum^a
for a in A:
ans.append(sum^a)
ans=' '.join(map(str,ans))
print(ans)
|
p02631
|
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2104
TLE
"""
import sys
from sys import stdin
input = stdin.readline
def main(args):
t = int(eval(input()))
for _ in range(t):
n, k = list(map(int, input().split()))
houses = [int(x) for x in input().split()]
if k >= n: # ????????¨?????????????????¨?????§??????
print((0))
continue
diff = []
prev = houses[0]
for h in houses[1:]:
temp = h - prev
diff.append(temp)
prev = h
points = []
s_diff = sorted(diff)
for x in range(k-1):
pos = diff.index(s_diff.pop())
points.append(pos)
diff[pos] = -1
cable_total = 0
prev = 0
for p in points:
cable_total += houses[p] - houses[prev]
prev = p + 1
if prev != (n - 1):
cable_total += houses[-1] - houses[prev]
print(cable_total)
if __name__ == '__main__':
main(sys.argv[1:])
|
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2104
"""
import sys
from sys import stdin
from bisect import bisect_left
input = stdin.readline
def main(args):
t = int(eval(input()))
for _ in range(t):
n, k = list(map(int, input().split()))
houses = [int(x) for x in input().split()]
if k >= n: # ????????¨?????????????????¨?????§??????
print((0))
continue
diff = []
prev = houses[0]
for i, h in enumerate(houses[1:]):
diff.append((h - prev, i))
prev = h
diff.sort(reverse=True)
points = diff[:k-1]
cable_total = 0
prev = 0
for _, p in points:
cable_total += houses[p] - houses[prev]
prev = p + 1
if prev != (n - 1):
cable_total += houses[-1] - houses[prev]
print(cable_total)
if __name__ == '__main__':
main(sys.argv[1:])
|
p01227
|
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2104
"""
import sys
from sys import stdin
from bisect import bisect_left
input = stdin.readline
def main(args):
t = int(eval(input()))
for _ in range(t):
n, k = list(map(int, input().split()))
houses = [int(x) for x in input().split()]
if k >= n: # ????????¨?????????????????¨?????§??????
print((0))
continue
diff = []
prev = houses[0]
for i, h in enumerate(houses[1:]):
diff.append((h - prev, i))
prev = h
diff.sort(reverse=True)
points = diff[:k-1]
cable_total = 0
prev = 0
for _, p in points:
cable_total += houses[p] - houses[prev]
prev = p + 1
if prev != (n - 1):
cable_total += houses[-1] - houses[prev]
print(cable_total)
if __name__ == '__main__':
main(sys.argv[1:])
|
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2104
AC
"""
import sys
from sys import stdin
input = stdin.readline
def main(args):
t = int(eval(input()))
for _ in range(t):
n, k = list(map(int, input().split()))
houses = [int(x) for x in input().split()]
if k >= n: # ????????¨?????????????????¨?????§????????´???
print((0))
continue
# ??¶??????????????¢????¨????????????????????????¨????????????????????????
gaps = []
prev = houses[0]
for i, h in enumerate(houses[1:]):
gaps.append((h - prev, i))
prev = h
# gap?????§????????¨??????????????????????????????????????´????????????
gaps.sort(reverse=True)
gaps = gaps[:k-1]
# ???????????????????????±????????????????¨??????????
cable_total = 0
prev = 0
for _, p in gaps:
cable_total += houses[p] - houses[prev]
prev = p + 1
if prev != (n - 1):
cable_total += houses[-1] - houses[prev]
print(cable_total)
if __name__ == '__main__':
main(sys.argv[1:])
|
p01227
|
from operator import itemgetter
import heapq
def prim_heap():
used=[True]*n
edgelist=[]
for e in edge[0]:
heapq.heappush(edgelist,e)
used[0] = False
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0]
return res
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[list(map(int,input().split())) for i in range(n)]
edge=[[] for i in range(n)]
l.sort()
for i in range(n):
l[i]=[l[i][0],l[i][1],i]
for i in range(n-1):
edge[i].append([min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),i+1])
edge[i+1].append([min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),i])
l=sorted(l,key=itemgetter(1))
for i in range(n-1):
edge[l[i][2]].append([min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),l[i+1][2]])
edge[l[i+1][2]].append([min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),l[i][2]])
print((prim_heap()))
|
from operator import itemgetter
import heapq
def prim_heap():
used=[True]*n
edgelist=[]
for e in edge[0]:
heapq.heappush(edgelist,e)
used[0] = False
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0]
return res
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[list(map(int,input().split())) for i in range(n)]
edge=[[] for i in range(n)]
l.sort()
for i in range(n):
l[i]=[l[i][0],l[i][1],i]
for i in range(n-1):
edge[i].append((min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),i+1))
edge[i+1].append((min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),i))
l=sorted(l,key=itemgetter(1))
for i in range(n-1):
edge[l[i][2]].append((min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),l[i+1][2]))
edge[l[i+1][2]].append((min(abs(l[i][0]-l[i+1][0]),abs(l[i][1]-l[i+1][1])),l[i][2]))
print((prim_heap()))
|
p03682
|
import sys
input = sys.stdin.readline
def INT(): return int(eval(input()))
def MAP(): return list(map(int,input().split()))
def LI(): return list(map(int,input().split()))
import decimal
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N = INT()
x = []
y = []
for _ in range(N):
xx,yy = MAP()
x.append(xx)
y.append(yy)
x = [(x[i],i) for i in range(N)]
y = [(y[i],i) for i in range(N)]
x.sort()
y.sort()
edges = []
for i in range(N-1):
edges.append((x[i][1],x[i+1][1],x[i+1][0]-x[i][0]))
edges.append((y[i][1],y[i+1][1],y[i+1][0]-y[i][0]))
edges.sort(key=lambda x:x[2])
uf = UnionFind(N)
answer = 0
for i in range(len(edges)):
s,t,w = edges[i]
if not uf.same(s,t):
uf.union(s,t)
answer += w
print(answer)
return
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
def INT(): return int(eval(input()))
def MAP(): return list(map(int,input().split()))
def LI(): return list(map(int,input().split()))
import decimal
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N = INT()
x = []
y = []
for _ in range(N):
xx,yy = MAP()
x.append(xx)
y.append(yy)
x = [(x[i],i) for i in range(N)]
y = [(y[i],i) for i in range(N)]
x.sort(key=lambda x:x[0])
y.sort(key=lambda x:x[0])
edges = []
for i in range(N-1):
edges.append((x[i][1],x[i+1][1],x[i+1][0]-x[i][0]))
edges.append((y[i][1],y[i+1][1],y[i+1][0]-y[i][0]))
edges.sort(key=lambda x:x[2])
uf = UnionFind(N)
answer = 0
for i in range(len(edges)):
s,t,w = edges[i]
if not uf.same(s,t):
uf.union(s,t)
answer += w
print(answer)
return
if __name__ == '__main__':
main()
|
p03682
|
import sys
sys.setrecursionlimit(10**7)
from collections import defaultdict
import collections
import itertools
import operator
class UnionFind:
def __init__(self, elems=None):
class KeyDict(dict):
def __missing__(self, key):
self[key] = key
return key
self.parent = KeyDict()
self.rank = collections.defaultdict(int)
if elems is not None:
for elem in elems:
_, _ = self.parent[elem], self.rank[elem]
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def are_same(self, x, y):
return self.find(x) == self.find(y)
def grouper(self):
roots = [(x, self.find(x_par)) for x, x_par in list(self.parent.items())]
root = operator.itemgetter(1)
for _, group in itertools.groupby(sorted(roots, key=root), root):
yield [x for x, _ in group]
'''
def init(n):
return list(range(n+1))#
def find(lis, x):
if lis[x] == x:
return x
else:
lis[x] = find(lis, lis[x])
return lis[x]
def sameset(lis, x, y):
return find(lis, x) == find(lis, y)
def union(lis, x, y):
x = find(lis, x)
y = find(lis, y)
if x != y:
lis[x] = y
'''
N = int(eval(input()))
#union_find_tree = init(N)
town = []
for i in range(N):
x, y = list(map(int, input().split()))
town.append((i, x, y))
x_sorted_town = sorted(town, key=lambda x: x[1])
y_sorted_town = sorted(town, key=lambda x: x[2])
graph = []
pre_tx = x_sorted_town[0]
pre_ty = y_sorted_town[0]
pre_nx = town[pre_tx[0]]
pre_ny = town[pre_ty[0]]
for tx, ty in zip(x_sorted_town[1:], y_sorted_town[1:]):
nx = town[tx[0]]
ny = town[ty[0]]
wx = min(abs(tx[1] - pre_tx[1]), abs(nx[2] - pre_nx[2]))
wy = min(abs(ty[2] - pre_ty[2]), abs(ny[1] - pre_ny[1]))
graph.append((nx[0], pre_nx[0], wx))
graph.append((ny[0], pre_ny[0], wy))
pre_tx = tx
pre_ty = ty
pre_nx = nx
pre_ny = ny
uf = UnionFind()
cost = 0
for (s,t,w) in sorted(graph, key=lambda x: x[2]):
if not uf.are_same(s,t):
uf.unite(s,t)
cost += w
print(cost)
|
import sys
sys.setrecursionlimit(10**7)
from collections import defaultdict
def init(n):
return list(range(n+1))
def find(lis, x):
if lis[x] == x:
return x
else:
lis[x] = find(lis, lis[x])
return lis[x]
def sameset(lis, x, y):
return find(lis, x) == find(lis, y)
def union(lis, x, y):
x = find(lis, x)
y = find(lis, y)
if x != y:
lis[x] = y
N = int(eval(input()))
union_find_tree = init(N)
town = []
for i in range(N):
x, y = list(map(int, input().split()))
town.append((i, x, y))
x_sorted_town = sorted(town, key=lambda x: x[1])
y_sorted_town = sorted(town, key=lambda x: x[2])
graph = []
pre_tx = x_sorted_town[0]
pre_ty = y_sorted_town[0]
pre_nx = town[pre_tx[0]]
pre_ny = town[pre_ty[0]]
for tx, ty in zip(x_sorted_town[1:], y_sorted_town[1:]):
nx = town[tx[0]]
ny = town[ty[0]]
wx = min(abs(tx[1] - pre_tx[1]), abs(nx[2] - pre_nx[2]))
wy = min(abs(ty[2] - pre_ty[2]), abs(ny[1] - pre_ny[1]))
graph.append((nx[0], pre_nx[0], wx))
graph.append((ny[0], pre_ny[0], wy))
pre_tx = tx
pre_ty = ty
pre_nx = nx
pre_ny = ny
cost = 0
for (s,t,w) in sorted(graph, key=lambda x: x[2]):
if not sameset(union_find_tree,s,t):
union(union_find_tree,s,t)
cost += w
print(cost)
|
p03682
|
n = int(eval(input()))
x = []
y = []
for i in range(n):
s = list(map(int, input().split()))
x.append([s[0], i])
y.append([s[1], i])
x.sort()
y.sort()
xdiff = []
ydiff = []
for i in range(1, n):
xdiff.append([x[i][0] - x[i - 1][0], x[i - 1][1], x[i][1]])
ydiff.append([y[i][0] - y[i - 1][0], y[i - 1][1], y[i][1]])
xdiff.sort()
ydiff.sort()
parent = [-1] * n
def getParent(index):
while parent[index] != -1:
index = parent[index]
return index
count = 0
ans = 0
xIndex = 0
yIndex = 0
while count != n - 1:
if xIndex != n - 1:
xTemp = xdiff[xIndex]
if yIndex != n - 1:
yTemp = ydiff[yIndex]
if yIndex == n - 1 or (xIndex != n - 1 and xTemp[0] < yTemp[0]):
xIndex += 1
temp = xTemp
else:
yIndex += 1
temp = yTemp
parent1 = getParent(temp[1])
parent2 = getParent(temp[2])
if parent1 == parent2:
continue
else:
count += 1
ans += temp[0]
parent[parent1] = parent2
print(ans)
|
import sys
sys.setrecursionlimit(100000)
n = int(eval(input()))
x = []
y = []
for i in range(n):
s = list(map(int, input().split()))
x.append([s[0], i])
y.append([s[1], i])
x.sort()
y.sort()
xdiff = []
ydiff = []
for i in range(1, n):
xdiff.append([x[i][0] - x[i - 1][0], x[i - 1][1], x[i][1]])
ydiff.append([y[i][0] - y[i - 1][0], y[i - 1][1], y[i][1]])
xdiff.sort()
ydiff.sort()
parent = [-1] * n
def getParent(index):
if parent[index] == -1:
return index
else:
parent[index] = getParent(parent[index])
return parent[index]
count = 0
ans = 0
xIndex = 0
yIndex = 0
while count != n - 1:
if xIndex != n - 1:
xTemp = xdiff[xIndex]
if yIndex != n - 1:
yTemp = ydiff[yIndex]
if yIndex == n - 1 or (xIndex != n - 1 and xTemp[0] < yTemp[0]):
xIndex += 1
temp = xTemp
else:
yIndex += 1
temp = yTemp
parent1 = getParent(temp[1])
parent2 = getParent(temp[2])
if parent1 == parent2:
continue
else:
count += 1
ans += temp[0]
parent[parent1] = parent2
print(ans)
|
p03682
|
class unionfind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(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 same(self, x, y):
return self.find(x) == self.find(y)
def count(self, x):
return -self.root[self.find(x)]
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=sorted([tuple(map(int,input().split())) for i in range(n)])
import collections
d=collections.defaultdict(int)
j=1
for i in l:
if d[i]==0:
d[i]=j
j+=1
pq=[]
for i in range(n-1):
pq.append((l[i+1][0]-l[i][0],d[l[i]],d[l[i+1]]))
l.sort(key=lambda x:x[1])
for i in range(n-1):
pq.append((l[i+1][1]-l[i][1],d[l[i]],d[l[i+1]]))
ans=0
pq.sort()
uf=unionfind(n)
for c,x,y in pq:
if not uf.same(x,y):
ans+=c
uf.unite(x,y)
print(ans)
|
class unionfind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(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 same(self, x, y):
return self.find(x) == self.find(y)
def count(self, x):
return -self.root[self.find(x)]
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[tuple(map(int,input().split())) for i in range(n)]
l.sort(key=lambda x:x[0])
import collections
d=collections.defaultdict(int)
j=1
for i in l:
if d[i]==0:
d[i]=j
j+=1
pq=[]
for i in range(n-1):
pq.append((l[i+1][0]-l[i][0],d[l[i]],d[l[i+1]]))
l.sort(key=lambda x:x[1])
for i in range(n-1):
pq.append((l[i+1][1]-l[i][1],d[l[i]],d[l[i+1]]))
ans=0
pq.sort(key=lambda x:x[0])
uf=unionfind(n)
for c,x,y in pq:
if not uf.same(x,y):
ans+=c
uf.unite(x,y)
print(ans)
|
p03682
|
class unionfind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(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 same(self, x, y):
return self.find(x) == self.find(y)
def count(self, x):
return -self.root[self.find(x)]
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[tuple(map(int,input().split())) for i in range(n)]
l.sort(key=lambda x:x[0])
import collections
d=collections.defaultdict(int)
j=1
for i in l:
if d[i]==0:
d[i]=j
j+=1
pq=[]
for i in range(n-1):
pq.append((l[i+1][0]-l[i][0],d[l[i]],d[l[i+1]]))
l.sort(key=lambda x:x[1])
for i in range(n-1):
pq.append((l[i+1][1]-l[i][1],d[l[i]],d[l[i+1]]))
ans=0
pq.sort(key=lambda x:x[0])
uf=unionfind(n)
for c,x,y in pq:
if not uf.same(x,y):
ans+=c
uf.unite(x,y)
print(ans)
|
class unionfind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(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 same(self, x, y):
return self.find(x) == self.find(y)
def count(self, x):
return -self.root[self.find(x)]
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[tuple(map(int,input().split())) for i in range(n)]
l.sort()
import collections
d=collections.defaultdict(int)
j=1
for i in l:
if d[i]==0:
d[i]=j
j+=1
pq=[]
for i in range(n-1):
pq.append((l[i+1][0]-l[i][0],d[l[i]],d[l[i+1]]))
l.sort(key=lambda x:x[1])
for i in range(n-1):
pq.append((l[i+1][1]-l[i][1],d[l[i]],d[l[i+1]]))
ans=0
pq.sort(key=lambda x:x[0])
uf=unionfind(n)
for c,x,y in pq:
if not uf.same(x,y):
ans+=c
uf.unite(x,y)
print(ans)
|
p03682
|
class unionfind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(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 same(self, x, y):
return self.find(x) == self.find(y)
def count(self, x):
return -self.root[self.find(x)]
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[tuple(map(int,input().split())) for i in range(n)]
l.sort()
import collections
d=collections.defaultdict(int)
j=1
for i in l:
if d[i]==0:
d[i]=j
j+=1
pq=[]
for i in range(n-1):
pq.append((l[i+1][0]-l[i][0],d[l[i]],d[l[i+1]]))
l.sort(key=lambda x:x[1])
for i in range(n-1):
pq.append((l[i+1][1]-l[i][1],d[l[i]],d[l[i+1]]))
ans=0
pq.sort(key=lambda x:x[0])
uf=unionfind(n)
for c,x,y in pq:
if not uf.same(x,y):
ans+=c
uf.unite(x,y)
print(ans)
|
class unionfind:
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(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 same(self, x, y):
return self.find(x) == self.find(y)
def count(self, x):
return -self.root[self.find(x)]
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[tuple(map(int,input().split())) for i in range(n)]
l.sort()
import collections
d=collections.defaultdict(int)
j=1
for i in l:
if d[i]==0:
d[i]=j
j+=1
pq=[]
for i in range(n-1):
pq.append((l[i+1][0]-l[i][0],d[l[i]],d[l[i+1]]))
l.sort(key=lambda x:x[1])
for i in range(n-1):
pq.append((l[i+1][1]-l[i][1],d[l[i]],d[l[i+1]]))
ans=0
pq.sort()
uf=unionfind(n)
for c,x,y in pq:
if not uf.same(x,y):
ans+=c
uf.unite(x,y)
print(ans)
|
p03682
|
import heapq
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
town = [list(map(int,input().split()))+[i] for i in range(N)]
townx = sorted(town)
towny = sorted(town,key = lambda t : t[1])
heap = []
heapq.heapify(heap)
for i in range(N-1):
heapq.heappush(heap,[abs(townx[i][0]-townx[i+1][0]),townx[i][2],townx[i+1][2]])
heapq.heappush(heap,[abs(towny[i][1]-towny[i+1][1]),towny[i][2],towny[i+1][2]])
uf = UnionFind(N)
ans = 0
while heap:
cost,t1,t2 = heapq.heappop(heap)
if uf.same(t1,t2):
continue
uf.union(t1,t2)
ans += cost
print(ans)
|
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
town = [list(map(int,input().split()))+[i] for i in range(N)]
townx = sorted(town)
towny = sorted(town,key = lambda t : t[1])
road = []
for i in range(N-1):
road.append([abs(townx[i][0]-townx[i+1][0]),townx[i][2],townx[i+1][2]])
road.append([abs(towny[i][1]-towny[i+1][1]),towny[i][2],towny[i+1][2]])
road.sort()
uf = UnionFind(N)
ans = 0
for r in road:
cost,t1,t2 = r
if uf.same(t1,t2):
continue
uf.union(t1,t2)
ans += cost
print(ans)
|
p03682
|
with open(0) as f:
N, *xy = list(map(int, f.read().split()))
from collections import namedtuple
v = namedtuple('v',['x','y'])
V = [v(x-1,y-1) for x,y in zip(xy[::2],xy[1::2])] #頂点
cost = lambda i,j:min(abs(V[i].x-V[j].x), abs(V[i].y-V[j].y))
from itertools import combinations
Edge = sorted([(cost(i,j), i, j) for i,j in combinations(list(range(N)),2)])
root = namedtuple('root',['num', 'rank']) #(num_of_root, rank_of_root)
Root = [root(i,0) for i in range(N)]
def fr(i): #findRoot
if i == Root[i].num:
return Root[i]
Root[i] = fr(Root[i].num)
return Root[i]
def unionT(i, j): #unionTree
p, q = fr(i), fr(j)
if p.rank < q.rank:
Root[p.num] = q
elif p.rank > q.rank:
Root[q.num] = p
elif p.rank == q.rank:
r, s = min(p, q), max(p, q)
Root[r.num] = Root[s.num] = root(r.num, r.rank+1)
ans = 0
#最小全域木の大きさ算出(環状にならないように辺を小さい順に足してゆく)
for w, i, j in Edge:
p, q = fr(i), fr(j)
if p.num == q.num: #既に連結済み
continue
else:
unionT(i,j)
ans += w
print(ans)
|
with open(0) as f:
N, *xy = list(map(int, f.read().split()))
from collections import namedtuple
v = namedtuple('v',['coordinate','num'])
#最小全域木に使われる辺は高々座標(xまたはy)が隣接する頂点間のものである
#したがって、x座標・y座標それぞれでソートして辺を求める
X = sorted([v(x,i) for x,i in zip(xy[::2], list(range(N)))])
Y = sorted([v(y,i) for y,i in zip(xy[1::2], list(range(N)))])
diffiter = lambda X:list(zip(X[:len(X)-1], X[1:])) #Xの1階階差差分のイテレータを返す関数
cost = lambda u,v:abs(u.coordinate - v.coordinate)
from itertools import chain
Edge = sorted([(cost(u,v), u.num, v.num) for u,v in chain(diffiter(X),diffiter(Y))])
root = namedtuple('root',['num', 'rank']) #(num_of_root, rank_of_root)
Root = [root(i,0) for i in range(N)]
def fr(i): #findRoot
if i == Root[i].num:
return Root[i]
Root[i] = fr(Root[i].num)
return Root[i]
def unionT(i, j): #unionTree
p, q = fr(i), fr(j)
if p.rank < q.rank:
Root[p.num] = q
elif p.rank > q.rank:
Root[q.num] = p
elif p.rank == q.rank:
r, s = min(p, q), max(p, q)
Root[r.num] = Root[s.num] = root(r.num, r.rank+1)
ans = 0
#最小全域木の大きさ算出(環状にならないように辺を小さい順に足してゆく)
for w, i, j in Edge:
if fr(i).num == fr(j).num: #既に連結済み
continue
else:
unionT(i,j)
ans += w
print(ans)
|
p03682
|
N = int(eval(input()))
P = [[i, list(map(int, input().split()))] for i in range(N)]
X = sorted([[i, xy[0]] for i, xy in P], key=lambda x: x[1])
Y = sorted([[i, xy[1]] for i, xy in P], key=lambda y: y[1])
Xe = [[X[i][0], X[i+1][0], abs(X[i][1]-X[i+1][1])] for i in range(N-1)]
Ye = [[Y[i][0], Y[i+1][0], abs(Y[i][1]-Y[i+1][1])] for i in range(N-1)]
E = sorted(Xe + Ye, key=lambda e: e[2])
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if 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_check(self, x, y):
return self.find(x) == self.find(y)
uf = UnionFind(N)
edge_cnt = 0
MST_cost = 0
i = 0
while edge_cnt < N-1:
a, b, cost = E[i]
if not uf.same_check(a, b):
MST_cost += cost
uf.union(a, b)
edge_cnt += 1
i += 1
print(MST_cost)
|
N = int(eval(input()))
Points = [[i] + list(map(int, input().split())) for i in range(N)]
# x, yそれぞれについてソートして、一番近いところを見れば十分
Edges = []
Points.sort(key=lambda p: p[1])
for i in range(N - 1):
n1, x1, y1 = Points[i]
n2, x2, y2 = Points[i + 1]
Edges.append([n1, n2, x2 - x1])
Points.sort(key=lambda p: p[2])
for i in range(N - 1):
n1, x1, y1 = Points[i]
n2, x2, y2 = Points[i + 1]
Edges.append([n1, n2, y2 - y1])
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if 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_check(self, x, y):
return self.find(x) == self.find(y)
uf = UnionFind(N)
Edges.sort(key=lambda e: e[2], reverse=True)
MST_cost = 0
i = 0
# 辺のコストが小さいものから、閉路を作らないように、木を構成する
# 最小全域木の必要辺は(頂点数-1)本
while i != N - 1:
x, y, cost = Edges.pop()
# 同じ辺集合に属していないならば（閉路が生まれないならば）
if not uf.same_check(x, y):
MST_cost += cost
uf.union(x, y)
i += 1
print(MST_cost)
|
p03682
|
N = int(eval(input()))
Points = [[i] + list(map(int, input().split())) for i in range(N)]
# x, yそれぞれについてソートして、一番近いところを見れば十分
Edges = []
Points.sort(key=lambda p: p[1])
for i in range(N - 1):
n1, x1, y1 = Points[i]
n2, x2, y2 = Points[i + 1]
Edges.append([n1, n2, x2 - x1])
Points.sort(key=lambda p: p[2])
for i in range(N - 1):
n1, x1, y1 = Points[i]
n2, x2, y2 = Points[i + 1]
Edges.append([n1, n2, y2 - y1])
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if 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_check(self, x, y):
return self.find(x) == self.find(y)
uf = UnionFind(N)
Edges.sort(key=lambda e: e[2], reverse=True)
MST_cost = 0
i = 0
# 辺のコストが小さいものから、閉路を作らないように、木を構成する
# 最小全域木の必要辺は(頂点数-1)本
while i != N - 1:
x, y, cost = Edges.pop()
# 同じ辺集合に属していないならば（閉路が生まれないならば）
if not uf.same_check(x, y):
MST_cost += cost
uf.union(x, y)
i += 1
print(MST_cost)
|
N = int(eval(input()))
Towns = [[i] + list(map(int, input().split())) for i in range(N)]
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# すべての頂点に対して親を検索する
def all_find(self):
for n in range(len(self.par)):
self.find(n)
E = []
# xについてソート
Towns.sort(key=lambda t: t[1])
for i in range(1, N):
t_prev, t_now = Towns[i - 1], Towns[i]
E.append([t_prev[0], t_now[0], t_now[1] - t_prev[1]])
# yについてソート
Towns.sort(key=lambda t: t[2])
for i in range(1, N):
t_prev, t_now = Towns[i - 1], Towns[i]
E.append([t_prev[0], t_now[0], t_now[2] - t_prev[2]])
E.sort(reverse=True, key=lambda e: e[2])
UF = UnionFind(N)
MST_cost = 0
i = 0
# 辺のコストが小さいものから、閉路を作らないように、木を構成する
# 最小全域木の必要辺は(頂点数-1)本
while i != N - 1:
x, y, cost = E.pop()
# 同じ辺集合に属していないならば（閉路が生まれないならば）
if not UF.same(x, y):
MST_cost += cost
UF.union(x, y)
i += 1
print(MST_cost)
|
p03682
|
from heapq import heappush, heappop
class UnionFind():
def __init__(self, n):
self.parents = list(range(n))
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
self.parents[y] = x
N = int(eval(input()))
q = []
ans = 0
S = UnionFind(N)
x = []
y = []
for i in range(N):
p,r = list(map(int, input().split()))
x.append([p,i])
y.append([r,i])
x.sort()
y.sort()
for i in range(N-1):
x1, i1 = x[i]
y1, j1 = y[i]
x2, i2 = x[i+1]
y2, j2 = y[i+1]
heappush(q, (abs(x1-x2), i1, i2))
heappush(q, (abs(y1-y2), j1, j2))
heappush(q, (abs(x[N-1][0]-x[0][0]), x[N-1][1], x[0][1]))
heappush(q, (abs(y[N-1][0]-y[0][0]), y[N-1][1], y[0][1]))
# クラスカル法
while len(q) > 0:
d, a, b = heappop(q)
if S.find(a) != S.find(b):
ans += d
S.union(a, b)
print(ans)
|
from heapq import heappop, heappush
class UnionFind():
def __init__(self, n):
self.parents = list(range(n))
self.size = [1] * n
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.size[x] < self.size[y]:
x,y = y,x
self.parents[y] = x
self.size[x] += self.size[y]
N = int(eval(input()))
x = [None] * N
y = [None] * N
for i in range(N):
a, b = list(map(int, input().split()))
x[i] = (a,i)
y[i] = (b,i)
x.sort()
y.sort()
q = []
for i in range(N-1):
heappush(q, (abs(x[i][0]-x[i+1][0]), x[i][1], x[i+1][1]))
heappush(q, (abs(y[i][0]-y[i+1][0]), y[i][1], y[i+1][1]))
uf = UnionFind(N)
ans = 0
# クラスカル法
while len(q) > 0:
w, s, t = heappop(q)
if uf.find(s) != uf.find(t):
ans += w
uf.union(s,t)
print(ans)
|
p03682
|
import heapq
N = int(eval(input()))
place = []
d = {}
j = 0
for i in range(N):
x, y = list(map(int, input().split()))
place.append((x,y))
if not (x,y) in d:
d[(x,y)] = j
j += 1
N = j
sort_x = sorted(place)
sort_y = sorted(place, key = lambda k:k[1])
edge=[[] for i in range(N)]
flag = False
for x,y in sort_x:
now = d[(x,y)]
if flag:
edge[before].append([x-before_x,now])
edge[now].append([x-before_x,d[(before_x,before_y)]])
else:
flag = True
before_x = x
before_y = y
before = now
flag = False
for x,y in sort_y:
now = d[(x,y)]
if flag:
edge[before].append([y-before_y,now])
edge[now].append([y-before_y,before])
else:
flag = True
before_x = x
before_y = y
before = now
used = [True]*N
edgelist = []
for e in edge[0]:
heapq.heappush(edgelist,e)
used[0] = False
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0]
print(res)
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N = int(eval(input()))
xy = []
uf = UnionFind(N)
d = {}
j = 0
for i in range(N):
x, y = list(map(int, input().split()))
if not (x,y) in d:
d[(x,y)] = j
xy.append((x,y))
j += 1
N = len(xy)
xy = sorted(xy, key = lambda x:x[0])
root = []
for i in range(N-1):
before_x, before_y = xy[i]
x, y = xy[i+1]
root.append((d[xy[i]],d[xy[i+1]],x - before_x))
xy = sorted(xy, key = lambda x:x[1])
for i in range(N-1):
before_x, before_y = xy[i]
x, y = xy[i+1]
root.append((d[xy[i]],d[xy[i+1]],y - before_y))
root = sorted(root, key = lambda x:x[2])
ans = 0
for s,g,c in root:
if uf.same(s,g):
continue
else:
uf.union(s,g)
ans += c
print(ans)
|
p03682
|
#16:15
n = int(eval(input()))
xyi = []
for i in range(n):
xyi.append(list(map(int,input().split())) + [i])
xyi.sort()
road = []
for j in range(n-1):
road.append([xyi[j+1][0]-xyi[j][0],xyi[j][2],xyi[j+1][2]])
xyi.sort(key = lambda x: x[1])
for j in range(n-1):
road.append([xyi[j+1][1]-xyi[j][1],xyi[j][2],xyi[j+1][2]])
road.sort()
pre = [i for i in range(n)]
ans = 0
for k in range(2*n-2):
d,I,J = road[k]
ii = []
ic = 0
jj = []
jc = 0
while pre[I] != I:
ii.append(I)
ic += 1
I = pre[I]
while pre[J] != J:
jj.append(J)
jc += 1
J = pre[J]
if I != J:
ans += d
if ic >= jc:
for Js in jj:
pre[Js] = I
pre[J] = I
else:
for Is in ii:
pre[Is] = J
pre[I] = J
print(ans)
|
#16:15
n = int(eval(input()))
xyi = []
for i in range(n):
xyi.append(list(map(int,input().split())) + [i])
xyi.sort()
road = []
for j in range(n-1):
road.append([xyi[j+1][0]-xyi[j][0],xyi[j][2],xyi[j+1][2]])
xyi.sort(key = lambda x: x[1])
for j in range(n-1):
road.append([xyi[j+1][1]-xyi[j][1],xyi[j][2],xyi[j+1][2]])
road.sort()
pre = [i for i in range(n)]
ans = 0
for k in range(2*n-2):
d,I,J = road[k]
ii = []
jj = []
while pre[I] != I:
ii.append(I)
I = pre[I]
for Is in ii:
pre[Is] = I
while pre[J] != J:
jj.append(J)
J = pre[J]
for Js in jj:
pre[Js] = J
if I != J:
pre[J] = I
ans += d
print(ans)
|
p03682
|
import heapq
from collections import defaultdict
N=int(eval(input()))
X=[]
Y=[]
dic_x=defaultdict(list)
dic_y=defaultdict(list)
for i in range(N):
x,y=list(map(int,input().split()))
dic_x[x].append(i)
dic_y[y].append(i)
X.append(x)
Y.append(y)
X=sorted(X)
Y=sorted(Y)
V=N
E=(V-1)*2
G=[]
for i in range(N-1):
if i==0:
x1,x2=X[0],X[1]
y1,y2=Y[0],Y[1]
else:
x1,x2=x_prev,X[i+1]
y1,y2=y_prev,Y[i+1]
x_prev=x2
y_prev=y2
heapq.heappush(G,(x2-x1,dic_x[x1].pop(),dic_x[x2][0]))
heapq.heappush(G,(y2-y1,dic_y[y1].pop(),dic_y[y2][0]))
class UnionFind:
def __init__(self, n):
self.n = n
self.p = [e for e in range(n)]
self.rank = [0] * n
self.size = [1] * n
def same(self, u, v):
return self.find_set(u) == self.find_set(v)
def unite(self, u, v):
u = self.find_set(u)
v = self.find_set(v)
if u == v:
return
if self.rank[u] > self.rank[v]:
self.p[v] = u
self.size[u] += self.size[v]
else:
self.p[u] = v
self.size[v] += self.size[u]
if self.rank[u] == self.rank[v]:
self.rank[v] += 1
def find_set(self, u):
if u != self.p[u]:
self.p[u] = self.find_set(self.p[u])
return self.p[u]
def update_p(self):
for u in range(self.n):
self.find_set(u)
def get_size(self, u):
return self.size[self.find_set(u)]
def Minmum_Spanning_Tree(G,V,E):
uf=UnionFind(V)
T=[]
tot_weight=0
while len(T)!=V-1:
w,u,v=heapq.heappop(G)
if uf.same(u-1,v-1)==False:
uf.unite(u-1,v-1)
tot_weight+=w
T.append([u,v])
return [T,tot_weight]
l=Minmum_Spanning_Tree(G,V,E)
T=l[0]
weight=l[1]
print(weight)
|
import heapq
from collections import defaultdict
N=int(eval(input()))
X=[]
Y=[]
dic_x=defaultdict(list)
dic_y=defaultdict(list)
for i in range(N):
x,y=list(map(int,input().split()))
dic_x[x].append(i)
dic_y[y].append(i)
X.append(x)
Y.append(y)
X=sorted(X)
Y=sorted(Y)
V=N
E=(V-1)*2
G=[]
for i in range(N-1):
heapq.heappush(G,(X[i+1]-X[i],dic_x[X[i]].pop(),dic_x[X[i+1]][0]))
heapq.heappush(G,(Y[i+1]-Y[i],dic_y[Y[i]].pop(),dic_y[Y[i+1]][0]))
class UnionFind:
def __init__(self, n):
self.n = n
self.p = [e for e in range(n)]
self.rank = [0] * n
self.size = [1] * n
def same(self, u, v):
return self.find_set(u) == self.find_set(v)
def unite(self, u, v):
u = self.find_set(u)
v = self.find_set(v)
if u == v:
return
if self.rank[u] > self.rank[v]:
self.p[v] = u
self.size[u] += self.size[v]
else:
self.p[u] = v
self.size[v] += self.size[u]
if self.rank[u] == self.rank[v]:
self.rank[v] += 1
def find_set(self, u):
if u != self.p[u]:
self.p[u] = self.find_set(self.p[u])
return self.p[u]
def update_p(self):
for u in range(self.n):
self.find_set(u)
def get_size(self, u):
return self.size[self.find_set(u)]
def Minmum_Spanning_Tree(G,V,E):
uf=UnionFind(V)
cnt=0
tot_weight=0
while cnt!=V-1:
w,u,v=heapq.heappop(G)
if uf.same(u-1,v-1)==False:
uf.unite(u-1,v-1)
tot_weight+=w
cnt+=1
return tot_weight
weight=Minmum_Spanning_Tree(G,V,E)
print(weight)
|
p03682
|
def main():
import heapq
class Prim():
# 無向グラフであるという前提に注意
def __init__(self, N):
self.edge = [[] for i in range(N)]
self.N = N
def add(self, u, v, d):
"""
u = from, v = to, d = cost
0-indexedであることに注意、graph.add(u-1, v-1)とする必要がある
"""
self.edge[u].append([d, v]) # コスト、e_toとなっていることに注意
self.edge[v].append([d, u])
def delete(self, u, v):
self.edge[u] = [_ for _ in self.edge[u] if _[0] != v]
self.edge[v] = [_ for _ in self.edge[v] if _[0] != u]
def Prim(self):
"""
return: 最小全域木のコストの和
"""
used = [True] * self.N # True:不使用
edgelist = []
for e in self.edge[0]:
heapq.heappush(edgelist, e)
used[0] = False
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
used[v] = False
for e in self.edge[v]:
if used[e[1]]:
heapq.heappush(edgelist, e)
res += minedge[0]
return res
N = int(eval(input()))
data = [list(map(int, input().split())) for i in range(N)]
G = Prim(N)
X = []
Y = []
for i in range(G.N):
X.append((data[i][0], i))
Y.append((data[i][1], i))
X = sorted(X)
Y = sorted(Y)
# 辞書順で隣り合うものだけ考えれば良い
for i in range(G.N - 1):
G.add(X[i][1], X[i + 1][1], X[i + 1][0] - X[i][0])
G.add(Y[i][1], Y[i + 1][1], Y[i + 1][0] - Y[i][0])
print((G.Prim()))
if __name__ == '__main__':
main()
|
class Kruskal():
def __init__(self,n):
self.e = []
self.par = [i for i in range(n+1)] #親のノード番号
self.rank = [0]*(n+1)
def add(self,u,v,d): #クラスカル法で考えるのは無向グラフ
self.e.append([u,v,d])
def find(self,x): #xの根のノード番号
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self,x,y): #x,yが同じグループか否か
return self.find(x) == self.find(y)
def unite(self,x,y): #x,yの属するグループの併合
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
elif self.rank[x] > self.rank[y]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def Kruskal(self):
edges = sorted(self.e,key=lambda x: x[2]) #距離でソート
a = 0
for e in edges:
if not self.same_check(e[0],e[1]):
self.unite(e[0],e[1])
a += e[2]
return a
N = int(eval(input()))
A = [list(map(int,input().split())) for i in range(N)]
G = Kruskal(N)
X = []
Y = []
for i in range(N):
X.append((A[i][0], i))
Y.append((A[i][1], i))
X = sorted(X)
Y = sorted(Y)
# 辞書順で隣り合うものだけ考えれば良い
for i in range(N - 1):
G.add(X[i][1], X[i + 1][1], X[i + 1][0] - X[i][0])
G.add(Y[i][1], Y[i + 1][1], Y[i + 1][0] - Y[i][0])
print((G.Kruskal()))
|
p03682
|
import heapq
n=int(eval(input()))
x=[]
y=[]
for i in range(n):
xx,yy=list(map(int,input().split()))
x.append([xx,i])
y.append([yy,i])
x.sort()
y.sort()
px=[]
py=[]
for i in range(n-1):
px.append([x[i+1][0]-x[i][0],x[i][1],x[i+1][1]])
py.append([y[i+1][0]-y[i][0],y[i][1],y[i+1][1]])
p=px+py
x=[]
y=[]
px=[]
py=[]
heapq.heapify(p)
r=[i for i in range(n)]
rank=[1 for i in range(n)]
def root(x):
if x==r[x]:
return x
else:
r[x]=root(r[x])
return r[x]
def union(x,y):
rx=root(x)
ry=root(y)
if rank[rx]>rank[ry]:
r[rx]=ry
rank[rx]+=rank[ry]
else:
r[ry]=rx
rank[ry]+=rank[rx]
ans=0
while p:
path=heapq.heappop(p)
if root(path[1])==root(path[2]):
continue
union(path[1],path[2])
ans+=path[0]
print(ans)
|
n=int(eval(input()))
x=[]
y=[]
for i in range(n):
xx,yy=list(map(int,input().split()))
x.append([xx,i])
y.append([yy,i])
x.sort()
y.sort()
px=[]
py=[]
for i in range(n-1):
px.append([x[i+1][0]-x[i][0],x[i][1],x[i+1][1]])
py.append([y[i+1][0]-y[i][0],y[i][1],y[i+1][1]])
p=px+py
x=[]
y=[]
px=[]
py=[]
p.sort()
r=[i for i in range(n)]
rank=[1 for i in range(n)]
def root(x):
if x==r[x]:
return x
else:
r[x]=root(r[x])
return r[x]
def union(path):
rx=root(path[1])
ry=root(path[2])
if rx==ry:
return 0
else:
if rank[rx]>rank[ry]:
r[rx]=ry
rank[rx]+=rank[ry]
else:
r[ry]=rx
rank[ry]+=rank[rx]
return path[0]
ans=0
for i in range(len(p)):
ans+=union(p[i])
print(ans)
|
p03682
|
n=int(eval(input()))
x=[]
y=[]
for i in range(n):
xx,yy=list(map(int,input().split()))
x.append([xx,i])
y.append([yy,i])
x.sort()
y.sort()
px=[]
py=[]
for i in range(n-1):
px.append([x[i+1][0]-x[i][0],x[i][1],x[i+1][1]])
py.append([y[i+1][0]-y[i][0],y[i][1],y[i+1][1]])
p=px+py
x=[]
y=[]
px=[]
py=[]
p.sort()
r=[i for i in range(n)]
rank=[1 for i in range(n)]
def root(x):
if x==r[x]:
return x
else:
r[x]=root(r[x])
return r[x]
def union(path):
rx=root(path[1])
ry=root(path[2])
if rx==ry:
return 0
else:
if rank[rx]>rank[ry]:
r[rx]=ry
rank[rx]+=rank[ry]
else:
r[ry]=rx
rank[ry]+=rank[rx]
return path[0]
ans=0
for i in range(len(p)):
ans+=union(p[i])
print(ans)
|
n=int(eval(input()))
x=[]
y=[]
for i in range(n):
xx,yy=list(map(int,input().split()))
x.append([xx,i])
y.append([yy,i])
x.sort()
y.sort()
px=[[x1-x0,i0,i1] for (x0,i0),(x1,i1) in zip(x,x[1:])]
py=[[y1-y0,i0,i1] for (y0,i0),(y1,i1) in zip(y,y[1:])]
p=px+py
x=[]
y=[]
px=[]
py=[]
p.sort()
r=[i for i in range(n)]
rank=[1 for i in range(n)]
def root(x):
if x==r[x]:
return x
else:
r[x]=root(r[x])
return r[x]
def union(path):
rx=root(path[1])
ry=root(path[2])
if rx==ry:
return 0
else:
if rank[rx]>rank[ry]:
r[rx]=ry
rank[rx]+=rank[ry]
else:
r[ry]=rx
rank[ry]+=rank[rx]
return path[0]
ans=0
for i in range(len(p)):
ans+=union(p[i])
print(ans)
|
p03682
|
from operator import itemgetter
from collections import defaultdict
class UnionFindTree():
def __init__(self):
self.__parent_of = defaultdict(lambda: None)
self.__rank_of = defaultdict(lambda: 0)
self.__size = defaultdict(lambda: 1)
def __root(self, value):
if self.__parent_of[value] is None:
return value
else:
self.__parent_of[value] = self.__root(self.__parent_of[value])
return self.__parent_of[value]
def unite(self, a, b):
r1 = self.__root(a)
r2 = self.__root(b)
if r1 != r2:
if self.__rank_of[r1] < self.__rank_of[r2]:
self.__parent_of[r1] = r2
self.__size[r2] += self.__size[r1]
else:
self.__parent_of[r2] = r1
self.__size[r1] += self.__size[r2]
if self.__rank_of[r1] == self.__rank_of[r2]:
self.__rank_of[r1] += 1
def is_same(self, a, b):
return self.__root(a) == self.__root(b)
def size(self, a):
return self.__size[self.__root(a)]
def main():
N = int(eval(input()))
X = [None] * N
Y = [None] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
adj = [None] * (2*N - 2)
for i in range(N-1):
adj[2*i] = (X[i+1][0] - X[i][0], X[i][1], X[i+1][1])
adj[2*i+1] = (Y[i+1][0] - Y[i][0], Y[i][1], Y[i+1][1])
adj.sort(key=itemgetter(0))
uft = UnionFindTree()
ans = 0
for pair in adj:
cost, a, b = pair
if not uft.is_same(a, b):
uft.unite(a, b)
ans += cost
if uft.size(a) == N:
break
print(ans)
if __name__ == "__main__":
main()
|
from operator import itemgetter
class UnionFindTree():
def __init__(self, N):
self.__parent_of = [None] * N
self.__rank_of = [0] * N
self.__size = [1] * N
def __root(self, value):
if self.__parent_of[value] is None:
return value
else:
self.__parent_of[value] = self.__root(self.__parent_of[value])
return self.__parent_of[value]
def unite(self, a, b):
r1 = self.__root(a)
r2 = self.__root(b)
if r1 != r2:
if self.__rank_of[r1] < self.__rank_of[r2]:
self.__parent_of[r1] = r2
self.__size[r2] += self.__size[r1]
else:
self.__parent_of[r2] = r1
self.__size[r1] += self.__size[r2]
if self.__rank_of[r1] == self.__rank_of[r2]:
self.__rank_of[r1] += 1
def is_same(self, a, b):
return self.__root(a) == self.__root(b)
def size(self, a):
return self.__size[self.__root(a)]
def groups(self):
groups = {}
for k in list(self.__parent_of.keys()):
r = self.__root(k)
if r not in groups:
groups[r] = []
groups[r].append(k)
return [groups[x] for x in groups]
def main():
N = int(eval(input()))
X = [None] * N
Y = [None] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
adj = [None] * (2*N - 2)
for i in range(N-1):
adj[2*i] = (X[i+1][0] - X[i][0], X[i][1], X[i+1][1])
adj[2*i+1] = (Y[i+1][0] - Y[i][0], Y[i][1], Y[i+1][1])
adj.sort(key=itemgetter(0))
uft = UnionFindTree(N)
ans = 0
for pair in adj:
cost, a, b = pair
if not uft.is_same(a, b):
uft.unite(a, b)
ans += cost
if uft.size(a) == N:
break
print(ans)
if __name__ == "__main__":
main()
|
p03682
|
import operator
import sys
# sys.stdin = open('d1.in')
def read_int_list():
return list(map(int, input().split()))
def read_str_list():
return input().split()
def read_int():
return int(eval(input()))
def read_str():
return eval(input())
p = []
rank = []
def make_set(x):
p[x] = x
rank[x] = 0
def _union(x, y):
link(find_set(x), find_set(y))
def link(x, y):
if rank[x] > rank[y]:
p[y] = x
else:
p[x] = y
if rank[x] == rank[y]:
rank[x] += 1
def find_set(x):
if x != p[x]:
p[x] = find_set(p[x])
return p[x]
def solve():
n = read_int()
a = [read_int_list() for i in range(n)]
global p, rank
p = [0] * n
rank = [0] * n
for x in range(n):
make_set(x)
def get_cost(i, j):
return min(abs(a[i][0] - a[j][0]), abs(a[i][1] - a[j][1]))
roads = []
for j in range(2):
l = sorted(list(range(n)), key=lambda i: a[i][j])
for i in range(n - 1):
cost = get_cost(l[i], l[i + 1])
road = (cost, l[i], l[i + 1])
roads.append(road)
roads.sort()
res = 0
for road in roads:
c, u, v = road
if find_set(u) != find_set(v):
res += c
_union(u, v)
return res
def main():
res = solve()
print(res)
main()
|
import sys
# sys.stdin = open('d1.in')
def read_int_list():
return list(map(int, input().split()))
def read_str_list():
return input().split()
def read_int():
return int(eval(input()))
def read_str():
return eval(input())
p = []
rank = []
def make_set(x):
p[x] = x
rank[x] = 0
def _union(x, y):
link(find_set(x), find_set(y))
def link(x, y):
if rank[x] > rank[y]:
p[y] = x
else:
p[x] = y
if rank[x] == rank[y]:
rank[x] += 1
def find_set(x):
if x != p[x]:
p[x] = find_set(p[x])
return p[x]
def solve():
n = read_int()
a = [read_int_list() for i in range(n)]
global p, rank
p = [0] * n
rank = [0] * n
for x in range(n):
make_set(x)
def get_cost(i, j):
return min(abs(a[i][0] - a[j][0]), abs(a[i][1] - a[j][1]))
roads = []
for j in range(2):
l = sorted(list(range(n)), key=lambda i: a[i][j])
for i in range(n - 1):
cost = get_cost(l[i], l[i + 1])
road = (cost, l[i], l[i + 1])
roads.append(road)
roads.sort()
res = 0
m = 0
for road in roads:
c, u, v = road
if find_set(u) != find_set(v):
res += c
m += 1
_union(u, v)
if m == n - 1:
break
return res
def main():
res = solve()
print(res)
main()
|
p03682
|
N = int(eval(input()))
z = [tuple(map(int,input().split())) for i in range(N)]
z.sort()
y = [(z[i][1],i) for i in range(N)]
y.sort()
cost = [[] for i in range(N)]
for i in range(N-1):
j = y[i][1]
cost[i].append((i-1,min(abs(z[i][0]-z[i-1][0]),abs(z[i][1]-z[i-1][1]))))
j_ = y[i-1][1]
cost[j].append((j_,min(abs(y[i][0]-y[i-1][0]),abs(z[j][0]-z[j_][0]))))
cost[i].append((i+1,min(abs(z[i+1][0]-z[i][0]),abs(z[i+1][1]-z[i][1]))))
j_ = y[i+1][1]
cost[j].append((j_,min(abs(y[i+1][0]-y[i][0]),abs(z[j_][1]-z[j][1]))))
i = N-1
j = y[i][1]
cost[i].append((i-1,min(abs(z[i][0]-z[i-1][0]),abs(z[i][1]-z[i-1][1]))))
j_ = y[i-1][1]
cost[j].append((j_,min(abs(y[i][0]-y[i-1][0]),abs(z[j][0]-z[j_][0]))))
import heapq
def prim(cost):
V = len(cost)
res = 0
mincost = [float('inf')]*V
used = [False]*V
hq = []
mincost[0] = 0
heapq.heappush(hq,(0,0))
done = 0
while hq:
weight,u = heapq.heappop(hq)
if not used[u]:
used[u] = True
done += 1
res += weight
mincost[u] = weight
for v, v_cost in cost[u]:
if not used[v]:
heapq.heappush(hq,(v_cost,v))
if done == V:
break
return res
print((prim(cost)))
|
N = int(eval(input()))
z = [tuple(map(int,input().split())) for i in range(N)]
z.sort()
y = [(z[i][1],i) for i in range(N)]
y.sort()
cost = [[] for i in range(N)]
for i in range(N-1):
j = y[i][1]
cost[i].append((i-1,min(abs(z[i][0]-z[i-1][0]),abs(z[i][1]-z[i-1][1]))))
j_ = y[i-1][1]
cost[j].append((j_,min(abs(y[i][0]-y[i-1][0]),abs(z[j][0]-z[j_][0]))))
cost[i].append((i+1,min(abs(z[i+1][0]-z[i][0]),abs(z[i+1][1]-z[i][1]))))
j_ = y[i+1][1]
cost[j].append((j_,min(abs(y[i+1][0]-y[i][0]),abs(z[j_][1]-z[j][1]))))
i = N-1
j = y[i][1]
cost[i].append((i-1,min(abs(z[i][0]-z[i-1][0]),abs(z[i][1]-z[i-1][1]))))
j_ = y[i-1][1]
cost[j].append((j_,min(abs(y[i][0]-y[i-1][0]),abs(z[j][0]-z[j_][0]))))
import heapq
def prim(cost):
V = len(cost)
res = 0
mincost = [float('inf')]*V
used = [False]*V
hq = []
mincost[0] = 0
heapq.heappush(hq,(0,0))
while hq:
weight,u = heapq.heappop(hq)
if not used[u]:
used[u] = True
res += weight
mincost[u] = weight
for v, v_cost in cost[u]:
if not used[v]:
heapq.heappush(hq,(v_cost,v))
return res
print((prim(cost)))
|
p03682
|
N=int(eval(input()))
city=[]
for i in range(N):
x,y=list(map(int,input().split()))
city.append((i,x,y))
city.sort(key=lambda x:x[1])
data=[]
for i in range(N-1):
data.append((city[i][0],city[i+1][0],city[i+1][1]-city[i][1]))
city.sort(key=lambda y:y[2])
for i in range(N-1):
data.append((city[i][0],city[i+1][0],city[i+1][2]-city[i][2]))
data.sort(key=lambda d:d[2])
idx=[-1]*N
def find(idx,x):
if idx[x]<0:
return x
elif idx[x]>=0:
idx[x]=find(idx,idx[x])
return idx[x]
ans=0
for q in range(len(data)):
i,j,d=data[q]
iidx=find(idx,i)
jidx=find(idx,j)
if iidx==jidx:
continue
elif idx[iidx]<=idx[jidx]:
idx[iidx]+=idx[jidx]
idx[jidx]=iidx
ans+=d
elif idx[iidx]>idx[jidx]:
idx[jidx]+=idx[iidx]
idx[iidx]=jidx
ans+=d
print(ans)
|
N=int(eval(input()))
city=[0]*N
for i in range(N):
x,y=list(map(int,input().split()))
city[i]=(i,x,y)
city.sort(key=lambda x:x[1])
data=[(city[i][0],city[i+1][0],city[i+1][1]-city[i][1]) for i in range(N-1)]
city.sort(key=lambda x:x[2])
data+=[(city[i][0],city[i+1][0],city[i+1][2]-city[i][2]) for i in range(N-1)]
data.sort(key=lambda x:x[2])
root=[-1]*N
def search(i):
global root
if root[i]>=0:
root[i]=search(root[i])
return root[i]
return i
cost=0
for i,j,k in data:
ri=search(i)
rj=search(j)
if ri==rj:
continue
elif root[ri]<=root[rj]:
cost+=k
root[ri]+=root[rj]
root[rj]=ri
elif root[ri]>root[rj]:
cost+=k
root[rj]+=root[ri]
root[ri]=rj
print(cost)
|
p03682
|
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
import heapq
n = int(eval(input()))
l = [[0, 0] for i in range(n)]
for i in range(n):
x, y = list(map(int, input().split()))
l[i][0] = x
l[i][1] = y
graph = []
for i in range(n-1):
x1, y1 = l[i]
for j in range(i, n):
x2, y2 = l[j]
graph.append((min(abs(x1-x2), abs(y1-y2)), i, j))
graph.append((min(abs(x1-x2), abs(y1-y2)), j, i))
#union find
def Find(x, par):
if par[x] < 0:
return x
else:
# 経路圧縮
par[x] = Find(par[x], par)
return par[x]
def Unite(x, y, par, rank):
x = Find(x, par)
y = Find(y, par)
if x != y:
# rankの低い方を高い方につなげる
if rank[x] < rank[y]:
par[y] += par[x]
par[x] = y
else:
par[x] += par[y]
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
def Same(x, y, par):
return Find(x, par) == Find(y, par)
def Size(x, par):
return -par[Find(x)]
#print(graph)
graph.sort()
par = [-1]*n
rank = [0]*n
cost = 0
for d, p, q in graph:
if not Same(p, q, par):
cost += d
Unite(p, q, par, rank)
print(cost)
|
import sys
input = sys.stdin.buffer.readline
n = int(eval(input()))
P = []
for i in range(n):
x, y = list(map(int, input().split()))
P.append((x, y, i))
import heapq
def prim_heap():
used = [True]*n
edgelist = []
for e in edge[0]:
heapq.heappush(edgelist, e)
used[0] = False
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist)
if not used[minedge[1]]:
continue
v = minedge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist, e)
res += minedge[0]
return res
P.sort()
edge = [[] for _ in range(n)]
for i in range(n-1):
d = min(abs(P[i+1][0]-P[i][0]), abs(P[i+1][1]-P[i][1]))
edge[P[i][2]].append((d, P[i+1][2]))
edge[P[i+1][2]].append((d, P[i][2]))
P.sort(key = lambda x: x[1])
for i in range(n-1):
d = min(abs(P[i+1][0]-P[i][0]), abs(P[i+1][1]-P[i][1]))
edge[P[i][2]].append((d, P[i+1][2]))
edge[P[i+1][2]].append((d, P[i][2]))
print((prim_heap()))
|
p03682
|
class UnionFind:
# 初期化
def __init__(self, n):
# 根なら-size, 子なら親の頂点
self.par = [-1] * n
# 木の高さ
self.rank = [0] * n
# 検索
def find(self, x):
if self.par[x] < 0:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
# 高い方をxとする。
if self.rank[x] < self.rank[y]:
x,y = y,x
# 同じ高さの時は高さ+1
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# yの親をxとし、xのサイズにyのサイズを加える
self.par[x] += self.par[y]
self.par[y] = x
# 同集合判定
def same(self, x, y):
return self.find(x) == self.find(y)
from operator import itemgetter
n = int(eval(input()))
xy = []
for i in range(n):
x,y = list(map(int, input().split()))
xy.append([i,x,y])
x = sorted(xy,key=itemgetter(1))
y = sorted(xy,key=itemgetter(2))
xx = []
yy = []
for i in range(n-1):
xx.append([x[i+1][1]-x[i][1],x[i][0],x[i+1][0]])
yy.append([y[i+1][2]-y[i][2],y[i][0],y[i+1][0]])
xx.sort()
yy.sort()
xx.reverse()
yy.reverse()
a = UnionFind(n)
ans = 0
i = 0
xxx = xx.pop()
yyy = yy.pop()
while i!=n-1:
if xxx[0] < yyy[0]:
if not a.same(xxx[1],xxx[2]):
a.unite(xxx[1],xxx[2])
ans += xxx[0]
i += 1
if xx:
xxx = xx.pop()
else:
xxx = [float('inf'),0,0]
else:
if not a.same(yyy[1],yyy[2]):
a.unite(yyy[1],yyy[2])
ans += yyy[0]
i += 1
if yy:
yyy = yy.pop()
else:
yyy = [float('inf'),0,0]
print(ans)
|
class UnionFind:
# 初期化
def __init__(self, n):
# 根なら-size, 子なら親の頂点
self.par = [-1] * n
# 木の高さ
self.rank = [0] * n
# 検索
def find(self, x):
if self.par[x] < 0:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
# 異なる集合に属する場合のみ併合
if x != y:
# 高い方をxとする。
if self.rank[x] < self.rank[y]:
x,y = y,x
# 同じ高さの時は高さ+1
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# yの親をxとし、xのサイズにyのサイズを加える
self.par[x] += self.par[y]
self.par[y] = x
# 同集合判定
def same(self, x, y):
return self.find(x) == self.find(y)
# 集合の大きさ
def size(self, x):
return -self.par[self.find(x)]
from operator import itemgetter
n = int(eval(input()))
xy = []
for i in range(n):
x,y = list(map(int, input().split()))
xy.append([i,x,y])
x = sorted(xy,key=itemgetter(1))
y = sorted(xy,key=itemgetter(2))
xx = []
yy = []
for i in range(n-1):
xx.append([x[i][0],x[i+1][0],x[i+1][1]-x[i][1]])
yy.append([y[i][0],y[i+1][0],y[i+1][2]-y[i][2]])
xx.sort(key=itemgetter(2))
yy.sort(key=itemgetter(2))
xx.reverse()
yy.reverse()
a = UnionFind(n)
ans = 0
i = 0
xxx = xx.pop()
yyy = yy.pop()
while i!=n-1:
if xxx[2] < yyy[2]:
if not a.same(xxx[0],xxx[1]):
a.unite(xxx[0],xxx[1])
ans += xxx[2]
i += 1
if xx:
xxx = xx.pop()
else:
xxx = [0,0,float('inf')]
else:
if not a.same(yyy[0],yyy[1]):
a.unite(yyy[0],yyy[1])
ans += yyy[2]
i += 1
if yy:
yyy = yy.pop()
else:
yyy = [0,0,float('inf')]
print(ans)
|
p03682
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.