笛卡尔树

时间:2019-09-27
本文章向大家介绍笛卡尔树,主要包括笛卡尔树使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

听上去有丶厉害,实际也很巧妙

学习了这两篇:ReMoon - 单调栈的应用 --- 笛卡尔树与虚树

       ACM算法日常 - 算法合集 | 神奇的笛卡尔树 - HDU 1506


~ 简介 ~

虽然名字中带有“树”,但是笛卡尔树其实是对于一个序列的转化,并通过这个转化获得更多此序列的信息

对于一个简单的序列:$2,8,5,7,1,4$,我们可以建立如下的笛卡尔树($pos$表示原序列中的位置,$val$表示该位置的值)

笛卡尔树有这样的基本性质:

   对于树上的任意一点$x$和左右儿子$left,right$,有:

   1. $pos[left]<pos[x]<pos[right]$

   2. $val[x]<val[left],val[right]$

即一般讲解所说的$pos$满足二叉查找树,$val$满足堆

直观点说,就是这两条延伸性质:

   以树上任意一点$x$为根构成的子树中,

   1. 各节点的$pos$是连续的,且对$pos$的先序遍历即为原序列顺序(由$pos$满足二叉查找树可得)

   2. $x$点的$val$为全子树最小(由$val$满足堆可得)


~ 建树 ~

有了对笛卡尔树结构的了解,现在考虑怎么建立这棵树

【方法一】优先满足$val$

要想优先满足$val$的条件,那就必须从顶向下建树了

利用上面的延伸性质2,每次选取当前区间$[l,r]$中$val$的最小值所在的$pos$(记$pos=i$)作为子树的根节点

然后对于$[l,i-1],[i+1,r]$递归地不断重复上述过程

其中选取区间$val$最小值所在的$pos$可以使用线段树优化

总复杂度$O(nlogn)$

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N=100005;
const int INF=1<<30;

int n;
int val[N];

int sz;
int t[N<<2];

inline void Add(int i)
{
    int k=i+sz-1;
    t[k]=i;
    k>>=1;
    while(k)
    {
        int left=t[k<<1],right=t[k<<1|1];
        t[k]=(val[left]<val[right]?left:right);
        k>>=1;
    }
}

inline int Query(int k,int l,int r,int a,int b)
{
    if(a>r || b<l)
        return 0;
    if(a>=l && b<=r)
        return t[k];
    
    int mid=(a+b)>>1;
    int left=Query(k<<1,l,r,a,mid),right=Query(k<<1|1,l,r,mid+1,b);
    return (val[left]<val[right]?left:right);
}

void Init()
{
    sz=1;
    while(sz<n)
        sz<<=1;
    
    val[0]=INF;
    for(int i=1;i<(sz<<1);i++)
        t[i]=0;
    for(int i=1;i<=n;i++)
        Add(i);
}

int ls[N],rs[N];

inline int Build(int l,int r)
{
    if(l>r)
        return 0;
    
    int pos=Query(1,l,r,1,sz);
    ls[pos]=Build(l,pos-1);
    rs[pos]=Build(pos+1,r);
    return pos;
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&val[i]);
    
    Init();
    int root=Build(1,n);
    
/*    for(int i=1;i<=n;i++)
        printf("i=%d: ls=%d rs=%d\n",i,ls[i],rs[i]);*/
    return 0;
}
View Code

【方法二】优先满足$pos$

由于对于子树的先序遍历是原序列顺序,所以考虑按$i=1\text{ ~ }n$的顺序依次加入节点并调整树的结构,使得当前的树为子序列$[1,i]$所构成的笛卡尔树

由于$pos$满足二叉排序树,而$i$在区间$[1,i]$中$pos$最大,所以$i$插入的位置为 序列$[1,i-1]$所构成的笛卡尔树的根节点 一直向右儿子走、直到走到了空节点

这样插入后,$i$的$pos$已经满足要求了,但是$val$却不一定满足堆

于是考虑怎么调整当前的树

若$i$的$val$不满足要求,即存在某(些)祖先$j$,使得$j$为根的子树中$val$全大于$val[i]$;显然我们需要通过调整$i$的位置,使得$i$成为$j$的祖先

是这样操作的:

   0. 刚刚插入完成后,可能树是这样的

    

   1. 将$i$向上一层移动;这时由于$pos[k]<pos[i]$,所以$k$成为$i$的左儿子,$k'$依然是$k$的左儿子

   

   2. 继续将$i$向上一层移动,相似的,$j$也应当属于$i$的左子树;不妨让$j$为$i$的左儿子,$k$为$j$的右儿子(使用这种调整方法,$j,k,k'$相互间与原来的连边相同

   

以上的调整操作都是在$[1,i-1]$序列构成的笛卡尔树的最右链(即从根节点一直向右儿子走的这条路径)上进行的

在处理完后,我们对比一下调整前后的树结构,发现只有很少的地方出现了变化:

   1. $k$的右儿子变成了空节点

   2. $j$的父亲变成了$i$,且$j$是$i$的左儿子

   3. $i$继承了原来$j$的父亲

事实上,即使$i$到$j$的路径很长很长,一共也只有这三个地方发生了变化,所以我们的调整不是很复杂

现在最大的问题变成,如何找到$j$

目光回到最右链上,由于$val$满足堆,于是最右链上的各节点$val$是单调递增的;可以考虑用单调栈维护,栈中装的是最右链上节点的$pos$

而我们要找的$j$,就是$val[j]<val[i]$、且最靠近栈底的元素

原理理解了之后,重新整理一下思路,尽量简单清楚地建笛卡尔树:

   1. 用单调栈维护最右链

   2. 每次插入当前的$i$,在单调栈中不停弹出栈顶,直到栈顶$fa$满足$val[fa]<val[i]$,则最后一次弹出的就是$j$

   3. 将$i$作为$fa$的右儿子,$j$作为$i$的左儿子

是不是很简单owo

复杂度$O(n)$,是相当优秀的一种方法

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

const int N=100005;

int n;
int a[N];

int root;
int ls[N],rs[N];
vector<int> v;

void Build()
{
    for(int i=1;i<=n;i++)
    {
        int j=0;
        while(v.size() && a[v.back()]>a[i])
        {
            j=v.back();
            v.pop_back();
        }
        
        if(!v.size())
            root=i;
        else
            rs[v.back()]=i;
        
        ls[i]=j;
        v.push_back(i);
    }
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    
    Build();
    
/*    for(int i=1;i<=n;i++)
        printf("i=%d ls=%d rs=%d\n",i,ls[i],rs[i]);*/
    return 0;
}
View Code

所以在一些情况下,笛卡尔树的题目可以不用建树,直接用单调栈就够了


~应用~

最简单的一个应用是求元素的左右延伸区间

具体点说,就是对于一个数列$a$,询问以$a[i]$为区间最大(小)值的最长区间

使用笛卡尔树,就可以通过$O(n)$的预处理做到$O(1)$查询:进行中序遍历,每个节点$x$的子树的$pos$最小、最大值就是答案

模板题:HDU 1506 ($Largest\ Rectangle\ in\ a\ Histogram$)

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

typedef long long ll;
const int N=100005;

int n;
int a[N];

int root;
int ls[N],rs[N];
vector<int> v;

void Build()
{
    v.clear();
    memset(ls,0,sizeof(ls));
    memset(rs,0,sizeof(rs));
    
    for(int i=1;i<=n;i++)
    {
        int j=0;
        while(v.size() && a[v.back()]>a[i])
        {
            j=v.back();
            v.pop_back();
        }
        
        if(!v.size())
             root=i;
        else
            rs[v.back()]=i;
        
        ls[i]=j;
        v.push_back(i);
    }
}

int l[N],r[N];

void dfs(int x)
{
    l[x]=r[x]=x;
    
    if(ls[x])
    {
        dfs(ls[x]);
        l[x]=l[ls[x]];
    }
    if(rs[x])
    {
        dfs(rs[x]);
        r[x]=r[rs[x]];
    }
}

int main()
{
    scanf("%d",&n);
    while(n)
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        
        Build();
        
        dfs(root);
        
        ll ans=0;
        for(int i=1;i<=n;i++)
            ans=max(ans,ll(a[i])*(r[i]-l[i]+1));
        printf("%lld\n",ans);
        
        scanf("%d",&n);
    }
    return 0;
}
View Code

一个稍微高级一点的应用,就是给出分治的边界

一道不错的题:Luogu P4755 ($Beautiful\ Pair$)

官方题解已经很完善了:FlierKing - 题解 P4755 【Beautiful Pair】

简单点说,就是每次取当前区间$[l,r]$的最大值$a_i$,那么$i$即为笛卡尔树中 此区间对应子树的根节点

于是将区间分成两部分$[l,i-1],[i+1,r]$的操作,就可以转化成笛卡尔树上的分治

同时,这个题解将“统计$[l,r]$中$a_i\leq x$的数量”这个主席树问题,离线后通过拆分转化为树状数组问题,设计十分巧妙

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
const int N=100005;

int n;
int a[N];

int root;
int ls[N],rs[N];
vector<int> v;

void Build()
{
    for(int i=1;i<=n;i++)
    {
         int j=0;
        while(v.size() && a[v.back()]<a[i])
        {
            j=v.back();
            v.pop_back();
        }
        
        if(!v.size())
            root=i;
        else
            rs[v.back()]=i;
        
        ls[i]=j;
        v.push_back(i);
    }
}

int l[N],r[N];

inline void dfs(int x)
{
    if(ls[x])
    {
        dfs(ls[x]);
        l[x]=l[ls[x]];
    }
    else
        l[x]=x;
    if(rs[x])
    {
        dfs(rs[x]);
        r[x]=r[rs[x]];
    }
    else
        r[x]=x;
}

vector<pii> add[N];

inline void Solve(int x)
{
    int lp=x-l[x],rp=r[x]-x;
    if(lp<rp)
        for(int i=l[x];i<=x;i++)
        {
            add[r[x]].push_back(pii(a[x]/a[i],1));
            add[x-1].push_back(pii(a[x]/a[i],-1));
        }
    else
        for(int i=x;i<=r[x];i++)
        {
            add[x].push_back(pii(a[x]/a[i],1));
            add[l[x]-1].push_back(pii(a[x]/a[i],-1));
        }
    
    if(ls[x])
        Solve(ls[x]);
    if(rs[x])
        Solve(rs[x]);
}

vector<int> pos;

int t[N];

inline int lowbit(int x)
{
    return x&(-x);
}

inline void Add(int k,int x)
{
    for(int i=k;i<=n;i+=lowbit(i))
        t[i]+=x;
}

inline int Query(int k)
{
    int res=0;
    for(int i=k;i;i-=lowbit(i))
        res+=t[i];
    return res;
}

int main()
{
    scanf("%d",&n);
    pos.push_back(0);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]),pos.push_back(a[i]);
    
    sort(pos.begin(),pos.end());
    pos.resize(unique(pos.begin(),pos.end())-pos.begin());
    
    Build();
    dfs(root);
    
    Solve(root);
    
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        int p=lower_bound(pos.begin(),pos.end(),a[i])-pos.begin();
        Add(p,1);
        
        for(int j=0;j<add[i].size();j++)
        {
            int lim=lower_bound(pos.begin(),pos.end(),add[i][j].first)-pos.begin();
            if(pos[lim]>add[i][j].first)
                lim--;
            
            ans=ans+add[i][j].second*Query(lim);
        }
    }
    printf("%lld\n",ans);
    return 0;
}
View Code

学完之后立马就现场碰到基本一样的题...

牛客ACM 883G ($Removing\ Stones$,2019牛客暑期多校训练营(第三场))

只不过对于当前区间,是遍历较小的那一半、并在另一半二分

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long ll;
const int N=300005;

int n;
int a[N];
ll p[N];

int root;
int ls[N],rs[N];
vector<int> v;

void Build()
{
    for(int i=1;i<=n;i++)
    {
        int j=0;
        while(v.size() && a[v.back()]<a[i])
        {
            j=v.back();
            v.pop_back();
        }
        
        if(!v.size())
            root=i;
        else
            rs[v.back()]=i;
        
        ls[i]=j;
        v.push_back(i);
    }
}

int l[N],r[N];

inline void dfs(int x)
{
    if(ls[x])
    {
        dfs(ls[x]);
        l[x]=l[ls[x]];
    }
    else
        l[x]=x;
    if(rs[x])
    {
        dfs(rs[x]);
        r[x]=r[rs[x]];
    }
    else
        r[x]=x;
}

ll ans=0;

void Solve(int x)
{
    ll sum=0;
    int lp=x-l[x]+1,rp=r[x]-x+1;
    
    int left,right,mid;
    if(lp<rp)
        for(int i=x;i>=l[x];i--)
        {
            sum+=a[i];
            left=x,right=r[x]+1,mid;
            while(left<right)
            {
                mid=(left+right)>>1;
                if(sum+p[mid]-p[x]<2LL*a[x])
                    left=mid+1;
                else
                    right=mid;
            }
            
            ans+=r[x]-left+1;
        }
    else
        for(int i=x;i<=r[x];i++)
        {
            sum+=a[i];
            left=l[x],right=x,mid;
            while(left<right)
            {
                mid=(left+right)>>1;
                if(sum+p[x-1]-p[mid-1]>=2LL*a[x])
                    left=mid+1;
                else
                    right=mid;
            }
            if(sum+p[x-1]-p[left-1]<2LL*a[x])
                left--;
            
            ans+=left-l[x]+1;
        }
    
    if(ls[x])
        Solve(ls[x]);
    if(rs[x])
        Solve(rs[x]);
}

void Clear()
{
    ans=0;
    v.clear();
    for(int i=1;i<=n;i++)
        ls[i]=rs[i]=0;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        Clear();
        
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]),p[i]=p[i-1]+a[i];
        
        Build();
        dfs(root);
        
        Solve(root);
        printf("%lld\n",ans);
    }
    return 0;
}
View Code

一道比较明显的题:HDU 6701 ($Make\ Rounddog\ Happy$,$2019\ Multi-University\ Training\ Contest\ 10$)

由于需要对$a_l,...,a_r$求max,所以能比较自然地想到笛卡尔树上分治

然后就是处理区间内数字不同的限制;不过也并不困难,只要正向、反向各扫一遍就能预处理出来$i$向左、向右不出现重复数字的最大延伸长度了

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long ll;
const int N=300005;

int n,k;
int a[N];

int root;
int ls[N],rs[N];
vector<int> v;

void Build()
{
    v.clear();
    for(int i=1;i<=n;i++)
    {
        int j=0;
        while(v.size() && a[v.back()]<a[i])
        {
            j=v.back();
            v.pop_back();
        }
        
        if(!v.size())
            root=i;
        else
            rs[v.back()]=i;
        
        ls[i]=j;
        v.push_back(i);
    }
}

int l[N],r[N];

void dfs(int x)
{
    l[x]=r[x]=x;
    if(ls[x])
        dfs(ls[x]),l[x]=l[ls[x]];
    if(rs[x])
        dfs(rs[x]),r[x]=r[rs[x]];
}

int cnt[N];
int L[N],R[N];

ll ans=0;

void Solve(int x)
{
    int lp=x-l[x],rp=r[x]-x;
    if(lp<rp)
    {
        for(int i=l[x];i<=x;i++)
            ans+=max(0,min(R[i],r[x])-max(a[x]-k+i-1,x)+1);
    }
    else
    {
        for(int i=x;i<=r[x];i++)
            ans+=max(0,min(k-a[x]+i+1,x)-max(L[i],l[x])+1);
    }
    
    if(ls[x])
        Solve(ls[x]);
    if(rs[x])
        Solve(rs[x]);
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&k);
        ans=0;
        for(int i=1;i<=n;i++)
            ls[i]=rs[i]=0;
        
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        
        Build();
        dfs(root);
        
        int j=1;
        for(int i=1;i<=n;i++)
        {
            cnt[a[i]]++;
            while(cnt[a[i]]>1)
            {
                R[j]=i-1;
                cnt[a[j]]--;
                j++;
            }
        }
        for(int i=j;i<=n;i++)
            R[i]=n,cnt[a[i]]--;
        
        j=n;
        for(int i=n;i>=1;i--)
        {
            cnt[a[i]]++;
            while(cnt[a[i]]>1)
            {
                L[j]=i+1;
                cnt[a[j]]--;
                j--;
            }
        }
        for(int i=j;i>=1;i--)
            L[i]=1,cnt[a[i]]--;
        
        Solve(root);
        
        printf("%lld\n",ans);
    }
    return 0;
}
View Code

标算是左偏树,不过用笛卡尔树+倍增也能搞过去:HDU 5575 ($Discover\ Water\ Tank$,$2015\ ACM/ICPC$上海)

首先可以根据隔板的高度,对于$n-1$个隔板建立一个大根笛卡尔树

有了这棵笛卡尔树,我们可以考虑利用它来划分出分治区间

比如,对于笛卡尔树根节点对应原序列的位置$pos_{root}$,相当于将$1\text{~}n$的区间划分成两部分$[1,pos_{root}],[pos_{root}+1,n]$,且每部分的水位最高都不超过$h[pos_{root}]$;其余节点的划分同理

我们先将每个查询分配到划分树上,具体方法是,先倍增出每个划分树节点的父亲关系,然后对于每个查询$\{x,y,w\}$,从$[x,x]$对应的区间,向上找到树上最深的 水位限制大于等于$y$的祖先,并将这个查询扔到那个节点的vector中

于是考虑树形dp

对于一个区间,要不将它整体灌满,要不不灌满、并向下递归;所以对于每个划分树上的节点,分别记录灌满和不灌满的 最多正确询问数

注意$y$的边界即可(我的处理是将每个$y++$)

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

struct Query
{
    int x,y,w;
    Query(int a,int b,int c)
    {
        x=a,y=b,w=c;
    }
};
inline bool operator <(Query A,Query B)
{
    return A.y<B.y;
}
inline bool operator >(Query A,Query B)
{
    return A.y>B.y;
}

const int INF=1<<30;
const int N=200005;
const int LOG=20;

int n,m;
int h[N];

struct Cartesian
{
    int root;
    int ls[N],rs[N];
    vector<int> v;
    
    void clear()
    {
        root=0;
        v.clear();
        for(int i=1;i<n;i++)
            ls[i]=rs[i]=0;
    }
    
    void build()
    {
        for(int i=1;i<n;i++)
        {
            int j=0;
            while(v.size() && h[v.back()]<h[i])
            {
                j=v.back();
                v.pop_back();
            }
            
            if(!v.size())
                root=i;
            else
                rs[v.back()]=i;
            
            ls[i]=j;
            v.push_back(i);
        }
    }
}tree;

int tot;
int lb[N],rb[N],lim[N];
int ls[N],rs[N];
int fa[N][LOG];

int place[N];

void Build(int x,int y,int l,int r,int f)
{
    lb[x]=l,rb[x]=r;
    fa[x][0]=f;
    if(l==r)
    {
        place[l]=x;
        return;
    }
    
    ls[x]=++tot;
    lim[tot]=h[y];
    Build(tot,tree.ls[y],l,y,x);
    
    rs[x]=++tot;
    lim[tot]=h[y];
    Build(tot,tree.rs[y],y+1,r,x);
}

int sum[N],sub[N];
vector<Query> v[N];

void dfs(int x)
{
    if(ls[x])
        dfs(ls[x]);
    if(rs[x])
        dfs(rs[x]);
    
    int empty=0,full=0;
    for(int i=0;i<v[x].size();i++)
    {
        Query tmp=v[x][i];
        if(tmp.w==0)
            empty++;
    }
    
    sub[x]=sub[ls[x]]+sub[rs[x]]+empty;
    for(int i=0;i<v[x].size();)
    {
        int j=i;
        while(j<v[x].size() && v[x][i].y==v[x][j].y)
        {
            Query tmp=v[x][j];
            if(tmp.w==0)
                empty--;
            if(tmp.w==1)
                full++;
            j++;
        }
        i=j;
        
        sub[x]=max(sub[x],sum[ls[x]]+sum[rs[x]]+full+empty);
    }
    sum[x]=sum[ls[x]]+sum[rs[x]]+full;
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int kase=1;kase<=T;kase++)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<n;i++)
            scanf("%d",&h[i]);
        
        tree.clear();
        tree.build();
        
        for(int i=1;i<=tot;i++)
        {
            v[i].clear();
            ls[i]=rs[i]=fa[i][0]=0;
            sum[i]=sub[i]=0;
        }
        tot=1;
        
        lim[1]=INF;
        Build(1,tree.root,1,n,0);
        
        for(int i=1;i<LOG;i++)
            for(int j=1;j<=tot;j++)
                fa[j][i]=fa[fa[j][i-1]][i-1];
        
        for(int i=1;i<=m;i++)
        {
            int x,y,w;
            scanf("%d%d%d",&x,&y,&w);
            Query tmp(x,++y,w);
            
            int p=place[x];
            for(int j=LOG-1;j>=0;j--)
                if(fa[p][j] && y>lim[fa[p][j]])
                    p=fa[p][j];
            if(y>lim[p])
                p=fa[p][0];
    
            v[p].push_back(tmp);
        }
        
        for(int i=1;i<=tot;i++)
            sort(v[i].begin(),v[i].end());
        
        dfs(1);
        printf("Case #%d: %d",kase,sub[1]);
        putchar('\n');
    }
    return 0;
}
View Code

一般都是银牌题难度的样子吧,平常见的不多,遇到再补充

(完)

原文地址:https://www.cnblogs.com/LiuRunky/p/Cartesian_Tree.html