import java.io.{BufferedReader, InputStream, InputStreamReader}
import java.util.StringTokenizer

import scala.collection.mutable
import scala.util.Sorting
import math.{abs, max, min}

object Main {
  val MOD = 1000000007
  def solve(): Unit = {
    val sc = new InputReader(System.in)
    val N = sc.nextInt()

    val x = Array.ofDim[(Int, Int)](N)
    val y = Array.ofDim[(Int, Int)](N)
    (0 until N) foreach { i =>
      x(i) = (sc.nextInt(), i)
      y(i) = (sc.nextInt(), i)
    }
    Sorting.quickSort(x)(Ordering.by(_._1))
    Sorting.quickSort(y)(Ordering.by(_._1))

    type Edge = (Int, (Int, Int))
    def e(a: Array[(Int, Int)], i: Int, j: Int): Edge = {
      val c = abs(a(i)._1 - a(j)._1)
      val u = a(i)._2
      val v = a(j)._2
      (c, u -> v)
    }

    val q = mutable.PriorityQueue[Edge]()(Ordering.by[Edge, Int](_._1).reverse)
    (0 until N) foreach { i =>
      if (i - 1 >= 0) {
        q.enqueue(e(x, i, i - 1))
        q.enqueue(e(y, i, i - 1))
      }
      if (i + 1 < N) {
        q.enqueue(e(x, i, i + 1))
        q.enqueue(e(y, i, i + 1))
      }
    }

    var ans: Long = 0
    var n: Int = 0
    val uf = new UnionFind(N)
    while(n < N -1) {
      val (c, (u, v)) = q.dequeue()
      if (uf.find(u) != uf.find(v)) {
        uf.unite(u, v)
        ans += c
        n += 1
      }
    }

    println(ans)
  }


  def main(args: Array[String]): Unit = {
    solve()
  }


  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = null

    def next: String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next.toInt
    def nextLong(): Long = next.toLong
    def nextChar(): Char = next.charAt(0)
  }

  class UnionFind(n: Int) {
    private val par = Array.iterate(0, n)(_ + 1)
    private val rank = Array.ofDim[Int](n)

    def find(x: Int): Int = {
      if (par(x) == x) x
      else {
        par(x) = find(par(x))
        par(x)
      }
    }

    def unite(x: Int, y: Int): Unit = {
      val x1 = find(x)
      val y1 = find(y)
      if (x1 != y1) {
        if (rank(x1) < rank(y)) {
          par(x1) = y1
        } else {
          par(y1) = x1
          if (rank(x1) == rank(y1)) rank(x1) += 1
        }
      }
    }
  }
}
