Problem:
Score : 300 points

Problem Statement

A sequence a_1,a_2,... ,a_n is said to be /\/\/\/ when the following conditions are satisfied:

For each i = 1,2,..., n-2, a_i = a_{i+2}.

Exactly two different numbers appear in the sequence.

You are given a sequence v_1,v_2,...,v_n whose length is even.
We would like to make this sequence /\/\/\/ by replacing some of its elements.
Find the minimum number of elements that needs to be replaced.

Constraints

2 \leq n \leq 10^5

n is even.

1 \leq v_i \leq 10^5

v_i is an integer.

Input

Input is given from Standard Input in the following format:

n
v_1 v_2 ... v_n

Output

Print the minimum number of elements that needs to be replaced.

Sample Input 1

4
3 1 3 2

Sample Output 1

1

The sequence 3,1,3,2 is not /\/\/\/, but we can make it /\/\/\/ by replacing one of its elements: for example, replace the fourth element to make it 3,1,3,1.

Sample Input 2

6
105 119 105 119 105 119

Sample Output 2

0

The sequence 105,119,105,119,105,119 is /\/\/\/.

Sample Input 3

4
1 1 1 1

Sample Output 3

2

The elements of the sequence 1,1,1,1 are all the same, so it is not /\/\/\/.

Solution in Kotlin (1.0.0) (judge verdict: Accepted)

import java.io.PrintWriter

fun next() = readLine()!!
fun nextInt() = next().toInt()
fun nextLong() = next().toLong()
fun nextDouble() = next().toDouble()
fun nextList() = next().split(" ")
fun nextIntList() = nextList().map(String::toInt)
fun nextLongList() = nextList().map(String::toLong)
fun nextDoubleList() = nextList().map(String::toDouble)

val pw = PrintWriter(System.out)
fun print(s: Any = "") = pw.print(s)
fun println(s: Any = "") = pw.println(s)

fun main(args: Array<String>) {
    main()
    pw.flush()
}

fun main() {
    val N = nextInt()
    val V = nextIntList()
    val A = IntArray(N / 2 + 1)
    val B = IntArray(N / 2 + 1)
    for (i in 0 until N / 2) {
        A[i] = V[i * 2]
        B[i] = V[i * 2 + 1]
    }
    A[N / 2] = 0
    B[N / 2] = 0
    val C = A.toCountMap().toList().sortedByDescending { it.second }
    val D = B.toCountMap().toList().sortedByDescending { it.second }
    val (i, j) = when {
        C[0].first != D[0].first -> Pair(0, 0)
        C[0].second + D[1].second > C[1].second + D[0].second -> Pair(0, 1)
        else -> Pair(1, 0)
    }
    println(C.map { it.second }.sum() + D.map { it.second }.sum() - C[i].second - D[j].second)
}

fun IntArray.toCountMap(): Map<Int, Long> {
    return this.groupBy { it }.mapValues { if (it.key != 0) it.value.size.toLong() else 0 }
}