bzoj 4009 [HNOI2015]接水果树套树

最新推荐文章于 2018-11-22 12:00:00 发布

原创最新推荐文章于 2018-11-22 12:00:00 发布 · 818 阅读

0 ·

CC 4.0 BY-SA版权

树套树专栏收录该内容

9 篇文章

订阅专栏

本文探讨了如何通过特定条件判断水果是否能落入指定盘子的问题，并将其转化为平面几何中的矩形查询问题。采用离线处理的方式，利用线段树进行高效求解。

考虑满足什么条件的水果(x1,y1)会落在指定盘子(x2,y2)上：

如果x2,y2为祖先孩子关系，设x2是y2的祖先，t是x2到y2路径上第二个点那么x1,y1一定满足x1在y2子树中，y1在x2子树外。
在子树中可以表示为dfs序中一段，在子树外可以表示为两段。

否则x1一定在x2子树中，y1一定在y2子树中。

这样问题就转化成平面上一些矩形，每个矩形有权值，一些询问，求包含一个点的权值第k小的矩形。

离线下来，把一维的矩形坐标拆成在x1处+1，x2+1处-1。排一下序。然后就变成了一个二维问题。

需要普通线段树维护位置，权值线段树维护第K大。

由于外层树结构不支持区间修改，因此需要权值线段树套普通线段树。

#include <bits/stdc++.h>
using namespace std;
#define N 41000
#define M 21000000
int n,m,q,tot,cnt,top;
int lq,rq,type;
int head[N],nex[N<<1],to[N<<1],deep[N],fa[N][21];
int pos[N],beg[N],en[N],ans[N],st[N];
struct node
{
    int pos,beg,en,val,type;
    friend bool operator < (const node &r1,const node &r2)
    {return r1.pos<r2.pos;};
}a[N<<3];
struct poi
{
    int u,v,K,pos;
    void read(){scanf("%d%d%d",&u,&v,&K);}
    friend bool operator < (const poi &r1,const poi &r2)
    {return r1.u<r2.u;};
}p[N];
void add(int x,int y)
{
    tot++;
    nex[tot]=head[x];head[x]=tot;
    to[tot]=y;
}
void dfs(int x,int y)
{
    fa[x][0]=y;
    for(int i=1;i<=20;i++)
        fa[x][i]=fa[fa[x][i-1]][i-1];

    deep[x]=deep[y]+1;
    pos[x]=++cnt;beg[x]=cnt;
    for(int i=head[x];i;i=nex[i])
        if(to[i]!=y)dfs(to[i],x);
    en[x]=cnt;
}
int up(int x,int y)
{
    for(int i=0;i<=20;i++)
        if(y>>i&1)x=fa[x][i];
    return x;
}
void Ins(int l1,int r1,int l2,int r2,int v)
{
    a[++cnt]=(node){l1,l2,r2,v,1};
    a[++cnt]=(node){r1+1,l2,r2,v,-1};
}
void ins(int l1,int r1,int l2,int r2,int v)
{
    if(l2>r2)return;
    Ins(l1,r1,l2,r2,v);Ins(l2,r2,l1,r1,v);
}
struct seg_tree
{
    int ch[M][2],num[M],cnt;
    void insert(int l,int r,int &now)
    {
        if(!now)now=++cnt;
        if(lq<=l&&r<=rq)
            {num[now]+=type;return;}
        int mid=(l+r)>>1;
        if(mid>=lq)insert(l,mid,ch[now][0]);
        if(mid<rq) insert(mid+1,r,ch[now][1]);
    }
    int query(int l,int r,int now,int pos)
    {
        if(l==r)return num[now];
        int mid=(l+r)>>1;
        if(mid>=pos)return num[now]+query(l,mid,ch[now][0],pos);
        else return num[now]+query(mid+1,r,ch[now][1],pos);
    }
}tr2;
struct val_tree
{
    int root[N<<2];
    void insert(int l,int r,int now,int v)
    {
        tr2.insert(1,n,root[now]);
        if(l==r)return;
        int mid=(l+r)>>1;
        if(mid>=v)insert(l,mid,now<<1,v);
        else insert(mid+1,r,now<<1|1,v);
    }
    int query(int l,int r,int now,int rem,int pos)
    {
        if(l==r)return st[l];
        int mid=(l+r)>>1;
        int sum=tr2.query(1,n,root[now<<1],pos);
        if(sum>=rem)return query(l,mid,now<<1,rem,pos);
        else return query(mid+1,r,now<<1|1,rem-sum,pos);
    }
}tr1;
int main()
{
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1,x,y;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    dfs(1,0);cnt=0;
    for(int i=1,x,y,v;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&v);st[++top]=v;
        if(deep[x]>deep[y])swap(x,y);
        if(beg[x]<=beg[y]&&en[y]<=en[x])
        {
            int t=up(y,deep[y]-deep[x]-1);
            ins(beg[y],en[y],1,beg[t]-1,v);
            ins(beg[y],en[y],en[t]+1,n,v);
        }
        else ins(beg[x],en[x],beg[y],en[y],v);
    }
    sort(st+1,st+1+top);
    top=unique(st+1,st+1+top)-st-1;
    for(int i=1;i<=cnt;i++)
        a[i].val=lower_bound(st+1,st+1+top,a[i].val)-st;
    sort(a+1,a+1+cnt);

    for(int i=1;i<=q;i++)
    {
        p[i].read(),p[i].pos=i;
        p[i].u=pos[p[i].u];p[i].v=pos[p[i].v];
    }
    sort(p+1,p+1+q);
    for(int i=1,now=1;i<=q;i++)
    {
        while(now<=cnt&&a[now].pos<=p[i].u)
        {
            lq=a[now].beg,rq=a[now].en;type=a[now].type;
            tr1.insert(1,top,1,a[now].val);now++;
        }
        ans[p[i].pos]=tr1.query(1,top,1,p[i].K,p[i].v);
    }
    for(int i=1;i<=q;i++)
        printf("%d\n",ans[i]);
    return 0;
}