笛卡尔树学习笔记
定义
笛卡尔树是一棵特殊的二叉树，它的每个节点都包含了两个值 ( k , w ) (k,w) (k,w)。其中，整棵树关于 k k k 为一棵二叉搜索树，而关于 w w w 为一个小根堆（或大根堆）。
到这里可以发现，Treap 是一种特殊的笛卡尔树，因为 Treap 相当于给定了 k k k，而我们人为将其随机了一个 w w w。
性质
- 对于一棵笛卡尔树，它的中序遍历就是原先输入的序列
a
a
a。
- 在插入序列 a a a 时，我们默认它的下标为 k k k。因此，原序列 a a a 中在某个数左边的数在笛卡尔树中也一定在这个数的左子树中，在某个数右边的数在笛卡尔树中也一定在这个数的右子树中。
- 在原序列中的区间
[
l
,
r
]
[l,r]
[l,r] 的最小值，就是这个序列的笛卡尔树上
l
l
l 和
r
r
r 的最近公共祖先。
- 因为 l l l 和 r r r 的公共祖先一定在区间 [ l , r ] [l,r] [l,r] 中，并且在整个区间中深度最小。因为笛卡尔树关于 w w w 是小根堆，所以 l l l 和 r r r 的最近公共祖先是原序列中区间 [ l , r ] [l,r] [l,r] 的最小值。
- 对于一个序列
a
a
a，如果它的
k
,
w
k,w
k,w 均互不重复，那么它建立出来的笛卡尔树是唯一的。
- 因为 k k k 互不重复，所以能构建出唯一无根二叉搜索树。而因为笛卡尔树关于 w w w 是小根堆，所以 w w w 最小的节点为根。又因为 w w w 互不重复，所以根节点确定，所以笛卡尔树确定。
建树
建树要求知道所有数字的插入顺序和具体的值，缺一不可。通常按照 k k k 升序输入。
通过洛谷【P5854 【模板】笛卡尔树】来了解最优的建树方法。
- 通过性质 2 2 2，我们可以通过 ST 表找出一个区间的最小值，让它作为根节点，接着递归处理它的左子树和右子树。时间复杂度是 O ( n log n + n ) O(n\log n+n) O(nlogn+n) 的，显然无法通过。
- 考虑到每一次插入要求关于 k k k 为一棵二叉搜索树，那么 k k k 大的值（即最后插入的值）一定在整个序列的最右边。因此通过单调栈维护整棵树的最右链，当栈顶节点的 w w w 值比当前节点大，就将其放在当前节点的左子树，反之直接将当前节点插入到栈顶节点的右子树中。时间复杂度是 O ( n ) O(n) O(n) 的。
code
void insert(int k,int w){
while(top&&w<a[stk[top]])ls[k]=stk[top--];
rs[stk[top]]=k;//最后的根节点就是 rs[0]
stk[++top]=k;
return ;
}
例题
洛谷【P5854 【模板】笛卡尔树】
Solution1【自己想的】
建立笛卡尔树，保存左右子树的编号，根据要求统计即可。另外一提，这道题卡常，需要加快读。
code1
#include <bits/stdc++.h>
using namespace std;
const int N=1e7;
int n,x,top;
int stk[N+5],ls[N+5],rs[N+5],a[N+5];
long long AnsL,AnsR;
int read(){
int ret=0,ch=getchar();
while(!isdigit(ch))ch=getchar();
while(isdigit(ch))ret=ret*10+ch-'0',ch=getchar();
return ret;
}
void insert(int k,int w){
while(top&&w<a[stk[top]])ls[k]=stk[top--];
if(top)rs[stk[top]]=k;
stk[++top]=k;
return ;
}
int main(){
n=read();
for(int i=1;i<=n;i++){
a[i]=read();
insert(i,a[i]);
}
for(int i=1;i<=n;i++){
AnsL^=(long long)i*(ls[i]+1);
AnsR^=(long long)i*(rs[i]+1);
}
printf("%lld %lld",AnsL,AnsR);
return 0;
}
洛谷【P1377 [TJOI2011] 树的序】
Solution1【自己想的】
考虑到题目中给出的输入相当于确定了 k k k，而下标则相当于 w w w。因为建立笛卡尔树需要按照 k k k 从小到大排序，因此首先排序，然后建立笛卡尔树，这个笛卡尔树就是对应的二叉搜索树。因为在父亲节点走到之前无法走到儿子节点，并且左儿子小于右儿子，所以这棵树的先序遍历就是要求的答案序列。
code1
#include <bits/stdc++.h>
using namespace std;
const int N=1e5;
int n,top,rt;
int stk[N+5],ls[N+5],rs[N+5];
pair<int,int>a[N+5];
int read(){
int ret=0,ch=getchar();
while(!isdigit(ch))ch=getchar();
while(isdigit(ch))ret=ret*10+ch-'0',ch=getchar();
return ret;
}
void insert(int k,int w){
while(top&&w<a[stk[top]].second)ls[k]=stk[top--];
if(top)rs[stk[top]]=k;
stk[++top]=k;
return ;
}
void show(int x){
printf("%d ",a[x].first);
if(ls[x])show(ls[x]);
if(rs[x])show(rs[x]);
return ;
}
int main(){
n=read();
for(int i=1;i<=n;i++)a[i]=make_pair(read(),i);
rt=a[1].first;
sort(a,a+n+1);
for(int i=1;i<=n;i++)insert(a[i].first,a[i].second);
show(rt);
return 0;
}
P2244. [hdu6305]RMQ Similar Sequence
Solution1【颓题解的】
因为序列 A , B A,B A,B 的所有子区间的 RMQ 相同，那么序列 A , B A,B A,B 的笛卡尔树应该是同构的。又因为序列 B B B 中的元素都是区间 [ 0 , 1 ] [0,1] [0,1] 内的实数，所以序列 B B B 内有重复元素的概率无限趋近于 0 0 0。我们假设序列 B B B 中没有重复元素，那么根据性质 3 3 3，序列 B B B 的笛卡尔树应该是唯一的。接着考虑对于每一个序列 B B B 的笛卡尔树与序列 A A A 的笛卡尔树同构的概率。因为数字从左往右的顺序不变，根据性质 1 1 1，只要确定了根节点，那么两边的元素集合一定相等，所以只要所有子树的根节点都相同，那么两个笛卡尔树就是同构的。设以 i i i 为根节点的子树大小为 s i z i siz_i sizi，那么笛卡尔树同构的概率为 1 ∏ i = 1 n s i z i \frac{1}{\prod_{i=1}^n siz_i} ∏i=1nsizi1。而序列 B B B 内每一个元素的期望都是 1 2 \frac{1}{2} 21，所以符合条件序列 B B B 的权值期望为 n 2 \frac{n}{2} 2n，所以序列 B B B 的权值期望为 n 2 ∏ i = 1 n s i z i \frac{n}{2\prod_{i=1}^nsiz_i} 2∏i=1nsizin。
code1
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N=1e6,M=1e9+7;
int T,n,top,rt;
int a[N+5],stk[N+5],ls[N+5],rs[N+5],siz[N+5];
void insert(int k,int w){
while(top&&w>a[stk[top]])ls[k]=stk[top--];
if(top)rs[stk[top]]=k;
else rt=k;
stk[++top]=k;
return ;
}
void dfs(int x){
siz[x]=1;
if(ls[x])dfs(ls[x]);
if(rs[x])dfs(rs[x]);
siz[x]+=siz[ls[x]]+siz[rs[x]];
return ;
}
ll QuickPow(ll a,int b){
ll res=1;
while(b){
if(b&1)res=res*a%M;
a=a*a%M;
b>>=1;
}
return res;
}
int main(){
scanf("%d",&T);
while(T--){
scanf("%d",&n);
top=0;
for(int i=1;i<=n;i++)ls[i]=rs[i]=0;
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
insert(i,a[i]);
}
dfs(rt);
long long sum=2;
for(int i=1;i<=n;i++)sum=sum*siz[i]%M;
printf("%lld\n",n*QuickPow(sum,M-2)%M);
}
return 0;
}
P2245. [SPOJ#2616]PERIODNI
Solution1【自己想的】
考虑到如果有一个最小的棋盘将两边分隔开，那么除去这个棋所在的行以外，剩下的两组棋盘互不干扰。即对于 i > h x i>h_x i>hx，棋盘 x x x 左边的第 i i i 行和棋盘 x x x 右边的第 i i i 行互不干扰。那么可以通过这一点进行树形 dp。我们发现，一个子树的根节点是整个区间的最小值，所以整棵树是一棵笛卡尔树。给出的高度相当于 w w w，下标相当于 k k k。接着令 f i , j f_{i,j} fi,j 表示节点 i i i 为根的子树中放置 j j j 个节点，且所有棋子所在行的编号不小于节点 i i i 的父亲节点的高度，即棋子的行编号在区间 ( h f a x , + ∞ ) (h_{fa_x},+\infty) (hfax,+∞) 内的方案数。
先考虑棋子编号在区间 ( h x , + ∞ ) (h_x,+\infty) (hx,+∞) 的方案数，此时相当于一个背包，转移方程为：
f i , j = ∑ t o ∈ s o n i ∑ k = 1 j f t o , k × f i , j − k f_{i,j}=\sum_{to\in son_i}\sum_{k=1}^{j}f_{to,k}\times f_{i,j-k} fi,j=to∈soni∑k=1∑jfto,k×fi,j−k
注意此时为了不让数组刚更新的内容去更新其他内容，因此 j j j 应从大到小循环。接着考虑行编号在区间 ( h f a x , h x ] (h_{fa_x},h_x] (hfax,hx] 中的棋子。我们如果放 k k k 个这样的棋子，那么说明必须有一些列是空的，接着从范围内选出 k k k 个不同的数字然后分在这些空列当中，转移方程为：
f i , j = ∑ k = 1 j f i , j − k × C h x − h f a x k × A s i z i − ( j − k ) k f_{i,j}=\sum_{k=1}^{j}f_{i,j-k}\times C_{h_x-h_{fa_x}}^{k}\times A_{siz_i-(j-k)}^{k} fi,j=k=1∑jfi,j−k×Chx−hfaxk×Asizi−(j−k)k
注意此时为了不让数组刚更新的内容去更新其他内容，因此 j j j 应从大到小循环。最后两个区间的方案数累加起来就是对应的值。最后的答案是 f r t , k f_{rt,k} frt,k。
code1
#include <bits/stdc++.h>
using namespace std;
const int N=500,M=1e9+7,H=1e6;
int n,k,top,rt;
int stk[N+5],ls[N+5],rs[N+5],a[N+5],siz[N+5];
long long dp[N+5][N+5],f[H+5],g[H+5];
void insert(int k,int w){
while(top&&w<a[stk[top]])ls[k]=stk[top--];
rs[stk[top]]=k;
stk[++top]=k;
return ;
}
long long QuickPow(long long a,int b){
long long res=1;
while(b){
if(b&1)res=res*a%M;
a=a*a%M;
b>>=1;
}
return res;
}
void pre(int N){
f[0]=1;
for(int i=1;i<=N;i++)f[i]=f[i-1]*i%M;
g[N]=QuickPow(f[N],M-2);
for(int i=N-1;i>=0;i--)g[i]=g[i+1]*(i+1)%M;
return ;
}
long long C(int n,int m){
if(n<m||n<0||m<0)return 0;
return f[n]*g[n-m]%M*g[m]%M;
}
long long A(int n,int m){
if(n<m||n<0||m<0)return 0;
return f[n]*g[n-m]%M;
}
void dfs(int x,int lst){
siz[x]=1;
if(ls[x])dfs(ls[x],x);
if(rs[x])dfs(rs[x],x);
siz[x]+=siz[ls[x]]+siz[rs[x]];
dp[x][0]=1;
for(int i=k;i>=1;i--){
for(int j=1;j<=min(i,siz[ls[x]]);j++)dp[x][i]=(dp[x][i]+dp[x][i-j]*dp[ls[x]][j]%M)%M;
}
for(int i=k;i>=1;i--){
for(int j=1;j<=min(i,siz[rs[x]]);j++)dp[x][i]=(dp[x][i]+dp[x][i-j]*dp[rs[x]][j]%M)%M;
}
for(int i=min(k,siz[x]);i>=1;i--){
for(int j=min(i,a[x]-a[lst]);j>=1;j--)dp[x][i]=(dp[x][i]+dp[x][i-j]*C(a[x]-a[lst],j)%M*A(siz[x]-i+j,j)%M)%M;
}
return ;
}
int main(){
pre(H);
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
insert(i,a[i]);
}
dfs(rs[0],0);
printf("%lld",dp[rs[0]][k]);
return 0;
}
P2246. [hdu4125]Moles
Solution1【自己想的】
问题即要求建一棵二叉搜索树、求解路径节点和模式串匹配。建立二叉搜索树可以和【洛谷【P1377 [TJOI2011] 树的序】】一样，按 k k k 值排序后，用笛卡尔树 O ( n ) O(n) O(n) 解决。路径上的节点只需要先走左子树，再走右子树得到欧拉序即可，dfs 是 O ( n ) O(n) O(n) 的。模式串匹配用 KMP，因为欧拉序最多 2 n 2n 2n 个节点，所以也是 O ( n ) O(n) O(n) 的，所以时间复杂度 O ( n ) O(n) O(n)。
code1
#include <bits/stdc++.h>
using namespace std;
const int N=6e5,S=7e3;
int T,n,top,rt,tot1,tot2,cnt;
int t[N+5],stk[N+5],ls[N+5],rs[N+5],a[N+5],nxt[N+5];
char s1[(N<<1)+5],s2[S+5];
void insert(int k,int w){
while(top&&w<t[stk[top]])ls[k]=stk[top--];
if(top)rs[stk[top]]=k;
else rt=k;
stk[++top]=k;
return ;
}
void dfs(int x){
s1[tot1++]=x%2+'0';
if(ls[x]){
dfs(ls[x]);
s1[tot1++]=x%2+'0';
}
if(rs[x]){
dfs(rs[x]);
s1[tot1++]=x%2+'0';
}
return ;
}
int main(){
scanf("%d",&T);
for(int c=1;c<=T;c++){
scanf("%d",&n);
top=tot1=cnt=0;
for(int i=1;i<=n;i++)t[i]=ls[i]=rs[i]=nxt[i]=0;
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
t[a[i]]=i;
}
for(int i=1;i<=n;i++)insert(i,t[i]);
dfs(rt);
scanf("%s",s2);
tot2=strlen(s2);
for(int i=0;s2[i];i++)nxt[i]=0;
for(int i=1,j=0;i<tot2;i++){
while(j&&s2[i]!=s2[j])j=nxt[j-1];
if(s2[i]==s2[j])j++;
nxt[i]=j;
}
for(int i=0,j=0;i<tot1;i++){
while(j&&s1[i]!=s2[j])j=nxt[j-1];
if(s1[i]==s2[j])j++;
if(j==tot2){
cnt++;
j=nxt[j-1];
}
}
printf("Case #%d: %d\n",c,cnt);
}
return 0;
}
P2247. [hdu6854]Kcats
Solution1【颓题解的】
考虑到 a i a_i ai 本质上是最后的笛卡尔树上，第 i i i 个节点的所有祖先中 k k k 值比自己小的节点的数量。接着考虑区间 dp，令 f i , j , d f_{i,j,d} fi,j,d 表示区间 [ l , r ] [l,r] [l,r] 所对应的笛卡尔树的根节点的祖先中有 d d d 个 k k k 值比自己小。那么它的左儿子节点，即区间 [ l , r t ] [l,rt] [l,rt] 的根节点的有贡献的祖先节点一定和它的祖先节点是一样的。但是它的右儿子节点，即区间 ( r t , r ] (rt,r] (rt,r] 的根节点不仅有它有的祖先节点，还包含它本身。因为笛卡尔树满足小根堆，所以它的左子树一定比他大且按顺序排列，因此数字的组合可能为 C j − i k − i C_{j-i}^{k-i} Cj−ik−i。转移方程为：
f i , j , d = ∑ k = i j { ∑ d = a k f i , k − 1 , d × f k + 1 , j , d + 1 × C j − i k − i ( a k ≠ − 1 ) ∑ d = 1 n f i , k − 1 , d × f k + 1 , j , d + 1 × C j − 1 k − i ( a k = − 1 ) f_{i,j,d}=\sum_{k=i}^{j}\left\{\begin{matrix} \sum_{d=a_k}f_{i,k-1,d}\times f_{k+1,j,d+1}\times C_{j-i}^{k-i}(a_k\ne-1)\\ \sum_{d=1}^{n}f_{i,k-1,d}\times f_{k+1,j,d+1}\times C_{j-1}^{k-i}(a_k=-1) \end{matrix}\right. fi,j,d=k=i∑j{∑d=akfi,k−1,d×fk+1,j,d+1×Cj−ik−i(ak=−1)∑d=1nfi,k−1,d×fk+1,j,d+1×Cj−1k−i(ak=−1)
code1
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N=100,M=1e9+7;
int t,n,l,r;
int a[N+5];
ll f[N+5],g[N+5],dp[N+5][N+5][N+5];
ll QuickPow(ll a,int b){
ll res=1;
while(b){
if(b&1)res=res*a%M;
a=a*a%M;
b>>=1;
}
return res;
}
void pre(int N){
f[0]=1;
for(int i=1;i<=N;i++)f[i]=f[i-1]*i%M;
g[N]=QuickPow(f[N],M-2);
for(int i=N-1;i>=0;i--)g[i]=g[i+1]*(i+1)%M;
return ;
}
ll C(int n,int m){
if(n<m||n<0||m<0)return 0;
return f[n]*g[n-m]%M*g[m]%M;
}
int main(){
pre(N);
scanf("%d",&t);
while(t--){
scanf("%d",&n);
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
for(int k=1;k<=n;k++)dp[i][j][k]=0;
}
}
for(int i=1;i<=n;i++)scanf("%d",&a[i]);
for(int i=n;i>=1;i--){
for(int j=i;j<=n;j++){
for(int k=i;k<=j;k++){
if(a[k]==-1){
l=1;
r=n;
}else l=r=a[k];
for(int d=l;d<=r;d++)dp[i][j][d]=(dp[i][j][d]+(i<k?dp[i][k-1][d]:1)*(k<j?dp[k+1][j][d+1]:1)%M*C(j-i,k-i)%M)%M;
}
}
}
printf("%lld\n",dp[1][n][1]);
}
return 0;
}
扫一扫
4531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
