#include <iostream>
#include <queue>
#include <map>
#include <cmath>
#include <algorithm>
#include <queue>
#include <cstdarg>
#include <set>
#include <limits>
#include <iomanip>

using namespace std;
#define INF 2e9 + 9
#define MOD 1000000007
#define ALL(v) v.begin() , v.end()
#define Int int64_t
#define pll pair<Int,Int>
template<class T> using pql = priority_queue<T, vector<T>>;
template<class T> using pq = priority_queue<T, vector<T>, greater<T>>;
#define ll(n) Int n; cin >> n;
#define LL(...) Int __VA_ARGS___; cin >> __VA_ARGS___;
#define OUT(...) cout << __VA_ARGS___;
#define RP(n, i, s) for(Int i = s ;i < n ;i++)
#define REP(n, i) for (Int i = 0; i < n; i++)
#define REPe(n, i) for (Int i = 1; i <= n; i++)
#define RPe(n, i, s) for (Int i = s; i <= n; i++)
#define upd_max(maxer, updater) if (maxer < updater) maxer = updater;
#define upd_min(miner, updater) if (miner > updater) miner = updater;

void ansYes(bool flag) {
    if (flag) cout << "Yes" << endl; else cout << "No" << endl;
}

void ansYES(bool flag) {
    if (flag) cout << "YES" << endl; else cout << "NO" << endl;
}

struct node {
    Int to;
    Int length;
};


vector<Int> divisor(Int n) {
    vector<Int> ret;
    for (Int i = 1; i * i <= n; i++) {
        if (n % i == 0) {
            ret.push_back(i);
            if (i * i != n) ret.push_back(n / i);
        }
    }
    return (ret);
}

/*
vector<vector<int>> to;
vector<int> flag;
vector<int> c;


Int dfs(int from, int mae) {
    flag[from] = 1;
    Int mini = 0;
    for (auto next : to[from]) {
        if (next == mae) continue;
        if (flag[next] == 1) {
            return -1;
        } else {
            mini = min(mini, dfs(next, from));
        }
    }
    return mini;
}*/

int dx8[8] = {0, -1, -1, -1, 0, 1, 1, 1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};

int dx[4] = {0, -1, 0, 1};
int dy[4] = {-1, 0, 1, 0};

struct datas {
    Int max;
    Int size;
};

class ContainChecker {
protected:
    Int minx, miny, maxx, maxy;
public:
    ContainChecker(Int minx, Int miny, Int maxx, Int maxy) : minx(minx), miny(miny), maxx(maxx), maxy(maxy) {};

    bool in(Int x, Int y) {
        return (minx <= x && miny <= y && x <= maxx && y <= maxy);
    }
};

Int dfs(Int digits, Int tugi, Int num, Int koko) {

}



int main(void) {
    Int kisu[100010] = {};
    Int gusu[100010] = {};
    Int n;
    cin >> n;
    REP(n,i){
        Int x;
        cin >> x;
        if (i % 2 == 0)  kisu[x]++; else gusu[x]++;
    }
    Int kisumax = 0;
    Int kisumaxcnt = 0;
    Int kisusecond = 0;
    Int gusumax = 0;
    Int gusumaxcnt = 0;
    Int gususecond = 0;
    REP(100010,i){
        if (kisumax <= kisu[i]) {
            kisusecond = kisumax;
            kisumax = kisu[i];
            kisumaxcnt = i;
        }else if (kisusecond <= kisu[i]) {
            kisusecond = kisu[i];
        }
        if (gusumax <= gusu[i]) {
            gususecond = gusumax;
            gusumax = gusu[i];
            gusumaxcnt = i;
        }else if (gususecond <= gusu[i]) {
            gususecond = gusu[i];
        }
    }

    if (kisumaxcnt != gusumaxcnt) {
        cout << n - (kisumax + gusumax) << endl;
    }else{
        Int ans = 0;
        ans = n - max((kisumax + gususecond),(gusumax + kisusecond));
        cout << ans << endl;
    }
}




Measured memory_bytes: 1792