Problem p02798 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>

#include <algorithm>
#include <cmath>
#include <functional>

#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#define TEST                                                                   \
  { IS_TEST = true; }
#define fi first
#define se second
#define pb(x)                                                                  \
  { push_back(x); }

using namespace std;
using ll = int_fast64_t;
using v_b = vector<bool>;
using v_ll = vector<ll>;
using str = string;
using v_str = vector<string>;
using p_ll = pair<ll, ll>;
using vv_b = vector<v_b>;
using vv_ll = vector<v_ll>;
using vp_ll = vector<p_ll>;
using vvv_ll = vector<vv_ll>;
using vvp_ll = vector<vp_ll>;

using ld = long double;
using v_ld = vector<ld>;
using vv_ld = vector<v_ld>;

bool IS_TEST = false;
ll ll_min64 = 1LL << 63;
ll ll_max64 = ~ll_min64;
ll ll_min32 = 1LL << 31;
ll ll_max32 = ~ll_min32;

ll MOD = 1000000007;

/*displaying functions for debug*/
template <class T> void show2(const T &x) { cout << x; }
template <class T1, class T2> void show2(const pair<T1, T2> &x) {
  cout << "{" << show2(x.first) << "," << show2(x.second) << "}";
}
template <class T> void show(const T &x) {
  if (!IS_TEST)
    return;
  show2(x);
  cout << endl;
}
template <class T> void v_show(const T &v, ll n = -1) {
  if (!IS_TEST)
    return;
  auto itr = v.begin();
  ll m = n;
  while (itr != v.end() && m != 0) {
    show2(*itr);
    cout << " ";
    itr++;
    m--;
  }
  cout << endl;
}
template <class T> void vv_show(const T &v, ll n = -1) {
  if (!IS_TEST)
    return;
  cout << "--------------------------------\n";
  auto itr = v.begin();
  ll m = n;
  while (itr != v.end() && m != 0) {
    v_show(*itr, n);
    itr++;
    m--;
  }
  cout << "--------------------------------" << endl;
}
/*--------------------------------*/

/*loading integers*/
void load(ll &x1) { cin >> x1; }
void load(ll &x1, ll &x2) { cin >> x1 >> x2; }
void load(ll &x1, ll &x2, ll &x3) { cin >> x1 >> x2 >> x3; }
void load(ll &x1, ll &x2, ll &x3, ll &x4) { cin >> x1 >> x2 >> x3 >> x4; }
void v_load(ll n, v_ll &v1, ll head = 0, ll tail = 0, ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head];
  }
}
void v_load(ll n, v_ll &v1, v_ll &v2, ll head = 0, ll tail = 0, ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  v2.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head] >> v2[i + head];
  }
}
void v_load(ll n, v_ll &v1, v_ll &v2, v_ll &v3, ll head = 0, ll tail = 0,
            ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  v2.assign(m, init);
  v3.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head] >> v2[i + head] >> v3[i + head];
  }
}
void v_load(ll n, v_ll &v1, v_ll &v2, v_ll &v3, v_ll &v4, ll head = 0,
            ll tail = 0, ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  v2.assign(m, init);
  v3.assign(m, init);
  v4.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head] >> v2[i + head] >> v3[i + head] >> v4[i + head];
  }
}
/*--------------------------------*/

v_ll local_sort(ll x1 = ll_max64, ll x2 = ll_max64, ll x3 = ll_max64,
                ll x4 = ll_max64) {
  v_ll x{x1, x2, x3, x4};
  sort(x.begin(), x.end());
  return x;
}

ll max(ll x, ll y) { return x > y ? x : y; }
ll max(v_ll::iterator b, v_ll::iterator e) {
  ll ans = *b;
  while (b < e) {
    ans = max(ans, *b);
    b++;
  }
  return ans;
}
ll argmax(v_ll::iterator b, v_ll::iterator e) {
  ll ans = 0, cnt = 0, val = *b;
  while (b < e) {
    if (val < *b) {
      ans = cnt;
      val = *b;
    }
    cnt++;
    b++;
  }
  return ans;
}

ll min(ll x, ll y) { return x < y ? x : y; }
ll min(v_ll::iterator b, v_ll::iterator e) {
  ll ans = *b;
  while (b < e) {
    ans = min(ans, *b);
    b++;
  }
  return ans;
}
ll argmin(v_ll::iterator b, v_ll::iterator e) {
  ll ans = 0, cnt = 0, val = *b;
  while (b < e) {
    if (val > *b) {
      ans = cnt;
      val = *b;
    }
    cnt++;
    b++;
  }
  return ans;
}

ll sum(v_ll::iterator b, v_ll::iterator e) {
  ll ans = 0;
  while (b < e) {
    ans += *b;
    b++;
  }
  return ans;
}

template <class T> void chmax(T &x, const T &y) {
  if (x >= y)
    return;
  x = y;
}
template <class T> void chmin(T &x, const T &y) {
  if (x <= y)
    return;
  x = y;
}
template <class T, class S> void chmax(T &x, S &xx, const T &y, const S &yy) {
  if (x >= y)
    return;
  x = y;
  xx = yy;
}
template <class T, class S> void chmin(T &x, S &xx, const T &y, const S &yy) {
  if (x <= y)
    return;
  x = y;
  xx = yy;
}

template <class T> void quit(T x) {
  cout << x << endl;
  exit(0);
}

ll rem(ll x, ll y) {
  ll z = x % y;
  return z >= 0 ? z : z + y;
}

// setprecision(digit)

ll N, M, K, H, W, ans;
v_ll A, B, C;
int main() {
  load(N);
  A.assign(N, 0);
  B.assign(N, 0);
  for (ll i = 0; i < N; i++) {
    scanf("%lld", &A[i]);
  }
  for (ll i = 0; i < N; i++) {
    scanf("%lld", &B[i]);
  }
  for (ll i = 1; i < N; i += 2) {
    swap(A[i], B[i]);
  }

  v_ll S(N / 2, 0);
  for (ll i = 0; i < N / 2; i++) {
    S[i] = i;
  }
  bool flag = true;
  ans = -1;
  while (flag) {
    v_ll T1(N - N / 2, 0);
    v_ll T2(N / 2, 0);
    ll j = 0, k = 0;
    bool good = true;
    for (ll i = 0; i < N; i++) {
      if (k < N / 2 && i == S[k]) {
        T2[k] = i;
        k++;
      } else {
        T1[j] = i;
        j++;
      }
    }

    sort(T1.begin(), T1.end(), [&](const ll &x, const ll &y) {
      if (A[x] < A[y])
        return true;
      if (A[x] == A[y] && x < y)
        return true;
      return false;
    });
    sort(T2.begin(), T2.end(), [&](const ll &x, const ll &y) {
      if (B[x] < B[y])
        return true;
      if (B[x] == B[y] && x < y)
        return true;
      return false;
    });

    for (ll i = 0; i < T2.size(); i++) {
      if (B[T2[i]] < A[T1[i]])
        good = false;
    }
    for (ll i = 1; i < T1.size(); i++) {
      if (A[T1[i]] < B[T2[i - 1]])
        good = false;
    }
    v_ll U;
    if (good) {
      for (ll i = 0; i < T1.size(); i++) {
        U.push_back(T1[i]);
        if (i < T2.size()) {
          U.push_back(T2[i]);
        }
      }
      ll a = 0;
      for (ll i = 0; i < N; i++) {
        for (ll j = i + 1; j < N; j++) {
          if (U[i] > U[j])
            a++;
        }
      }
      if (ans < 0 || a < ans)
        ans = a;
    }
    ll i = 0;
    for (i = N / 2 - 1; i >= 0; i--) {
      S[i]++;
      if (S[i] <= N - (N / 2) + i) {
        i++;
        break;
      }
      if (i == 0)
        flag = false;
    }
    for (; i < N / 2; i++) {
      if (i > 0)
        S[i] = S[i - 1] + 1;
    }
  }
  cout << ans << endl;
}


Fixed submission:
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>

#include <algorithm>
#include <cmath>
#include <functional>

#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#define TEST                                                                   \
  { IS_TEST = true; }
#define fi first
#define se second
#define pb(x)                                                                  \
  { push_back(x); }

using namespace std;
using ll = int_fast64_t;
using v_b = vector<bool>;
using v_ll = vector<ll>;
using str = string;
using v_str = vector<string>;
using p_ll = pair<ll, ll>;
using vv_b = vector<v_b>;
using vv_ll = vector<v_ll>;
using vp_ll = vector<p_ll>;
using vvv_ll = vector<vv_ll>;
using vvp_ll = vector<vp_ll>;

using ld = long double;
using v_ld = vector<ld>;
using vv_ld = vector<v_ld>;

bool IS_TEST = false;
ll ll_min64 = 1LL << 63;
ll ll_max64 = ~ll_min64;
ll ll_min32 = 1LL << 31;
ll ll_max32 = ~ll_min32;

ll MOD = 1000000007;

/*displaying functions for debug*/
template <class T> void show2(const T &x) { cout << x; }
template <class T1, class T2> void show2(const pair<T1, T2> &x) {
  cout << "{" << show2(x.first) << "," << show2(x.second) << "}";
}
template <class T> void show(const T &x) {
  if (!IS_TEST)
    return;
  show2(x);
  cout << endl;
}
template <class T> void v_show(const T &v, ll n = -1) {
  if (!IS_TEST)
    return;
  auto itr = v.begin();
  ll m = n;
  while (itr != v.end() && m != 0) {
    show2(*itr);
    cout << " ";
    itr++;
    m--;
  }
  cout << endl;
}
template <class T> void vv_show(const T &v, ll n = -1) {
  if (!IS_TEST)
    return;
  cout << "--------------------------------\n";
  auto itr = v.begin();
  ll m = n;
  while (itr != v.end() && m != 0) {
    v_show(*itr, n);
    itr++;
    m--;
  }
  cout << "--------------------------------" << endl;
}
/*--------------------------------*/

/*loading integers*/
void load(ll &x1) { cin >> x1; }
void load(ll &x1, ll &x2) { cin >> x1 >> x2; }
void load(ll &x1, ll &x2, ll &x3) { cin >> x1 >> x2 >> x3; }
void load(ll &x1, ll &x2, ll &x3, ll &x4) { cin >> x1 >> x2 >> x3 >> x4; }
void v_load(ll n, v_ll &v1, ll head = 0, ll tail = 0, ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head];
  }
}
void v_load(ll n, v_ll &v1, v_ll &v2, ll head = 0, ll tail = 0, ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  v2.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head] >> v2[i + head];
  }
}
void v_load(ll n, v_ll &v1, v_ll &v2, v_ll &v3, ll head = 0, ll tail = 0,
            ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  v2.assign(m, init);
  v3.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head] >> v2[i + head] >> v3[i + head];
  }
}
void v_load(ll n, v_ll &v1, v_ll &v2, v_ll &v3, v_ll &v4, ll head = 0,
            ll tail = 0, ll init = 0) {
  ll m = n + head + tail;
  v1.assign(m, init);
  v2.assign(m, init);
  v3.assign(m, init);
  v4.assign(m, init);
  for (ll i = 0; i < n; i++) {
    cin >> v1[i + head] >> v2[i + head] >> v3[i + head] >> v4[i + head];
  }
}
/*--------------------------------*/

v_ll local_sort(ll x1 = ll_max64, ll x2 = ll_max64, ll x3 = ll_max64,
                ll x4 = ll_max64) {
  v_ll x{x1, x2, x3, x4};
  sort(x.begin(), x.end());
  return x;
}

ll max(ll x, ll y) { return x > y ? x : y; }
ll max(v_ll::iterator b, v_ll::iterator e) {
  ll ans = *b;
  while (b < e) {
    ans = max(ans, *b);
    b++;
  }
  return ans;
}
ll argmax(v_ll::iterator b, v_ll::iterator e) {
  ll ans = 0, cnt = 0, val = *b;
  while (b < e) {
    if (val < *b) {
      ans = cnt;
      val = *b;
    }
    cnt++;
    b++;
  }
  return ans;
}

ll min(ll x, ll y) { return x < y ? x : y; }
ll min(v_ll::iterator b, v_ll::iterator e) {
  ll ans = *b;
  while (b < e) {
    ans = min(ans, *b);
    b++;
  }
  return ans;
}
ll argmin(v_ll::iterator b, v_ll::iterator e) {
  ll ans = 0, cnt = 0, val = *b;
  while (b < e) {
    if (val > *b) {
      ans = cnt;
      val = *b;
    }
    cnt++;
    b++;
  }
  return ans;
}

ll sum(v_ll::iterator b, v_ll::iterator e) {
  ll ans = 0;
  while (b < e) {
    ans += *b;
    b++;
  }
  return ans;
}

template <class T> void chmax(T &x, const T &y) {
  if (x >= y)
    return;
  x = y;
}
template <class T> void chmin(T &x, const T &y) {
  if (x <= y)
    return;
  x = y;
}
template <class T, class S> void chmax(T &x, S &xx, const T &y, const S &yy) {
  if (x >= y)
    return;
  x = y;
  xx = yy;
}
template <class T, class S> void chmin(T &x, S &xx, const T &y, const S &yy) {
  if (x <= y)
    return;
  x = y;
  xx = yy;
}

template <class T> void quit(T x) {
  cout << x << endl;
  exit(0);
}

ll rem(ll x, ll y) {
  ll z = x % y;
  return z >= 0 ? z : z + y;
}

// setprecision(digit)

ll N, M, K, H, W, ans;
v_ll A, B, C;
int main() {
  load(N);
  A.assign(N, 0);
  B.assign(N, 0);
  for (ll i = 0; i < N; i++) {
    scanf("%lld", &A[i]);
  }
  for (ll i = 0; i < N; i++) {
    scanf("%lld", &B[i]);
  }
  for (ll i = 1; i < N; i += 2) {
    swap(A[i], B[i]);
  }

  v_ll S(N / 2, 0);
  for (ll i = 0; i < N / 2; i++) {
    S[i] = i;
  }
  bool flag = true;
  ans = -1;
  while (flag) {
    v_ll T1(N - N / 2, 0);
    v_ll T2(N / 2, 0);
    ll j = 0, k = 0;
    bool good = true;
    for (ll i = 0; i < N; i++) {
      if (k < N / 2 && i == S[k]) {
        T2[k] = i;
        k++;
      } else {
        T1[j] = i;
        j++;
      }
    }

    sort(T1.begin(), T1.end(), [&](const ll &x, const ll &y) {
      if (A[x] < A[y])
        return true;
      if (A[x] == A[y] && x < y)
        return true;
      return false;
    });
    sort(T2.begin(), T2.end(), [&](const ll &x, const ll &y) {
      if (B[x] < B[y])
        return true;
      if (B[x] == B[y] && x < y)
        return true;
      return false;
    });

    for (ll i = 0; i < T2.size(); i++) {
      if (B[T2[i]] < A[T1[i]])
        good = false;
    }
    for (ll i = 1; i < T1.size(); i++) {
      if (A[T1[i]] < B[T2[i - 1]])
        good = false;
    }
    v_ll U;
    if (good) {
      for (ll i = 0; i < T1.size(); i++) {
        U.push_back(T1[i]);
        if (i < T2.size()) {
          U.push_back(T2[i]);
        }
      }
      ll a = 0;
      for (ll i = 0; i < N; i++) {
        for (ll j = i + 1; j < N; j++) {
          if (U[i] > U[j])
            a++;
        }
      }
      if (ans < 0 || a < ans)
        ans = a;

      if (ans == 0)
        quit(0);
    }
    ll i = 0;
    for (i = N / 2 - 1; i >= 0; i--) {
      S[i]++;
      if (S[i] <= N - (N / 2) + i) {
        i++;
        break;
      }
      if (i == 0)
        flag = false;
    }
    for (; i < N / 2; i++) {
      if (i > 0)
        S[i] = S[i - 1] + 1;
    }
  }
  cout << ans << endl;
}