using static System.Math;
using static System.Console;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace AtCoder
{
    class Program
    {
        static void Main(string[] args)
        {
            var n = int.Parse(ReadLine());
            var cities = new int[n][];
            var parents = new int[n];
            var costs = new Dictionary<int, Dictionary<int, int>>();
            for (var i = 0; i < n; i++)
            {
                var line = ReadLine().Split(' ').Select(value => int.Parse(value)).ToArray();
                cities[i] = new int[3] { i, line[0], line[1] };
                parents[i] = i;
                costs.Add(i, new Dictionary<int, int>());
            }

            cities = cities.OrderBy(array => array[1]).ToArray();
            for(var i = 0; i < n - 1; i++)
            {
                if(cities[i][0] < cities[i + 1][0])
                {
                    costs[cities[i][0]].Add(cities[i + 1][0], Abs(cities[i][1] - cities[i + 1][1]));
                }
                else
                {
                    costs[cities[i + 1][0]].Add(cities[i][0], Abs(cities[i][1] - cities[i + 1][1]));
                }
            }
            cities = cities.OrderBy(array => array[2]).ToArray();
            for (var i = 0; i < n - 1; i++)
            {
                if (cities[i][0] < cities[i + 1][0])
                {
                    if (costs[cities[i][0]].ContainsKey(cities[i + 1][0]))
                    {
                        costs[cities[i][0]][cities[i + 1][0]] = Min(costs[cities[i][0]][cities[i + 1][0]], Abs(cities[i][2] - cities[i + 1][2]));
                    }
                    else
                    {
                        costs[cities[i][0]].Add(cities[i + 1][0], Abs(cities[i][2] - cities[i + 1][2]));
                    }
                }
                else
                {
                    if (costs[cities[i + 1][0]].ContainsKey(cities[i][0]))
                    {
                        costs[cities[i + 1][0]][cities[i][0]] = Min(costs[cities[i + 1][0]][cities[i][0]], Abs(cities[i + 1][2] - cities[i][2]));
                    }
                    else
                    {
                        costs[cities[i + 1][0]].Add(cities[i][0], Abs(cities[i + 1][2] - cities[i][2]));
                    }
                }
            }

            var costsList = new List<int[]>();
            foreach (var source in costs)
            {
                foreach (var destination in source.Value)
                {
                    costsList.Add(new int[3] { source.Key, destination.Key, destination.Value });
                }
            }
            costsList = costsList.OrderBy(array => array[2]).ToList();

            var totalCost = 0;
            foreach(var cost in costsList)
            {
                if(GetRoot(parents, cost[0]) != GetRoot(parents, cost[1]))
                {
                    totalCost += cost[2];
                    Union(parents, cost[0], cost[1]);
                }
            }

            WriteLine(totalCost);
        }

        private static int GetRoot(int[] parents, int node)
        {
            if(parents[node] == node)
            {
                return node;
            }
            return parents[node] = GetRoot(parents, parents[node]);
        }

        private static void Union(int[] parents, int x, int y)
        {
            x = GetRoot(parents, x);
            y = GetRoot(parents, y);

            if(x != y)
            {
                parents[x] = y;
            }
        }
    }
}


Measured memory_bytes: 72112