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


Submission (verdict: Wrong answer on test 4):
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long
 
// // //------------Lazy Segment Tree Framework--------------------------------
 
// // // struct node{
// // //     int lazy;
// // //     int sum;
// // //     node(){
// // //         sum = 0;
// // //         lazy = 0;
// // //     }
// // // };
 
// // // node merge(node a,node b){
// // //     node ans;
// // //     ans.lazy = 0;
// // //     ans.sum = a.sum + b.sum;
// // //     return ans;
// // // }
 
// // // node t[4*200200];
 
// // // void push(int id,int l,int r){
// // //     //apply correct value here and then push 
// // //     if(t[id].lazy){
// // //         //if lazy there then apply and push down 
// // //         //apply logic
// // //         t[id].sum += (r-l+1)*t[id].lazy;
        
// // //         //push logic
// // //         if(l!=r){
// // //             t[id*2].lazy += t[id].lazy;
// // //             t[id*2 + 1].lazy += t[id].lazy;  //can optimise it as t[id<<1|1]
// // //         }
        
// // //         //clear
// // //         t[id].lazy = 0;
// // //     }
// // // }
 
// // // void build(int id, int l, int r) {
// // //     if (l == r) {
// // //         t[id].sum = 1;
// // //         return;
// // //     }
// // //     int mid = (l + r) / 2;
// // //     build(2 * id, l, mid);
// // //     build(2 * id + 1, mid + 1, r);
// // //     t[id] = merge(t[2 * id], t[2 * id + 1]);
// // // }
 
// // // void update(int id, int l, int r,int lq,int rq,int val) {
// // //     push(id,l,r);
// // //     if (lq>r || l>rq) {
// // //         return;
// // //     }
// // //     if(lq<=l && rq<=r){
// // //         t[id].lazy += val;
// // //         pus(id,l,r);
// // //         return;
// // //     }
// // //     int mid = (l + r) / 2;
// // //     update(2 * id, l, mid, pos, value);
// // //     update(2 * id + 1, mid + 1, r, pos, value);
// // //     t[id] = merge(t[2 * id], t[2 * id + 1]);
// // // }
 
// // // node query(int id, int l, int r, int lq, int rq) {
// // //     push(id,l,r);
// // //     if (lq > r || l > rq) {
// // //         return node();
// // //     }
// // //     if (lq <= l && r <= rq) {
// // //         return t[id];
// // //     }
// // //     int mid = (l + r) / 2;
// // //     return merge(query(2 * id, l, mid, lq, rq), query(2 * id + 1, mid + 1, r, lq, rq));
// // // }
 
 
// // // // -------Non Lazy Segment Tree Framework--------------------------------
// // // struct node{
// // //     int sum;
// // //     node(){
// // //         sum = 0;
// // //     }
// // // };
 
// // // node merge(node a,node b){
// // //     node ans;
// // //     ans.sum = a.sum + b.sum;
// // //     return ans;
// // // }
 
// // // int arr[200200];
// // // node t[4*200200];
 
// // // void build(int id, int l, int r) {
// // //     if (l == r) {
// // //         t[id].sum = 1;
// // //         return;
// // //     }
// // //     int mid = (l + r) / 2;
// // //     build(2 * id, l, mid);
// // //     build(2 * id + 1, mid + 1, r);
// // //     t[id] = merge(t[2 * id], t[2 * id + 1]);
// // // }
 
// // // void update(int id, int l, int r, int pos, int value) {
// // //     if (pos < l || pos > r) {
// // //         return;
// // //     }
// // //     if (l == r) {
// // //         t[id].sum -= value;
// // //         return;
// // //     }
// // //     int mid = (l + r) / 2;
// // //     update(2 * id, l, mid, pos, value);
// // //     update(2 * id + 1, mid + 1, r, pos, value);
// // //     t[id] = merge(t[2 * id], t[2 * id + 1]);
// // // }
 
// // // // node query(int id, int l, int r, int lq, int rq) {
// // // //     if (lq > r || l > rq) {
// // // //         return node();
// // // //     }
// // // //     if (lq <= l && r <= rq) {
// // // //         return t[id];
// // // //     }
// // // //     int mid = (l + r) / 2;
// // // //     return merge(query(2 * id, l, mid, lq, rq), query(2 * id + 1, mid + 1, r, lq, rq));
// // // // }
 
// // // int query(int id,int l,int r,int req){
// // //     if(t[id].sum<req){
// // //         return 0;
// // //     }
// // //     if(l==r){
// // //         return l;
// // //     }
// // //     int mid = (l+r)/2;
// // //     if(t[id*2].sum>=req){
// // //         return query(2*id,l,mid,req);
// // //     }
// // //     else{
// // //         return query(2*id+1,mid+1,r,req - t[2*id].sum);
// // //     }
// // //     return 0;
// // // }
 
// // //----------End of Non Lazy Framework--------------------------------'
 
class DSU{
    vector<int> rank, parent, size;
public:
    DSU(int n) {
        rank.resize(n + 1, 0);
        parent.resize(n + 1);
        size.resize(n + 1);
        for (int i = 0; i <= n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }

    int findUPar(int node) {
        if (node == parent[node])
            return node;
        return parent[node] = findUPar(parent[node]);
    }

    void unionByRank(int u, int v) {
        int ulp_u = findUPar(u);
        int ulp_v = findUPar(v);
        if (ulp_u == ulp_v) return;
        if (rank[ulp_u] < rank[ulp_v]) {
            parent[ulp_u] = ulp_v;
        }
        else if (rank[ulp_v] < rank[ulp_u]) {
            parent[ulp_v] = ulp_u;
        }
        else {
            parent[ulp_v] = ulp_u;
            rank[ulp_u]++;
        }
    }

    void unionBySize(int u, int v) {
        int ulp_u = findUPar(u);
        int ulp_v = findUPar(v);
        if (ulp_u == ulp_v) return;
        if (size[ulp_u] < size[ulp_v]) {
            parent[ulp_u] = ulp_v;
            size[ulp_v] += size[ulp_u];
        }
        else {
            parent[ulp_v] = ulp_u;
            size[ulp_u] += size[ulp_v];
        }
    }
    
};
const int mod = 1e9 + 7;
int dp[1000001];
int rec(int n, vector<int>&arr){
    if(n==0){
        return 1;
    }
    if(dp[n]!=-1){
        return dp[n];
    }
    int ans = 0;
    for(int i=0;i<arr.size();i++){
        if(arr[i]<=n){
            ans = (ans + rec(n - arr[i], arr))%mod;
        }
    }
    return dp[n] = ans;
}

bool dfs(int node, vector<vector<int>>& adj, vector<bool>& vis, int src) {
    if (node == src) return true;
    vis[node] = true;
    for (auto it : adj[node]) {
        if (!vis[it]) {
            if (dfs(it, adj, vis, src)) {
                return true;
            }
        }
    }
    return false;
}

bool dfsprint(int node, vector<vector<int>>& adj, vector<bool>& vis, int src, stack<int>&st) {
    if (node == src) {
        return true;
    }
    vis[node] = true;
    bool flag = false;
    for (auto it : adj[node]) {
        if (dfsprint(it, adj, vis, src, st)) {
            st.push(it);
            return true;
        }
    }
    return flag;
}

#include <bits/stdc++.h>
using namespace std;

#define endl "\n"
#define int long long

void solve() {
    int n;
    cin >> n;
    vector<int>arr(n);
    for(int i=0;i<n;i++){
        cin>>arr[i];
    }
    if(n==1){
        cout<<0<<endl;
        return;
    }
    int ans = (n*(n-1))/2 + 1;
    cout<<ans<<endl;
    set<int>done;
    int overtake = n-1;
    while(overtake>1){
        for(int i=1;i<=n;i++){
            if(done.find(i)==done.end() && arr[overtake]!=i){
                cout<<i<<" "<<arr[overtake]<<endl;
            }
        }
        done.insert(arr[overtake]);
        overtake--;
    }
    cout<<arr[1]<<" "<<arr[0]<<endl;
    cout<<arr[0]<<" "<<arr[1]<<endl;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
    // cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}