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: Accepted)

#include <bits/stdc++.h>

int main() {
    long long n;
    std::cin >> n;
    std::vector<long long> a(n), b(n);
    auto sa = 0ll, sb = 0ll;
    // (val, A or B, index)
    // A -> true, B -> false
    std::set<std::tuple<long long, bool, long long>> ss;
    for (int i = 0; i < n; i++) {
        std::cin >> a[i] >> b[i];
        ss.emplace(a[i], true, i);
        ss.emplace(b[i], false, i);
        sa += a[i];
        sb += b[i];
    }

    std::set<int> nums;
    std::deque<std::tuple<long long, bool, long long>> q;
    while (q.size() < n) {
        auto el = *ss.begin();
        q.push_back(el);
        nums.insert(std::get<2>(el));
        ss.erase(ss.begin());
    }

    auto q2(q);
    if (nums.size() == n)
    {
        auto le = q[n - 1];
        auto it = ss.begin();
        while (std::get<2>(*it) == std::get<2>(le)) it++;
        q.pop_back();
        q.push_back(*it);

        le = q2[n - 2];
        it = ss.begin();
        while (std::get<2>(*it) == std::get<2>(le)) it++;
        q2.erase(q2.begin() + n - 2);
        q2.push_back(*it);
    }

    auto s = std::accumulate(q.begin(), q.end(), 0ll, [](auto init, auto& el) { return init + std::get<0>(el); }),
        s2 = std::accumulate(q2.begin(), q2.end(), 0ll, [](auto init, auto& el) { return init + std::get<0>(el); });
    std::cout << std::min({ s, s2, sa, sb }) << std::endl;

    return 0;
}