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 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using vi = vector<i64>;
using vvi = vector<vi>;

bool visited[101010];
bool revisited;

struct edge {
    int a, id;
    bool out;
};

int main() {
    int n;
    cin >> n;
    vector<edge> vs;
    for (int i = 0; i < n; i++) {
        int a, b;
        cin >> a >> b;
        vs.push_back((edge) {a, i, true});
        vs.push_back((edge) {b, i, false});
    }
    sort(vs.begin(), vs.end(), [](edge e1, edge e2) {
        return e1.a < e2.a;
    });

    i64 ans = 0;
    int incnt = 0;
    int outcnt = 0;
    int cntmax = (n + 1) / 2;
    for (edge& e: vs) {
        if (incnt + outcnt == n) {
            break;
        }
        if (visited[e.id] && !revisited) {
            if (e.out) {
                if (outcnt + 1 <= cntmax) {
                    outcnt++;
                    revisited = true;
                    ans += e.a;
                }
            } else {
                if (incnt + 1 <= incnt) {
                    incnt++;
                    revisited = true;
                    ans += e.a;
                }
            }
        }
        if (visited[e.id]) continue;
        if (!visited[e.id]) {
            if (e.out) {
                if (outcnt + 1 <= cntmax) {
                    outcnt++;
                    visited[e.id] = true;
                    ans += e.a;
                }
            } else {
                if (incnt + 1 <= cntmax) {
                    incnt++;
                    visited[e.id] = true;
                    ans += e.a;
                }
            }
        }
    }
    cout << ans << endl;
}