C++ 数组中的反转计数数。使用合并排序

对于那些不知道反转的人

倒置-

给定一个由N个整数组成的数组A，数组的反转被定义为任意一对索引（i，j），使得iA[j]

简而言之：

{inv}（A）={（A（i），A（j）），iA（j）}

例如，数组a={2,3,1,5,4}对于条目对（2,1）、（3,1）、（5,4），有三个反转：（1,3）、（2,3）、（4,5）

总反转计数=3

我试图通过使用标准的合并排序来解决这个问题。 以下是我认为它的工作原理

假设在某个阶段，合并排序的partA和partb是

第A部分-[1,2,3]

B部分-[4,5]

现在，让X成为第一个数组partA的元素。Y代表第二个数组，partB

如果将X复制到输出数组（即，如果X 如果Y被复制到输出数组，则为Else（即，如果X>Y）。 然后我们有反转计数=计数+中间-i+1。（i为该元素的位置）。当按递增顺序排序时，位置j>i，X[j]>Y处的所有元素

下面是代码和详细信息

#include <iostream>
#include <vector>
using namespace std;

vector<int> a;
vector<int> c;
void merge(int low, int high, int mid);
void mergesort(int low, int high)
{
 int mid;
 if (low < high)
 {
     mid=(low+high)/2;
     mergesort(low,mid);
     mergesort(mid+1,high);
     merge(low,high,mid);
 }
return ;
}

int count ; //to store the inversion count
void merge(int low, int high, int mid)
{
int i, j, k;
i = low;
k = low;
j = mid + 1;
// standard merging from merge sort
while (i <= mid && j <= high)
{
    if (a[i] < a[j])
    {
        c[k] = a[i];
        k++;
        i++;
    }
    else
    {
        c[k] = a[j];
        k++;
         j++;
      //   cout<<a[i]<<" "<<mid<<" "<<i<<"\n";
         count += mid - i+1; // This is where the trick occurs, if X > Y,
         //eg. in [3, 4, 5] and [1,2]
         //if(3>1) then 4,5 is obviously greater then 1, thus making count as mid - i+1              
     }
 }
while (i <= mid)
{
    c[k] = a[i];
    k++;
    i++;
}
while (j <= high)
{
    c[k] = a[j];
    k++;
    j++;
}
for (i = low; i < k; i++)
{
    a[i] = c[i];
 }
}
int main()
{
//int a[20], i, b[20];
int T;
cin>>T;
while(T--){
    //cout<<"enter  the elements\n";
    int N;
    cin>>N;
    count =0;
    a.clear(); a.resize(N);
    c.clear(); c.resize(N);
    for (int i = 0; i < N; i++)
    {
        cin>>a[i];
    }
    mergesort(0, N-1);

    cout<<count<<"\n";
}
}

#包括
#包括
使用名称空间std；
载体a；
载体c；
无效合并（整数低、整数高、整数中）；
无效合并排序（整数低，整数高）
{
int mid；
如果（低<高）
{
中等=（低+高）/2；
合并排序（低、中）；
合并排序（中+1，高）；
合并（低、高、中）；
}
返回；
}
整数计数//存储反转计数
无效合并（整数低、整数高、整数中）
{
int i，j，k；
i=低；
k=低；
j=mid+1；
//从合并排序进行标准合并
虽然（i您的解决方案的问题是结果可能大于整数范围，例如，如果序列为n，n-1，…，1，（不增加），则反转数将为n*（n-1）/2，如果n=2*10^5，则结果将远大于整数范围

因此，将
int count
更改为
long-long count
并

更改此行：

count += mid - i + 1;

进入：

你会得到公认的答案

我的
你对倒装的描述是缺乏的，我不得不查看维基百科页面进行澄清。也许是说，一对索引（I，j），其中Ia[j]谢谢你指出这一点，我已经更新了它。是的，你是对的，我发现了它，并且被接受了，只是懒得在这里发布它。无论如何，谢谢你的详细阐述，可能对其他人有用。还有一件事，我认为对于非递增序列，答案应该是N*（N-1）/2，而不是N*（N+1）/2。例如，如果数组是[5,4,3,2,1]。那么倒数是[{5,4}，{5,3}，{5,2}，{5,1}]-Total=4。[{4,3}，{4,2}，{4,1}]。Total+=3。[{3,2}，{3,1}]。Total+=2{2,1}。Total+=1.4+3+2+1=10，等于，5*（5-1）/2=5*4/2=5=2=10。@3232918。@userright，谢谢你的回答。如果你的问题是正确的话，你也可以接受吗？
count += (long long)mid - (long long) i + 1L;