洛谷 P1966 火柴排队 离散化+归并排序/树状数组

[NOIP2013 提高组] 火柴排队

题目描述

涵涵有两盒火柴，每盒装有 $n$ 根火柴，每根火柴都有一个高度。 现在将每盒中的火柴各自排成一列， 同一列火柴的高度互不相同， 两列火柴之间的距离定义为：$ \sum (a_i-b_i)^2$

其中 $a_i$ 表示第一列火柴中第 $i$ 个火柴的高度，$b_i$ 表示第二列火柴中第 $i$ 个火柴的高度。

每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。请问得到这个最小的距离，最少需要交换多少次？如果这个数字太大，请输出这个最小交换次数对 $10^8-3$ 取模的结果。

输入格式

共三行，第一行包含一个整数 $n$，表示每盒中火柴的数目。

第二行有 $n$ 个整数，每两个整数之间用一个空格隔开，表示第一列火柴的高度。

第三行有 $n$ 个整数，每两个整数之间用一个空格隔开，表示第二列火柴的高度。

输出格式

一个整数，表示最少交换次数对 $10^8-3$ 取模的结果。

样例 #1

样例输入 1

4
2 3 1 4
3 2 1 4

样例输出 1

1

样例 2

样例输入 2

4
1 3 4 2
1 7 2 4

样例输出 2

2

提示

【输入输出样例说明一】

最小距离是$ 0$，最少需要交换 $1$ 次，比如：交换第 $1 $列的前$ 2$ 根火柴或者交换第 $2$ 列的前 $2 $根火柴。

【输入输出样例说明二】

最小距离是 $10$，最少需要交换 $2$ 次，比如：交换第 $1$ 列的中间 $2$ 根火柴的位置，再交换第 $2$ 列中后 $2$ 根火柴的位置。

【数据范围】

对于 $10\%$ 的数据， $1\le n\le 10$；

对于 $30\%$ 的数据，$1\le n\le 100$；

对于 $60\%$ 的数据，$1\le n\le 10^3$；

对于 $100\%$ 的数据，$1\le n\le 10^5$，$0\le$ 火柴高度 $<2^{31}$。

解题

分析

这道题最难的地方是看出来这道题是求逆序对的变式。
逆序对，即满足i < j使得nums[i] > nums[j]的两个数。

那我们来分析一下，这道题为什么是求逆序对
首先，我们很容易知道，当两个数组都满足是增序序列时，两个数列之间的距离一定最短。
但是，我们一定不会把两个序列分别排序，从实例1就可以看出分别排序是不能分开处理的。
那么我们再思考一下，如果我们把两个序列以同样的顺序打乱，这个时候，两个序列之间的距离是不会变的。
再简单一点说，只要满足在A序列中第n大的数与在B序列中第n大的数配对即可。
那么，我们可以将A, B依照一个数列的顺序一一对应，将两个数列打包排序，然后求另一个数列中的逆序对个数即可。

但是数据太大，使用树状数组的话需要离散化，即用数i在数列中是第几大来代替它。
举个例子，我们有数列1e9, 1, 1e-9, 1e3，离散化之后，我们可以用1代替1e-9，用2代替1，用3代替1e3，用4代替1e9

这下来，我们就可以着手寻找逆序对的个数了。
求逆序对的个数一般会使用两种方法：归并排序, 树状数组。
两种方法各有优劣:

• 归并排序相对而言理解较为简单，但是代码实现有点复杂，且空间使用更多。
• 树状数组相反，代码实现简单，空间使用也不多，但是理解比较复杂（主要是因为网上很多资源讲的都不是太清晰，建议线下问同学或导师）。

其实还有一种方法：线段树，与树状数组相似，但是可以处理极差更大的数列，但是实现有点复杂

这里我不详细探讨两个方法的原理，可以参考其他叙述求逆序对个数的博客，或者参考leetcode上的官方题解

顺带说一个教训，结果只要是个数就用long long， 都是坑啊

代码

离散化+线段树

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#include <utility>
#include <algorithm>
#include <iostream>

using namespace std;

#define MAXN 100005
pair<int, int> A[MAXN], B[MAXN], n;
int C[MAXN] = {0};
int BIT[MAXN] = {0};
int lowbit(int i) {
	return i & -i;
}

void update(int i, int k) {
	while (i < MAXN) {
		BIT[i] += k;
		i += lowbit(i);
	}
}

int getsum(int i) {
	int r = 0;
	while (i > 0) {
		r += BIT[i];
		i -= lowbit(i);
	}
	return r;
}

bool cmp(pair<int, int> & a, pair<int, int> & b) {
	return a.first < b.first;
}

int main() {
	int n; scanf("%d", &n);
	
	int tmp;
	for (int i = 0; i < n; i++) {
		scanf("%d", &tmp);
		A[i] = make_pair(tmp, i);
	}
	for (int i = 0; i < n; i++) {
		scanf("%d", &tmp);
		// 这里加一是因为离散化最好不要从0开始记起 
		B[i] = make_pair(tmp, i + 1);
	}
	
	// 按照数在序列中的大小排序
	// 图方便没有手写排序，打包，就用了这种方法 
	sort(A, A + n, cmp);
	sort(B, B + n, cmp);
	
	long long r = 0;
	for (int i = 0; i < n; i++) {
		// 这里是把A数组中第i大的数与B数组中第i大的数配对
		// 但是是以A为基序进行排序 
		C[A[i].second] = B[i].second;
	}

	// 树状数组求逆序对的具体思路可以参考其他人写的博客
	// 篇幅原因(主要是我很懒)所以没有详解	
	for (int i = n - 1; i >= 0; i--) {
		r = (r + getsum(C[i] - 1)) % 99999997;
		update(C[i], 1);
	}
	printf("%ld\n", r);
}

离散化+归并排序

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>

#include <algorithm>
#include <iostream>

using namespace std;

#define MAXN 100005
typedef struct num {
	int v, i;
} num; 

num A[MAXN], B[MAXN];
int C[MAXN];

long long cnt = 0;

// 这里用了动态分配的内存
// 这年头不会还有人看不懂归并排序吧（手动狗头） 
int * mergeSort(int * v, int left, int right) {
	int * ret = (int *)malloc(sizeof(int) * (right - left));
	if (left + 1 == right) {
		ret[0] = v[left];
		return ret;
	}
	
	int mid = (left + right) / 2;
	
	int * l = mergeSort(v, left, mid);
	long long li = 0, le = mid - left;
	int * r = mergeSort(v, mid, right);
	long long ri = 0, re = right - mid;
	
	int i = 0;
	while (li < le && ri < re) {
		if (l[li] <= r[ri]) ret[i++] = l[li++];
		else cnt += le - li, ret[i++] = r[ri++];
	}
	
	while (li < le) ret[i++] = l[li++];
	while (ri < re) ret[i++] = r[ri++];
	
	free(l); free(r);
	
	assert(i == right - left);
	return ret;
}

bool cmp(num & i, num & j) {
	return i.v < j.v;
}

int main() {
	int n; scanf("%d", &n);
	
	int tmp;
	for (int i = 0; i < n; i++) {
		scanf("%d", &A[i].v);
		A[i].i = i;
	}
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &B[i].v);
		B[i].i = i;
	}
	
	sort(A, A + n, cmp);
	sort(B, B + n, cmp);

	for (int i = 0; i < n; i++) {
		C[A[i].i] = B[i].i;
	}

	int * needFree = mergeSort(C, 0, n);
	free(needFree);
	
	cout << cnt % long(1e8 - 3) << endl;
}