buildHeap

#include <vector>
#include <algorithm>
#include <iostream>
#include <functional>
#include <iterator>

template <typename T>
class Heap
{
public:
    Heap() {}
    Heap(std::vector <T> & other, bool minHeap): v(other), typeHeap(minHeap), size(v.size()) {}
    void buildHeap() {
        for (int i = v.size() /2; i >=0; --i)
            siftDown(i);
    }
    void siftDown(int i) {
        int maxIdx = maxIndex(i);
        while ((maxIdx = maxIndex(i)) != i ) {
            swap(i, maxIdx);
            i = maxIdx;
        }
    }
    void swap(size_t i, size_t j) {
        vlog.push_back({i, j});
        std::swap(v[i], v[j]);
    }
    inline int maxIndex(int i) {
        int child;
        int m = (child  = 2 * i + 1) >= size ? i : f(v[i], v[child])  ? i : child;
        m = (child  = 2 * i + 2) >= size ? m : f(v[m], v[child])  ? m : child;
        return m;
    }

std::vector <T> & v;
std::vector <std::pair<size_t, size_t>> vlog;
bool typeHeap;
int size;

bool f(T &l, T & r) {
    return  typeHeap ? l <= r : r <= l;
}

};

using namespace std;

int main()
{
    size_t n;
    std::cin >> n;
    std::vector <double> v(n) ;
    std::copy_n(std::istream_iterator<double>(std::cin), n, v.begin());

    Heap <double>heap {v, true};
    heap.buildHeap();

    std::cout << heap.vlog.size() << "\n";
    for (const auto & x: heap.vlog) {
        std::cout << x.first << " " << x.second << "\n";
    }

    return 0;
}