#include <iostream>
#include <stdio.h>
#include <math.h> 
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <string>
#include <numeric>
#include <bitset>
#include <queue>
#include <map>

using namespace std;


int main() {

	//input
	int n;
	cin >> n;

	vector<int> vec; //全体の値
	vector<int> kisu; //奇数の値(重複削除用)
	vector<int> gusu; //偶数の値(重複削除用)
	vector<int> kisu2; //奇数の値
	vector<int> gusu2; //奇数の値

	for (int i = 0; i < n; ++i) {
		int tmp = 0;
		cin >> tmp;
		vec.push_back(tmp);
		if (i % 2 == 0) {
			gusu.push_back(tmp);
			gusu2.push_back(tmp);
		}
		else if (i % 2 == 1) {
			kisu.push_back(tmp);
			kisu2.push_back(tmp);
		}
	}

	//全部同じ値ならn/2(1,1,1,1 →　2回)
	int tmp = 0;
	for (int i = 0; i < vec.size() - 1; ++i) {
		if (vec[i] == vec[i + 1]) {
			tmp++;
		}
		if (tmp == n - 1) {
			cout << n / 2 << endl;
			return 0;
		}
	}


	//奇数と偶数のvectorから出現頻度の大きい値を取得する
	map<int, int> gusumap; //偶数の各値の出現頻度管理用mapの宣言(出現回数，その値)
	vector<int> gusu_score;
	sort(gusu.begin(), gusu.end());
	sort(gusu2.begin(), gusu2.end());
	gusu.erase(unique(gusu.begin(), gusu.end()), gusu.end()); //gusuから重複を削除

	for (int i = 0; i < gusu.size(); ++i) {
		int same_cnt = 0;
		int num = 0; //最初にgusu[i]が現れた番号※計算速度を速めるためにここは必要
		for (int j = 0; j < gusu2.size(); ++j) {
			if (gusu[i] == gusu2[j]) {
				num = j;
				break;
			}
		}
		for (int j = num; j < gusu2.size(); ++j) {
			if (gusu[i] == gusu2[j]) {
				same_cnt++;
			}
			else {
				break; //※計算速度を速めるためにここは必要
			}
		}
		gusumap.insert(make_pair(same_cnt, gusu[i]));
		gusu_score.push_back(same_cnt);
	}
	sort(gusu_score.begin(), gusu_score.end(), greater<int>());

	map<int, int> kisumap; //奇数の各値の出現頻度管理用mapの宣言(出現回数，その値)
	vector<int> kisu_score;
	sort(kisu.begin(), kisu.end());
	sort(kisu2.begin(), kisu2.end());
	kisu.erase(unique(kisu.begin(), kisu.end()), kisu.end()); //kisuから重複を削除

	for (int i = 0; i < kisu.size(); ++i) {
		int same_cnt = 0;
		int num = 0; //最初にkisu[i]が現れた番号
		for (int j = 0; j < kisu2.size(); ++j) {
			if (kisu[i] == kisu2[j]) {
				num = j;
				break;
			}
		}
		for (int j = num; j < kisu2.size(); ++j) {
			if (kisu[i] == kisu2[j]) {
				same_cnt++;
			}
			else {
				break;
			}
		}
		kisumap.insert(make_pair(same_cnt, kisu[i]));
		kisu_score.push_back(same_cnt);
	}
	sort(kisu_score.begin(), kisu_score.end(), greater<int>());

	//奇数と偶数で1，2位の最頻値を有する値を調べる
	int kisu_max_app = 0; //最頻値
	int gusu_max_app = 0; //最頻値
	int kisu_max_app2 = 0; //2最頻値
	int gusu_max_app2 = 0; //2最頻値

	kisu_max_app = kisu_score[0];
	gusu_max_app = gusu_score[0];
	if (kisu_score.size() > 2) {
		kisu_max_app2 = kisu_score[1];
	}
	if (gusu_score.size() > 2) {
		gusu_max_app2 = gusu_score[1];
	}

	int kisu_max_num = 0; //有する値
	int gusu_max_num = 0; //有する値
	kisu_max_num = kisumap[kisu_score[0]];
	gusu_max_num = gusumap[gusu_score[0]];

	if (kisu_max_num != gusu_max_num) {
		cout << n - (gusu_max_app + kisu_max_app) << endl;
		return 0;
	}
	else {
		//奇数と偶数の最頻値の要素が同じときに第2位の要素を考えるが、その要素の出現回数は順位が同じでも異なる
		//ことがあるので、下記の処理を行い固定する値の組み合わせから大きい方の値を求めておく※ここが重要
		int adjt = max((kisu_max_app + gusu_max_app2), (gusu_max_app + kisu_max_app2));
		cout << n - adjt << endl;
		return 0;
	}

	return 0;
}

Measured memory_bytes: 2296