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 <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <numeric>
#include <iostream>

using namespace std;

#define FOR(i, a, b)   for(int i = (a); i < (b); ++i)
#define RFOR(i, a, b)  for(int i = (a); i > (b); --i)
#define rep(i, n)      for(int i = 0; i < (n); ++i)
#define all(c)         begin(c), end(c)
#define rall(c)        rbegin(c), rend(c)
#define SZ(a)          ((ll) a.size())

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;

int main() {
  int N;
  cin >> N;
  vector<int> A(N);
  vector<int> B(N);
  rep(i,N) scanf("%d %d\n",&A[i],&B[i]);

  vector<pair<int,int> > sortA(N);
  vector<pair<int,int> > sortB(N);
  rep(i,N){
    sortA[i]=make_pair(A[i],-i);
    sortB[i]=make_pair(B[i],-i);
  }
  sort(all(sortA));
  sort(all(sortB));

  vector<int> flagA(N,0);
  vector<int> flagB(N,0);
  vector<int> flag(N,0);

  int samenum1=0;
  int samenum2=0;
  rep(i,N-1){
    flagA[-sortA[i].second] = 1;
    if(flagB[-sortA[i].second]==1) samenum1++;
    flagB[-sortB[N-i-1].second] = 1;
    if(flagA[-sortB[N-i-1].second]==1) samenum2++;
    if((samenum1+samenum2)==(i+1)) flag[i+1]=1;
  }

  vector<ll> accA(N+1,0);
  vector<ll> accB(N+1,0);
  rep(i,N){
    accA[i+1]=accA[i]+sortA[i].first;
    accB[i+1]=accB[i]+sortB[i].first;
  }

  ll ans=min(accA[N],accB[N]);
  FOR(i,1,N){

    if(((accA[i]+accB[N-i])<ans) && (flag[i] == 0)) {

      ans=accA[i]+accB[N-i];

    }
  }
  cout << ans;

  return 0;
}