#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <limits>
#include <stack>
#include <queue>
#include <map>
#include<set>

using namespace std;

using ll = long long;
using ui = unsigned int;
const ll MOD = 1000000007;
const ll INF = 9223372036854775807;

//AtCoder Beginner Contest 111-C
int main() {
	ll n;
	scanf("%lld", &n);
	vector<ll> v(n);
	for (ll i = 0; i < n; i++) {
		scanf("%lld", &v[i]);
	}

	map<ll, ll> mp1;
	map<ll, ll> mp2;
	for (ll i = 0; i < n; i++) {
		if (i % 2 == 0) {
			mp1[v[i]]++;
		}
		else {
			mp2[v[i]]++;
		}
	}

	ll max_count_num1 = -1;
	ll max_count1 = -1;
	ll second_count1 = -1;
	auto begin = mp1.begin(), end = mp1.end();
	for (auto iter = begin; iter != end; iter++) {
		// iter->first: key, iter->second: value
		if (iter->second > max_count1) {
			max_count_num1 = iter->first;
			second_count1 = max_count1;
			max_count1 = iter->second;
		}
		else if (iter->second > second_count1) {
			second_count1 = iter->second;
		}
	}

	ll max_count_num2 = -1;
	ll max_count2 = -1;
	ll second_count2 = -1;
	begin = mp2.begin();
	end = mp2.end();
	for (auto iter = begin; iter != end; iter++) {
		// iter->first: key, iter->second: value
		if (iter->second > max_count2) {
			max_count_num2 = iter->first;
			second_count2 = max_count2;
			max_count2 = iter->second;
		}
		else if (iter->second > second_count2) {
			second_count2 = iter->second;
		}
	}

	ll result = 0;

	if (max_count_num1 == max_count_num2) {
		if (second_count1 < 0 && second_count2 < 0) {
			result += n / 2;
		}
		else if (second_count1 >= 0 && second_count2 >= 0) {
			if (max_count1 + second_count2 > second_count1 + max_count2) {
				result += n / 2 - max_count1;
				result += n / 2 - second_count2;
			}
			else {
				result += n / 2 - second_count1;
				result += n / 2 - max_count2;
			}
		}
		else if (second_count1 < 0 && second_count2 >= 0) {
			result += n / 2 - second_count2;
		}
		else if (second_count1 >= 0 && second_count2 < 0) {
			result += n / 2 - second_count1;
		}
	}
	else {
		result += n / 2 - max_count1;
		result += n / 2 - max_count2;
	}

	printf("%lld\n", result);
}


//CODE FESTIVAL 2017 qual A - B
/*
int main() {
	ll N;
	scanf("%lld", &N);
	ll M;
	scanf("%lld", &M);
	ll K;
	scanf("%lld", &K);

	bool success = false;
	for (ll i = 0; i <= N; i++) {
		for (ll j = 0; j <= M; j++) {
			ll count = i * (M - j) + (N - i) * j;
			if (count == K) {
				success = true;
				break;
			}
		}
		if (success == true) {
			break;
		}
	}

	if (success == true) {
		printf("Yes\n");
	}
	else {
		printf("No\n");
	}
}
*/

//CODE FESTIVAL 2016 Final - B
/*
int main() {
	ll N;
	scanf("%lld", &N);

	ll maxI = 0;
	while (true) {
		if (2 * N <= maxI * (maxI + 1)) {
			break;
		}
		maxI++;
	}

	for (ll i = maxI; i >= 1; i--) {
		if (N >= i) {
			printf("%lld\n", i);
			N -= i;
		}
	}
}
*/

//ABC061-C
/*
struct LLPair {
	ll a = 0;
	ll b = 0;
};

int main() {
	ll N;
	scanf("%lld", &N);
	ll K;
	scanf("%lld", &K);

	vector<LLPair> A;
	for (ll i = 0; i < N; i++) {
		LLPair p;
		scanf("%lld %lld", &p.a, &p.b);
		A.push_back(p);
	}

	std::sort(A.begin(), A.end(), [](const LLPair &a, const LLPair &b) {
		return a.a < b.a;
	});


	ll result = 0;
	ll count = 0;
	for (auto p : A) {
		count += p.b;

		if (count >= K) {
			result = p.a;
			break;
		}
	}

	printf("%lld\n", result);
}
*/

//ABC051-B
/*
int main() {
	ll K;
	scanf("%lld", &K);
	ll S;
	scanf("%lld", &S);

	ll result = 0;

	for (ll i = 0; i <= min(K, S); i++) {
		for (ll j = 0; j <= min(K, S - i); j++) {
			if (i + j + K >= S) {
				result++;
			}
		}

	}

	printf("%lld\n", result);
}
*/

//ABC047-B
/*
int main() {
	ll W;
	scanf("%lld", &W);
	ll H;
	scanf("%lld", &H);
	ll N;
	scanf("%lld", &N);

	vector<vector<ll>> arr(W + 1, vector<ll>(H + 1, 0));

	for (ll i = 0; i < N; i++) {
		ll x;
		scanf("%lld", &x);
		ll y;
		scanf("%lld", &y);
		ll a;
		scanf("%lld", &a);

		switch (a)
		{
		case 1ll:
			if (x > 0) {
				arr[0][0]++;
				arr[x][0]--;
				arr[0][H]--;
				arr[x][H]++;
			}
			break;
		case 2ll:
			if (x < W) {
				arr[x][0]++;
				arr[W][0]--;
				arr[x][H]--;
				arr[W][H]++;
			}
			break;
		case 3ll:
			if (y > 0) {
				arr[0][0]++;
				arr[W][0]--;
				arr[0][y]--;
				arr[W][y]++;
			}
			break;
		case 4ll:
			if (y < H) {
				arr[0][y]++;
				arr[W][y]--;
				arr[0][H]--;
				arr[W][H]++;
			}
			break;
		default:
			break;
		}
	}

	for (ll y = 0; y <= H; y++) {
		for (ll x = 1; x <= W; x++) {
			arr[x][y] += arr[x - 1][y];
		}
	}

	for (ll x = 0; x <= W; x++) {
		for (ll y = 1; y <= H; y++) {
			arr[x][y] += arr[x][y - 1];
		}
	}

	ll result = 0;

	for (ll y = 0; y < H; y++) {
		for (ll x = 0; x < W; x++) {
			if (arr[x][y] == 0) {
				result++;
			}
		}
	}

	printf("%lld\n", result);
}
*/

//ABC117-C
/*
int main() {
	ll N;
	scanf("%lld", &N);
	ll M;
	scanf("%lld", &M);
	vector<ll> X(M);
	for (ll i = 0; i < M; i++) {
		scanf("%lld", &X[i]);
	}

	if (M <= N) {
		printf("0\n");
		return 0;
	}

	sort(X.begin(), X.end());

	vector<ll> d;
	for (ll i = 0; i < M - 1; i++) {
		d.push_back(X[i + 1] - X[i]);
	}

	sort(d.begin(), d.end(), std::greater<ll>());

	ll result = X[M - 1] - X[0];

	for (ll i = 0; i < N - 1; i++) {
		result -= d[i];
	}

	printf("%lld\n", result);
}
*/

//ABC065
/*
int main() {
	ll N;
	scanf("%lld", &N);
	ll M;
	scanf("%lld", &M);

	if (abs(N - M) >= 2) {
		printf("0\n");
		return 0;
	}

	ll result = 1;
	for (ll i = 1; i <= N; i++) {
		result *= i;
		result %= MOD;
	}
	for (ll i = 1; i <= M; i++) {
		result *= i;
		result %= MOD;
	}

	if (N == M) {
		result *= 2;
		result %= MOD;
	}

	printf("%lld\n", result);
}
*/

//AGC032-A
/*
int main() {
	int ret_scanf;

	ll N;
	ret_scanf = scanf("%lld", &N);
	vector<ll> b(N);
	for (ll i = 0; i < N; i++) {
		ret_scanf = scanf("%lld", &b[i]);
	}

	stack<ll> st;
	bool success = true;
	while (b.size() > 0) {
		bool fail = true;
		for (ll i = b.size() - 1; i >= 0; i--) {
			if (b[i] == i + 1) {
				st.push(i + 1);
				b.erase(b.begin() + i);
				fail = false;
				break;
			}
		}

		if (fail == true) {
			success = false;
			break;
		}
	}

	if (success == true) {
		while (st.empty() == false) {
			ll result = st.top();
			st.pop();
			printf("%lld\n", result);
		}
	}
	else {
		printf("-1\n");
	}

}
*/

//ABC078-C
/*
int main() {
	ll N;
	scanf("%lld", &N);
	ll M;
	scanf("%lld", &M);

	ll time_one = M * 1900ll + (N - M) * 100ll;

	ll result = time_one << M;

	printf("%lld\n", result);
}
*/

//AGC008-A
/*
int main() {
	ll x;
	scanf("%lld", &x);
	ll y;
	scanf("%lld", &y);
	
	ll result = INF;


	if (x == y) {
		result = 0;
	}
	else if (x < y) {
		if (x >= 0 && y >= 0) {
			result = y - x;
		}
		else if (x <= 0 && y <= 0) {
			result = y - x;
		}
		else {
			//x:- y:+

			if (abs(x) <= y) {
				result = 1ll + y - abs(x);
			}
			else if (abs(x) > y) {
				result = abs(x) - y + 1ll;
			}
		}
	}
	else if(x > y){
		if (x == 0) {
			result = abs(y) + 1ll;
		}
		else if (y == 0) {
			result = 1ll + x;
		}
		else if (x > 0 && y >= 0) {
			result = 1ll + x - y + 1ll;
		}
		else if (x < 0 && y <= 0) {
			result = 1ll + abs(y) - abs(x) + 1ll;
		}
		else {
			//x:+ y:-

			if (x >= abs(y)) {
				result = 1ll + x - abs(y);
			}
			else if(x < abs(y)) {
				result = abs(y) - x + 1ll;
			}
		}
	}

	printf("%lld\n", result);
}
*/


//ABC097-C
/*
int main() {
	string s;
	cin >> s;
	ll K;
	cin >> K;

	ll len = s.length();
	set<string> st;

	for (ll i = 0; i < len; i++) {
		for (ll j = 1; j <= min(K, len - i); j++) {
			st.insert(s.substr(i, j));
		}
	}

	vector<string> A;
	for (auto item : st) {
		A.push_back(item);
	}

	std::sort(A.begin(), A.end());

	cout << A[K - 1];

}
*/


//ABC99-C
/*
int main() {
	ll N;
	scanf("%lld", &N);

	vector<ll> dp(N + 1, INF);
	dp[N] = 0;

	for (ll i = N; i > 0; i--) {
		if (dp[i] == INF) {
			continue;
		}

		dp[i - 1] = min(dp[i - 1], dp[i] + 1);

		ll draw = 6;
		while (true) {
			if (i >= draw) {
				dp[i - draw] = min(dp[i - draw], dp[i] + 1);
			}
			else {
				break;
			}

			draw *= 6;
		}

		draw = 9;
		while (true) {
			if (i >= draw) {
				dp[i - draw] = min(dp[i - draw], dp[i] + 1);
			}
			else {
				break;
			}

			draw *= 9;
		}
	}

	printf("%lld\n", dp[0]);
}
*/

//ARC100-C
//L1�����̑��a���ŏ�������ɂ͒����l
/*
int main() {
	ll N;
	scanf("%lld", &N);
	vector<ll> A(N, 0);
	for (ll i = 0; i < N; i++) {
		scanf("%lld", &A[i]);
	}

	vector<ll> B(N, 0);
	ll sum = 0;
	for (ll i = 0; i < N; i++) {
		B[i] = A[i] - (i + 1);
	}

	std::sort(B.begin(), B.end());

	ll b = B[N / 2];


	ll result = 0;

	for (ll i = 0; i < N; i++) {
		result += std::abs(A[i] - (b + i + 1));
	}

	printf("%lld\n", result);
}
*/

Measured memory_bytes: 7296