import java.util.Scanner
import scala.collection.mutable.PriorityQueue

class UnionFind(v: Int){
  // 根であれば *そのグループの要素数(負)* が、子であれば親の番号が入る。
  val uni = Array.fill(v)(-1)

  // 頂点 v の所属するグループを調べる
  def root(v: Int): Int =
    uni(v) < 0 match{
      case true  =>  // v が親の場合
        return v
      case false =>  // v が子の場合
        uni(v) = root(uni(v))  // 親のrootを調べる
        return uni(v)
    }

  // 頂点 a と頂点 b をつなぐ。もともと同じグループのとき、False を返す
  def connect(a: Int, b: Int): Boolean = {
    // まずはそれぞれ根の番号に置き換える
    var ra = root(a)
    var rb = root(b)
    if(ra == rb)
      return false  // a と b がそもそも同じグループに属しているなら即終了

    // ra を大きなグループにしたいので、逆であれば入れ替える
    if(uni(ra) > uni(rb)) {  // rbの方が要素数が多ければ
      var tmp = ra
      ra = rb
      rb = tmp
    }

    // ra と rb を結合し、rb の親を ra とする
    uni(ra) += uni(rb)
    uni(rb) = ra
    return true
  }

  // 頂点 a, b が同じグループであるかを調べる
  def isConnect(a: Int, b: Int): Boolean =
    root(a) == root(b)

  // 頂点 a を含むグループの頂点数を調べる
  def size(a: Int): Int = -uni(root(a))
}

object Main extends App {
  val sc = new Scanner(System.in)

  val N = sc.nextInt()
  val xp = new Array[(Int, Int)](N)
  val yp = new Array[(Int, Int)](N)

  for (i <- 1 to N){
    val x = sc.nextInt(); val y = sc.nextInt()
    xp(i-1) = (x, i)
    yp(i-1) = (y, i)
  }

  scala.util.Sorting.quickSort(xp)
  scala.util.Sorting.quickSort(yp)

  // ret : (cost, (node1, node2))
  def makeCosts(pl: List[(Int, Int)]): List[(Int, (Int, Int))] = {
    def calc(pl: List[(Int, Int)], res: List[(Int, (Int, Int))]): List[(Int, (Int, Int))] = {
      pl match {
        case Nil | _ :: Nil => res
        case a :: b :: rest =>
          val cost = Math.abs(a._1 - b._1)
          calc(b :: rest, (cost, (a._2, b._2)) :: res)
      }
    }
    calc(pl, List())
  }

  val xc = makeCosts(xp.toList)
  val yc = makeCosts(yp.toList)

  val pq = new PriorityQueue[(Int, (Int, Int))]

  for (xinfo <- xc.map{case (cost, p) => (-cost, p)}) {
    pq.enqueue(xinfo)
  }
  for (yinfo <- yc.map{case (cost, p) => (-cost, p)}) {
    pq.enqueue(yinfo)
  }


  List()(1)

  // // 
  val uf = new UnionFind(N+1)

  var ans = 0L
  var flag = true
  while(flag) {
    val (cost, (a, b)) = pq.dequeue
    if(!uf.isConnect(a, b)) {
      ans += -cost
      uf.connect(a, b)
      if(uf.size(a) == N)
        flag = false
    }
  }

  println(ans)
}
