Problem: 2052A - Adrenaline Rush
Language: c++17 

Solution 1 (runtime: 1140 ms):
	#include<bits/stdc++.h>
		using namespace std ;
		typedef long long ll ;
			 
		typedef vector<long long> vll ;
		typedef pair<long long , long long> pll ;
		typedef map<long long , long long> mpll ;
			 
		#define pb push_back
		#define FOR(i,n) for(ll i = 0 ; i < n ; i++)
		#define all(x) (x).begin(),(x).end() 
			 
			 
		void print_vec(vll v){
			for(auto iter : v){
				cout << iter << " " ;
				}
			cout << endl ;
		}
		ll maxll(ll val1 ,ll val2){
					if(val1>val2){
						return val1 ;
					}
	 
					else{
						return val2 ;
					}
				}
				ll minll(ll val1 ,ll val2){
					if(val1<val2){
						return val1 ;
					}
					else{
						return val2 ;
					}
				}
				
			 
				vll input_vec(ll n){
					vll vec(n) ;
					FOR(i,n){
						cin >> vec[i] ;
					}
					return vec ;
				}
			 
				long long gcd(ll a , ll b){
					if(a%b == 0){ // a is the dividend in this case 
						return b ;
					}
					return gcd(b,a%b) ;
				}
				long long lcm(ll a , ll b){
					return (a*b)/gcd(a,b) ;
				}
			 
			 
	// 			// Seive Algorithms
	// 			const int N = 1e7 + 7 ;
	// 			vector<bool> isPrime(N,1) ;
	// 			vector<ll> hp(N) ;
	// 			vector<ll> lp(N,0) ;
			 
	// 			void SeiveAlgo(){
	// 				isPrime[0] = isPrime[1] = 0 ;
	// 				for(int i = 2 ; i*i <= N ;i++){
	// 					if(isPrime[i] == true){
	// 						lp[i] = i ;
	// 						for(int j = i*i ; j <= N ; j += i){
	// 							isPrime[j] = false ;
	// 							hp[j] = i ;
	// 							if(lp[j] == 0){
	// 								lp[j] = i ;
	// 							}
	// 						}
	// 					}
	// 				}
							
	// 			}
			 
				
				
			 
					
			 
					
				
		 
			
				
				long long power(long long a, long long b , long long mod)
		{
		    long long result = 1;
		    while (b) {
		        if (b & 1)
		            result = (result * a) % mod;
		        a = (a * a) % mod;
		        b >>= 1;
		    }
		    return result;
		}
	 
		
	ll modInverse(ll A, ll M)
	{
	    return power(A, M - 2, M);
	}
	 
	// ll cal_N_C_R(ll n , ll k , ll p){
	// 	ll n_fact = 1 ;
	// 	for(ll i = 1 ; i <= n ; i++){
	// 		n_fact = ((n_fact%p) * (i%p))%p ;
	// 	}
	// 	ll k_fact = 1 ;
	// 	for(ll i = 1 ; i <= k ; i++){
	// 		k_fact = ((k_fact%p) * (i%p))%p ;
	// 	}
	// 	ll n_minus_k_fact = 1 ;
	// 	for(ll i = 1 ; i <= (n - k) ; i++){
	// 		n_minus_k_fact = ((n_minus_k_fact%p) * (i%p))%p ;
	// 	}
	 
	// 	k_fact = power(k_fact , p - 2 , p) ;
	// 	n_minus_k_fact = power(n_minus_k_fact , p - 2 , p) ;
	// 	ll ans = ((n_fact%p) * (k_fact%p))%p ;
	// 	ans = ((ans%p) * (n_minus_k_fact%p))%p ;
	 
	// 	return ans ;
	 
	// }
	 
	// vll N_C_R(ll n , ll p){
	// 	vll v ;
	 
	// 	ll n_fact = 1 ;
	// 	for(ll i = 1 ; i <= n ; i++){
	// 		v.pb(n_fact) ;
	// 		n_fact = ((n_fact%p) * (i%p))%p ;
	// 	}
	// 	v.pb(n_fact) ;
	// 	//print_vec(v) ;
	 
	// 	vll ncr ;
	// 	for(ll i = 0 ; i < v.size() ; i++){
	// 		ll n_fact = v[v.size() - 1] ;
	// 		//cout << n_fact << endl ;
	// 		ll r_fact = power(v[i] , p - 2 , p) ;
	// 		//cout << r_fact << endl ;
	// 		ll n_minus_r_fact = power(v[n - i] , p - 2 , p) ;
	// 		//cout << v[n - i] << endl ;
	// 		//cout << "yes" << endl ;
	 
	// 		ll ans = ((n_fact%p) * (r_fact%p))%p ;
	// 		ans = ((ans%p) * (n_minus_r_fact%p))%p ;
	 
	 
	// 		ncr.pb(ans) ;
	// 	}
	 
	// 	//print_vec(ncr) ;
	// 	return ncr ;
	// }
	 
	// ll cal_max_len(vector<ll> &v , ll index , ll dp[] , map<ll,vll> &mp){
	// 	if(index == v.size() - 1){
	// 		return dp[index] = 0 ;
	// 	}
	// 	else if(index >= v.size()){
	// 		return 0 ;
	// 	}
	// 	else if(dp[index] != -1){
	// 		return dp[index] ;
	// 	}
	// 	else{
	// 		ll take = -1 ;
	// 		ll count = 0 ;
	// 		for(auto it : mp[v[index]]){
	// 			if(it > index){
	// 				take = maxll(take , it - index + 1 + cal_max_len(v , it + 1 , dp , mp)) ;
						
	// 			}
	 
	// 		}
	// 		ll not_take = cal_max_len(v , index + 1 , dp , mp) ;
	// 		dp[index] = max(take , not_take) ;
	// 		return dp[index] ;
	// 	}
	// }
 
	// ll cal_children(vector<ll> adj[] , ll dp[] , ll index){
	// 	if(dp[index] != -1){
	// 		return dp[index] ;
	// 	}
	// 	else if(adj[index].size() == 0){
	// 		return dp[index] = 1 ;
	// 	}
	// 	else{
	// 		ll sum = 0 ;
	// 		for(auto it : adj[index]){
	// 			sum += cal_children(adj , dp , it) ;
	// 		}
	// 		return dp[index] = sum + 1 ;
	// 	}
	// }
		
 
	// pair<ll,ll> cal_cost(ll curr_num , ll target , map<pair<ll,ll> , pair<ll,ll>> &mp){
	// 	pair<ll,ll> P ;
	// 	P.first = curr_num ;
	// 	P.second = target ;
	// 	if(mp.find(P) != mp.end()){
	// 		return mp[P] ;
	// 	}
	// 	else if(curr_num > target){
	// 		pair<ll,ll> p1 = cal_cost(curr_num/2 + curr_num%2 , target , mp) ;
	// 		pair<ll,ll> p2 = cal_cost(curr_num - curr_num/2 - curr_num%2 , target , mp) ;
	// 		pair<ll,ll> p ;
	// 		p.first = 1 + p1.first + p2.first ;
	// 		p.second = minll(p1.second , p2.second) ;
	// 		return mp[P] = p ;
	// 	}
	// 	else{
	// 		pair<ll,ll> p ;
	// 		p.first = 0 ;
	// 		p.second = curr_num ;
	// 		return mp[P] = p ;
	// 	}
	// }
 
 
	// ll binary_search(vll &v , ll target){
	// 	ll lower_bound = 0 ;
	// 	ll upper_bound = v.size() - 1 ;
 
	// 	ll mid = (upper_bound - lower_bound) / 2 + lower_bound ;
 
	// 	while(upper_bound >= lower_bound){
	// 		mid = (upper_bound - lower_bound) / 2 + lower_bound ;
 
	// 		if(v[mid] > target){
	// 			upper_bound = mid - 1 ;
	// 			mid = mid - 1 ;
	// 		}
	// 		else if(v[mid] < target){
	// 			lower_bound = mid + 1 ;
	// 		}
	// 		else if(v[mid] == target){
	// 			return mid ;
	// 		}
			
	// 	}
	// 	return mid;
	// }
 
 
	// ll cal_ways(vll &v , ll index , ll x , vll &prefix_sums , ll dp[]){
	// 	if(index == v.size()){
	// 		return dp[index] = 0 ;
	// 	}
	// 	if(dp[index] != -1){
	// 		return dp[index] ;
	// 	}
	// 	ll target_sum ;
	// 	if(index == 0){
	// 		target_sum = x ;
	// 	}
	// 	else{
	// 		target_sum = x + prefix_sums[index - 1] ;
	// 	}
	// 	ll lower_bound = index ;
	// 	ll upper_bound = v.size() - 1 ;
 
	// 	// cout << lower_bound << upper_bound << endl ;
	// 	// cout << target_sum << endl ;
 
	// 	ll mid = (upper_bound - lower_bound) / 2 + lower_bound ;
	// 	while(lower_bound <= upper_bound){
	// 		mid = (upper_bound - lower_bound) / 2 + lower_bound ;
	// 		if(prefix_sums[mid] <= target_sum){
	// 			lower_bound = mid + 1 ;
	// 			mid = mid + 1 ;
	// 		}
	// 		else if(prefix_sums[mid] > target_sum){
	// 			upper_bound = mid - 1 ;
	// 		}
 
	// 	}
	// 	//cout << mid << endl ;
	// 	if(mid == v.size()){
	// 		return dp[index] = 0 ;
	// 	}
	// 	else{
	// 		dp[index] = 1 + cal_ways(v , mid + 1 , x , prefix_sums , dp) ;
	// 		return dp[index] ;
	// 	}
	// }
 
	// ll dfs_checker(vll &initial_perm , map<ll,set<ll>> &adj , ll node , ll ptr){
 
	// 	if(ptr == initial_perm.size()){
	// 		return ptr ;
	// 	}
	// 	else if(ptr == -1){
	// 		return -1 ;
	// 	}
	// 	while(true){
	// 		if(ptr == initial_perm.size()){
	// 			return ptr ;
	// 		}
	// 		if(adj[node].find(initial_perm[ptr]) != adj[node].end()){
	// 			adj[node].erase(*adj[node].find(initial_perm[ptr])) ;
	// 			//cout << "yes" << endl ;
	// 			ptr = dfs_checker(initial_perm , adj , initial_perm[ptr] , ptr+1) ;
	// 			//cout << ptr << endl ;
				
	// 		}
	// 		else if(adj[node].size() == 0){
	// 			return ptr ;
	// 		}
	// 		else{
	// 			return -1 ;
	// 		}
			
	// 	}
	// 	if(ptr == initial_perm.size()){
	// 		return ptr ;
	// 	}
	// 	else{
	// 		return ptr ;
	// 	}
	// }
 
	// void bfs(set<ll> adj[] , ll starting_node , ll vis[] , ll deg[]){
	// 	queue<ll> q ;
	// 	vll v ;
	// 	v.pb(starting_node) ;
	// 	q.push(starting_node) ;
 
	// 	vis[starting_node] = 1 ;
 
	// 	while(!q.empty()){
	// 		ll node = q.front() ;
	// 		q.pop() ;
 
	// 		for(auto it : adj[node]){
	// 			if(vis[it] == -1){
	// 				q.push(it) ;
	// 				vis[it] = 1 ;
	// 				v.pb(it) ;
	// 			}
	// 		}
	// 	}
	// }
	// ll func(vll &v , ll curr_s , ll curr_i , ll index , ll dp[]){
 
	// 	//cout << curr_s << " " << curr_i << " " << index << endl ;
	// 	if(index == v.size()){
	// 		return 0 ;
	// 	}
	// 	if(dp[curr_s] != -1){
	// 		return dp[curr_s] ;
	// 	}
	// 	if(v[index] == 0){
	// 		ll p = max(func(v , curr_s + 1 , curr_i , index+1 , dp) , func(v , curr_s , curr_i + 1 , index+1 , dp)) ;
	// 		//cout << p << endl ;
	// 		dp[curr_s] = p ;
	// 		return p ;
	// 	}
	// 	else if(v[index] > 0){
	// 		if(curr_s >= v[index]){
	// 			return 1 + func(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 		else{
	// 			return 0 + func(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	else if(v[index] < 0){
	// 		if(curr_i >= abs(v[index])){
 
	// 			ll p = 1 + func(v , curr_s , curr_i , index + 1 , dp) ;
	// 			//cout << p << endl  ;
	// 			return p ;
	// 		}
	// 		else{
	// 			return 0 + func(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	return dp[curr_s] = func(v , curr_s , curr_i , index , dp) ;
	// }
 
	// ll func2(vll &v , ll curr_s , ll curr_i , ll index , ll dp[]){
 
	// 	//cout << curr_s << " " << curr_i << " " << index << endl ;
	// 	if(index == v.size()){
	// 		return 0 ;
	// 	}
	// 	if(dp[curr_i] != -1){
	// 		return dp[curr_i] ;
	// 	}
	// 	if(v[index] == 0){
	// 		ll p = max(func2(v , curr_s + 1 , curr_i , index+1 , dp) , func2(v , curr_s , curr_i + 1 , index+1 , dp)) ;
	// 		//cout << p << endl ;
	// 		dp[curr_i] = p ;
	// 		return p ;
	// 	}
	// 	else if(v[index] > 0){
	// 		if(curr_s >= v[index]){
	// 			return 1 + func2(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 		else{
	// 			return 0 + func2(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	else if(v[index] < 0){
	// 		if(curr_i >= abs(v[index])){
 
	// 			ll p = 1 + func2(v , curr_s , curr_i , index + 1 , dp) ;
	// 			//cout << p << endl  ;
	// 			return p ;
	// 		}
	// 		else{
	// 			return 0 + func2(v , curr_s , curr_i , index + 1 , dp);
	// 		}
	// 	}
	// 	return dp[curr_i] = func2(v , curr_s , curr_i , index , dp) ;
	// }
	bool cmp2(pair<ll,ll>&p1 , pair<ll,ll>&p2){
		
 
					if(min(p1.first , p1.second) < min(p2.first , p2.second)){
						return true ;
					}
					else if(min(p1.first , p1.second) == min(p2.first , p2.second)){
						return max(p1.first , p1.second) <= max(p2.first , p2.second) ;
					}
					return false ;
				}
 
 
ll swapCount = 0;
 
void merge(vector<ll>& arr, ll left, ll mid, ll right) {
    ll n1 = mid - left + 1;
    ll n2 = right - mid;
 
    // Create temp vectors
    vector<ll> L(n1), R(n2);
 
    // Copy data to temp vectors L[] and R[]
    for (ll i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (ll j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];
 
    ll i = 0, j = 0;
    ll k = left;
 
    // Merge the temp vectors back into arr[left..right]
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            swapCount += (n1 - i); // Count the swaps
            j++;
        }
        k++;
    }
 
    // Copy the remaining elements of L[], if there are any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
 
    // Copy the remaining elements of R[], if there are any
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
 
ll mergeSort(ll left, ll right , ll p , ll sum) {
	cout << left << " " << right << " " << sum << endl ;
 
    ll mid = (right + left)/2 ;
 
    if(((right - left + 1)/2) < p){
    	if((right - left + 1)%2 != 0){
    		return sum + mid ;
    	}
    	return sum ;
    }
    else if((right - left + 1)%2 == 0){
    	sum = mergeSort(left, mid , p , sum);
    	sum = mergeSort(mid + 1, right , p , sum);	
    }
    else{
    	sum = mergeSort(left, mid - 1 , p , sum + mid);
    	sum = mergeSort(mid + 1, right , p , sum);
    }
    //cout << sum << endl ;
    
    return sum ;
}
 
bool cmp(pair<ll,ll> &p1 , pair<ll,ll> &p2){
	if(p1.second < p2.second){
		return true ;
	}
	else{
		return false ;
	}
}
// k
 
vll Djakstras(ll a , vll adj[] , ll num_vertices){ // a is the source vertex
 
	ll n = num_vertices ;
	ll vis[n+1] ;
	for(ll i = 1 ; i < n+1 ; i++){
			vis[i] = INT_MAX ;
		}
		
 
	set<pair<ll,ll>> s ;
	s.insert({0 , a}) ;
	vis[a] = 0 ;
 
		while(s.size() != 0){
			ll node = (*s.begin()).second ;
			ll dist = (*s.begin()).first ;
			s.erase(s.begin()) ;
			for(auto it : adj[node]){
				if(dist + 1 < vis[it]){
					vis[it] = dist + 1 ;
					s.insert({dist + 1 , it}) ;
				}
			}
 
		}
 
	vll v ;
	for(ll i = 1 ; i <= n ; i++){
		v.pb(vis[i]) ;
	}
	return v ;
 
}

// vector<vector<ll>> Djakstras_counter(ll start_x , ll start_y , map<pair<ll,ll> , vector<pair<ll,ll>>> &mp){
// 	vector<vector<pair<ll,ll>>> v ;
// 	for(ll i = 0 ; i < n ; i++){
// 		vector<pair<ll,ll>> v1 ;
// 		for(ll j = 0 ; j < m ; j++){
// 			v1.pb({INT_MAX , 0}) ;
// 		}
// 		v.pb(v1) ;
// 	}
// 	set<pair<pair<ll,pair<ll,ll>> ,pair<char,ll>>> S;
// 	pair<ll,pair<ll,ll>> P ;
// 	P.make_pair({0 , {start_x , start_y}}) ;
// 	pair<char , ll > P2 ;
// 	P2.make_pair({'S' , 0}) ;
// 	v[start_x][start_y] = {0 , 0} ;

// 	S.insert({P , P2}) ;

// 	while(S.size() > 0){
// 		pair<ll,ll> node = *S.begin().first.second;
// 		ll dist = *S.begin().first.first ;
// 		pair<char,ll> Prev_dir = *S.begin().second ;

// 		S.erase(S.begin()) ;

// 		for(auto it : mp[node]){
// 			char direction ;
// 			ll new_dist = dist + 1 ;
// 			ll direction_dist ;
// 			pair<ll,ll> neighbour = it ;
// 			if(node.first == it.first + 1){
// 				direction = 'L' ;
// 			}
// 			if(node.first == it.first - 1){
// 				direction = 'R' ;
// 			}
// 			if(node.second == it.second + 1){
// 				direction = 'D' ;
// 			}
// 			if(node.second == it.second + 1){
// 				direction = 'U' ;
// 			}

// 			if(direction == Prev_dir.first){
// 				if(Prev_dir.second == 3){
// 					new_dist += 2 ;
// 					direction_dist = 1 ;
// 				}
// 				else{
// 					direction_dist = Prev_dir + 1 ;
// 				}
// 			}
// 			else{
// 				direction_dist = 1 ;
// 			}

// 			if(new_dist < v[it.first][it.second].first){

// 			}
// 		}
// 	}
// }

ll dfs(set<ll> adj[] , ll source , ll count , vll &v){
	adj[v[source - 1]].erase(source) ;
	cout << source  << " " << v[source - 1] << endl ;

	if(adj[v[source - 1]].size() == 0){
		return dfs(adj , v[source - 1] , count + 1 , v) ;
	}
	return count ;
}

ll bfs(ll vis[] , vector<ll> adj[] , ll source){
	queue<ll> q ;
	vis[source] = 1 ;
	ll component_size = 1 ;
	q.push(source) ;

	while(q.size() != 0){
		ll node = q.front() ;
		q.pop() ;
		for(auto it : adj[node]){
			if(vis[it] == -1){
				q.push(it) ;
				vis[it] = 1 ;
				component_size++ ;
			}
		}
	}
	return component_size ;
}

ll bfs_chec(vector<ll> adj[] , ll vis[] , ll source , ll target){
	queue<ll> q ;
	q.push(source) ;
	vis[source] = 1 ;

	while(q.size() != 0){
		ll node = q.front() ;
		q.pop() ;

		for(auto it : adj[node]){
			if(vis[it] == -1){
				q.push(it) ;
				vis[it] = 1 ;
			}
		}
	}
	if(vis[target] == 1){
		return 1 ;
	}
	else{
		return 0 ;
	}
}
 
void solve(ll P) {
	ll n ;
	cin >> n ;

	vll v = input_vec(n) ;
	vector<pair<ll,ll>> vp ;

	vll curr ;
	for(ll i = n ; i >= 1 ; i--){
		curr.pb(i) ;
	}

	//print_vec(curr) ;
	for(ll i = 1 ; i <= n - 1 ; i++){
		for(ll j = i + 1 ; j <= n ; j++){
			vp.pb({j , i}) ;
		}
	}

	for(ll i = 0 ; i < n ; i++){
		ll num = v[i] ;
		ll index ;

		// Search the index of num ;
		for(ll j = 0 ; j < n ; j++){
			if(num == curr[j]){
				index = j ;
				break ;
			}
		}

		for(ll j = index ; j > i ; j--){
			vp.pb({curr[j] , curr[j-1]}) ;
			ll temp = curr[j] ;
			curr[j] = curr[j-1] ;
			curr[j-1] = temp ; 
		}
		//print_vec(curr) ;
	}
	cout << vp.size() << endl ;
	for(auto it : vp){
		cout << it.first << " " << it.second << endl; 
	}


 }

 
 
	 	
	 
	 	 
				int main(){
					// SeiveAlgo() ;
							
					// lp[1] = 1 ;
					ios_base::sync_with_stdio(false);
					cin.tie(NULL) ;
			 
					ll t = 1;
					;
						
					ll p = 1 ;
	 
					while(t--){
			 
						solve(p);
						p++;
						
					}
				}

Solution 2 (runtime: 218 ms):
#include<bits/stdc++.h>
#define endl '\n'

using namespace std;
typedef long long LL;

void solve()
{
	vector<pair<int,int>> ans;
	int n;cin>>n;
	vector<int> a(n+1,0),b(n+1,0),p(n+1,0);
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
		b[i]=n-i+1;
		p[a[i]]=n-a[i]+1;
	}
	for(int i=n;i>=1;i--)
	{
		for(int j=i-1;j>=1;j--) ans.push_back({i,j});
	}
	for(int i=1;i<=n;i++)
	{
		while(p[a[i]]!=i)
		{
			int tmp=p[a[i]];
			ans.push_back({b[tmp],b[tmp-1]});
			swap(b[tmp],b[tmp-1]);
			swap(p[a[i]],p[b[tmp]]);
		}
	}
	cout<<ans.size()<<endl;
	for(auto i : ans) cout<<i.first<<' '<<i.second<<endl;
}

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

/*
5
3 2 5 4 1

5 4 3 2 1
4 5 3 2 1
4 3 5 2 1


1 2 3 4

1 2 4 3
1 4 2 3
1 2 4 3
1 2 3 4
1 3 2 4
3 1 2 4
3 2 1 4
3 2 4 1
*/