# 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)

# 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)

+import sys + +input = sys.stdin.readline