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++14 (GCC 5.4.1) (judge verdict: Runtime Error)



#include<iostream>
#include<vector>
#include<algorithm>
#include<set>



template<class Container>
auto me(const Container& c) {
	return std::max_element(std::begin(c), std::end(c));
}


int tab1[10001]{};
int tab2[10001]{};


auto exec() {
	
	int n{};
	std::cin >> n;
	std::vector< int > a2{}, a2_1{};


	for (int i{ 0 }; i < n / 2; i++) {
		int x{ 0 };
		std::cin >> x;
		++tab1[x - 1];
//		std::cout << tab1[x - 1] << "\n";

		std::cin >> x;
		++tab2[x - 1];

//		std::cout << tab2[x - 1] <<"\n";
	}


	auto m1 = me(tab1);//max_element
	auto m2 = me(tab2);//

	auto m1i = m1 - tab1;
	auto m2i = m2 - tab2;

	int result{ n - 2 };


	if (m1i == m2i) {

		int tmp{ 0 };
		std::swap( tab1[m1i], tmp );
		tab2[m2i] = 0;
		auto x = std::max( *me(tab1), *me(tab2) );
		//std::cout << tmp << "\n";
		result = x + tmp;
	}
	else {
//		std::cout << n << tab1[m1i] << tab2[m2i] << "\n";
		result = n - (tab1[m1i] + tab2[m2i]);
	}

	std::cout << result << "\n";
}

auto exec2() {
	int N{};

	int tab1[10001]{}, tab2[10001]{};
	std::cin >> N;

	for (int i{}; i < N/2; i++) {
		int tmp{};
		std::cin >> tmp; tab1[tmp]++;
		std::cin >> tmp; tab2[tmp]++;
	}

	auto it1 = std::max_element(tab1, tab1 + 10001);
	auto d1 = std::distance(tab1, it1);
	
	auto it2 = std::max_element(tab2, tab2 + 10001);
	auto d2 = std::distance(tab2, it2);

	auto valid = 0;
	if (d1 == d2) {
		valid = std::max(*it1, *it2);
		*it1 = *it2 = 0;
		auto it12 = std::max_element(tab1, tab1 + 10001);
		auto it22 = std::max_element(tab2, tab2 + 10001);
		valid += std::max(*it12, *it22);
	}
	else {
		valid = *it1 + *it2;
	}
	std::cout << N- valid << "\n";

}

int main() {

//	while (true) {
//		std::fill(tab1, tab1+sizeof(tab1) , 0);
//		std::fill(tab2, tab2+sizeof tab2 , 0);
		//exec();
//	}
	exec2();
		return 0;
}