Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Minimum Cost Sort

You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.

Write a program which reports the minimal total cost to sort the given integers.

Input

In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.

Output

Print the minimal cost in a line.

Constraints

$1 \leq n \leq 1,000$

$0 \leq w_i\leq 10^4$

$w_i$ are all different

Sample Input 1

5
1 5 3 4 2

Sample Output 1

7

Sample Input 2

4
4 3 2 1

Sample Output 2

10

Solution in C# (judge verdict: Wrong Answer)

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

namespace _20180307_AOJ
{
    class ALDS1_6D
    {
        static void Main(string[] args)
        {
            for (;;)
            {
                string line = Console.ReadLine();
                if (string.IsNullOrEmpty(line))
                {
                    break;
                }

                int n = int.Parse(line);
                int[] arr = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
                int[] sorted = arr.OrderBy(x => x).ToArray();
                // <sorted, original>
                Dictionary<int, int> diff = new Dictionary<int, int>();
                for(int i=0;i<n;i++)
                {
                    if(sorted[i] != arr[i])
                    {
                        diff.Add(sorted[i], arr[i]);
                    }
                }

                int cost = 0;

                List<int> mutual = new List<int>();
                foreach (var kvp in diff)
                {
                    if (diff[kvp.Value] == kvp.Key)
                    {
                        mutual.Add(kvp.Value);
                    }
                }

                cost = mutual.Sum();
                foreach (var v in mutual)
                {
                    diff.Remove(v);
                }

                while (diff.Count>1)
                {
                    var ordered = diff.OrderBy(x => x.Value);
                    var min = ordered.First();
                    var second = diff.First(x=>x.Value == min.Key);

                    cost += min.Value + second.Value;
                    if (diff[second.Key] == min.Value)
                    {
                        diff.Remove(second.Key);
                    }
                    else
                    {
                        diff[second.Key] = min.Value;
                    }
                    diff.Remove(second.Value);
                }

                Console.WriteLine(cost);
            }
        }
    }
}