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: Wrong Answer)

#include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>

using namespace std;

#define loop(i, times) for(int i = 0; i < times; i++)
#define seloop(i, start_index, end_index) for(int i = start_index; i < end_index; i++)
#define eqseloop(i, start_index, end_index) for(int i = start_index; i <= end_index; i++)

#include <iostream>
#include <map>
#include <vector>

using namespace std;

class NyaGadgetVector
{
public:
	/**
	@brief 加算関数
	@note
	 collectionの全要素にadd_valueだけ値を加算する
	**/
	template<typename T> static void Add(vector<T>& collection, T add_value)
	{
		for (auto& e : collection)
			e += add_value;
	}
	/**
	@brief 全要素変更関数
	@note
	 collectionの全要素をchange_valueに変更する
	**/
	template<typename T> static void ChangeAll(vector<T>& collection, T change_value)
	{
		for (auto& e : collection)
			e = change_value;
	}
	/**
	@brief 同じ要素の個数を数える関数
	@note
	 コンテナinput_collectionの同じ要素の個数を数えてoutput_collectionに結果を格納する。
	 output_collectionの第一引数には要素の値、第二引数には要素の個数が格納される。
	-------------------------------------------------------------------------------------
	[sample code]
	int main() {
		vector<long> input_collection = {10000000000, 10000000000, 2, 1, 2, 2, 2};
		map<long, int> count_collection;
		NyaGadgetVector::CountValue<long>(input_collection, count_collection);

		for (const auto& e : count_collection)
			cout << "(" << e.first << "," << e.second << ")";
		return 0;
	}
	[output]
	(1,1)(2,4)(10000000000,2)
	**/
	template<typename T> static void CountValue(const vector<T>& input_collection, vector<pair<T, int>>& output_collection)
	{
		map<T, int> count_collection;
		for (const auto& e : input_collection)
			count_collection[e] += 1;

		for (const auto e : count_collection)
			output_collection.push_back(make_pair(e.first, e.second));
	}
	/**
	@brief 標準入力関数
	@note
	 標準入力から入力されたsize個の値をcollectionに格納する
	**/
	template<typename T> static void InputStream(vector<T>& collection, int size)
	{
		for (int i = 0; i < size; i++)
			cin >> collection[i];
	}
	/**
	@brief pairの引数を反転させる関数
	@note
	 input_collectionのpair.firstとpair.secondを入れ替えて新たなコンテナを作成する。
	**/
	template<typename T, typename U> static void TurnPair(const vector<pair<T, U>>& input_collection, vector<pair<U, T>>& output_collection)
	{
		for (const auto& e : input_collection)
			output_collection.push_back(make_pair(e.second, e.first));
	}
	/**
	@brief 最大値取得関数
	@note
	 collectionの要素の中で最大値を取得する
	**/
	template<typename T> static T Max(const vector<T>& collection)
	{
		T max = collection[0];
		for (const auto& e : collection)
		{
			if (max < e)
				max = e;
		}
		return max;
	}
	/**
	@brief 最小値取得関数
	@note
	 collectionの要素の中で最大値を取得する
	**/
	template<typename T> static T Min(const vector<T>& collection)
	{
		T min = collection[0];
		for (const auto& e : collection)
		{
			if (e < min)
				min = e;
		}
		return min;
	}
	/**
	@brief 合計関数
	@note
	 collectionの要素を合計して返す(範囲はstart_index以上end_index未満)
	**/
	template<typename T> static T Sum(const vector<T>& collection, int start_index, int end_index)
	{
		int sum = 0;
		for (int i = start_index; i < end_index; i++)
			sum += collection[i];
		return sum;
	}
};

long Sum(vector<pair<int, int>>& collection, int min_index, int max_index)
{
	long sum = 0;
	for (int i = min_index; i < max_index; i++)
		sum += get<0>(collection[i]);
	return sum;
}

int main()
{
	int n; cin >> n;
	vector<int> odd_collection(n / 2, 0), even_collection(n / 2, 0);

	loop(i, n / 2)
	{	// 偶数番目と奇数番目の入力を保存
		cin >> odd_collection[i];
		cin >> even_collection[i];
	}

	// 偶数数列の同じ要素をカウントする
	vector<pair<int, int>> count_result;
	NyaGadgetVector::CountValue<int>(odd_collection, count_result);
	vector<pair<int, int>> count_odd_collection;	// p.first=size, p.second=value
	NyaGadgetVector::TurnPair(count_result, count_odd_collection);

	// 奇数数列の同じ要素をカウントする
	count_result.clear();
	NyaGadgetVector::CountValue<int>(even_collection, count_result);
	vector<pair<int, int>> count_even_collection;	// p.first=size, p.second=value
	NyaGadgetVector::TurnPair(count_result, count_even_collection);

	long min = 0;
	// 例外処理その１「偶数数列と奇数数列が全て同じ数字のとき」
	// 数列を個別に見れば置き換え回数はゼロだが、実際は片方の数列を全て置き換える必要がある
	if (get<0>(count_odd_collection[0]) == get<1>(count_even_collection[0]) &&
		get<1>(count_odd_collection[0]) == get<1>(count_even_collection[0]))
	{
		min = n / 2;
		return 0;
	}

	if (get<1>(count_odd_collection[0]) == get<1>(count_even_collection[0]))
	{	// 例外処理その２「偶数数列と奇数数列で出現頻度が最も高い数字が同じ時」
		if (get<0>(count_odd_collection[1]) < get<0>(count_even_collection[1]))
		{
			min += Sum(count_odd_collection, 1, (int)count_odd_collection.size());
			min += get<0>(count_even_collection[0]);
			min += Sum(count_even_collection, 2, (int)count_even_collection.size());
		}
		else
		{
			min += get<0>(count_odd_collection[0]);
			min += Sum(count_odd_collection, 2, (int)count_odd_collection.size());
			min += Sum(count_even_collection, 1, (int)count_even_collection.size());

		}
	}

	// 通常処理　出現頻度が最も高い数字に置き換えれば答えになる
	min += Sum(count_odd_collection, 1, (int)count_odd_collection.size());
	min += Sum(count_even_collection, 1, (int)count_even_collection.size());
	cout << min;

	return 0;
}