Problem:
Score : 700 points

Problem Statement

We have a directed weighted graph with N vertices.
Each vertex has two integers written on it, and the integers written on Vertex i are A_i and B_i.

In this graph, there is an edge from Vertex x to Vertex y for all pairs 1 \leq x,y \leq N, and its weight is {\rm min}(A_x,B_y).

We will consider a directed cycle in this graph that visits every vertex exactly once.
Find the minimum total weight of the edges in such a cycle.

Constraints

2 \leq N \leq 10^5

1 \leq A_i \leq 10^9

1 \leq B_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 B_1
A_2 B_2
:
A_N B_N

Output

Print the minimum total weight of the edges in such a cycle.

Sample Input 1

3
1 5
4 2
6 3

Sample Output 1

7

Consider the cycle 1→3→2→1. The weights of those edges are {\rm min}(A_1,B_3)=1, {\rm min}(A_3,B_2)=2 and {\rm min}(A_2,B_1)=4, for a total of 7.
As there is no cycle with a total weight of less than 7, the answer is 7.

Sample Input 2

4
1 5
2 6
3 7
4 8

Sample Output 2

10

Sample Input 3

6
19 92
64 64
78 48
57 33
73 6
95 73

Sample Output 3

227

Solution in Scala (2.11.7) (judge verdict: Wrong Answer)

import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  val N = in.next().toInt
  val A = new Array[Long](N+1)
  val B = new Array[Long](N+1)
  for (i <- 1 to N) {
    val a, b = in.next().toInt
    A(i) = a
    B(i) = b
  }


  // check smallest
  val hoge = new Array[(Long, Int)](2*N)
  for (i <- 1 to N) {
    val ind = 2*(i-1)
    hoge(ind) = (A(i), -i)
    hoge(ind+1) = (B(i), i)
  }

  val ord = hoge.sorted
  var ans = ord.take(N).map(_._1).sum
  var flag1 = false
  val memo = new Array[Boolean](N+1)
  for (i <- 0 until N) {
    val (_, _ind) = ord(i)
    val ind = _ind.abs

    if(memo(ind))
      flag1 = true
    else
      memo(ind) = true
  }

  if(A.sum == ans || B.sum == ans || flag1)
    ()
  else {
    val dpA = new Array[Boolean](N+1)
    val dpB = new Array[Boolean](N+1)

    for (i <- 0 until N) {
      val (_, ind) = ord(i)

      if(ind < 0)
        dpA(ind.abs) = true
      else
        dpB(ind.abs) = true
    }

    var diff = 0L
    val (maxNum, maxi) = ord(N-1)
    breakable {
      for ((nowNum, nowi) <- ord.slice(N, 2*N)) {
        if(nowi < 0 && !dpA(nowi.abs)) {
          diff = nowNum - maxNum
          break
        }
        else if(nowi > 0 && !dpB(nowi.abs)) {
          diff = nowNum - maxNum
          break
        }
      }
    }


    ans = A.sum min B.sum min (ans+diff)
  }


  println(ans)
}


class InputReader(stream: InputStream) {
  private val reader = new BufferedReader(new InputStreamReader(stream))
  private var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}