package main

/*
最小コストソート
*/

import (
	"bufio"
	"bytes"
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
)

func partition(a []int) int {
	x := a[len(a)-1]
	i := -1
	for j := 0; j < len(a)-1; j++ {
		if a[j] <= x {
			i++
			a[i], a[j] = a[j], a[i]
		}
	}
	a[i+1], a[len(a)-1] = a[len(a)-1], a[i+1]
	return i + 1
}
func quickSort(a []int) {
	if len(a) > 1 {
		q := partition(a)
		quickSort(a[:q])
		quickSort(a[q+1:])
	}
}

func countCycleCost(a []int) int {
	// n個の要素
	// 最小値を使ってn-1回要素を入れ替える．
	// min(a) 以外の要素は1回だけのコスト:sum(a) - min(a)
	// min(a) は n-1回移動する:min(a) * (n-1)
	// sum(a) + min(a) * n-2
	return sum(a) + min(a)*(len(a)-2)
}
func countCycleCostWithX(a []int, x int) int {
	// n個の要素
	// 外部のxを使って要素を入れ替える．
	// xとmin(a)を入れ替えて元に戻すコスト:(min(a) + x) * 2
	// min(a)以外の要素は1回だけのコスト:sum(a) - min(a)
	// x は n-1回移動する:x * (n - 1)
	// (min(a) + x) * 2 + sum(a) - min(a) + x * (n - 1)
	// sum(a) + 2*min(a) -min(a) + 2*x + x*(n-1)
	// sum(a) + min(a) + x*(n+1)
	return sum(a) + min(a) + x*(len(a)+1)
}

func collectGroup(a []int) [][]int {
	var result [][]int

	b := make([]int, len(a))
	copy(b, a)
	quickSort(b) // bはソート済み配列

	c := make([]bool, len(a)) // cはサイクルグループに分別したかどうかを表す．

	for i := 0; i < len(a); i++ {
		if c[i] {
			// すでに分別済み
			continue
		}
		cur := i
		var r []int
		for {
			c[cur] = true
			v := a[cur]
			r = append(r, v)
			// 本来あるべき offsetをソート済み配列から取得する
			offset := find(v, b)
			if c[offset] {
				// 1つのサイクルグループ完了したので全体結果に追加
				result = append(result, r)
				break
			}
			cur = offset
		}
	}
	return result
}
func solve(a []int) int {
	x := min(a)
	group := collectGroup(a)
	cost := 0
	for _, g := range group {
		if len(g) > 1 {
			c1 := countCycleCost(g)
			c2 := countCycleCostWithX(g, x)
			cost += min([]int{c1, c2})
		}
	}
	return cost
}

func main() {
	scanner := makeScanner(6 * 1000)
	eGetInt(scanner)
	integers := eGetInts(scanner)
	fmt.Println(solve(integers))
}

////////////////////////////////////////////////////////////////////////////////
// ライブラリ
////////////////////////////////////////////////////////////////////////////////
func makeScanner(maxByte int) *bufio.Scanner {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]uint8, 0, 8192), maxByte)
	return scanner
}
func eGetLine(r *bufio.Scanner) string {
	if r.Scan() {
		return r.Text()
	}
	err := r.Err()
	if err != nil {
		log.Fatal(err)
	}
	// EOF
	return ""
}
func eGetInt(r *bufio.Scanner) int {
	line := eGetLine(r)
	return eAtoi(line)
}
func eGetFields(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Fields(line)
}
func eGetInts(r *bufio.Scanner) []int {
	fields := eGetFields(r)
	ints := make([]int, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoi(fields[i])
	}
	return ints
}
func eGetChars(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Split(line, "")
}
func eAtoi(s string) int {
	n, err := strconv.Atoi(s)
	if err != nil {
		log.Fatal(err)
	}
	return n
}

type ints []int

func (s ints) String() string {
	var buf bytes.Buffer
	sep := ""
	for _, v := range s {
		buf.WriteString(fmt.Sprintf("%s%d", sep, v))
		sep = " "
	}
	return buf.String()
}

func reverse(a ints) ints {
	r := make(ints, len(a))
	for i := 0; i < len(a); i++ {
		r[i] = a[len(a)-1-i]
	}
	return r
}
func max(a ints) (int, bool) {
	if len(a) == 0 {
		return 0, false
	}
	m := a[0]
	for _, e := range a {
		if e > m {
			m = e
		}
	}
	return m, true
}
func min(a []int) int {
	m := a[0]
	for _, v := range a {
		if v < m {
			m = v
		}
	}
	return m
}

func sum(a ints) int {
	if len(a) == 0 {
		return 0
	}
	sum := 0
	for _, e := range a {
		sum += e
	}
	return sum
}
func find(n int, a ints) int {
	for i, v := range a {
		if n == v {
			return i
		}
	}
	return -1
}



Measured memory_bytes: 1316