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 C++14 (Clang 3.8.0) (judge verdict: Accepted)

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>
#include <map>
#include <random>
#include <cstdio>
#include <cstring>
#include <cmath>

using namespace std;
using ll = long long;
using P = pair<ll, ll>;

ll N;
vector<P> AB;

void input() {
    cin >> N;
    AB.resize(N);
    for (auto& v : AB) {
        cin >> v.first >> v.second;
    }
}

ll solve() {
    struct ABRef {
        ll p, t;
        ll v() {
            return t == 0 ? AB[p].first : AB[p].second;
        }
    };
    ll sumA = 0, sumB = 0;
    for (auto& v : AB) {
        sumA += v.first;
        sumB += v.second;
    }
    
    vector<ABRef> abrs(N * 2);
    for (ll i = 0; i < N; i++) for (ll j = 0; j < 2; j++) {
        abrs[i * 2 + j] = ABRef{i, j};
    }
    sort(abrs.begin(), abrs.end(), [](ABRef l, ABRef r) {
       return l.v() < r.v();
    });
    
    ll cw[N * 2];
    cw[0] = abrs[0].v();
    for (int i = 1; i < N * 2; i++)
        cw[i] = cw[i - 1] + abrs[i].v();
    
    vector<bool> used(N, false);
    bool useFrontNth = false;
    for (int i = 0; i < N; i++) {
        if (used[abrs[i].p]){
            useFrontNth = true;
            break;
        }
        used[abrs[i].p] = true;
    }
    
    ll sumN = 0;
    if (useFrontNth) {
        sumN = cw[N - 1];
    } else {
        for (int unuse = 0; unuse < N; unuse++) {
            ll sum = cw[N - 1] - abrs[unuse].v();
            ll unuseI = abrs[unuse].p;
            if (abrs[N].p != unuseI)
                sum += abrs[N].v();
            else
                sum += abrs[N + 1].v();
            sumN = unuse == 0 ? sum : min(sumN, sum);
        }
    }
    return min(min(sumA, sumB), sumN);
}

int main() {
    input();
    
    cout << solve() << endl;
    
    
    return 0;
}