[CF1500E] Subset Trick （平衡树）

题面

_洛谷翻译

$\mathrm{V}\mathrm{a}\mathrm{n}\mathrm{y}\mathrm{a}$ 有一个初始大小为 $n$ 的集合 $S$ 和 $q$ 次往集合加数/删数的操作。（集合中每个数字不同）

称一个数 $x$ 为不合适的，当前仅当满足可以取出 $S$ 的两个大小相同的子集，其中一个元素和 $\le x$，另一个元素和 $>x$。

求初始集合与每次操作结束后的集合不合适 $x$ 的数量。

$n,q\le 2e5,S_i\le 1e13$

3000 ms , 512 mb

题解

洛谷的翻译已经转换了一部分题意了，我们接着转换。

既然是两个大小相同的子集，那么针对每种子集大小，我们不妨找出元素和最小以及元素和最大的两个集合，令其元素和分别为 $L,R$，那么 $[L,R)$ 以内都是不合适的 $x$ 。

我们把整个集合从小到大排成一列，会发现问题简单了许多。元素和最小的大小为 $i$ 的集合就是前缀 $i$（$sum(i)$），同理，元素和最大的大小为 $i$ 的集合就是后缀 $|S|-i+1$（$suf(|S|-i+1)$）。

回过头来，我们可以把要求的答案表示为 $[L_1,R_1)\cup [L_2,R_2)\cup ...\cup [L_{|S|},R_{|S|})$，即 $[sum(1),suf(|S|))\cup [sum(2),suf(|S|-1))\cup ...\cup [sum(|S|),suf(1))$ ，我们会发现一些规律：

1. 由于序列是单增的，因此 $y=sum(x)$ 下凸， $y=suf(|S|-x+1)$ 上凸。
2. $sum(|S|)=suf(1)$ ，因此 $[sum(|S|),suf(1))$ 是空集，我们把它去掉。
3. $sum(i)=\mathrm{S}\mathrm{u}{\mathrm{m}}_{\mathrm{S}}-suf(i+1),suf(|S|-i+1)=\mathrm{S}\mathrm{u}{\mathrm{m}}_{\mathrm{S}}-sum(|S|-i)$ ，因此 $[L_i,R_i]$ 和 $[L_{|S|-i},R_{|S|-i}]$ 是大小相等的，整个并集是左右对称的。

我们会发现，难点就在于这是集合并，不能简单地求长度和，我们得判断哪些区间融合了，哪些单了出来。好在之前的规律可以帮助我们，我们可以发现一个规律：整个并集两边的区间单出来一些(possibly, none)，中间则是一个大区间，也就是存在中间一段 $[L_s,R_s)\cup ...\cup [L_t,R_t)$ 是一整个大区间，其余的 { [ L i , R i ) ∣ i < s ∨ i > t } \{[L_i,R_i) |i<s\vee i>t\} {[Li​,Ri​)∣i<s∨i>t} 都是独立的（长度可以直接加）。形似这样：

[)  [-)    [---)     [-----------------------------------)     [---)    [-)  [)

• 证明：由于并集对称，我们只证明左半边，右半边同理。考虑左半边某个区间 $[sum(i),suf(|S|-i+1))$ 是独立的，那么 $suf(|S|-i+1)<sum(i+1)$ ，也即
  $$suf(|S|-(i-1)+1)+S_{|S|-i+1}<sum(i)+S_{i+1}\text{\hspace{1em}(1)}$$
  由于是在序列左半边，序列从左到右单增，因此
  $$S_{i+1}<S_{|S|-i+1}\iff -S_{|S|-i+1}<-S_{i+1}\text{\hspace{1em}(2)}$$
  由于同号，因此把这个不等式 $(2)$ 和上面的不等式 $(1)$ 左右两边分别相加，可得：
  $$suf(|S|-(i-1)+1)<sum((i-1)+1)$$
  所以我们发现区间 $[L_{i-1},R_{i-1})=[sum(i-1),suf(|S|-(i-1)+1))$ 也就是它左边那个区间也是独立的。
  由此可得，左边的独立区间一定是最靠左的连续一段 $[L_i,R_i)$ ，由于对称，右边也一样。证毕。

我们每次计算答案可以只算左半边，就能得到右半边的答案，同时要处理最中间的特殊情况。我们先考虑求区间独立的范围 $[1,s)$ ，这个可以二分位置，然后判断 $sum$ 和 $suf$ 的大小关系。我们得到 $s$ 过后，$t$ 就可以直接对称得到，中间的大区间就很好计算了，我们找到右端点左端点做个减法就行。对于左边的独立区间，答案就是
$$\begin{gathered} \sum _{i=1}^{s-1}(R_i-L_i)=\sum _{i=1}^{s-1}suf(|S|-i+1)-\sum _{i=1}^{s-1}sum(i) \\ =\sum _{i=1}^{s-1}(s-i)S_{|S|-i+1}-\sum _{i=1}^{s-1}(s-i)S_i \end{gathered}$$

综上所述，我们得用数据结构维护一个单增序列每段子串的 $\sum S_i$，$\sum S_i\cdot i$ ，以及同时，该数据结构还得支持

• 从某个值后面添加一个数
• 删除某个值的数

那么最适合的数据结构就是平衡树了！虽然有点卡常。

官解做法：

推理结论都差不多，只不过角度不同：官解是用全集 - 空隙，然后证明了最左和最右两端的空隙都是连续的（定义了 $f(k)=sum(k+1)-suf(n-k+1)$，然后直接告诉你它在左半边是单减的(Let’s note two simply things: …)）。

然后也是二分边界，维护元素和以及元素带权和，只不过用的是离散化+线段树，常数小一些，但是自我感觉想起来很麻烦。

CODE

无旋Treap ，中间求sum和suf时卡了卡常。
无O2: 2979 ms ，加O2: 2542 ms

#include<map>
#include<queue>
#include<ctime>
#include<cmath>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 200005
#define ENDL putchar('\n')
#define LL long long
#define DB double
#define lowbit(x) ((-x) & (x))
#define eps 1e-9
//#pragma GCC optimize(2)
LL read() {
	LL f = 1,x = 0;char s = getchar();
	while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f * x;
}
int n,m,i,j,s,o,k;
LL a[MAXN];
//----------------------------------Treap
struct np{int s[2];np(){s[0]=s[1]=0;}np(int A,int B){s[0]=A;s[1]=B;}};
struct tr{
	int s[2],siz,hp,lz;
	LL ky,sm,k2,sm2;
	tr(){s[0]=s[1]=siz=hp=0;ky=sm=k2=sm2=lz=0;}
}tre[MAXN<<1];
int CNT;
inline int newnode(LL key) {
	int x = ++ CNT; tre[x] = tr();
	tre[x].ky = tre[x].sm = tre[x].k2 = tre[x].sm2 = key;
	tre[x].siz = 1; tre[x].hp = rand() *1ll* rand() % 998244353;
	return x;
}
inline int update(int x) {
	int ls = tre[x].s[0],rs = tre[x].s[1];
	tre[x].sm = tre[x].ky + tre[ls].sm + tre[rs].sm;
	tre[x].sm2 = tre[x].k2 + tre[ls].sm2 + tre[rs].sm2 + (tre[ls].sm + tre[rs].sm) *1ll* tre[x].lz;
	tre[x].siz = tre[ls].siz + tre[rs].siz + 1;
	tre[0] = tr(); return x;
}
inline void addtm(int x,int y) {
	if(!x) return ;
	tre[x].k2 += tre[x].ky *1ll* y;
	tre[x].sm2 += tre[x].sm *1ll* y;
	tre[x].lz += y; return ;
}
inline void pushdown(int x) {
	if(!x) return ;
	int ls = tre[x].s[0],rs = tre[x].s[1];
	if(tre[x].lz) {
		addtm(ls,tre[x].lz); addtm(rs,tre[x].lz);
		tre[x].lz = 0;
	}return ;
}
inline np spli1(int x,LL k) {
	np as(0,0); if(!x) return as;
	pushdown(x);
	int d = (tre[x].ky <= k ? 1:0);
	as = spli1(tre[x].s[d],k);
	tre[x].s[d] = as.s[d^1];
	as.s[d^1] = update(x); return as;
}
inline np spli2(int x,int rk) {
	np as(0,0); if(!x) return as;
	pushdown(x); if(rk <= 0) return np(0,x);
	int d = (tre[tre[x].s[0]].siz+1 <= rk ? 1:0);
	if(d) rk -= tre[tre[x].s[0]].siz+1;
	as = spli2(tre[x].s[d],rk);
	tre[x].s[d] = as.s[d^1];
	as.s[d^1] = update(x); return as;
}
inline int merg(int p1,int p2) {
	if(!p1 || !p2) return p1+p2;
	pushdown(p1); pushdown(p2);
	if(tre[p1].hp < tre[p2].hp) {tre[p1].s[1] = merg(tre[p1].s[1],p2);return update(p1);}
	tre[p2].s[0] = merg(p1,tre[p2].s[0]); return update(p2);
}
inline int ins(int x,int y) {
	np p = spli1(x,tre[y].ky);
	addtm(y,tre[p.s[0]].siz); addtm(p.s[1],1);
	return merg(merg(p.s[0],y),p.s[1]);
}
inline int del(int x,LL k) {
	np p1 = spli1(x,k-1);
	np p2 = spli2(p1.s[1],1);
	if(p2.s[0] && tre[p2.s[0]].ky == k) p2.s[0] = 0,addtm(p2.s[1],-1);
	return merg(p1.s[0],merg(p2.s[0],p2.s[1]));
}
inline LL sum(int x,int y) {
	if(!x || !y) return 0ll;
	if(tre[tre[x].s[0]].siz+1 <= y)
		return tre[tre[x].s[0]].sm+tre[x].ky+sum(tre[x].s[1],y-(tre[tre[x].s[0]].siz+1));
	return sum(tre[x].s[0],y);
}
inline LL suf(int x,int y) {
	if(!x || y > tre[x].siz) return 0ll;
	if(tre[tre[x].s[0]].siz+1 < y)
		return suf(tre[x].s[1],y-(tre[tre[x].s[0]].siz+1));
	return tre[tre[x].s[1]].sm+tre[x].ky+suf(tre[x].s[0],y);
}
inline LL sum2(int &x,int y) {
	np p1 = spli2(x,y);
	LL res = tre[p1.s[0]].sm * (1ll+y) - tre[p1.s[0]].sm2;
	x = merg(p1.s[0],p1.s[1]);
	return res;
}
inline LL suf2(int &x,int y) {
	np p1 = spli2(x,y-1);
	LL res = tre[p1.s[1]].sm2 - tre[p1.s[1]].sm *1ll* (y-1ll);
	x = merg(p1.s[0],p1.s[1]);
	return res;
}
// ----------------------------------------------------------------
int root = 0;
inline LL calcu() {
	n = tre[root].siz;
	if(!root || n <= 0) return 0ll;
	int md = n/2,st = 0;
	LL ans = 0;
	for(int i = 19;i >= 0;i --) {
		int ad = st+(1<<i);
		if(ad < md && suf(root,n-ad+1) < sum(root,ad+1)) st = ad;
	}
	if(st) ans += (suf2(root,n-st+1) - sum2(root,st)) * 2ll;
	if((n-1) & 1) {
		int rr = 2*md-st-1;
		LL l1 = sum(root,st+1), r1 = suf(root,n-rr+1);
		ans += r1 - l1;
	}
	else if(n > 1) {
		int rr = 2*md-st;
		LL l1 = sum(root,st+1),r1 = suf(root,n-md+1);
		LL l2 = sum(root,md+1),r2 = suf(root,n-rr+1);
		if(r1 < l2) ans += r1-l1 + r2-l2;
		else ans += r2 - l1;
	}
	return ans;
}
int main() {
	n = read(); m = read();
	for(int i = 1;i <= n;i ++) {
		a[i] = read();
		root = ins(root,newnode(a[i]));
	}
	printf("%lld\n",calcu());
	for(int i = 1;i <= m;i ++) {
		o = read();
		LL nm = read();
		if(o == 1) root = ins(root,newnode(nm));
		else root = del(root,nm);
		printf("%lld\n",calcu());
	}
	return 0;
}

官解线段树：jly的代码