input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
def size(self, x):
return -self.parent[self.find(x)]
def find(self, x):
if (self.parent[x] < 0):
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if (x == y):
return False
if (self.size(x) < self.size(y)):
self.parent[y] += self.parent[x]
self.parent[x] = y
else:
self.parent[x] += self.parent[y]
self.parent[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def main():
N = int(eval(input()))
x_list = []
y_list = []
x_app = x_list.append
y_app = y_list.append
for i in range(N):
x, y = (int(x) for x in input().split())
x_app([x, i])
y_app([y, i])
x_list.sort()
y_list.sort()
adj = []
adj_app = adj.append
for i in range(N-1):
adj_app([x_list[i + 1][0] - x_list[i][0], x_list[i + 1][1], x_list[i][1]])
adj_app([y_list[i + 1][0] - y_list[i][0], y_list[i + 1][1], y_list[i][1]])
adj.sort()
uf = UnionFind(N)
ans = 0
for edge in adj:
if not uf.same(edge[1], edge[2]):
ans += edge[0]
uf.unite(edge[1], edge[2])
print(ans)
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
def size(self, x):
return -self.parent[self.find(x)]
def find(self, x):
if (self.parent[x] < 0):
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if (x == y):
return False
if (self.size(x) < self.size(y)):
self.parent[y] += self.parent[x]
self.parent[x] = y
else:
self.parent[x] += self.parent[y]
self.parent[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def main():
N = int(eval(input()))
x_list = []
y_list = []
x_app = x_list.append
y_app = y_list.append
for i in range(N):
x, y = (int(x) for x in input().split())
x_app([x, i])
y_app([y, i])
x_list.sort()
y_list.sort()
adj = []
adj_app = adj.append
for i in range(N-1):
adj_app((x_list[i + 1][0] - x_list[i][0], x_list[i + 1][1], x_list[i][1]))
adj_app((y_list[i + 1][0] - y_list[i][0], y_list[i + 1][1], y_list[i][1]))
adj.sort()
uf = UnionFind(N)
ans = 0
for edge in adj:
if not uf.same(edge[1], edge[2]):
ans += edge[0]
uf.unite(edge[1], edge[2])
print(ans)
if __name__ == '__main__':
main()
|
p03682
|
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
def size(self, x):
return -self.parent[self.find(x)]
def find(self, x):
if (self.parent[x] < 0):
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if (x == y):
return False
if (self.size(x) < self.size(y)):
self.parent[y] += self.parent[x]
self.parent[x] = y
else:
self.parent[x] += self.parent[y]
self.parent[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def main():
N = int(eval(input()))
x_list = []
y_list = []
x_app = x_list.append
y_app = y_list.append
for i in range(N):
x, y = (int(x) for x in input().split())
x_app([x, i])
y_app([y, i])
x_list.sort()
y_list.sort()
adj = []
adj_app = adj.append
for i in range(N-1):
adj_app((x_list[i + 1][0] - x_list[i][0], x_list[i + 1][1], x_list[i][1]))
adj_app((y_list[i + 1][0] - y_list[i][0], y_list[i + 1][1], y_list[i][1]))
adj.sort(key=lambda x: x[0])
uf = UnionFind(N)
ans = 0
for edge in adj:
if not uf.same(edge[1], edge[2]):
ans += edge[0]
uf.unite(edge[1], edge[2])
print(ans)
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1] * (n + 1)
self.rnk = [0] * (n + 1)
def find_root(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find_root(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
def isSameGroup(self, x, y):
return self.find_root(x) == self.find_root(y)
def size(self, x):
return -self.root[self.find_root(x)]
def main():
N = int(eval(input()))
x_list = []
y_list = []
x_app = x_list.append
y_app = y_list.append
for i in range(N):
x, y = list(map(int, input().split()))
x_app([x, i])
y_app([y, i])
x_list.sort()
y_list.sort()
adj = []
adj_app = adj.append
for i in range(N-1):
adj_app([x_list[i + 1][0] - x_list[i][0], x_list[i + 1][1], x_list[i][1]])
adj_app([y_list[i + 1][0] - y_list[i][0], y_list[i + 1][1], y_list[i][1]])
adj.sort(key=lambda x: x[0])
uf = UnionFind(N)
ans = 0
for edge in adj:
if not uf.isSameGroup(edge[1], edge[2]):
ans += edge[0]
uf.unite(edge[1], edge[2])
print(ans)
if __name__ == '__main__':
main()
|
p03682
|
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*n
self.rank=[-1]*n
def Find_Root(self,x):
if self.root[x]<0:return x
else:
self.root[x]=self.Find_Root(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.Find_Root(x)
y=self.Find_Root(y)
if x==y:return
elif self.rank[x]>self.rank[y]:
self.root[x] +=self.root[y]
self.root[y]=x
else:
self.root[y] +=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y] +=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def size(self,x):
return -self.root[self.Find_Root(x)]
def members(self,x):
root=self.Find_Root(x)
return [i for i in range(self.n) if self.Find_Root(i)==root]
def roots(self):
return[i for i,j in enumerate(self.root) if j<0]
def group_members(self):
return {i:self.members(i) for i in self.roots()}
def group_count(self):
return len(self.roots())
def kruskal():
D,M=[],[]
A,B=sorted(XY),sorted(XY, key=lambda x: x[1])
for i in range(n-1):
M.append([min(abs(A[i][0]-A[i+1][0]),abs(A[i][1]-A[i+1][1])),A[i][2],A[i+1][2]])
M.append([min(abs(B[i][0]-B[i+1][0]),abs(B[i][1]-B[i+1][1])),B[i][2],B[i+1][2]])
M.sort()
for w,s,t in M:
if UnionFind.isSameGroup(s,t) is False:
UnionFind.Unite(s,t)
D.append(w)
return D
n=int(eval(input()))
XY=[list(map(int,input().split()))+[i+1] for i in range(n)]
UnionFind=UnionFind(n+1)
print((sum(kruskal())))
|
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*n
self.rank=[-1]*n
def Find_Root(self,x):
if self.root[x]<0:return x
else:
self.root[x]=self.Find_Root(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.Find_Root(x)
y=self.Find_Root(y)
if x==y:return
elif self.rank[x]>self.rank[y]:
self.root[x] +=self.root[y]
self.root[y]=x
else:
self.root[y] +=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y] +=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def size(self,x):
return -self.root[self.Find_Root(x)]
def members(self,x):
root=self.Find_Root(x)
return [i for i in range(self.n) if self.Find_Root(i)==root]
def roots(self):
return[i for i,j in enumerate(self.root) if j<0]
def group_members(self):
return {i:self.members(i) for i in self.roots()}
def group_count(self):
return len(self.roots())
def kruskal():
D,M=[],[]
A,B=sorted(XY),sorted(XY, key=lambda x: x[1])
for i in range(n-1):
M.append([min(abs(A[i][0]-A[i+1][0]),abs(A[i][1]-A[i+1][1])),A[i][2],A[i+1][2]])
M.append([min(abs(B[i][0]-B[i+1][0]),abs(B[i][1]-B[i+1][1])),B[i][2],B[i+1][2]])
M.sort()
for w,s,t in M:
if UnionFind.isSameGroup(s,t) is False:
UnionFind.Unite(s,t)
D.append(w)
return D
import sys
input=sys.stdin.readline
n=int(eval(input()))
XY=[list(map(int,input().split()))+[i+1] for i in range(n)]
UnionFind=UnionFind(n+1)
print((sum(kruskal())))
|
p03682
|
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*n
self.rank=[-1]*n
def Find_Root(self,x):
if self.root[x]<0:return x
else:
self.root[x]=self.Find_Root(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.Find_Root(x)
y=self.Find_Root(y)
if x==y:return
elif self.rank[x]>self.rank[y]:
self.root[x] +=self.root[y]
self.root[y]=x
else:
self.root[y] +=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y] +=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def size(self,x):
return -self.root[self.Find_Root(x)]
def members(self,x):
root=self.Find_Root(x)
return [i for i in range(self.n) if self.Find_Root(i)==root]
def roots(self):
return[i for i,j in enumerate(self.root) if j<0]
def group_members(self):
return {i:self.members(i) for i in self.roots()}
def group_count(self):
return len(self.roots())
def kruskal():
D,M=[],[]
A,B=sorted(XY),sorted(XY, key=lambda x: x[1])
for i in range(n-1):
M.append([min(abs(A[i][0]-A[i+1][0]),abs(A[i][1]-A[i+1][1])),A[i][2],A[i+1][2]])
M.append([min(abs(B[i][0]-B[i+1][0]),abs(B[i][1]-B[i+1][1])),B[i][2],B[i+1][2]])
M.sort()
for w,s,t in M:
if UnionFind.isSameGroup(s,t) is False:
UnionFind.Unite(s,t)
D.append(w)
return D
import sys
input=sys.stdin.readline
n=int(eval(input()))
XY=[list(map(int,input().split()))+[i+1] for i in range(n)]
UnionFind=UnionFind(n+1)
print((sum(kruskal())))
|
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*n
self.rank=[-1]*n
def Find_Root(self,x):
if self.root[x]<0:return x
else:
self.root[x]=self.Find_Root(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.Find_Root(x)
y=self.Find_Root(y)
if x==y:return
elif self.rank[x]>self.rank[y]:
self.root[x] +=self.root[y]
self.root[y]=x
else:
self.root[y] +=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y] +=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def size(self,x):
return -self.root[self.Find_Root(x)]
def members(self,x):
root=self.Find_Root(x)
return [i for i in range(self.n) if self.Find_Root(i)==root]
def roots(self):
return[i for i,j in enumerate(self.root) if j<0]
def group_members(self):
return {i:self.members(i) for i in self.roots()}
def group_count(self):
return len(self.roots())
def kruskal():
D,M=[],[]
A,B=sorted(XY),sorted(XY,key=lambda x:x[1])
for i in range(n-1):
M.append([abs(A[i][0]-A[i+1][0]),A[i][2],A[i+1][2]])
M.append([abs(B[i][1]-B[i+1][1]),B[i][2],B[i+1][2]])
M.sort()
for i,j,k in M:
if UnionFind.isSameGroup(j,k) is False:
UnionFind.Unite(j,k)
D.append(i)
return D
n=int(eval(input()))
XY=[list(map(int,input().split()))+[i+1] for i in range(n)]
UnionFind=UnionFind(n+1)
print((sum(kruskal())))
|
p03682
|
import sys
input = sys.stdin.readline
from heapq import heappop,heappush
n = int(eval(input()))
p = []
for i in range(n):
x,y = list(map(int,input().split()))
p.append((i,x,y))
e = [[] for _ in range(n)]
p = sorted(p,key=lambda x:x[1])
n0,x0,y0 = p[0]
for i in range(n-1):
n1,x1,y1 = p[i+1]
e[n0].append([min(abs(x1-x0),abs(y1-y0)),n1])
e[n1].append([min(abs(x1-x0),abs(y1-y0)),n0])
n0,x0,y0 = n1,x1,y1
p = sorted(p,key=lambda x:x[2])
n0,x0,y0 = p[0]
for i in range(n-1):
n1,x1,y1 = p[i+1]
e[n0].append([min(abs(x1-x0),abs(y1-y0)),n1])
e[n1].append([min(abs(x1-x0),abs(y1-y0)),n0])
n0,x0,y0 = n1,x1,y1
def Prim(n,edge):
#edge[source] = [[cost_1,target_1],[cost_2,target_2],...]
used = [False] * n
q = []
#e = [cost,target]
for e in edge[0]:
heappush(q,e)
used[0] = True
res = 0
while q:
c,v = heappop(q)
if used[v]:
continue
used[v] = True
for e in edge[v]:
if not used[e[1]]:
heappush(q,e)
res += c
return res
print((Prim(n,e)))
|
from heapq import heappop,heappush
n = int(eval(input()))
p = []
for i in range(n):
x,y = list(map(int,input().split()))
p.append((i,x,y))
e = [[] for _ in range(n)]
p = sorted(p,key=lambda x:x[1])
n0,x0,y0 = p[0]
for i in range(n-1):
n1,x1,y1 = p[i+1]
e[n0].append((min(abs(x1-x0),abs(y1-y0)),n1))
e[n1].append((min(abs(x1-x0),abs(y1-y0)),n0))
n0,x0,y0 = n1,x1,y1
p = sorted(p,key=lambda x:x[2])
n0,x0,y0 = p[0]
for i in range(n-1):
n1,x1,y1 = p[i+1]
e[n0].append((min(abs(x1-x0),abs(y1-y0)),n1))
e[n1].append((min(abs(x1-x0),abs(y1-y0)),n0))
n0,x0,y0 = n1,x1,y1
def Prim(n,edge):
#edge[source] = [(cost_1,target_1),(cost_2,target_2),...]
used = [False] * n
q = []
#e = [cost,target]
for e in edge[0]:
heappush(q,e)
used[0] = True
res = 0
while q:
c,v = heappop(q)
if used[v]:
continue
used[v] = True
for e in edge[v]:
if not used[e[1]]:
heappush(q,e)
res += c
return res
print((Prim(n,e)))
|
p03682
|
N = int(eval(input()))
def find(x, U, r):
p = []
while not x == U[x]:
p.append(x)
x = U[x]
for x_ in p:
U[x_] == x
return x
def merge(x, y, U, r):
x = find(x, U, r)
y = find(y, U, r)
if x == y:
return False
#print(x,y, U)
if r[x] < r[y]:
x, y = y, x
U[y] = x
r[x] = max(r[y]+1, r[x])
#print(x,y, U)
return True
U = [i for i in range(N)]
r = [0 for _ in range(N)]
A = [(tuple(map(int, input().split())), j) for j in range(N)]
B = sorted(A)
C = sorted(A, key=lambda t: ((t[0][1],t[0][0]),t[1]))
#辺の作成
R = []
for i in range(1,N):
c = B[i][0][0] - B[i-1][0][0]
p1 = B[i][1]
p2 = B[i-1][1]
R.append((c, p1, p2))
R.append((c, p2, p1))
c = C[i][0][1] - C[i-1][0][1]
p1 = C[i][1]
p2 = C[i-1][1]
R.append((c, p1, p2))
R.append((c, p2, p1))
R.sort()
#Union Find:
U = [i for i in range(N)]
r = [0 for _ in range(N)]
#print(U)
ans = 0
for road in R:
c = road[0]
x = road[1]
y = road[2]
if merge(x, y, U, r):
#print(U)
ans += c
#print(U)
print(ans)
|
N = int(eval(input()))
def find(x, U, r):
p = []
while not x == U[x]:
p.append(x)
x = U[x]
for x_ in p:
U[x_] == x
return x
def merge(x, y, U, r):
x = find(x, U, r)
y = find(y, U, r)
if x == y:
return False
#print(x,y, U)
if r[x] < r[y]:
x, y = y, x
U[y] = x
r[x] = max(r[y]+1, r[x])
#print(x,y, U)
return True
U = [i for i in range(N)]
r = [0 for _ in range(N)]
B = []
C = []
for i in range(N):
u, v = list(map(int, input().split()))
B.append((u, v, i))
C.append((v, u, i))
B.sort()
C.sort()
#辺の作成
R = []
for i in range(1,N):
c = B[i][0] - B[i-1][0]
p1 = B[i][2]
p2 = B[i-1][2]
R.append((c, p1, p2))
R.append((c, p2, p1))
c = C[i][0] - C[i-1][0]
p1 = C[i][2]
p2 = C[i-1][2]
R.append((c, p1, p2))
R.append((c, p2, p1))
R.sort()
#Union Find:
U = [i for i in range(N)]
r = [0 for _ in range(N)]
#print(U)
ans = 0
for road in R:
c = road[0]
x = road[1]
y = road[2]
if merge(x, y, U, r):
#print(U)
ans += c
#print(U)
print(ans)
|
p03682
|
N = int(eval(input()))
def find(x, U, r):
p = []
while not x == U[x]:
p.append(x)
x = U[x]
for x_ in p:
U[x_] == x
return x
def merge(x, y, U, r):
x = find(x, U, r)
y = find(y, U, r)
if x == y:
return False
#print(x,y, U)
if r[x] < r[y]:
x, y = y, x
U[y] = x
r[x] = max(r[y]+1, r[x])
#print(x,y, U)
return True
U = [i for i in range(N)]
r = [0 for _ in range(N)]
B = []
C = []
for i in range(N):
u, v = list(map(int, input().split()))
B.append((u, v, i))
C.append((v, u, i))
B.sort()
C.sort()
#辺の作成
R = []
for i in range(1,N):
c = B[i][0] - B[i-1][0]
p1 = B[i][2]
p2 = B[i-1][2]
R.append((c, p1, p2))
R.append((c, p2, p1))
c = C[i][0] - C[i-1][0]
p1 = C[i][2]
p2 = C[i-1][2]
R.append((c, p1, p2))
R.append((c, p2, p1))
R.sort()
#Union Find:
U = [i for i in range(N)]
r = [0 for _ in range(N)]
#print(U)
ans = 0
for road in R:
c = road[0]
x = road[1]
y = road[2]
if merge(x, y, U, r):
#print(U)
ans += c
#print(U)
print(ans)
|
N = int(eval(input()))
def find(x, U, r):
p = []
while not x == U[x]:
p.append(x)
x = U[x]
for x_ in p:
U[x_] == x
return x
def merge(x, y, U, r):
x = find(x, U, r)
y = find(y, U, r)
if x == y:
return False
#print(x,y, U)
if r[x] < r[y]:
x, y = y, x
U[y] = x
r[x] = max(r[y]+1, r[x])
#print(x,y, U)
return True
U = [i for i in range(N)]
r = [0 for _ in range(N)]
B = []
C = []
for i in range(N):
u, v = list(map(int, input().split()))
B.append((u, v, i))
C.append((v, u, i))
B.sort()
C.sort()
#辺の作成
R = []
for i in range(1,N):
c = B[i][0] - B[i-1][0]
p1 = B[i][2]
p2 = B[i-1][2]
R.append((c, p1, p2))
c = C[i][0] - C[i-1][0]
p1 = C[i][2]
p2 = C[i-1][2]
R.append((c, p1, p2))
R.sort()
#Union Find:
U = [i for i in range(N)]
r = [0 for _ in range(N)]
#print(U)
ans = 0
for road in R:
c = road[0]
x = road[1]
y = road[2]
if merge(x, y, U, r):
#print(U)
ans += c
#print(U)
print(ans)
|
p03682
|
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納 par[x] == x の時そのノードは根
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0)
self.rank = [0] * (n+1)
# 各々の集合の要素数（根が代表して値を持っておく）
self.count = [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)
t = (x == y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.count[y] += self.count[x]
self.count[x] = 0
else:
self.par[y] = x
self.count[x] += self.count[y]
self.count[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
return t
# 同じ集合に属しているか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
# 属している集合の要素数
def size(self,x):
q = UnionFind.find(self,x)
return self.count[q]
n = int(eval(input()))
data = [list(map(int,input().split()))+[i] for i in range(n)]
data.sort()
edge = []
append = edge.append
for i in range(1,n):
append([data[i][0]-data[i-1][0],data[i][2],data[i-1][2]])
data.sort(key=lambda x:x[1])
for i in range(1,n):
append([data[i][1]-data[i-1][1],data[i][2],data[i-1][2]])
edge.sort()
uf = UnionFind(n)
ans = 0
for x,y,z in edge:
if not uf.same_check(y,z):
uf.union(y,z)
ans += x
print(ans)
|
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納 par[x] == x の時そのノードは根
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0)
self.rank = [0] * (n+1)
# 各々の集合の要素数（根が代表して値を持っておく）
self.count = [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)
t = (x == y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.count[y] += self.count[x]
self.count[x] = 0
else:
self.par[y] = x
self.count[x] += self.count[y]
self.count[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
return t
# 同じ集合に属しているか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
# 属している集合の要素数
def size(self,x):
q = UnionFind.find(self,x)
return self.count[q]
import sys
input = sys.stdin.readline
n = int(eval(input()))
data = [list(map(int,input().split()))+[i] for i in range(n)]
data.sort()
edge = []
append = edge.append
for i in range(1,n):
append([data[i][0]-data[i-1][0],data[i][2],data[i-1][2]])
data.sort(key=lambda x:x[1])
for i in range(1,n):
append([data[i][1]-data[i-1][1],data[i][2],data[i-1][2]])
edge.sort()
uf = UnionFind(n)
ans = 0
for x,y,z in edge:
if not uf.same_check(y,z):
uf.union(y,z)
ans += x
print(ans)
|
p03682
|
from operator import itemgetter
import array
import collections
class UnionFind():
def __init__(self,n):
self.parent = [-1 for _ in range(n)]
def size(self,x):
return -self.parent[self.find(x)]
def find(self,x):
if(self.parent[x]<0):
return x
else:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def unite(self,x,y):
x = self.find(x)
y = self.find(y)
if(x == y):
return False
if(self.size(x)<self.size(y)):
self.parent[y]+=self.parent[x]
self.parent[x]=y
else:
self.parent[x]+=self.parent[y]
self.parent[y]=x
return True
def same(self,x,y):
return self.find(x)==self.find(y)
def compute_mst_kruskal(max_v, edges):
edges.sort(key=lambda edge: edge.weight)
uf = UnionFind(max_v)
weight = 0
for edge in edges:
if not uf.same(edge.start, edge.end):
uf.unite(edge.start, edge.end)
weight+=edge.weight
return weight
def main():
Edge = collections.namedtuple('Edge',('start','end','weight'))
N = int(eval(input()))
xli = []
yli = []
x_app = xli.append
y_app = yli.append
for i in range(N):
x,y = (int(x) for x in input().split())
x_app([x-1,i])
y_app([y-1,i])
xli.sort()
yli.sort()
edges = []
edges_app = edges.append
for i in range(N-1):
edges_app(Edge(xli[i][1],xli[i+1][1],xli[i+1][0]-xli[i][0]))
edges_app(Edge(yli[i][1],yli[i+1][1],yli[i+1][0]-yli[i][0]))
ans = compute_mst_kruskal(N,edges)
print(ans)
if __name__ == '__main__':
main()
|
from operator import itemgetter
import array
class UnionFind():
def __init__(self,n):
self.parent = [-1 for _ in range(n)]
def size(self,x):
return -self.parent[self.find(x)]
def find(self,x):
if(self.parent[x]<0):
return x
else:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def unite(self,x,y):
x = self.find(x)
y = self.find(y)
if(x == y):
return False
if(self.size(x)<self.size(y)):
self.parent[y]+=self.parent[x]
self.parent[x]=y
else:
self.parent[x]+=self.parent[y]
self.parent[y]=x
return True
def same(self,x,y):
return self.find(x)==self.find(y)
def compute_mst_kruskal(max_v, edges):
edges.sort(key=lambda edge: edge[2])
uf = UnionFind(max_v)
weight = 0
for edge in edges:
if not uf.same(edge[0], edge[1]):
uf.unite(edge[0], edge[1])
weight+=edge[2]
return weight
def main():
N = int(eval(input()))
xli = []
yli = []
x_app = xli.append
y_app = yli.append
for i in range(N):
x,y = (int(x) for x in input().split())
x_app([x-1,i])
y_app([y-1,i])
xli.sort()
yli.sort()
edges = []
edges_app = edges.append
for i in range(N-1):
edges_app((xli[i][1],xli[i+1][1],xli[i+1][0]-xli[i][0]))
edges_app((yli[i][1],yli[i+1][1],yli[i+1][0]-yli[i][0]))
print((compute_mst_kruskal(N,edges)))
if __name__ == '__main__':
main()
|
p03682
|
from operator import itemgetter
import array
class UnionFind():
def __init__(self,n):
self.parent = [-1 for _ in range(n)]
def size(self,x):
return -self.parent[self.find(x)]
def find(self,x):
if(self.parent[x]<0):
return x
else:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def unite(self,x,y):
x = self.find(x)
y = self.find(y)
if(x == y):
return False
if(self.size(x)<self.size(y)):
self.parent[y]+=self.parent[x]
self.parent[x]=y
else:
self.parent[x]+=self.parent[y]
self.parent[y]=x
return True
def same(self,x,y):
return self.find(x)==self.find(y)
def compute_mst_kruskal(max_v, edges):
edges.sort(key=lambda edge: edge[2])
uf = UnionFind(max_v)
weight = 0
for edge in edges:
if not uf.same(edge[0], edge[1]):
uf.unite(edge[0], edge[1])
weight+=edge[2]
return weight
def main():
N = int(eval(input()))
xli = []
yli = []
x_app = xli.append
y_app = yli.append
for i in range(N):
x,y = (int(x) for x in input().split())
x_app([x-1,i])
y_app([y-1,i])
xli.sort()
yli.sort()
edges = []
edges_app = edges.append
for i in range(N-1):
edges_app((xli[i][1],xli[i+1][1],xli[i+1][0]-xli[i][0]))
edges_app((yli[i][1],yli[i+1][1],yli[i+1][0]-yli[i][0]))
print((compute_mst_kruskal(N,edges)))
if __name__ == '__main__':
main()
|
import array
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self,n):
self.parent = [-1 for _ in range(n)]
def size(self,x):
return -self.parent[self.find(x)]
def find(self,x):
if(self.parent[x]<0):
return x
else:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def unite(self,x,y):
x = self.find(x)
y = self.find(y)
if(x == y):
return False
if(self.size(x)<self.size(y)):
self.parent[y]+=self.parent[x]
self.parent[x]=y
else:
self.parent[x]+=self.parent[y]
self.parent[y]=x
return True
def same(self,x,y):
return self.find(x)==self.find(y)
def main():
N = int(eval(input()))
xli = []
yli = []
x_app = xli.append
y_app = yli.append
for i in range(N):
x,y = (int(x) for x in input().split())
x_app([x-1,i])
y_app([y-1,i])
xli.sort()
yli.sort()
edges = []
edges_app = edges.append
for i in range(N-1):
edges_app((xli[i][1],xli[i+1][1],xli[i+1][0]-xli[i][0]))
edges_app((yli[i][1],yli[i+1][1],yli[i+1][0]-yli[i][0]))
edges.sort(key=lambda edge: edge[2])
uf = UnionFind(N)
weight = 0
for edge in edges:
if not uf.same(edge[0], edge[1]):
uf.unite(edge[0], edge[1])
weight+=edge[2]
print(weight)
if __name__ == '__main__':
main()
|
p03682
|
def find(x):
if(par[x]==x):
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
a=find(a)
b=find(b)
if(a==b):
return 0
else:
if rank[a]>rank[b]:
par[b]=a
else:
par[a]=b
if rank[a]==rank[b]:
rank[b]+=1
def same(a,b):
return find(a)==find(b)
def Kruskal(Edge,E):
cost=0
Edge.sort(key=lambda x:x[2])
for i in range(E):
f,t,c=Edge[i]
if(not same(f,t)):
union(f,t)
cost+=c
return cost
N=int(eval(input()))
par=[i for i in range(N)]
rank=[0 for _ in range(N)]
p=[tuple(map(int,input().split())) for i in range(N)]
dic={p[i]:i for i in range(N)}
xp=sorted(p,key=lambda x:x[0])
yp=sorted(p,key=lambda x:x[1])
Edge=[]
for i in range(N):
if(i>0):
Edge.append((dic[xp[i]],dic[xp[i-1]],abs(xp[i][0]-xp[i-1][0])))
if(i<N-1):
Edge.append((dic[xp[i]],dic[xp[i+1]],abs(xp[i][0]-xp[i+1][0])))
for i in range(N):
if(i>0):
Edge.append((dic[yp[i]],dic[yp[i-1]],abs(yp[i][1]-yp[i-1][1])))
if(i<N-1):
Edge.append((dic[yp[i]],dic[yp[i+1]],abs(yp[i][1]-yp[i+1][1])))
Edge.sort(key=lambda x:x[2])
print((Kruskal(Edge,len(Edge))))
|
import sys
read=sys.stdin.readline
def find(x):
if(par[x]==x):
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
a=find(a)
b=find(b)
if(a==b):
return 0
else:
if rank[a]>rank[b]:
par[b]=a
else:
par[a]=b
if rank[a]==rank[b]:
rank[b]+=1
def same(a,b):
return find(a)==find(b)
def Kruskal(Edge,E):
cost=0
Edge.sort(key=lambda x:x[2])
for i in range(E):
f,t,c=Edge[i]
if(not same(f,t)):
union(f,t)
cost+=c
return cost
N=int(eval(input()))
par=[];p=[];dic={};rank=[]
for i in range(N):
par.append(i)
rank.append(0)
p.append(tuple(map(int,read().split())))
dic[p[i]]=i
xp=sorted(p,key=lambda x:x[0])
yp=sorted(p,key=lambda x:x[1])
Edge=[]
for i in range(N):
if(i>0):
Edge.append((dic[xp[i]],dic[xp[i-1]],abs(xp[i][0]-xp[i-1][0])))
if(i<N-1):
Edge.append((dic[xp[i]],dic[xp[i+1]],abs(xp[i][0]-xp[i+1][0])))
if(i>0):
Edge.append((dic[yp[i]],dic[yp[i-1]],abs(yp[i][1]-yp[i-1][1])))
if(i<N-1):
Edge.append((dic[yp[i]],dic[yp[i+1]],abs(yp[i][1]-yp[i+1][1])))
print((Kruskal(Edge,len(Edge))))
|
p03682
|
import heapq
def prim_heap():
used = [True]*n #True:不使用
edgelist = []
for e in edge[0]: #連結なのでedge[0]は必ず存在する
heapq.heappush(edgelist,e)
used[0] = False #番号0の頂点を始点とする
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
#########################
n = int(eval(input()))
L = []
for i in range(n):
a,b = list(map(int,input().split()))
L.append([i,a,b])
L = sorted(L, key = lambda x:x[1])
edge = [[] for i in range(n)] # edge[i]:[コスト,行先]
for i in range(n):
if i == 0:
edge[L[0][0]].append([min(abs(L[0][1]-L[1][1]),abs(L[0][2]-L[1][2])),L[1][0]])
edge[L[1][0]].append([min(abs(L[0][1]-L[1][1]),abs(L[0][2]-L[1][2])),L[0][0]])
elif i == n-1:
edge[L[n-1][0]].append([min(abs(L[n-1][1]-L[n-2][1]),abs(L[n-1][2]-L[n-2][2])),L[n-2][0]])
edge[L[n-2][0]].append([min(abs(L[n-1][1]-L[n-2][1]),abs(L[n-1][2]-L[n-2][2])),L[n-1][0]])
else:
edge[L[i][0]].append([min(abs(L[i][1]-L[i-1][1]),abs(L[i][2]-L[i-1][2])),L[i-1][0]])
edge[L[i-1][0]].append([min(abs(L[i][1]-L[i-1][1]),abs(L[i][2]-L[i-1][2])),L[i][0]])
edge[L[i][0]].append([min(abs(L[i][1]-L[i+1][1]),abs(L[i][2]-L[i+1][2])),L[i+1][0]])
edge[L[i+1][0]].append([min(abs(L[i][1]-L[i+1][1]),abs(L[i][2]-L[i+1][2])),L[i][0]])
L = sorted(L, key = lambda x:x[2])
for i in range(n):
if i == 0:
edge[L[0][0]].append([min(abs(L[0][1]-L[1][1]),abs(L[0][2]-L[1][2])),L[1][0]])
edge[L[1][0]].append([min(abs(L[0][1]-L[1][1]),abs(L[0][2]-L[1][2])),L[0][0]])
elif i == n-1:
edge[L[n-1][0]].append([min(abs(L[n-1][1]-L[n-2][1]),abs(L[n-1][2]-L[n-2][2])),L[n-2][0]])
edge[L[n-2][0]].append([min(abs(L[n-1][1]-L[n-2][1]),abs(L[n-1][2]-L[n-2][2])),L[n-1][0]])
else:
edge[L[i][0]].append([min(abs(L[i][1]-L[i-1][1]),abs(L[i][2]-L[i-1][2])),L[i-1][0]])
edge[L[i-1][0]].append([min(abs(L[i][1]-L[i-1][1]),abs(L[i][2]-L[i-1][2])),L[i][0]])
edge[L[i][0]].append([min(abs(L[i][1]-L[i+1][1]),abs(L[i][2]-L[i+1][2])),L[i+1][0]])
edge[L[i+1][0]].append([min(abs(L[i][1]-L[i+1][1]),abs(L[i][2]-L[i+1][2])),L[i][0]])
print((prim_heap()))
|
n = int(eval(input()))
L = []
ans = 0
for i in range(n):
a,b = list(map(int,input().split()))
L.append([a,b,i])
P = []
L.sort()
for i in range(n-1):
dist = min(abs(L[i][0]-L[i+1][0]),abs(L[i][1]-L[i+1][1]))
P.append([dist,L[i][2],L[i+1][2]])
L = sorted(L, key = lambda x:x[1])
for i in range(n-1):
dist = min(abs(L[i][0]-L[i+1][0]),abs(L[i][1]-L[i+1][1]))
P.append([dist,L[i][2],L[i+1][2]])
P.sort()
par = [i for i in range(n)]
rank = [0]*n
def find(x,par):
if x == par[x]:
return par[x]
else:
return find(par[x],par)
def unite(x,y,par,rank):
x = find(x,par)
y = find(y,par)
if x != y:
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
for i in range(len(P)):
if find(P[i][1],par) != find(P[i][2],par):
ans += P[i][0]
unite(P[i][1],P[i][2],par,rank)
print(ans)
|
p03682
|
class UnionFind():
def __init__(self,n):
self.n=n
self.parents = [i for i in range(n+1)]
self.size = [1]*(n+1)
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 unite(self,x,y):
xRoot = self.find(x)
yRoot = self.find(y)
if xRoot == yRoot:
return
if self.size[xRoot]>self.size[yRoot]:
self.parents[yRoot] = xRoot
else:
self.parents[xRoot] = yRoot
if self.size[xRoot] == self.size[yRoot]:
self.size[yRoot]+=1
N = int(eval(input()))
nodesX = []
nodesY = []
for i in range(1,N+1):
x,y = list(map(int,input().split()))
nodesX.append((x,i))
nodesY.append((y,i))
nodesX.sort()
nodesY.sort()
edges = []
for i in range(1,N):
edges.append((nodesX[i][0]-nodesX[i-1][0],nodesX[i][1],nodesX[i-1][1]))
edges.append((nodesY[i][0]-nodesY[i-1][0],nodesY[i][1],nodesY[i-1][1]))
edges.sort()
tree = UnionFind(N)
cost = 0
for w,s,t in edges:
if tree.find(s)!= tree.find(t):
tree.unite(s,t)
cost += w
print(cost)
|
def main():
import sys
sys.setrecursionlimit(2000000)
input = sys.stdin.readline
class UnionFind():
def __init__(self,n):
self.n=n
self.parents = [i for i in range(n+1)]
self.size = [1]*(n+1)
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 unite(self,x,y):
xRoot = self.find(x)
yRoot = self.find(y)
if xRoot == yRoot:
return
if self.size[xRoot]>self.size[yRoot]:
self.parents[yRoot] = xRoot
else:
self.parents[xRoot] = yRoot
if self.size[xRoot] == self.size[yRoot]:
self.size[yRoot]+=1
N = int(eval(input()))
nodesX = []
nodesY = []
for i in range(1,N+1):
x,y = list(map(int,input().split()))
nodesX.append((x,i))
nodesY.append((y,i))
nodesX.sort()
nodesY.sort()
edges = []
for i in range(1,N):
edges.append((nodesX[i][0]-nodesX[i-1][0],nodesX[i][1],nodesX[i-1][1]))
edges.append((nodesY[i][0]-nodesY[i-1][0],nodesY[i][1],nodesY[i-1][1]))
edges.sort()
tree = UnionFind(N)
cost = 0
for w,s,t in edges:
if tree.find(s)!= tree.find(t):
tree.unite(s,t)
cost += w
print(cost)
main()
|
p03682
|
class UnionFind():
def __init__(self,n):
self.n=n
self.parents = [i for i in range(n+1)]
self.size = [1]*(n+1)
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 unite(self,x,y):
xRoot = self.find(x)
yRoot = self.find(y)
if xRoot == yRoot:
return
if self.size[xRoot]>self.size[yRoot]:
self.parents[yRoot] = xRoot
else:
self.parents[xRoot] = yRoot
if self.size[xRoot] == self.size[yRoot]:
self.size[yRoot]+=1
N = int(eval(input()))
tree = UnionFind(N)
nodes = []
for i in range(1,N+1):
x,y = list(map(int,input().split()))
nodes.append((i,x,y))
edges = []
nodes.sort(key=lambda x: x[1])
for i in range(1,N):
edges.append((nodes[i][1]-nodes[i-1][1],nodes[i][0],nodes[i-1][0]))
nodes.sort(key=lambda x: x[2])
for i in range(1,N):
edges.append((nodes[i][2]-nodes[i-1][2],nodes[i][0],nodes[i-1][0]))
edges.sort()
cost = 0
for w,s,t in edges:
if tree.find(s)!=tree.find(t):
tree.unite(s,t)
cost += w
print(cost)
|
class UnionFind():
def __init__(self,n):
self.n=n
self.parents = [i for i in range(n+1)]
self.size = [1]*(n+1)
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 unite(self,x,y):
xRoot = self.find(x)
yRoot = self.find(y)
if xRoot == yRoot:
return
if self.size[xRoot]>self.size[yRoot]:
self.parents[yRoot] = xRoot
else:
self.parents[xRoot] = yRoot
if self.size[xRoot] == self.size[yRoot]:
self.size[yRoot]+=1
N = int(eval(input()))
edges = []
nodes = []
for i in range(N):
x,y = list(map(int,input().split()))
nodes.append((i,x,y))
nodes.sort(key=lambda x: x[1])
for i in range(1,N):
w = nodes[i][1]-nodes[i-1][1]
edges.append((w,nodes[i][0],nodes[i-1][0]))
nodes.sort(key=lambda x: x[2])
for i in range(1,N):
w = nodes[i][2] - nodes[i-1][2]
edges.append((w,nodes[i][0],nodes[i-1][0]))
edges.sort()
tree = UnionFind(N)
cost = 0
for w,a,b in edges:
if tree.find(a) != tree.find(b):
tree.unite(a,b)
cost += w
print(cost)
|
p03682
|
class UnionFind():
def __init__(self,n):
self.n=n
self.parents = [i for i in range(n+1)]
self.size = [1]*(n+1)
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 unite(self,x,y):
xRoot = self.find(x)
yRoot = self.find(y)
if xRoot == yRoot:
return
if self.size[xRoot]>self.size[yRoot]:
self.parents[yRoot] = xRoot
else:
self.parents[xRoot] = yRoot
if self.size[xRoot] == self.size[yRoot]:
self.size[yRoot]+=1
N = int(eval(input()))
edges = []
nodes = []
for i in range(N):
x,y = list(map(int,input().split()))
nodes.append((i,x,y))
nodes.sort(key=lambda x: x[1])
for i in range(1,N):
w = nodes[i][1]-nodes[i-1][1]
edges.append((w,nodes[i][0],nodes[i-1][0]))
nodes.sort(key=lambda x: x[2])
for i in range(1,N):
w = nodes[i][2] - nodes[i-1][2]
edges.append((w,nodes[i][0],nodes[i-1][0]))
edges.sort()
tree = UnionFind(N)
cost = 0
for w,a,b in edges:
if tree.find(a) != tree.find(b):
tree.unite(a,b)
cost += w
print(cost)
|
class UnionFind():
def __init__(self,n):
self.n=n
self.parents = [i for i in range(n+1)]
self.size = [1]*(n+1)
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 unite(self,x,y):
xRoot = self.find(x)
yRoot = self.find(y)
if xRoot == yRoot:
return
if self.size[xRoot]>self.size[yRoot]:
self.parents[yRoot] = xRoot
self.size[xRoot] += self.size[yRoot]
self.size[yRoot] = 0
else:
self.parents[xRoot] = yRoot
self.size[yRoot] += self.size[xRoot]
self.size[xRoot] = 0
N = int(eval(input()))
XY = [[i]+list(map(int,input().split())) for i in range(N)]
edges = []
XY.sort(key=lambda x: x[1])
for j in range(1,N):
edges.append((XY[j-1][0],XY[j][0],XY[j][1]-XY[j-1][1]))
XY.sort(key=lambda x: x[2])
for j in range(1,N):
edges.append((XY[j-1][0],XY[j][0],XY[j][2]-XY[j-1][2]))
cost = 0
edges.sort(key=lambda x: x[2])
tree = UnionFind(N)
for i,j,c in edges:
if tree.find(i)!=tree.find(j):
tree.unite(i,j)
cost += c
print(cost)
|
p03682
|
from collections import Counter,defaultdict,deque
import sys
import bisect
import math
import itertools
import string
import queue
import copy
# import numpy as np
# import scipy
from itertools import permutations, combinations
from heapq import heappop, heappush
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): # n=1
return int(eval(input()))
def inpm(): # x=1,y=2
return list(map(int,input().split()))
def inpl(): # a=[1,2,3,4,5,...,n]
return list(map(int, input().split()))
def inpls(): # a=['1','2','3',...,'n']
return list(input().split())
def inplm(n): # x=[] 複数行
return list(int(eval(input())) for _ in range(n))
def inpll(n): # [[1,1,1,1],[2,2,2,2],[3,3,3,3]]
return sorted([list(map(int, input().split())) for _ in range(n)])
def sortx(x,n,k):
if k == 0:x.sort(key=lambda y:y[1,n])
else:x.sort(reversed=True, key=lambda y:y[1,n])
def graphm():
n,m=inpm()
g=[[] for _ in range(n)]
for _ in range(m):
a,b,w=inpm()
a-=1
b-=1
g[a].append((w,b))
g[b].append((w,a))
return n,m,g
def prim(n,g):
edgelist = []
used = [False for _ in range(n)]
for edge in g[0]:
heappush( edgelist, edge)
used[0] = True
res = 0
while len(edgelist)>0:
minedge = heappop(edgelist)
if used[minedge[1]]:
continue
v = minedge[1]
used[v] = True
for edge in g[v]:
if not used[edge[1]]:
heappush( edgelist, edge)
res += minedge[0]
return res
def main():
n=inp()
xy=[]
for _ in range(n):
x,y = inpm()
xy.append((x,y))
g=[[] for _ in range(n)]
for i in range(n-1):
for j in range(i+1,n):
w = min(abs(xy[i][0]-xy[j][0]),abs(xy[i][1]-xy[j][1]))
g[i].append((w,j))
g[j].append((w,i))
print(( prim(n,g) ))
if __name__ == "__main__":
main()
|
from collections import Counter,defaultdict,deque
import sys
import bisect
import math
import itertools
import string
import queue
import copy
# import numpy as np
# import scipy
from itertools import permutations, combinations
from heapq import heappop, heappush
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): # n=1
return int(eval(input()))
def inpm(): # x=1,y=2
return list(map(int,input().split()))
def inpl(): # a=[1,2,3,4,5,...,n]
return list(map(int, input().split()))
def inpls(): # a=['1','2','3',...,'n']
return list(input().split())
def inplm(n): # x=[] 複数行
return list(int(eval(input())) for _ in range(n))
def inpll(n): # [[1,1,1,1],[2,2,2,2],[3,3,3,3]]
return sorted([list(map(int, input().split())) for _ in range(n)])
def sortx(x,n,k):
if k == 0:x.sort(key=lambda y:y[1,n])
else:x.sort(reversed=True, key=lambda y:y[1,n])
def graphm():
n,m=inpm()
g=[[] for _ in range(n)]
for _ in range(m):
a,b,w=inpm()
a-=1
b-=1
g[a].append((w,b))
g[b].append((w,a))
return n,m,g
def prim(n,g):
edgelist = []
used = [False for _ in range(n)]
for edge in g[0]:
heappush( edgelist, edge)
used[0] = True
res = 0
while len(edgelist)>0:
minedge = heappop(edgelist)
if used[minedge[1]]:
continue
v = minedge[1]
used[v] = True
for edge in g[v]:
if not used[edge[1]]:
heappush( edgelist, edge)
res += minedge[0]
return res
def main():
n=inp()
xy=[]
for index in range(n):
x,y = inpm()
xy.append((x,y,index))
g=[[] for _ in range(n)]
xy.sort()
for i in range(n-1):
j = i+1
w = min(abs(xy[i][0]-xy[j][0]),abs(xy[i][1]-xy[j][1]))
a = xy[i][2]
b = xy[j][2]
g[a].append((w,b))
g[b].append((w,a))
xy.sort(key=lambda y:y[1])
for i in range(n-1):
j = i+1
w = min(abs(xy[i][0]-xy[j][0]),abs(xy[i][1]-xy[j][1]))
a = xy[i][2]
b = xy[j][2]
g[a].append((w,b))
g[b].append((w,a))
print(( prim(n,g) ))
if __name__ == "__main__":
main()
|
p03682
|
import heapq
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
def solve():
n = int(eval(input()))
query = []
xquery = []
yquery = []
for i in range(n):
x,y = (int(i) for i in input().split())
xquery.append((x,y,i))
yquery.append((y,x,i))
xquery = sorted(xquery)
yquery = sorted(yquery)
for i in range(n-1):
tx,ty,place = xquery[i]
tx2,ty2,place2 = xquery[i+1]
cost = min(abs(tx2-tx),abs(ty2-ty))
heapq.heappush(query,(cost,place,place2))
ty,tx,place = yquery[i]
ty2,tx2,place2 = yquery[i+1]
cost = min(abs(tx2-tx),abs(ty2-ty))
heapq.heappush(query,(cost,place,place2))
ct = 0
uf = UnionFind(n)
while len(query) > 0:
cost,place1,place2 = heapq.heappop(query)
if uf.same_check(place1,place2):
continue
else:
uf.union(int(place1),int(place2))
ct += cost
print(ct)
solve()
|
#https://atcoder.jp/contests/abc065/submissions/5881131
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
def MST(n, E):
E = sorted(E, key=lambda x: x[2])
uf = UnionFind(n)
ct = 0
for i,j,cost in E:
if uf.same_check(i,j):
continue
else:
uf.union(i,j)
ct += cost
return ct
def solve():
N = int(eval(input()))
X = []
append=X.append
for i in range(N):
x, y = list(map(int, input().split()))
append((i, x, y))
F = []
append = F.append
Y = sorted(X, key = lambda x: x[1])
for i in range(len(Y)-1):
append((Y[i][0], Y[i+1][0], abs(Y[i+1][1]-Y[i][1])))
Y = sorted(X, key = lambda x: x[2])
for i in range(len(Y)-1):
append((Y[i][0], Y[i+1][0], abs(Y[i+1][2]-Y[i][2])))
print((MST(N, F)))
solve()
|
p03682
|
class UnionFind():
def __init__(self,n):
self.n=n
self.par=[i for i in range(n)]
self.size=[1]*n
def find(self,x):
if x==self.par[x]:
return self.par[x]
else:
self.par[x]=self.find(self.par[x])
return self.par[x]
def unite(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.size[x]>self.size[y]:
self.size[x]+=self.size[y]
self.par[y]=x
else:
self.size[y]+=self.size[x]
self.par[x]=y
n=int(eval(input()))
x_list=[]
y_list=[]
for i in range(n):
x,y=list(map(int,input().split()))
x_list.append((x,i))
y_list.append((y,i))
x_list.sort()
y_list.sort()
edges=[]
for i in range(1,n):
edges.append((x_list[i][0]-x_list[i-1][0],x_list[i][1],x_list[i-1][1]))
edges.append((y_list[i][0]-y_list[i-1][0],y_list[i][1],y_list[i-1][1]))
edges.sort()
uf=UnionFind(n)
ans=0
for e in edges:
wt=e[0]
x=e[1]
y=e[2]
if uf.find(x)==uf.find(y):
continue
ans+=wt
uf.unite(x,y)
print(ans)
|
class UnionFind():
def __init__(self,n):
self.n=n
self.par=[i for i in range(n)]
self.size=[1]*n
def find(self,x):
if x==self.par[x]:
return self.par[x]
else:
self.par[x]=self.find(self.par[x])
return self.par[x]
def unite(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.size[x]>self.size[y]:
self.size[x]+=self.size[y]
self.par[y]=x
else:
self.size[y]+=self.size[x]
self.par[x]=y
import sys
input=sys.stdin.buffer.readline
n=int(eval(input()))
x_list=[]
y_list=[]
for i in range(n):
x,y=list(map(int,input().split()))
x_list.append((x,i))
y_list.append((y,i))
x_list.sort()
y_list.sort()
edges=[]
for i in range(1,n):
edges.append((x_list[i][0]-x_list[i-1][0],x_list[i][1],x_list[i-1][1]))
edges.append((y_list[i][0]-y_list[i-1][0],y_list[i][1],y_list[i-1][1]))
edges.sort()
uf=UnionFind(n)
ans=0
for e in edges:
wt=e[0]
x=e[1]
y=e[2]
if uf.find(x)==uf.find(y):
continue
ans+=wt
uf.unite(x,y)
print(ans)
|
p03682
|
from sys import stdin, setrecursionlimit
from operator import itemgetter
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
class UnionFind:
# Reference: https://note.nkmk.me/python-union-find/
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
P = [0] * N
for i in range(N):
x, y = list(map(int, input().split()))
P[i] = (i, x, y)
edges = []
for i in (1, 2):
P.sort(key=itemgetter(i))
for j in range(N - 1):
edges.append((P[j][0], P[j + 1][0], P[j + 1][i] - P[j][i]))
edges.sort(key=itemgetter(2))
uf = UnionFind(N)
ans = 0
cities = 1
for i, j, c in edges:
if not uf.same(i, j):
uf.union(i, j)
ans += c
cities += 1
if cities == N:
break
print(ans)
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
class UnionFind:
# Reference: https://note.nkmk.me/python-union-find/
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def main():
N, *XY = list(map(int, read().split()))
X = list(zip(XY[::2], list(range(N))))
Y = list(zip(XY[1::2], list(range(N))))
X.sort()
Y.sort()
edge = []
for i in range(N - 1):
edge.append((X[i + 1][0] - X[i][0], X[i][1], X[i + 1][1]))
edge.append((Y[i + 1][0] - Y[i][0], Y[i][1], Y[i + 1][1]))
edge.sort()
uf = UnionFind(N)
ans = 0
for d, s, t in edge:
if not uf.same(s, t):
uf.union(s, t)
ans += d
print(ans)
return
if __name__ == '__main__':
main()
|
p03682
|
import sys
input = sys.stdin.readline
n=int(eval(input()))
Edge=[[] for i in range(n)]
XY=[]
append=XY.append
for i in range(n):
x,y=list(map(int,input().split()))
append([i,x,y])
XY.sort(key=lambda x:x[1])
for i in range(1,n):
n1,x1,y1=XY[i-1][0],XY[i-1][1],XY[i-1][2]
n2,x2,y2=XY[i][0],XY[i][1],XY[i][2]
Edge[n1].append([min(abs(x2-x1),abs(y2-y1)),n2])
Edge[n2].append([min(abs(x2-x1),abs(y2-y1)),n1])
XY.sort(key=lambda x:x[2])
for i in range(1,n):
n1,x1,y1=XY[i-1][0],XY[i-1][1],XY[i-1][2]
n2,x2,y2=XY[i][0],XY[i][1],XY[i][2]
Edge[n1].append([min(abs(x2-x1),abs(y2-y1)),n2])
Edge[n2].append([min(abs(x2-x1),abs(y2-y1)),n1])
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
print((prim_heap()))
|
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
def MST(n, E):
def par(m):
if UF[m] == m:
return m
ret = par(UF[m])
UF[m] = ret
return ret
UF = [i for i in range(n)]
E = sorted(E, key=lambda x: x[2])
ans = 0
for i, j, d in E:
if par(i) != par(j):
ans += d
UF[par(i)] = par(j)
return ans
N = int(eval(input()))
X = []
append=X.append
for i in range(N):
x, y = list(map(int, input().split()))
append((i, x, y))
F = []
Y = sorted(X, key = lambda x: x[1])
for i in range(len(Y)-1):
F.append((Y[i][0], Y[i+1][0], abs(Y[i+1][1]-Y[i][1])))
Y = sorted(X, key = lambda x: x[2])
for i in range(len(Y)-1):
F.append((Y[i][0], Y[i+1][0], abs(Y[i+1][2]-Y[i][2])))
print((MST(N, F)))
|
p03682
|
# ユニオンファインド
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()))
a= [list(map(int, input().split())) for i in range(n)]
b=[]
a.sort()
# aの各点に通し番号を振る
for i in range(n):
a[i].append(i)
# 繋ぐ点の候補は上下左右の４つ
# 左右に繋ぐ辺を追加
for i in range(n):
if i==0:
b.append([a[i][2],a[i+1][2], a[i+1][0]-a[i][0]])
elif i==n-1:
b.append([a[i][2],a[i-1][2], a[i][0]-a[i-1][0]])
else:
b.append([a[i][2],a[i-1][2], a[i][0]-a[i-1][0]])
b.append([a[i][2], a[i + 1][2], a[i + 1][0] - a[i][0]])
a.sort(key=lambda x:x[1])
# 上下に繋ぐ辺を追加
for i in range(n):
if i==0:
b.append([a[i][2],a[i+1][2], a[i+1][1]-a[i][1]])
elif i==n-1:
b.append([a[i][2],a[i-1][2], a[i][1]-a[i-1][1]])
else:
b.append([a[i][2],a[i-1][2], a[i][1]-a[i-1][1]])
b.append([a[i][2], a[i + 1][2], a[i + 1][1] - a[i][1]])
b.sort(key=lambda x:x[2])
uf=UnionFind(n)
ans=0
cnt=0
# クラスカル法
for x,y,z in b:
if not uf.same(x,y):
uf.union(x,y)
cnt+=1
ans+=z
if cnt==n-1:
break
print(ans)
|
# ユニオンファインド
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n=int(eval(input()))
a= [list(map(int, input().split())) for i in range(n)]
b=[]
a.sort()
# aの各点に通し番号を振る
for i in range(n):
a[i].append(i)
# 繋ぐ点の候補は上下左右の４つ
# 左右に繋ぐ辺を追加
for i in range(n-1):
b.append([a[i][2], a[i + 1][2], a[i + 1][0] - a[i][0]])
a.sort(key=lambda x:x[1])
# 上下に繋ぐ辺を追加
for i in range(n-1):
b.append([a[i][2], a[i + 1][2], a[i + 1][1] - a[i][1]])
b.sort(key=lambda x:x[2])
uf=UnionFind(n)
ans=0
cnt=0
# クラスカル法
for x,y,z in b:
if not uf.same(x,y):
uf.union(x,y)
cnt+=1
ans+=z
if cnt==n-1:
break
print(ans)
|
p03682
|
# ユニオンファインド
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()))
a= [list(map(int, input().split())) for i in range(n)]
b=[]
a.sort()
# aの各点に通し番号を振る
for i in range(n):
a[i].append(i)
# 繋ぐ点の候補は上下左右の４つ
# 左右に繋ぐ辺を追加
for i in range(n-1):
b.append([a[i][2], a[i + 1][2], a[i + 1][0] - a[i][0]])
a.sort(key=lambda x:x[1])
# 上下に繋ぐ辺を追加
for i in range(n-1):
b.append([a[i][2], a[i + 1][2], a[i + 1][1] - a[i][1]])
b.sort(key=lambda x:x[2])
uf=UnionFind(n)
ans=0
cnt=0
# クラスカル法
for x,y,z in b:
if not uf.same(x,y):
uf.union(x,y)
cnt+=1
ans+=z
if cnt==n-1:
break
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 same(self, x, y):
return self.find(x) == self.find(y)
n=int(eval(input()))
a= [list(map(int, input().split())) for i in range(n)]
b=[]
a.sort()
# aの各点に通し番号を振る
for i in range(n):
a[i].append(i)
# 繋ぐ点の候補は上下左右の４つ
# 左右に繋ぐ辺を追加
for i in range(n-1):
b.append([a[i][2], a[i + 1][2], a[i + 1][0] - a[i][0]])
a.sort(key=lambda x:x[1])
# 上下に繋ぐ辺を追加
for i in range(n-1):
b.append([a[i][2], a[i + 1][2], a[i + 1][1] - a[i][1]])
b.sort(key=lambda x:x[2])
uf=UnionFind(n)
ans=0
cnt=0
# クラスカル法
for x,y,z in b:
if not uf.same(x,y):
uf.union(x,y)
cnt+=1
ans+=z
if cnt==n-1:
break
print(ans)
|
p03682
|
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
import math
while True:
lst = []
S = input()
if S == '.':
break
lst.append(S)
while True:
S = input()
if S == '.':
break
lst.append(S)
upper = []
flag = False
for i in range(len(lst)):
S = lst[i]
if '=' in S:
try:
exec(S)
except:
flag = True
for elem in upper:
for key in elem[0]:
if key >= elem[1]:
flag = True
break
if flag:
print(i + 1)
break
else:
P = S.split('[')
name = P[0]
num = int(P[1][:-1])
exec(name + ' = {}')
upper.append((globals()[name], num))
if not flag:
print(0)
|
while True:
lst = []
S = input()
if S == '.':
break
lst.append(S)
while True:
S = input()
if S == '.':
break
lst.append(S)
upper = []
flag = False
for i in range(len(lst)):
S = lst[i]
if '=' in S:
try:
exec(S)
except:
flag = True
for elem in upper:
for key in elem[0]:
if key >= elem[1]:
flag = True
break
if flag:
print(i + 1)
break
else:
P = S.split('[')
name = P[0]
num = int(P[1][:-1])
exec(name + ' = {}')
upper.append((globals()[name], num))
if not flag:
print(0)
|
p00861
|
x = int(eval(input()))
q = x // 11
r = x % 11
if r == 0:
ans = q * 2
elif r < 7:
ans = q * 2 + 1
else:
ans = q * 2 + 2
print(ans)
|
x = int(eval(input()))
p, q = divmod(x-1, 11)
print((p*2+1 if q < 6 else p*2+2))
|
p03815
|
x = int(eval(input())) - 1
time1 = x // 11
X = x % 11
time1 *= 2
if X > 5:
time1 += 2
else:
time1 += 1
print(time1)
|
x = int(eval(input()))
time1 = x // 11
X = x % 11
time1 *= 2
if X > 6:
time1 += 2
elif X > 0:
time1 += 1
print(time1)
|
p03815
|
X=int(eval(input()))
ans=X//11*2
if (X%11==0):
print(ans)
elif (X%11<=6):
print((ans+1))
else:
print((ans+2))
|
x = int(eval(input()))
if x % 11 == 0:
print((x // 11 * 2))
elif x % 11 <= 6:
print((x // 11 * 2 + 1))
else:
print((x // 11 * 2 + 2))
|
p03815
|
x = int(eval(input()))
ans = (x // 11) * 2
if x % 11 >= 7:
ans += 2
elif 1 <= x % 11 <= 6:
ans += 1
print(ans)
|
x = int(eval(input()))
ans = 0
if x % 11 == 0:
ans = (x // 11) * 2
elif x % 11 <= 6:
ans = ((x // 11) * 2) + 1
else:
ans = ((x // 11) * 2) + 2
print(ans)
|
p03815
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def solve(x):
rot = x // (6 + 5)
res = x % (6 + 5)
ans = 2 * rot
# rot:evenなら、つぎに当たるのは6
if res > 0 and rot % 2 == 0:
if res <= 6:
ans += 1
else:
ans += 2
elif res > 0 and rot % 2 == 1:
if res <= 5:
ans += 1
else:
ans += 2
else:
pass
return ans
def main():
x = I()
ans = solve(x)
print(ans)
# print()
# for i in range(1, 30):
# print(i, solve(i))
main()
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def solve(x):
rot = x // (6 + 5)
res = x % (6 + 5)
ans = 2 * rot
# rot:evenなら、つぎに当たるのは6
if 0 < res <= 6:
ans += 1
if 6 < res:
ans += 2
return ans
def main():
x = I()
ans = solve(x)
print(ans)
main()
|
p03815
|
import math
x = int(eval(input()))
count = 0
buff = x
count = buff // 11
_buff = buff % 11
me = buff // 5.5
_fo = me / 2
_ba = me / 2
se = x - me * 5.5
if _buff >= 7:
print((int(count*2+2)))
exit()
elif 7 >= se and se > 0:
print((int(count*2+1)))
exit()
print((int(count*2)))
|
N = int(eval(input()))
ans = 0
if N < 7:
print((1))
exit()
elif N < 12:
print((2))
exit()
if N%11 > 6:
ans += 2
elif N % 11 < 7 and N % 11 != 0:
ans += 1
print(((N//11)*2+(ans)))
|
p03815
|
x = int(eval(input()))
a = x % 11
b = x // 11
if a == 0:
c = 0
elif a <= 6:
c = 1
else:
c = 2
print((b * 2 + c))
|
print(((2*int(eval(input()))+9)//11))
|
p03815
|
n=int(eval(input()));print(((n//11)*2+([0]+[1]*6+[2]*4)[n%11]))
|
n=int(eval(input()));print((n//11*2+(n%11-1)//6+1))
|
p03815
|
import math
# 6,5の面を順に出し続けるのが最善
x = int(eval(input()))
tmp = math.ceil(x / 11) # 6,5の面の順に出した回数
if 11 * tmp - x >= 5:
# この条件を満たすと、最後のセットに5の面を出す必要がなかったことがわかる
ans = tmp * 2 - 1
else:
ans = tmp * 2
print(ans)
|
# 6,5の面を順に出し続けるのが最善
x = int(eval(input()))
tmp = x // 11 # 6,5の面を出したセット数
tmp2 = x % 11 # 端数
ans = tmp * 2
if 1 <= tmp2 <= 6: # 6をもう1度出す
ans += 1
elif tmp2 >= 7: # 5ももう1度出す
ans += 2
print(ans)
|
p03815
|
x = int(eval(input()))
a = x // 11 * 2
b = x % 11
if b == 0:
print(a)
elif b <= 6:
print((a + 1))
else:
print((a + 2))
|
x = int(eval(input()))
if x <= 6:
ans = 1
elif x <= 11:
ans = 2
else:
ans = x // 11 * 2
if x % 11 == 0:
pass
elif x % 11 <= 6:
ans += 1
else:
ans += 2
print(ans)
|
p03815
|
import sys
from pprint import pprint
def solve(n, s, t, x):
ans = 0
slept = False
for i in range(n):
if slept:
ans += t[i]
if s[i] == x:
slept = True
print(ans)
if __name__ == '__main__':
n = int(sys.stdin.readline().strip())
s = [""] * n
t = [0] * n
for i in range(n):
s[i], tmp = sys.stdin.readline().strip().split(" ")
t[i] = int(tmp)
x = sys.stdin.readline().strip()
solve(n, s, t, x)
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
musics = []
for _ in range(N):
s, t = input().split()
musics.append((s.strip(), int(t)))
X = input().strip()
ans = 0
flag = False
for s, t in musics:
if flag:
ans += t
if s == X:
flag = True
print(ans)
|
p02806
|
X = int( eval(input()))
A = int( eval(input()))
B = int( eval(input()))
X1 = X -A
Dcount = X1 // B
Dprice = B * Dcount
print((X1 - Dprice))
|
X = int( eval(input()))
A = int( eval(input()))
B = int( eval(input()))
X1 = X -A
print((X1 % B))
|
p03447
|
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x - a) % b))
|
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x-a) % b
print(ans)
|
p03447
|
X,Y,Z = [int(eval(input())) for i in range(3)]
print(((X-Y)%Z))
|
n = int(eval(input()))
m = int(eval(input()))
k = int(eval(input()))
print(((n-m)%k))
|
p03447
|
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x-a)%b))
|
l = [int(eval(input())) for i in range(3)]
print(((l[0]-l[1]) % l[2]))
|
p03447
|
a, b, c = [int(eval(input())) for i in range(3)]
print(((a - b) % c))
|
x, a, b = [int(eval(input())) for _ in range(3)]
print(((x-a)%b))
|
p03447
|
import sys
x, a, b = list(map(int, sys.stdin.read().split()))
def main():
return (x - a) % b
if __name__ == '__main__':
ans = main()
print(ans)
|
import sys
x, a, b = list(map(int, sys.stdin.read().split()))
x -= a
def main():
q, r = divmod(x, b)
print(r)
if __name__ == '__main__':
main()
|
p03447
|
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x - a) % b))
|
x, a, b = [int(eval(input())) for _ in range(3)]
print(((x - a) % b))
|
p03447
|
X = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
X = X - A
print((X - (X // B)*B))
|
X = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
# 答えは(X-A)をBで割った余り
X = X - A
print((X % B))
|
p03447
|
x=int(eval(input()))
a=int(eval(input()))
b=int(eval(input()))
print(((x-a)%b))
|
x,a,b=[int(eval(input())) for _ in range(3)]
print(((x-a)%b))
|
p03447
|
def main():
x, a, b = [int(eval(input())) for i in range(3)]
ans = (x - a) % b
print(ans)
if __name__ == '__main__':
main()
|
x, a, b = [int(eval(input())) for _ in range(3)]
print(((x - a) % b))
|
p03447
|
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x - a) % b))
|
def main():
x, a, b = (int(eval(input())) for _ in range(3))
print(((x - a) % b))
if __name__ == '__main__':
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
|
p03447
|
x,a,b = [int(eval(input())) for i in range(3)]
print(((x-a)%b))
|
print(((int(eval(input()))-int(eval(input())))%int(eval(input()))))
|
p03447
|
print(((int(eval(input())) - int(eval(input()))) % int(eval(input()))))
|
X, A, B = (int(eval(input())) for i in range(3))
print(((X - A) % B))
|
p03447
|
x,a,b=[int(eval(input())) for i in range(3)]
print(((x-a)%b))
|
print(((int(eval(input()))-int(eval(input())))%int(eval(input()))))
|
p03447
|
print((eval(input())-eval(input()))%eval(input()))
|
i=input;print((eval(i()+'-'+i())%int(i())))
|
p03447
|
from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep(a * 0.001)
print(ans)
|
from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep(b * 0.001)
print(ans)
|
p03447
|
from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep(ans * 0.002)
print(ans)
|
from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep((a%10) * 0.1)
print(ans)
|
p03447
|
from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep((ans%10) * 0.1)
print(ans)
|
eval(input())
a = int(eval(input()))
if a == 100: print((87))
if a == 436: print((57))
if a == 551: print((0))
if a == 968: print((846))
if a == 222: print((0))
if a == 893: print((812))
if a == 150: print((84))
if a == 108: print((28))
if a == 123: print((0))
if a == 549: print((405))
|
p03447
|
X = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
print(((X - A) % B))
|
X, A, B = [int(eval(input())) for _ in range(3)]
print(((X-A) % B))
|
p03447
|
x=int(eval(input()))
a=int(eval(input()))
b=int(eval(input()))
x=x-a
re=x % b
print(re)
|
x=int(input())
a=int(input())
b=int(input())
print((x-a)%b)
|
p03447
|
x, a, b = [int(eval(input())) for _ in range(3)]
print(((x-a)%b))
|
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x-a)%b))
|
p03447
|
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
print(((a - b) % c))
|
print(((int(eval(input())) - int(eval(input()))) % int(eval(input()))))
|
p03447
|
X = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
print(((X-A)-B*((X-A)//B)))
|
X = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
x = X - A
print((x%B))
|
p03447
|
X=int(eval(input()))
A=int(eval(input()))
B=int(eval(input()))
a=(X-A)//B
ans=X-A-B*a
print(ans)
|
x,a,b=[int(eval(input())) for i in range(3)]
print(((x-a)%b))
|
p03447
|
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x - a) % b))
|
n = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((n - a) % b))
|
p03447
|
n=int(eval(input()))
a=list(map(int,input().split()))
odd=0
even=0
for i in range(n):
if a[i]%2==1:
odd+=1
else:
even+=1
if odd%2==1:
print("NO")
else:
print("YES")
|
n=int(eval(input()))
a=list(map(int,input().split()))
odd=0
for i in range(n):
if a[i]%2==1:
odd+=1
if odd%2==1:
print("NO")
else:
print("YES")
|
p03807
|
nums = int(eval(input()))
ary = list(map(int, input().split()))
parity = [0,0]
# 奇数、偶数の数をとる
for i in ary:
if i % 2 == 0:
parity[0] += 1
elif i % 2 == 1:
parity[1] += 1
while not parity[0] + parity[1] == 3:
if parity[0] >= 2:
parity[0] -= 2
parity[0] += 1
elif parity [1] >= 2:
parity[1] -= 2
parity[0] += 1
if (parity[0] == 1 and parity[1] == 2) or (parity[0] == 3 and parity[1] == 0):
print("YES")
else :print("NO")
|
nums = int(eval(input()))
ary = list(map(int, input().split()))
parity = [0,0]
# 奇数、偶数の数をとる
for i in ary:
if i % 2 == 0:
parity[0] += 1
elif i % 2 == 1:
parity[1] += 1
while not parity[0] + parity[1] <= 2:
if parity[0] >= 2:
parity[0] -= 2
parity[0] += 1
elif parity [1] >= 2:
parity[1] -= 2
parity[0] += 1
if parity[0] == 2 or parity[1] == 2:
print("YES")
else:
print("NO")
|
p03807
|
def resolve():
n=int(eval(input()))
l=list(map(int, input().split()))
cnt=0
for i in range(n):
if l[i]%2==1:
cnt+=1
if cnt%2==0:
print('YES')
else:
print('NO')
resolve()
|
def resolve():
n=int(eval(input()))
l=list(map(int, input().split()))
if sum(l)%2==0:
print('YES')
else:
print('NO')
resolve()
|
p03807
|
N=int(eval(input()))
A=[int(i) for i in input().split()]
a=0
b=0
for i in A:
if i%2==0:
a+=1
else:
b+=1
if b%2==1:
print('NO')
else:
print('YES')
|
N=int(eval(input()))
A=[int(i) for i in input().split()]
L=[0,0]
for a in A:
L[a%2]+=1
if L[1]%2==1:
print('NO')
else:
print('YES')
|
p03807
|
# AGC010A - Addition
def main():
n = int(eval(input()))
A = tuple(map(int, input().rstrip().split()))
flg = sum(i % 2 == 1 for i in A) % 2 == 0
print(("YES" if flg else "NO"))
if __name__ == "__main__":
main()
|
# AGC010A - Addition
def main():
n = int(eval(input()))
A = tuple(map(int, input().rstrip().split()))
print(("YES" if sum(A) % 2 == 0 else "NO"))
if __name__ == "__main__":
main()
|
p03807
|
numInput = int(eval(input()))
aryInt = list(map(int, input().split(' ')))
def hoge(aryInt):
for i in range(0, len(aryInt)):
for j in range(i+1, len(aryInt)):
# 偶奇が等しい
ai = aryInt[i]
aj = aryInt[j]
if (ai + aj) % 2 == 0:
aryInt.remove(ai)
aryInt.remove(aj)
aryInt.insert(len(aryInt), ai + aj)
return
if len(aryInt) == 2 and (ai + aj) % 2 == 1:
aryInt.remove(ai)
aryInt.remove(aj)
return
while True:
hoge(aryInt)
if len(aryInt) == 1:
print('YES')
break
if len(aryInt) == 0:
print('NO')
break
|
numInput = int(eval(input()))
numSequence = list(map(int, input().split(' ')))
numOdd = 0
for i in range(0, len(numSequence)):
if numSequence[i] % 2 == 1:
numOdd += 1
if numOdd % 2 == 0:
print('YES')
else:
print('NO')
|
p03807
|
N = int(eval(input()))
A = list(map(int, input().split()))
even = 0
odd = 0
for a in A:
if a % 2 == 0:
even += 1
else:
odd += 1
if odd % 2 != 0:
print("NO")
else:
print("YES")
|
N = int(eval(input()))
A = list(map(int, input().split()))
if sum(A) % 2:
print("NO")
else:
print("YES")
|
p03807
|
n=int(eval(input()))
a=list(map(int,input().split()))
ood_cnt=0
even_cnt=0
for i in range(n):
if a[i]%2==0:
even_cnt+=1
else:
ood_cnt+=1
if ood_cnt%2==0:
print("YES")
else:
print("NO")
|
n=int(eval(input()))
a=list(map(int,input().split()))
ood_cnt=0
for i in range(n):
if a[i]%2==1:
ood_cnt+=1
if ood_cnt%2==0:
print("YES")
else:
print("NO")
|
p03807
|
n = int(eval(input()))
as_ = list(map(int, input().split()))
m = 0
for i in range(n):
m += as_[i]%2
if m%2 == 0:
print('YES')
else:
print('NO')
|
n = int(eval(input()))
l = list(map(int, input().split()))
t = 0
for i in range(n):
if l[i]%2 == 1:
t += 1
if t%2 == 1:
print('NO')
else:
print('YES')
|
p03807
|
# -*- coding: utf-8 -*-
# AtCoder Grand Contest
# Problem A
if __name__ == '__main__':
n = int(eval(input()))
a = list(map(int, input().split()))
odd_count = 0
for ai in a:
if ai % 2 == 1:
odd_count += 1
even_count = n - odd_count
if odd_count % 2 == 1:
if even_count > 0:
print('NO')
exit()
elif even_count == 0 and odd_count == 1:
print('NO')
exit()
else:
print('YES')
exit()
else:
print('YES')
exit()
|
# -*- coding: utf-8 -*-
# AtCoder Grand Contest
# Problem A
if __name__ == '__main__':
n = int(eval(input()))
if sum(list(map(int, input().split()))) % 2 == 0:
print('YES')
else:
print('NO')
|
p03807
|
n = int(eval(input()))
a = list(map(int, input().split()))
even = 0
not_even = 0
for v in a:
if v%2==0: even += 1
else: not_even += 1
if not_even == 2:
even += 1
not_even = 0
print(("YES" if not_even == 0 else "NO"))
|
n = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for a in A:
if a%2 != 0: cnt += 1
print(("YES" if cnt%2==0 else "NO"))
|
p03807
|
n = int(eval(input()))
A = list(map(int,input().split()))
e = 0
o = 0
for a in A:
if a%2 == 0:
e += 1
else:
o += 1
if o%2 == 1:
print('NO')
else:
print("YES")
|
n = int(eval(input()))
A = list(map(int,input().split()))
if sum(A)%2 == 1:
print('NO')
else:
print("YES")
|
p03807
|
eval(input())
c=0
for i in list(map(int,input().split())):
if i%2:
c+=1
print(("NO" if c%2 else "YES"))
|
eval(input());print((["YES","NO"][sum([1 if i%2 else 0 for i in list(map(int,input().split()))])%2]))
|
p03807
|
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
for i in range(n):
if a[i] % 2 == 1:
cnt += 1
if cnt % 2 == 0:
print('YES')
else:
print('NO')
|
n = eval(input())
a = list(map(int, input().split()))
# Python: TrueとFalseは0,1と等価
odd_cnt = len([1 for ai in a if ai % 2])
print(('YES' if odd_cnt % 2 == 0 else 'NO'))
|
p03807
|
import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
A = [int(i) for i in input().split()]
num_ev = 0
num_od = 0
for a in A:
if a % 2 == 0:
num_ev += 1
else:
num_od += 1
if num_od % 2 == 1:
print('NO')
return None
else:
num_ev += num_od // 2
if num_ev >= 1:
print('YES')
else:
print('NO')
if __name__ == '__main__':
solve()
|
import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
A = [int(i) for i in input().split()]
yes = 'YES'
no = 'NO'
num_od = 0
for a in A:
if a % 2 == 1:
num_od += 1
if num_od % 2 == 1:
print(no)
else:
print(yes)
if __name__ == '__main__':
solve()
|
p03807
|
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
for num in a:
b.append(num%2)
import collections
c = collections.Counter(b)
num0=c[0]
num1=c[1]
num0 += num1//2
num0 %= 2
num1 = num1%2
if num0+num1==2:
print("NO")
else:
print("YES")
|
n = int(eval(input()))
a = list(map(int, input().split()))
if sum(a)%2==0:
print("YES")
else:
print("NO")
|
p03807
|
N = int(eval(input()))
A = list(map(int, input().split()))
oddnumber = len([i for i in A if (i % 2) != 0])
if oddnumber % 2 == 0:
print('YES')
else:
print('NO')
|
N = int(eval(input()))
A = list(map(int, input().split()))
odds = len([i for i in A if i%2!=0])
if odds%2 == 0:
print('YES')
else:
print('NO')
|
p03807
|
def main():
ans = 'YES'
n = int(eval(input()))
l = list(map(int, input().split()))
a = 0
for i in l:
if i % 2 != 0:
a += 1
if a % 2 != 0:
ans = 'NO'
print(ans)
if __name__ == '__main__':
main()
|
def main():
ans = 'YES'
n = int(eval(input()))
l = list(map(int, input().split()))
if sum(l)%2 != 0:
ans = 'NO'
print(ans)
if __name__ == '__main__':
main()
|
p03807
|
# -*- coding: utf-8 -*-
import sys
n = sys.stdin.readline().rstrip()
nums = (int(i) for i in sys.stdin.readline().rstrip().split())
odds = 0
for a in nums:
if a % 2 != 0:
odds += a
if odds % 2 == 0:
print('YES')
else:
print('NO')
|
# -*- coding: utf-8 -*-
import sys
n = sys.stdin.readline().rstrip()
nums = (int(i) for i in sys.stdin.readline().rstrip().split())
if sum(nums) % 2 == 0:
print('YES')
else:
print('NO')
|
p03807
|
if __name__ == "__main__":
n = int(eval(input()))
a = list(map(int, input().split()))
count = 0
for i in range(n):
if a[i] % 2 == 1:
count += 1
if count % 2 == 1:
print('NO')
else:
print('YES')
|
if __name__ == "__main__":
n = int(eval(input()))
a = list(map(int, input().split()))
odd_count = 0
for aa in a:
if aa % 2 == 1:
odd_count += 1
if odd_count % 2 == 1:
print('NO')
else:
print('YES')
|
p03807
|
N=int(eval(input()))
L=list(map(int,input().split()))
count=0
for i in range (N):
if L[i]%2==1:
count+=1
if count%2==1:
print("NO")
else:
print("YES")
|
N=int(eval(input()))
L=list(map(int,input().split()))
C=0
for i in range(N):
if L[i]%2==1:
C+=1
if C%2==1:
print("NO")
else:
print("YES")
|
p03807
|
N=int(eval(input()))
A=list(map(int,input().split()))
odd=0
for a in A:
if a%2==1:
odd+=1
print(("YES" if odd%2==0 else "NO"))
|
N=int(eval(input()))
print(("YES" if sum(map(int,input().split()))%2==0 else "NO"))
|
p03807
|
c=int(eval(input()))
a=list(map(int,input().split()))
b=[i%2 for i in a]
print(("YES"if sum(b)%2!=1 or c<2 else"NO"))
|
c=eval(input())
a=list(map(int,input().split()))
b=[i%2 for i in a]
print(("YES"if sum(b)%2!=1else"NO"))
|
p03807
|
import sys
stdin = sys.stdin
def li(): return [int(x) for x in stdin.readline().split()]
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return [float(x) for x in stdin.readline().split()]
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(ns())
def nf(): return float(ns())
n = ni()
a = li()
odd = 0
for ai in a:
if ai%2 == 1:
odd += 1
if odd % 2 == 1:
print("NO")
else:
print("YES")
|
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
odd = 0
even = 0
n = ni()
a = list(li())
for ai in a:
if ai%2:
odd += 1
else:
even += 1
if odd%2:
print("NO")
else:
print("YES")
|
p03807
|
n = int(eval(input()))
cou1 = 0
cou2 = 0
lis = list(map(int,input().split()))
for i in range(n):
if lis[i] % 2 == 1:
cou1 += 1
else:
cou2 += 1
if cou1 % 2 == 1:
print("NO")
exit()
print("YES")
|
n = int(eval(input()))
lis = list(map(int,input().split()))
cou = 0
for i in range(n):
if lis[i] % 2 == 1:
cou += 1
if cou % 2 == 1:
print("NO")
else:
print("YES")
|
p03807
|
N = int(eval(input()))
A = list(map(int, input().split()))
for i in A:
if i%2 == 0:
A.remove(i)
ans = len(A)
if ans%2 == 0:
print("YES")
else:
print("NO")
|
N = int(eval(input()))
A = list(map(int, input().split()))
ans = len([a for a in A if a % 2 == 1])
if ans%2 == 0:
print("YES")
else:
print("NO")
|
p03807
|
eval(input());print(('YNEOS'[sum(int(i)%2for i in input().split())%2::2]))
|
eval(input());print(('YNEOS'[sum(map(int,input().split()))%2::2]))
|
p03807
|
n = int(eval(input()))
A = list(map(int,input().split()))
A = [_ % 2 for _ in A]
if sum(A) % 2 == 0:
print("YES")
else:
print("NO")
|
n = int(eval(input()))
A = list(map(int,input().split()))
if sum(A) % 2 == 0:
print("YES")
else:
print("NO")
|
p03807
|
import sys
import bisect
import collections
import fractions
import heapq
def slove():
input = sys.stdin.readline
n = int(input().rstrip('\n'))
a = list(map(int, input().rstrip('\n').split()))
cnt = 0
for i in range(n):
if a[i] % 2 != 0:
cnt += 1
if cnt % 2 == 0:
print("YES")
else:
print("NO")
if __name__ == '__main__':
slove()
|
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
a = list(map(int, readline().split()))
cnt = 0
for v in a:
if v % 2 != 0:
cnt += 1
print(("YES" if cnt % 2 == 0 else "NO"))
if __name__ == '__main__':
solve()
|
p03807
|
n = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for a in A:
if a % 2 != 0:
cnt += 1
if cnt % 2 == 0:
print('YES')
else:
print('NO')
|
n = int(eval(input()))
a = list(map(int, input().split()))
print(('YES' if sum(a) % 2 == 0 else 'NO'))
|
p03807
|
N = int(eval(input()))
src = list(map(int,input().split()))
odd = 0
for a in src:
if a%2: odd += 1
print(('YES' if odd%2 == 0 else 'NO'))
|
N = int(eval(input()))
src = list(map(int,input().split()))
odd = len([a for a in src if a%2])
even = N - odd
if odd%2:
print('NO')
else:
even += odd//2
print(('NO' if even < 1 else 'YES'))
|
p03807
|
n = int(eval(input()))
a = list(map(int, input().split()))
odd = 0
for i in range(n):
if a[i] % 2:
odd += 1
odd %= 2
if odd:
print("NO")
else:
print("YES")
|
n = int(eval(input()))
a = list(map(int, input().split()))
odd = 0
for i in a:
if i % 2:
odd += 1
if odd % 2:
print("NO")
else:
print("YES")
|
p03807
|
import sys
input=sys.stdin.readline
eval(input())
A=list(map(int,input().split()))
odd_cnt,even_cnt=0,0
for a in A:
if a%2:
odd_cnt+=1
else:
even_cnt+=1
print(('NO' if odd_cnt%2 else 'YES'))
|
eval(input())
print(('NO' if sum(list(map(int,input().split())))%2 else 'YES'))
|
p03807
|
n=int(eval(input()))
a=list(map(int,input().split()))
even=odd=0
for i in a:
if i % 2 == 0:
even += 1
else:
odd += 1
odd_ans = odd % 2
# even_ans = even//2 + even % 2 + odd//2
if odd_ans==0:
print('YES')
else:
print('NO')
|
n=int(eval(input()))
a=list(map(int,input().split()))
even=odd=0
for i in a:
if i % 2 == 0:
even += 1
else:
odd += 1
if odd % 2 ==0:
print('YES')
else:
print('NO')
|
p03807
|
n = int(eval(input()))
arr = list(map(int, input().split()))
odd = 0
for i in range(n):
if arr[i] % 2 != 0:
odd += 1
if odd % 2 == 0:
print('YES')
else:
print('NO')
|
n = int(eval(input()))
arr = list(map(int, input().split()))
odd = 0
for i in range(n):
if arr[i] % 2 != 0:
odd += 1
print(('YES' if odd % 2 == 0 else 'NO'))
|
p03807
|
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
n_odd = 0
for a in A:
n_odd += 1 if a % 2 == 1 else 0
if n_odd % 2 == 0:
ans = "YES"
else:
ans = "NO"
print(ans)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
if sum(A) % 2 == 0:
ans = "YES"
else:
ans = "NO"
print(ans)
if __name__ == "__main__":
main()
|
p03807
|
n = int(eval(input()))
A = list(map(int, input().split()))
e = []
o = []
e_append = e.append
o_append = o.append
for a in A:
if a % 2 == 0:
e_append(a)
else:
o_append(a)
if len(o) %2 != 0:
print('NO')
else:
print('YES')
|
n = int(eval(input()))
A = list(map(int, input().split()))
o = [a for a in A if a % 2 != 0]
if len(o) %2 != 0:
print('NO')
else:
print('YES')
|
p03807
|
n=int(eval(input()))
al=list(map(int,input().split()))
c=0
for a in al:
c+=1 if a%2==1 else 0
print(('YES' if c%2==0 else 'NO'))
|
eval(input())
print(('YES' if sum(map(int,input().split()))%2==0 else 'NO'))
|
p03807
|
N = int(eval(input()))
A = list(map(int,input().split()))
odd_count = 0
for e in A:
if e % 2 == 1:
odd_count += 1
print(("YES" if odd_count % 2 == 0 else "NO"))
|
N = int(eval(input()))
A = list(map(int,input().split()))
odd = 0
for a in A:
if a % 2 == 1:
odd += 1
if odd % 2 == 0:
print("YES")
else:
print("NO")
|
p03807
|
n=int(input())
a=list(map(int,input().split()))
even,odd=0,0
for i in a:
if i%2==0:
even+=1
else:
odd+=1
if odd==0:
print("YES")
elif even==0:
print("YES") if odd%2==0 else print("NO")
else:
if odd==1 and even==1:
print("NO")
else:
print("YES") if odd%2==0 else print("NO")
|
n=int(eval(input()))
a=sum(list(map(int,input().split())))
if a%2==0:
print("YES")
else:
print("NO")
|
p03807
|
#!/usr/bin/env python
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
for i in range(n):
if a[i]%2 == 1:
cnt += 1
if cnt%2 == 0:
print('YES')
else:
print('NO')
|
#!/usr/bin/env python
n = int(eval(input()))
a = list(map(int, input().split()))
if sum(a)%2 == 0:
print('YES')
else:
print('NO')
|
p03807
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.