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# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WakachigakiAndIndexingByFasttext
{
    public class Program
    {
        static void Main(string[] args)
{
            List<int[]> input = GetNLineInput();
            int n = input.Count;
            int[] a = new int[n];
            int[] b = new int[n];
            int[] sortedA = new int[n];
            int[] sortedB = new int[n];
            int[] all = new int[2*n];
            int sum = 0;
            for(int i=0;i<input.Count;i++)
            {
                a[i] = input[i][0];
                b[i] = input[i][1];
                sortedA[i] = input[i][0];
                sortedB[i] = input[i][1];
                all[2*i] = input[i][0];
                all[2*i+1] = input[i][1];
                sum += input[i][0] + input[i][1];
            }
            Array.Sort(all);

            bool perfect = false;
            if(n==1)
            {
                perfect = true;
            }
            else if(all[n-1]==all[n])
            {
                perfect = true;
            }
            else
            {
                Array.Sort(sortedA);
                Array.Sort(sortedB);
                if(sortedA[n-1]==all[n-1])
                {
                    perfect = true;
                }
                else if (sortedB[n - 1] == all[n - 1]) { perfect = true; }
            }

            if(perfect)
            {
                Console.Write(sum);
            }
            else
            {
                Console.Write(sum - all[n - 1] + all[n]);
            }
        }
        
        static List<int[]> GetNLineInput()
        {
            List<int[]> result = new List<int[]>();
            int lineNum =int.Parse( Console.ReadLine());
            for(int i=0;i<lineNum;i++)
            {
                string[] items = Console.ReadLine().Split(' ');
                int[] nums = new int[items.Length];
                for(int j=0;j<nums.Length;j++)
                {
                    nums[j] = int.Parse(items[i]);
                }
                result.Add(nums);
            }
            return result;
        }
    }
}