逆序对与树状数组→P1966 火柴排队（思路整理）

刷题的时候现场手切了这道题，但是是在知道这道题用到逆序对的前提下（水的，整理一下思路

题目看完后感觉在写cf，需要一点思维，我在这里使用了离散化，思路如下

假设有一个样例      1 3 4 2 和 1 7 2 4，我们是要求每一个位置对应都是两个数组钟同样的第k大，这样算出来最后∑(ai​−bi​)2会最小（codeforces练多了的数学直觉，想要证明可以去题解去看看）

这样以来，我先对第一个数组进行操作，我用1 2 3 4来分别代替这个数组中每一个数字。也就是说，我的1代表最小的数字，2代表第3小，3代表第4小的（最大），以此类推，这样构造一个数列，就可以在后面用逆序对的求了。

第二个数组 1 7 2 4→ 1 4 2 3，再用上面那个数组对它操作一下，发现是，1 3 4 2 ，所以实际上就是求1 3 4 2的逆序对个数

一般而言，使用归并或者树状数组（树状数组据说要好一些，建议用），这里写一篇树状数组的实现代码

// Problem: 
//     P1966 [NOIP2013 提高组] 火柴排队
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1966
#include<iostream>
#include<algorithm>
using namespace std;
#define int long long
long long P=1e8-3;  //记得要模1e8-3，不然会WA最后两个点(亲测)
const int N=1e5+100;
struct nodenode{     //用于逆序对，这里不多提
	int val,num;
}nodenodes[N];
struct node{         //用于离散化
	int val,id;
}nodes[N],c[N];
int tree[N];         //树状数组
inline bool cmp1(node a,node b){    
	return a.val<b.val;
}
inline bool cmp2(nodenode a,nodenode b){  
    //这里一定是1 2 3 4，如果有1 2 2 3 4的话还要比较num
	return a.val>b.val;
}
int a[N];//将第i大的记录一个位置,这里的i是第i大，记录的是第i大对应的数字
int d[N];//见后面代码，用于第二个数组的存用
int n;
int lowbit(int x){
	return x & -x;
}
inline void update(int x,int k){
	while(x<=n){
		tree[x]+=k;
		x+=lowbit(x);
	}
}
inline int sum(int x){
	int ans=0;
	while(x){
		ans+=tree[x];
		x-=lowbit(x);
	}
	return ans;
}

signed main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;++i){
		nodes[i].id=i;cin>>nodes[i].val;
	}
	sort(nodes+1,nodes+1+n,cmp1);
	for(int i=1;i<=n;++i){
		a[i]=nodes[i].id;
	}                            //正宗的离散化
	for(int i=1;i<=n;++i){
		cin>>c[i].val;c[i].id=i;
		d[i]=c[i].val;
	}
	sort(c+1,c+1+n,cmp1);
	for(int i=1;i<=n;++i){
		d[c[i].id]=i;
	}
	for(int i=1;i<=n;++i) d[i]=a[d[i]]; //操作第二个数组，使它与第一个数组找到一种关系
	for(int i=1;i<=n;++i) nodenodes[i].num=i,nodenodes[i].val=d[i];//下面就是逆序对的模板啦
	sort(nodenodes+1,nodenodes+1+n,cmp2);
	long long ans=0;
	for(int i=1;i<=n;++i){
		ans=(ans+sum(nodenodes[i].num-1))%P;
		update(nodenodes[i].num,1);
	}
	cout<<ans<<endl;
	
	return 0;
}