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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.min;
import static java.lang.System.exit;
import static java.util.Arrays.sort;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

	static class Token implements Comparable<Token> {
		final int value, id;
		final boolean isB;
		boolean isBig;

		Token(int value, int id, boolean isB) {
			this.value = value;
			this.id = id;
			this.isB = isB;
		}

		public int compareTo(Token o) {
			return value - o.value;
		}
	}

	static void solve() throws Exception {
		int n = scanInt();
		Token a[] = new Token[n], b[] = new Token[n];
		Token tokens[] = new Token[2 * n];
		for (int i = 0; i < n; i++) {
			a[i] = tokens[i] = new Token(scanInt(), i, false);
			b[i] = tokens[i + n] = new Token(scanInt(), i, true);
		}
		sort(tokens);
		long sum = 0;
		for (int i = 0; i < n; i++) {
			sum += tokens[i].value;
		}
		for (int i = n; i < 2 * n; i++) {
			tokens[i].isBig = true;
		}
		int c1 = 0, c2 = 0, c3 = 0;
		for (int i = 0; i < n; i++) {
			if (!a[i].isBig && b[i].isBig) {
				++c1;
			} else if (a[i].isBig && !b[i].isBig) {
				++c3;
			} else {
				++c2;
			}
		}
		if (c2 == 0 && c1 != 0 && c3 != 0) {
			if (tokens[n - 1].id != tokens[n].id ||
				(c1 == 1 && tokens[n].isB == tokens[n].isBig) ||
				(c3 == 1 && tokens[n].isB != tokens[n].isBig)) {
				sum += tokens[n].value - tokens[n - 1].value;
			} else {
				sum += min(tokens[n].value - tokens[n - 2].value,
					tokens[n + 1].value - tokens[n - 1].value);
			}
		}
		out.print(sum);
	}

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	static long scanLong() throws IOException {
		return parseLong(scanString());
	}

	static String scanString() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}