Problem: 2052A - Adrenaline Rush
Language: C++20 (GCC 13-64)


Submission (verdict: Wrong answer on test 7):
#include <bits/stdc++.h>
#define endl '\n'
#define all(a) a.begin(), a.end()
#define ll long long
#define ull unsigned long long
#define inf 0x7fffffff;
//#define int long long
//#define III int
using namespace std;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<vector<int> >;
using vll = vector<vector<ll> >;
using vpii = vector<pair<int, int> >;
using vpll = vector<pair<ll, ll> >;
//cout << ceil(-0.2) << endl;
//const ll mod = 1e9 + 7;
const ll mod = 998244353;
const ll INF = 1e18;

// struct node {
//     ll dis, u;
//     int hh;
//     bool operator>(const node &a) const {return dis > a.dis;}
// };

// struct now {
//     ll a, b;
//
//     bool operator<(const now &x) const {
//         return a < x.a;
//     }
// };

ll qpow(ll a, ll b) {
    ll ret = 1;
    a %= mod;
    while (b) {
        if (b & 1) {
            ret *= a;
            ret %= mod;
        }
        b /= 2;
        a = (a * a) % mod;
    }
    return ret;
}


const int MAXN = 2e5 + 5;
std::vector<ll> fac, invfac;

void init() {
    fac.resize(MAXN), invfac.resize(MAXN);
    fac[0] = 1;
    for (int i = 1; i < MAXN; i++) {
        fac[i] = 1LL * fac[i - 1] * i % mod;
    }
    invfac[MAXN - 1] = qpow(fac[MAXN - 1], mod - 2);
    for (int i = MAXN - 2; i >= 0; i--) {
        invfac[i] = 1LL * invfac[i + 1] * (i + 1) % mod;
    }
}

ll binom(int n, int k) {
    if (k < 0 || k > n) {
        return 0;
    }
    return 1LL * fac[n] * invfac[k] % mod * invfac[n - k] % mod;
}

int dirs[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};


void solve() {
    int n;
    cin >> n;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    vector<pair<int, int>> ans;
    vector<set<int>> st(n + 1);
    for (int i = 1; i < n; i++) {
        vector<int> t;
        for (int j = i + 1; j <= n; j++) {
            if (a[i] > a[j]) {
                t.push_back(a[j]);
                st[a[i]].insert(a[j]);
            }
        }
        sort(all(t), greater<int>());
        for (int j : t) {
            ans.emplace_back(a[i], j);
        }
    }
    for (int i = 1; i < n; i++) {
        vector<int> t;
        for (int j = i + 1; j <= n; j++) {
            if (st[a[i]].find(a[j]) == st[a[i]].end() && st[a[j]].find(a[i]) == st[a[j]].end()) {
                t.push_back(a[j]);
            }
        }
        for (int j : t) {
            ans.emplace_back(j, a[i]);
        }
        for (int j = t.size() - 1; j >= 0; j--) {
            ans.emplace_back(a[i], t[j]);
        }
    }
    cout << ans.size() << endl;
    for (auto p : ans) {
        cout << p.first << ' ' << p.second << endl;
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    // helper();
    // init();
    int t = 1;
    //cin >> t;
    while (t--) solve();

    return 0;
}


// struct node {
//     ll w, l, r;
// };


// //int n;
// ll tree[500005];
// int lowbit(int x) {
//     return x & (-x);
// }
// void add(int l, ll x) {
//     for (int i = l; i <= n; i += lowbit(i)) {
//         tree[i] += x;
//     }
// }
// ll sum(int r) {
//     ll ret = 0;
//     for (int i = r; i >= 1; i -= lowbit(i)) {
//         ret += tree[i];
//     }
//     return ret;
// }


// int n;
// struct node {
//     int u;
//     ll dis;
//     bool operator<(node b) const {
//         return dis > b.dis;
//     }
// };
// vector<pair<int, ll>> g[400010];
// ll dis[400010];
// int vis[400010];
// void dijkstra(int st) {
//     dis[st] = 0;
//     // vis[st] = 1;
//     priority_queue<node> pq;
//     pq.push({1, dis[1]});
//     while (!pq.empty()) {
//         auto [u, d] = pq.top();
//         pq.pop();
//         if (vis[u]) continue;
//         vis[u] = 1;
//         for (auto p : g[u]) {
//             if (dis[p.first] > dis[u] + p.second) {
//                 dis[p.first] = dis[u] + p.second;
//                 pq.push({p.first, dis[p.first]});
//             }
//         }
//     }
// }