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 = []
id2pos = {i : tuple(j) for i, j in enumerate(city_ls)}
pos2id = {j : i for i, j in list(id2pos.items())}
for i in range(len(sort_by_x)-1):
current_by_x = sort_by_x[i]
next_by_x = sort_by_x[i + 1]
G.append((abs(current_by_x[0] - next_by_x[0]),current_by_x, next_by_x))
sort_by_x.sort(key=lambda x:x[1])
for i in range(len(sort_by_x) - 1):
current_by_x = sort_by_x[i]
next_by_x = sort_by_x[i + 1]
G.append((abs(current_by_x[1] - next_by_x[1]), current_by_x, next_by_x))
G.sort(key=lambda x:x[0])
sum_cost = 0
par = [i for i in range(N)]
rank = [1 for i in range(N)]
def find(x):
if par[x] == x:
return x
else:
return find(par[x])
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
pass
else:
if rank[x] > rank[y]:
par[y] = x
rank[x] += rank[y]
else:
par[x] = par[y]
rank[y] += rank[x]
def is_same(x, y):
if find(x) == find(y):
return True
else:
return False
for i in G:
(cost, _from, _to) = i
_from = pos2id[tuple(_from)]
_to = pos2id[tuple(_to)]
if is_same(_from, _to):
continue
unite(_from, _to)
sum_cost += cost
print(sum_cost)
|
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_by_x = sort_by_x[i]
next_by_x = sort_by_x[i + 1]
G.append((abs(current_by_x[0] - next_by_x[0]),current_by_x, next_by_x))
sort_by_x.sort(key=lambda x:x[1])
for i in range(len(sort_by_x) - 1):
current_by_x = sort_by_x[i]
next_by_x = sort_by_x[i + 1]
G.append((abs(current_by_x[1] - next_by_x[1]), current_by_x, next_by_x))
G.sort(key=lambda x:x[0])
sum_cost = 0
par = [i for i in range(N)]
rank = [1 for i in range(N)]
def find(x):
if par[x] == x:
return x
else:
return find(par[x])
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
pass
else:
if rank[x] > rank[y]:
par[y] = x
rank[x] += rank[y]
else:
par[x] = par[y]
rank[y] += rank[x]
def is_same(x, y):
if find(x) == find(y):
return True
else:
return False
for i in G:
(cost, _from, _to) = i
_from = pos2id[tuple(_from)]
_to = pos2id[tuple(_to)]
if is_same(_from, _to):
continue
unite(_from, _to)
sum_cost += cost
print(sum_cost)
|
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)
def unite(self, a, b):
a = self.find(a)
b = self.find(b)
if self.rank[a] < self.rank[b]:
a, b = b, a
self.par[b] = a
if self.rank[a] == self.rank[b]:
self.rank[a] += 1
def find(self, a):
if a == self.par[a]:
return a
self.par[a] = self.find(self.par[a])
return self.par[a]
Edge = namedtuple('Edge', 'w s t')
X = namedtuple('X', 'x i')
Y = namedtuple('Y', 'y i')
N = int(eval(input()))
edges = []
xg = []
yg = []
for i in range(N):
x, y = list(map(int, input().split()))
xg.append(X(x, i))
yg.append(Y(y, i))
xg.sort()
yg.sort()
for i in range(N - 1):
x1, a = xg[i]
x2, b = xg[i + 1]
heappush(edges, Edge(abs(x1 - x2), a, b))
for i in range(N - 1):
y1, a = yg[i]
y2, b = yg[i + 1]
heappush(edges, Edge(abs(y1 - y2), a, b))
u = UnionFind(N)
cost = 0
while edges:
w, s, t = heappop(edges)
if u.is_same(s, t):
continue
u.unite(s, t)
cost += w
print(cost)
|
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] < self.size[b]:
a, b = b, a
self.par[b] = a
self.size[a] += self.size[b]
def size_of(self, a):
return self.size[self.find(a)]
def find(self, a):
if a == self.par[a]:
return a
self.par[a] = self.find(self.par[a])
return self.par[a]
Edge = namedtuple('Edge', 'w s t')
X = namedtuple('X', 'x i')
Y = namedtuple('Y', 'y i')
N = int(eval(input()))
edges = []
xg = []
yg = []
for i in range(N):
x, y = list(map(int, input().split()))
xg.append(X(x, i))
yg.append(Y(y, i))
xg.sort()
yg.sort()
for i in range(N - 1):
x1, a = xg[i]
x2, b = xg[i + 1]
edges.append(Edge(abs(x1 - x2), a, b))
for i in range(N - 1):
y1, a = yg[i]
y2, b = yg[i + 1]
edges.append(Edge(abs(y1 - y2), a, b))
edges.sort()
u = UnionFind(N)
cost = 0
for w, s, t in edges:
if u.is_same(s, t):
continue
u.unite(s, t)
cost += w
print(cost)
|
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 union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
x = self.find(x)
return self.size[x]
from heapq import heapify, heappop, heappush
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();Y.sort()
dx = [];dy =[]
for i in range(N-1):
tx = X[i+1][0]-X[i][0]
dx.append((tx,(X[i+1][1],X[i][1])))
ty = Y[i+1][0]-Y[i][0]
dy.append((ty,(Y[i+1][1],Y[i][1])))
heapify(dx);heapify(dy)
#print(dx,dy)
visited = set([])
ans = 0
uf = UnionFind(N)
while uf.get_size(0) < N:
if not dy or dx[0] <= dy[0]:
cost, loc = heappop(dx)
else:
cost, loc = heappop(dy)
if uf.is_same(loc[0],loc[1]): #すでに接続済みのところはスキップ
continue
ans += cost
#print(cost)
uf.union(loc[0],loc[1])
print(ans)
|
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 union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
x = self.find(x)
return self.size[x]
import sys
input = sys.stdin.readline
from heapq import heapify, heappop, heappush
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();Y.sort()
dx = [];dy =[]
for i in range(N-1):
tx = X[i+1][0]-X[i][0]
dx.append((tx,(X[i+1][1],X[i][1])))
ty = Y[i+1][0]-Y[i][0]
dy.append((ty,(Y[i+1][1],Y[i][1])))
heapify(dx);heapify(dy)
#print(dx,dy)
visited = set([])
ans = 0
uf = UnionFind(N)
while uf.get_size(0) < N:
if not dy or dx[0] <= dy[0]:
cost, loc = heappop(dx)
else:
cost, loc = heappop(dy)
if uf.is_same(loc[0],loc[1]): #すでに接続済みのところはスキップ
continue
ans += cost
#print(cost)
uf.union(loc[0],loc[1])
print(ans)
|
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 union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
x = self.find(x)
return self.size[x]
import sys
input = sys.stdin.readline
from heapq import heapify, heappop, heappush
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();Y.sort()
dx = [];dy =[]
for i in range(N-1):
tx = X[i+1][0]-X[i][0]
dx.append((tx,(X[i+1][1],X[i][1])))
ty = Y[i+1][0]-Y[i][0]
dy.append((ty,(Y[i+1][1],Y[i][1])))
heapify(dx);heapify(dy)
#print(dx,dy)
visited = set([])
ans = 0
uf = UnionFind(N)
while uf.get_size(0) < N:
if not dy or dx[0] <= dy[0]:
cost, loc = heappop(dx)
else:
cost, loc = heappop(dy)
if uf.is_same(loc[0],loc[1]): #すでに接続済みのところはスキップ
continue
ans += cost
#print(cost)
uf.union(loc[0],loc[1])
print(ans)
|
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
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
"""
x と y のグループを結合
"""
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
"""
x と y が同じグループか否か
"""
return self.find(x) == self.find(y)
def get_size(self, x):
"""
x が属するグループの要素数
"""
x = self.find(x)
return self.size[x]
from heapq import heapify, heappop, heappush
N = int(eval(input()))
X = [];Y = []
for i in range(N):
a,b = list(map(int,input().split()))
X.append((a,b,i))
Y.append((a,b,i))
X.sort(key=lambda x:x[0])
Y.sort(key=lambda x:x[1])
#print(X,Y)
PQ = []
for i in range(N-1):
difx = (X[i+1][0]-X[i][0],X[i][2],X[i+1][2])
dify = (Y[i+1][1]-Y[i][1],Y[i][2],Y[i+1][2])
#print(difx,dify)
heappush(PQ,difx);heappush(PQ,dify)
uf = UnionFind(N)
ans = 0
while PQ:
dis,a,b = heappop(PQ)
if uf.is_same(a, b):
continue
ans += dis
uf.union(a,b)
print(ans)
|
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)
hq=[]
for i in range(1,N):
x1,y1=xylist[i-1]
x2,y2=xylist[i]
heapq.heappush(hq,(min(abs(x2-x1),abs(y1-y2)),(x1,y1),(x2,y2)))
y1,x1=yxlist[i-1]
y2,x2=yxlist[i]
heapq.heappush(hq,(min(abs(x2-x1),abs(y1-y2)),(x1,y1),(x2,y2)))
#print(hq)
def get_par(x):
if x == par_dic[x]:
return x
else:
par_dic[x] = get_par(par_dic[x])
return par_dic[x]
def merge(x,y):
par_x = get_par(x)
par_y = get_par(y)
if par_x != par_y:
par_dic[par_y] = par_x
def is_same(x,y):
return get_par(x) == get_par(y)
answer=0
while hq:
d,p1,p2=heapq.heappop(hq)
#print(d,p1,p2)
if not is_same(p1,p2):
merge(p1,p2)
answer+=d
print(answer)
|
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 in range(1,N):
x1,y1=xylist[i-1]
x2,y2=xylist[i]
elist.append((min(abs(x2-x1),abs(y1-y2)),(x1,y1),(x2,y2)))
y1,x1=yxlist[i-1]
y2,x2=yxlist[i]
elist.append((min(abs(x2-x1),abs(y1-y2)),(x1,y1),(x2,y2)))
#print(hq)
elist.sort(reverse=True)
def get_par(x):
if x == par_dic[x]:
return x
else:
par_dic[x] = get_par(par_dic[x])
return par_dic[x]
def merge(x,y):
par_x = get_par(x)
par_y = get_par(y)
if par_x != par_y:
par_dic[par_y] = par_x
def is_same(x,y):
return get_par(x) == get_par(y)
answer=0
while elist:
d,p1,p2=elist.pop()
#print(d,p1,p2)
if not is_same(p1,p2):
merge(p1,p2)
answer+=d
print(answer)
|
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]
b,y = cityx[i+1]
side[x].append([b-a,y])
side[y].append([b-a,x])
for i in range(N-1):
a,x = cityy[i]
b,y = cityy[i+1]
side[x].append([b-a,y])
side[y].append([b-a,x])
f = [1] + [0] * (N-1)
queue = side[0][:]
ans = 0
heapq.heapify(queue)
while queue:
cost, q = heapq.heappop(queue)
if f[q] == 0:
ans += cost
f[q] = 1
for a,b in side[q]:
heapq.heappush(queue,[a,b])
print(ans)
|
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([cityx[i+1][0]-cityx[i][0], cityx[i+1][1], cityx[i][1]])
side.append([cityy[i+1][0]-cityy[i][0], cityy[i+1][1], cityy[i][1]])
side.sort()
ans = 0
per = [i for i in range(N)]
rank = [0]*N
def find(x):
if per[x] == x:
return x
else:
per[x] = find(per[x])
return per[x]
ans = 0
for cost,x,y in side:
x = find(x)
y = find(y)
if x != y:
ans += cost
if rank[x] < rank[y]:
per[x] = y
else:
per[y] = x
if rank[x] == rank[y]:
rank[x] += 1
print(ans)
|
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=heapq.heappop(hqy)
heapq.heappush(edges,(x-prex,prexi,xi))
heapq.heappush(edges,(y-prey,preyi,yi))
prex,prexi=x,xi
prey,preyi=y,yi
frag=list(range(n+1))
fragnum=[0]*(n+1)
#以下でフラグ建設 フラグが同じなら同じチームである
def takefrag(p):
stock=[]
while frag[frag[p]]!=frag[p]:
stock.append(p)
p=frag[p]
p=frag[p]
for i in stock:
frag[i]=p
return p
count=0
ans=0
while True:
cost,a,b=heapq.heappop(edges)
f1,f2 = list(map(takefrag,(a,b)))
if f1!=f2:
count+=1
f1,f2 = min(f1,f2),max(f1,f2)
frag[f1]=f2
ans+=cost
if count==n-1:
break
print(ans)
|
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))
edges.append((y-prey,preyi,yi))
prex,prexi=x,xi
prey,preyi=y,yi
edges.sort()
frag=list(range(n+1))
fragnum=[0]*(n+1)
def takefrag(p):
stock=[]
while frag[frag[p]]!=frag[p]:
stock.append(p)
p=frag[p]
p=frag[p]
for i in stock:
frag[i]=p
return p
count=0
ans=0
for i in range(2*n):
cost,a,b=edges[i]
f1,f2 = list(map(takefrag,(a,b)))
if f1!=f2:
count+=1
f1,f2 = min(f1,f2),max(f1,f2)
frag[f1]=f2
ans+=cost
if count==n-1:
break
print(ans)
|
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 = 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()))
edge = [[] for i in range(n)]
#隣接リスト edge[i]:[コスト,行先]
l=[]
for i in range(n):
a,b=list(map(int,input().split()))
l.append([a,b,i])
l=sorted(l,key=lambda x: -x[0])
for i in range(n-1):
x=l[i][2]
y=l[i+1][2]
z=l[i][0]-l[i+1][0]
edge[x].append([z,y])
edge[y].append([z,x])
l=sorted(l,key=lambda x: -x[1])
for i in range(n-1):
x=l[i][2]
y=l[i+1][2]
z=l[i][1]-l[i+1][1]
edge[x].append([z,y])
edge[y].append([z,x])
print((prim_heap()))
|
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]]:
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()))
edge = [[] for i in range(n)]
#隣接リスト edge[i]:[コスト,行先]
l=[]
for i in range(n):
a,b=list(map(int,input().split()))
l.append([a,b,i])
l=sorted(l,key=lambda x: -x[0])
for i in range(n-1):
x=l[i][2]
y=l[i+1][2]
z=l[i][0]-l[i+1][0]
edge[x].append([z,y])
edge[y].append([z,x])
l=sorted(l,key=lambda x: -x[1])
for i in range(n-1):
x=l[i][2]
y=l[i+1][2]
z=l[i][1]-l[i+1][1]
edge[x].append([z,y])
edge[y].append([z,x])
print((prim_heap()))
|
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]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
ls = []
rs = []
ind = 0
inds = dict()
for _ in range(N):
x,y = list(map(int,input().split()))
if (x,y) not in list(inds.keys()):
ls.append((x,y))
rs.append((y,x))
inds[(x,y)] = ind
ind += 1
N = ind
ls.sort()
rs.sort()
uf = UnionFind(N)
edges = []
for i in range(N-1):
x = ls[i][0]
a = ls[i+1][0]
y = ls[i][1]
b = ls[i+1][1]
d = min(abs(x-a), abs(y-b))
edges.append((d,(x,y),(a,b)))
x = rs[i][1]
a = rs[i+1][1]
y = rs[i][0]
b = rs[i+1][0]
d = min(abs(x-a), abs(y-b))
edges.append((d,(x,y),(a,b)))
edges.sort(key=lambda x:x[0])
ans = 0
for d,i,j in edges:
# 閉路ができない場合追加する
if not uf.same(inds[i],inds[j]):
uf.unite(inds[i],inds[j])
ans += d
print(ans)
|
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(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
# union by rank
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
if __name__ == "__main__":
N = int(eval(input()))
vs = []
for i in range(N):
x,y = list(map(int,input().split()))
vs.append((x,y,i))
vs.sort()
edges = []
for k in range(1, N):
x,y,i = vs[k]
a,b,j = vs[k-1]
edges.append((i, j, min(abs(x-a),abs(y-b))))
vs.sort(key=lambda x:x[1])
for k in range(1, N):
x,y,i = vs[k]
a,b,j = vs[k-1]
edges.append((i, j, min(abs(x-a),abs(y-b))))
uf = UnionFind(N)
edges.sort(key=lambda x:x[2])
ans = 0
for i,j,w in edges:
if not uf.same(i,j):
uf.unite(i,j)
ans += w
print(ans)
|
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)
# uとpred[u]を結ぶ辺の重みがkey[u]に入る
key = collections.defaultdict(lambda: INF)
key[0] = 0
# 二分ヒープを優先度付きキューとして用いる
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# 優先度付きキューに頂点が入っているかを示す配列
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq[v] = True
return (pred, key)
def main():
n = int(eval(input()))
z = []
for i in range(n): # h:高さ
z.append([int(m) for m in input().split()] + [i])
zx = sorted(z, key=lambda x: (x[0]))
zy = sorted(z, key=lambda x: (x[1]))
# 最小木問題をプリム法で解く
# 点群を発生
p = [[zx[i][2], zx[i + 1][2], min(abs(zx[i][0] - zx[i + 1][0]), abs(zx[i][1] - zx[i + 1][1]))] for i in range(n - 1)]
p += [[zy[i][2], zy[i + 1][2], min(abs(zy[i][0] - zy[i + 1][0]), abs(zy[i][1] - zy[i + 1][1]))] for i in range(n - 1)]
max_v, max_e = n, len(p)
adjacency_list = collections.defaultdict(set)
for i in range(max_e):
s, t, w = p[i][0], p[i][1], p[i][2]
adjacency_list[s].add(AdjacentVertex(t, w))
adjacency_list[t].add(AdjacentVertex(s, w))
(_, key) = compute_mst_prim(max_v, adjacency_list)
print((sum(key.values())))
if __name__ == '__main__':
main()
|
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]
t2 = towns[i + 1][0]
cost = min(abs(towns[i + 1][1] - towns[i][1]), abs(towns[i + 1][2] - towns[i][2]))#towns[i + 1][xy] - towns[i][xy]
adj[t1].append((t2, cost))
adj[t2].append((t1, cost))
# 最小全域木を求める（プリム法）
import heapq
pq = []
heapq.heappush(pq, (0, 0))
done = set()
ans = 0
while pq:
cost, v_now = heapq.heappop(pq)
if v_now in done:
continue
ans += cost
done.add(v_now)
if len(done) == N:
break
for v, c in adj[v_now]:
if v not in done:
heapq.heappush(pq, (c, v))
print(ans)
|
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
while len(edgelist) != 0:
short_edge = heappop(edgelist)
if not used[short_edge[1]]:
continue
v = short_edge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heappush(edgelist,e)
res += short_edge[0]
return res
n = int(eval(input()))
A = [list(map(int,input().split()))+[i] for i in range(n)]
A.append([-10**12,-10**12,-1])
A.append([10**12,10**12,-1])
X = sorted(A)
Y = sorted(A,key = itemgetter(1))
d = []
dapp = d.append
for i in range(1,n+1):
sx = X[i-1][0]
sy = Y[i-1][1]
mx = X[i][0]
my = Y[i][1]
lx = X[i+1][0]
ly = Y[i+1][1]
nsx = X[i-1][2]
nsy = Y[i-1][2]
nmx = X[i][2]
nmy = Y[i][2]
nlx = X[i+1][2]
nly = Y[i+1][2]
dapp((nsx,nmx,mx-sx))
dapp((nmx,nlx,lx-mx))
dapp((nsy,nmy,my-sy))
dapp((nmy,nly,ly-my))
edge = [[] for i in range(n)]
for x,y,z in d:
if x==-1 or y==-1:
continue
edge[x].append([z,y])
edge[y].append([z,x])
print((prim()))
if __name__ == '__main__':
main()
|
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
while len(edgelist) != 0:
short_edge = heappop(edgelist)
if not used[short_edge[1]]:
continue
v = short_edge[1]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heappush(edgelist,e)
res += short_edge[0]
return res
n = int(eval(input()))
A = [list(map(int,input().split()))+[i] for i in range(n)]
A.append([-10**12,-10**12,-1])
A.append([10**12,10**12,-1])
X = sorted(A)
Y = sorted(A,key = itemgetter(1))
edge = [[] for i in range(n)]
for i in range(1,n+1):
sx = X[i-1][0]
sy = Y[i-1][1]
mx = X[i][0]
my = Y[i][1]
lx = X[i+1][0]
ly = Y[i+1][1]
nsx = X[i-1][2]
nsy = Y[i-1][2]
nmx = X[i][2]
nmy = Y[i][2]
nlx = X[i+1][2]
nly = Y[i+1][2]
edge[nsx].append((mx-sx,nmx))
edge[nmx].append((mx-sx,nsx))
edge[nlx].append((lx-mx,nmx))
edge[nmx].append((lx-mx,nlx))
edge[nsy].append((my-sy,nmy))
edge[nmy].append((my-sy,nsy))
edge[nly].append((ly-my,nmy))
edge[nmy].append((ly-my,nly))
print((prim()))
if __name__ == '__main__':
main()
|
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
return self.p[x]
def unite(self, x, y):
x, y = self.root(x), self.root(y)
if x != y:
self.p[x] = y
self.components -= 1
def same(self, x,y):
return (self.root(x) == self.root(y))
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()
Y.sort()
edges = []
for i in range(N-1):
edges.append([X[i+1][0]-X[i][0], X[i][1], X[i+1][1]])
edges.append([Y[i+1][0]-Y[i][0], Y[i][1], Y[i+1][1]])
edges.sort()
UF = UnionFind(N)
ans = 0
for cost, s, t in edges:
if UF.same(s,t): continue
UF.unite(s,t)
ans += cost
print(ans)
|
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:
break
else:
stack.append(self.p[top])
for v in stack:
self.p[v] = top
return self.p[x]
def unite(self, x, y):
x, y = self.root(x), self.root(y)
if x != y:
self.p[x] = y
self.components -= 1
def same(self, x,y):
return (self.root(x) == self.root(y))
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()
Y.sort()
edges = []
for i in range(N-1):
edges.append([X[i+1][0]-X[i][0], X[i][1], X[i+1][1]])
edges.append([Y[i+1][0]-Y[i][0], Y[i][1], Y[i+1][1]])
edges.sort()
UF = UnionFind(N)
ans = 0
for cost, s, t in edges:
if UF.same(s,t): continue
UF.unite(s,t)
ans += cost
print(ans)
|
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] = self.find(self.parents[v])
return self.parents[v]
def unite(self, u, v): # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
u = self.find(u)
v = self.find(v)
if u == v:
return
if self.parents[u] > self.parents[v]: # u < v に統一する
u, v = v, u
self.parents[u] += self.parents[v]
self.parents[v] = u
def size(self, v): # vが属する集合の要素数
return -self.parents[self.find(v)]
def same(self, u, v): # uとvが同じ集合に属するか否か
return self.find(u) == self.find(v)
#############################################################
N = int(eval(input()))
XY = [list(map(int, input().split())) + [i] for i in range(N)]
X = sorted(XY, key=lambda x: x[0])
Y = sorted(XY, key=lambda x: x[1])
side = []
for i in range(N - 1):
# iとi+1の距離、iのindex, i+1のindex
side.append([X[i + 1][0] - X[i][0], X[i][2], X[i + 1][2]])
side.append([Y[i + 1][1] - Y[i][1], Y[i][2], Y[i + 1][2]])
ans = 0
side.sort(key=lambda x: x[0])
uf = UnionFind(N)
for cost, i, j in side:
if uf.same(i, j):
continue
uf.unite(i, j)
ans += cost
print(ans)
|
# 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] = self.find(self.parents[v])
return self.parents[v]
def unite(self, u, v): # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
u = self.find(u)
v = self.find(v)
if u == v:
return
if self.parents[u] > self.parents[v]: # u < v に統一する
u, v = v, u
self.parents[u] += self.parents[v]
self.parents[v] = u
def size(self, v): # vが属する集合の要素数
return -self.parents[self.find(v)]
def same(self, u, v): # uとvが同じ集合に属するか否か
return self.find(u) == self.find(v)
#############################################################
N = int(eval(input()))
XY = [list(map(int, input().split())) + [i] for i in range(N)]
X = sorted(XY, key=lambda x: x[0])
Y = sorted(XY, key=lambda x: x[1])
dist = []
for i in range(N - 1):
# iとi+1の距離、iのindex, i+1のindex
dist.append([X[i + 1][0] - X[i][0], X[i][2], X[i + 1][2]])
dist.append([Y[i + 1][1] - Y[i][1], Y[i][2], Y[i + 1][2]])
ans = 0
dist.sort(key=lambda x: x[0])
uf = UnionFind(N)
# クラスカル法
for cost, i, j in dist:
if uf.same(i, j):
continue
uf.unite(i, j)
ans += cost
print(ans)
|
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] = self.find(self.parents[v])
return self.parents[v]
def unite(self, u, v): # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
u = self.find(u)
v = self.find(v)
if u == v:
return
if self.parents[u] > self.parents[v]: # u < v に統一する
u, v = v, u
self.parents[u] += self.parents[v]
self.parents[v] = u
def size(self, v): # vが属する集合の要素数
return -self.parents[self.find(v)]
def same(self, u, v): # uとvが同じ集合に属するか否か
return self.find(u) == self.find(v)
#############################################################
N = int(eval(input()))
XY = [list(map(int, input().split())) + [i] for i in range(N)]
X = sorted(XY, key=lambda x: x[0])
Y = sorted(XY, key=lambda x: x[1])
dist = []
for i in range(N - 1):
# iとi+1の距離、iのindex, i+1のindex
dist.append([X[i + 1][0] - X[i][0], X[i][2], X[i + 1][2]])
dist.append([Y[i + 1][1] - Y[i][1], Y[i][2], Y[i + 1][2]])
ans = 0
dist.sort(key=lambda x: x[0])
uf = UnionFind(N)
# クラスカル法
for cost, i, j in dist:
if uf.same(i, j):
continue
uf.unite(i, j)
ans += cost
print(ans)
|
# 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] = self.find(self.parents[v])
return self.parents[v]
def unite(self, u, v): # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
u = self.find(u)
v = self.find(v)
if u == v:
return
if self.parents[u] > self.parents[v]: # u < v に統一する
u, v = v, u
self.parents[u] += self.parents[v]
self.parents[v] = u
def size(self, v): # vが属する集合の要素数
return -self.parents[self.find(v)]
def same(self, u, v): # uとvが同じ集合に属するか否か
return self.find(u) == self.find(v)
#############################################################
import sys
input = sys.stdin.readline
N = int(eval(input()))
XY = [list(map(int, input().split())) + [i] for i in range(N)]
X = sorted(XY, key=lambda x: x[0])
Y = sorted(XY, key=lambda x: x[1])
dist = []
for i in range(N - 1):
# iとi+1の距離、iのindex, i+1のindex
dist.append([X[i + 1][0] - X[i][0], X[i][2], X[i + 1][2]])
dist.append([Y[i + 1][1] - Y[i][1], Y[i][2], Y[i + 1][2]])
ans = 0
dist.sort(key=lambda x: x[0])
uf = UnionFind(N)
# クラスカル法
for cost, i, j in dist:
if uf.same(i, j):
continue
uf.unite(i, j)
ans += cost
print(ans)
|
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][2], XY[i + 1][2])))
dist.sort()
root = [i for i in range(N + 1)]
comp_size = [1] * (N+1)
def root_find(x):
y = root[x]
if x == y:
return x
else:
z = root_find(y)
root[x] = z
return z
def merge(x, y):
rx = root_find(x)
ry = root_find(y)
sx = comp_size[rx]
sy = comp_size[ry]
if rx != ry:
if sx >= sy:
root[ry] = rx
comp_size[rx] = sx + sy
else:
root[rx] = ry
comp_size[ry] = sx + sy
answer = 0
for d, (a, b) in dist:
if root_find(a) != root_find(b):
merge(a, b)
answer += d
print(answer)
|
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):
dist.append((abs(XY[i][1] - XY[i + 1][1]), (XY[i][2], XY[i + 1][2])))
dist.sort()
root = [i for i in range(N + 1)]
comp_size = [1] * (N+1)
def root_find(x):
y = root[x]
if x == y:
return x
else:
z = root_find(y)
root[x] = z
return z
def merge(x, y):
rx = root_find(x)
ry = root_find(y)
sx = comp_size[rx]
sy = comp_size[ry]
if rx != ry:
if sx >= sy:
root[ry] = rx
comp_size[rx] = sx + sy
else:
root[rx] = ry
comp_size[ry] = sx + sy
answer = 0
for d, (a, b) in dist:
if root_find(a) != root_find(b):
merge(a, b)
answer += d
print(answer)
|
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]:
par[frm][0], frm = to, par[frm][0]
par[frm][0] = to
def get_par(par, p):
while par[p][0] != par[p][1]:
p = par[p][0]
return p
manhattan = lambda x,y:min(abs(x[0] - y[0]), abs(x[1]- y[1]))
N = int(eval(input()))
points = []
edges = []
for i in range(N):
x,y = list(map(int, input().split()))
points.append([i,i,[x,y]])
for j in range(i):
edges.append((abs(points[i][2][0] - points[j][2][0]), j, i))
edges.append((abs(points[i][2][1] - points[j][2][1]), j, i))
edges.sort(key=lambda x:x[0], reverse=True)
cost = 0
count = 0
while count < N - 1:
edge = edges.pop()
if get_par(points, edge[1]) == get_par(points, edge[2]):
continue
cost += edge[0]
count += 1
update_tree(points, edge[1], edge[2])
print(cost)
|
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]:
par[frm][0], frm = to, par[frm][0]
par[frm][0] = to
def get_par(par, p):
while par[p][0] != par[p][1]:
p = par[p][0]
return p
manhattan = lambda x,y:min(abs(x[0] - y[0]), abs(x[1]- y[1]))
N = int(eval(input()))
points = []
edges = []
for i in range(N):
x,y = list(map(int, input().split()))
points.append([i,i,[x,y]])
points.sort(key=lambda x:x[2][0])
for i in range(N-1):
edges.append((abs(points[i][2][0] - points[i+1][2][0]), points[i][1], points[i+1][1]))
points.sort(key=lambda x:x[2][1])
for i in range(N-1):
edges.append((abs(points[i][2][1] - points[i+1][2][1]), points[i][1], points[i+1][1]))
edges.sort(key=lambda x:x[0], reverse=True)
cost = 0
count = 0
points.sort()
while count < N - 1:
edge = edges.pop()
if get_par(points, edge[1]) == get_par(points, edge[2]):
continue
cost += edge[0]
count += 1
update_tree(points, edge[1], edge[2])
print(cost)
|
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]:
par[frm][0], frm = to, par[frm][0]
par[frm][0] = to
def get_par(par, p):
while par[p][0] != par[p][1]:
p = par[p][0]
return p
manhattan = lambda x,y:min(abs(x[0] - y[0]), abs(x[1]- y[1]))
N = int(eval(input()))
points = []
edges = []
for i in range(N):
x,y = list(map(int, input().split()))
points.append([i,i,[x,y]])
points.sort(key=lambda x:x[2][0])
for i in range(N-1):
edges.append((abs(points[i][2][0] - points[i+1][2][0]), points[i][1], points[i+1][1]))
points.sort(key=lambda x:x[2][1])
for i in range(N-1):
edges.append((abs(points[i][2][1] - points[i+1][2][1]), points[i][1], points[i+1][1]))
edges.sort(key=lambda x:x[0], reverse=True)
cost = 0
count = 0
points.sort()
while count < N - 1:
edge = edges.pop()
if get_par(points, edge[1]) == get_par(points, edge[2]):
continue
cost += edge[0]
count += 1
update_tree(points, edge[1], edge[2])
print(cost)
|
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(int, input().split()))
points.append([x,y,i])
points.sort()
for i in range(N-1):
edges.append((abs(points[i][0] - points[i+1][0]), points[i][2], points[i+1][2]))
points.sort(key=lambda x:x[1])
for i in range(N-1):
edges.append((abs(points[i][1] - points[i+1][1]), points[i][2], points[i+1][2]))
edges.sort(key=lambda x:x[0], reverse=True)
par = [None] * N
cost = 0
count = 0
points.sort()
while count < N - 1:
c, i, j = edges.pop()
if get_par(i) == get_par(j):
continue
unite(i, j)
cost += c
count += 1
print(cost)
|
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 = 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()))
zahyo = []
for i in range(n):
x,y = list(map(int,input().split()))
zahyo.append((x,y))
edge = [[] for i in range(n)]
#隣接リスト edge[i]:[コスト,行先]
for i in range(n-1):
for j in range(i+1,n):
c = min(abs(zahyo[i][0]-zahyo[j][0]),abs(zahyo[i][1]-zahyo[j][1]))
edge[j].append((c,i))
edge[i].append((c,j))
print((prim_heap()))
|
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 = 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()))
zahyo = []
for i in range(n):
x,y = list(map(int,input().split()))
zahyo.append((x,y,i))
xza = sorted(zahyo)
yza = sorted(zahyo,key=lambda x: x[1])
edge = [[] for i in range(n)]
#隣接リスト edge[i]:[コスト,行先]
for i in range(n-1):
c = abs(xza[i][0]-xza[i+1][0])
edge[xza[i][2]].append((c,xza[i+1][2]))
edge[xza[i+1][2]].append((c,xza[i][2]))
for i in range(n-1):
c = abs(yza[i][1]-yza[i+1][1])
edge[yza[i][2]].append((c,yza[i+1][2]))
edge[yza[i+1][2]].append((c,yza[i][2]))
print((prim_heap()))
|
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((X[i+1][0]-X[i][0], X[i+1][1]))
G[X[i+1][1]].append((X[i+1][0]-X[i][0], X[i][1]))
G[Y[i][1]].append((Y[i+1][0]-Y[i][0], Y[i+1][1]))
G[Y[i+1][1]].append((Y[i+1][0]-Y[i][0], Y[i][1]))
q = []
heapq.heapify(q)
for elem in G[0]:
heapq.heappush(q, elem)
used = [False] * N
used[0] = True
ans = 0
while q:
res = heapq.heappop(q)
cost, nq = res
if not used[nq]:
used[nq] = True
ans += cost
for elem in G[nq]:
heapq.heappush(q, elem)
print(ans)
|
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):
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 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
else:
return False
u = UnionFind(N)
q = []
for i in range(N-1):
q.append((X[i+1][0]-X[i][0], X[i+1][1], X[i][1]))
q.append((Y[i+1][0]-Y[i][0], Y[i+1][1], Y[i][1]))
q.sort(key=itemgetter(0))
ans = 0
for elem in q:
cost, a, b = elem
if u.union(a, b):
ans += cost
print(ans)
|
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]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if self.rank[xr] > self.rank[yr]:
self.parent[yr] = xr
elif self.rank[xr] < self.rank[yr]:
self.parent[xr] = yr
elif xr != yr:
self.parent[yr] = xr
self.rank[xr] += 1
from collections import defaultdict
from itertools import chain
from bisect import bisect
N = int(eval(input()))
points = tuple(tuple(map(int,input().split())) for _ in range(N))
ds = DisjointSet(N)
x_i = sorted((x,i) for i,(x,y) in enumerate(points))
y_i = sorted((y,i) for i,(x,y) in enumerate(points))
xr = [x_i[0]]
yr = [y_i[0]]
for (x0,i0),(x1,i1) in zip(x_i,x_i[1:]):
if x0 == x1:
ds.union(i0,i1)
else:
xr.append((x1,i1))
for (y0,i0),(y1,i1) in zip(y_i,y_i[1:]):
if y0 == y1:
ds.union(i0,i1)
else:
yr.append((y1,i1))
deltas = sorted(
chain(
((x1-x0,i0,i1) for (x0,i0), (x1,i1) in zip(xr,xr[1:])),
((y1-y0,i0,i1) for (y0,i0), (y1,i1) in zip(yr,yr[1:])),
)
)
def it():
for d,i0,i1 in deltas:
if ds.find(i0) != ds.find(i1):
ds.union(i0,i1)
yield d
print((sum(it())))
|
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]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if self.rank[xr] > self.rank[yr]:
self.parent[yr] = xr
elif self.rank[xr] < self.rank[yr]:
self.parent[xr] = yr
elif xr != yr:
self.parent[yr] = xr
self.rank[xr] += 1
from itertools import chain
N = int(eval(input()))
points = tuple(tuple(map(int,input().split())) for _ in range(N))
ds = DisjointSet(N)
x_i = sorted((x,i) for i,(x,y) in enumerate(points))
y_i = sorted((y,i) for i,(x,y) in enumerate(points))
xr = [x_i[0]]
yr = [y_i[0]]
for (x0,i0),(x1,i1) in zip(x_i,x_i[1:]):
if x0 == x1:
ds.union(i0,i1)
else:
xr.append((x1,i1))
for (y0,i0),(y1,i1) in zip(y_i,y_i[1:]):
if y0 == y1:
ds.union(i0,i1)
else:
yr.append((y1,i1))
deltas = sorted(
chain(
((x1-x0,i0,i1) for (x0,i0), (x1,i1) in zip(xr,xr[1:])),
((y1-y0,i0,i1) for (y0,i0), (y1,i1) in zip(yr,yr[1:])),
)
)
def it():
for d,i0,i1 in deltas:
if ds.find(i0) != ds.find(i1):
ds.union(i0,i1)
yield d
print((sum(it())))
|
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]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if self.rank[xr] > self.rank[yr]:
self.parent[yr] = xr
elif self.rank[xr] < self.rank[yr]:
self.parent[xr] = yr
elif xr != yr:
self.parent[yr] = xr
self.rank[xr] += 1
from itertools import chain
N = int(eval(input()))
points = tuple(tuple(map(int,input().split())) for _ in range(N))
ds = DisjointSet(N)
x_i = sorted((x,i) for i,(x,y) in enumerate(points))
y_i = sorted((y,i) for i,(x,y) in enumerate(points))
xr = [x_i[0]]
yr = [y_i[0]]
for (x0,i0),(x1,i1) in zip(x_i,x_i[1:]):
if x0 == x1:
ds.union(i0,i1)
else:
xr.append((x1,i1))
for (y0,i0),(y1,i1) in zip(y_i,y_i[1:]):
if y0 == y1:
ds.union(i0,i1)
else:
yr.append((y1,i1))
deltas = sorted(
chain(
((x1-x0,i0,i1) for (x0,i0), (x1,i1) in zip(xr,xr[1:])),
((y1-y0,i0,i1) for (y0,i0), (y1,i1) in zip(yr,yr[1:])),
)
)
def it():
for d,i0,i1 in deltas:
if ds.find(i0) != ds.find(i1):
ds.union(i0,i1)
yield d
print((sum(it())))
|
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:
parent[y] = x
return x
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if self.rank[xr] > self.rank[yr]:
self.parent[yr] = xr
elif self.rank[xr] < self.rank[yr]:
self.parent[xr] = yr
elif xr != yr:
self.parent[yr] = xr
self.rank[xr] += 1
from itertools import chain
N = int(eval(input()))
points = tuple(tuple(map(int,input().split())) for _ in range(N))
ds = DisjointSet(N)
x_i = sorted((x,i) for i,(x,y) in enumerate(points))
y_i = sorted((y,i) for i,(x,y) in enumerate(points))
xr = [x_i[0]]
yr = [y_i[0]]
for (x0,i0),(x1,i1) in zip(x_i,x_i[1:]):
if x0 == x1:
ds.union(i0,i1)
else:
xr.append((x1,i1))
for (y0,i0),(y1,i1) in zip(y_i,y_i[1:]):
if y0 == y1:
ds.union(i0,i1)
else:
yr.append((y1,i1))
deltas = sorted(
chain(
((x1-x0,i0,i1) for (x0,i0), (x1,i1) in zip(xr,xr[1:])),
((y1-y0,i0,i1) for (y0,i0), (y1,i1) in zip(yr,yr[1:])),
)
)
def it():
for d,i0,i1 in deltas:
i0,i1 = ds.find(i0), ds.find(i1)
if i0 != i1:
ds.union(i0,i1)
yield d
print((sum(it())))
|
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."""
r = self._root_table[x]
if r != x:
# Update the cache on query.
r = self._root_table[x] = self.find(r)
return r
def union(self, x, y):
"""Merges two groups."""
x = self.find(x)
y = self.find(y)
if x == y:
return
# Ensure that x is the larger (or equal) group.
if self._size_table[x] < self._size_table[y]:
x, y = y, x
self._size_table[x] += self._size_table[y]
self._root_table[y] = x
def size(self, x):
return self._size_table[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._root_table) if x == i]
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()))
cities, xs, ys = [], [], []
for i in range(N):
x, y = list(map(int, input().split()))
cities.append((x, y))
xs.append((x, i))
ys.append((y, i))
xs.sort()
ys.sort()
xd, yd = [], []
for i in range(1, N):
x1, c1 = xs[i - 1]
x2, c2 = xs[i]
if x2-x1 <= abs(cities[c1][1] - cities[c2][1]):
xd.append((x2 - x1, c1, c2))
y1, c1 = ys[i - 1]
y2, c2 = ys[i]
if y2-y1 <= abs(cities[c1][0] - cities[c2][0]):
xd.append((y2 - y1, c1, c2))
xd.sort()
uf = UnionFind(N)
xi = yi = 0
cost = 0
INF = 10**10
merged_cnt = 0
while xi < len(xd):
d1, c1, c2 = xd[xi]
if not uf.same(c1, c2):
uf.union(c1, c2)
cost += d1
merged_cnt += 1
if merged_cnt == N-1:
break
xi += 1
print(cost)
|
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 root node id."""
r = self._root_table[x]
if r != x:
# Update the cache on query.
r = self._root_table[x] = self.find(r)
return r
def union(self, x, y):
"""Merges two groups."""
x = self.find(x)
y = self.find(y)
if x == y:
return
# Ensure that x is the larger (or equal) group.
if self._size_table[x] < self._size_table[y]:
x, y = y, x
self._size_table[x] += self._size_table[y]
self._root_table[y] = x
def size(self, x):
return self._size_table[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._root_table) if x == i]
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())
input = sys.stdin.readline
def main():
N = int(eval(input()))
cities, xs, ys = [], [], []
for i in range(N):
x, y = list(map(int, input().split()))
cities.append((x, y))
xs.append((x, i))
ys.append((y, i))
xs.sort()
ys.sort()
xd, yd = [], []
for i in range(1, N):
x1, c1 = xs[i - 1]
x2, c2 = xs[i]
if x2 - x1 <= abs(cities[c1][1] - cities[c2][1]):
xd.append((x2 - x1, c1, c2))
y1, c1 = ys[i - 1]
y2, c2 = ys[i]
if y2 - y1 < abs(cities[c1][0] - cities[c2][0]):
xd.append((y2 - y1, c1, c2))
xd.sort()
uf = UnionFind(N)
cost = 0
merged_cnt = 0
for d1, c1, c2 in xd:
if not uf.same(c1, c2):
uf.union(c1, c2)
cost += d1
merged_cnt += 1
if merged_cnt == N - 1:
break
print(cost)
if __name__ == "__main__":
main()
|
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 root node id."""
r = self._root_table[x]
if r != x:
# Update the cache on query.
r = self._root_table[x] = self.find(r)
return r
def union(self, x, y):
"""Merges two groups."""
x = self.find(x)
y = self.find(y)
if x == y:
return
# Ensure that x is the larger (or equal) group.
if self._size_table[x] < self._size_table[y]:
x, y = y, x
self._size_table[x] += self._size_table[y]
self._root_table[y] = x
def size(self, x):
return self._size_table[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._root_table) if x == i]
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())
input = sys.stdin.readline
def main():
N = int(eval(input()))
cities, xs, ys = [], [], []
for i in range(N):
x, y = list(map(int, input().split()))
cities.append((x, y))
xs.append((x, i))
ys.append((y, i))
xs.sort()
ys.sort()
xd, yd = [], []
for i in range(1, N):
x1, c1 = xs[i - 1]
x2, c2 = xs[i]
if x2 - x1 <= abs(cities[c1][1] - cities[c2][1]):
xd.append((x2 - x1, c1, c2))
y1, c1 = ys[i - 1]
y2, c2 = ys[i]
if y2 - y1 < abs(cities[c1][0] - cities[c2][0]):
xd.append((y2 - y1, c1, c2))
xd.sort()
uf = UnionFind(N)
cost = 0
merged_cnt = 0
for d1, c1, c2 in xd:
if not uf.same(c1, c2):
uf.union(c1, c2)
cost += d1
merged_cnt += 1
if merged_cnt == N - 1:
break
print(cost)
if __name__ == "__main__":
main()
|
"""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
def find(self, x):
"""Returns x's root node id."""
r = self._root_table[x]
if r != x:
# Update the cache on query.
r = self._root_table[x] = self.find(r)
return r
def union(self, x, y):
"""Merges two groups."""
x = self.find(x)
y = self.find(y)
if x == y:
return
# Ensure that x is the larger (or equal) group.
if self._size_table[x] < self._size_table[y]:
x, y = y, x
self._size_table[x] += self._size_table[y]
self._root_table[y] = x
def size(self, x):
return self._size_table[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._root_table) if x == i]
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())
input = sys.stdin.readline
def main():
N = int(eval(input()))
cities, xs, ys = [], [], []
for i in range(N):
x, y = list(map(int, input().split()))
cities.append((x, y))
xs.append((x, i))
ys.append((y, i))
xs.sort()
ys.sort()
xd, yd = [], []
for i in range(1, N):
x1, c1 = xs[i - 1]
x2, c2 = xs[i]
if x2 - x1 <= abs(cities[c1][1] - cities[c2][1]):
xd.append((x2 - x1, c1, c2))
y1, c1 = ys[i - 1]
y2, c2 = ys[i]
if y2 - y1 < abs(cities[c1][0] - cities[c2][0]):
xd.append((y2 - y1, c1, c2))
xd.sort()
uf = UnionFind(N)
cost = 0
merged_cnt = 0
for d1, c1, c2 in xd:
if not uf.same(c1, c2):
uf.union(c1, c2)
cost += d1
merged_cnt += 1
if merged_cnt == N - 1:
break
print(cost)
if __name__ == "__main__":
main()
|
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.table[s1] >= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
return False
def union_bad(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] > self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
return False
uf=UnionFind1(100001)
n = eval(input())
cities = [list(map(int,input().split(" ")))+[i] for i in range(n)]
cities_x = sorted(cities, key=lambda a:a[0])
cities_y = sorted(cities, key=lambda a:a[1])
road = [[cities_x[i+1][0]-cities_x[i][0],cities_x[i][2],cities_x[i+1][2]] for i in range(n-1)]
road +=[[cities_y[i+1][1]-cities_y[i][1],cities_y[i][2],cities_y[i+1][2]] for i in range(n-1)]
sum = 0
for (cost,i,j) in sorted(road):
if(uf.find(i)!=uf.find(j)):
uf.union(i,j)
sum += cost
print(sum)
|
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 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
return False
uf=UnionFind3(100001)
n = eval(input())
cities = [list(map(int,input().split(" ")))+[i] for i in range(n)]
cities_x = sorted(cities, key=lambda a:a[0])
cities_y = sorted(cities, key=lambda a:a[1])
road = [[cities_x[i+1][0]-cities_x[i][0],cities_x[i][2],cities_x[i+1][2]] for i in range(n-1)]
road +=[[cities_y[i+1][1]-cities_y[i][1],cities_y[i][2],cities_y[i+1][2]] for i in range(n-1)]
sum = 0
for (cost,i,j) in sorted(road):
if(uf.find(i)!=uf.find(j)):
uf.union(i,j)
sum += cost
print(sum)
|
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 reduce
from collections import Counter
class UnionFind:
def __init__(self, n):
self.N = n
self.parent = list(range(n))
self.rank = [1 for _ in range(n)]
def findRoot(self, i):
if self.parent[i] == i: # 親が自分ならroot
return i
else:
self.parent[i] = self.findRoot(self.parent[i]) # 親をrootに付け替える
return self.parent[i]
def unite(self, i, j):
i_root = self.findRoot(i)
j_root = self.findRoot(j)
if i_root == j_root:
return
if self.rank[i_root] > self.rank[j_root]: # ランクが高い方を親にする。
self.parent[j_root] = i_root
elif self.rank[i_root] == self.rank[j_root]:
self.parent[j_root] = i_root
self.rank[i_root] += 1
else:
self.parent[i_root] = j_root
return i
def isSame(self, i, j):
return self.findRoot(i) == self.findRoot(j)
def setGroup(self, elements):
reduce(self.unite, elements)
def getElementCount(self): # 要素ごとにそれが属してる集合の要素数を取る
roots = [self.findRoot(i) for i in range(self.N)]
counts = Counter(roots)
return [counts[r] for r in roots]
def getRootCount(self): # ルートごとにそれが属してる集合の要素数を取る
roots = [self.findRoot(i) for i in range(self.N)]
counts = Counter(roots)
return counts
def resolve():
# S = [x for x in sys.stdin.readline().split()][0] # 文字列 一つ
N = [int(x) for x in sys.stdin.readline().split()][0] # int 一つ
# N, D = [int(x) for x in sys.stdin.readline().split()] # 複数int
# h_list = [int(x) for x in sys.stdin.readline().split()] # 複数int
# grid = [list(sys.stdin.readline().split()[0]) for _ in range(N)] # 文字列grid
# v_list = [int(sys.stdin.readline().split()[0]) for _ in range(N)]
grid = [[int(x) for x in sys.stdin.readline().split()] + [i]
for i in range(N)] # int grid
logger.debug('{}'.format([]))
edge_list = []
# x でソート
grid = sorted(grid, key=lambda xy: xy[0])
for i in range(N - 1):
xi, yi, vi = grid[i]
xj, yj, vj = grid[i + 1]
edge_list.append((min(abs(xi - xj), abs(yi - yj)), vi, vj))
# y でソート
grid = sorted(grid, key=lambda xy: xy[1])
for i, j in combinations(list(range(N)), 2):
xi, yi, vi = grid[i]
xj, yj, vj = grid[i + 1]
edge_list.append((min(abs(xi - xj), abs(yi - yj)), vi, vj))
edge_list = sorted(edge_list)
union_find = UnionFind(N)
total_cost = 0
for edge in edge_list:
cost, i, j = edge
if not union_find.isSame(i, j):
union_find.unite(i, j)
total_cost += cost
print(total_cost)
if __name__ == "__main__":
resolve()
# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3
1 5
3 9
7 8"""
output = """3"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """6
8 3
4 9
12 19
18 1
13 5
7 6"""
output = """8"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """2
0 0
0 0"""
output = """0"""
self.assertIO(input, output)
|
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 reduce
from collections import Counter
class UnionFind:
def __init__(self, n):
self.N = n
self.parent = list(range(n))
self.rank = [1 for _ in range(n)]
def findRoot(self, i):
if self.parent[i] == i: # 親が自分ならroot
return i
else:
self.parent[i] = self.findRoot(self.parent[i]) # 親をrootに付け替える
return self.parent[i]
def unite(self, i, j):
i_root = self.findRoot(i)
j_root = self.findRoot(j)
if i_root == j_root:
return
if self.rank[i_root] > self.rank[j_root]: # ランクが高い方を親にする。
self.parent[j_root] = i_root
elif self.rank[i_root] == self.rank[j_root]:
self.parent[j_root] = i_root
self.rank[i_root] += 1
else:
self.parent[i_root] = j_root
return i
def isSame(self, i, j):
return self.findRoot(i) == self.findRoot(j)
def setGroup(self, elements):
reduce(self.unite, elements)
def getElementCount(self): # 要素ごとにそれが属してる集合の要素数を取る
roots = [self.findRoot(i) for i in range(self.N)]
counts = Counter(roots)
return [counts[r] for r in roots]
def getRootCount(self): # ルートごとにそれが属してる集合の要素数を取る
roots = [self.findRoot(i) for i in range(self.N)]
counts = Counter(roots)
return counts
def resolve():
# S = [x for x in sys.stdin.readline().split()][0] # 文字列 一つ
N = [int(x) for x in sys.stdin.readline().split()][0] # int 一つ
# N, D = [int(x) for x in sys.stdin.readline().split()] # 複数int
# h_list = [int(x) for x in sys.stdin.readline().split()] # 複数int
# grid = [list(sys.stdin.readline().split()[0]) for _ in range(N)] # 文字列grid
# v_list = [int(sys.stdin.readline().split()[0]) for _ in range(N)]
grid = [[int(x) for x in sys.stdin.readline().split()] + [i]
for i in range(N)] # int grid
logger.debug('{}'.format([]))
edge_list = []
# x でソート
grid = sorted(grid, key=lambda xy: xy[0])
for i in range(N - 1):
xi, yi, vi = grid[i]
xj, yj, vj = grid[i + 1]
edge_list.append((min(abs(xi - xj), abs(yi - yj)), vi, vj))
# y でソート
grid = sorted(grid, key=lambda xy: xy[1])
for i in range(N - 1):
xi, yi, vi = grid[i]
xj, yj, vj = grid[i + 1]
edge_list.append((min(abs(xi - xj), abs(yi - yj)), vi, vj))
edge_list = sorted(edge_list)
union_find = UnionFind(N)
total_cost = 0
for edge in edge_list:
cost, i, j = edge
if not union_find.isSame(i, j):
union_find.unite(i, j)
total_cost += cost
print(total_cost)
if __name__ == "__main__":
resolve()
# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3
1 5
3 9
7 8"""
output = """3"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """6
8 3
4 9
12 19
18 1
13 5
7 6"""
output = """8"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """2
0 0
0 0"""
output = """0"""
self.assertIO(input, output)
|
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]])
class Unionfind:
def __init__(self,n):
self.uf = [-1]*n
def find(self,x):
if self.uf[x] < 0:
return x
else:
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def same(self,x,y):
return self.find(x) == self.find(y)
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.uf[x] > self.uf[y]:
x,y = y,x
self.uf[x] += self.uf[y]
self.uf[y] = x
def size(self,x):
x = self.find(x)
return -self.uf[x]
u = Unionfind(n)
count = 0
e.sort()
for i in e:
if u.find(i[1]) != u.find(i[2]):
u.union(i[1],i[2])
count += i[0]
print(count)
|
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]])
class Unionfind:
def __init__(self,n):
self.uf = [-1]*n
def find(self,x):
if self.uf[x] < 0:
return x
else:
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def same(self,x,y):
return self.find(x) == self.find(y)
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.uf[x] > self.uf[y]:
x,y = y,x
self.uf[x] += self.uf[y]
self.uf[y] = x
def size(self,x):
x = self.find(x)
return -self.uf[x]
s = set()
u = Unionfind(n)
count = 0
e.sort()
for i in e:
if not u.same(i[1],i[2]):
u.union(i[1],i[2])
s.add(i[1])
s.add(i[2])
count += i[0]
print(count)
|
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:
self.tree[x] = self.find(self.tree[x]) # 経路圧縮
return self.tree[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
# ランクを考慮しない場合はどちらが親になっても良い
if self.rank[x] < self.rank[y]:
self.tree[x] = y
self.size[y] += self.size[x]
else:
self.tree[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def has_same_parent(self, x, y):
return self.find(x) == self.find(y)
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LMI(): return list(map(int, input().split()))
N = I()
X = [None] * N
Y = [None] * N
for i in range(N):
x, y = MI()
X[i] = (x, i, x, y)
Y[i] = (y, i, x, y)
X.sort()
Y.sort()
# ある頂点vから最小全域木に含まれる点をたどった先の頂点は、x軸方向で最も近いかy軸方向で最もvから近いはず
q = list()
for i in range(N - 1):
for axis in [X, Y]:
_, t0, x0, y0 = axis[i]
_, t1, x1, y1 = axis[i + 1]
cost = min(abs(x1 - x0), abs(y1 - y0))
heappush(q, (cost, t0, t1))
uf = UnionFind(N)
ans = 0
while len(q) > 0:
cost, t0, t1 = heappop(q)
if not uf.has_same_parent(t0, t1):
uf.unite(t0, t1)
ans += cost
print(ans)
|
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]]:
self.tree[x] = self.tree[self.tree[x]] # 経路圧縮
return self.tree[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
# ランクを考慮しない場合はどちらが親になっても良い
if self.rank[x] < self.rank[y]:
self.tree[x] = y
self.size[y] += self.size[x]
else:
self.tree[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def has_same_parent(self, x, y):
return self.find(x) == self.find(y)
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LMI(): return list(map(int, input().split()))
N = I()
X = [None] * N
Y = [None] * N
for i in range(N):
x, y = MI()
X[i] = (x, i, x, y)
Y[i] = (y, i, x, y)
X.sort()
Y.sort()
# ある頂点vから最小全域木に含まれる点をたどった先の頂点は、x軸方向で最も近いかy軸方向で最もvから近いはず
q = list()
for i in range(N - 1):
for axis in [X, Y]:
_, t0, x0, y0 = axis[i]
_, t1, x1, y1 = axis[i + 1]
cost = min(abs(x1 - x0), abs(y1 - y0))
heappush(q, (cost, t0, t1))
# Kruskal法 := 最小コストの辺から順に見て、新たな頂点が仲間に入るなら加える
uf = UnionFind(N)
ans = 0
while len(q) > 0:
cost, t0, t1 = heappop(q)
if not uf.has_same_parent(t0, t1):
uf.unite(t0, t1)
ans += cost
print(ans)
|
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([tmp,i,j])
cad.sort()
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())
h = UnionFind(n)
cost = 0
for i in range(len(cad)):
a = cad[i][1]
b = cad[i][2]
c = cad[i][0]
if not h.same(a,b):
h.union(a,b)
cost += c
print(cost)
|
#最小領域木
#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[i+1][0] - lst[i][0],lst[i+1][2],lst[i][2]])
lsty = lst.sort(key = lambda x: x[1])
for i in range(n-1):
cad.append([lst[i+1][1] - lst[i][1],lst[i+1][2],lst[i][2]])
cad.sort()
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())
h = UnionFind(n)
cost = 0
count = 0
for i in range(len(cad)):
a = cad[i][1]
b = cad[i][2]
c = cad[i][0]
if not h.same(a,b):
h.union(a,b)
cost += c
count += 1
if count == n-1:
print(cost)
sys.exit()
|
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)
par[j] = get_par(i)
return
for k in range(N-1):
x,y,i = xy[k]
x2,y2,j = xy[k+1]
if i>j:i,j = j,i
path.append((abs(x-x2),i,j))
xy.sort(key=lambda x:x[1])
for k in range(N-1):
x,y,i = xy[k]
x2,y2,j = xy[k+1]
if i>j:i,j = j,i
path.append((abs(y-y2),i,j))
path.sort(key = lambda x:x[0],reverse=True)
par = [None]*N
cnt = 0
ans = 0
while cnt < N-1:
c,i,j = path.pop()
if same(i,j):continue
unite(i,j)
ans += c
cnt += 1
print(ans)
|
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):
j = get_par(j)
par[j] = get_par(i)
return
for k in range(N-1):
x,y,i = xy[k]
x2,y2,j = xy[k+1]
path.append((abs(x-x2),i,j))
xy.sort(key=lambda x:x[1])
for k in range(N-1):
x,y,i = xy[k]
x2,y2,j = xy[k+1]
path.append((abs(y-y2),i,j))
path.sort(key = lambda x:x[0],reverse=True)
par = [None]*N
cnt = 0
ans = 0
while cnt < N-1:
c,i,j = path.pop()
if same(i,j):continue
unite(i,j)
ans += c
cnt += 1
print(ans)
|
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
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
x, a, b = LI()
if b <= a:
print("delicious")
elif b <= a + x:
print("safe")
else:
print("dangerous")
return
#B
def B():
n = II()
a = IR(n)
check = [False] * (n + 1)
check[1] = True
now = a[0]
for i in range(1,n+1):
if check[now]:
break
if now == 2:
print(i)
return
check[now] = True
now = a[now - 1]
print((-1))
return
#C
def C():
return
#D
def D():
def root(x):
if x == par[x]:
return x
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 rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = II()
v = LIR(n)
l = [None for i in range(2*n-2)]
for i in range(n):
v[i].append(i)
par = [i for i in range(n)]
rank = [0 for i in range(n)]
v.sort(key = lambda x:x[0])
for i in range(n-1):
l[i] = [v[i][2],v[i+1][2],v[i+1][0]-v[i][0]]
v.sort(key = lambda x:x[1])
for i in range(n-1):
l[i+n-1] = [v[i][2],v[i+1][2],v[i+1][1]-v[i][1]]
l.sort(key = lambda x:x[2])
k = 0
ans = 0
for i in range(2*n-2):
x,y,c = l[i]
if not same(x,y):
k += 1
ans += c
unite(x,y)
if k == n-1:break
print(ans)
return
#Solve
if __name__ == '__main__':
D()
|
#!/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
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
x, a, b = LI()
if b <= a:
print("delicious")
elif b <= a + x:
print("safe")
else:
print("dangerous")
return
#B
def B():
n = II()
a = IR(n)
check = [False] * (n + 1)
check[1] = True
now = a[0]
for i in range(1,n+1):
if check[now]:
break
if now == 2:
print(i)
return
check[now] = True
now = a[now - 1]
print((-1))
return
#C
def C():
return
#D
def D():
def find(x):
if x == par[x]:
return x
par[x] = find(par[x])
return par[x]
def same(x, y):
return find(x) == find(y)
def unite(x, y):
x = find(x)
y = find(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
return True
n = II()
par = [i for i in range(n)]
rank = [0] * n
xy = LIR(n)
for i in range(n):
xy[i].append(i)
xy.sort(key=lambda x: x[0])
edg = [None] * (2 * n - 2)
a = 0
for i in range(n-1):
edg[i] = [xy[i + 1][0] - xy[i][0], xy[i][2], xy[i + 1][2]]
xy.sort(key=lambda x: x[1])
for i in range(n-1):
edg[n + i - 1] = [xy[i + 1][1] - xy[i][1], xy[i][2], xy[i + 1][2]]
ans = 0
a = 0
edg.sort(key=lambda x: x[0])
for i in range(2 * n - 2):
value, p0, p1 = edg[i]
if a == n - 1:
break
if not same(p0, p1):
unite(p0, p1)
a += 1
ans += value
print(ans)
return
#Solve
if __name__ == '__main__':
D()
|
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
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
x, a, b = LI()
if b <= a:
print("delicious")
elif b <= a + x:
print("safe")
else:
print("dangerous")
return
#B
def B():
n = II()
a = IR(n)
check = [False] * (n + 1)
check[1] = True
now = a[0]
for i in range(1,n+1):
if check[now]:
break
if now == 2:
print(i)
return
check[now] = True
now = a[now - 1]
print((-1))
return
#C
def C():
return
#D
def D():
def find(x):
if x == par[x]:
return x
par[x] = find(par[x])
return par[x]
def same(x, y):
return find(x) == find(y)
def unite(x, y):
x = find(x)
y = find(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
return True
n = II()
par = [i for i in range(n)]
rank = [0] * n
xy = LIR(n)
for i in range(n):
xy[i].append(i)
xy.sort(key=lambda x: x[0])
edg = [None] * (2 * n - 2)
a = 0
for i in range(n-1):
edg[i] = [xy[i + 1][0] - xy[i][0], xy[i][2], xy[i + 1][2]]
xy.sort(key=lambda x: x[1])
for i in range(n-1):
edg[n + i - 1] = [xy[i + 1][1] - xy[i][1], xy[i][2], xy[i + 1][2]]
ans = 0
a = 0
edg.sort(key=lambda x: x[0])
for i in range(2 * n - 2):
value, p0, p1 = edg[i]
if a == n - 1:
break
if not same(p0, p1):
unite(p0, p1)
a += 1
ans += value
print(ans)
return
#Solve
if __name__ == '__main__':
D()
|
#!/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
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
x, a, b = LI()
if b <= a:
print("delicious")
elif b <= a + x:
print("safe")
else:
print("dangerous")
return
#B
def B():
n = II()
a = IR(n)
check = [False] * (n + 1)
check[1] = True
now = a[0]
for i in range(1,n+1):
if check[now]:
break
if now == 2:
print(i)
return
check[now] = True
now = a[now - 1]
print((-1))
return
#C
def C():
return
#D
def D():
def find(x):
if x == par[x]:
return x
par[x] = find(par[x])
return par[x]
def unite(x, y):
x = find(x)
y = find(y)
if x == y: return False
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
return True
n = II()
par = [i for i in range(n)]
rank = [0] * n
xy = LIR(n)
for i in range(n):
xy[i].append(i)
xy.sort(key=lambda x: x[0])
edg = [None] * (2 * n - 2)
a = 0
for i in range(n-1):
edg[i] = [xy[i + 1][0] - xy[i][0], xy[i][2], xy[i + 1][2]]
xy.sort(key=lambda x: x[1])
for i in range(n-1):
edg[n + i - 1] = [xy[i + 1][1] - xy[i][1], xy[i][2], xy[i + 1][2]]
ans = 0
a = 0
edg.sort(key=lambda x: x[0])
for i in range(2 * n - 2):
value, p0, p1 = edg[i]
if a == n - 1:
break
if unite(p0, p1):
a += 1
ans += value
print(ans)
return
#Solve
if __name__ == '__main__':
D()
|
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(abs(X[i][0]-X[i-1][0]),abs(X[i][1]-X[i-1][1])),X[i-1][2],X[i][2]))
es.append((min(abs(Y[i][0]-Y[i-1][0]),abs(Y[i][1]-Y[i-1][1])),Y[i][2],Y[i-1][2]))
es.append((min(abs(Y[i][0]-Y[i-1][0]),abs(Y[i][1]-Y[i-1][1])),Y[i-1][2],Y[i][2]))
es.sort(key=lambda x:x[0])
#Union-Find木
#par[i]:iの親 deep[i]:iの深さ size[i]:iの大きさ
par=[i for i in range(n)]
deep=[1]*n
size=[1]*n
#親を見つける
def find(x):
if par[x]==x:
return x
else:
return find(par[x])
#二つのグループを統合する
def unite(x,y):
x=find(x)
y=find(y)
if x==y:
return
if deep[x]<deep[y]:
par[x]=y
size[y]+=size[x]
else:
par[y]=x
size[x]+=size[y]
if deep[x]==deep[y]:
deep[x]+=1
#xとyが同じグループに属するかどうか
def same(x,y):
return find(x)==find(y)
#xが属するグループの要素数を返す
def group_count(x):
return size[find(x)]
#クラスカル法
#esは重みで小さい順にsort済み
#es[i]:[重み、始点、終点]
def kruskal(n,es):
ans=0
for to in es:
if not same(to[1],to[2]):
ans+=to[0]
unite(to[1],to[2])
return ans
print((kruskal(n,es)))
|
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(abs(X[i][0]-X[i-1][0]),abs(X[i][1]-X[i-1][1])),X[i-1][2],X[i][2]))
es.append((min(abs(Y[i][0]-Y[i-1][0]),abs(Y[i][1]-Y[i-1][1])),Y[i][2],Y[i-1][2]))
#es.append((min(abs(Y[i][0]-Y[i-1][0]),abs(Y[i][1]-Y[i-1][1])),Y[i-1][2],Y[i][2]))
es.sort(key=lambda x:x[0])
#Union-Find木
#par[i]:iの親 deep[i]:iの深さ size[i]:iの大きさ
par=[i for i in range(n)]
deep=[1]*n
size=[1]*n
#親を見つける
def find(x):
if par[x]==x:
return x
else:
return find(par[x])
#二つのグループを統合する
def unite(x,y):
x=find(x)
y=find(y)
if x==y:
return
if deep[x]<deep[y]:
par[x]=y
size[y]+=size[x]
else:
par[y]=x
size[x]+=size[y]
if deep[x]==deep[y]:
deep[x]+=1
#xとyが同じグループに属するかどうか
def same(x,y):
return find(x)==find(y)
#xが属するグループの要素数を返す
def group_count(x):
return size[find(x)]
#クラスカル法
#esは重みで小さい順にsort済み
#es[i]:[重み、始点、終点]
def kruskal(n,es):
ans=0
for to in es:
if not same(to[1],to[2]):
ans+=to[0]
unite(to[1],to[2])
return ans
print((kruskal(n,es)))
|
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 = [0 for _ in range(n)]
def find(self, x):
"""
x が属するグループを探索
"""
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
"""
x と y のグループを結合
"""
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
def is_same(self, x, y):
"""
x と y が同じグループか否か
"""
return self.find(x) == self.find(y)
class Graph(object):
"""
隣接リストによる有向グラフ
"""
def __init__(self):
self.graph = defaultdict(dict)
def __len__(self):
return len(self.graph)
def add_edge(self, src, dst, weight=1):
self.graph[src][dst] = weight
def get_nodes(self):
return list(self.graph.keys())
class Kruskal(object):
"""
クラスカル法による最小全域木
O(ElogV)
"""
def __init__(self, graph):
self.edge = []
self.total = 0
N = len(graph)
g = graph.graph
uf = UnionFind(N)
Q = []
for src, v in list(g.items()):
for dst, cost in list(v.items()):
heappush(Q, (cost, (src, dst)))
while len(self.edge) < N - 1 and Q:
cost, edge = heappop(Q)
if uf.find(edge[0]) != uf.find(edge[1]):
self.total += cost
self.edge.append(edge)
uf.union(*edge)
def built(g, town):
for i in range(N - 1):
t1, t2 = town[i], town[i + 1]
dx = abs(t1[0] - t2[0])
dy = abs(t1[1] - t2[1])
c = min(dx, dy)
g.add_edge(t1[2], t2[2], c)
g.add_edge(t2[2], t1[2], c)
return g
g = Graph()
g = built(g, sorted(town, key=itemgetter(0)))
g = built(g, sorted(town, key=itemgetter(1)))
print((Kruskal(g).total))
|
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):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 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 union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
def is_same(self, x, y):
return self.find(x) == self.find(y)
def Kruskal(edges):
edge = []
total = 0
uf = UnionFind(N)
Q = sorted(edges, reverse=True)
while len(edge) < N - 1 and Q:
cost, e = Q.pop()
if uf.find(e[0]) != uf.find(e[1]):
total += cost
edge.append(edge)
uf.union(*e)
return total
edges = []
for xy in [1, 2]:
town = sorted(town, key=itemgetter(xy))
for i in range(N - 1):
t1, t2 = town[i], town[i + 1]
d = t2[xy] - t1[xy]
edges.append((d, (t1[0], t2[0])))
print((Kruskal(edges)))
|
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],sortX[i+1][0])] for i in range(N-1)]
EY = [[sortY[i][0], sortY[i+1][0], distance(P,sortY[i][0],sortY[i+1][0])] for i in range(N-1)]
E = EX + EY
E = sorted(E, key=lambda x:x[2])
CI = [i for i in range(N)]
disSum = 0
for e in E[:]:
s,l = min(e[0],e[1]),max(e[0],e[1])
if CI[s] != CI[l]:
CI = list([CI[s] if x == CI[l] else x for x in CI])
disSum += e[2]
print(disSum)
|
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().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],sortX[i+1][0])] for i in range(N-1)]
EY = [[sortY[i][0], sortY[i+1][0], distance(P,sortY[i][0],sortY[i+1][0])] for i in range(N-1)]
E = EX + EY
E = sorted(E, key=lambda x:x[2])
CI = [i for i in range(N)]
disSum = 0
for e in E:
s,l = min(e[0],e[1]),max(e[0],e[1])
# if CI[s] != CI[l]:
# CI = list(map(lambda x:CI[s] if x == CI[l] else x, CI))
# disSum += e[2]
if root(CI, s) != root(CI, l):
CI[root(CI, l)] = root(CI, s)
disSum += e[2]
print(disSum)
|
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(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
return
elif self.rank[y]<self.rank[x]:
self.par[y] = x
self.size[x] += self.size[y]
else:
self.par[y] = x
self.size[x] += self.size[y]
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
def count(self, x):
return self.size[self.find(x)]
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X += [(x,y,i)]
Y += [(x,y,i)]
X.sort()
Y.sort(key=lambda x:x[1])
hq = []
for i in range(N-1):
x1, y1, i1 = X[i]
x2, y2, i2 = X[i+1]
heappush(hq, (x2-x1,i1,i2))
x1, y1, i1 = Y[i]
x2, y2, i2 = Y[i+1]
heappush(hq, (y2-y1,i1,i2))
u = UnionFind(N)
cnt = 1
ans = 0
while cnt<N:
c, i1, i2 = heappop(hq)
if u.same(i1,i2):
continue
ans += c
cnt += 1
u.unit(i1,i2)
print(ans)
|
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(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
return
elif self.rank[y]<self.rank[x]:
self.par[y] = x
self.size[x] += self.size[y]
else:
self.par[y] = x
self.size[x] += self.size[y]
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X += [(x,y,i)]
Y += [(x,y,i)]
X.sort()
Y.sort(key=lambda x:x[1])
hq = []
for i in range(N-1):
x1, y1, i1 = X[i]
x2, y2, i2 = X[i+1]
heappush(hq, (x2-x1,i1,i2))
x1, y1, i1 = Y[i]
x2, y2, i2 = Y[i+1]
heappush(hq, (y2-y1,i1,i2))
u = UnionFind(N)
cnt = 1
ans = 0
while cnt<N:
c, i1, i2 = heappop(hq)
if u.same(i1,i2):
continue
ans += c
cnt += 1
u.unit(i1,i2)
print(ans)
|
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):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.size_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
parent = self.root()
return parent.group_id_
def size(self):
parent = self.root()
return parent.size_
def unite(self, unite_node):
parent = self.root()
unite_parent = unite_node.root()
if parent.group_id_ != unite_parent.group_id_:
if parent.size() > unite_parent.size():
unite_parent.parent_ = parent
parent.size_ = parent.size_ + unite_parent.size_
else:
parent.parent_ = unite_parent
unite_parent.size_ = parent.size_ + unite_parent.size_
def is_group(self,other):#selfとotherが同じグループに属するか
return self.root()==other.root()
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()
Y.sort()
E=[]
ans=0
for i in range(N-1):
a=X[i]
b=X[i+1]
c=Y[i]
d=Y[i+1]
E.extend([(b[0]-a[0],X[i][1],X[i+1][1]),(d[0]-c[0],Y[i][1],Y[i+1][1])])
E.sort()
U=[UnionFindNode(i) for i in range(N)]
for cost,v1,v2 in E:
if not U[v1].is_group(U[v2]):
U[v1].unite(U[v2])
ans+=cost
if U[v1].size()==N:
break
print(ans)
|
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):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.size_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
parent = self.root()
return parent.group_id_
def size(self):
parent = self.root()
return parent.size_
def unite(self, unite_node):
parent = self.root()
unite_parent = unite_node.root()
if parent.group_id_ != unite_parent.group_id_:
if parent.size() > unite_parent.size():
unite_parent.parent_ = parent
parent.size_ = parent.size_ + unite_parent.size_
else:
parent.parent_ = unite_parent
unite_parent.size_ = parent.size_ + unite_parent.size_
def is_group(self,other):#selfとotherが同じグループに属するか
return self.root()==other.root()
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()
Y.sort()
E=[]
ans=0
count=1
for i in range(N-1):
a=X[i]
b=X[i+1]
c=Y[i]
d=Y[i+1]
E.extend([(b[0]-a[0],X[i][1],X[i+1][1]),(d[0]-c[0],Y[i][1],Y[i+1][1])])
E.sort()
U=[UnionFindNode(i) for i in range(N)]
for cost,v1,v2 in E:
if not U[v1].is_group(U[v2]):
U[v1].unite(U[v2])
ans+=cost
count+=1
if count==N:
break
print(ans)
|
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):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.size_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
parent = self.root()
return parent.group_id_
def size(self):
parent = self.root()
return parent.size_
def unite(self, unite_node):
parent = self.root()
unite_parent = unite_node.root()
if parent.group_id_ != unite_parent.group_id_:
if parent.size() > unite_parent.size():
unite_parent.parent_ = parent
parent.size_ = parent.size_ + unite_parent.size_
else:
parent.parent_ = unite_parent
unite_parent.size_ = parent.size_ + unite_parent.size_
def is_group(self,other):#selfとotherが同じグループに属するか
return self.root()==other.root()
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()
Y.sort()
E=[]
ans=0
count=1
for i in range(N-1):
a=X[i]
b=X[i+1]
c=Y[i]
d=Y[i+1]
E.extend([(b[0]-a[0],X[i][1],X[i+1][1]),(d[0]-c[0],Y[i][1],Y[i+1][1])])
E.sort()
U=[UnionFindNode(i) for i in range(N)]
for cost,v1,v2 in E:
if not U[v1].is_group(U[v2]):
U[v1].unite(U[v2])
ans+=cost
count+=1
if count==N:
break
print(ans)
|
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):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.size_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
parent = self.root()
return parent.group_id_
def size(self):
parent = self.root()
return parent.size_
def unite(self, unite_node):
parent = self.root()
unite_parent = unite_node.root()
if parent.group_id_ != unite_parent.group_id_:
if parent.size() > unite_parent.size():
unite_parent.parent_ = parent
parent.size_ = parent.size_ + unite_parent.size_
else:
parent.parent_ = unite_parent
unite_parent.size_ = parent.size_ + unite_parent.size_
def is_group(self,other):#selfとotherが同じグループに属するか
return self.root()==other.root()
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()
Y.sort()
E=[]
ans=0
count=1
for i in range(N-1):
a=X[i]
b=X[i+1]
c=Y[i]
d=Y[i+1]
E.extend([(b[0]-a[0],X[i][1],X[i+1][1]),(d[0]-c[0],Y[i][1],Y[i+1][1])])
E.sort()
U=[UnionFindNode(i) for i in range(N)]
i=0
while(count<N):
cost,v1,v2=E[i]
if not U[v1].is_group(U[v2]):
U[v1].unite(U[v2])
ans+=cost
count+=1
i+=1
print(ans)
|
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):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.size_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
parent = self.root()
return parent.group_id_
def size(self):
parent = self.root()
return parent.size_
def unite(self, unite_node):
parent = self.root()
unite_parent = unite_node.root()
if parent.group_id_ != unite_parent.group_id_:
if parent.size() > unite_parent.size():
unite_parent.parent_ = parent
parent.size_ = parent.size_ + unite_parent.size_
else:
parent.parent_ = unite_parent
unite_parent.size_ = parent.size_ + unite_parent.size_
def is_group(self,other):#selfとotherが同じグループに属するか
return self.root()==other.root()
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()
Y.sort()
G=[]
for i in range(N-1):
G.append([X[i+1][0]-X[i][0],X[i][1],X[i+1][1]])
G.append([Y[i+1][0]-Y[i][0],Y[i][1],Y[i+1][1]])
G.sort()
U=[UnionFindNode(i) for i in range(N)]
ans=0
for i in range(len(G)):
c,a,b=G[i]
if U[a].is_group(U[b]):
continue
U[a].unite(U[b])
ans+=c
if U[0].size()==N:
print(ans)
quit()
|
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
def __str__(self):
template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})"
return template.format(self.group_id_, self.parent_, self.value, self.size_)
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
parent = self.root()
return parent.group_id_
def size(self):
parent = self.root()
return parent.size_
def unite(self, unite_node):
parent = self.root()
unite_parent = unite_node.root()
if parent.group_id_ != unite_parent.group_id_:
if parent.size() > unite_parent.size():
unite_parent.parent_ = parent
parent.size_ = parent.size_ + unite_parent.size_
else:
parent.parent_ = unite_parent
unite_parent.size_ = parent.size_ + unite_parent.size_
def is_group(self,other):#selfとotherが同じグループに属するか
return self.root()==other.root()
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()
Y.sort()
G=[]
for i in range(N-1):
G.append([X[i+1][0]-X[i][0],X[i][1],X[i+1][1]])
G.append([Y[i+1][0]-Y[i][0],Y[i][1],Y[i+1][1]])
G.sort()
U=[UnionFindNode(i) for i in range(N)]
ans=0
for i in range(len(G)):
c,a,b=G[i]
if U[a].is_group(U[b]):
continue
U[a].unite(U[b])
ans+=c
if U[0].size()==N:
print(ans)
quit()
|
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]
# 併合
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)
N = int(eval(input()))
# minimum spanning tree
res = 0
pos = []
for i in range(N):
p = tuple(int(x) for x in input().split())
p = (p[0], p[1], i)
pos.append(p)
x_order = sorted(pos)
y_order = sorted(pos, key=lambda x: x[1])
uf = UnionFind(N)
x_i = y_i = 0
num_edge = 0
edge = []
for i in range(len(x_order) - 1):
v1 = x_order[i+1]
v2 = x_order[i]
edge.append((v1[0] - v2[0], v1[2], v2[2]))
v1 = y_order[i+1]
v2 = y_order[i]
edge.append((v1[1] - v2[1], v1[2], v2[2]))
edge.sort()
while num_edge < N-1:
e = edge.pop(0)
if uf.same_check(e[1], e[2]):
continue
else:
res += e[0]
uf.union(e[1], e[2])
num_edge += 1
print(res)
|
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)
N = int(eval(input()))
# minimum spanning tree
res = 0
pos = []
for i in range(N):
p = tuple(int(x) for x in input().split())
p = (p[0], p[1], i)
pos.append(p)
x_order = sorted(pos)
y_order = sorted(pos, key=lambda x: x[1])
uf = UnionFind(N)
x_i = y_i = 0
num_edge = 0
edge = []
for i in range(len(x_order) - 1):
v1 = x_order[i+1]
v2 = x_order[i]
edge.append((v1[0] - v2[0], v1[2], v2[2]))
v1 = y_order[i+1]
v2 = y_order[i]
edge.append((v1[1] - v2[1], v1[2], v2[2]))
edge.sort()
i = 0
while num_edge < N-1:
e = edge[i]
i += 1
if uf.same_check(e[1], e[2]):
continue
else:
res += e[0]
uf.union(e[1], e[2])
num_edge += 1
print(res)
|
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.heappush(h, (Y[i+1][1]-Y[i][1], Y[i+1][2], Y[i][2]))
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def find_root(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find_root(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
def isSameGroup(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.root[self.find_root(x)]
UF = UnionFind(N)
ans = 0
while h:
t = heapq.heappop(h)
if UF.isSameGroup(t[1], t[2]):
continue
ans += t[0]
UF.unite(t[1], t[2])
print(ans)
|
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
used[0] = 1
h = []
c = 1
idx = Y_idx[0]
heapq.heappush(h, (pos[c][0]-pos[c-1][0], 1))
if idx > 0:
heapq.heappush(h, (Y[idx][1]-Y[idx-1][1], Y[idx-1][2]))
if idx < N-1:
heapq.heappush(h, (Y[idx+1][1]-Y[idx][1], Y[idx+1][2]))
cnt = 0
while cnt < N-1:
t = heapq.heappop(h)
if used[t[1]] == 1:
continue
c = t[1]
used[c] = 1
cnt += 1
ans += t[0]
if c > 0 and used[c-1] == 0:
heapq.heappush(h, (pos[c][0]-pos[c-1][0], c-1))
if c < N-1 and used[c+1] == 0:
heapq.heappush(h, (pos[c+1][0]-pos[c][0], c+1))
idx = Y_idx[c]
if idx > 0 and used[Y[idx-1][2]] == 0:
heapq.heappush(h, (Y[idx][1]-Y[idx-1][1], Y[idx-1][2]))
if idx < N-1 and used[Y[idx+1][2]] == 0:
heapq.heappush(h, (Y[idx+1][1]-Y[idx][1], Y[idx+1][2]))
print(ans)
|
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[nowx[0]].append([distx,nextx[0]])
D[nextx[0]].append([distx,nowx[0]])
#print(xG)
yG=sorted(G,key=lambda x:x[2])
for index_y in range(n-1):
nowy=yG[index_y]
nexty=yG[index_y+1]
disty=nexty[2]-nowy[2]
D[nowy[0]].append([disty,nexty[0]])
D[nexty[0]].append([disty,nowy[0]])
#print(yG)
#print(D)
def prim_heap():
used = [True] * n #True:不使用
edgelist = []
for e in D[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 D[v]:
if used[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0]
return res
ans=prim_heap()
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()))
G=[]
for i in range(N):
x,y=list(map(int,input().split()))
G.append((x,y,i))
Gx=sorted(G,key=lambda x:x[0])
Gy=sorted(G,key=lambda x:x[1])
newG=[]
for i in range(N-1):
now=Gx[i]
next=Gx[i+1]
dist=abs(now[0]-next[0])
newG.append((dist,now[2],next[2]))
for i in range(N-1):
now=Gy[i]
next=Gy[i+1]
dist=abs(now[1]-next[1])
newG.append((dist,now[2],next[2]))
newG.sort()
uf=UnionFind(N)
count=N
ans=0
for c,i,j in newG:
if count==0:
break
if not uf.same(i,j):
ans+=c
uf.union(i,j)
count-=1
print(ans)
|
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][0]==index:
return index
else:
self.tree[index][0]=self.root(self.tree[index][0])
return self.tree[index][0]
#結合
def unite(self,index1,index2):
r1=self.root(index1)
r2=self.root(index2)
if r1!=r2:
d1,d2=self.tree[r1][1],self.tree[r2][1]
if d1<=d2:
self.tree[r1][0]=r2
self.tree[r2][1]=max(d1+1,d2)
else:
self.tree[r2][0]=r1
self.tree[r1][1]=max(d2+1,d1)
#同じか判定
def same(self,index1,index2):
r1=self.root(index1)
r2=self.root(index2)
return r1==r2
n=int(eval(input()))
xy=[list(map(int,input().split())) for _ in [0]*n]
xyz=[xy[i]+[i] for i in range(n)]
x_sort=sorted(xyz,key=lambda x:x[0])
y_sort=sorted(xyz,key=lambda x:x[1])
g=[]
heapq.heapify(g)
for i in range(n-1):
heapq.heappush(g,[abs(x_sort[i+1][0]-x_sort[i][0]),x_sort[i][2],x_sort[i+1][2]])
for i in range(n-1):
heapq.heappush(g,[abs(y_sort[i+1][1]-y_sort[i][1]),y_sort[i][2],y_sort[i+1][2]])
u=unionfind(n)
cnt=0
while g:
d,i,j=heapq.heappop(g)
if u.same(i,j)==False:
cnt+=d
u.unite(i,j)
print(cnt)
main()
|
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:
d1,d2=tree[r1][1],tree[r2][1]
if d1<=d2:
tree[r1][0]=r2
tree[r2][1]=max(d1+1,d2)
else:
tree[r2][0]=r1
tree[r1][1]=max(d2+1,d1)
def same(index1,index2):
return root(index1)==root(index2)
n=int(eval(input()))
xy=[list(map(int,input().split())) for _ in [0]*n]
xyz=[xy[i]+[i] for i in range(n)]
x_sort=sorted(xyz,key=lambda x:x[0])
y_sort=sorted(xyz,key=lambda x:x[1])
tree=[[i,1] for i in range(n)]#root,depth
g=[]
heapq.heapify(g)
for i in range(n-1):
heapq.heappush(g,[abs(x_sort[i+1][0]-x_sort[i][0]),x_sort[i][2],x_sort[i+1][2]])
for i in range(n-1):
heapq.heappush(g,[abs(y_sort[i+1][1]-y_sort[i][1]),y_sort[i][2],y_sort[i+1][2]])
cnt=0
while g:
d,i,j=heapq.heappop(g)
if same(i,j)==False:
cnt+=d
unite(i,j)
print(cnt)
main()
|
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)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
"""
実装例
ABC126E 1or2
#E問題
#UnionFind(normal)
UFコードは省略
if __name__ == "__main__":
N,M = map(int,input().split())
uf = UnionFind(N+1)
for i in range(M):
X,Y,Z = map(int,input().split())
if not uf.isSameGroup(X,Y):
uf.Unite(X,Y)
ans=0
for j in uf.root[1:N+1]:
if j < 0:
ans+=1
print(ans)
"""
import heapq
N = int(eval(input()))
XY0 = []
XY1 = []
for i in range(N):
x,y = list(map(int,input().split()))
XY0.append([x,y,i])
XY1.append([x,y,i])
XY0.sort()
XY1 = sorted(XY1, key=lambda x: x[1])
E = []
for i,x in enumerate(XY0):
if i == 0:
ox = x[0]
oi = x[2]
else:
dx = x[0]-ox
ox = x[0]
heapq.heappush(E,[dx,oi,x[2]])
oi = x[2]
for i,y in enumerate(XY1):
if i == 0:
oy = y[1]
oi = y[2]
else:
dy = y[1]-oy
oy = y[1]
heapq.heappush(E,[dy,oi,y[2]])
oi = y[2]
uf = UnionFind(N)
V = [i for i in range(N)]
ans = 0
while E:
w,s,t = heapq.heappop(E)
if not uf.isSameGroup(s,t):
uf.Unite(s,t)
ans+=w
print(ans)
|
#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(eval(input()))
XY0 = []
XY1 = []
for i in range(N):
x,y = list(map(int,input().split()))
XY0.append([x,y,i])
XY1.append([x,y,i])
XY0.sort()
XY1 = sorted(XY1, key=lambda x: x[1])
E = []
for i,x in enumerate(XY0):
if i == 0:
ox = x[0]
oi = x[2]
else:
dx = x[0]-ox
ox = x[0]
heapq.heappush(E,[dx,oi,x[2]])
oi = x[2]
for i,y in enumerate(XY1):
if i == 0:
oy = y[1]
oi = y[2]
else:
dy = y[1]-oy
oy = y[1]
heapq.heappush(E,[dy,oi,y[2]])
oi = y[2]
V = [i for i in range(N)]
ans = 0
while E:
w,s,t = heapq.heappop(E)
if find(V,s) != find(V,t):
union(V,s,t)
ans+=w
print(ans)
|
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, input().split()))
def LIST(): return list(map(int, input().split()))
n = INT()
position = [[]for i in range(n)]
for i in range(n):
a, b= MAP()
position[i] = (a, b)
def prim():
res = 0
used = [False]*n
que = []
heapq.heapify(que)
used[0] = True
for i in range(1, n):
distance = min(abs(position[0][0]-position[i][0]), abs(position[0][1]-position[i][1]))
heapq.heappush(que,(distance,i))
while(len(que) > 0):
cost, vertex = heapq.heappop(que)
if used[vertex]:continue
res += cost
used[vertex] = True
for i in range(n):
if used[i]:continue
distance = min(abs(position[vertex][0]-position[i][0]), abs(position[vertex][1]-position[i][1]))
heapq.heappush(que,(distance, i))
return res
print((prim()))
|
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, input().split()))
def LIST(): return list(map(int, input().split()))
n = INT()
G = [[]for i in range(n)]
position = [[]for i in range(n)]
for i in range(n):
a, b= MAP()
position[i] = (i, a, b)
position_x = sorted(position, key = lambda x:x[1])
position_y = sorted(position, key = lambda x:x[2])
for i in range(1,n):
G[position_x[i][0]].append((position_x[i][1]-position_x[i-1][1], position_x[i-1][0]))
G[position_x[i-1][0]].append((position_x[i][1]-position_x[i-1][1], position_x[i][0]))
G[position_y[i][0]].append((position_y[i][2]-position_y[i-1][2], position_y[i-1][0]))
G[position_y[i-1][0]].append((position_y[i][2]-position_y[i-1][2], position_y[i][0]))
def prim(G):
res = 0
used = [False]*n
que = []
heapq.heapify(que)
used[0] = True
for Gs in G[0]:
heapq.heappush(que,Gs)
while(len(que) > 0):
cost, vertex = heapq.heappop(que)
if used[vertex]:continue
res += cost
used[vertex] = True
for Gs in G[vertex]:
if used[Gs[1]]:continue
heapq.heappush(que,Gs)
return res
print((prim(G)))
|
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=lambda z:z[1])
s = []
for i in range(n-1):
xcost =nodesx[i+1][0]-nodesx[i][0]
ycost =nodesy[i+1][1]-nodesy[i][1]
s.append((xcost,(nodesx[i+1],nodesx[i])))
s.append((ycost,(nodesy[i+1],nodesy[i])))
s.sort()
def root(node,par):
if node == par[node]:
return node
else:
par[node] =root(par[node],par)
return par[node]
def unite(node1,node2,par):
par[root(node1,par)] = root(node2,par)
ans = 0
count =0
for cost,(node1,node2) in s:
if count == n-1:
break
root1 =root(node1,par)
root2 =root(node2,par)
if root1 != root2:
unite(node1,node2,par)
ans +=cost
count += 1
print(ans)
|
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=lambda z:z[1])
s = []
m = len(set(nodes))
for i in range(n-1):
xcost =nodesx[i+1][0]-nodesx[i][0]
ycost =nodesy[i+1][1]-nodesy[i][1]
s.append((xcost,(nodesx[i+1],nodesx[i])))
s.append((ycost,(nodesy[i+1],nodesy[i])))
s.sort()
s = deque(s)
def root(node,par):
if node == par[node]:
return node
else:
par[node] =root(par[node],par)
return par[node]
def unite(node1,node2,par):
par[root(node1,par)] = root(node2,par)
ans = 0
count =0
while count < m-1 :
cost,(node1,node2) = s.popleft()
root1 =root(node1,par)
root2 =root(node2,par)
if root1 != root2:
unite(node1,node2,par)
ans +=cost
count += 1
print(ans)
|
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()))
cities.append(pt(x=x, y=y, idx=idx))
g = tuple(set() for _ in range(n))
xs = sorted(cities, key=attrgetter('x'))
for a, b in zip(xs, xs[1:]):
g[a.idx].add((b.x - a.x, b.idx))
g[b.idx].add((b.x - a.x, a.idx))
ys = sorted(cities, key=attrgetter('y'))
for a, b in zip(ys, ys[1:]):
g[a.idx].add((b.y - a.y, b.idx))
g[b.idx].add((b.y - a.y, a.idx))
ret = 0
h = [(0, 0)]
used = [False] * n
count = 0
while True:
c, v = heappop(h)
if used[v]:
continue
used[v] = True
count += 1
ret += c
if count == n:
break
for c_, u in g[v]:
if used[u]:
continue
heappush(h, (c_, u))
return ret
if __name__ == '__main__':
print((solve()))
# 最小全域木
|
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 = []
for city_idx in range(N):
x, y = list(map(int, input().split()))
c_ = City(x, y, city_idx)
cities.append(c_)
cities_x_asc = sorted(cities, key=attrgetter('x'))
cities_y_asc = sorted(cities, key=attrgetter('y'))
edges = []
it_x = iter(cities_x_asc)
gx1, gx2 = tee(it_x, 2)
next(gx2)
for c1, c2 in zip(gx1, gx2):
d_ = c2.x - c1.x
e_ = Edge(d_, c1.idx, c2.idx)
edges.append(e_)
# x方向にN-1本の辺を張る
it_y = iter(cities_y_asc)
gy1, gy2 = tee(it_y, 2)
next(gy2)
for c1, c2 in zip(gy1, gy2):
d_ = c2.y - c1.y
e_ = Edge(d_, c1.idx, c2.idx)
edges.append(e_)
# y方向にN-1本の辺を張る
edges.sort(key=attrgetter('cost'))
# <Kruskal’s Algorithm>
# https://tjkendev.github.io/procon-library/python/graph/min_st_kruskal.html
# E = [(cost, v, w), ...]
# G上の全ての辺(v, w)とそのcostを含むlist
# Union-Findを使うことで頂点間の連結判定を行う
*p, = list(range(N))
def root(x):
if x == p[x]:
return x
p[x] = y = root(p[x])
return y
def unite(x, y):
px = root(x)
py = root(y)
if px == py:
return 0
if px < py:
p[py] = px
else:
p[px] = py
return 1
mi = 0
for e_ in edges:
if unite(e_.a, e_.b):
mi += e_.cost
# miが最小全域木の解
print(mi)
return
if __name__ == '__main__':
solve_abc065d()
|
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(eval(input()))
cities = []
for city_idx in range(N):
x, y = list(map(int, input().split()))
c_ = City(x, y, city_idx)
cities.append(c_)
cities_x_asc = sorted(cities, key=attrgetter('x'))
cities_y_asc = sorted(cities, key=attrgetter('y'))
graph = tuple(set() for _ in range(N))
it_x = iter(cities_x_asc)
gx1, gx2 = tee(it_x, 2)
next(gx2)
for c1, c2 in zip(gx1, gx2):
d_ = c2.x - c1.x
graph[c1.idx].add(Edge(d_, c2.idx))
graph[c2.idx].add(Edge(d_, c1.idx))
# x方向にN-1本の辺を張る
it_y = iter(cities_y_asc)
gy1, gy2 = tee(it_y, 2)
next(gy2)
for c1, c2 in zip(gy1, gy2):
d_ = c2.y - c1.y
graph[c1.idx].add(Edge(d_, c2.idx))
graph[c2.idx].add(Edge(d_, c1.idx))
# y方向にN-1本の辺を張る
# <Prim’s Algorithm>
# https://tjkendev.github.io/procon-library/python/graph/min_st_prim.html
# プリム法では、グラフGの1頂点からなる木から始め、
# 木に含まれる頂点と木に含まれない頂点を繋ぐ辺のうち、
# 一番コストが小さい辺が繋ぐ(木に含まれない方の)頂点を木に追加する、
# ことを繰り返すことで最小全域木を求める。
# G[v] = [w, ...]
# グラフG上で頂点vが隣接する辺集合
start = 0 # 起点とする頂点
used = [-1] * N
used[start] = 1
h = []
for e_ in graph[start]:
heappush(h, e_)
mi = 0
while h:
e_ = heappop(h)
if ~used[e_.to]: continue
used[e_.to] = 1
mi += e_.cost
for ne_ in graph[e_.to]:
if ~used[ne_.to]: continue
heappush(h, ne_)
# miが最小全域木の解
print(mi)
return
if __name__ == '__main__':
solve_abc065d()
|
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)
if x == y:
return False
else:
if self.v[x] > self.v[y]:
x, y = y, x
self.v[x] += self.v[y]
self.v[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.v[self.find(x)]
def main():
from operator import itemgetter
import sys
input = sys.stdin.readline
N = int(eval(input()))
ps = []
xs = set()
ys = set()
for i in range(N):
x, y = list(map(int, input().split()))
ps.append((x, y))
xs.add(x)
ys.add(y)
xs = tuple(sorted(xs))
ys = tuple(sorted(ys))
dx = {e: i for i, e in enumerate(xs)}
dy = {e: i for i, e in enumerate(ys)}
uf = UnionFind(N * 2)
for x, y in ps:
uf.unite(dx[x], dy[y] + N)
def make_edges(xs, d, *, add_val=0):
xes = []
for x0, x1 in zip(xs, xs[1:]):
xes.append((abs(x1 - x0), d[x0] + add_val, d[x1] + add_val))
return xes
xes = make_edges(xs, dx)
yes = make_edges(ys, dy, add_val=N)
# Kruskal
# 最小コストの辺から順に使用する
# 同じ連結成分に属していればつながない(閉路を作らない)
# コスト昇順ソート済みの辺リストを使用する
ret = 0
joined = set()
for cost, a, b in sorted(xes + yes, key=itemgetter(0)):
if (a in joined) or (b in joined): continue
if uf.same(a, b): continue
uf.unite(a, b)
ret += cost
print(ret)
if __name__ == '__main__':
main()
|
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:
n=6
xy=[[8, 3], [4, 9], [12, 19], [18, 1], [13, 5], [7, 6]]
#xy = list(map(list, set(map(tuple, xy))))
xy.sort()
xy=xy[:n]
pair_lst = [i for i in range(n)]
que=[]
for i in range(n-1):
for j in range(i+1,n):
wi=min(abs(xy[i][0]-xy[j][0]),abs(xy[i][1]-xy[j][1]))
heappush(que,(wi,i,j))
def find(x):
if x == pair_lst[x]:
return x
else:
tmp = find(pair_lst[x])
pair_lst[x] = tmp
return tmp
length_sum = 0
while que:
w, s, t = heappop(que)
root_s = find(s)
root_t = find(t)
if root_s != root_t:
pair_lst[root_s] = root_t
length_sum += w
print(length_sum)
|
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()))
elif icase==1:
n=3
# xy=[[1, 5], [3, 9], [7, 8]]
x=[1, 3, 7]
y=[5, 9, 8]
elif icase==2:
n=6
# xy=[[8, 3], [4, 9], [12, 19], [18, 1], [13, 5], [7, 6]]
x=[8, 4, 12,18,13,7]
y=[3, 9, 19, 1, 5, 6]
xi=[[0]*2 for i in range(n)]
yi=[[0]*2 for i in range(n)]
for i in range(n):
xi[i]=[x[i],i]
yi[i]=[y[i],i]
xi.sort()
x=xi
y=yi.sort()
y=yi
pair_lst = [i for i in range(n)]
que=[]
for i in range(n-1):
wi=x[i+1][0]-x[i][0]
heappush(que,(wi,x[i][1],x[i+1][1]))
wi=y[i+1][0]-y[i][0]
heappush(que,(wi,y[i][1],y[i+1][1]))
def find(x):
if x == pair_lst[x]:
return x
else:
tmp = find(pair_lst[x])
pair_lst[x] = tmp
return tmp
icnt=0
length_sum = 0
while que:
w, s, t = heappop(que)
# print(w,s,t)
root_s = find(s)
root_t = find(t)
if root_s != root_t:
pair_lst[root_s] = root_t
length_sum += w
icnt+=1
# print(icnt)
print(length_sum)
|
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()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
#D
def root(x):
if x == par[x]:
return x
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 rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
v = LIR(n)
l = []
for i in range(n):
v[i].append(i)
par = [i for i in range(n)]
rank = [0 for i in range(n)]
v.sort(key = lambda x:x[0])
for i in range(n-1):
l.append([v[i][2],v[i+1][2],v[i+1][0]-v[i][0]])
v.sort(key = lambda x:x[1])
for i in range(n-1):
l.append([v[i][2],v[i+1][2],v[i+1][1]-v[i][1]])
l.sort(key = lambda x:x[2])
k = 0
ans = 0
while k != n-1:
x,y,c = l.pop(0)
if not same(x,y):
k += 1
ans += c
unite(x,y)
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
#!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()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
#D
def root(x):
if x == par[x]:
return x
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 rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
v = LIR(n)
l = []
for i in range(n):
v[i].append(i)
par = [i for i in range(n)]
rank = [0 for i in range(n)]
v.sort(key = lambda x:x[0])
for i in range(n-1):
l.append([v[i][2],v[i+1][2],v[i+1][0]-v[i][0]])
v.sort(key = lambda x:x[1])
for i in range(n-1):
l.append([v[i][2],v[i+1][2],v[i+1][1]-v[i][1]])
l.sort(key = lambda x:x[2])
k = 0
ans = 0
for i in range(len(l)):
x,y,c = l[i]
if not same(x,y):
k += 1
ans += c
unite(x,y)
if k == n-1:break
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
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()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
#D
def root(x):
if x == par[x]:
return x
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 rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
v = LIR(n)
l = []
for i in range(n):
v[i].append(i)
par = [i for i in range(n)]
rank = [0 for i in range(n)]
v.sort(key = lambda x:x[0])
for i in range(n-1):
l.append([v[i][2],v[i+1][2],v[i+1][0]-v[i][0]])
v.sort(key = lambda x:x[1])
for i in range(n-1):
l.append([v[i][2],v[i+1][2],v[i+1][1]-v[i][1]])
l.sort(key = lambda x:x[2])
k = 0
ans = 0
for i in range(len(l)):
x,y,c = l[i]
if not same(x,y):
k += 1
ans += c
unite(x,y)
if k == n-1:break
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
#!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()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
#D
def root(x):
if x == par[x]:
return x
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 rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
v = LIR(n)
l = [None for i in range(2*n-2)]
for i in range(n):
v[i].append(i)
par = [i for i in range(n)]
rank = [0 for i in range(n)]
v.sort(key = lambda x:x[0])
for i in range(n-1):
l[i] = [v[i][2],v[i+1][2],v[i+1][0]-v[i][0]]
v.sort(key = lambda x:x[1])
for i in range(n-1):
l[i+n-1] = [v[i][2],v[i+1][2],v[i+1][1]-v[i][1]]
l.sort(key = lambda x:x[2])
k = 0
ans = 0
for i in range(2*n-2):
x,y,c = l[i]
if not same(x,y):
k += 1
ans += c
unite(x,y)
if k == n-1:break
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
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()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
#D
def root(x):
if x == par[x]:
return x
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)
par[x] = y
n = I()
v = LIR(n)
l = [None for i in range(2*n-2)]
for i in range(n):
v[i].append(i)
par = [i for i in range(n)]
v.sort(key = lambda x:x[0])
for i in range(n-1):
l[i] = [v[i][2],v[i+1][2],v[i+1][0]-v[i][0]]
v.sort(key = lambda x:x[1])
for i in range(n-1):
l[i+n-1] = [v[i][2],v[i+1][2],v[i+1][1]-v[i][1]]
l.sort(key = lambda x:x[2])
k = 0
ans = 0
for i in range(2*n-2):
x,y,c = l[i]
if not same(x,y):
k += 1
ans += c
unite(x,y)
if k == n-1:break
print(ans)
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
#!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 sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n = I()
p = LIR(n)
for i in range(n):
p[i].append(i)
p.sort()
v = []
for i in range(n-1):
x,y,c = p[i]
a,b,d = p[i+1]
v.append((min(abs(x-a),abs(y-b)),c,d))
p.sort(key = lambda x:x[1])
for i in range(n-1):
x,y,c = p[i]
a,b,d = p[i+1]
v.append((min(abs(x-a),abs(y-b)),c,d))
v.sort()
par = [i for i in range(n)]
rank = [0]*n
ans = 0
for c,a,b in v:
if root(a) != root(b):
ans += c
unite(a,b)
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
|
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 = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
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
# 木の高さが同じなら片方を1増やす
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
X = [[0] * 2 for i in range(N)]
Y = [[0] * 2 for i in range(N)]
for i in range(N):
x, y = list(map(int, input().split()))
X[i][0] = x
X[i][1] = i
Y[i][0] = y
Y[i][1] = i
# 元indexを保持して座標位置順にソート
X.sort()
Y.sort()
edges = []
for i in range(1, N):
# 座標上で隣り合う頂点同士で辺集合を作る
edges.append((X[i-1][1], X[i][1], X[i][0] - X[i-1][0]))
edges.append((Y[i-1][1], Y[i][1], Y[i][0] - Y[i-1][0]))
# コスト順にソート
edges.sort(key=itemgetter(2))
uf = UnionFind(N)
ans = 0
# Union-Findで閉路を作らない確認をして最小全域木を作る
for x, y, w in edges:
if not uf.same(x, y):
uf.union(x, y)
ans += w
print(ans)
|
# -*- 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、その場合は[0]は未使用
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
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
# 木の高さが同じなら片方を1増やす
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
X = [[0] * 2 for i in range(N)]
Y = [[0] * 2 for i in range(N)]
for i in range(N):
x, y = list(map(int, input().split()))
X[i][0] = x
X[i][1] = i
Y[i][0] = y
Y[i][1] = i
# 元indexを保持して座標位置順にソート
X.sort()
Y.sort()
edges = []
for i in range(1, N):
# 座標上で隣り合う頂点同士で辺集合を作る
edges.append((X[i-1][1], X[i][1], X[i][0] - X[i-1][0]))
edges.append((Y[i-1][1], Y[i][1], Y[i][0] - Y[i-1][0]))
# コスト順にソート
edges.sort(key=itemgetter(2))
uf = UnionFind(N)
ans = 0
grp = N
# Union-Findで閉路を作らない確認をして最小全域木を作る
for x, y, w in edges:
if not uf.same(x, y):
uf.union(x, y)
ans += w
grp -= 1
# グループが1つになれば、それ以上やる必要ない
if grp == 1:
break
print(ans)
|
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、その場合は[0]は未使用
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
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
# 木の高さが同じなら片方を1増やす
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
X = [[0] * 2 for i in range(N)]
Y = [[0] * 2 for i in range(N)]
for i in range(N):
x, y = list(map(int, input().split()))
X[i][0] = x
X[i][1] = i
Y[i][0] = y
Y[i][1] = i
# 元indexを保持して座標位置順にソート
X.sort()
Y.sort()
edges = []
for i in range(1, N):
# 座標上で隣り合う頂点同士で辺集合を作る
edges.append((X[i-1][1], X[i][1], X[i][0] - X[i-1][0]))
edges.append((Y[i-1][1], Y[i][1], Y[i][0] - Y[i-1][0]))
# コスト順にソート
edges.sort(key=itemgetter(2))
uf = UnionFind(N)
ans = 0
grp = N
# Union-Findで閉路を作らない確認をして最小全域木を作る
for x, y, w in edges:
if not uf.same(x, y):
uf.union(x, y)
ans += w
grp -= 1
# グループが1つになれば、それ以上やる必要ない
if grp == 1:
break
print(ans)
|
# -*- 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、その場合は[0]は未使用
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
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
# 木の高さが同じなら片方を1増やす
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
N = int(eval(input()))
X = [[0] * 2 for i in range(N)]
Y = [[0] * 2 for i in range(N)]
for i in range(N):
x, y = list(map(int, input().split()))
X[i][0] = x
X[i][1] = i
Y[i][0] = y
Y[i][1] = i
# 元indexを保持して座標位置順にソート
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
edges = []
for i in range(1, N):
# 座標上で隣り合う頂点同士で辺集合を作る
edges.append((X[i-1][1], X[i][1], X[i][0] - X[i-1][0]))
edges.append((Y[i-1][1], Y[i][1], Y[i][0] - Y[i-1][0]))
# コスト順にソート
edges.sort(key=itemgetter(2))
uf = UnionFind(N)
ans = 0
grp = N
# Union-Findで閉路を作らない確認をして最小全域木を作る
for x, y, w in edges:
if not uf.same(x, y):
uf.union(x, y)
ans += w
grp -= 1
# グループが1つになれば、それ以上やる必要ない
if grp == 1:
break
print(ans)
|
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, y = list(map(int, input().split()))
POINT_x.append((x, y))
POINT_y.append((x, y))
POINT_x = sorted(POINT_x, key=lambda x: x[0])
POINT_y = sorted(POINT_y, key=lambda x: x[1])
EDGE = defaultdict(list)
for i in range(N):
p = POINT_x[i]
if i != 0:
prev = POINT_x[i-1]
EDGE[p].append((abs(p[0]-prev[0]), prev))
if i != N-1:
nxt = POINT_x[i+1]
EDGE[p].append((abs(p[0]-nxt[0]), nxt))
for i in range(N):
p = POINT_y[i]
if i != 0:
prev = POINT_y[i-1]
EDGE[p].append((abs(p[1]-prev[1]), prev))
if i != N-1:
nxt = POINT_y[i+1]
EDGE[p].append((abs(p[1]-nxt[1]), nxt))
INF = 10 ** 12
mincost = [INF] * N
used = defaultdict(lambda: False)
point = POINT_x[0]
used[point] = True
q = []
ans = 0
for e in EDGE[point]:
heapq.heappush(q, e)
while(True):
update = False
for _ in range(len(q)):
cost, point = heapq.heappop(q)
if used[point]:
continue
update = True
ans += cost
used[point] = True
for e in EDGE[point]:
heapq.heappush(q, e)
if not update:
break
print(ans)
|
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, y = list(map(int, input().split()))
POINT_x.append((x, y))
POINT_y.append((x, y))
POINT_x = sorted(POINT_x, key=lambda x: x[0])
POINT_y = sorted(POINT_y, key=lambda x: x[1])
EDGE = defaultdict(list)
for i in range(N):
p = POINT_x[i]
if i != 0:
prev = POINT_x[i-1]
EDGE[p].append((abs(p[0]-prev[0]), prev))
if i != N-1:
nxt = POINT_x[i+1]
EDGE[p].append((abs(p[0]-nxt[0]), nxt))
for i in range(N):
p = POINT_y[i]
if i != 0:
prev = POINT_y[i-1]
EDGE[p].append((abs(p[1]-prev[1]), prev))
if i != N-1:
nxt = POINT_y[i+1]
EDGE[p].append((abs(p[1]-nxt[1]), nxt))
INF = 10 ** 12
mincost = [INF] * N
used = defaultdict(lambda: False)
point = POINT_x[0]
used[point] = True
q = []
ans = 0
for e in EDGE[point]:
heapq.heappush(q, e)
while(True):
update = False
for _ in range(len(q)):
cost, point = heapq.heappop(q)
if used[point]:
continue
update = True
ans += cost
used[point] = True
for e in EDGE[point]:
if not used[e[1]]:
heapq.heappush(q, e)
if not update:
break
print(ans)
|
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)
# 根をbxに統一
A[by] = bx
N = int(eval(input()))
X = [(0,0)] * N
Y = [(0,0)] * N
E = [(0,0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
E[i] = (x, y)
X.sort()
Y.sort()
H = []
heapify(H)
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i + 1]
y1, k1 = Y[i]
y2, k2 = Y[i + 1]
# ヒープ構造を用いて常にHの最初に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
V = [i for i in range(N)]
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if find(V, s) != find(V, t):
union(V, s, t)
answer += w
print(answer)
|
# 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), find(A, y)
# 根をbx(値の小さい方)に統一
A[by] = bx
N = int(eval(input()))
X = [(0,0)] * N
Y = [(0,0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
X.sort()
Y.sort()
H = []
heapify(H)
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i+1]
y1, k1 = Y[i]
y2, k2 = Y[i+1]
# ヒープ構造を用いて常にHの先頭に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
V = [i for i in range(N)]
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if find(V, s) != find(V, t):
union(V, s, t)
answer += w
print(answer)
|
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
data[root] += data[second]
height[root] = max(height[root], height[second]+1)
data[second] = root
return True
N = int(eval(input()))
X = [(0,0)] * N
Y = [(0,0)] * N
E = [(0,0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
X.sort()
Y.sort()
H = []
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i + 1]
y1, k1 = Y[i]
y2, k2 = Y[i + 1]
# ヒープ構造を用いて常にHの最初に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
data = [-1] * (N+1) # 1-indexed rootには-sizeが入る
height = [0] * (N+1)
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if union(s, t):
answer += w
print(answer)
|
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] < data[second]:
second, root = root, second
data[root] += data[second]
height[root] = max(height[root], height[second]+1)
data[second] = root
return True
N = int(eval(input()))
X = [(0,0)] * N
Y = [(0,0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
X.sort()
Y.sort()
H = []
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i + 1]
y1, k1 = Y[i]
y2, k2 = Y[i + 1]
# ヒープ構造を用いて常にHの最初に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
data = [-1] * (N+1) # 1-indexed rootには-sizeが入る
height = [0] * (N+1)
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if union(s, t):
answer += w
print(answer)
if __name__ == "__main__":
main()
|
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 = [[] for i in range(lenT)]
for i in range(lenT-1):
xc, yc = cost(Tx[i][0], Tx[i][1], Tx[i+1][0], Tx[i+1][1]), cost(Ty[i][0], Ty[i][1], Ty[i+1][0], Ty[i+1][1])
P[T.index(Tx[i])].append([xc, T.index(Tx[i+1])])
P[T.index(Tx[i+1])].append([xc, T.index(Tx[i])])
P[T.index(Ty[i])].append([yc, T.index(Ty[i+1])])
P[T.index(Ty[i+1])].append([yc, T.index(Ty[i])])
Visit = [False for i in range(lenT)]
Visit[0] = True
Q = [p for p in P[0]]
heapq.heapify(Q)
Total = 0
while Q:
nextCost, nextNode = heapq.heappop(Q)
if Visit[nextNode] == False:
Total += nextCost
Visit[nextNode] = True
for t in P[nextNode]:
if Visit[t[1]] == False:
heapq.heappush(Q, [t[0], t[1]])
print(Total)
|
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
road[i] = (x, y, i)
roadx[i] = (x, y, i)
roady[i] = (x, y, i)
roadx.sort()
roadx_id = dict()
roady.sort(key = itemgetter(1))
roady_id = dict()
for i in range(N):
roadx_id[roadx[i]] = i
roady_id[roady[i]] = i
visited = [False] * N
q = []
heapq.heapify(q)
heapq.heappush(q, (0, 0)) #(cost, town_id)
cost = 0
while q:
add_cost, id = heapq.heappop(q)
#print(add_cost, id, cost)
#print(visited)
if not visited[id]:
cost += add_cost
visited[id] = True
for s in range(2):
nx = roadx_id[road[id]] + (-1) ** s #roadxにおけるid
if 0 <= nx < N:
if not visited[town[roadx[nx]]]: heapq.heappush(q, (min(abs(road[id][0] - roadx[nx][0]), abs(road[id][1] - roadx[nx][1])), town[roadx[nx]]))
ny = roady_id[road[id]] + (-1) ** s #roadyにおけるid
if 0 <= ny < N:
if not visited[town[roady[ny]]]: heapq.heappush(q, (min(abs(road[id][1] - roady[ny][1]), abs(road[id][1] - roady[ny][1])), town[roady[ny]]))
print(cost)
return 0
if __name__ == "__main__":
solve()
|
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][1]))
cost=Y[n+1][0]-Y[n][0]
D[Y[n+1][1]].append((cost,Y[n][1]))
D[Y[n][1]].append((cost,Y[n+1][1]))
visited=[0]*N
pq = []
for w, t in D[0]:
heappush(pq,(w,t))
visited[0]=1
ans = 0
while pq:
w,t=heappop(pq)
if visited[t]:
continue
visited[t]=1
ans+=w
for w,s in D[t]:
if visited[s]==0:
heappush(pq,(w,s))
print (ans)
|
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))
es.sort(key=lambda x:x[0])
class UnionFind:
def __init__(self,N):
self.parent = [i for i in range(N)]
self._size = [1] * N
self.count = 0
def root(self,a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self._size[ra] < self._size[rb]: ra,rb = rb,ra
self._size[ra] += self._size[rb]
self.parent[rb] = ra
self.count += 1
def size(self,a):
return self._size[self.root(a)]
uf = UnionFind(N)
ans = 0
for d,a,b in es:
if uf.is_same(a,b): continue
uf.unite(a,b)
ans += d
print(ans)
|
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 range(n)]
def f(x):
if x==t[x]:
return x
x=t[x]
return f(t[x])
c=0
for i,j,h in s:
j,h=f(j),f(h)
if h!=j:
t[j]=h
c+=i
print(c)
|
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 range(n)]
def f(x):
if x==t[x]:
return x
t[x]=f(t[x])
return f(t[x])
c=0
for i,j,h in s:
j,h=f(j),f(h)
if h!=j:
t[j]=h
c+=i
print(c)
|
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]=y
X=[]
Y=[]
for i in range(N):
x,y=list(map(int, sys.stdin.readline().split()))
X.append( (x,i) )
Y.append( (y,i) )
X.sort(key=lambda x: x[0])
Y.sort(key=lambda x: x[0])
hq=[]
prev_x=None
prev_i=None
for x,i in X:
if prev_x is not None:
heappush( hq, ( x-prev_x, i, prev_i) )
prev_x=x
prev_i=i
prev_x=None
prev_i=None
for x,i in Y:
if prev_x is not None:
heappush( hq, ( x-prev_x, i, prev_i) )
prev_x=x
prev_i=i
ans=0
while hq:
d,a,b=heappop(hq)
if not same(a,b):
ans+=d
unite(a,b)
print (ans)
|
# -*- 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_x,fro=V[i][0],V[i][2]
to_x,to=V[i+1][0],V[i+1][2]
E.append( (abs(fro_x-to_x),fro,to))
#頂点をx軸でソート
V.sort(key=lambda x:(x[1]) )
for i in range(N-1):
fro_y,fro=V[i][1],V[i][2]
to_y,to=V[i+1][1],V[i+1][2]
E.append( (abs(fro_y-to_y),fro,to))
#辺の集合を辺の長さで昇順ソート
E.sort(key=lambda x:(x[0]) )
par=[ i for i in range(N+1) ]
size=[ 1 for i in range(N+1) ]
#Union Find
def root(x):
while par[x]!=x:
x=par[x]
return x
def same(x,y):
return root(x)==root(y)
def unite(x,y):
x=root(x)
y=root(y)
if x==y: return
if size[y]<size[x]: x,y=y,x #yの要素数を大きくする
size[y]+=size[x]
par[x]=y #yが親ノード
def getsize(x):
return size[root(x)]
ans=0
for cost,v1,v2 in E:
if same(v1,v2) is False:
ans+=cost
unite(v1,v2)
print(ans)
|
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 input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
show_flg=False
show_flg=True
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
def _root(self, x):
if self.table[x] < 0:
return x
else:
# 経路の圧縮
self.table[x] = self._root(self.table[x])
return self.table[x]
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
def __str__(self):
rt=[i if j<0 else j for i,j in enumerate(self.table)]
return str(rt)
def dijkstra(edge,st):
# edge=[[(v_to,dist_to_v),...],[],...]
# initialize: def: d=dist(st,i), prev=[previous vertex in minimum path], q[]
n=len(edge)
d=[(0 if st==i else inf) for i in range(n)]
prev=[0]*n
q=[(j,i) for i,j in enumerate(d)]
heapify(q)
# calc
while q:
dist,cur=heappop(q)
for dst,dist in edge[cur]:
alt=d[cur]+dist
if alt<d[dst]:
d[dst]=alt
prev[dst]=cur
heappush(q,(alt,dst))
return d,prev
n=I()
p=[]
for i in range(n):
x,y=LI()
p.append((x,y,i))
X=sorted(p,key=lambda x:x[0])
Y=sorted(p,key=lambda x:x[1])
g=[[] for i in range(n)]
q=[]
for i in range(n-1):
x0,y0,a=X[i]
x1,y1,b=X[i+1]
q.append((min(abs(x1-x0),abs(y1-y0)),a,b))
for i in range(n-1):
x0,y0,a=Y[i]
x1,y1,b=Y[i+1]
q.append((min(abs(x1-x0),abs(y1-y0)),a,b))
uf=UnionFind(n)
heapify(q)
ans=0
e=n-1
while e:
d,a,b=heappop(q)
if uf._root(a)!=uf._root(b):
ans+=d
uf.union(a,b)
e-=1
print(ans)
|
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 input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
show_flg=False
show_flg=True
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
def _root(self, x):
if self.table[x] < 0:
return x
else:
# 経路の圧縮
self.table[x] = self._root(self.table[x])
return self.table[x]
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
def __str__(self):
rt=[i if j<0 else j for i,j in enumerate(self.table)]
return str(rt)
def dijkstra(edge,st):
# edge=[[(v_to,dist_to_v),...],[],...]
# initialize: def: d=dist(st,i), prev=[previous vertex in minimum path], q[]
n=len(edge)
d=[(0 if st==i else inf) for i in range(n)]
prev=[0]*n
q=[(j,i) for i,j in enumerate(d)]
heapify(q)
# calc
while q:
dist,cur=heappop(q)
for dst,dist in edge[cur]:
alt=d[cur]+dist
if alt<d[dst]:
d[dst]=alt
prev[dst]=cur
heappush(q,(alt,dst))
return d,prev
n=I()
p=[]
for i in range(n):
x,y=LI()
p.append((x,y,i))
X=sorted(p,key=lambda x:x[0])
Y=sorted(p,key=lambda x:x[1])
g=[[] for i in range(n)]
q=[]
for i in range(n-1):
x0,y0,a=X[i]
x1,y1,b=X[i+1]
q.append((min(abs(x1-x0),abs(y1-y0)),a,b))
for i in range(n-1):
x0,y0,a=Y[i]
x1,y1,b=Y[i+1]
q.append((min(abs(x1-x0),abs(y1-y0)),a,b))
uf=UnionFind(n)
q.sort(reverse=True,key=lambda x:x[0])
ans=0
e=n-1
while e:
d,a,b=q.pop()
if uf._root(a)!=uf._root(b):
ans+=d
uf.union(a,b)
e-=1
print(ans)
|
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))
x.sort()
y.sort()
for i in range(N-1):
dx = x[i+1][0] - x[i][0]
dy = y[i+1][0] - y[i][0]
root[x[i][1]].append((dx,x[i+1][1]))
root[x[i+1][1]].append((dx,x[i][1]))
root[y[i][1]].append((dy,y[i+1][1]))
root[y[i+1][1]].append((dy,y[i][1]))
ans = 0
queue = root[0]
heapq.heapify(queue)
go[0] = False
while queue:
cost,following = heapq.heappop(queue)
if not go[following]:
continue
go[following] = False
for e in root[following]:
if go[e[1]]:
heapq.heappush(queue,e)
ans += cost
print(ans)
if __name__ == "__main__":
main()
|
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 root(x):
if x == I[x]:
return x
I[x] = root(I[x])
return I[x]
def unite(x,y):
px,py = root(x),root(y)
rx,ry = rank[px],rank[py]
if rx > ry:
I[py] = px
else:
I[px] = py
if rx == ry:
rank[py] += 1
ans = 0
rx.sort()
ry.sort()
for i in range(N-1):
dx = rx[i+1][0]-rx[i][0]
dy = ry[i+1][0]-ry[i][0]
_root.append((dx,rx[i][1],rx[i+1][1]))
_root.append((dy,ry[i][1],ry[i+1][1]))
_root.sort()
a = len(_root)
for i in range(a):
cost,now,fol = _root[i]
if (root(now) == root(fol)):
continue
ans += cost
unite(now,fol)
print(ans)
if __name__ == "__main__":
main()
|
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][1])]]
ixy.sort(key=lambda y:y[2])
for j in range(N-1):
costs[ixy[j][0]] += [[ixy[j+1][0],abs(ixy[j][2]-ixy[j+1][2])]]
costs[ixy[j+1][0]] += [[ixy[j][0],abs(ixy[j][2]-ixy[j+1][2])]]
import heapq
pq = []
heapq.heappush(pq,[0,0])
visited = [0]*N
ans = 0
while pq:
cost, v = heapq.heappop(pq)
if visited[v]: continue
ans += cost
visited[v]=1
for u,c in costs[v]:
if not visited[u]:
heapq.heappush(pq, [c,u])
print(ans)
|
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]
# 併合
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
# 小さいほうが個数が多い
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
return False
N = int(eval(input()))
ixy=[]
for i in range(N):
x, y = list(map(int,input().split()))
ixy+=[[i,x,y]]
costs = []
ixy.sort(key=lambda x:x[1])
for j in range(N-1):
costs += [(ixy[j][0], ixy[j+1][0], ixy[j+1][1]-ixy[j][1])]
costs += [(ixy[j+1][0], ixy[j][0], ixy[j+1][1]-ixy[j][1])]
ixy.sort(key=lambda y:y[2])
for j in range(N-1):
costs += [(ixy[j][0], ixy[j+1][0], ixy[j+1][2]-ixy[j][2])]
costs += [(ixy[j+1][0], ixy[j][0], ixy[j+1][2]-ixy[j][2])]
costs.sort(key=lambda cost:cost[2])
ans = 0
roots = UnionFind(N)
for cost in costs:
u, v, c = cost
if roots.find(u)!=roots.find(v):
roots.union(u, v)
ans += c
print(ans)
|
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]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def nums(self,x):
return abs(self.parents[self.find(x)])
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
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()))+[i] for i in range(N)]
edge = []
A.sort()
for i in range(N-1):
w = min(abs(A[i+1][0]-A[i][0]),abs(A[i+1][1]-A[i][1]))
edge.append((w,A[i][2],A[i+1][2]))
A.sort(key=lambda x:x[1])
for i in range(N-1):
w = min(abs(A[i+1][0]-A[i][0]),abs(A[i+1][1]-A[i][1]))
edge.append((w,A[i][2],A[i+1][2]))
edge.sort()
uf = UnionFind(N)
ans = 0
for i in range(len(edge)):
u,x,y = edge[i]
if not uf.same(x,y):
uf.union(x,y)
ans += u
print(ans)
|
#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]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def nums(self,x):
return abs(self.parents[self.find(x)])
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
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()))+[i] for i in range(N)]
edge = []
A.sort()
for i in range(N-1):
w = A[i+1][0]-A[i][0]
edge.append((w,A[i][2],A[i+1][2]))
A.sort(key=lambda x:x[1])
for i in range(N-1):
w = A[i+1][1]-A[i][1]
edge.append((w,A[i][2],A[i+1][2]))
edge.sort()
uf = UnionFind(N)
ans = 0
for i in range(len(edge)):
u,x,y = edge[i]
if not uf.same(x,y):
uf.union(x,y)
ans += u
print(ans)
|
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]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def nums(self,x):
return abs(self.parents[self.find(x)])
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
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()))+[i] for i in range(N)]
edge = []
A.sort()
for i in range(N-1):
w = A[i+1][0]-A[i][0]
edge.append((w,A[i][2],A[i+1][2]))
A.sort(key=lambda x:x[1])
for i in range(N-1):
w = A[i+1][1]-A[i][1]
edge.append((w,A[i][2],A[i+1][2]))
edge.sort()
uf = UnionFind(N)
ans = 0
for i in range(len(edge)):
u,x,y = edge[i]
if not uf.same(x,y):
uf.union(x,y)
ans += u
print(ans)
|
#最小全域木問題、プリム法
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]].append((w,A[i][2]))
A.sort(key=lambda x:x[1])
for i in range(N-1):
w = A[i+1][1]-A[i][1]
edge[A[i][2]].append((w,A[i+1][2]))
edge[A[i+1][2]].append((w,A[i][2]))
bridges = []
heapify(bridges)
used = [False]*N
used[0] = True
ans = 0
for w,v in edge[0]:
heappush(bridges,(w,v))
while len(bridges)>0:
w,v = heappop(bridges)
if used[v]==False:
ans += w
used[v] = True
for w,u in edge[v]:
if used[u]==False:
heappush(bridges,(w,u))
return ans
print((solve()))
|
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(self, x, y):
x, y = self.find(x), self.find(y)
if x == y: return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
self.rank[x] += (self.rank[x] == self.rank[y])
def kruskal(n, edge):
ans = 0
uf = UnionFind(n)
while True:
d, v, u = heapq.heappop(edge)
if uf.find(v) != uf.find(u):
uf.union(v, u)
n -= 1
ans += d
if n < 2: return ans
return ans
n = int(eval(input()))
x, y = [None]*n, [None]*n
dist = [[0] * n for _ in range(n)]
for i in range(n):
a, b = list(map(int, input().split()))
x[i] = (a, i)
y[i] = (b, i)
x.sort(key=lambda x:x[0])
y.sort(key=lambda y:y[0])
edge = []
for i in range(n-1):
heapq.heappush(edge, (x[i+1][0]-x[i][0], x[i][1], x[i+1][1]))
heapq.heappush(edge, (y[i+1][0]-y[i][0], y[i][1], y[i+1][1]))
del x, y
print((kruskal(n, edge)))
|
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(self, x, y):
x, y = self.find(x), self.find(y)
if x == y: return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
self.rank[x] += (self.rank[x] == self.rank[y])
def kruskal(n, edge):
ans = 0
uf = UnionFind(n)
while True:
d, v, u = heapq.heappop(edge)
if uf.find(v) != uf.find(u):
uf.union(v, u)
n -= 1
ans += d
if n < 2: return ans
return ans
n = int(eval(input()))
x, y = [None]*n, [None]*n
for i in range(n):
a, b = list(map(int, input().split()))
x[i] = (a, i)
y[i] = (b, i)
x.sort(key=lambda x:x[0])
y.sort(key=lambda y:y[0])
edge = []
for i in range(n-1):
heapq.heappush(edge, (x[i+1][0]-x[i][0], x[i][1], x[i+1][1]))
heapq.heappush(edge, (y[i+1][0]-y[i][0], y[i][1], y[i+1][1]))
del x, y
print((kruskal(n, edge)))
|
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)
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
n=int(eval(input()))
x=[[0,0] for _ in range(n)]
y=[[0,0] for _ in range(n)]
for i in range(n):
x[i][0],y[i][0]=list(map(int,input().split()))
x[i][1],y[i][1]=i+1,i+1
dx,dy=[],[]
x,y=sorted(x),sorted(y)
for i in range(n-1):
dx.extend([(abs(x[i][0]-x[i+1][0]),x[i][1],x[i+1][1])])
dy.extend([(abs(y[i][0]-y[i+1][0]),y[i][1],y[i+1][1])])
target=sorted(dx+dy)
tree=UnionFind(n)
cnt,cost,i=0,0,0
while cnt<n-1:
c,a,b=target[i]
if tree.find(a)!=tree.find(b):
cost+=c
tree.union(a,b)
cnt+=1
i+=1
print(cost)
|
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.find(b)
if a==b:return
if self.size[a]>self.size[b]:
self.size[a]+=self.size[b]
self.parent[b]=a
else:
self.size[b]+=self.size[a]
self.parent[a]=b
def isunited(self,a,b):
return self.find(a)==self.find(b)
N=int(eval(input()))
l=[[i+1]+list(map(int,input().split())) for i in range(N)]
o=[]
l.sort(key=lambda x:x[1])
for i in range(N-1):
o.append((l[i][0],l[i+1][0],l[i+1][1]-l[i][1]))
l.sort(key=lambda x:x[2])
for i in range(N-1):
o.append((l[i][0],l[i+1][0],l[i+1][2]-l[i][2]))
o.sort(key=lambda x:x[2])
ans=0
uft=UnionFind(N)
for town1,town2,cost in o:
if not uft.isunited(town1,town2):
uft.unite(town1,town2)
ans+=cost
print(ans)
|
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.find(b)
if a==b:return
if self.size[a]>self.size[b]:
self.size[a]+=self.size[b]
self.parent[b]=a
else:
self.size[b]+=self.size[a]
self.parent[a]=b
def isunited(self,a,b):
return self.find(a)==self.find(b)
N=int(eval(input()))
l=[[i+1]+list(map(int,input().split())) for i in range(N)]
o=[]
l.sort(key=lambda x:x[1])
for i in range(N-1):
o.append((l[i][0],l[i+1][0],l[i+1][1]-l[i][1]))
l.sort(key=lambda x:x[2])
for i in range(N-1):
o.append((l[i][0],l[i+1][0],l[i+1][2]-l[i][2]))
o.sort(key=lambda x:x[2])
ans=0
uft=UnionFind(N)
for town1,town2,cost in o:
if not uft.isunited(town1,town2):
uft.unite(town1,town2)
ans+=cost
print(ans)
|
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):
return self.size[self.find(a)]
def unite(self, a, b):
a=self.find(a)
b=self.find(b)
if a==b:return
if self.size[a]>self.size[b]:
self.size[a]+=self.size[b]
self.parent[b]=a
else:
self.size[b]+=self.size[a]
self.parent[a]=b
def isunited(self, a, b):
return self.find(a)==self.find(b)
N = int(eval(input()))
l = []
q = []
for i in range(N):
x, y = list(map(int, input().split()))
l.append((x, y, i+1))
l.sort()
for i in range(N-1):
x1, y1, s = l[i]
x2, y2, t = l[i+1]
q.append((abs(x1-x2), s, t))
l.sort(key=lambda x:x[1])
for i in range(N-1):
x1, y1, s = l[i]
x2, y2, t = l[i+1]
q.append((abs(y1-y2), s, t))
uft = UnionFind(N)
ans = 0
q.sort()
for cost, s, t in q:
if not uft.isunited(s, t):
ans += cost
uft.unite(s, t)
print(ans)
|
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
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self, x, y):
#同じかどうかの確認
return self.find(x) == self.find(y)
def union(self, x, y):
#統合する
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
elif self.rank[x] > self.rank[y]:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
else:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
def getsize(self, x):
p = self.find(x)
return self.size[p]
x = []
y = []
for i in range(n):
a,b = list(map(int, input().split()))
x.append([a,i+1])
y.append([b,i+1])
x.sort()
y.sort()
edge = []
for i in range(n-1):
edge.append([x[i+1][0] - x[i][0],x[i+1][1],x[i][1]])
edge.append([y[i+1][0] - y[i][0],y[i+1][1],y[i][1]])
#edge[i][0] = cost, [1] -> [2]でつながっている辺
edge.sort()
UF = UnionFind(n)
ans = 0
for i in range(len(edge)):
cost,a,b = edge[i]
if UF.same_check(a,b):
continue
else:
ans += cost
UF.union(a,b)
print(ans)
|
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] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self, x, y):
#同じかどうかの確認
return self.find(x) == self.find(y)
def union(self, x, y):
#統合する
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
elif self.rank[x] > self.rank[y]:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
else:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
def getsize(self, x):
p = self.find(x)
return self.size[p]
x = []
y = []
for i in range(n):
a,b = list(map(int, input().split()))
x.append([a,i+1])
y.append([b,i+1])
x.sort(key = lambda x: x[0])
y.sort(key = lambda x: x[0])
edge = []
for i in range(n-1):
edge.append([x[i+1][0] - x[i][0],x[i+1][1],x[i][1]])
edge.append([y[i+1][0] - y[i][0],y[i+1][1],y[i][1]])
#edge[i][0] = cost, [1] -> [2]でつながっている辺
edge.sort(key = lambda x: x[0])
UF = UnionFind(n)
ans = 0
for i in range(len(edge)):
cost,a,b = edge[i]
if UF.same_check(a,b):
continue
else:
ans += cost
UF.union(a,b)
print(ans)
|
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]
sort_y_ix = sorted(ix, key=lambda i:y[i])
sort_y = [y[i] for i in sort_y_ix]
g = [i for i in range(N+1)]
def root(x):
if g[x] == x : return x
g[x] = root(g[x])
return g[x]
q = []
for i in range(N-1):
q.append((sort_x[i+1]-sort_x[i],sort_x_ix[i],sort_x_ix[i+1]))
q.append((sort_y[i+1]-sort_y[i],sort_y_ix[i],sort_y_ix[i+1]))
q.sort()
ans = 0
cnt = N
for d,s,t in q:
if cnt <= 1: break
if root(s) != root(t):
ans += d
cnt -= 1
g[root(t)] = g[s]
print(ans)
|
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(N)]
x.sort()
y.sort()
edge = []
p,i = x[0]
for q,j in x[1:]:
edge.append((q-p,i,j))
p,i = q,j
p,i = y[0]
for q,j in y[1:]:
edge.append((q-p,i,j))
p,i = q,j
edge.sort()
g = [i for i in range(N + 1)]
g_num = [1 for i in range(N + 1)]
def find(x):
if g[x] == x: return x
g[x] = find(g[x])
return g[x]
def union(x, y):
if find(x) == find(y): return
if g_num[g[x]] < g_num[g[y]]: x, y = y, x
g_num[g[x]] += g_num[g[y]]
g_num[g[y]] = 0
g[g[y]] = g[x]
ans = 0
for v,i,j in edge:
if find(i) != find(j):
ans += v
union(i,j)
print(ans)
if __name__ == '__main__':
main()
|
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))
self.cost[v].append((u,w))
def prim(self):
que = []
heapify(que)
used = self.used
for e in self.cost[0]:
heappush(que,[e[1],e[0]])
used[0] = True
res = 0
while que:
p = heappop(que)
cos,v = p
if used[v]:continue
self.used[v] = True
for e in self.cost[v]:
if not used[e[0]]:
heappush(que,[e[1],e[0]])
res += cos
return res
def main():
N = int(eval(input()))
cost = []
for i in range(N):
x,y = list(map(int,input().split()))
cost.append((x,y,i))
prim = Prim(N)
x = sorted(cost,key=lambda x: x[0])
y = sorted(cost,key=lambda x: x[1])
for i in range(N-1):
a,b,u = x[i]
c,d,v = x[i+1]
w = min(abs(a-c),abs(b-d))
prim.setcost(u,v,w)
e,f,s = y[i]
g,h,t = y[i+1]
u = min(abs(e-g),abs(f-h))
prim.setcost(s,t,u)
ans = prim.prim()
print(ans)
if __name__ == "__main__":
main()
|
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))
self.cost[v].append((u,w))
def prim(self):
que = []
heapify(que)
used = self.used
for e in self.cost[0]:
heappush(que,[e[1],e[0]])
used[0] = True
res = 0
while que:
p = heappop(que)
cos,v = p
if used[v]:continue
self.used[v] = True
for e in self.cost[v]:
if not used[e[0]]:
heappush(que,[e[1],e[0]])
res += cos
return res
def main():
N = int(eval(input()))
cost = []
for i in range(N):
x,y = list(map(int,input().split()))
cost.append((x,y,i))
prim = Prim(N)
x = tuple(sorted(cost,key=lambda x: x[0]))
y = tuple(sorted(cost,key=lambda x: x[1]))
for i in range(N-1):
a,b,u = x[i]
c,d,v = x[i+1]
w = min(abs(a-c),abs(b-d))
prim.setcost(u,v,w)
e,f,s = y[i]
g,h,t = y[i+1]
u = min(abs(e-g),abs(f-h))
prim.setcost(s,t,u)
ans = prim.prim()
print(ans)
if __name__ == "__main__":
main()
|
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 edgelist:
self.w_e[i][j] = w
self.neighbor[i].append(j)
def dijkstra(self,v_n):
d = [float('inf')]*self.v
d[v_n] = 0
prev = [-1]*self.v
queue = []
for i,d_i in enumerate(d): heapq.heappush(queue,(d_i,i))
while len(queue)>0:
d_u,u = queue.pop()
if d[u]<d_u :continue
for v in self.neighbor[u]:
alt = d[u]+self.w_e[u][v]
if d[v]>alt:
d[v] = alt
prev[v] = u
heapq.heappush(queue,(alt,v))
return d,prev
def warshallFloyd(self):
d = [[10**18]*self.v for _ in [0]*self.v]
for i in range(self.v):
d[i][i] = 0
for i in range(self.v):
for j in self.neighbor[i]:
d[i][j] = self.w_e[i][j]
for i in range(self.v):
for j in self.neighbor[i]:
d[i][j] = self.w_e[i][j]
for k in range(self.v):
for i in range(self.v):
for j in range(self.v):
check = d[i][k] + d[k][j]
if d[i][j] > check:
d[i][j] = check
return d
def prim(self):
gb = GraphBuilder(self.v,self.directed)
queue = []
for i,w in list(self.w_e[0].items()): heapq.heappush(queue,(w,0,i))
rest = [True]*self.v
rest[0] = False
v = 1
while len(queue)>0:
w,i,j = heapq.heappop(queue)
if rest[j]:
gb.addEdge(i,j,w)
rest[j] = False
for k,w in list(self.w_e[j].items()):
if rest[k]:heapq.heappush(queue,(w,j,k))
return gb
class Tree():
def __init__(self,v,e):
pass
class GraphBuilder():
def __init__(self,v,directed = False):
self.v = v
self.directed = directed
self.edge = []
def addEdge(self,i,j,w=1):
if not self.directed:
self.edge.append((j,i,w))
self.edge.append((i,j,w))
def addEdges(self,edgelist,weight = True):
if weight:
if self.directed:
for i,j,w in edgelist:
self.edge.append((i,j,w))
else:
for i,j,w in edgelist:
self.edge.append((i,j,w))
self.edge.append((j,i,w))
else:
if self.directed:
for i,j,w in edgelist:
self.edge.append((i,j,1))
else:
for i,j,w in edgelist:
self.edge.append((i,j,1))
self.edge.append((j,i,1))
def addAdjMat(self, mat):
for i,mat_i in enumerate(mat):
for j,w in enumerate(mat_i):
self.edge.append((i,j,w))
def buildTree(self):
pass
def buildGraph(self):
return Graph(self.v,self.edge,directed=self.directed)
def main():
n= int(eval(input()))
edge = []
for i in range(n):
x,y = list(map(int,input().split()))
edge.append((x,y,i))
xs = sorted(edge,key=lambda a:a[0])
ys = sorted(edge,key=lambda a:a[1])
edge = []
for i in range(n-1):
x1,y1,p1 = xs[i]
x2,y2,p2 = xs[i+1]
edge.append((p1,p2,min(x2-x1,abs(y2-y1))))
x1,y1,p1 = ys[i]
x2,y2,p2 = ys[i+1]
edge.append((p1,p2,min(abs(x2-x1),y2-y1)))
gb = GraphBuilder(n)
gb.addEdges(edge)
mint = gb.buildGraph().prim()
ans = 0
for a in mint.edge:
ans+=a[2]
print((ans//2))
if __name__ == "__main__":
main()
|
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])
return self.par[x]
def unite(self, x, y):
x_r = self.root(x)
y_r = self.root(y)
if self.rank[x_r]>self.rank[y_r]:
self.par[y_r] = x_r
elif self.rank[x_r]<self.rank[y_r]:
self.par[x_r] = y_r
elif x_r != y_r:
self.par[y_r] = x_r
self.rank[x_r] += 1
if x_r != y_r:
size = self.tsize[x_r]+self.tsize[y_r]
self.tsize[x_r] = size
self.tsize[y_r] = size
def isSame(self,x,y):
return self.root(x) == self.root(y)
def size(self,x):
return self.tsize[self.root(x)]
def main():
n= int(eval(input()))
edge = []
for i in range(n):
x,y = list(map(int,input().split()))
edge.append((x,y,i))
xs = sorted(edge,key=lambda a:a[0])
ys = sorted(edge,key=lambda a:a[1])
edge = []
for i in range(n-1):
x1,y1,p1 = xs[i]
x2,y2,p2 = xs[i+1]
edge.append((p1,p2,min(x2-x1,abs(y2-y1))))
x1,y1,p1 = ys[i]
x2,y2,p2 = ys[i+1]
edge.append((p1,p2,min(abs(x2-x1),y2-y1)))
edge.sort(key = lambda a:a[2])
uf = UnionFind(n)
ans = 0
for x,y,w in edge:
if uf.isSame(x,y):continue
uf.unite(x,y)
ans+=w
print(ans)
if __name__ == "__main__":
main()
|
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)-1
N=int(input())
X,Y=[0]*N,[0]*N
dx,dy={},{}
for i in range(N):
X[i],Y[i]=map(int,input().split())
if X[i] in dx:
dx[X[i]].append(i)
else:
dx[X[i]]=[i]
if Y[i] in dy:
dy[Y[i]].append(i)
else:
dy[Y[i]]=[i]
ux,uy=list(set(X)),list(set(Y))
ux.sort()
uy.sort()
uxi={x:i for i,x in enumerate(ux)}
uyi={y:i for i,y in enumerate(uy)}
edge=[[] for i in range(N)]
for i,(x,y) in enumerate(zip(X,Y)):
for index in dx[x]+dy[y]:
if index!=i:
edge[i].append((0,index))
if uxi[x]>=1:
nx=ux[uxi[x]-1]
for index in dx[nx]:
if index!=i:
edge[i].append((abs(nx-x),index))
edge[index].append((abs(nx-x),i))
if uyi[y]>=1:
ny=uy[uyi[y]-1]
for index in dy[ny]:
if index!=i:
edge[i].append((abs(ny-y),index))
edge[index].append((abs(ny-y),i))
def prim(n,edges):
used=[False]*n
used[0]=True
edgelist=[]
for edge in edges[0]:
heappush(edgelist,edge)
cost=0
while edgelist:
minedge=heappop(edgelist)
if used[minedge[1]]:
continue
v=minedge[1]
used[v]=True
for edge in edges[v]:
if not used[edge[1]]:
heappush(edgelist,edge)
cost+=minedge[0]
return cost
print(prim(N,edge))
|
# -*- 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)-1
N=int(input())
X,Y=[],[]
for i in range(N):
x,y=map(int,input().split())
X.append((y,i))
Y.append((x,i))
X.sort(key=lambda t:t[0])
Y.sort(key=lambda t:t[0])
edge=[[] for i in range(N)]
for i in range(N-1):
edge[X[i][1]].append((abs(X[i][0]-X[i+1][0]),X[i+1][1]))
edge[X[i+1][1]].append((abs(X[i][0]-X[i+1][0]),X[i][1]))
edge[Y[i][1]].append((abs(Y[i][0]-Y[i+1][0]),Y[i+1][1]))
edge[Y[i+1][1]].append((abs(Y[i][0]-Y[i+1][0]),Y[i][1]))
def prim(n,edges):
used=[False]*n
used[0]=True
edgelist=[]
for edge in edges[0]:
heappush(edgelist,edge)
cost=0
while edgelist:
minedge=heappop(edgelist)
if used[minedge[1]]:
continue
v=minedge[1]
used[v]=True
for edge in edges[v]:
if not used[edge[1]]:
heappush(edgelist,edge)
cost+=minedge[0]
return cost
print(prim(N,edge))
|
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:
p1,p2 = p2,p1
self.par[p1] += self.par[p2]
self.par[p2] = p1
def same(self, x,y):
return self.find(x) == self.find(y)
N = int(eval(input()))
coordinates = []
for i in range(N):
x,y = list(map(int, input().split()))
coordinates.append((i,x,y))
edges = []
sort_x = sorted(coordinates, key=lambda x: x[1])
for i in range(N-1):
u,v = sort_x[i][0], sort_x[i+1][0]
edges.append([u,v,abs(sort_x[i][1] - sort_x[i+1][1])])
sort_y = sorted(coordinates, key=lambda x: x[2])
for i in range(N-1):
u,v = sort_y[i][0], sort_y[i+1][0]
edges.append([u,v,abs(sort_y[i][2] - sort_y[i+1][2] )])
edges.sort(key=lambda x: x[2])
uf = UF(N)
res = 0
for u,v,c in edges:
if not uf.same(u,v):
uf.union(u,v)
res += c
print(res)
|
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:
p1,p2 = p2,p1
self.par[p1] += self.par[p2]
self.par[p2] = p1
def same(self, x,y):
return self.find(x) == self.find(y)
n = int(eval(input()))
coords = []
for i in range(n):
x,y = list(map(int,input().split()))
coords.append((i,x,y))
edges = []
sorted_x = sorted(coords, key=lambda x: x[1])
for i in range(n-1):
c = abs(sorted_x[i][1] - sorted_x[i+1][1])
u,v = sorted_x[i][0], sorted_x[i+1][0]
edges.append((c,u,v))
sorted_y = sorted(coords, key=lambda x: x[2])
for i in range(n-1):
c = abs(sorted_y[i][2] - sorted_y[i+1][2])
u,v = sorted_y[i][0], sorted_y[i+1][0]
edges.append((c,u,v))
edges.sort()
uf = UF(n)
res = 0
for c,u,v in edges:
if not uf.same(u,v):
uf.union(u,v)
res += c
print(res)
|
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):
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
N = int(eval(input()))
Px = []
Py = []
for k, s in enumerate(sys.stdin.readlines()):
x, y = list(map(int, s.split()))
Px.append((x, k))
Py.append((y, k))
edge = []
Px.sort()
Py.sort()
for i in range(N - 1):
x0, k0 = Px[i]
x1, k1 = Px[i + 1]
d = abs(x0 - x1)
edge.append((d, k0, k1))
y0, k0 = Py[i]
y1, k1 = Py[i + 1]
d = abs(y0 - y1)
edge.append((d, k0, k1))
edge.sort()
uf = UnionFind(N)
cnt = 0
for d, k0, k1 in edge:
if uf.find(k0) != uf.find(k1):
uf.union(k0, k1)
cnt += d
if uf.parents[uf.find(0)] == -N:
break
print(cnt)
|
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):
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
N = int(eval(input()))
Px = []
Py = []
for k, s in enumerate(sys.stdin.readlines()):
x, y = list(map(int, s.split()))
Px.append((x, k))
Py.append((y, k))
edge = []
Px.sort()
Py.sort()
for i in range(N - 1):
x0, k0 = Px[i]
x1, k1 = Px[i + 1]
d = abs(x0 - x1)
edge.append((d, k0, k1))
y0, k0 = Py[i]
y1, k1 = Py[i + 1]
d = abs(y0 - y1)
edge.append((d, k0, k1))
edge.sort()
uf = UnionFind(N)
cnt = 0
for d, k0, k1 in edge:
if uf.find(k0) != uf.find(k1):
uf.union(k0, k1)
cnt += d
print(cnt)
|
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)] #cost[i]にはi番目から(j,k)でj番目にコストkかかる
for i in range(n-1):
cost[x_sort[i][2]].append((x_sort[i+1][2],x_sort[i+1][0]-x_sort[i][0]))
cost[x_sort[i+1][2]].append((x_sort[i][2],x_sort[i+1][0]-x_sort[i][0]))
cost[y_sort[i][2]].append((y_sort[i+1][2],y_sort[i+1][1]-y_sort[i][1]))
cost[y_sort[i+1][2]].append((y_sort[i][2],y_sort[i+1][1]-y_sort[i][1]))
used=[False]*(n+3)#頂点が最小全域木にもうすでに含まれているかどうか
q=[]
#すでに最小全域木が決まっている部分からまだ決まっていない部分への辺をヒープで管理
#(a,b)でaには向かう先の頂点,bにはかかるコスト
#ヒープで小さいコストからとりだせる
#初期条件
#はじめはどこでもよいので０番目スタートとする(0番目だけではコストは0)
used[0] = True
ans = 0
#0番目からの辺をすべてヒープに挿入
for to,cst in cost[0]:
heappush(q,(cst,to))
#すでに決まっている最小全域木部分からまだ決まっていない部分を貪欲的にひたすら追加する
#はじめは初期条件の通り
while(len(q)!=0):
c,ver=heappop(q)
#すでに決まっている部分から一番小さいコストの辺を取り出す
if used[ver] == True:
continue
#もしすでに最小全域木部分であればやり直し
#そうでなければコストの分を加算し、新しい頂点を最小全域木部分に追加する
ans += c
used[ver] = True
#新しく追加した頂点からの辺をヒープに追加する
for to,cst in cost[ver]:
heappush(q,(cst,to))
#これを貪欲的に繰り返すことでうまくいくらしい
print(ans)
|
#最小全域木 クラスカル法
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def find_root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
#経路圧縮
self.root[x] = self.find_root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.find_root(x)
y = self.find_root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSame(self, x, y):
return self.find_root(x) == self.find_root(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find_root(x)]
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])
edge = [] #edge=[i番目と,j番目が,コストk]
for i in range(n-1):
edge.append([x_sort[i][2],x_sort[i+1][2],x_sort[i+1][0]-x_sort[i][0]])
edge.append([y_sort[i][2],y_sort[i+1][2],y_sort[i+1][1]-y_sort[i][1]])
#クラスカル法では辺のコストを小さい順にみていき閉路ができなければ追加する。を繰り返す
#閉路ができるかどうかはUnionFindで効率的に判定できる
ans = 0
edge.sort(key=lambda x:x[2])
u=UnionFind(n)
for i,j,cost in edge:
if u.isSame(i,j) == False:
u.unite(i,j)
ans+=cost
print(ans)
|
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.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n = int(eval(input()))
XY = [tuple(map(int, input().split())) for _ in range(n)]
L_to_R = sorted([(xy[0], xy[1], i) for i, xy in enumerate(XY)])
D_to_U = sorted([(xy[0], xy[1], i) for i, xy in enumerate(XY)], key=itemgetter(1))
dist = []
for i in range(n-1):
x1, y1, num1 = L_to_R[i]
x2, y2, num2 = L_to_R[i+1]
d = min(abs(x1-x2), abs(y1-y2))
dist.append((d, num1, num2))
for i in range(n-1):
x1, y1, num1 = D_to_U[i]
x2, y2, num2 = D_to_U[i+1]
d = min(abs(x1-x2), abs(y1-y2))
dist.append((d, num1, num2))
dist.sort(reverse=True)
uf = UnionFind(n)
count = 0
ans = 0
while count < n-1:
d, num1, num2 = dist.pop()
if uf.same(num1, num2):
continue
count += 1
ans += d
uf.unite(num1, num2)
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 unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n = int(eval(input()))
XY = [tuple(map(int, input().split())) for _ in range(n)]
X, Y = list(zip(*XY))
L_to_R = sorted([(x, i) for i, x in enumerate(X)])
D_to_U = sorted([(y, i) for i, y in enumerate(Y)])
dist = []
for i in range(n-1):
x1, num1 = L_to_R[i]
x2, num2 = L_to_R[i+1]
d = x2-x1
dist.append((d, num1, num2))
for i in range(n-1):
y1, num1 = D_to_U[i]
y2, num2 = D_to_U[i+1]
d = y2-y1
dist.append((d, num1, num2))
dist.sort(reverse=True)
uf = UnionFind(n)
count = 0
ans = 0
while count < n-1:
d, num1, num2 = dist.pop()
if uf.same(num1, num2):
continue
count += 1
ans += d
uf.unite(num1, num2)
print(ans)
|
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]
i1 = min(xs[i+1][1], xs[i][1])
i2 = max(xs[i+1][1], xs[i][1])
es[(i1,i2)] = min(es[(i1,i2)], xd)
yd = ys[i+1][0] - ys[i][0]
i3 = min(ys[i+1][1], ys[i][1])
i4 = max(ys[i+1][1], ys[i][1])
es[(i3,i4)] = min(es[(i3,i4)], yd)
parent = [i for i in range(N)]
def root(a):
if parent[a] == a:
return a
else:
parent[a] = root(parent[a])
return parent[a]
def is_same(a,b):
return root(a) == root(b)
def unite(a,b):
ra = root(a)
rb = root(b)
if ra == rb: return
parent[ra] = rb;
value = 0
for k,v in sorted(list(es.items()), key=operator.itemgetter(1)):
a,b = k
if is_same(a,b): continue
unite(a,b)
value += v
print(value)
|
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:]):
es.append((y2-y1, i1, i2))
es.sort()
class UnionFind:
def __init__(self,N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
def root(self,a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]: self.rank[ra] += 1
self.count += 1
ans = 0
uf = UnionFind(N)
for d,a,b in es:
if uf.is_same(a,b): continue
uf.unite(a,b)
ans += d
print(ans)
|
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):
self.makeSet(i)
def makeSet(self, x):
self.p.insert(x, x)
self.rank.insert(x, 0)
def same(self, x, y):
return self.findSet(x) == self.findSet(y)
def unite(self, x, y):
self.link(self.findSet(x), self.findSet(y))
def link(self, x, y):
if self.rank[x] > self.rank[y]:
self.p[y] = x
else:
self.p[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def findSet(self, x):
if x != self.p[x]:
self.p[x] = self.findSet(self.p[x])
return self.p[x]
def kruskal(V, E, es):
es.sort(key=lambda x: x.c)
uf = DisjointSet(V)
res = 0
for i in range(E):
e = es[i]
if not uf.same(e.u, e.v):
uf.unite(e.u, e.v)
res += e.c
return res
edge = namedtuple('edge', ['u', 'v', 'c'])
def main(args):
N = int(eval(input()))
cities = []
for i in range(1, N+1):
x, y = list(map(int, input().split()))
cities.append([x, y, i])
es = []
cities.sort(key=lambda x: x[0])
prev_x, _, prev_i = cities[0]
for x, y, i in cities[1:]:
es.append(edge(prev_i, i, x - prev_x))
es.append(edge(i, prev_i, x - prev_x))
prev_x = x
prev_i = i
cities.sort(key=lambda x: x[1])
_, prev_y, prev_i = cities[0]
for x, y, i in cities[1:]:
es.append(edge(prev_i, i, y - prev_y))
es.append(edge(i, prev_i, y - prev_y))
prev_y = y
prev_i = i
result = kruskal(N+1, len(es), es)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
|
# -*- 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):
self.makeSet(i)
def makeSet(self, x):
self.p.insert(x, x)
self.rank.insert(x, 0)
def same(self, x, y):
return self.findSet(x) == self.findSet(y)
def unite(self, x, y):
self.link(self.findSet(x), self.findSet(y))
def link(self, x, y):
if self.rank[x] > self.rank[y]:
self.p[y] = x
else:
self.p[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def findSet(self, x):
if x != self.p[x]:
self.p[x] = self.findSet(self.p[x])
return self.p[x]
def kruskal(V, E, es):
es.sort(key=lambda x: x.c)
uf = DisjointSet(V)
res = 0
for i in range(E):
e = es[i]
if not uf.same(e.u, e.v):
uf.unite(e.u, e.v)
res += e.c
return res
edge = namedtuple('edge', ['u', 'v', 'c'])
def main(args):
N = int(eval(input()))
cities = []
for i in range(1, N+1):
x, y = list(map(int, input().split()))
cities.append([x, y, i])
es = []
cities.sort(key=lambda x: x[0])
prev_x, _, prev_i = cities[0]
for x, y, i in cities[1:]:
es.append(edge(prev_i, i, x - prev_x))
# es.append(edge(i, prev_i, x - prev_x))
prev_x = x
prev_i = i
cities.sort(key=lambda x: x[1])
_, prev_y, prev_i = cities[0]
for x, y, i in cities[1:]:
es.append(edge(prev_i, i, y - prev_y))
# es.append(edge(i, prev_i, y - prev_y))
prev_y = y
prev_i = i
result = kruskal(N+1, len(es), es)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
|
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
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()))
Xsort=[]
Ysort=[]
for i in range(N):
X,Y=list(map(int,input().split()))
Xsort.append([X,i])
Ysort.append([Y,i])
Xsort=sorted(Xsort,key=lambda x:x[0])
Ysort=sorted(Ysort,key=lambda x:x[0])
Nidxlst=[[0,0] for i in range(N)]
for i in range(N):
idx=Xsort[i][1]
Nidxlst[idx][0]=i
idx=Ysort[i][1]
Nidxlst[idx][1]=i
def main(i):
x,y=Nidxlst[i]
lst=[]
if x>0:
a=Xsort[x-1][1]
m=Xsort[x][0]-Xsort[x-1][0]
if not uf.same(i,a):
lst.append([m,a])
if x<N-1:
a=Xsort[x+1][1]
m=Xsort[x+1][0]-Xsort[x][0]
if not uf.same(i,a):
lst.append([m,a])
if y>0:
a=Ysort[y-1][1]
m=Ysort[y][0]-Ysort[y-1][0]
if not uf.same(i,a):
lst.append([m,a])
if y<N-1:
a=Ysort[y+1][1]
m=Ysort[y+1][0]-Ysort[y][0]
if not uf.same(i,a):
lst.append([m,a])
if lst:
lst=sorted(lst,key=lambda x:x[0])
uf.union(i,lst[0][1])
return(lst[0][0])
value=0
uf=UnionFind(N)
for i in range(N):
m=main(i)
if m:
value+=m
if uf.group_count()==1:
break
print(value)
|
#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):
X,Y=list(map(int,input().split()))
Xsort.append([X,i])
Ysort.append([Y,i])
Xsort=sorted(Xsort,key=lambda x:x[0])
Ysort=sorted(Ysort,key=lambda x:x[0])
Nidxlst=[[0,0] for i in range(N)]
for i in range(N):
idx=Xsort[i][1]
Nidxlst[idx][0]=i
idx=Ysort[i][1]
Nidxlst[idx][1]=i
value=0
x,y=Nidxlst[0]
ittenai=set([i for i in range(1,N)])
stack=[]
heapify(stack)
setm=set()
dic={}
def main(x,y):
if x>0:
a=Xsort[x-1][1]
if a in ittenai:
m=Xsort[x][0]-Xsort[x-1][0]
heappush(stack,m)
if m in setm :
dic[m].append(a)
else:
setm.add(m)
dic.update({m:[a]})
if x<N-1:
a=Xsort[x+1][1]
if a in ittenai:
m=Xsort[x+1][0]-Xsort[x][0]
heappush(stack,m)
if m in setm :
dic[m].append(a)
else:
setm.add(m)
dic.update({m:[a]})
if y>0:
a=Ysort[y-1][1]
if a in ittenai:
m=Ysort[y][0]-Ysort[y-1][0]
heappush(stack,m)
if m in setm :
dic[m].append(a)
else:
setm.add(m)
dic.update({m:[a]})
if y<N-1:
a=Ysort[y+1][1]
if a in ittenai:
m=Ysort[y+1][0]-Ysort[y][0]
heappush(stack,m)
if m in setm :
dic[m].append(a)
else:
setm.add(m)
dic.update({m:[a]})
main(x,y)
idle=10**9+1
value=0
while ittenai:
m=heappop(stack)
a=dic[m].pop()
if a in ittenai:
x,y=Nidxlst[a]
main(x,y)
ittenai.remove(a)
value+=m
print(value)
|
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 = d[i+1]
dis = abs(px-qx)
graph[a].append((dis, b))
graph[b].append((dis, a))
edge.append((dis, a, b))
edge.append((dis, b, a))
# y座標に関する辺の設定
d.sort(key=lambda x: x[2])
for i in range(N-1):
a, px, py = d[i]
b, qx, qy = d[i+1]
dis = abs(py-qy)
graph[a].append((dis, b))
graph[b].append((dis, a))
edge.append((dis, a, b))
edge.append((dis, b, a))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * (n+1)
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
# 最小全域木
def kruskal():
res = 0
G = UnionFind(N)
edge.sort()
for cost, p, q, in edge:
if not G.same(p, q):
G.union(p, q)
res += cost
return res
ans = kruskal()
print(ans)
|
# 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, qy = d[i+1]
dis = abs(px-qx)
edge.append((dis, a, b))
edge.append((dis, b, a))
# y座標に関する辺の設定
d.sort(key=lambda x: x[2])
for i in range(N-1):
a, px, py = d[i]
b, qx, qy = d[i+1]
dis = abs(py-qy)
edge.append((dis, a, b))
edge.append((dis, b, a))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * (n+1)
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
edge.sort()
# 最小全域木（クラスかるほう）
def kruskal():
res = 0
G = UnionFind(N)
for cost, p, q, in edge:
if not G.same(p, q):
G.union(p, q)
res += cost
return res
ans = kruskal()
print(ans)
|
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 = Isx[i-1], Isx[i]
a, b = xys[p]
c, d = xys[q]
cost = min(abs(a-c), abs(b-d))
M.add((cost, p, q))
for i in range(N):
p, q = Isy[i-1], Isy[i]
a, b = xys[p]
c, d = xys[q]
cost = min(abs(a-c), abs(b-d))
M.add((cost, p, q))
#print(M)
F = [{i} for i in range(N)]
S = list(M)
S.sort(reverse=True)
#print(S)
r = 0
while S:
cost, p, q = S.pop()
for i in range(N):
s = F[i]
if p in s:
break
for j in range(N):
s = F[j]
if q in s:
break
#print(i, j)
if i != j:
r += cost
s = F[i]|F[j]
F.pop(max(i, j))
F.pop(min(i, j))
F.append(s)
#print(F)
print(r)
|
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 = Isx[i-1], Isx[i]
a, b = xys[p]
c, d = xys[q]
cost = min(abs(a-c), abs(b-d))
M.add((cost, p, q))
for i in range(1, N):
p, q = Isy[i-1], Isy[i]
a, b = xys[p]
c, d = xys[q]
cost = min(abs(a-c), abs(b-d))
M.add((cost, p, q))
#print(M)
S = list(M)
S.sort(reverse=True)
#print(S)
r = 0
UF = list(range(N))
def par(m):
if UF[m] == m:
return m
ret = par(UF[m])
UF[m] = ret
return ret
while S:
cost, p, q = S.pop()
i = par(p)
j = par(q)
if i != j:
r += cost
UF[i] = j
#print(UF)
print(r)
|
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.append([x[i][0],x[i+1][0],x[i+1][1]-x[i][1]])
tree.append([y[i][0],y[i+1][0],y[i+1][1]-y[i][1]])
#UnionFindクラス
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 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]
# xとyの根を結合させる
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
# x,yの根が同じかどうかを返す（根が同じ:True、根が異なる:False）
def is_same(self, x, y):
return self.find(x) == self.find(y)
uf = UnionFind(len(tree))
tree = sorted(tree,key=itemgetter(2))
ans = 0
for i in tree:
x,y,kyori = i
if not uf.is_same(x,y):
uf.union(y,x)
ans += kyori
print(ans)
|
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:
# tree[x[i][0]].append([x[i+1][0],abs(x[i][1]-x[i+1][1])])
# tree[y[i][0]].append([y[i+1][0],abs(y[i][1]-y[i+1][1])])
# elif i==n-1:
# tree[x[i][0]].append([x[i-1][0],abs(x[i][1]-x[i-1][1])])
# tree[y[i][0]].append([y[i-1][0],abs(y[i][1]-y[i-1][1])])
# else:
# tree[x[i][0]].append([x[i+1][0],abs(x[i][1]-x[i+1][1])])
# tree[x[i][0]].append([x[i-1][0],abs(x[i][1]-x[i-1][1])])
# tree[y[i][0]].append([y[i+1][0],abs(y[i][1]-y[i+1][1])])
# tree[y[i][0]].append([y[i-1][0],abs(y[i][1]-y[i-1][1])])
for i in range(n-1):
tree.append([x[i][0],x[i+1][0],abs(x[i][1]-x[i+1][1])])
tree.append([y[i][0],y[i+1][0],abs(y[i][1]-y[i+1][1])])
#UnionFindクラス
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 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]
# xとyの根を結合させる
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
# x,yの根が同じかどうかを返す（根が同じ:True、根が異なる:False）
def is_same(self, x, y):
return self.find(x) == self.find(y)
uf = UnionFind(len(tree))
tree = sorted(tree,key=itemgetter(2))
ans = 0
for i in tree:
x,y,kyori = i
if not uf.is_same(x,y):
uf.union(y,x)
ans += kyori
print(ans)
|
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
from functools import reduce
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[i+1]
edge.append((y2-y1,i1,i2))
class UnionFind():
def __init__(self, N):
self.rank = [0] * N
self.par = [i for i in range(N)]
self.counter = [1] * N
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
z = self.counter[x] + self.counter[y]
self.counter[x], self.counter[y] = z, z
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 size(self, x):
x = self.find(x)
return self.counter[x]
def same(self, x, y):
return self.find(x) == self.find(y)
#クラスカル法
uf = UnionFind(n)
edge.sort()
ans = 0
edge_cnt = 0
i = 0
while edge_cnt < n-1:
cost,i1,i2 = edge[i]
if not uf.same(i1,i2):
ans += cost
uf.unite(i1,i2)
edge_cnt += 1
i += 1
print(ans)
|
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[i+1]
edge.append((y2-y1,i1,i2))
class UnionFind():
def __init__(self, N):
self.rank = [0] * N
self.par = [i for i in range(N)]
self.counter = [1] * N
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
z = self.counter[x] + self.counter[y]
self.counter[x], self.counter[y] = z, z
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 size(self, x):
x = self.find(x)
return self.counter[x]
def same(self, x, y):
return self.find(x) == self.find(y)
#クラスカル法
uf = UnionFind(n)
edge.sort()
ans = 0
edge_cnt = 0
i = 0
while edge_cnt < n-1:
cost,i1,i2 = edge[i]
if not uf.same(i1,i2):
ans += cost
uf.unite(i1,i2)
edge_cnt += 1
i += 1
print(ans)
|
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[i][1]])
g[y[i][1]].append([abs(y[i+1][0]-y[i][0]),y[i+1][1]])
g[y[i+1][1]].append([abs(y[i+1][0]-y[i][0]),y[i][1]])
import heapq
hq = []
for d,e in g[0]:
heapq.heappush(hq,[d,e])
cnt = 1
visit = [False]*n
visit[0] = True
ans = 0
while cnt <n:
cost, end = heapq.heappop(hq)
if not visit[end]:
ans += cost
visit[end] = True
cnt += 1
for d,e in g[end]:
heapq.heappush(hq,[d,e])
print(ans)
|
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[i][1]])
g[y[i][1]].append([abs(y[i+1][0]-y[i][0]),y[i+1][1]])
g[y[i+1][1]].append([abs(y[i+1][0]-y[i][0]),y[i][1]])
import heapq
hq = []
for d,e in g[0]:
heapq.heappush(hq,[d,e])
cnt = 1
visit = [False]*n
visit[0] = True
ans = 0
while cnt <n:
cost, end = heapq.heappop(hq)
if visit[end]: continue
ans += cost
visit[end] = True
cnt += 1
for d,e in g[end]:
if not visit[e]:
heapq.heappush(hq,[d,e])
print(ans)
|
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]
x2 = xsort_n[i+1]
y1 = ysort_n[i]
y2 = ysort_n[i+1]
neighbors[x1].append(x2)
neighbors[x2].append(x1)
neighbors[y1].append(y2)
neighbors[y2].append(y1)
from heapq import *
isused = [0] * N
h = []
heappush(h, (0, 0))
result = 0
while h:
d, n = heappop(h)
if isused[n]:
continue
result += d
isused[n] = 1
for i in neighbors[n]:
if not isused[i]:
d1 = min(abs(xy[n][0] - xy[i][0]), abs(xy[n][1] - xy[i][1]))
heappush(h, (d1, i))
print(result)
|
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]
x2 = xsort_n[i+1]
xd = xy[x2][0] - xy[x1][0]
y1 = ysort_n[i]
y2 = ysort_n[i+1]
yd = xy[y2][1] - xy[y1][1]
neighbors[x1].append((x2, xd))
neighbors[x2].append((x1, xd))
neighbors[y1].append((y2, yd))
neighbors[y2].append((y1, yd))
from heapq import *
isused = [0] * N
h = []
heappush(h, (0, 0))
result = 0
while h:
d, n = heappop(h)
if isused[n]:
continue
result += d
isused[n] = 1
for ni, nd in neighbors[n]:
if not isused[ni]:
heappush(h, (nd, ni))
print(result)
|
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])
a.sort()
b.sort()
#print(a)
#print(b)
# making adj list
adj = [[] for _ in range(n)]
for [x0, j0], [x1, j1] in zip(a, a[1:]):
adj[j0].append([x1-x0, j1])
adj[j1].append([x1-x0, j0])
for [y0, j0], [y1, j1] in zip(b, b[1:]):
adj[j0].append([y1-y0, j1])
adj[j1].append([y1-y0, j0])
#print(adj)
# Prim's algorithm
#d = [10**10]*n
visited = [False]*n
h = []
s = 0
heapq.heappush(h, [0, s])
cnt = 0
totalcost = 0
while h:
cost, node = heapq.heappop(h)
#if visited[node] != True and cost < d[node]:
if visited[node] != True:
#d[node] = cost
visited[node] = True
totalcost += cost
cnt += 1
if cnt == n:
break
for edge in adj[node]:
if visited[edge[1]] == True:
continue
heapq.heappush(h, edge)
#print(d)
print(totalcost)
|
# -*- 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.append([xy[0],i])
b.append([xy[1],i])
a.sort()
b.sort()
#print(a)
#print(b)
# making adj list
adj = [[] for _ in range(n)]
for [x0, j0], [x1, j1] in zip(a, a[1:]):
adj[j0].append([x1-x0, j1])
adj[j1].append([x1-x0, j0])
for [y0, j0], [y1, j1] in zip(b, b[1:]):
adj[j0].append([y1-y0, j1])
adj[j1].append([y1-y0, j0])
#print(adj)
# Prim's algorithm
#d = [10**10]*n
visited = [False]*n
h = []
s = 0
heapq.heappush(h, [0, s])
cnt = 0
totalcost = 0
while h:
cost, node = heapq.heappop(h)
#if visited[node] != True and cost < d[node]:
if visited[node] != True:
#d[node] = cost
visited[node] = True
totalcost += cost
cnt += 1
if cnt == n:
break
for edge in adj[node]:
if visited[edge[1]]:
continue
heapq.heappush(h, edge)
#print(d)
print(totalcost)
|
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,x,i])
xyi.sort()
yxi.sort()
line = []
for i in range(N-1):
heapq.heappush(line,[ xyi[i+1][0]-xyi[i][0] , xyi[i][2] , xyi[i+1][2] ])
heapq.heappush(line,[ yxi[i+1][0]-yxi[i][0] , yxi[i][2] , yxi[i+1][2] ])
line.sort()
p = [i for i in range(N)]
rank = [1] * N
ans = 0
while len(line) > 0:
e = heapq.heappop(line)
cost = e[0]
a = e[1]
b = e[2]
ap = want_p(a)
bp = want_p(b)
#print (a,b,cost,p,ans)
if ap != bp:
ans += cost
if rank[ap] > rank[bp]:
p[bp] = ap
elif rank[ap] == rank[bp]:
p[bp] = ap
rank[ap] += 1
else:
p[ap] = bp
print (ans)
|
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.sort()
yxi.sort()
line = []
for i in range(N-1):
line.append([ xyi[i+1][0]-xyi[i][0] , xyi[i][2] , xyi[i+1][2] ])
line.append([ yxi[i+1][0]-yxi[i][0] , yxi[i][2] , yxi[i+1][2] ])
line.sort()
p = [i for i in range(N)]
rank = [1] * N
ans = 0
for j in range(len(line)):
e = line[j]
cost = e[0]
a = e[1]
b = e[2]
ap = want_p(a)
bp = want_p(b)
#print (a,b,cost,p,ans)
if ap != bp:
ans += cost
if rank[ap] > rank[bp]:
p[bp] = ap
elif rank[ap] == rank[bp]:
p[bp] = ap
rank[ap] += 1
else:
p[ap] = bp
print (ans)
|
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.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
import heapq
def prim_heap(n, edges): # n: 最大の頂点番号+1, edges[頂点番号]=[[重み, 行き先],[重み, 行き先],...]. 無向グラフの場合は相方向有向グラフの表記にしておく。
used = [True] * n #True:不使用
edgelist = [] # heapq
for e in edges[0]: # 頂点 0 から伸びる辺をすべて heapq に入れる。
heapq.heappush(edgelist,e)
used[0] = False # 頂点 0 は見たと記録する。
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist) # edgelist から最小の辺を1つ取り出す。
if not used[minedge[1]]: # その辺の行き先がすでに見た先だったら棄却して次へ。
continue
v = minedge[1] # 行き先を v とする。
used[v] = False # 頂点 v は見たと記録する。
for e in edges[v]: # 頂点 v から伸びる辺すべてについて、もしその行き先を見ていなかったら heapq に追加する。
if used[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0] # いま使った辺の重みを結果に加える。
return res # 最小全域木の全体の重みを出力する。
def main():
N = II()
pos_li = []
for _ in range(N):
pos_li.append(LI())
edges = [[] for _ in range(N)]
for i in range(N):
for j in range(N):
weight = min(abs(pos_li[i][0] - pos_li[j][0]), abs(pos_li[i][1] - pos_li[j][1]))
edges[i].append([weight, j])
edges[j].append([weight, i])
# print(edges)
print((prim_heap(N, edges)))
main()
|
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
import heapq
def prim_heap(n, edges): # n: 最大の頂点番号+1, edges[頂点番号]=[[重み, 行き先],[重み, 行き先],...]. 無向グラフの場合は相方向有向グラフの表記にしておく。
seen = [False] * n #True:不使用
edgelist = [] # heapq
for e in edges[0]: # 頂点 0 から伸びる辺をすべて heapq に入れる。
heapq.heappush(edgelist,e)
seen[0] = True # 頂点 0 は見たと記録する。
res = 0
while len(edgelist) != 0:
minedge = heapq.heappop(edgelist) # edgelist から最小の辺を1つ取り出す。
if seen[minedge[1]]: # その辺の行き先がすでに見た先だったら棄却して次へ。
continue
v = minedge[1] # 行き先を v とする。
seen[v] = True # 頂点 v は見たと記録する。
for e in edges[v]: # 頂点 v から伸びる辺すべてについて、もしその行き先を見ていなかったら heapq に追加する。
if not seen[e[1]]:
heapq.heappush(edgelist,e)
res += minedge[0] # いま使った辺の重みを結果に加える。
return res # 最小全域木の全体の重みを出力する。
def main():
N = II()
pos_li = []
for i in range(N):
x,y = LI()
pos_li.append((x,y,i))
edges = [[] for _ in range(N)]
# # すべての頂点を結ぶグラフを作ってその最小全域木を取ると、時間が足りない（二重ループが O(10^10)）。
# for i in range(N):
# for j in range(N):
# weight = min(abs(pos_li[i][0] - pos_li[j][0]), abs(pos_li[i][1] - pos_li[j][1]))
# edges[i].append([weight, j])
# edges[j].append([weight, i])
# # なので、座標でソートして、最も近い4点のみへ辺を伸ばす。
pos_li.sort(key=lambda x: x[0])
for k in range(N-1):
x1, y1, p1 = pos_li[k]
x2, y2, p2 = pos_li[k+1]
weight = abs(x1-x2)
edges[p1].append([weight, p2])
edges[p2].append([weight, p1])
pos_li.sort(key=lambda x: x[1])
for k in range(N-1):
x1, y1, p1 = pos_li[k]
x2, y2, p2 = pos_li[k+1]
weight = abs(y1-y2)
edges[p1].append([weight, p2])
edges[p2].append([weight, p1])
# print(edges)
print((prim_heap(N, edges)))
main()
|
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:
parent[d]+=parent[c]
parent[c]=d
return
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()
Y.sort()
edge=[]
for i in range(1,N):
edge.append([X[i][0]-X[i-1][0],X[i-1][1],X[i][1]])
edge.append([Y[i][0]-Y[i-1][0],Y[i-1][1],Y[i][1]])
edge.sort()
parent=[-1]*N
ans=0
for l,a,b in edge:
if find_parent(a)==find_parent(b):
continue
else:
ans+=l
connect(a,b)
print(ans)
|
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]
parent[d]=c
else:
parent[d]+=parent[c]
parent[c]=d
return
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()
Y.sort()
edge=[]
for i in range(1,N):
edge.append([X[i][0]-X[i-1][0],X[i-1][1],X[i][1]])
edge.append([Y[i][0]-Y[i-1][0],Y[i-1][1],Y[i][1]])
edge.sort()
parent=[-1]*N
ans=0
for l,a,b in edge:
if find_parent(a)==find_parent(b):
continue
else:
ans+=l
connect(a,b)
print(ans)
|
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), abs(ay-by))
G[an] += [(cost, bn)]
G[bn] += [(cost, an)]
def prim(V):
global G, used
edgelist = []
for e in G[0]:
heappush(edgelist, e)
used[0] = True
res = 0
while edgelist:
minedge = heappop(edgelist)
if used[minedge[1]]:
continue
v = minedge[1]
used[v] = True
for e in G[v]:
if not used[e[1]]:
heappush(edgelist, e)
res += minedge[0]
return res
def main():
global G, used
N = int(eval(input()))
xy = []
for i in range(N):
xy += [[i, list(map(int, input().split()))]]
G = [[] for _ in range(N)]
used = [False for _ in range(N)]
input_graph(N, xy)
print((prim(N)))
if __name__ == "__main__":
main()
|
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()
for i in range(N-1):
xa = inp_x[i][1]
xb = inp_x[i+1][1]
ya = inp_y[i][1]
yb = inp_y[i+1][1]
cost_x = abs(inp_x[i][0]-inp_x[i+1][0])
cost_y = abs(inp_y[i][0]-inp_y[i+1][0])
G[xa] += [(cost_x, xb)]
G[xb] += [(cost_x, xa)]
G[ya] += [(cost_y, yb)]
G[yb] += [(cost_y, ya)]
def prim(V):
global G, used
edgelist = []
for e in G[0]:
heappush(edgelist, e)
used[0] = True
res = 0
while edgelist:
minedge = heappop(edgelist)
if used[minedge[1]]:
continue
v = minedge[1]
used[v] = True
for e in G[v]:
if not used[e[1]]:
heappush(edgelist, e)
res += minedge[0]
return res
def main():
global G, used
N = int(eval(input()))
G = [[] for _ in range(N)]
used = [False for _ in range(N)]
input_graph(N)
print((prim(N)))
if __name__ == "__main__":
main()
|
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]
yt = y_list[i+1][1]
dis_x = abs(x_list[i][0]-x_list[i+1][0])
dis_y = abs(y_list[i][0]-y_list[i+1][0])
graph[xs] += [[dis_x, xt]]
graph[xt] += [[dis_x, xs]]
graph[ys] += [[dis_y, yt]]
graph[yt] += [[dis_y, ys]]
def prim():
# graph[i]は第一要素が重み、第二要素が頂点になるように
# graph[s] += [[w, t]], w:重み, s,t:頂点
used = [-1]*n
edgelist = []
for e in graph[0]:
heapq.heappush(edgelist, e)
used[0] = 1
res = 0
while edgelist:
minedge = heapq.heappop(edgelist)
if used[minedge[1]] == 1:
continue
v = minedge[1]
used[v] = 1
for e in graph[v]:
if used[e[1]] == -1:
heapq.heappush(edgelist, e)
res += minedge[0]
return res
print((prim()))
|
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()
for i in range(N-1):
xa = inp_x[i][1]
xb = inp_x[i+1][1]
ya = inp_y[i][1]
yb = inp_y[i+1][1]
cost_x = abs(inp_x[i][0]-inp_x[i+1][0])
cost_y = abs(inp_y[i][0]-inp_y[i+1][0])
G[xa] += [(cost_x, xb)]
G[xb] += [(cost_x, xa)]
G[ya] += [(cost_y, yb)]
G[yb] += [(cost_y, ya)]
def prim(V):
global G, used
edgelist = []
for e in G[0]:
heappush(edgelist, e)
used[0] = True
res = 0
while edgelist:
minedge = heappop(edgelist)
if used[minedge[1]]:
continue
v = minedge[1]
used[v] = True
for e in G[v]:
if not used[e[1]]:
heappush(edgelist, e)
res += minedge[0]
return res
def main():
global G, used
N = int(eval(input()))
G = [[] for _ in range(N)]
used = [False for _ in range(N)]
input_graph(N)
print((prim(N)))
if __name__ == "__main__":
main()
|
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]
dis_x = abs(x_list[i][0]-x_list[i+1][0])
dis_y = abs(y_list[i][0]-y_list[i+1][0])
stw += [[dis_x, xs, xt]]
stw += [[dis_x, xt, xs]]
stw += [[dis_y, ys, yt]]
stw += [[dis_y, yt, ys]]
#print(stw)
heapq.heapify(stw)
#stw = sorted(stw, key=lambda x:x[2])
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
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
def kruskal():
# stw = [[s0, t0, w0], [s1, t1, w1], ..., [sn, tn, wn]]
# stw: s: 始点, t: 終点, w: st間の重み
# stwはwを小さい順にソートされたものとする
res = 0
uf = UnionFind(n)
while stw:
w, s, t = heapq.heappop(stw)
if not uf.isSameGroup(s, t):
uf.Unite(s, t)
res += w
return res
print((kruskal()))
|
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]
dis_x = abs(x_list[i][0]-x_list[i+1][0])
dis_y = abs(y_list[i][0]-y_list[i+1][0])
stw += [[dis_x, xs, xt]]
#stw += [[dis_x, xt, xs]]
stw += [[dis_y, ys, yt]]
#stw += [[dis_y, yt, ys]]
#print(stw)
heapq.heapify(stw)
#stw = sorted(stw, key=lambda x:x[2])
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
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
def kruskal():
# stw = [[s0, t0, w0], [s1, t1, w1], ..., [sn, tn, wn]]
# stw: s: 始点, t: 終点, w: st間の重み
# stwはwを小さい順にソートされたものとする
res = 0
uf = UnionFind(n)
while stw:
w, s, t = heapq.heappop(stw)
if not uf.isSameGroup(s, t):
uf.Unite(s, t)
res += w
return res
print((kruskal()))
|
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(y_list, y_list[1:]):
stw += [[abs(u-v), fr, to]]
heapq.heapify(stw)
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
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
def kruskal():
# stw = [[s0, t0, w0], [s1, t1, w1], ..., [sn, tn, wn]]
# stw: s: 始点, t: 終点, w: st間の重み
# stwはwを小さい順にソートされたものとする
res = 0
uf = UnionFind(n)
while stw:
w, s, t = heapq.heappop(stw)
if not uf.isSameGroup(s, t):
uf.Unite(s, t)
res += w
return res
print((kruskal()))
|
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_list[1:]):
stw += [[abs(u-v), fr, to]]
stw = sorted(stw, key=lambda x:x[0])
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
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
def kruskal():
# stw = [[s0, t0, w0], [s1, t1, w1], ..., [sn, tn, wn]]
# stw: s: 始点, t: 終点, w: st間の重み
# stwはwを小さい順にソートされたものとする
res = 0
uf = UnionFind(n)
#while stw:
for i in range(len(stw)):
#w, s, t = heapq.heappop(stw)
w, s, t = stw[i]
if not uf.isSameGroup(s, t):
uf.Unite(s, t)
res += w
return res
print((kruskal()))
|
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 in range(n-1):
stw += [[y_list[i][1], y_list[i+1][1], abs(y_list[i][0]-y_list[i+1][0])]]
stw.sort(key=lambda x:x[2])
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
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
def kruskal():
# stw = [[s0, t0, w0], [s1, t1, w1], ..., [sn, tn, wn]]
# stw: s: 始点, t: 終点, w: st間の重み
# stwはwを小さい順にソートされたものとする
# s, tを入れ替えたものはいれなくていい
res = 0
uf = UnionFind(n)
for i in range(len(stw)):
s, t, w = stw[i]
if not uf.isSameGroup(s, t):
uf.Unite(s, t)
res += w
return res
ans = kruskal()
print(ans)
|
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
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
def kruskal(N, stw):
# stw = [[s0, t0, w0], [s1, t1, w1], ..., [sn, tn, wn]]
# stw: s: 始点, t: 終点, w: st間の重み
# stwはwを小さい順にソートされたものとする
# s, tを入れ替えたものはいれなくていい
res = 0
uf = UnionFind(N)
for i in range(len(stw)):
s, t, w = stw[i]
if not uf.isSameGroup(s, t):
uf.Unite(s, t)
res += w
return res
N = int(eval(input()))
ixy = []
for i in range(N):
x, y = list(map(int, input().split()))
ixy += [[i, x, y]]
stw = []
ixy = sorted(ixy, key=lambda x:x[1])
for j in range(N-1):
i, x, y = ixy[j]
ii, xx, yy = ixy[j+1]
stw += [[i, ii, min(abs(x-xx), abs(y-yy))]]
ixy = sorted(ixy, key=lambda x:x[2])
for j in range(N-1):
i, x, y = ixy[j]
ii, xx, yy = ixy[j+1]
stw += [[i, ii, min(abs(x-xx), abs(y-yy))]]
stw = sorted(stw, key=lambda x:x[2])
print((kruskal(N, stw)))
|
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.p[y]=x
return x
def find(self, x, y):
return self.root(x)==self.root(y)
def union(self, x, y):
r1=self.root(x)
r2=self.root(y)
if r1==r2:
return
p1=self.p[r1]
p2=self.p[r2]
if p1<=p2:
self.p[r2]=r1
self.size[r1]+=self.size[r2]
if p1==p2:
self.p[r1]-=1
else:
self.p[r1]=r2
self.size[r2]+=self.size[r1]
def main():
N=int(eval(input()))
r=[tuple(map(int,input().split())) for i in range(N)]
pq=[]
for i in range(N):
for j in range(i+1, N):
d=min(abs(r[i][0]-r[j][0]), abs(r[i][1]-r[j][1]))
heapq.heappush(pq,(d,i,j))
uft=UnionFind(N)
ans=0
while(uft.size[uft.root(0)]<N):
e=heapq.heappop(pq)
if not(uft.find(e[1],e[2])):
ans+=e[0]
uft.union(e[1],e[2])
print(ans)
if __name__=="__main__":
main()
|
# 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.p[y]=x
return x
def find(self, x, y):
return self.root(x)==self.root(y)
def union(self, x, y):
r1=self.root(x)
r2=self.root(y)
if r1==r2:
return
p1=self.p[r1]
p2=self.p[r2]
if p1<=p2:
self.p[r2]=r1
self.size[r1]+=self.size[r2]
if p1==p2:
self.p[r1]-=1
else:
self.p[r1]=r2
self.size[r2]+=self.size[r1]
def main():
N=int(eval(input()))
r=[tuple([i]+list(map(int,input().split()))) for i in range(N)]
rx=sorted(r,key=lambda x:x[1])
ry=sorted(r,key=lambda x:x[2])
pq=[]
for i in range(1,N):
dx=abs(rx[i][1]-rx[i-1][1])
heapq.heappush(pq,(dx,rx[i][0],rx[i-1][0]))
dy=abs(ry[i][2]-ry[i-1][2])
heapq.heappush(pq,(dy,ry[i][0],ry[i-1][0]))
uft=UnionFind(N)
ans=0
while(uft.size[uft.root(0)]<N):
e=heapq.heappop(pq)
if not(uft.find(e[1],e[2])):
ans+=e[0]
uft.union(e[1],e[2])
print(ans)
if __name__=="__main__":
main()
|
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]
invy[cy]=i
xi=invx[0]
yi=invy[0]
q=[(0,0)]
visit=[0]*n
ans=0
while q:
cnt,i=heapq.heappop(q)
if visit[i]==1:
continue
visit[i]=1
ans+=cnt
xi=invx[i]
yi=invy[i]
if xi>0 and visit[x[xi-1][0]]==0:
heapq.heappush(q,(x[xi][1]-x[xi-1][1],x[xi-1][0]))
if xi<n-1 and visit[x[xi+1][0]]==0:
heapq.heappush(q,(x[xi+1][1]-x[xi][1],x[xi+1][0]))
if yi>0 and visit[y[yi-1][0]]==0:
heapq.heappush(q,(y[yi][1]-y[yi-1][1],y[yi-1][0]))
if yi<n-1 and visit[y[yi+1][0]]==0:
heapq.heappush(q,(y[yi+1][1]-y[yi][1],y[yi+1][0]))
print(ans)
|
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,0)]
visit=[0]*n
ans=0
while q:
cnt,i=heapq.heappop(q)
if visit[i]==1:
continue
visit[i]=1
ans+=cnt
xi=invx[i]
yi=invy[i]
for delta in [-1,1]:
nx=xi+delta
ny=yi+delta
if 0<=nx<n and visit[x[nx][0]]==0:
heapq.heappush(q,(abs(x[nx][1]-x[xi][1]),x[nx][0]))
if 0<=ny<n and visit[y[ny][0]]==0:
heapq.heappush(q,(abs(y[ny][1]-y[yi][1]),y[ny][0]))
print(ans)
|
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
#from collections import defaultdict
from itertools import combinations, permutations, accumulate
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 1000000007
N = int(eval(input()))
xy = []
for i in range(N):
x,y = list(map(int, input().split()))
xy.append([x, y, i])
x_sort = sorted(xy, key=lambda x: x[0])
y_sort = sorted(xy, key=lambda x: x[1])
#[cost, 頂点1, 頂点2]
cost = []
for i in range(N-1):
cost.append([abs(x_sort[i][0]-x_sort[i+1][0]), x_sort[i][2], x_sort[i+1][2]])
cost.append([abs(y_sort[i][1]-y_sort[i+1][1]), y_sort[i][2], y_sort[i+1][2]])
cost = sorted(cost, key=lambda x: x[0])
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
def same(x,y):
return find(x) == find(y)
par = [-1]*N
res = 0
for c, v1, v2 in cost:
if not same(v1, v2):
unite(v1, v2)
res += c
print(res)
if __name__ == '__main__':
main()
|
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,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 1000000007
N = int(eval(input()))
xy = []
for i in range(N):
x,y = list(map(int, input().split()))
xy.append([x, y, i])
x_sort = sorted(xy, key=lambda x: x[0])
y_sort = sorted(xy, key=lambda x: x[1])
#[cost, 頂点1, 頂点2]
cost = []
for i in range(N-1):
cost.append([x_sort[i+1][0]-x_sort[i][0], x_sort[i][2], x_sort[i+1][2]])
cost.append([y_sort[i+1][1]-y_sort[i][1], y_sort[i][2], y_sort[i+1][2]])
cost = sorted(cost, key=lambda x: x[0])
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
def same(x,y):
return find(x) == find(y)
par = [-1]*N
res = 0
for c, v1, v2 in cost:
if not same(v1, v2):
unite(v1, v2)
res += c
print(res)
if __name__ == '__main__':
main()
|
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() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = list(range(n + 1))
self.ranks = [0 for _ in range(n + 1)]
def get_root(self, x):
if self.parents[x] == x:
return x
self.parents[x] = self.get_root(self.parents[x])
return self.parents[x]
def merge(self, x, y):
x = self.get_root(x)
y = self.get_root(y)
if x != y:
if self.ranks[x] < self.ranks[y]:
self.parents[x] = y
else:
self.parents[y] = x
if self.ranks[x] == self.ranks[y]:
self.ranks[x] += 1
def kruskal(n_nodes, edges):
edges.sort(key=operator.itemgetter(2))
res = []
uf = UnionFind(n_nodes)
for e in edges:
if uf.get_root(e[0]) != uf.get_root(e[1]):
res.append(e)
uf.merge(e[0], e[1])
return res
n = ri()
ls = rils(n)
ls = list(enumerate(ls))
edges = []
ls.sort(key=lambda x: x[1][0])
for (i, (x0, y0)), (j, (x1, y1)) in zip(ls, ls[1:]):
edges.append((i, j, min(abs(x0 - x1), abs(y0 - y1))))
ls.sort(key=lambda x: x[1][1])
for (i, (x0, y0)), (j, (x1, y1)) in zip(ls, ls[1:]):
edges.append((i, j, min(abs(x0 - x1), abs(y0 - y1))))
res = kruskal(n, edges)
print((sum(x[2] for x in res)))
|
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() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = list(range(n))
self.ranks = [0 for _ in range(n)]
def get_root(self, x):
if self.parents[x] == x:
return x
self.parents[x] = self.get_root(self.parents[x])
return self.parents[x]
def merge(self, x, y):
x = self.get_root(x)
y = self.get_root(y)
if x != y:
if self.ranks[x] < self.ranks[y]:
self.parents[x] = y
else:
self.parents[y] = x
if self.ranks[x] == self.ranks[y]:
self.ranks[x] += 1
def kruskal(n_nodes, edges):
edges.sort(key=operator.itemgetter(2))
res = []
uf = UnionFind(n_nodes)
for e in edges:
if uf.get_root(e[0]) != uf.get_root(e[1]):
res.append(e)
uf.merge(e[0], e[1])
return res
n = ri()
ls = rils(n)
ls = list(enumerate(ls))
edges = []
ls.sort(key=lambda x: x[1][0])
for (i, (x0, y0)), (j, (x1, y1)) in zip(ls, ls[1:]):
edges.append((i, j, min(abs(x0 - x1), abs(y0 - y1))))
ls.sort(key=lambda x: x[1][1])
for (i, (x0, y0)), (j, (x1, y1)) in zip(ls, ls[1:]):
edges.append((i, j, min(abs(x0 - x1), abs(y0 - y1))))
res = kruskal(n, edges)
print((sum(x[2] for x in res)))
|
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_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)]
# adj: [[weight, u, v] * num_edge], V: number of vertices
def kruskal(adj, V):
adj.sort()
uf = UnionFind(V)
ans = 0
for edge in adj:
weight, u, v = edge
if not uf.isSameGroup(u, v):
ans += weight
uf.unite(u, v)
return ans
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()
adj = []
for i in range(N-1):
adj.append([x_list[i + 1][0] - x_list[i][0], x_list[i + 1][1], x_list[i][1]])
adj.append([y_list[i + 1][0] - y_list[i][0], y_list[i + 1][1], y_list[i][1]])
print((kruskal(adj, 2 * (N - 1))))
|
# 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:
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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.