浅谈笛卡尔树

合集 - 算法·理论(1)

1.浅谈笛卡尔树2024-09-30

收起

[介绍（百度百科）](笛卡尔树_百度百科 (baidu.com))

笛卡尔树是一种特定的二叉树数据结构，可由数列构造，在范围最值查询、范围$to{p}_k$查询（range top k queries）等问题上有广泛应用。它具有堆的有序性，中序遍历可以输出原数列。笛卡尔树结构由Vuillmin(1980)在解决范围搜索的几何数据结构问题时提出。从数列中构造一棵笛卡尔树可以线性时间完成，需要采用基于栈的算法来找到在该数列中的所有最近小数。

---

特殊的$treap$

性质

先说性质感觉会更好理解一些

虽然是"树"，但是笛卡尔树其实就是对序列的一个转化

对于树上的任意一点x，左右儿子left,right，以及在原序列上的$pos$值，有：

• 树中的元素满足二叉搜索树的性质，要求按照中序遍历得到的序列为原数组序列，各节点的$pos$是连续的，$pos[left]<pos[x]<pos[right]$，（维持原序列的顺序）
• 树中节点满足堆性质，节点的$val$值要大于其左右子节点的$val$值，$val[x]<val[left],val[right]$，（大根此时则恰恰相反）

对于笛卡尔树中每个节点都有两个权值$(val,key)$

建树

可以使用线段树，st表这些数据结构维护区间最大值/最小值，但是没有必要，大多数笛卡尔树的题目都可以通过维护一个单调栈来实现$O(n)$的建树

• 使用单调栈维护最右链
• 每次插入当前的$i$，在单调栈中不停弹出栈顶，直至栈顶$fa$满足$va{l}_{fa}<va{l}_i$，则最后一次弹出的就是$j$
• 将$i$作为$fa$的右儿子，$j$作为$i$的左儿子

模拟一下就是：

对于序列$a=\{9,3,7,1,8,12,10,20,15,18,5\}$

• 添加点$1$，$va{l}_1=9$加入栈
• 添加点$2$，弹出点$1$，点$1$就是$fa$的左儿子，将$va{l}_2=3$加入栈，成为栈顶
• 添加点$3$，$va{l}_3<va{l}_2$，故成为点$1$的右儿子
• .................（见图）

---

[P5854 【模板】笛卡尔树](P5854 【模板】笛卡尔树 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn))

模板题，求建出树后就可以得到$ans$

#include"bits/stdc++.h"

using namespace std;
const int N=1e7+15;
#define inl inline
#define regi register
#define PII pair<int,int>
//#define ll long long
inl int read(void)
{
	int x=0,f=1;char ch=getchar();
	while(!isdigit(ch)) f=ch=='-'?-1:f,ch=getchar();
	while(isdigit(ch))  x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
	return x*f;
}
int rt;int ls[N],rs[N],fa[N],n;

void build(int* a)
{
	stack<int> sta;stack<int>().swap(sta);
	for(int i=1;i<=n;i++)
	{
		int j=0;
		while(!sta.empty()&&a[sta.top()]>a[i])	j=sta.top(),sta.pop();
		if(sta.empty())	rt=i;
		else	rs[sta.top()]=i;
		ls[i]=j;
		sta.push(i);
	}
}
int p[N],tot=0;
stack<int> sta;
void insert(int val)
{
	p[++tot]=val;
	int i=tot;
	while(!sta.empty()&&p[sta.top()]>p[i])	sta.pop();
	if(!sta.empty())
		fa[i]=sta.top(),rs[sta.top()]=i,ls[i]=i-1;
	else	ls[i]=rt,rt=i;
	sta.push(i);
}
struct RMQ
{
	
	int L,R,dep[10015],sz[10015],ans;
	int dfs1(int u)
	{
		dep[u]=dep[fa[u]]+1;
		if(ls[u])	dfs1(ls[u]);
		if(rs[u])	dfs1(rs[u]);
		sz[u]+=sz[ls[u]],sz[u]+=sz[rs[u]];
	}//lca(l,r)=min(val_l,val_r),dfs1->get_dep
	RMQ(int l,int r):L(l),R(r){memset(dep,0,sizeof dep),memset(sz,0,sizeof sz);};
	int get_RMQ(void)
	{	
		int l=L,r=R;dfs1(1);
		int u=l,v=r;
		while(dep[u]!=dep[v])
		{
			if(dep[u]<dep[v])	swap(u,v);
			u=fa[u];
		}
		ans=u;
	}//log_2 n
};
int a[N];
int main(void)
{
	n=read();
	for(int i=1;i<=n;i++)	a[i]=read();
	build(a);
	long long ans1=0,ans2=0;
	for(int i=1;i<=n;i++)	ans1^=1ll*i*(ls[i]+1),ans2^=1ll*i*(rs[i]+1);
	printf("%lld %lld",ans1,ans2);
	return 0;
}

---

[P4755 Beautiful Pair](P4755 Beautiful Pair - 洛谷 | 计算机科学教育新生态 (luogu.com.cn))

有一个数列$a$，需要求出有多少数对$(i,j)$满足$a_i\times a_j\le \underset{l=i}{\overset{j}{max}}{a}_l$的数量

有很多人使用的都是线段树分治，但是提到笛卡尔树了，就写一下笛卡尔树分治

笛卡尔树在这些区间最值的地方有着非常不错的性质，考虑分治，区间为$[l,r]$，$mid=(l+r)/2$，先转化一下式子为$a_i\le \lfloor \frac{a_{mid}}{a_j}\rfloor$，笛卡尔树满足堆的性质，也满足搜索树的性质，套个$cdq$分治

建出笛卡尔树，可以很容易发现，贡献都是$max$两边提供的，考虑两边对答案的影响：

1.max的左子树的贡献
2.max的右子树的贡献
3.右边对左边的贡献

再维护一个树状数组

时间复杂度为$O(nlo{g}^{2}n)$

#include"bits/stdc++.h"

using namespace std;
const int N=1e5+15,M=1e9+15;
#define inl inline
#define regi register
#define PII pair<int,int>
#define int long long

inl int read(void)
{
	int x=0,f=1;char ch=getchar();
	while(!isdigit(ch)) f=ch=='-'?-1:f,ch=getchar();
	while(isdigit(ch))  x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
	return x*f;
}
int rt;
struct node
{
	int ls,rs;
}tr[N];
int n;
void build(int* a)
{
	stack<int> sta;stack<int>().swap(sta);
	for(int i=1;i<=n;i++)
	{
		int j=0;
		
		while(!sta.empty()&&a[sta.top()]<a[i])	j=sta.top(),sta.pop();
		if(sta.empty())	rt=i;
		else	tr[sta.top()].rs=i;
		tr[i].ls=j;
		sta.push(i);
	}
}
int ans;
int siz,a[N],b[N];
long long c[N];
#define lowbit(x) x&(-x)
void add(int x,int k){for(;x<=n;x+=lowbit(x))c[x]+=k;}
int query(int x){long long res=0;for(;x;x-=lowbit(x))res+=c[x];return res;}
void solve(int u,int l,int r)
{
	if(u==0)	return ;
	int ls=tr[u].ls,rs=tr[u].rs;
	int mid=u;
	if(mid-l>r-mid)
	{
		for(int i=mid;i<=r;i++)
		{
			int x=upper_bound(b,b+siz+1,b[a[mid]]/b[a[i]])-b;
			if(x)	ans-=query(x-1);
		}
		solve(ls,l,mid-1),add(a[mid],1);
		for(int i=mid;i<=r;i++)
		{
			int x=upper_bound(b,b+siz+1,b[a[mid]]/b[a[i]])-b;
			if(x)	ans+=query(x-1);
		}
		solve(rs,mid+1,r);
	}
	else
	{
		for(int i=l;i<=mid;i++)
		{
			int x=upper_bound(b,b+siz+1,b[a[mid]]/b[a[i]])-b;
			if(x)	ans-=query(x-1);
		}
		solve(rs,mid+1,r),add(a[mid],1);
		for(int i=l;i<=mid;i++)
		{
			int x=upper_bound(b,b+siz+1,b[a[mid]]/b[a[i]])-b;
			if(x)	ans+=query(x-1);
		}
		solve(ls,l,mid-1);
	}
}

signed main(void)
{
	n=read();
	for(int i=1;i<=n;i++)	b[i]=a[i]=read();
	sort(b+1,b+1+n);
	siz=unique(b+1,b+1+n)-b-1;
	for(int i=1;i<=n;i++)	a[i]=lower_bound(b+1,b+1+siz,a[i])-b;
	build(a);
	solve(rt,1,n);
	printf("%lld",ans);
	return 0;
}