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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Main main = new Main();
		main.run();
	}

	public void run() {
		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		int v[] = new int[n];
		for(int i=0; i<n; i++) {
			v[i]=sc.nextInt();
		}

		Map<Integer, Integer> e = new HashMap<Integer,Integer>();
		Map<Integer, Integer> o = new HashMap<Integer,Integer>();

		for(int i=0; i<n; i++) {
			if(i%2==0) {
				int c = e.containsKey(v[i]) ? e.get(v[i]) : 0;
				e.put(v[i], c+1);
			}else {
				int c = o.containsKey(v[i]) ? o.get(v[i]) : 0;
				o.put(v[i], c+1);
			}
		}

		e.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));
		o.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));

		int ek1=-1;
		int ev1=-1;
		int ev2=0;

		int ok1=-1;
		int ov1=-1;
		int ov2=0;

		for(Entry<Integer,Integer> s : e.entrySet()) {
			if(ek1==-1) {
				ek1=s.getKey();
				ev1=s.getValue();
			}else {
				ev2=s.getValue();
				break;
			}
		}

		for(Entry<Integer,Integer> s : o.entrySet()) {
			if(ok1==-1) {
				ok1=s.getKey();
				ov1=s.getValue();
			}else {
				ov2=s.getValue();
				break;
			}
		}

		int ans = Integer.MAX_VALUE;
		if(ek1!=ok1) {
			ans = (n/2)-ev1 + (n/2)-ov1;
		} else {
			ans = (n/2)-ev1 + (n/2)-ov2;
			ans = Math.min(ans, (n/2)-ev2 + (n/2)-ov1);
		}
		System.out.println(ans);

		sc.close();
	}
}