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] = {
            if (value != Nil){
                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 }))
                }
            } else {
                map
            }
        }

        val evenMap = makeMap(even.toSet, even)
        val oddMap = makeMap(odd.toSet, 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 }.toSet, even.filter { num: Int => num != oddMaxKey })
                            evenMaxVal = {
                                if (t == Map.empty) {
                                   0
                                } else {
                                   t.maxBy(item => item._2)._2
                                }
                            }
                        } else {
                            var t = makeMap(odd.filter { num: Int => num != evenMaxKey }.toSet, 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)
	}
}
