for (int j = 0; j < record.length-1; j++) {
    for (int i = j+1; i < record.length; i++) {
        if (record[j] > record[i]) {
            result += 1;
        }
    }
}

class Solution {
  // 主函数，用于计算数组中的逆序对数量
  // 逆序对是指满足 i < j 且 record[i] > record[j] 的下标对 (i, j)
  public int reversePairs(int[] record) {
    // 处理边界情况：如果数组为空或长度小于2，则没有逆序对，返回0
    if (record == null || record.length < 2) return 0;
    // 调用归并排序函数，处理整个数组（从索引0到length-1）
    return mergeSort(record, 0, record.length - 1);
  }

  // 递归的归并排序函数，通过分治法分割数组并统计逆序对
  // 参数：record（数组），left（子数组起始索引），right（子数组结束索引）
  private int mergeSort(int[] record, int left, int right) {
    // 基本情况：如果子数组长度为0或1（left >= right），没有逆序对，返回0
    if (left >= right) return 0;

    // 计算中间索引，将数组分成两半
    // 使用 left + (right - left) / 2 避免整数溢出，而不是 (left + right) / 2
    int mid = left + (right - left) / 2;

    // 递归计算左半部分（left到mid）和右半部分（mid+1到right）的逆序对
    // 总逆序对数 = 左半部分逆序对 + 右半部分逆序对 + 合并过程中的逆序对
    int count = mergeSort(record, left, mid) + mergeSort(record, mid + 1, right);

    // 在合并两个子数组时统计逆序对并完成合并
    count += merge(record, left, mid, right);

    // 返回当前子数组的逆序对总数
    return count;
  }

  // 合并函数，用于合并两个已排序的子数组并统计逆序对
  // 参数：record（数组），left（左子数组起始索引），mid（左子数组结束索引），right（右子数组结束索引）
  private int merge(int[] record, int left, int mid, int right) {
    // 创建临时数组存储合并结果，大小为 right - left + 1，包含整个子数组范围
    int[] temp = new int[right - left + 1];

    // 初始化逆序对计数器
    int count = 0;

    // 初始化指针：
    // i：指向左子数组 [left, mid] 的当前元素
    // j：指向右子数组 [mid+1, right] 的当前元素
    // k：指向临时数组的当前填充位置
    int i = left, j = mid + 1, k = 0;

    // 合并两个子数组并同时统计逆序对
    while (i <= mid && j <= right) {
      // 如果左子数组当前元素小于或等于右子数组当前元素
      // 没有逆序对，将左子数组元素放入临时数组，移动i指针
      if (record[i] <= record[j]) {
        temp[k++] = record[i++];
      } else {
        // 如果 record[i] > record[j]，发现逆序对
        // 由于左子数组已排序，从i到mid的所有元素都大于record[j]
        // 因此逆序对数量为 mid - i + 1
        count += mid - i + 1;
        // 将右子数组元素放入临时数组，移动j指针
        temp[k++] = record[j++];
      }
    }

    // 将左子数组剩余元素复制到临时数组
    // 这些元素已经按顺序，无需额外处理
    while (i <= mid) {
      temp[k++] = record[i++];
    }

    // 将右子数组剩余元素复制到临时数组
    // 这些元素也已按顺序
    while (j <= right) {
      temp[k++] = record[j++];
    }

    // 将临时数组中的合并结果复制回原数组，从left开始
    // 确保原数组在[left, right]范围内保持排序
    System.arraycopy(temp, 0, record, left, temp.length);

    // 返回本次合并过程中发现的逆序对数量
    return count;
  }
}