Java 求逆的个数

下面是一个算法，它应该使用合并排序查找数组中的反转数。它产生错误的输出，虽然它非常简单，但我看不出它有什么问题。你能帮帮我吗

例如，对于输入1 3 1 2，即perm。它生产39994辆，而不是2辆

/* *
 * INPUT:
 * 1. t : number of test cases; t test cases follow
 * 2. n : number of elements to consider in each test case
 * 3. ar[i] : n numbers, elements of considered array
 * */

import java.util.*;

public class Inversions {

    // Merges arrays left[] and right[] into ar[], returns number of
    // inversions found in the process
    public static long merge(long[] arr, long[] left, long[] right) {
        int i = 0, j = 0;
        long count = 0;
        while (i < left.length || j < right.length) {
            if (i == left.length) {
                arr[i+j] = right[j];
                j++;
            } else if (j == right.length) {
                arr[i+j] = left[i];
                i++;
            } else if (left[i] <= right[j]) {
                arr[i+j] = left[i];
                i++;                
            } else {
                arr[i+j] = right[j];
                // # inv. is curr. size of left array
                count += left.length-i;
                j++;
            }
        }
        return count;
    }

    // Traditional merge sort on arr[], returns number of inversions
    public static long invCount(long[] arr) {
        if (arr.length < 2)
            return 0;

        int m = (arr.length + 1) / 2;
        long left[] = Arrays.copyOfRange(arr, 0, m);
        long right[] = Arrays.copyOfRange(arr, m, arr.length);

        return invCount(left) + invCount(right) + merge(arr, left, right);
    }

    public static void main (String args[]) {
        int t, n;
        long[] ar = new long[20000];
        Scanner sc = new Scanner(System.in);
        t = sc.nextInt();
        while(t-- > 0) {
            n = sc.nextInt();
            for(int i = 0; i < n; i++) {
                ar[i] = sc.nextLong();
            }
            System.out.println(invCount(ar));
        }
    }
}

/**
*输入：
* 1. t：测试用例数；t测试用例如下
* 2. N:每个测试用例中要考虑的元素数
* 3. ar[i]：n个数，所考虑数组的元素
* */
导入java.util.*；
公共类倒置{
//将数组left[]和right[]合并为ar[]，返回
//过程中发现的反转
公共静态长合并（长[]arr，长[]左，长[]右）{
int i=0，j=0；
长计数=0；
而（i

我知道我不是第一个问类似问题的人。我能找到正确的算法。我只是好奇这个有什么问题

---

谢谢！

问题在于，您正在计算长度不是n而是20000的数组中的反转数，并将其扩展为零。解决方法是使数组具有正确的大小：

public static void main(String args[]) {
    int t, n;
    Scanner sc = new Scanner(System.in);
    t = sc.nextInt();
    while (t-- > 0) {
        n = sc.nextInt();
        long[] ar = new long[n];
        for (int i = 0; i < n; i++) {
            ar[i] = sc.nextLong();
        }
        System.out.println(invCount(ar));
    }
}

publicstaticvoidmain（字符串参数[]）{
int t，n；
扫描仪sc=新的扫描仪（System.in）；
t=sc.nextInt（）；
而（t-->0）{
n=sc.nextInt（）；
long[]ar=新长[n]；
对于（int i=0；i

您是否有失败的测试用例？您是否来自coursera的算法类？：）@Davidisenstat我添加了一个。