Algorytm inwersji

Dzień dobry

Mam problem z poniższym zadaniem. Po wrzuceniu rozwiązania do sprawdzarki "themis" otrzymuje 4 na 7 sprawdzeń pozytywnych. Próby nie zaliczone wyrzucają komunikat "wrong answer"

Treść zadania:

Liczba inwersji w permutacji
Problem code: INWERSJE | Time: 4 s | Memory: 16 MB | Solved: no |

Dana jest permutacja czyli n różnych liczb ze zbioru {1,2,...,n}. Oblicz ile znajduje się w niej inwersji, czyli takich par liczb (a, b), że: a > b oraz w danej permutacji liczba a znajduje się przed liczbą b.

Wejście
W pierwszym wierszu wejścia znajduje się liczba n (1 ≤ n ≤ 10^6). W drugim wierszu znajduje się dana permutacja w postaci n liczb oddzielonych pojedynczym odstępem.

Wyjście
Twój program powinien wypisać tylko liczbę inwersji w danej permutacji.

Przykład
Dla danych wejściowych

6
4 3 1 6 5 2
poprawną odpowiedzią jest
8

Mój kod:

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

int _mergeSort(int arr[], int temp[],int left, int right);
int merge(int arr[], int temp[], int left,int mid, int right);

int mergeSort(int arr[], int array_size)
{
    int temp[array_size];
    return _mergeSort(arr, temp, 0, array_size - 1);
}


int _mergeSort(int arr[], int temp[],int left, int right)
{
    int mid, inv_count = 0;
    if (right > left)
    {
        mid = (right + left) / 2;
        inv_count += _mergeSort(arr, temp,left, mid);
        inv_count += _mergeSort(arr, temp,mid + 1, right);
        inv_count += merge(arr, temp, left,mid + 1, right);
    }
    return inv_count;
}


int merge(int arr[], int temp[], int left,int mid, int right)
{
    int i, j, k;
    int inv_count = 0;

    i = left;
    j = mid;
    k = left;
    while ((i <= mid - 1) && (j <= right))
    {
        if (arr[i] <= arr[j])
        {
            temp[k++] = arr[i++];
        }
        else
        {
            temp[k++] = arr[j++];
            inv_count = inv_count + (mid - i);
        }
    }


    while (i <= mid - 1)
        temp[k++] = arr[i++];

    while (j <= right)
        temp[k++] = arr[j++];

    for (i = left; i <= right; i++)
        arr[i] = temp[i];

    return inv_count;
}


int main()
{
    int n;
    scanf("%d", &n);
    int* arr = new int[n];
    for (int i = 0; i < n; i++)
        scanf("%d", &arr[i]);
    int ans = mergeSort(arr, n);
    cout << ans;
    return 0;
}

Wydaje mi się, że nie przetestowałeś przypadków granicznych. Dla dużego n i w odpowiednim układzie liczba inwersji może być większa niż zakres int'a. Prawdopodobnie musisz użyć innego typu zmiennych, aby obsłużyć wszystkie możliwe sytuacje.

Dzięki za naprowadzenie. Użycie long long pomogło.