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

using System;
using System.Linq;
using System.Collections.Generic;
using static System.Console;
using System.Text;
using System.IO;

namespace AOJ
{
    class Program
    {
        static public long[] Sarray() { return ReadLine().Split().Select(long.Parse).ToArray(); }
        static public List<long> Slist() { return ReadLine().Split().Select(long.Parse).ToList(); }

        struct pair
        {
            public long k;
            public long v;
            public pair(long K, long V) { k = K; v = V; }
        }
        static void Main(string[] args)
        {
            var N = Sarray()[0];
            var Ai = Sarray();
            var As = new List<pair>();
            for (var i = 0; i < N; ++i)
            {
                var p = new pair(i, Ai[i]);
                As.Add(p);
            }
            As.Sort((l, r) => (int)(l.v - r.v));

            var v = new bool[N];
            var cst = 0L;
            for (var i = 0L; i < N; ++i)
            {
                if (v[i]) continue;
                var j = i;
                var sum = 0L;
                var cnt = 0L;
                do
                {
                    ++cnt;
                    sum += As[(int)j].v;
                    v[j] = true;
                    j = As[(int)j].k;
                }
                while (i != j);
                if (1 < cnt)
                    cst += sum + Math.Min((cnt - 2) * As[(int)i].v, As[(int)i].v + (cnt + 1) * As[0].v);
            }
            WriteLine(cst);
        }
    }
}