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 Scala (2.11.7) (judge verdict: Time Limit Exceeded)

import scala.io.StdIn

object Main {
    def main(args: Array[String]) = {
        StdIn.readLine()
        val a = StdIn.readLine().split(" ").toList.map { str: String => str.toInt }

        def getAlternateIndex(intList: List[Int], result: List[Int] = Nil): List[Int] = intList match {
                case Nil => result.reverse
                case int :: tail => getAlternateIndex(tail.drop(1), int :: result)
        }

        val even = getAlternateIndex(a)
        val odd  = getAlternateIndex(a.drop(1))

//        def makeMap(key: Set[Int], value: List[Int], map: Map[Int, Int] = Map.empty[Int, Int]): Map[Int, Int] = {
//            key.toList match {
//                case Nil => map
//                case k :: tail => makeMap(tail.toSet, value.filter { v: Int => k != v }, map + (k -> value.count { v: Int => k == v }))
//            }
//        }
        
        def makeMap(value: List[Int], map: Map[Int, Int] = Map.empty[Int, Int]): Map[Int, Int] = value.toSet.toList match {
            case Nil => map
            case key ::tail => makeMap(value.filter { v: Int => key != v }, map + (key -> value.count { v: Int => key == v }))
        }

        val evenMap = makeMap(even)
        val oddMap = makeMap(odd)

        val evenMax = evenMap.maxBy(item => item._2)
        val oddMax  = oddMap.maxBy(item => item._2)

        var evenMaxVal = evenMax._2
        var oddMaxVal  = oddMax._2

        val evenMaxKey = evenMax._1
        val oddMaxKey  = oddMax._1

        var count = even.toSet.size + odd.toSet.size match {
            case x: Int if x < 2 => 0
            case _ =>
                if (evenMaxKey == oddMaxKey) {
                    {
                        if (evenMaxVal < oddMaxVal) {
                            var t = makeMap(even.filter { num: Int => num != oddMaxKey })
                            evenMaxVal = {
                                if (t == Map.empty) {
                                   0
                                } else {
                                   t.maxBy(item => item._2)._2
                                }
                            }
                        } else {
                            var t = makeMap(even.filter { num: Int => num != evenMaxKey })
                            evenMaxVal = {
                                if (t == Map.empty) {
                                    0
                                } else {
                                    t.maxBy(item => item._2)._2
                                }
                            }
                        }
                    }
                }
                even.size - evenMaxVal + odd.size - oddMaxVal
        }
        println(count)
    }
}