P1966 火柴排队（离散化，树状数组求逆序对）

P1966 火柴排队

题目描述

给定两列元素个数都为$n$的数列，每次只能交换同一序列的相邻两数，同一序列的任两数互不相同. 求最小交换次数$ans$，使得$\sum {\left(a_i-b_i\right)}^2$最小.

题目分析

我们不妨展开$\sum {\left(a_i-b_i\right)}^2$，得到

$$\sum a_i^2+\sum b_i^2-2\ast \sum a_i{b}_i$$

显然$\sum {\left(a_i-b_i\right)}^2$最小，当且仅当$2\ast \sum a_i{b}_i$取最大值，因为$\sum a_i^2+\sum b_i^2$的值总是一定的.

由数学中排序不等式的相关知识，我们知道：正序和>乱序和>逆序和，所以要求$2\ast \sum a_i{b}_i$取最大值，$a_i,b_i$的大小就要一一对应，即大对应大，小对应小.

也就是说，对$a$和$b$排序后的一组$(a_i,b_i)$也必须在交换后的序列中一一对应.

那么，现在问题就转化为求使得$a_i,b_i$能够按大小对应的最小交换次数.

难题来了，怎么求呢？

不妨设一个抽象的辅助数组 $c$，一般形式为$c_{a_i.rank}=b_i.rank$（ c [ a[i].rank ] = b[i].rank ，已排序）

用于求$c_i\ne i\Rightarrow c_i=i$的最小交换次数.

那么我们为什么可以这样实现呢？

首先，排序后可以保证同位相对，而$rank$表示的是在原数组中的位置.

我们知道，如果以其中某一个数列为参照物（这里选取$a$；也可以说成是以某一个数列为关键词）对另外一个数列进行排序，那么实际体现在操作中是被排序序列中的元素位置最终变得与参照序列中对应元素的位置一致.

• 注意以上参照序列和被排序序列都是指原序列，之前所述排序操作只是为了找出对应关系（这就是用$rank$的原因）.

即从$c_{b_i}\ne a_i$变成$a_i=b_i,c_{b_i}=a_i$的过程，即数组$c$体现的是被排序序列中的元素的原位以参照序列为参照形成的序列.

也就是说，对$c$的排序体现的就是被排序序列中的元素由原位到应该在的位置的过程.

又因为每次只能对一个序列中两相邻的元素进行交换，所以最小交换次数即为逆序对数.

如：
768 233 401 582 581
8 114 46 587 211
整理得：
5 1 2 4 3
1 3 2 5 4
p数组：
3 2 4 5 1

树状数组求逆序对

参考资料

树状数组求逆序对主要有两个操作：

其一是对数进行离散化；

其二是维护树状数组本身.

离散化的目的，是为了得出数之间的相对关系，便于在排序后建树；维护树状数组可以加快求逆序对的数目.

具体操作是，我们先对数由大到小排序，相同大小则由地址后到地址前排序（到时候add进树时就不会误判为大于相同大小而位置靠后的数了），然后建树（指定元素+1），查询（1到这个数的前一个位置目前共有多少数），完结撒花.

#include<bits/stdc++.h>
#define ll long long
#define maxn 500010
using namespace std;
struct number{
	ll key,rank;
}num[maxn];
int n;
ll tree[maxn];//tree相当于原数组，元素插入tree的过程实际上是模拟元素由大到小进入原数组的过程
int lowbit(int x){return x&(-x);}
void add(ll x,ll k){
	for(int i=x;i<=n;i+=lowbit(i))tree[i]+=k;
}
ll query(ll x){
	ll ret=0;
	for(int i=x;i;i-=lowbit(i))ret+=tree[i];
	return ret;
}
bool cmp(number a,number b){
	if(a.key ==b.key )return a.rank>b.rank ;//注意大小相同，位置靠后的先进树
	return a.key>b.key ;
}
ll ans;
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%lld",&num[i].key );
		num[i].rank =i;
	}
	sort(num+1,num+n+1,cmp);
	for(int i=1;i<=n;i++){
		add(num[i].rank ,1);//1表示有这一位一个数比后面的数大
		ans+=query(num[i].rank -1);//到当前元素位置的前一个
	}
	printf("%lld\n",ans);
	return 0;
}

代码出自P1908 逆序对

注意：tree相当于原数组，元素插入tree的过程实际上是模拟元素由大到小进入原数组的过程

程序实现

#include<bits/stdc++.h>
#define ll long long
#define maxn 100010
#define mod 99999997
using namespace std;
struct number{
	ll key,rank;
}a[maxn],b[maxn],c[maxn];
bool cmp(number x,number y){
	//if(x.key ==y.key )return x.rank <y.rank;如果没说互不相同则加上这一句
	return x.key <y.key ;
}
bool cmp_(number x,number y){
	return x.key >y.key ;
}
int n;
ll ans,tree[maxn];
int lowbit(int x){return x&(-x);}
void add(ll x,ll k){
	for(ll i=x;i<=n;i+=lowbit(i))tree[i]=(tree[i]+k)%mod;
}
ll query(ll x){
	ll ret=0;
	for(int i=x;i;i-=lowbit(i))ret=(ret+tree[i])%mod;
	return ret;
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%lld",&a[i].key );
		a[i].rank =i;
	}
	for(int i=1;i<=n;i++){
		scanf("%lld",&b[i].key );
		b[i].rank =i;
	}
	sort(a+1,a+n+1,cmp);
	sort(b+1,b+n+1,cmp);
	for(int i=1;i<=n;i++){
		c[a[i].rank ].key =b[i].rank ;
		c[a[i].rank ].rank =a[i].rank ;
	}
	//for(int i=1;i<=n;i++)printf("%d\n",c[i].key );
	sort(c+1,c+n+1,cmp_);
	for(int i=1;i<=n;i++){
		add(c[i].rank ,1);
		ans=(ans+query(c[i].rank -1))%mod;
	}
	printf("%lld\n",ans);
	return 0;
}

题后总结

$1.$ 题目细节多多，审题务必细心. 比如说 “每次只能交换同一序列的相邻两数" 和 “同一序列的任两数互不相同”，只要有一个没审好就做不出来.

$2.$ 虽说是树状数组求逆序对的题目，但是更重要的是建模. 尤其是$c$数组怎么想的问题，值得思考和在以后的题目中实践. 想明白这种比较抽象的东西，是很考验脑力的……从此就有了乱序排序的经验了.

$3.$ 遇上这种求和式、表达式，一是看能不能转换成既定定理，二是展开或者分解看看有没有什么规律. 这道题属于第二种，即展开求和式发现可以使用排序不等式，从而得出算法.

upd 19.11.6：可以对上面的排序这样理解：原本第一组火柴的第a位，现在在第二组火柴中是第b位，我们如果要让第一组火柴的各个位置匹配到他们在第二组火柴的位置，就得把这个序列恢复成在顺序的形式，而我们只能两两交换，所以需要求逆序对数.

举个栗子
第一组火柴：1 3 2 4，第二组火柴：2 1 3 4
按照如上程序中的排序方式得到的数列：2 3 1 4，其中每个数都表示对于第一组第a个火柴，其在第二组火柴中的位置为b，
我们如果要让第一组火柴的每一位都和第二组火柴的每一位一样，则第一组火柴的第a位应该换到第b位上，也就是应该让数列变成1 2 3 4的样子
由于只能两两交换，所以需要求数列的总的逆序对数.