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: Accepted)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main  implements Runnable {
	int [] ans_ar; 
	public static void main(String[] args) {
		new Thread(null, new Main(), "", 32 * 1024 * 1024).start(); //
	}
	public void run() {
		FastScanner sc = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = Integer.parseInt(sc.next());
		int[] a = new int[n/2+1];
		int[] b = new int[n/2+1];
		for (int i = 0; i < n/2; i++) {
			a[i] = Integer.parseInt(sc.next());
			b[i] = Integer.parseInt(sc.next());
		}
		a[n/2] = 1000000000;
		b[n/2] = 1000000000;
		Arrays.parallelSort(a);
		Arrays.parallelSort(b);
		int maxa = 0;
		int maxa2 = 0;
		int maxa_tmp = 1;
		int maxb2 = 0;
		int maxb = 0;
		int maxb_tmp = 1;
		int maxva = 0;
		int maxvb = 0;
		for (int i = 1; i <= n/2; i++) {
			if(a[i]==a[i-1])
			{
				maxa_tmp++;
			}
			else {
				if(maxa < maxa_tmp)
				{
					maxa2 = maxa;
					maxa = maxa_tmp;
					maxva = a[i-1];
				}
				else if(maxa2 < maxa_tmp)
				{
					maxa2 = maxa_tmp;
				}
				maxa_tmp = 1;
			}
			if(b[i]==b[i-1])
			{
				maxb_tmp++;
			}
			else {
				if(maxb < maxb_tmp)
				{
					maxb2 = maxb;
					maxb = maxb_tmp;
					maxvb = b[i-1];
				}
				else if(maxb2 < maxb_tmp)
				{
					maxb2 = maxb_tmp;
				}
				maxb_tmp = 1;
			}
		}
		if(maxva == maxvb)
		{
			out.println(Math.min(n-maxa-maxb2,n-maxa2-maxb));
		}
		else {
			out.println(n-maxa-maxb);
		}
		out.flush();
	}

	static class FastScanner {
        private BufferedReader reader = null;
        private StringTokenizer tokenizer = null;
        public FastScanner(String in) {
        	StringReader sr = new StringReader(in);
            reader = new BufferedReader(new BufferedReader(sr));
            tokenizer = null;
        }
        public FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }
        public String next() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
    }
}