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 union(self, x, y):

        x = self.find(x)

        y = self.find(y)



        if x == y:

            return



        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(input())

X=[]

Y=[]

for i in range(N):

    x,y=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()

"""

N = int(eval(input()))

P = [[i, list(map(int, input().split()))] for i in range(N)]



X = sorted([[i, xy[0]] for i, xy in P], key=lambda x: x[1])

Y = sorted([[i, xy[1]] for i, xy in P], key=lambda y: y[1])



Xe = [[X[i][0], X[i+1][0], abs(X[i][1]-X[i+1][1])] for i in range(N-1)]

Ye = [[Y[i][0], Y[i+1][0], abs(Y[i][1]-Y[i+1][1])] for i in range(N-1)]

E = sorted(Xe + Ye, key=lambda e: e[2])

U=UnionFind(N)

i=0

ans=0

count=1

while(count<N):

    v1,v2,cost=E[i]

    if not U.same_check(v1,v2):

        U.union(v1,v2)

        ans+=cost

        count+=1

    i+=1

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

P = [[i, list(map(int, input().split()))] for i in range(N)]



X = sorted([[i, xy[0]] for i, xy in P], key=lambda x: x[1])

Y = sorted([[i, xy[1]] for i, xy in P], key=lambda y: y[1])



Xe = [[X[i][0], X[i+1][0], abs(X[i][1]-X[i+1][1])] for i in range(N-1)]

Ye = [[Y[i][0], Y[i+1][0], abs(Y[i][1]-Y[i+1][1])] for i in range(N-1)]

E = sorted(Xe + Ye, key=lambda e: e[2])



U=[UnionFindNode(i) for i in range(N)]

i=0

ans=0

count=1

while(count<N):

    v1,v2,cost=E[i]

    if not U[v1].is_group(U[v2]):

        U[v1].unite(U[v2])

        ans+=cost

        count+=1

    i+=1

print(ans)

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 union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        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(input())
X=[]
Y=[]
for i in range(N):
    x,y=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()
"""
N = int(eval(input()))
P = [[i, list(map(int, input().split()))] for i in range(N)]
X = sorted([[i, xy[0]] for i, xy in P], key=lambda x: x[1])
Y = sorted([[i, xy[1]] for i, xy in P], key=lambda y: y[1])
Xe = [[X[i][0], X[i + 1][0], abs(X[i][1] - X[i + 1][1])] for i in range(N - 1)]
Ye = [[Y[i][0], Y[i + 1][0], abs(Y[i][1] - Y[i + 1][1])] for i in range(N - 1)]
E = sorted(Xe + Ye, key=lambda e: e[2])
U = UnionFind(N)
i = 0
ans = 0
count = 1
while count < N:
    v1, v2, cost = E[i]
    if not U.same_check(v1, v2):
        U.union(v1, v2)
        ans += cost
        count += 1
    i += 1
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()))
P = [[i, list(map(int, input().split()))] for i in range(N)]
X = sorted([[i, xy[0]] for i, xy in P], key=lambda x: x[1])
Y = sorted([[i, xy[1]] for i, xy in P], key=lambda y: y[1])
Xe = [[X[i][0], X[i + 1][0], abs(X[i][1] - X[i + 1][1])] for i in range(N - 1)]
Ye = [[Y[i][0], Y[i + 1][0], abs(Y[i][1] - Y[i + 1][1])] for i in range(N - 1)]
E = sorted(Xe + Ye, key=lambda e: e[2])
U = [UnionFindNode(i) for i in range(N)]
i = 0
ans = 0
count = 1
while count < N:
    v1, v2, cost = E[i]
    if not U[v1].is_group(U[v2]):
        U[v1].unite(U[v2])
        ans += cost
        count += 1
    i += 1
print(ans)

-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) +class UnionFindNode(object): +    """ +    Union-Find構造 +    ノードのグループ併合や、所属グループ判定を高速に処理する +    """ -    # 検索 -    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 __init__(self, group_id, parent=None, value=None): +        self.group_id_ = group_id +        self.parent_ = parent +        self.value = value +        self.size_ = 1 -    # 併合 -    def union(self, x, y): -        x = self.find(x) -        y = self.find(y) -        if x == y: -            return -        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 __str__(self): +        template = "UnionFindNode(group_id: {}, \n\tparent: {}, value: {}, size: {})" +        return template.format(self.group_id_, self.parent_, self.value, self.size_) -    # 同じ集合に属するか判定 -    def same_check(self, x, y): -        return self.find(x) == self.find(y) +    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(input()) -X=[] -Y=[] -for i in range(N): -    x,y=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 = UnionFind(N) +U = [UnionFindNode(i) for i in range(N)] -    if not U.same_check(v1, v2): -        U.union(v1, v2) +    if not U[v1].is_group(U[v2]): +        U[v1].unite(U[v2])