題目大意

給定一棵n個節點的樹，邊有邊權。m個操作：1. 給一條邊邊權加k；2.詢問一棵子樹第k小的深度。
修改操作的k和最初的邊權不超過一個給定的常數len

n,m≤100000 len≤10

分析

首先可以求出dfs序，轉化到序列上。
用數 據結構似乎無從下手，於是考慮分塊。
首先查詢是可以二分答案的，對於詢問區間完全包含掉的塊，預處理一個以權值為下標的陣列的字首和，可以O(1)查詢。
那麼對應的，修改操作對於未完全包含掉的塊，修改一個值的時候，對應的修改字首和陣列。可以發現修改一個點後，只會修改字首和陣列的len個位。
還剩下一個問題是字首和陣列規模可能很大。由於序列是樹的dfs序，如果這個陣列只開到區間的min到max，可以發現這相當於對於原樹的一個尤拉序遍歷，總的規模大約是2 * len * n的。
查詢一次複雜度O

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N=1e5+5,G=350,M=8e6+5;

typedef long long LL;

int n,m,len,h[N],nxt[N],l[N],dep[N],dfn[N],tot,cnt[N],Mi[N],Mx[N],St[N],Id[N],Size[N];

int typ[N],L[N],R[N],K[N],s[M],ch[N];

char
 
 c;

int read()
{
    int x=0,sig=1;
    for (c=getchar();c<'0' || c>'9';c=getchar()) if (c=='-') sig=-1;
    for (;c>='0' && c<='9';c=getchar()) x=x*10+c-48;
    return x*sig;
}

void dfs(int x)
{
    dfn[x]=++tot; ch[tot]=dep[x];
    Mi[Id[tot]]=min(Mi[Id[tot]],dep[x]);
    Mx[Id[tot]]=max(Mx[Id[tot]],dep[x]);
    for
 
 (int i=h[x];i;i=nxt[i])
    {
        dep[i]=dep[x]+l[i];
        dfs(i);
        Size[x]+=Size[i]+1;
    }
}

int main()
{
    n=read(); m=read(); len=read();
    Id[0]=-1;
    for (int i=2;i<=n;i++)
    {
        int f=read(); l[i]=read(); nxt[i]=h[f]; h[f]=i; Id[i]=i/G;
    }
    memset(Mi,127,sizeof(Mi));
    dfs(1);
    for (int i=0;i<m;i++)
    {
        typ[i]=read(); int x=read(); L[i]=dfn[x]; R[i]=L[i]+Size[x]; K[i]=read();
        if (typ[i]==2)
        {
            Mx[Id[L[i]]]+=K[i];
            if (Id[L[i]]!=Id[R[i]]) Mx[Id[R[i]]]+=K[i];
        }
    }
    for (int i=0;i<=Id[n];i++) St[i+1]=St[i]+Mx[i]-Mi[i]+1;
    for (int i=1;i<=n;i++) ch[i]-=Mi[Id[i]],s[St[Id[i]]+ch[i]]++;
    for (int i=0;i<=Id[n];i++)
        for (int j=St[i]+1;j<St[i+1];j++) s[j]+=s[j-1];
    for (int i=0;i<m;i++)
    {
        int l=L[i],r=R[i],k=K[i];
        if (typ[i]==2)
        {
            if (Id[l]==Id[r])
            {
                for (int j=l;j<=r;j++)
                {
                    for (int t=ch[j];t<ch[j]+k;t++) s[St[Id[l]]+t]--;
                    ch[j]+=k;
                }
                continue;
            }
            for (int j=Id[l]+1;j<Id[r];j++) Mi[j]+=k,Mx[j]+=k;
            for (int j=l;Id[j]==Id[l];j++)
            {
                for (int t=ch[j];t<ch[j]+k;t++) s[St[Id[l]]+t]--;
                ch[j]+=k;
            }
            for (int j=r;Id[j]==Id[r];j--)
            {
                for (int t=ch[j];t<ch[j]+k;t++) s[St[Id[r]]+t]--;
                ch[j]+=k;
            }
        }else
        {
            if (r-l+1<k)
            {
                printf("-1\n"); continue;
            }
            int Le=0,Ri=len*(n+i),mid;
            for (mid=Ri>>1;Le<Ri;mid=Le+Ri>>1)
            {
                int ss=0;
                if (Id[l]==Id[r])
                {
                    for (int j=l;j<=r;j++) if (ch[j]+Mi[Id[l]]<=mid) ss++;
                }else
                {
                    for (int j=l;Id[j]==Id[l];j++) if (ch[j]+Mi[Id[l]]<=mid) ss++;
                    for (int j=r;Id[j]==Id[r];j--) if (ch[j]+Mi[Id[r]]<=mid) ss++;
                    for (int j=Id[l]+1;j<Id[r];j++)
                    {
                        if (mid<Mi[j]) continue;
                        if (mid>Mx[j])
                        {
                            ss+=s[St[j+1]-1];
                            continue;
                        }
                        ss+=s[St[j]+mid-Mi[j]];
                    }
                }
                if (ss<k) Le=mid+1;else Ri=mid;
            }
            printf("%d\n",Le);
        }
    }
    return 0;
}