Problem:
Score : 500 points

Problem Statement

There are N towns on a plane. The i-th town is located at the coordinates (x_i,y_i). There may be more than one town at the same coordinates.

You can build a road between two towns at coordinates (a,b) and (c,d) for a cost of min(|a-c|,|b-d|) yen (the currency of Japan). It is not possible to build other types of roads.

Your objective is to build roads so that it will be possible to travel between every pair of towns by traversing roads. At least how much money is necessary to achieve this?

Constraints

2 ≤ N ≤ 10^5

0 ≤ x_i,y_i ≤ 10^9

All input values are integers.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
x_2 y_2
:
x_N y_N

Output

Print the minimum necessary amount of money in order to build roads so that it will be possible to travel between every pair of towns by traversing roads.

Sample Input 1

3
1 5
3 9
7 8

Sample Output 1

3

Build a road between Towns 1 and 2, and another between Towns 2 and 3. The total cost is 2+1=3 yen.

Sample Input 2

6
8 3
4 9
12 19
18 1
13 5
7 6

Sample Output 2

8

Solution in Scala (2.11.7) (judge verdict: Time Limit Exceeded)

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).toArray.sorted
  val yc = makeCosts(yp.toList).toArray.sorted

  // 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)
  // }


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

  var xi = 0; var yi = 0

  var ans = 0L
  var flag = true
  while(flag) {
    val (costx, (ax, bx)) = xc(xi)
    val (costy, (ay, by)) = yc(yi)
    val (cost, (a, b)) = {
      if(costx <= costy) {
        xi += 1
        (costx, (ax, bx))
      }
      else {
        yi += 1
        (costy, (ay, by))
      }
    }
    if(!uf.isConnect(a, b)) {
      ans += cost
      uf.connect(a, b)
      if(uf.size(a) == N)
        flag = false
    }
  }

  println(ans)
}