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 <algorithm>
#include <cassert>
#include <cstring>
#include <iostream>
#include <set>
#include <vector>

using namespace std;

#define TRACE(x) cout << #x << " = " << x << endl
#define _ << " _ " <<

typedef long long llint;

int main(void) {
  ios_base::sync_with_stdio(false);

  int N;
  cin >> N;
  vector<int> A(N), B(N);
  vector<pair<int, int>> Ap(N), Bp(N);
  for (int i = 0; i < N; ++i) {
    cin >> A[i] >> B[i];
    Ap[i] = {A[i], i};
    Bp[i] = {B[i], i};
  }

  sort(Ap.begin(), Ap.end());
  sort(Bp.begin(), Bp.end());
  reverse(Bp.begin(), Bp.end());

  vector<int> p(N);
  for (int i = 0; i < N; ++i) {
    p[Ap[i].second] = Bp[i].second;
  }

  bool ok = false;
  bool have0 = false, have1 = false;
  llint ret = 0;
  vector<bool> bio(N, false);
  for (int i = 0; i < N; ++i) {
    ret += min(A[i], B[p[i]]);
    if (!bio[i]) {
      int x = i;
      bool i0 = false, i1 = false;
      while (!bio[x]) {
        int y = p[x];
        if (A[x] <= B[y]) i0 = true;
        if (A[x] >= B[y]) i1 = true;
        bio[x] = true;
        x = y;
      }

      if (i0 && i1) ok = true;
      have0 |= i0;
      have1 |= i1;
    }
  }

  if (have0 && have1 && !ok) {
    int i = 0;
    while (i + 1 < N && Ap[i + 1].first < Bp[i + 1].first) i++;

    ret -= min(Ap[i].first, Bp[i].first);
    ret -= min(Ap[i + 1].first, Bp[i + 1].first);
    ret += min(Ap[i].first, Bp[i + 1].first);
    ret += min(Ap[i + 1].first, Bp[i].first);
  }
  cout << ret << "\n";
  return 0;
}