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 OCaml (4.10.0) (judge verdict: Accepted)

let split_string ?(pattern="") = Str.split @@ Str.regexp pattern
let n = Scanf.sscanf (read_line ()) "%d" @@ fun n -> n
let v = read_line () |> split_string ~pattern:" " |> List.map int_of_string

let rec take res n acc = match (n, acc) with
  | (_, []) | (0, _) -> List.rev res
  | (i, x :: xs) -> take (x :: res) (n - 1) xs
let take = take []

let rec split a b t = function
  | [] -> (a, b)
  | x :: xs -> if t then split (x :: a) b false xs else split a (x :: b) true xs

module IntMap = Map.Make(struct type t = int let compare = compare end)
let top acc =
  let map = List.fold_left (fun map n ->
    let i = 1 + try IntMap.find n map with Not_found -> 0 in
    IntMap.add n i map
  ) IntMap.empty acc in
  IntMap.bindings map |> List.sort (fun (_, a) (_, b) -> b - a) |> take 2 |> List.map fst

let solve a ta b tb =
  let cnt acc v = List.filter ((<>) v) acc |> List.length in
  List.map (fun x -> List.map (fun y -> (x, y)) tb) ta
    |> List.concat
    |> List.map (fun (x, y) -> if x = y then max_int else cnt a x + cnt b y)
    |> List.fold_left min max_int

let () =
  let a, b = split [] [] true v in
  let ta, tb = top a, top b in
  Printf.printf "%d\n" @@
  if List.length ta = 1 && List.length tb = 1 && List.hd ta = List.hd tb 
  then n / 2 else solve a ta b tb