Submission #3816253

---

Source Code Expand

#include <vector>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>

#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define DSORT(c, type) sort(ALL(c), greater<type>())

using namespace std;


pair<int, size_t> calcMode(unordered_map<int, size_t> hash){
  auto max_iterator = max_element(hash.begin(), hash.end(),
    [](const auto &a, const auto &b) -> bool {
        return (a.second < b.second);
    }
  );
  return make_pair(max_iterator->first, max_iterator->second);
}

pair<int, size_t> calcMode2(unordered_map<int, size_t> hash, int mode){
  auto max_iterator2 = max_element(hash.begin(), hash.end(),
    [&mode](const auto &a, const auto &b) -> bool {
        return (a.second < b.second && b.second != mode);
    }
  );
  if (max_iterator2->first == mode)
    return make_pair(0, 0);
  else
    return make_pair(max_iterator2->first, max_iterator2->second);
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n; 
  cin >> n;
  vector<int> v(n);
  unordered_map<int, size_t> hash_odd;
  unordered_map<int, size_t> hash_even;

  for(int i=0; i<n; ++i){
    cin >> v[i];

    if(i % 2 == 0){
      if(hash_odd.find(v[i]) != hash_odd.end()){
          ++hash_odd.at(v[i]);
      }else{
          hash_odd[v[i]] = 1;
      }
    }
    else{
      if(hash_even.find(v[i]) != hash_even.end()){
          ++hash_even.at(v[i]);
      }else{
          hash_even[v[i]] = 1;
      }
    }
  }
  
  auto mode_odd = calcMode(hash_odd);
  auto mode_even = calcMode(hash_even);

  if(mode_odd.first == mode_even.first){
    auto mode2_odd = calcMode2(hash_odd, mode_odd.first);
    auto mode2_even = calcMode2(hash_even, mode_even.first);
    if(mode2_odd.second > mode2_even.second)
      cout << n - mode2_odd.second - mode_even.second << endl;
    else
      cout << n - mode_odd.second - mode2_even.second << endl;
  }
  else
    cout << n - mode_odd.second - mode_even.second << endl;

  return 0;
}

Submission Info

Judge Result