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.*;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = Integer.parseInt(in.nextLine());
		String[] tokens = in.nextLine().split(" ");
		in.close();
		List<Integer> v = new ArrayList<>(n);
		for (int i = 0; i < n; ++i) {
			v.add(Integer.parseInt(tokens[i]));
		}
		Map<Integer, Integer> oddCount = count(v, false);
		Map<Integer, Integer> evenCount = count(v, true);
		int oddSelect = getMaxCountKey(oddCount);
		int evenSelect = getMaxCountKey(evenCount);
		if (oddSelect != evenSelect) {
			int result = getChangeCount(oddCount, oddSelect) + getChangeCount(evenCount, evenSelect);
			System.out.println(result);
		} else {
			int oddNum = oddCount.get(oddSelect);
			int evenNum = evenCount.get(evenSelect);
			if (oddNum > evenNum) {
				// odd側に合わせる -> even側を変更する
				evenSelect = getSecondCountKey(evenCount, evenSelect);
				evenNum = getChangeCount(evenCount, evenSelect);
				oddNum = getChangeCount(oddCount, oddSelect);
			} else {
				// even側に合わせる -> odd側を変更する
				oddSelect = getSecondCountKey(oddCount, oddSelect);
				oddNum = getChangeCount(oddCount, oddSelect);
				evenNum = getChangeCount(evenCount, evenSelect);
			}
			System.out.println((oddNum + evenNum));
		}
	}

	private static int getChangeCount(Map<Integer, Integer> count, int select) {
		int result = 0;
		for (Integer key : count.keySet()) {
			if (key != select) {
				result += count.get(key);
			}
		}
		return result;
	}

	private static int getSecondCountKey(Map<Integer, Integer> count, int maxKey) {
		int result = -1;
		int index = -1;
		for (Integer key : count.keySet()) {
			if (key != maxKey) {
				if (result < count.get(key)) {
					result = count.get(key);
					index = key;
				}
			}
		}
		return index;
	}

	private static int getMaxCountKey(Map<Integer, Integer> count) {
		int result = -1;
		int index = -1;
		for (Integer key : count.keySet()) {
			if (result < count.get(key)) {
				result = count.get(key);
				index = key;
			}
		}
		return index;
	}

	private static Map<Integer, Integer> count(List<Integer> v, boolean isEven) {
		Map<Integer, Integer> result = new HashMap<>();
		if (!isEven) {
			// oddパターンをカウント
			for (int i = 0; i < v.size(); i = i + 2) {
				int num = v.get(i);
				if (!result.containsKey(num)) {
					result.put(num, 1);
				} else {
					int count = result.get(num);
					result.put(num, count + 1);
				}
			}
		} else {
			// evenパターンをカウント
			for (int i = 1; i < v.size(); i = i + 2) {
				int num = v.get(i);
				if (!result.containsKey(num)) {
					result.put(num, 1);
				} else {
					result.put(num, result.get(num) + 1);
				}
			}
		}
		return result;
	}
}