๋ฏผํ์ด๋ ํฐ๋์ ์ด N-1๊ฐ ๊ฑด์คํด์ ๋ชจ๋ ํ์ฑ์ด ์๋ก ์ฐ๊ฒฐ๋๊ฒ ํ๋ ค๊ณ ํ๋ค.
์ด๋, ๋ชจ๋ ํ์ฑ์ ํฐ๋๋ก ์ฐ๊ฒฐํ๋๋ฐ ํ์ํ ์ต์ ๋น์ฉ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ต์ํ์ ๊ฒฝ๋ก, ์ต์ํ์ ๊ฒฝ๋น๋ฅผ ์๊ตฌํ๋ ์ต์ ์คํจ๋ ํธ๋ฆฌ ๋ฌธ์ ์ด๋ค.
๊ฐ ์ ์ ๋ค ๊ฐ์ ๊ฑฐ๋ฆฌ๋ min(|xA-xB|, |yA-yB|, |zA-zB|)
๋ก ๊ตฌํ ์ ์๋ค. ๋ ์ ์ ๊ฐ์ ๊ฑฐ๋ฆฌ๋ค์ x, y, z์ขํ ๊ฐ๊ฐ์ผ๋ก ๊ตฌํ ํ ๊ทธ ์ค ์ต์๊ฐ์ ํํ๋ฉด ๋๋ค. ๊ฐ ์ขํ์ ๋ํ ์ ์ ๋ค์ ์ต์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ๋ค. ๊ฐ ์ขํ๊ฐ๋ค์ ๊ธฐ์ค์ผ๋ก ๋ชจ๋ ์ ์ ๋ค์ ์ ๋ ฌํ๋ค. ์๋๋ x์ขํ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ๊ฒฐ๊ณผ๊ฐ์ด๋ค.
[2, [-1, -1, -5]]
[3, [10, -4, -1]]
[0, [11, -15, -15]]
[1, [14, -5, -15]]
[4, [19, -4, 19]]
์์ ๋ช ๋ฒ์งธ ์ ์ ์ธ์ง, ๋ค๋ ๊ฐ ์ ์ ์ xyz ์ขํ ๊ฐ์ด๋ค. x์ขํ์ ๋ํด ์ ๋ ฌํ์ผ๋ฏ๋ก x์ขํ ๊ธฐ์ค ์ค๋ฆ์ฐจ์์ผ๋ก ๋ํ๋๊ณ ์๋ค. ์ฌ๊ธฐ์ ๋ชจ๋ ์ ์ ๋ค์ ๋ํด์ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ๊น์ง์ ๊ฑฐ๋ฆฌ๋ค์ ์ ๋ถ ๊ตฌํ ํ์๋ ์๋ค. ์ด ๋ฌธ์ ์์ ์๊ตฌํ๋ ๊ฒ์ ๊ฒฐ๊ตญ ์ต์ ๋น์ฉ์ด๊ธฐ ๋๋ฌธ์, ์๋ก ์ธ์ ํ ์ ์ ๊ฐ์ ๊ฑฐ๋ฆฌ๋ง ๊ตฌํ๋ฉด ๋๋ค. ์ฆ 2๋ฒ ์ ์ ๊ณผ 3๋ฒ ์ ์ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ง ๊ตฌํ๋ฉด ๋๊ณ , 2๋ฒ ์ ์ ๊ณผ 0๋ฒ ์ ์ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ ๊ตณ์ด ๊ตฌํ ํ์๊ฐ ์๋ค๋ ์๋ฆฌ. ์ด์ฐจํผ 2๋ฒ ์ ์ ์์ 0๋ฒ ์ ์ ์ผ๋ก ๊ฐ๋ ๊ฑฐ๋ฆฌ 12๋, 3๋ฒ ์ ์ ์ ๊ฑฐ์ณ์(11+1)๊ฐ๋ ๊ฑฐ๋ฆฌ๋ ๋๊ฐ๋ค.
์ด๋ ๊ฒ ํด์ ๊ฐ ์ขํ ๋ณ๋ก ์ ๋ ฌํ ํ ์ธ์ ํ ๊ฑฐ๋ฆฌ๋ค์ ๊ตฌํ๋ค. ๋ชจ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋ค ๊ตฌํด์ ์ ์ ์ ๋ฒํธ๊ฐ ์์ ๊ฐ์ ์์ ์ค๋๋ก ํ ํ dist ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ๋ง๋ค๊ธฐ ์ํด์๋ ๊ฑฐ๋ฆฌ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ํด์ผ ํ๋ค. dist ๋ฐฐ์ด์ ๋ํด ๊ฑฐ๋ฆฌ ์์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ ํ ์ ๋์จํ์ธ๋๋ฅผ ์ฌ์ฉํด ๊ฐ ์ ์ ์ด ๊ฐ์ ์งํฉ์ ์ํด์๋์ง ํ์ธํ๊ณ ์ํด์์ง ์๋ค๋ฉด ๊ฐ์ ์งํฉ์ผ๋ก ๋ง๋๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉฐ ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ๊ทธ๋ ค๋๊ฐ๋ฉด ๋๋ค.
import sys
input = sys.stdin.readline
def find(x):
if parent[x] != x:
parent[x] = find(parent[x])
return parent[x]
def union(x, y):
x = find(x)
y = find(y)
if x < y:
parent[y] = x
else:
parent[x] = y
def find_dist(lst, k):
global dist
for i in range(N-1):
x, y = lst[i][0], lst[i+1][0]
if x < y:
dist.append((x, y, abs(lst[i][1][k]-lst[i+1][1][k])))
else:
dist.append((y, x, abs(lst[i][1][k]-lst[i+1][1][k])))
N = int(input())
planet = [[i, list(map(int, input().split()))] for i in range(N)]
parent = [x for x in range(N)]
dist = []
for i in range(3):
find_dist(sorted(planet, key=lambda x: x[1][i]), i)
dist.sort(key=lambda x: x[-1])
cost = 0
for x, y, d in dist:
if find(x) == find(y):
continue
union(x, y)
cost += d
print(cost)