P1975 [国家集训队]排队 线段树套平衡树维护动态逆序对查询

$ \color{#0066ff}{ 题目描述 }$

排排坐，吃果果，生果甜嗦嗦，大家笑呵呵。你一个，我一个，大的分给你，小的留给我，吃完果果唱支歌，大家乐和和。

红星幼儿园的小朋友们排起了长长地队伍，准备吃果果。不过因为小朋友们的身高有所区别，排成的队伍高低错乱，极不美观。设第i个小朋友的身高为hi，我们定义一个序列的杂乱程度为：满足i<j且hi>hj的(i,j)数量。

幼儿园阿姨每次会选出两个小朋友，交换他们的位置，请你帮忙计算出每次交换后，序列的杂乱程度。为方便幼儿园阿姨统计，在未进行任何交换操作时，你也应该输出该序列的杂乱程度。

\(\color{#0066ff}{输入格式}\)

第一行为一个正整数n，表示小朋友的数量；

第二行包含n个由空格分隔的正整数h1,h2,…,hn，依次表示初始队列中小朋友的身高；

第三行为一个正整数m，表示交换操作的次数；

以下m行每行包含两个正整数ai和bi­，表示交换位置ai与位置bi的小朋友。

\(\color{#0066ff}{输出格式}\)

输出文件共m+1行，第i行一个正整数表示交换操作i结束后，序列的杂乱程度。

\(\color{#0066ff}{输入样例}\)

3
130 150 140
2
2 3
1 3

\(\color{#0066ff}{输出样例}\)

1
0
3

\(\color{#0066ff}{数据范围与提示}\)

【样例说明】

未进行任何操作时，(2,3)满足条件；

操作1结束后，序列为130 140 150，不存在满足i<j且hi>hj的(i,j)对；

操作2结束后，序列为150 140 130,(1,2)，(1,3)，(2,3)共3对满足条件的(i,j)。

对于15%的数据，\(n,m \le 15\)；

对于30%的数据，\(n,m \le 200\)；

在剩下的70%数据中：

存在15%的数据，\(h_i\)各不相同；

存在15%的数据，\(1^{10} \le h_i \le 1^{60}\)；

以上两类数据不存在交集。

对于100%的数据，\(1 \le m \le 2\times 10^3\)，\(1 \le n \le 2 \times 10^4\)，\(1 \le h_i \le 10^9\)，\(a_i \ne b_i\)，\(1 \le a_i,b_i \le n\)。

\(\color{#0066ff}{题解}\)

一句话题意，给你一个序列，每次交换其中两个元素，每次输出逆序对数量

直接树套树， 每次减去改之前的贡献，然后修改，然后再加上改之后的贡献即可

#include<bits/stdc++.h>
#define LL long long
LL read() {
	char ch; LL x = 0, f = 1;
	while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
	for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
	return x * f;
}
template<class T> bool chkmax(T &a, const T &b) { return a < b? a = b, 1 : 0; }
template<class T> bool chkmin(T &a, const T &b) { return b < a? a = b, 1 : 0; }
const int maxn = 1e5 + 10;
struct Splay {
protected:
	struct node {
		node *ch[2], *fa;
		int siz, val;
		node(int siz = 0, int val = 0): siz(siz), val(val) { ch[0] = ch[1] = fa = NULL; }
		bool isr() { return this == fa->ch[1]; }
		void upd() { siz = (ch[0]? ch[0]->siz : 0) + (ch[1]? ch[1]->siz : 0) + 1; }
		int rkmin() { return (ch[0]? ch[0]->siz + 1 : 1); }
		int rkmax() { return (ch[1]? ch[1]->siz + 1 : 1); }
	}*root;
	void rot(node *x) {
		node *y = x->fa, *z = y->fa;
		bool k = x->isr(); node *w = x->ch[!k];
		if(y != root) z->ch[y->isr()] = x;
		else root = x;
		(x->ch[!k] = y)->ch[k] = w;
		(y->fa = x)->fa = z;
		if(w) w->fa = y;
		y->upd(), x->upd();
	}
	void splay(node *o) {
		while(o != root) {
			if(o->fa != root) rot(o->isr() ^ o->fa->isr()? o : o->fa);
			rot(o);
		}
	}
	node *merge(node *fa, node *x, node *y) {
		if(x) x->fa = fa;
		if(y) y->fa = fa;
		if(!x || !y) return x? x : y;
		if(rand() & 1) return x->ch[1] = merge(x, x->ch[1], y), x->upd(), x;
		else return y->ch[0] = merge(y, x, y->ch[0]), y->upd(), y;
	}
public:
	Splay() { root = NULL; }
	int querymin(int val) {
		int rank = 0; node *o = root;
		while(o) {
			if(o->val < val) rank += o->rkmin(), o = o->ch[1];
			else o = o->ch[0];
		}
		return rank;
	}
	int querymax(int val) {
		int rank = 0; node *o = root;
		while(o) {
			if(o->val > val) rank += o->rkmax(), o = o->ch[0];
			else o = o->ch[1];
		}
		return rank;
	}
	void ins(int val) {
		if(!root) return (void)(root = new node(1, val));
		node *o = root, *fa = NULL;
		while(o) fa = o, o = o->ch[val > o->val];
		fa->ch[val > fa->val] = o = new node(1, val);
		o->fa = fa, splay(o);
	}
	void del(int val) {
		node *o = root;
		while(o->val != val)  o = o->ch[val > o->val];
		splay(o);
		root = merge(NULL, o->ch[0], o->ch[1]);
	}
};
struct Tree {
protected:
	struct node {
		node *ch[2];
		int l, r;
		Splay T;
		node(int l = 0, int r = 0): l(l), r(r) { ch[0] = ch[1] = NULL; }
		int mid() { return (l + r) >> 1; }
	}*root;
	void build(node *&o, int l, int r, int *a) {
		o = new node(l, r);
		for(int i = l; i <= r; i++) o->T.ins(a[i]);
		if(l == r) return;
		build(o->ch[0], l, o->mid(), a);
		build(o->ch[1], o->mid() + 1, r, a);
	}
	int querymin(node *o, int l, int r, int val) {
		if(l > r) return 0;
		if(l <= o->l && o->r <= r) return o->T.querymin(val);
		int ans = 0;
		if(l <= o->mid()) ans += querymin(o->ch[0], l, r, val);
		if(r > o->mid()) ans += querymin(o->ch[1], l, r, val);
		return ans;
	}
	int querymax(node *o, int l, int r, int val) {
		if(l > r) return 0;
		if(l <= o->l && o->r <= r) return o->T.querymax(val);
		int ans = 0;
		if(l <= o->mid()) ans += querymax(o->ch[0], l, r, val);
		if(r > o->mid()) ans += querymax(o->ch[1], l, r, val);
		return ans;
	}
public:
	void init(int n, int *a) { build(root, 1, n, a); }
	void change(int pos, int old, int now) {
		node *o = root;
		while(1) {
			o->T.del(old), o->T.ins(now);
			if(o->l == o->r) break;
			if(pos <= o->mid()) o = o->ch[0];
			else o = o->ch[1];
		}
	}
	int querymin(int l, int r, int val) { return querymin(root, l, r, val); }
	int querymax(int l, int r, int val) { return querymax(root, l, r, val); }
}T;
int val[maxn], n;
int main() {
	n = read();
	for(int i = 1; i <= n; i++) val[i] = read();
	T.init(n, val);
	int ans = 0;
	for(int i = 1; i <= n; i++) ans += T.querymax(1, i - 1, val[i]) + T.querymin(i + 1, n, val[i]);
	printf("%d\n", ans >>= 1);
	for(int Q = read(); Q --> 0;) {
		int x = read(), y = read();
		ans -= T.querymax(1, x - 1, val[x]) + T.querymin(x + 1, n, val[x]);
		T.change(x, val[x], val[y]);
		ans += T.querymax(1, x - 1, val[y]) + T.querymin(x + 1, n, val[y]);
		ans -= T.querymax(1, y - 1, val[y]) + T.querymin(y + 1, n, val[y]);
		T.change(y, val[y], val[x]);
		ans += T.querymax(1, y - 1, val[x]) + T.querymin(y + 1, n, val[x]);
		std::swap(val[x], val[y]);
		printf("%d\n", ans);
	}
	return 0;
}