2014 Multi-University Training Contest 5 HDOJ 4911 Inversion_2014 multi-university training contest 5 1005-优快云博客

本文链接：https://blog.youkuaiyun.com/u010084308/article/details/38388841

本文介绍了一种求解序列经过有限次相邻元素交换后逆序数最小化的算法。使用归并排序法实现O(nlogn)的时间复杂度，通过案例演示了如何减少逆序数并给出具体代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

Inversion

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 73 Accepted Submission(s): 26

Problem Description

bobo has a sequence a ₁,a ₂,…,a _n. He is allowed to swap two adjacent numbers for no more than k times.

Find the minimum number of inversions after his swaps.

Note: The number of inversions is the number of pair (i,j) where 1≤i<j≤n and a _i>a _j.

Input

The input consists of several tests. For each tests:

The first line contains 2 integers n,k (1≤n≤10 ⁵,0≤k≤10 ⁹). The second line contains n integers a ₁,a ₂,…,a _n (0≤a _i≤10 ⁹).

Output

For each tests:

A single integer denotes the minimum number of inversions.

Sample Input

Sample Output

1
2

解题思路：

求出序列的逆序数，减去k即为所求结果。这里用O（n2）的算法会超时，我们只能用O(nlogn)的算法，可以用树状数组离散化求解，也可以用归并排序求解，ps：逆序数可能会超int范围。

代码：

#include<iostream>
#include<fstream>
using namespace std;
const int N=500005;
int a[N];
int t[N];
long long sum;
void copy(int *dest,int *src,int b,int e)
{
	while(b<=e)
	{
		dest[b]=src[b];
		b++;
	}
}

void merge(int * a,int b,int m, int e)
{
	int i=b;
	int j=m+1;
	int k=b;
	while((i<=m)&&(j<=e))
	{
		if(a[i]<=a[j])
			t[k++]=a[i++];

		else
		{
			t[k++]=a[j++];
			sum+=(m-i+1);
		}
	}
	while(i<=m)
	{
		t[k++]=a[i++];
	}
	while(j<=e)
	{
		t[k++]=a[j++];
	}
	copy(a,t,b,e);
}

void mergesort(int * a,int i,int j)
{
		if(i>=j)return;
		int m=(i+j)/2;
		mergesort(a,i,m);
		mergesort(a,m+1,j);
		merge(a,i,m,j);
}

int main()
{
	int n, k;
	std::ios::sync_with_stdio(false);
	while(cin>>n>>k)
	{
		sum=0;
		for(int i=0;i<n;i++)
			cin>>a[i];
		mergesort(a,0,n-1);
		sum -= k;
		if(sum < 0) sum = 0;
		cout<< sum <<endl;
	}
	return 0;
}