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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

public class Program{
    public static void Main(){
        
        var n = int.Parse(Console.ReadLine());
        string[] line = Console.ReadLine().Trim().Split();
        
        var progression = new Progression();
        
        progression.setProgression(line);
        
        progression.setMax();
        
        Console.WriteLine("{0}", progression.cntUp());
    }
}
public class Progression{
    List<int> evenPro;
    List<int> oddPro;
    int evenMaxNum;
    int oddMaxNum;
    int cnt;
    
    public void setProgression(string[] pro){
        cnt = 0;
        evenPro = new List<int>();
        oddPro = new List<int>();
        for(var i = 0; i < pro.Length; i++){
            var tmp = int.Parse(pro[i]);
            if(i % 2 == 0){
                evenPro.Add(tmp);
            }else{
                oddPro.Add(tmp);
            }
        }
    }
    
    public void setMax(){
        var evenHashList = new Dictionary<int,int>();//配列内の数字, 出現回数
        for(var i = 0; i < evenPro.Count; i++){
            if(evenHashList.ContainsKey(evenPro[i])){//配列内の数字が存在するかどうか
                evenHashList[evenPro[i]]++;
            }else{
                evenHashList.Add(evenPro[i],1);//配列内の数字を追加
            }
        }
        //出現回数をもとに後順に並び替えて先頭の配列内の数字値を取得
        var evenPair = evenHashList.OrderByDescending(x => x.Value).First();
        evenMaxNum = evenPair.Key;
        
        var oddHashList = new Dictionary<int,int>();//配列内の数字, 出現回数
        
        for(var i = 0; i < oddPro.Count; i++){
            if(oddHashList.ContainsKey(oddPro[i])){//配列内の数字が存在するかどうか
                oddHashList[oddPro[i]]++;
            }else{
                oddHashList.Add(oddPro[i],1);//配列内の数字を追加
            }
        }
        //出現回数をもとに後順に並び替えて先頭の配列内の数字値を取得
        var oddPair = oddHashList.OrderByDescending(x => x.Value).First();
        oddMaxNum = oddPair.Key;
        if(evenMaxNum == oddMaxNum){//奇数と偶数での揃える数字が同じ
            if(evenHashList.Count > 1 && oddHashList.Count > 1){//それぞれ要素が2つ以上ある場合
                evenHashList.Remove(evenMaxNum);
                oddHashList.Remove(oddMaxNum);
                evenPair = evenHashList.First();
                oddPair = oddHashList.First();
                
                if(evenPair.Value > oddPair.Value){//降順での2番目の数字の出現回数を比べる
                    evenMaxNum = evenPair.Value;
                }else{
                    oddMaxNum = oddPair.Value;
                }
                
            }else if(evenHashList.Count > 2 && oddHashList.Count > 1){
                evenHashList.Remove(evenMaxNum);
                evenPair = evenHashList.First();
                evenMaxNum = evenPair.Value;
            }else if(evenHashList.Count > 1 && oddHashList.Count > 2){
                oddHashList.Remove(oddMaxNum);
                oddPair = oddHashList.First();
                oddMaxNum = oddPair.Value;
            }else{
                oddMaxNum--;
            }
        }
    }
    
    public int cntUp(){
        
        for(var i = 0; i < evenPro.Count; i++){
            if(evenMaxNum != evenPro[i]){
                cnt++;
            }
            if(oddMaxNum != oddPro[i]){
                cnt++;
            }
        }
        return cnt;
    }
}