import java.io.BufferedReader
import java.io.BufferedWriter

fun main() = Case().exec(::solve)
fun solve(c: Case) {
    val n = c.long().toInt()
    val towns = (0 until n).map { ind -> c.intList().let { Town(ind, it[0], it[1]) }}
    val edges = towns.sortedBy { it.x }.zipWithNext().map {
        Kruskal.Edge(it.first.id, it.second.id, it.second.x - it.first.x)
    } + towns.sortedBy { it.y }.zipWithNext().map {
        Kruskal.Edge(it.first.id, it.second.id, it.second.y - it.first.y)
    }
    c.println(Kruskal.solve(n, edges))
}

data class Town(val id: Int, val y: Int, val x: Int)

object Kruskal {
    fun solve(nodeSize: Int, edges: List<Edge>): Long {
        val unionFind = UnionFind(nodeSize)
        var cost = 0L
        edges.sortedBy { it.cost }.forEach { edge ->
            if (unionFind.same(edge.from, edge.to)) return@forEach
            unionFind.unite(edge.from, edge.to)
            cost += edge.cost
        }
        return cost
    }

    data class Edge(val from: Int, val to: Int, val cost: Int)

    private class UnionFind(n: Int) {
        val par = (0 until n).toMutableList()
        fun root(x: Int): Int = if (par[x] == x) x else root(par[x]).also { par[x] = it }
        fun same(x: Int, y: Int): Boolean = root(x) == root(y)
        fun unite(x: Int, y: Int) {
            if (root(x) != root(y)) par[root(x)] = root(y)
        }
    }
}

class Case(
    private val input: BufferedReader = System.`in`.bufferedReader(),
    private val out: BufferedWriter = System.out.bufferedWriter()
) {
    fun exec(fn: (Case) -> Unit) = input.use { out.use { execInThread(fn) } }
    private fun execInThread(fn: (Case) -> Unit) =
        Thread(null, { fn(this) }, "solve", 64 * 1024 * 1024)
            .apply { setUncaughtExceptionHandler { _, e -> e.printStackTrace(); kotlin.system.exitProcess(1) } }
            .apply { start() }.join()

    fun println(c: CharSequence?) = out.appendln(c)
    fun println(c: Number) = println(c.toString())
    fun string(): String = input.readLine().trimEnd()
    fun int(): Int = string().toInt()
    fun long(): Long = string().toLong()
    fun intList(): List<Int> = string().split(" ").map { it.toInt() }
    fun longList(): List<Long> = string().split(" ").map { it.toLong() }
}