import sys

input = sys.stdin.readline

def INT(): return int(eval(input()))

def MAP(): return list(map(int,input().split()))

def LI(): return list(map(int,input().split()))

import decimal

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



def main():

    N = INT()

    x = []

    y = []

    for _ in range(N):

        xx,yy = MAP()

        x.append(xx)

        y.append(yy)

    x = [(x[i],i) for i in range(N)]

    y = [(y[i],i) for i in range(N)]

    x.sort()

    y.sort()

    edges = []

    for i in range(N-1):

        edges.append((x[i][1],x[i+1][1],x[i+1][0]-x[i][0]))

        edges.append((y[i][1],y[i+1][1],y[i+1][0]-y[i][0]))

    edges.sort(key=lambda x:x[2])

    uf = UnionFind(N)

    answer = 0

    for i in range(len(edges)):

        s,t,w = edges[i]

        if not uf.same(s,t):

            uf.union(s,t)

            answer += w

    print(answer)

    return



if __name__ == '__main__':

    main()

import sys

input = sys.stdin.readline

def INT(): return int(eval(input()))

def MAP(): return list(map(int,input().split()))

def LI(): return list(map(int,input().split()))

import decimal

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



def main():

    N = INT()

    x = []

    y = []

    for _ in range(N):

        xx,yy = MAP()

        x.append(xx)

        y.append(yy)

    x = [(x[i],i) for i in range(N)]

    y = [(y[i],i) for i in range(N)]

    x.sort(key=lambda x:x[0])

    y.sort(key=lambda x:x[0])

    edges = []

    for i in range(N-1):

        edges.append((x[i][1],x[i+1][1],x[i+1][0]-x[i][0]))

        edges.append((y[i][1],y[i+1][1],y[i+1][0]-y[i][0]))

    edges.sort(key=lambda x:x[2])

    uf = UnionFind(N)

    answer = 0

    for i in range(len(edges)):

        s,t,w = edges[i]

        if not uf.same(s,t):

            uf.union(s,t)

            answer += w

    print(answer)

    return



if __name__ == '__main__':

    main()

import sys

input = sys.stdin.readline


def INT():
    return int(eval(input()))


def MAP():
    return list(map(int, input().split()))


def LI():
    return list(map(int, input().split()))


import decimal


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


def main():
    N = INT()
    x = []
    y = []
    for _ in range(N):
        xx, yy = MAP()
        x.append(xx)
        y.append(yy)
    x = [(x[i], i) for i in range(N)]
    y = [(y[i], i) for i in range(N)]
    x.sort()
    y.sort()
    edges = []
    for i in range(N - 1):
        edges.append((x[i][1], x[i + 1][1], x[i + 1][0] - x[i][0]))
        edges.append((y[i][1], y[i + 1][1], y[i + 1][0] - y[i][0]))
    edges.sort(key=lambda x: x[2])
    uf = UnionFind(N)
    answer = 0
    for i in range(len(edges)):
        s, t, w = edges[i]
        if not uf.same(s, t):
            uf.union(s, t)
            answer += w
    print(answer)
    return


if __name__ == "__main__":
    main()

import sys

input = sys.stdin.readline


def INT():
    return int(eval(input()))


def MAP():
    return list(map(int, input().split()))


def LI():
    return list(map(int, input().split()))


import decimal


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


def main():
    N = INT()
    x = []
    y = []
    for _ in range(N):
        xx, yy = MAP()
        x.append(xx)
        y.append(yy)
    x = [(x[i], i) for i in range(N)]
    y = [(y[i], i) for i in range(N)]
    x.sort(key=lambda x: x[0])
    y.sort(key=lambda x: x[0])
    edges = []
    for i in range(N - 1):
        edges.append((x[i][1], x[i + 1][1], x[i + 1][0] - x[i][0]))
        edges.append((y[i][1], y[i + 1][1], y[i + 1][0] - y[i][0]))
    edges.sort(key=lambda x: x[2])
    uf = UnionFind(N)
    answer = 0
    for i in range(len(edges)):
        s, t, w = edges[i]
        if not uf.same(s, t):
            uf.union(s, t)
            answer += w
    print(answer)
    return


if __name__ == "__main__":
    main()

-    x.sort() -    y.sort() +    x.sort(key=lambda x: x[0]) +    y.sort(key=lambda x: x[0])