input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import bisect
import sys
import heapq
N = int(eval(input()))
city_ls = list()
for i in range(N):
city_ls.append([int(i) for i in sys.stdin.readline().split()])
sort_by_x = sorted([[i, j] for i,j in city_ls], key=lambda x:x[0])
sort_by_y = sorted([[j, i] for i,j in city_ls], key=lambda x:x[0])
G = []
id2po... | import sys
N = int(eval(input()))
city_ls = list()
for i in range(N):
city_ls.append([int(i) for i in sys.stdin.readline().split()])
sort_by_x = sorted([[i, j] for i,j in city_ls], key=lambda x:x[0])
G = []
pos2id = {tuple(j) : i for i, j in enumerate(city_ls)}
for i in range(len(sort_by_x)-1):
current... | p03682 |
from sys import stdin
from collections import namedtuple
from heapq import heappush, heappop
input = stdin.readline
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
def is_same(self, a, b):
return self.find(a) == self.find(b)
de... | from collections import namedtuple
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.size = [1] * (n + 1)
def is_same(self, a, b):
return self.find(a) == self.find(b)
def unite(self, a, b):
a = self.find(a)
b = self.find(b)
if self.size[a... | p03682 |
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def... | class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def... | p03682 |
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def... | class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
"""
x が属するグループを探索して親を出す。
"""
if self.par[x] == x:
return x
... | p03682 |
import heapq
import sys
sys.setrecursionlimit(10**9)
input=sys.stdin.readline
N=int(eval(input()))
xylist,yxlist=[],[]
par_dic={}
for i in range(N):
x,y=list(map(int,input().split()))
xylist.append((x,y))
yxlist.append((y,x))
par_dic[(x,y)]=(x,y)
xylist.sort()
yxlist.sort()
#print(xylist)
h... | import sys
sys.setrecursionlimit(10**9)
input=sys.stdin.readline
N=int(eval(input()))
xylist,yxlist=[],[]
par_dic={}
for i in range(N):
x,y=list(map(int,input().split()))
xylist.append((x,y))
yxlist.append((y,x))
par_dic[(x,y)]=(x,y)
xylist.sort()
yxlist.sort()
#print(xylist)
elist=[]
for i... | p03682 |
import sys
import heapq
input = sys.stdin.readline
N = int(eval(input()))
cityx = []
cityy = []
for i in range(N):
x,y = list(map(int,input().split()))
cityx.append([x,i])
cityy.append([y,i])
cityx.sort()
cityy.sort()
side = [[]for i in range(N)]
for i in range(N-1):
a,x = cityx[i]
... | import sys
input = sys.stdin.readline
N = int(eval(input()))
cityx = [[0,i]for i in range(N)]
cityy = [[0,i]for i in range(N)]
for i in range(N):
x,y = list(map(int,input().split()))
cityx[i][0] = x
cityy[i][0] = y
cityx.sort()
cityy.sort()
side = []
for i in range(N-1):
side.append([ci... | p03682 |
n=int(eval(input()))
import heapq
hqx=[]
hqy=[]
for i in range(n):
x,y=list(map(int,input().split()))
heapq.heappush(hqx,(x,i))
heapq.heappush(hqy,(y,i))
prex,prexi=heapq.heappop(hqx)
prey,preyi=heapq.heappop(hqy)
edges=[]#(cost,v1,v2)
for i in range(n-1):
x,xi=heapq.heappop(hqx)
y,yi=h... | n=int(eval(input()))
hqx=[]
hqy=[]
for i in range(n):
x,y=list(map(int,input().split()))
hqx.append((x,i))
hqy.append((y,i))
hqx.sort()
hqy.sort()
prex,prexi=hqx[0]
prey,preyi=hqy[0]
edges=[]#(cost,v1,v2)
for i in range(1,n):
x,xi=hqx[i]
y,yi=hqy[i]
edges.append((x-prex,prexi,xi))... | p03682 |
import heapq
def prim_heap():
used = [True] * n #True:不使用
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 = m... | import heapq
import sys
input = sys.stdin.readline
def prim_heap():
used = [True] * n #True:不使用
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... | p03682 |
import heapq as hq
class UnionFind(object):
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0]*size
def find(self, x):
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
... | import sys
input = sys.stdin.readline
class UnionFind(object):
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0]*size
def find(self, x):
if self.parent[x] == x:
return x
# path compression
self.parent[x] = self.find(sel... | p03682 |
import array
import collections
import heapq
AdjacentVertex = collections.namedtuple("AdjacentVertex", "vertex cost")
INF = 2 ** 31 - 1
NO_VERTEX = -1
# Prim法で頂点0からの最小全域木を求める
def compute_mst_prim(max_v, adj_list):
# pred[u]は頂点uの「ひとつ前」の頂点を表す
pred = collections.defaultdict(lambda: NO_VERTEX)
#... | N = int(eval(input()))
towns = []
for i in range(N):
x, y = list(map(int, input().split()))
towns.append((i, x, y))
# x, y座標の値でソートして、隣接する街の間の道を、隣接リストadjに追加する
adj = [[] for i in range(N)]
for xy in [1, 2]:
towns.sort(key=lambda t: t[xy])
for i in range(N - 1):
t1 = towns[i][0]
... | p03682 |
def main():
import sys
input = sys.stdin.readline
from heapq import heappop,heappush
from operator import itemgetter
def prim():
used = [True]*n
edgelist = []
for e in edge[0]:
heappush(edgelist,e)
used[0] = False
res = 0
... | def main():
import sys
input = sys.stdin.readline
from heapq import heappop,heappush
from operator import itemgetter
def prim():
used = [True]*n
edgelist = []
for e in edge[0]:
heappush(edgelist,e)
used[0] = False
res = 0
... | p03682 |
class UnionFind:
def __init__(self, n):
self.p = [i for i in range(n)]
self.components = n # 連結成分の数
def root(self, x):
if self.p[x] != x:
x_now = x
while self.p[x_now] != x_now:
x_now = self.p[x_now]
self.p[x] = x_now
... | class UnionFind:
def __init__(self, n):
self.p = [i for i in range(n)]
self.components = n # 連結成分の数
def root(self, x):
if self.p[x] != x:
stack = [x]
while True:
top = stack[-1]
if self.p[top] == top:
... | p03682 |
# UnionFind
#############################################################
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, v): # vが属する集合の根を返す
if self.parents[v] < 0:
return v
else:
self.parents[v] = s... | # UnionFind
#############################################################
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, v): # vが属する集合の根を返す
if self.parents[v] < 0:
return v
else:
self.parents[v] = s... | p03682 |
# UnionFind
#############################################################
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, v): # vが属する集合の根を返す
if self.parents[v] < 0:
return v
else:
self.parents[v] = s... | # UnionFind
#############################################################
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, v): # vが属する集合の根を返す
if self.parents[v] < 0:
return v
else:
self.parents[v] = s... | p03682 |
N = int(eval(input()))
XY = [list(map(int, input().split())) + [i + 1] for i in range(N)]
dist = []
XY.sort()
for i in range(N - 1):
dist.append((abs(XY[i][0] - XY[i + 1][0]), (XY[i][2], XY[i + 1][2])))
XY.sort(key = lambda x: x[1])
for i in range(N - 1):
dist.append((abs(XY[i][1] - XY[i + 1][1]), (XY[i... | import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
XY = [list(map(int, input().split())) + [i + 1] for i in range(N)]
dist = []
XY.sort()
for i in range(N - 1):
dist.append((abs(XY[i][0] - XY[i + 1][0]), (XY[i][2], XY[i + 1][2])))
XY.sort(key = lambda x: x[1])
for i in range(N - 1):
... | p03682 |
def update_tree(par, a, b):
frm = par[a][0] if par[par[a][0]][1] < par[par[b][0]][1] else par[b][0]
to = par[b][0] if frm == par[a][0] else par[a][0]
if par[par[frm][0]][1] > par[par[to][0]][1]:
par[par[to][0]][1] = par[par[frm][0]][1]
while par[frm][0] != par[par[frm][0]][0]:
... |
def update_tree(par, a, b):
frm = par[a][0] if par[par[a][0]][1] < par[par[b][0]][1] else par[b][0]
to = par[b][0] if frm == par[a][0] else par[a][0]
if par[par[frm][0]][1] > par[par[to][0]][1]:
par[par[to][0]][1] = par[par[frm][0]][1]
while par[frm][0] != par[par[frm][0]][0]:
... | p03682 |
def update_tree(par, a, b):
frm = par[a][0] if par[par[a][0]][1] < par[par[b][0]][1] else par[b][0]
to = par[b][0] if frm == par[a][0] else par[a][0]
if par[par[frm][0]][1] + 1> par[par[to][0]][1]:
par[par[to][0]][1] = par[par[frm][0]][1] + 1
while par[frm][0] != par[par[frm][0]][0]... | import sys
sys.setrecursionlimit(100000)
def unite(i, j):
j = get_par(j)
par[j] = get_par(i)
return
def get_par(p):
if par[p] is None:
return p
par[p] = get_par(par[p])
return par[p]
N = int(eval(input()))
points = []
edges = []
for i in range(N):
x,y = list(map(... | p03682 |
import heapq
def prim_heap():
used = [True] * n #True:不使用
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 = m... | import heapq
def prim_heap():
used = [True] * n #True:不使用
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 = m... | p03682 |
from operator import itemgetter
import heapq
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X.append((x, i))
Y.append((y, i))
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
G = [[] for _ in range(N)]
for i in range(N-1):
G[X[i][1]].append... | from operator import itemgetter
import heapq
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X.append((x, i))
Y.append((y, i))
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
import sys
sys.setrecursionlimit(10**6)
class UnionFind(object)... | p03682 |
class DisjointSet:
def __init__(self, size):
self.parent = list(range(size))
self.rank = [0]*size
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
d... | class DisjointSet:
def __init__(self, size):
self.parent = list(range(size))
self.rank = [0]*size
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
d... | p03682 |
class DisjointSet:
def __init__(self, size):
self.parent = list(range(size))
self.rank = [0]*size
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
d... | class DisjointSet:
def __init__(self, size):
self.parent = list(range(size))
self.rank = [0]*size
def find(self, x):
stack = []
parent = self.parent
while parent[x] != x:
stack.append(x)
x = parent[x]
for y in stack:
... | p03682 |
class UnionFind:
def __init__(self, n):
# total number of nodes.
self.n = n
# node id -> root node id
self._root_table = list(range(n))
# root node id -> group size
self._size_table = [1] * n
def find(self, x):
"""Returns x's root node id."""
... | import sys
class UnionFind:
def __init__(self, n):
# total number of nodes.
self.n = n
# node id -> root node id
self._root_table = list(range(n))
# root node id -> group size
self._size_table = [1] * n
def find(self, x):
"""Returns x's roo... | p03682 |
import sys
class UnionFind:
def __init__(self, n):
# total number of nodes.
self.n = n
# node id -> root node id
self._root_table = list(range(n))
# root node id -> group size
self._size_table = [1] * n
def find(self, x):
"""Returns x's roo... | """Minimum spanning tree with Kruskal's algorithm"""
import sys
class UnionFind:
def __init__(self, n):
# total number of nodes.
self.n = n
# node id -> root node id
self._root_table = list(range(n))
# root node id -> group size
self._size_table = [1] * n... | p03682 |
class UnionFind1:
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
while self.table[x] >= 0: x = self.table[x]
return x
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self... | class UnionFind3:
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self, x, y):
s1... | p03682 |
import sys
sys.setrecursionlimit(4100000)
import math
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
from collections import defaultdict
# d = defaultdict(list)
from itertools import combinations
# comb = combinations(range(N), 2)
from functools import... | import sys
sys.setrecursionlimit(4100000)
import math
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
from collections import defaultdict
# d = defaultdict(list)
from itertools import combinations
# comb = combinations(range(N), 2)
from functools import... | p03682 |
n = int(eval(input()))
l = []
for i in range(n):
x,y = list(map(int,input().split()))
l.append([x,y,i])
lx = sorted(l)
ly = sorted(l, key=lambda x: x[1])
e = []
for i in range(n-1):
e.append([lx[i+1][0]-lx[i][0],lx[i+1][2],lx[i][2]])
e.append([ly[i+1][1]-ly[i][1],ly[i+1][2],ly[i][2]])
... | n = int(eval(input()))
l = []
for i in range(n):
x,y = list(map(int,input().split()))
l.append([x,y,i])
lx = sorted(l)
ly = sorted(l, key=lambda x: x[1])
e = []
for i in range(n-1):
e.append([lx[i+1][0]-lx[i][0],lx[i+1][2],lx[i][2]])
e.append([ly[i+1][1]-ly[i][1],ly[i+1][2],ly[i][2]])
... | p03682 |
from heapq import heappop, heappush
class UnionFind(object):
def __init__(self, N):
self.tree = [i for i in range(N)]
self.rank = [0] * (N + 1)
self.size = [1] * N # 頂点iの属する連結成分の大きさ
def find(self, x):
if self.tree[x] == x:
return x
else:
... | from heapq import heappop, heappush
class UnionFind(object):
def __init__(self, N):
self.tree = [i for i in range(N)]
self.rank = [0] * (N + 1)
self.size = [1] * N # 頂点iの属する連結成分の大きさ
def find(self, x):
while self.tree[x] != self.tree[self.tree[x]]:
sel... | p03682 |
#最小領域木
#ABC065D - Built?
#https://atcoder.jp/contests/abc065/tasks/arc076_b
#自己考察
n = int(eval(input()))
lst = [list(map(int,input().split())) for _ in range(n)]
cad = []
for i in range(n):
for j in range(i,n):
tmp = min(abs(lst[i][0]-lst[j][0]),abs(lst[i][1]-lst[j][1]))
cad.append([... | #最小領域木
#ABC065D - Built?
#https://atcoder.jp/contests/abc065/tasks/arc076_b
#自己考察TLE
import sys
n = int(eval(input()))
cad = []
lst = []
for i in range(n):
x, y = list(map(int,input().split()))
lst.append([x,y,i])
lstx = lst.sort(key = lambda x: x[0])
for i in range(n-1):
cad.append([lst... | p03682 |
import sys
sys.setrecursionlimit(100000)
N=int(eval(input()))
xy=[list(map(int,input().split()))+[i] for i in range(N)]
xy.sort()
path = []
def get_par(n):
if par[n] is None:return n
return get_par(par[n])
def same(i,j):
return get_par(i) == get_par(j)
def unite(i,j):
j = get_par(j)
... | import sys
sys.setrecursionlimit(100000)
N=int(eval(input()))
xy=[list(map(int,input().split()))+[i] for i in range(N)]
xy.sort()
path = []
def get_par(n):
if par[n] is None:return n
par[n] = get_par(par[n])
return par[n]
def same(i,j):
return get_par(i) == get_par(j)
def unite(i,j):
... | p03682 |
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
... | #!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
... | p03682 |
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
... | #!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
... | p03682 |
n=int(eval(input()))
town=[]
for i in range(n):
x,y=list(map(int,input().split()))
town.append([x,y,i])
X=sorted(town,key=lambda x:x[0])
Y=sorted(town,key=lambda x:x[1])
es=[]
for i in range(1,n):
es.append((min(abs(X[i][0]-X[i-1][0]),abs(X[i][1]-X[i-1][1])),X[i][2],X[i-1][2]))
es.append((min(... | n=int(eval(input()))
town=[]
for i in range(n):
x,y=list(map(int,input().split()))
town.append([x,y,i])
X=sorted(town,key=lambda x:x[0])
Y=sorted(town,key=lambda x:x[1])
es=[]
for i in range(1,n):
es.append((min(abs(X[i][0]-X[i-1][0]),abs(X[i][1]-X[i-1][1])),X[i][2],X[i-1][2]))
#es.append((min... | p03682 |
from collections import defaultdict
from heapq import heappop, heappush
from operator import itemgetter
N = int(eval(input()))
town = [[int(x) for x in input().split()] + [i] for i in range(N)]
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank... | import sys
from collections import defaultdict
from heapq import heappop, heappush
from operator import itemgetter
readline = sys.stdin.readline
N = int(readline())
town = [None] * N
for i in range(N):
x, y = list(map(int, readline().split()))
town[i] = (i, x, y)
class UnionFind(object):
de... | p03682 |
def distance(P, p1, p2):
return min(abs(P[p1][1]-P[p2][1]), abs(P[p1][2]-P[p2][2]))
N = int(eval(input()))
P = [[j]+[int(i) for i in input().split(' ')] for j in range(N)]
sortX = sorted(P,key=lambda x:x[1])
sortY = sorted(P,key=lambda x:x[2])
EX = [[sortX[i][0], sortX[i+1][0], distance(P,sortX[i][0],sort... |
import sys
sys.setrecursionlimit(int(2e9))
def distance(P, p1, p2):
return min(abs(P[p1][1]-P[p2][1]), abs(P[p1][2]-P[p2][2]))
def root(CI, p):
if CI[p] == p:
return p
else:
CI[p] = root(CI, CI[p])
return CI[p]
N = int(eval(input()))
P = [[j]+[int(i) for i in input(... | p03682 |
from heapq import heappush, heappop
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.size = [1]*n
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(s... | from heapq import heappush, heappop
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.size = [1]*n
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(s... | p03682 |
class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.size_ = 1
def __str__(self):
templa... | class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.size_ = 1
def __str__(self):
templa... | p03682 |
class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.size_ = 1
def __str__(self):
templa... | class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.size_ = 1
def __str__(self):
templa... | p03682 |
class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.size_ = 1
def __str__(self):
templa... | import sys
input=sys.stdin.readline
class UnionFindNode(object):
"""
Union-Find構造
ノードのグループ併合や、所属グループ判定を高速に処理する
"""
def __init__(self, group_id, parent=None, value=None):
self.group_id_ = group_id
self.parent_ = parent
self.value = value
self.size_ = 1
... | p03682 |
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]
# 併合
... | 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]
# 併合
... | p03682 |
from operator import itemgetter
import heapq
N = int(eval(input()))
X = [[int(p) for p in input().split()] for _ in range(N)]
X.sort()
for i in range(N):
X[i].append(i)
Y = sorted(X, key=itemgetter(1))
h = []
for i in range(N-1):
heapq.heappush(h, (X[i+1][0]-X[i][0], i+1, i))
heapq.he... | from operator import itemgetter
import heapq
N = int(eval(input()))
pos = [[int(p) for p in input().split()] for _ in range(N)]
pos.sort()
for i in range(N):
pos[i].append(i)
Y = sorted(pos, key=itemgetter(1))
Y_idx = [0]*N
for i in range(N):
Y_idx[Y[i][2]] = i
ans = 0
used = [0]*N... | p03682 |
import heapq
n=int(eval(input()))
G=[]
for index in range(n):
x,y=list(map(int,input().split()))
G.append((index,x,y))
#print(G)
D=[[] for _ in range(n)]
xG=sorted(G,key=lambda x:x[1])
for index_x in range(n-1):
nowx=xG[index_x]
nextx=xG[index_x+1]
distx=nextx[1]-nowx[1]
D[n... | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
... | p03682 |
def main():
import heapq
class unionfind():
#size:要素数,tree：unionfind木
def __init__(self,size):#self,要素数
self.size=size
self.tree=[[i,1] for i in range(self.size)]#root,depth
#rootを探す
def root(self,index):
if self.tree[index][... | def main():
import heapq
def root(index):
if tree[index][0]==index:
return index
else:
tree[index][0]=root(tree[index][0])
return tree[index][0]
def unite(index1,index2):
r1=root(index1)
r2=root(index2)
if r1!=r2:
... | p03682 |
#D問題
#UnionFind(normal)
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
... | #D問題
def find(A,x):
p = A[x]
if p == x:
return x
a = find(A,p)
A[x] = a
return a
def union(A, x, y):
if find(A,x) > find(A,y):
bx, by = find(A,y), find(A,x)
else:
bx, by = find(A,x), find(A,y)
A[y] = bx
A[by] = bx
import heapq
N = int(eva... | p03682 |
import sys
from collections import Counter, deque, defaultdict
from math import factorial
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, ... | import sys
from collections import Counter, deque, defaultdict
from math import factorial
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, ... | p03682 |
from collections import deque
import sys
sys.setrecursionlimit(2000000000)
n = int(eval(input()))
nodes = []
done = [0 for _ in range(n)]
par = {}
for _ in range(n):
x, y = list(map(int,input().split()))
nodes.append((x,y))
par[(x,y)]=(x,y)
nodesx = sorted(nodes)
nodesy = sorted(nodes,key=l... | from collections import deque
import sys
sys.setrecursionlimit(2000000000)
n = int(eval(input()))
nodes = []
done = [0 for _ in range(n)]
par = {}
for _ in range(n):
x, y = list(map(int,input().split()))
nodes.append((x,y))
par[(x,y)]=(x,y)
nodesx = sorted(nodes)
nodesy = sorted(nodes,key=... | p03682 |
# 解説
def solve() -> None:
from collections import namedtuple
from heapq import heappush, heappop
from operator import attrgetter
pt = namedtuple('pt', 'x y idx')
n = int(eval(input()))
cities = []
for idx in range(n):
x, y = list(map(int, input().split()))
citie... | def solve_abc065d():
from collections import namedtuple
from operator import attrgetter
from itertools import tee
import sys
input = sys.stdin.readline
City = namedtuple('City', 'x y idx')
Edge = namedtuple('Edge', 'cost a b')
N = int(eval(input()))
cities = []
fo... | p03682 |
def solve_abc065d():
from collections import namedtuple
from heapq import heappush, heappop
from operator import attrgetter
from itertools import tee
import sys
input = sys.stdin.readline
City = namedtuple('City', 'x y idx')
Edge = namedtuple('Edge', 'cost to')
N = int(e... | class UnionFind:
def __init__(self, n):
self.v = [-1] * n
def find(self, x):
if self.v[x] < 0:
return x
else:
self.v[x] = self.find(self.v[x])
return self.v[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
... | p03682 |
import sys
sys.setrecursionlimit(10**6)
from heapq import heappop, heappush
icase=0
if icase==0:
n=int(eval(input()))
xy=[[0]*2 for i in range(n)]
for i in range(n):
xy[i]=list(map(int,input().split()))
elif icase==1:
n=3
xy=[[1, 5], [3, 9], [7, 8]]
elif icase==2:
... | import sys
sys.setrecursionlimit(10**6)
from heapq import heappop, heappush,heapify
icase=0
if icase==0:
n=int(eval(input()))
xy=[[0]*2 for i in range(n)]
x=[0]*n
y=[0]*n
for i in range(n):
# xy[i]=list(map(int,input().split()))
x[i],y[i]=list(map(int,input().split()))
e... | p03682 |
#!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
... | #!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
... | p03682 |
#!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
... | #!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
... | p03682 |
#!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
... | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in... | p03682 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
from operator import itemgetter
# Union-Find木
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
# 1-indexedのままでOK、その場合は[0]は未使用
self.par... | # -*- coding: utf-8 -*-
"""
・最小全域木、Union-Find
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
from operator import itemgetter
# Union-Find木
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
# 1-indexedのままでOK... | p03682 |
# -*- coding: utf-8 -*-
"""
・最小全域木、Union-Find
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
from operator import itemgetter
# Union-Find木
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
# 1-indexedのままでOK... | # -*- coding: utf-8 -*-
"""
・最小全域木、Union-Find
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
from operator import itemgetter
# Union-Find木
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
# 1-indexedのままでOK... | p03682 |
import sys
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
# 最小全域木
# プリム法 #
# 部分木から、最小コストの辺を貪欲に追加
# Kruskal法 #
# クラスカル法 #
# 辺でソートして、最小コストの辺から、ループにならないよう貪欲に追加
# UnionFindを使う
N = int(eval(input()))
# x,yでそれぞれソート
POINT_x = []
POINT_y = []
for _ in range(N):
x, ... | import sys
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
# 最小全域木
# プリム法 #
# 部分木から、最小コストの辺を貪欲に追加
# Kruskal法 #
# クラスカル法 #
# 辺でソートして、最小コストの辺から、ループにならないよう貪欲に追加
# UnionFindを使う
N = int(eval(input()))
# x,yでそれぞれソート
POINT_x = []
POINT_y = []
for _ in range(N):
x, ... | p03682 |
from heapq import *
# Aの中でxの根を求める
def find(A,x):
p = A[x]
if p == x:
return x
a = find(A,p)
A[x] = a
return a
# Aのリストでxとyの属する集合の併合
def union(A, x, y):
if find(A,x) > find(A,y):
bx, by = find(A,y), find(A,x)
else:
bx, by = find(A,x), find(A,y)
# ... | # D - Built?
from heapq import *
# Aでxの根を求める
def find(A, x):
p = A[x]
if p == x:
return x
a = find(A, p)
A[x] = a
return a
# Aでxとyの属する集合の併合
def union(A, x, y):
if find(A, x) > find(A, y):
bx, by = find(A, y), find(A, x)
else:
bx, by = find(A, x), fi... | p03682 |
from heapq import *
def find(x):
parent = data[x]
if parent < 0: return x
root = find(parent)
data[x] = root
return root
def union(x, y):
root, second = find(x), find(y)
if root == second: return False
if height[root] < data[second]:
second, root = root, second
... | from heapq import *
def main():
def find(x):
parent = data[x]
if parent < 0: return x
root = find(parent)
data[x] = root
return root
def union(x, y):
root, second = find(x), find(y)
if root == second: return False
if height[root] < d... | p03682 |
import heapq
def cost(a, b, c, d):
return min(abs(a-c), abs(b-d))
N = int(eval(input()))
T = []
for i in range(N):
x, y = list(map(int, input().split()))
if (x, y) not in T:
T.append((x, y))
lenT = len(T)
Tx, Ty = sorted(T, key = lambda t:t[0]), sorted(T, key = lambda t:t[1])
P = [[] fo... | import sys
from operator import itemgetter
import heapq
def solve():
input = sys.stdin.readline
N = int(eval(input()))
town = dict()
road = [None] * N
roadx, roady = [None] * N, [None] * N
for i in range(N):
x, y = list(map(int, input().split()))
town[(x, y, i)] = i
... | p03682 |
from heapq import *
N = int(eval(input()))
X,Y=[],[]
for n in range(N):
x,y=list(map(int,input().split()))
X.append((x, n))
Y.append((y, n))
X.sort()
Y.sort()
D=[[] for v in range(N)]
for n in range(N-1):
cost = X[n+1][0]-X[n][0]
D[X[n+1][1]].append((cost,X[n][1]))
D[X[n][1]].append((cost,X[n+1... | N = int(eval(input()))
XYI = [tuple(map(int,input().split() + [i])) for i in range(N)]
sx = sorted(XYI, key=lambda x:x[0])
sy = sorted(XYI, key=lambda x:x[1])
es = []
for (x0,_,i0),(x1,_,i1) in zip(sx,sx[1:]):
es.append((x1-x0, i0, i1))
for (_,y0,i0),(_,y1,i1) in zip(sy,sy[1:]):
es.append((y1-y0, i0, i1))... | p03682 |
n=int(eval(input()))
a=sorted([[i]+list(map(int,input().split()))for i in range(n)],key=lambda x:x[1])
s=[]
for i in range(n-1):
s.append((a[i+1][1]-a[i][1],a[i][0],a[i+1][0]))
a=sorted(a,key=lambda x:x[2])
for i in range(n-1):
s.append((a[i+1][2]-a[i][2],a[i][0],a[i+1][0]))
s.sort()
t=[i for i in rang... | n=int(eval(input()))
a=sorted([[i]+list(map(int,input().split()))for i in range(n)],key=lambda x:x[1])
s=[]
for i in range(n-1):
s.append((a[i+1][1]-a[i][1],a[i][0],a[i+1][0]))
a=sorted(a,key=lambda x:x[2])
for i in range(n-1):
s.append((a[i+1][2]-a[i][2],a[i][0],a[i+1][0]))
s.sort()
t=[i for i in rang... | p03682 |
import sys
from heapq import heappush, heappop, heapify
N=int(eval(input()))
par=[ i for i in range(N) ]
def root(x):
if par[x]==x:
return x
else:
par[x]=root( par[x] )
return par[x]
def same(x,y):
return root(x)==root(y)
def unite(x,y):
x=root(x)
y=root(y)
if x==y: return
par[x]... | # -*- coding: utf-8 -*-
import sys
N=int(sys.stdin.readline().strip())
V=[] #頂点の集合 (x座標、y座標、頂点番号)
for v in range(N): #v:頂点番号
x,y=tuple(map(int, sys.stdin.readline().split()))
V.append((x,y,v+1))
#頂点をy軸でソート
V.sort(key=lambda x:(x[0]) )
E=[] #辺の集合 (辺の長さ、頂点番号、頂点番号)
for i in range(N-1):
fro... | p03682 |
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in in... | from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in in... | p03682 |
import heapq
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
x,y = [],[]
root = [[] for _ in range(N)]
go = [True for _ in range(N)]
for i in range(N):
_x,_y = list(map(int,input().split()))
x.append((_x,i))
y.append((_y,i))
... | import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
rx,ry = [],[]
_root = []
for i in range(N):
a,b = list(map(int,input().split()))
rx.append((a,i))
ry.append((b,i))
I = [i for i in range(N)]
rank = [1 for _ in range(N)]
def r... | p03682 |
N = int(eval(input()))
ixy=[]
for i in range(N):
x, y = list(map(int,input().split()))
ixy+=[[i,x,y]]
costs = [[] for i in range(N)]
ixy.sort(key=lambda x:x[1])
for j in range(N-1):
costs[ixy[j][0]] += [[ixy[j+1][0],abs(ixy[j][1]-ixy[j+1][1])]]
costs[ixy[j+1][0]] += [[ixy[j][0],abs(ixy[j][1]-ixy[j+1]... | class UnionFind:
def __init__(self, size):
# 負の値はルート (集合の代表) で集合の個数
# 正の値は次の要素を表す
self.table = [-1 for _ in range(size)]
# 集合の代表を求める
def find(self, x):
if self.table[x] < 0:
return x
else:
# 経路の圧縮
self.table[x] = self.find(self.table[x])
return self.table[x]
... | p03682 |
#UnionFind木とそれを利用したクラスカル法
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]
... | #UnionFind木とそれを利用したクラスカル法
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]
... | p03682 |
#UnionFind木とそれを利用したクラスカル法
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]
... | #最小全域木問題、プリム法
from heapq import *
def solve():
N = int(eval(input()))
A = [list(map(int, input().split()))+[i] for i in range(N)]
edge = [[] for _ in range(N)]
A.sort()
for i in range(N-1):
w = A[i+1][0]-A[i][0]
edge[A[i][2]].append((w,A[i+1][2]))
edge[A[i+1][2]].ap... | p03682 |
import heapq
class UnionFind:
def __init__(self, n):
self.n = n
self.parent = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(... | import heapq
class UnionFind:
def __init__(self, n):
self.n = n
self.parent = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(... | p03682 |
class UnionFind(object):
def __init__(self,n):
*self.par,=list(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)
... | class UnionFind(object):
def __init__(self,n):
self.parent={i:i for i in range(1,n+1)}
self.size={i:1 for i in range(1,n+1)}
def find(self,a):
if self.parent[a]!=a:
self.parent[a]=self.find(self.parent[a])
return self.parent[a]
def unite(self,a,b):
a=self.find(a)
b=self.fin... | p03682 |
class UnionFind(object):
def __init__(self,n):
self.parent={i:i for i in range(1,n+1)}
self.size={i:1 for i in range(1,n+1)}
def find(self,a):
if self.parent[a]!=a:
self.parent[a]=self.find(self.parent[a])
return self.parent[a]
def unite(self,a,b):
a=self.find(a)
b=self.fin... | class UnionFind(object):
def __init__(self, n):
self.parent={i:i for i in range(1,n+1)}
self.size={i:1 for i in range(1,n+1)}
def find(self, a):
if self.parent[a]!=a:
self.parent[a]=self.find(self.parent[a])
return self.parent[a]
def getsize(self, a):
... | p03682 |
n = int(eval(input()))
data = []
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
els... | import sys
input = sys.stdin.readline
n = int(eval(input()))
data = []
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]... | p03682 |
import queue,sys,copy
sys.setrecursionlimit(10**7)
INF = 10**10
N = int(eval(input()))
x = [0 for _ in range(N)]
y = [0 for _ in range(N)]
for i in range(N):
x[i], y[i] = list(map(int,input().split()))
ix = [i for i in range(N)]
sort_x_ix = sorted(ix, key=lambda i:x[i])
sort_x = [x[i] for i in sort_x_ix]
... | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
xy = [LI() for _ in range(N)]
x = [(xy[i][0],i) for i in range(N)]
y = [(xy[i][1],i) for i in range... | p03682 |
from heapq import *
from collections import defaultdict
INF = float('inf')
class Prim:
def __init__(self,N):#Nはグラフのノード数
self.N = N
self.cost = defaultdict(list)
self.used = [False for _ in range(N)]
def setcost(self,u,v,w):
self.cost[u].append((v,w))
sel... | from heapq import *
from collections import defaultdict
INF = float('inf')
class Prim:
def __init__(self,N):#Nはグラフのノード数
self.N = N
self.cost = defaultdict(list)
self.used = [False for _ in range(N)]
def setcost(self,u,v,w):
self.cost[u].append((v,w))
sel... | p03682 |
import heapq
class Graph:
def __init__(self,v,edgelist,w_v = None,directed = False):
super().__init__()
self.v = v
self.w_e = [{} for _ in [0]*self.v]
self.neighbor = [[] for _ in [0]*self.v]
self.w_v = w_v
self.directed = directed
for i,j,w in edge... | class UnionFind:
def __init__(self,n):
super().__init__()
self.par = [-1]*n
self.rank = [0]*n
self.tsize = [1]*n
def root(self,x):
if self.par[x] == -1:
return x
else:
self.par[x] = self.root(self.par[x])
retur... | p03682 |
# -*- coding: utf-8 -*-
import sys
from heapq import heappush,heappop,heapify
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x... | # -*- coding: utf-8 -*-
import sys
from heapq import heappush,heappop,heapify
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x... | p03682 |
class UF():
def __init__(self, N):
self.par = [-1]*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 union(self, x,y):
p1,p2 = self.find(x),self.find(y)
if p1 == p2: return
if p1 > p2:
... | class UF():
def __init__(self, N):
self.par = [-1]*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 union(self, x,y):
p1,p2 = self.find(x),self.find(y)
if p1 == p2: return
if p1 > p2:
... | p03682 |
import sys
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
... | import sys
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
... | p03682 |
#最小全域木 プリム法
from heapq import *
n=int(eval(input()))
xy=[]
for i in range(n):
x,y=list(map(int,input().split()))
xy.append([x,y,i])
#今回の問題では,高々xが隣のやつとyが隣のやつを全部考えればよし
#（詳しくは解説pdfより）
x_sort = sorted(xy, key=lambda x: x[0])
y_sort = sorted(xy, key=lambda x: x[1])
cost = [[]for _ in range(n+3)] #co... | #最小全域木 クラスカル法
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノー... | p03682 |
from operator import itemgetter
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.parent... | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
... | p03682 |
from collections import defaultdict
import operator
N = eval(input())
xs = []
ys = []
for i in range(N):
x, y = list(map(int, input().split()))
xs.append((x,i))
ys.append((y,i))
xs.sort()
ys.sort()
es = defaultdict(lambda: float('inf'))
for i in range(N-1):
xd = xs[i+1][0] - xs[i][0]
... | N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N)]
xs = []
ys = []
for i,(x,y) in enumerate(src):
xs.append((x,i))
ys.append((y,i))
xs.sort()
ys.sort()
es = []
for (x1,i1),(x2,i2) in zip(xs,xs[1:]):
es.append((x2-x1, i1, i2))
for (y1,i1),(y2,i2) in zip(ys,ys[1:]... | p03682 |
# -*- coding: utf-8 -*-
"""
http://abc065.contest.atcoder.jp/tasks/arc076_b
"""
import sys
from sys import stdin
input = stdin.readline
from collections import namedtuple
class DisjointSet(object):
def __init__(self, size):
self.rank = []
self.p = []
for i in range(size):
... | # -*- coding: utf-8 -*-
"""
http://abc065.contest.atcoder.jp/tasks/arc076_b
TLE
"""
import sys
from sys import stdin
input = stdin.readline
from collections import namedtuple
class DisjointSet(object):
def __init__(self, size):
self.rank = []
self.p = []
for i in range(size)... | p03682 |
#from collections import *
#from itertools import *
#from bisect import *
from heapq import *
#import copy
#N=int(input())
#X,Y=map(int,input().split()))
#S=list(map(int,input().split()))
#S=[list(map(int,input().split())) for i in range(N)]
class UnionFind():
def __init__(self, n):
self.n = n
... | #from collections import *
#from itertools import *
#from bisect import *
from heapq import *
#import copy
#N=int(input())
#X,Y=map(int,input().split()))
#S=list(map(int,input().split()))
#S=[list(map(int,input().split())) for i in range(N)]
N=int(eval(input()))
Xsort=[]
Ysort=[]
for i in range(N):
... | p03682 |
# atcoder problem solving
# Built?
N = int(eval(input()))
d = []
graph = [[] for i in range(N+1)]
for i in range(N):
x, y = list(map(int, input().split()))
d.append((i+1, x, y))
edge = []
# x座標に関する辺の設定
d.sort(key=lambda x: x[1])
for i in range(N-1):
a, px, py = d[i]
b, qx, qy = ... | # atcoder problem solving
# Built?
import sys
input=sys.stdin.readline
N = int(eval(input()))
d = []
for i in range(N):
x, y = list(map(int, input().split()))
d.append((i+1, x, y))
edge = []
# x座標に関する辺の設定
d.sort(key=lambda x: x[1])
for i in range(N-1):
a, px, py = d[i]
b, qx, q... | p03682 |
N = int(eval(input()))
xys = []
for i in range(N):
x, y = list(map(int, input().split()))
xys.append((x, y))
Isx = sorted(list(range(N)), key=lambda i: (xys[i][0], xys[i][1]))
Isy = sorted(list(range(N)), key=lambda i: (xys[i][1], xys[i][0]))
#print(Isx)
#print(Isy)
M = set()
for i in range(N):
p, q = ... | N = int(eval(input()))
xys = []
for i in range(N):
x, y = list(map(int, input().split()))
xys.append((x, y))
Isx = sorted(list(range(N)), key=lambda i: (xys[i][0], xys[i][1]))
Isy = sorted(list(range(N)), key=lambda i: (xys[i][1], xys[i][0]))
#print(Isx)
#print(Isy)
M = set()
for i in range(1, N):
p, q... | p03682 |
from operator import itemgetter
n = int(eval(input()))
x =[]
y =[]
info = [list(map(int,input().split())) for i in range(n)]
for i in range(n):
x.append([i,info[i][0]])
y.append([i,info[i][1]])
x = sorted(x,key=itemgetter(1))
y = sorted(y,key=itemgetter(1))
tree = []
for i in range(n-1):
tree.ap... | from operator import itemgetter
n = int(eval(input()))
x =[]
y =[]
info = [list(map(int,input().split())) for i in range(n)]
for i in range(n):
x.append([i,info[i][0]])
y.append([i,info[i][1]])
x = sorted(x,key=itemgetter(1))
y = sorted(y,key=itemgetter(1))
tree = []
#for i in range(n):
# if i==0:
#... | p03682 |
from itertools import accumulate
from math import*
from collections import deque
from collections import defaultdict
from itertools import permutations
from heapq import*
from collections import Counter
from itertools import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = 10**18
... | n = int(eval(input()))
xy = [[i] + list(map(int,input().split())) for i in range(n)]
xy.sort(key=lambda x:x[1])
edge = []
for i in range(n-1):
i1,x1,y1 = xy[i]
i2,x2,y2 = xy[i+1]
edge.append((x2-x1,i1,i2))
xy.sort(key=lambda x:x[2])
for i in range(n-1):
i1,x1,y1 = xy[i]
i2,x2,y2 = xy... | p03682 |
n = int(eval(input()))
x,y = [],[]
for i in range(n):
a,b = list(map(int,input().split()))
x.append([a,i])
y.append([b,i])
x.sort()
y.sort()
g = [[] for _ in range(n)]
for i in range(n-1):
g[x[i][1]].append([abs(x[i+1][0]-x[i][0]),x[i+1][1]])
g[x[i+1][1]].append([abs(x[i+1][0]-x[i][0]),x[... | n = int(eval(input()))
x,y = [],[]
for i in range(n):
a,b = list(map(int,input().split()))
x.append([a,i])
y.append([b,i])
x.sort()
y.sort()
g = [[] for _ in range(n)]
for i in range(n-1):
g[x[i][1]].append([abs(x[i+1][0]-x[i][0]),x[i+1][1]])
g[x[i+1][1]].append([abs(x[i+1][0]-x[i][0]),x[... | p03682 |
N = int(eval(input()))
xy = [[int(_) for _ in input().split()] for i in range(N)]
xsort_n = sorted(list(range(N)), key=lambda n:xy[n][0])
ysort_n = sorted(list(range(N)), key=lambda n:xy[n][1])
from collections import defaultdict
neighbors = defaultdict(list)
for i in range(N - 1):
x1 = xsort_n[i]
... | N = int(eval(input()))
xy = [[int(_) for _ in input().split()] for i in range(N)]
xsort_n = sorted(list(range(N)), key=lambda n:xy[n][0])
ysort_n = sorted(list(range(N)), key=lambda n:xy[n][1])
from collections import defaultdict
neighbors = defaultdict(list)
for i in range(N - 1):
x1 = xsort_n[i]
... | p03682 |
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 20 21:40:30 2018
ABC065D
@author: maezawa
i=0...n (0-origin)
"""
import heapq
n = int(eval(input()))
a = []
b = []
for i in range(n): # i is a name of the city (0-origin)
xy = list(map(int, input().split()))
a.append([xy[0],i])
b.append([xy[1],i... | # -*- coding: utf-8 -*-
"""
Created on Thu Sep 20 21:40:30 2018
ABC065D
@author: maezawa
i=0...n (0-origin)
"""
import heapq
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = []
b = []
for i in range(n): # i is a name of the city (0-origin)
xy = list(map(int, input().split()))
a.... | p03682 |
import heapq
def want_p(n):
Q = []
while n != p[n]:
Q.append(n)
n = p[n]
for i in Q:
p[i] = n
return n
N = int(eval(input()))
xyi = []
yxi = []
for i in range(N):
x,y = list(map(int,input().split()))
xyi.append([x,y,i])
yxi.append([y... |
def want_p(n):
Q = []
while n != p[n]:
Q.append(n)
n = p[n]
for i in Q:
p[i] = n
return n
N = int(eval(input()))
xyi = []
yxi = []
for i in range(N):
x,y = list(map(int,input().split()))
xyi.append([x,y,i])
yxi.append([y,x,i])
xyi.... | p03682 |
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdi... | import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdi... | p03682 |
def find_parent(x):
y=parent[x]
if y<0:
return x
parent[x]=find_parent(y)
return parent[x]
def connect(a,b):
c=find_parent(a)
d=find_parent(b)
if c==d:
return
if parent[c]<parent[d]:
parent[c]+=parent[d]
parent[d]=c
else:
paren... | import sys
input=sys.stdin.readline
def find_parent(x):
y=parent[x]
if y<0:
return x
parent[x]=find_parent(y)
return parent[x]
def connect(a,b):
c=find_parent(a)
d=find_parent(b)
if c==d:
return
if parent[c]<parent[d]:
parent[c]+=parent[d]
... | p03682 |
import itertools
import heapq
from heapq import heappush, heappop
global G
def input_graph(N, xy):
global G
comb_list = list(itertools.combinations(xy, 2))
for i in range(N*(N-1)//2):
a, b = comb_list[i]
an, axy = a
ax, ay = axy
bn, bxy = b
bx, by = bxy
cost = min(abs(ax-bx... | import itertools
import heapq
from heapq import heappush, heappop
global G, inp_x, inp_y
def input_graph(N):
global G, inp_x, inp_y
inp_x = []
inp_y = []
for i in range(N):
x, y = list(map(int, input().split()))
inp_x.append((x, i))
inp_y.append((y, i))
inp_x.sort()
inp_y.sort()
... | p03682 |
import heapq
n = int(eval(input()))
graph = [[] for _ in range(n)]
x_list = []
y_list = []
for i in range(n):
x, y = list(map(int, input().split()))
x_list += [[x, i]]
y_list += [[y, i]]
x_list.sort()
y_list.sort()
for i in range(n-1):
xs = x_list[i][1]
xt = x_list[i+1][1]
ys = y_list[i][1... | import itertools
import heapq
from heapq import heappush, heappop
global G, inp_x, inp_y
def input_graph(N):
global G, inp_x, inp_y
inp_x = []
inp_y = []
for i in range(N):
x, y = list(map(int, input().split()))
inp_x.append((x, i))
inp_y.append((y, i))
inp_x.sort()
inp_y.sort()
... | p03682 |
import heapq
n = int(eval(input()))
stw = []
x_list = []
y_list = []
for i in range(n):
x, y = list(map(int, input().split()))
x_list += [[x, i]]
y_list += [[y, i]]
x_list.sort()
y_list.sort()
for i in range(n-1):
xs = x_list[i][1]
xt = x_list[i+1][1]
ys = y_list[i][1]
yt = y_list[i+1][1]... |
import heapq
n = int(eval(input()))
stw = []
x_list = []
y_list = []
for i in range(n):
x, y = list(map(int, input().split()))
x_list += [[x, i]]
y_list += [[y, i]]
x_list.sort()
y_list.sort()
for i in range(n-1):
xs = x_list[i][1]
xt = x_list[i+1][1]
ys = y_list[i][1]
yt = y_list[i+1][1]... | p03682 |
import heapq
n = int(eval(input()))
stw = []
x_list = []
y_list = []
for i in range(n):
x, y = list(map(int, input().split()))
x_list += [[x, i]]
y_list += [[y, i]]
x_list.sort()
y_list.sort()
for [u, fr], [v, to] in zip(x_list, x_list[1:]):
stw += [[abs(u-v), fr, to]]
for [u, fr], [v, to] in zip... | n = int(eval(input()))
stw = []
x_list = []
y_list = []
for i in range(n):
x, y = list(map(int, input().split()))
x_list += [[x, i]]
y_list += [[y, i]]
x_list.sort()
y_list.sort()
for [u, fr], [v, to] in zip(x_list, x_list[1:]):
stw += [[abs(u-v), fr, to]]
for [u, fr], [v, to] in zip(y_list, y_lis... | p03682 |
import heapq
n = int(eval(input()))
stw = []
x_list = []
y_list = []
for i in range(n):
x, y = list(map(int, input().split()))
x_list += [[x, i]]
y_list += [[y, i]]
x_list.sort()
y_list.sort()
for i in range(n-1):
stw += [[x_list[i][1], x_list[i+1][1], abs(x_list[i][0]-x_list[i+1][0])]]
for i... | class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.Find_R... | p03682 |
# ABC065D
import sys
input=sys.stdin.readline
import heapq
class UnionFind:
def __init__(self, n):
self.p=[-1]*n
self.size=[1]*n
def root(self, x):
st=set()
while(self.p[x]>=0):
st.add(x)
x=self.p[x]
for y in st:
self.... | # ABC065D
import sys
input=sys.stdin.readline
import heapq
class UnionFind:
def __init__(self, n):
self.p=[-1]*n
self.size=[1]*n
def root(self, x):
st=set()
while(self.p[x]>=0):
st.add(x)
x=self.p[x]
for y in st:
self.... | p03682 |
import heapq
n=int(eval(input()))
pts=[list(map(int,input().split())) for _ in range(n)]
x=sorted([(i,pts[i][0]) for i in range(n)],key=lambda x:x[1])
y=sorted([(i,pts[i][1]) for i in range(n)],key=lambda x:x[1])
invx=[0]*n
invy=[0]*n
for i in range(n):
cx,_=x[i]
invx[cx]=i
cy,_=y[i]
... | import heapq
n=int(eval(input()))
pts=[list(map(int,input().split())) for _ in range(n)]
x=sorted([(i,pts[i][0]) for i in range(n)],key=lambda x:x[1])
y=sorted([(i,pts[i][1]) for i in range(n)],key=lambda x:x[1])
invx=[0]*n
invy=[0]*n
for i in range(n):
invx[x[i][0]]=i
invy[y[i][0]]=i
q=[(0,... | p03682 |
'''
https://atcoder.jp/contests/abc065/tasks/arc076_b
最小全域木を考える際にある頂点について他の頂点への最小コストを
考えて繋げていくのは間違い(全域木になる保証がない)
考えたいのはあくまでも全辺のコスト
今回はxとyでそれぞれソートして隣り合う2点のコストのみを考えれば良い
'''
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque... | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate
#from itertools import product
from bisect import bisect_left... | p03682 |
import operator
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() ... | import operator
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() ... | p03682 |
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_roo... | # 6199094
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... | p03682 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.