信息学奥赛一本通 1876：【13NOIP提高组】火柴排队 | 洛谷 P1966 [NOIP 2013 提高组] 火柴排队

【题目链接】

ybt 1876：【13NOIP提高组】火柴排队
洛谷 P1966 [NOIP 2013 提高组] 火柴排队

【题目考点】

1. 索引排序

2. 归并排序：求逆序对

原理见：洛谷 P1908 逆序对

3. 离散化

【解题思路】

1. 确定配对方案

$a_i$表示第一列火柴中第i个火柴的高度，$b_i$表示第二列火柴中第i个火柴的高度。
该题要在进行最少次交换相邻火柴的操作后，使两列火柴的距离$\sum _{i=1}^n(a_i-b_i{)}^2$最小。

先给出配对方法：
记$a_i$和$b_j$配对为$(a_i,b_j)$
将a、b序列进行升序排序，$a_i$表示a序列第i小的数，$b_i$表示b序列第i小的数，此时$\sum _{i=1}^n(a_i-b_i{)}^2$是最小的。
即a序列中第1小的数$a_1$和b序列中第1小的数$b_1$配对，有$(a_1,b_1)$。
a序列中第2小的数$a_2$和b序列中第2小的数$b_2$配对，有$(a_2,b_2)$。
…
a序列第n小的数$a_n$和b序列中第n小的数$a_n$配对，，有$(a_n,b_n)$。

该配对方法能得到最小的$\sum _{i=1}^n(a_i-b_i{)}^2$。

证明：
假设存在一个任意的配对方案，对所有的配对按照a从小到大排序。假设前i-1个配对都是$a$的第x小的数与$b$的第x小的数进行配对，有$(a_1,b_1)$，$(a_2,b_2)$，…，$(a_{i-1},b_{i-1})$
$a_i$参与的配对是第一个不是形如$(a_x,b_x)$的配对。
设$a_i$与$b_j$配对，有$(a_i,b_j)$，由于$b_1\sim b_{i-1}$都已完成配对，而$a_i$又不能和$b_i$配对，因此$j>i$，所以有$b_j>b_i$。
设$a_k$与$b_i$配对，有$(a_k,b_i)$，由于$a_1\sim a_i$都已完成配对，因此$k>i$，所以有$a_k>a_i$。
当前这两个数对对“火柴距离”的贡献为$(a_i-b_j{)}^2+(a_k-b_i{)}^2$
假设让这两个数对中$b_i$和$b_j$交换，得到$(a_i,b_i)，(a_k,b_j)$两个数对。此时这两个数对对“火柴距离”的贡献为$(a_i-b_i{)}^2+(a_k-b_j{)}^2$。
由于其余配对关系不变，因此将$b_i$和$b_j$交换后的贡献减去交换前的贡献，为火柴距离的变化。
$$\begin{gathered} (a_i-b_i{)}^2+(a_k-b_j{)}^2-(a_i-b_j{)}^2-(a_k-b_i{)}^2 \\ =(a_i-b_i{)}^2-(a_i-b_j{)}^2+(a_k-b_j{)}^2-(a_k-b_i{)}^2 \\ =(a_i-b_i+a_i-b_j)(a_i-b_i-a_i+b_j)+(a_k-b_j+a_k-b_i)(a_k-b_j-a_k+b_i) \\ =(2a_i-b_i-b_j)(b_j-b_i)+(2a_k-b_i-b_j)(b_i-b_j) \\ =(2a_i-b_i-b_j)(b_j-b_i)-(2a_k-b_i-b_j)(b_j-b_i) \\ =(2a_i-b_i-b_j-2a_k+b_i+b_j)(b_j-b_i) \\ =2(a_i-a_k)(b_j-b_i) \end{gathered}$$
因为$a_k>a_i$，所以$a_i-a_k<0$。
因为$b_j>b_i$，所以$b_j-b_i>0$。
因此$2(a_i-a_k)(b_j-b_i)<0$
将$b_i$和$b_j$交换后，火柴距离会减小，为了得到最小的火柴距离，可以将二者交换。
完成交换后，有配对$(a_1,b_1)，...，(a_i,b_i)$。
不断重复上述过程，每次交换都可以使得火柴距离$\sum _{i=1}^n(a_i-b_i{)}^2$减小，同时形如$(a_x,b_x)$的配对增加，最后得到的配对方案为$(a_1,b_1),...,(a_n,b_n)$

2. 实现配对方案

解法1：离散化

要想进行最少的交换，完成配对方案$(a_1,b_1),...,(a_n,b_n)$。
可以先将a序列和b序列离散化，离散化后a、b都是由$1\sim n$组成的序列。
记a序列中数值i的下标为$ind{A}_i$，由于a序列中数值$a_i$的下标为i，所以$ind{A}_{a_i}=i$
在b序列中数值$i$的下标为$ind{B}_i$，由于b序列中数值$b_i$的下标为i，所以$ind{B}_{b_i}=i$。
那么设数组$x$，$x_i$表示b序列中第$i$个数$b_i$在a序列中的下标，即$x_i=ind{A}_{b_i}$
需要在经过多次交换相邻元素后，$b$序列和$a$序列相同，即$b_i=a_i$。
此时$x_i=ind{A}_{b_i}=ind{A}_{a_i}=i$，表示$b$序列中第$i$个数在$a$序列中的下标为$i$。

证明：交换$b$序列中相邻元素，最多会减少1对$x$序列中的逆序对。

设当前配对有$(a_i,u)$与$(a_{i+1},v)$
其中$u$为$b$序列第i个数，$v$为b序列第i+1个数
此时$x_i=ind{A}_u$，$x_{i+1}=ind{A}_v$
交换b中第i个数和第i+1个数，得到数对$(a_i,v)$与$(a_{i+1},u)$
此时$x_i=ind{A}_v$，$x_{i+1}=ind{A}_u$
因此交换$b$序列中相邻元素相应地会交换$x$序列中的相邻元素。
交换$x$序列中的一对相邻元素最多会减少一对x序列中的逆序对。
因此交换$b$序列中相邻元素，最多会减少1对$x$序列中的逆序对。

证明：交换$a$序列中相邻元素，最多会减少1对$x$序列中的逆序对。

设当前配对有$(u,b_i)$，$(v,b_{i+1})$，$(a_j,u)$，$(a_k,v)$
其中$u$为$a$序列第i个数，$b$序列第j个数。 $v$为a序列第i+1个数，$b$序列第k个数。
此时$x_j=i,x_k=i+1$
交换a序列中第i个数和第i+1个数，得到数对$(v,b_i),(u,b_{i+1})$
此时$x_j=i+1,x_k=i$
相当于将$x_j$与$x_k$交换。
如果$j<k$，数对$(x_j,x_k)$构成的数对从$(i,i+1)$，变为$(i+1,i)$，增加了一个逆序对。
如果$j>k$，数对$(x_k,x_j)$构成的数对从$(i+1,i)$，变为$(i,i+1)$，减少了一个逆序对。
对于由$x_k、x_j$二者之一与其他数构成的数对，
由于$x_j$与$x_k$是相邻的两个整数，原来大于或小于$x_j$（或$x_k$）的数在$x_j、x_k$交换后也仍然会大于或小于$x_j$（或$x_k$），所以逆序对数量不变。
因此交换$a$序列中相邻元素，最多会减少1对$x$序列中的逆序对。

要让$x$从初始序列变为$x_i=i$，这是对$x$序列的排序过程。通过交换$a$序列或$b$序列中相邻元素来减少$x$序列中的逆序对，直到$x$序列变为升序序列。
那么$a$序列或$b$序列中交换相邻元素的最少次数为$x$序列中逆序对的数量。
可以使用归并排序方法求$x$序列中的逆序对数量，时间复杂度为$O(n\log n)$。

由于序列长度n为$10^5$，逆序对的数量为$n^2$量级，最大为$10^{10}$，可以使用long long类型变量保存逆序对数量，最后再对$10^8-3$取模。

解法2：索引数组

上述方法中使用离散化的方法将$a$序列中第i小的数与$b$序列中第i小的数转化为相同的数值i，而后再进行分析。
其实并不需要真的确定$a$、$b$序列第i小的数的数值。
可以在概念上去考虑使用$a$、$b$序列第$i$小的数，在代码中使用索引数组实现。
假设$a$序列排序后为序列$ta$，$t{a}_i$为$a$序列第i小的数。
$a$序列的索引数组为$indA$，$ind{A}_i$为$t{a}_i$在$a$序列中的下标，即$t{a}_i=a_{ind{A}_i}$。
假设$b$序列排序后为序列$tb$，$t{b}_i$为$b$序列第i小的数。
$b$序列的索引数组为$indB$，$ind{B}_i$为$t{b}_i$在$b$序列中的下标，即$t{b}_i=b_{ind{B}_i}$。
设数组$x$，$x_i$表示b序列中第$i$个数$b_i$在a序列中对应元素的下标。
b中第k小元素为：$t{b}_k=b_{ind{B}_k}$，
a中第k小元素为：$t{a}_k=a_{ind{A}_k}$。
$b_{ind{B}_k}$与$a_{ind{A}_k}$对应，因此$x_{ind{B}_k}=ind{A}_k$
本方法中$x$数组的概念和解法1中$x$数组的概念一致，因此最终结果仍然是求$x$数组的逆序对数量。

【题解代码】

解法1：离散化

#include<bits/stdc++.h>
using namespace std;
#define N 100005
const int M = 1e8-3;
int n, a[N], b[N], ind_a[N], t[N], x[N];
long long revNum;
void discretization(int *d, int n)//将传入的数组d中的数值离散化 
{
	vector<int> u(d+1, d+1+n);//复制d中元素到u中 
	sort(u.begin(), u.end());//没有重复元素 不需要去重
	for(int i = 1; i <= n; ++i)
		d[i] = upper_bound(u.begin(), u.end(), d[i])-u.begin();//离散化为1~n 
}
void mergeSort(int *a, int l, int r)//归并求a数组的逆序对 
{
	if(l >= r)
		return;
	int mid = (l+r)/2;
	mergeSort(a, l, mid);
	mergeSort(a, mid+1, r);
	int i = l, j = mid+1, k = l;
	while(i <= mid && j <= r)
	{
		if(a[i] > a[j])
		{
			t[k++] = a[j++];
			revNum += mid-i+1;
		}
		else
			t[k++] = a[i++];
	}
	while(i <= mid)
		t[k++] = a[i++];
	while(j <= r)
		t[k++] = a[j++];
	for(i = l; i <= r; ++i)
		a[i] = t[i];
}
int main()
{
	cin >> n;
	for(int i = 1; i <= n; ++i)
		cin >> a[i];
	for(int i = 1; i <= n; ++i)
		cin >> b[i];
	discretization(a, n);
	discretization(b, n);
	for(int i = 1; i <= n; ++i)
		ind_a[a[i]] = i;//ind_a[i]：数值i在a中的下标 
	for(int i = 1; i <= n; ++i)
		x[i] = ind_a[b[i]];//x[i]：b中第i个数b[i]在a中的下标
	mergeSort(x, 1, n);//求x数组逆序对数量 
	cout << revNum%M;
	return 0;
}

解法2：使用索引数组

#include<bits/stdc++.h>
using namespace std; 
#define N 100005 
const int M = 1e8-3;
int a[N], b[N], n, ind_a[N], ind_b[N], x[N], t[N];
long long revNum;
bool cmp_a(int x, int y)
{
	return a[x] < a[y];
}
bool cmp_b(int x, int y)
{
	return b[x] < b[y];
}
void mergeSort(int *a, int l, int r)
{
	if(l >= r)
		return;
	int mid = (l+r)/2;
	mergeSort(a, l, mid);
	mergeSort(a, mid+1, r);
	int i = l, j = mid+1, k = l;
	while(i <= mid && j <= r)
	{
		if(a[i] > a[j])
		{
			t[k++] = a[j++];
			revNum += mid-i+1;
		}
		else
			t[k++] = a[i++];
	}
	while(i <= mid)
		t[k++] = a[i++];
	while(j <= r)
		t[k++] = a[j++];
	for(i = l; i <= r; ++i)
		a[i] = t[i];
}
int main()
{
	cin >> n;
	for(int i = 1; i <= n; ++i)
	{
		cin >> a[i];
		ind_a[i] = i;
	}
	for(int i = 1; i <= n; ++i)
	{
		cin >> b[i];
		ind_b[i] = i;
	}
	sort(ind_a+1, ind_a+1+n, cmp_a);
	sort(ind_b+1, ind_b+1+n, cmp_b); 
    for(int i = 1; i <= n; ++i)
    	x[ind_b[i]] = ind_a[i];
    mergeSort(x, 1, n);
    cout << revNum%M;
	return 0;
}