Inversion count implemented with merge sort

// inversion definition: for an array, if i < j but a[i] > a[j]

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

int min(int a, int b)
{
    return a < b ? a : b;
}

int merge(vector<int> &arry, int start, int mid, int end, vector<int> &backup)
{
    int i = start;
    int j = mid;
    int ret = 0;
    // two subarray: a from index start to mid, b from index mid to end
    // base case: the subarray only have two elements
    if (mid - start == 2 && arry[start] > arry[start + 1])
        ++ret;
    if (end - mid == 2 && arry[mid] > arry[mid + 1])
        ++ret;
    
    for (int idx = start; idx < end; ++ idx)
    {
        if (i < mid && (j >= end || arry[i] < arry[j]))
            backup[idx] = arry[i++];
        else
        {
            backup[idx] = arry[j++];
            if (i < mid)
            {
                // merge and count, if (a[i] > b[j]), then b[j] is inverted with every element left in a
                ret += (mid - i);
            }
        }
    }
    return ret;
}

void mergeSort(vector<int> &arry)
{
    auto n = arry.size();
    vector<int> backup(n);
    for (int width = 1; width <= n; width *= 2)
    {
        for (int i = 0; i < n; i += (width * 2))
        {
            merge(arry, i, min(i + width, n), min(i + (2 * width), n), backup);
        }
        copy(backup.begin(), backup.end(), arry.begin());
    }
}


int inversion_count(vector<int> &arry, vector<int> &backup)
{
    int n = arry.size();
    backup.resize(n);
    int count = 0;
    for (int width = 1; width <= n; width *= 2)
    {
        for (int i = 0; i < n; i += (width * 2))
        {
            count += merge(arry, i, min(i + width, n), min(i + (2 * width), n), backup);
        }
        copy(backup.begin(), backup.end(), arry.begin());
    }
    return count;
}

int main(int argc, const char * argv[]) {
    vector<int> vi {1, 5, 4, 8, 10, 2, 6, 9, 3, 7};
    vector<int> backup;
    int i = inversion_count(vi, backup);
    cout << "Inversion count: " << i << endl;
    cout << "The sorted array: ";
    for (auto a : backup)
        cout << a << " ";
    cout << endl;
    return 0;
}

Reference:

http://www.cs.princeton.edu/~wayne/kleinberg-tardos/pdf/05DivideAndConquerI.pdf

https://en.wikipedia.org/wiki/Merge_sort