算重学(1) 函数式编程&DS

引入

定义定义定义！

感觉理解分治的时候挺好用的，也就是我常说的推锅下去。

函数式线段树（主席树）

函数式平衡树 (fhq_treap)

以及若干东西，你都可以定义下去。

本质上是一个映射，对于你输入的东西映射，再通过定义去得到最终结果。

https://max.book118.com/html/2016/0304/36834109.shtm

fhq-treap

考虑一个东西

fhq_treap 需要满足 $val_1$ 满足 BST 性质，$val_2$ 满足 heap 性质，你可以认为 $val_2$ 是为了让 fhq_treap 平衡才加进去的一个随机权值。

考虑定义若干函数：

pair<int,int> split(x,k) 表示将 $x$ 这棵树分裂成两棵 treap，满足第一棵 treap 的 $val_1$ 的最大值小于等于 $k$，第二棵 treap 的最小值大于 $k$。

考虑我仅仅只需要满足当前该咋做，接着推锅下去即可。

if(val1(x)<=k) {
	a=x; auto qwq=split(x.rs,k);
	a.rs=qwq.first;
	b=qwq.second;
} else { //则把 x 的 rs 都给 b，然后考虑 ls 即可。 
	b=x; auto qwq=split(x.ls,k);
	a=qwq.first;
	b.ls=qwq.second;
}
return mp(a,b); 

注意看我每一步只做了什么？当前是咋样的，通过子问题得到的结果来保证当前的正确性。因为只会跑 O(树高) 次，然后你 fhq_treap 保持平衡，所以复杂度就是对的。

注意，每次 split 完只需要 push_up 形态在当前改变的

merge(x,y) 合并 x,y 两棵树。需要注意，建议你把所有的树都看成外向树，也就是你实际上合并的是子树 x，子树 y，它可能原先所在的树并不以它为根。不过这没关系，因为我们定义就是以它为根，既然最开始的时候满足，那么我们只需要接下来每一步都满足即可。

我们限定 x,y 满足 $\max val_1 T(x)<\min val_1 T(y)$，所以你合并的时候 $val_1$ 的性质是很好满足的，所以你只需要满足 heap 的性质。

若我们钦定合并完是以当前的 y 为根（根据 $val_2$ 大小钦定，即满足堆的性质），因为你要么 x 为根，要么 y 为根，因为我们不带旋转操作，下面的点没办法旋上来。

push_down(y); push_down(x);
y.ls=merge(x,y.ls); 
return y;

复杂度显然还是树高次。

因为你若以 $y$ 为根，显然其 rs 都是直接保留的，因为你 $x$ 不可能能插到其 rs 的。那么你只需要考虑 ls 对应的树，显然为 x,y.ls 合并起来的，注意顺序不能颠倒！需要满足定义！

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
using namespace std;
const int N=(int)(1e5+5);
mt19937 RAND(time(0)); 
struct Tr {
	int ls,rs,rad,sz,val,tag;
}t[N];
int rt,tot,n,m;

int nd(int v) {
	++tot;
	t[tot].val=v; t[tot].ls=t[tot].rs=t[tot].tag=0; t[tot].rad=RAND();
	t[tot].sz=1; 
	return tot;
}

void push_up(int x) {
	t[x].sz=t[t[x].ls].sz+t[t[x].rs].sz+1;
}

void push_down(int x) {
	if(!t[x].tag) return ;
	t[t[x].ls].tag^=1; t[t[x].rs].tag^=1;
	t[x].tag=0;
	swap(t[x].ls,t[x].rs);
	
}

pair<int,int> split(int x,int sz) {
	if(!x) return mp(0,0);
	push_down(x);
	int a,b;
	if(t[t[x].ls].sz+1<=sz) {
		a=x; 
		auto qwq=split(t[x].rs,sz-t[t[x].ls].sz-1);
		t[a].rs=qwq.first; b=qwq.second;
//		push_up(a); push_up(b);
	} else {
		b=x;
		auto qwq=split(t[x].ls,sz);
		a=qwq.first; t[b].ls=qwq.second;
//		push_up(a); push_up(b);
	}
//	push_up(a); push_up(b); 
	push_up(x);
	return mp(a,b);
}

int merge(int x,int y) {
	if(!x||!y) return x+y;
	push_down(x); push_down(y);
	if(t[x].rad<t[y].rad) {
		t[x].rs=merge(t[x].rs,y);
		push_up(x);
		return x;
	} else {
		t[y].ls=merge(x,t[y].ls);
		push_up(y);
		return y;
	}
}

void pr(int x) {
	push_down(x); 
	if(t[x].ls) pr(t[x].ls);
	cout<<t[x].val<<' ';
	if(t[x].rs) pr(t[x].rs);
}

signed main() {
	cin.tie(0); ios::sync_with_stdio(false);
	cin>>n>>m;
	for(int i=1;i<=n;i++) rt=merge(rt,nd(i));
	while(m--) {
		int l,r; cin>>l>>r;
		auto qwq=split(rt,r);
		int k1=qwq.first,k2=0,k3=qwq.second;
		qwq=split(k1,l-1);
		k1=qwq.first; k2=qwq.second;
		t[k2].tag^=1;
		rt=merge(k1,k2);
		rt=merge(rt,k3);
	}
	pr(rt);
	return 0;
}

可持久化

然后可持久化是很好做的，具体的，你只需要根据定义来做即可。即类主席树一样定义若干个版本的树，然后你显然是要根据定义来继承旧版本信息的。

你就直接定义 split 为分裂出 2 棵新 treap，而不更改原先节点的形态，merge 也是合并为新 treap，不更改原先 2 棵树的本身结构。

因此，你每次都要建新点来保证原先形态不被改变。即倘若有操作需要改变到原先的形态，你都需要复制原先的点生成一个新点，再在新点上更改形态，因为你可持久化后是认子不认父的，一个点可能有多个父亲，你要是贸然修改可能其他树的结构信息就被破坏掉了。

因为都是外向边，所以认子不认父，一个点可以有多个父亲，这也是为啥复杂度正确。

#include <bits/stdc++.h>
#define int long long
#define pb push_back
#define mp make_pair
using namespace std;
const int N=(int)(2e5+5);
struct Tr {
	int ls,rs,val,rad,sz,sum,tag;
}t[N*100];
mt19937 RAND(time(0));
int m,rt[N],tot;

int nd(int v) {
	++tot;
	t[tot].ls=t[tot].rs=t[tot].tag=0;
	t[tot].val=t[tot].sum=v;
	t[tot].sz=1;
	t[tot].rad=RAND();
	return tot;
}

int cpy(int x) {
	++tot; t[tot]=t[x];
	return tot;
}

void push_down(int x) {
	if(!t[x].tag) return ;
	if(t[x].ls) t[x].ls=cpy(t[x].ls);
	if(t[x].rs) t[x].rs=cpy(t[x].rs);
	swap(t[x].ls,t[x].rs);
	if(t[x].ls) t[t[x].ls].tag^=1;
	if(t[x].rs) t[t[x].rs].tag^=1;
	t[x].tag=0;
}

void push_up(int x) {
	t[x].sz=t[t[x].ls].sz+t[t[x].rs].sz+1;
	t[x].sum=t[t[x].ls].sum+t[t[x].rs].sum+t[x].val;
}

pair<int,int> split(int x,int k) {
	if(!x) return mp(0,0);
	push_down(x);
	int a,b;
	if(t[t[x].ls].sz+1<=k) {
		a=++tot; t[a]=t[x];
		auto qwq=split(t[x].rs,k-t[t[x].ls].sz-1);
		t[a].rs=qwq.first; b=qwq.second;
		push_up(a);
	} else {
		b=++tot; t[b]=t[x];
		auto qwq=split(t[x].ls,k);
		a=qwq.first; t[b].ls=qwq.second;
		push_up(b);
	}
	return mp(a,b);
}

int merge(int x,int y) {
	if(!x||!y) return x+y;
	push_down(x); push_down(y);
	int p=++tot;
	if(t[x].rad<t[y].rad) {
		t[p]=t[x];
		t[p].rs=merge(t[x].rs,y);
	} else {
		t[p]=t[y];
		t[p].ls=merge(x,t[y].ls);
	}
	push_up(p);
	return p;
}

void pr(int x) {
	push_down(x);
	if(t[x].ls) pr(t[x].ls);
//	cout<<x<<" "<<t[x].val<<' ';
	if(t[x].rs) pr(t[x].rs);
}

signed main() {
	cin.tie(0); ios::sync_with_stdio(false);
	cin>>m;
	int ans=0;
	for(int i=1;i<=m;i++) {
		int pre,op; cin>>pre>>op;
		if(op==1) {
			int p,x; cin>>p>>x;
			p^=ans; x^=ans;
			auto qwq=split(rt[pre],p);
			int k1=qwq.first,k2=qwq.second;
			rt[i]=merge(k1,nd(x));
			rt[i]=merge(rt[i],k2);
		} else if(op==2) {
			int p; cin>>p;
			p^=ans;
			auto qwq=split(rt[pre],p-1);
			int k1=qwq.first,k2=0,k3=qwq.second;
			qwq=split(k3,1);
			k2=qwq.first; k3=qwq.second;
			rt[i]=merge(k1,k3);
		} else if(op==3) {
			int l,r; cin>>l>>r;
			l^=ans; r^=ans;
			auto qwq=split(rt[pre],r);
			int k1=qwq.first,k2=0,k3=qwq.second;
			qwq=split(k1,l-1);
			k1=qwq.first; k2=qwq.second;
			t[k2].tag^=1;
			rt[i]=merge(k1,merge(k2,k3));
		} else {
			int l,r; cin>>l>>r;
			l^=ans; r^=ans;
			auto qwq=split(rt[pre],r);
			int k1=qwq.first,k2=0,k3=qwq.second;
			qwq=split(k1,l-1);
			k1=qwq.first; k2=qwq.second;
			ans=t[k2].sum;
			cout<<ans<<'\n';
			rt[i]=merge(k1,merge(k2,k3));
		}
//		cout<<": "<<i<<'\n';
//		pr(rt[i]);
//		cout<<'\n';
	}
	return 0;
} 

__EOF__

本文作者：F x o r G
本文链接：https://www.cnblogs.com/xugangfan/p/16987040.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！