【hihocoder】1141 : 二分·归并排序之逆序对

题目链接：http://hihocoder.com/problemset/problem/1141
题目：

我们可以看到，船默认排序是以等级为参数。但实际上一个船的火力值和等级的关系并不大，所以会存在A船比B船等级高，但是A船火力却低于B船这样的情况。比如上图中77级的飞龙改二火力就小于55级的夕立改二。
现在Nettle将按照等级高低的顺序给出所有船的火力值，请你计算出一共有多少对船满足上面提到的这种情况。

提示：火力高才是猛！

输入

第1行：1个整数N。N表示舰船数量, 1≤N≤100,000
第2行：N个整数，第i个数表示等级第i低的船的火力值a[i]，1≤a[i]≤2^31-1。

输出

第1行：一个整数，表示有多少对船满足“A船比B船等级高，但是A船火力低于B船”。

思路：

求逆序数对的个数。   利用归并排序的思想，在merge阶段时 左右子段都是有序的。

想了一下还是举个栗子来说吧，比如 当（1,3,4,7,9）是左半段，（2,5,8）是右半段，将两段merge

右段2来说，左段包括3，及3以后的所有数都是逆序的，所以2可以和 3,4,7,9构成逆序对。 以此类推：

3,4,7,9->2  该逆序对的长度是3的下标到9下标的长度即mid-i+1

7,9->5

9->8

共4+2+1=7个逆序对。

————————————

想ac还得过两个坑：count如果用int可能会溢出，要用long或其他；不要分配用不到的数组空间，分配数组空间是需要耗费时间的，如果在merge的时候暂存有序数组分配一个长度为(以代码中数组a为例) a.length，实际只需要right-left+1的空间，其余空间是用不到的，如果分配多余数组空间，由于耗费时间，会超时。。。而且这个坑还真不容易看出来。。以前以为分配不同size的数组只是耗费空间不同，没想到时间也不同，而且差距还挺大的。

算法：

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Main m = new Main();
		m.handleInput();
	}

	public void handleInput() {
		Scanner in = new Scanner(System.in);
		int len = 0, i = 0;
		len = in.nextInt();
		int nums[] = new int[len];
		while (i < len&&in.hasNext()) {
			nums[i] = in.nextInt();
			i++;
		}
		System.out.println(merge(nums, 0, len - 1));
	}

	public long merge(int a[], int left, int right) {
		if (right <= left)
			return 0;
		int mid = (right + left)>>1;
		
		long count=merge(a, left, mid)+merge(a, mid + 1, right);
		int i = left, j = mid + 1, k =0;
		int n[] = new int[right-left+1];
		while (i <= mid && j <= right) {
			if (a[i] <= a[j]) {
				n[k] = a[i];
				i++;
			} else {
				count+=mid - i + 1;
				n[k] = a[j];
				j++;
			}
			k++;
		}

		while (i <= mid) {
			n[k] = a[i];
			i++;
			k++;
		}

		while (j <= right) {
			n[k] = a[j];
			j++;
			k++;
		}
		k = 0;
		j=left;
		while (k < n.length) {
			a[j++] = n[k++];
		}
		return count;
	}

}