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.Collections.Generic;
using System.Linq;
using System.Text;

namespace ALDS1_6_D
{
    public class Program

    {
        public static void Main(string[] args)
        {
            int n = ReadInt();
            int[] line = ReadIntAr();
            Console.WriteLine(SillySort(line).ToString());
        }

        public struct node { public int value; public int place; }
        public static int SillySort(int[] seq)
        {

            int cost = 0, s;
            node[] nodes = new node[seq.Count()];
            node[] tmp = new node[seq.Count()];

            for (int i = 0 ; i < seq.Count() ; i++) { tmp[i].value = seq[i]; tmp[i].place = i; }
            tmp = tmp.OrderBy(x => x.value).ToArray<node>();
            for (int i = 0 ; i < seq.Count() ; i++) { nodes[i].value = seq[i]; nodes[tmp[i].place].place = i; }
            s = tmp[0].value;

            for (int i = 0 ; i < seq.Count() ; i++)
            {
                int j = nodes[i].place;
                if (j >= 0 && j != i)
                {
                    int n = 1, sum, amin;
                    amin = sum = nodes[i].value;
                    while (j != i)
                    {
                        int next = nodes[j].place;
                        amin = Math.Min(amin, nodes[j].value);
                        sum += nodes[j].value;
                        n++;
                        nodes[j].place = -1;
                        j = next;
                    }
                    cost += Math.Min(sum + ((n - 2) * amin), sum + amin + (n + 1) * s);
                }
            }

            return cost;
        }


        static string ReadSt() { return Console.ReadLine(); }
        static int ReadInt() { return int.Parse(Console.ReadLine()); }
        static long ReadLong() { return long.Parse(Console.ReadLine()); }
        static double ReadDouble() { return double.Parse(Console.ReadLine()); }
        static string[] ReadStAr(char sep = ' ') { return Console.ReadLine().Split(sep); }
        static int[] ReadIntAr(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Split(sep), e => int.Parse(e)); }
        static long[] ReadLongAr(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Split(sep), e => long.Parse(e)); }
        static double[] ReadDoubleAr(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Split(sep), e => double.Parse(e)); }

    }

}