codeforces 502 g The Tree

题解：

一道优秀的题目

有几种做法：

1.维护后缀和

刚开始我想的是维护前缀和

然后用$sum[x]-sum[y]>=dep[x]-dep[y]$来做

但是这样子树赋值为0这个操作就很难进行了

因为你查找的是链上最小值，所以不改子树上面的节点是做不了的

那我们换一种方式，单点改，查询区间最大后缀和

这样子树染白的时候我们就可以在x处减去一个上面的最大后缀和，那么就对子树没有影响了

然后再把子树清空一下就可以

其实这个东西就是动态dp。。。

$$f(v)=max(f(x)-1,0)+v[v]$$

这个只用查询链

所以我们只需要维护$f[v]=MAX(f[top]必选时的最大值k1,任意情况最大值k2)$就可以了(v都是必选点）

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for(int i=h;i<=t;i++)
#define dep(i,t,h) for(int i=t;i>=h;i--)
#define ll long long
#define me(x) memset(x,0,sizeof(x))
#define mep(x,y) memcpy(x,y,sizeof(y))
#define mid ((h+t)>>1)
namespace IO{
    char ss[<<],*A=ss,*B=ss;
    IL char gc()
    {
        return A==B&&(B=(A=ss)+fread(ss,,<<,stdin),A==B)?EOF:*A++;
    }
    template<class T> void read(T &x)
    {
        rint f=,c; while (c=gc(),c<||c>) if (c=='-') f=-; x=(c^);
        while (c=gc(),c>&&c<) x=(x<<)+(x<<)+(c^); x*=f;
    }
    char sr[<<],z[]; ll Z,C1=-;
    template<class T>void wer(T x)
    {
        if (x<) sr[++C1]='-',x=-x;
        while (z[++Z]=x%+,x/=);
        while (sr[++C1]=z[Z],--Z);
    }
    IL void wer1()
    {
        sr[++C1]=' ';
    }
    IL void wer2()
    {
        sr[++C1]='\n';
    }
    template<class T>IL void maxa(T &x,T y) {if (x<y) x=y;}
    template<class T>IL void mina(T &x,T y) {if (x>y) x=y;}
    template<class T>IL T MAX(T x,T y){return x>y?x:y;}
    template<class T>IL T MIN(T x,T y){return x<y?x:y;}
};
using namespace IO;
const int N=2.1e5;
struct re{
    int a,b;
}e[N*];
int head[N],l,n,m;
IL void arr(int x,int y)
{
    e[++l].a=head[x];
    e[l].b=y;
    head[x]=l;
}
struct re2{
    int a[];
    re2() { a[]=a[]=; }
    re2(int x,int y) {a[]=x; a[]=y;};
    re2 operator *(const re2 &o) const
    {
        re2 c;
        c.a[]=a[]+o.a[]; c.a[]=MAX(a[]+o.a[],o.a[]);
        return c;
    }
};
int fa[N],num[N],son[N],dfn[N],top[N],cnt;
void dfs(int x,int y)
{
    num[x]=; fa[x]=y;
    for (rint u=head[x];u;u=e[u].a)
    {
        int v=e[u].b;
        if (v!=y)
        {
          dfs(v,x);
          num[x]+=num[v];
          if (num[son[x]]<num[v]) son[x]=v;
        }
    }
}
void dfs1(int x,int y,int z)
{
    top[x]=y; dfn[x]=++cnt;
    if (son[x]) dfs1(son[x],y,x);
    for (rint u=head[x];u;u=e[u].a)
    {
        int v=e[u].b;
        if (v!=z&&v!=son[x])
        {
            dfs1(v,v,x);
        }
    }
}
struct sgt{
    re2 sum[N*];
    bool lazy[N*];
    #define updata(x) sum[x]=sum[x*2]*sum[x*2+1]
    IL void down(int x,int h,int t)
    {
        if (lazy[x])
        {
            lazy[x*]=lazy[x*+]=; lazy[x]=;
            sum[x*]=re2(-(mid-h+),-);
            sum[x*+]=re2(-(t-mid),-);
        }
    }
    void build(int x,int h,int t)
    {
        if (h==t) { sum[x]=re2(-,-); return;}
        build(x*,h,mid); build(x*+,mid+,t);
        updata(x);
    }
    void change(int x,int h,int t,int pos,int k)
    {
        if (h==t) { sum[x]=re2(k,k);return; }
        down(x,h,t);
        if (pos<=mid) change(x*,h,mid,pos,k);
        else change(x*+,mid+,t,pos,k);
        updata(x);
    }
    re2 query(int x,int h,int t,int h1,int t1)
    {
        if (h1<=h&&t<=t1) return sum[x];
        down(x,h,t);
        if (h1<=mid&&mid<t1) return query(x*,h,mid,h1,t1)*query(x*+,mid+,t,h1,t1);
        else if (h1<=mid) return query(x*,h,mid,h1,t1);
        else return query(x*+,mid+,t,h1,t1);
    }
    void push(int x,int h,int t,int h1,int t1)
    {
        if (h1<=h&&t<=t1) { lazy[x]=; sum[x]=re2(-(t-h+),-); return;}
        down(x,h,t);
        if (h1<=mid) push(x*,h,mid,h1,t1);
        if (mid<t1) push(x*+,mid+,t,h1,t1);
        updata(x);
    }
}S;
IL int query(int x)
{
    int ans=-;
    re2 p1=re2(,-);
    while (x)
    {
        re2 p=S.query(,,n,dfn[top[x]],dfn[x]);
        p1=p*p1;
        ans=max(ans,p1.a[]);
        x=fa[top[x]];
    }
    return ans;
}
int main()
{
    freopen("1.in","r",stdin);
    freopen("1.out","w",stdout);
    read(n); read(m);
    rep(i,,n)
    {
        int x;
        read(x);
        arr(i,x); arr(x,i);
    }
    dfs(,); dfs1(,,);
    S.build(,,n);
    rep(i,,m)
    {
        int kk,x;
        read(kk); read(x);
        if (kk==)
        {
            S.change(,,n,dfn[x],S.query(,,n,dfn[x],dfn[x]).a[]+);
        }
        if (kk==)
        {
            S.push(,,n,dfn[x],dfn[x]+num[x]-);
            int ans=query(x);
            S.change(,,n,dfn[x],-ans-);
        }
        if (kk==)
        {
            if (query(x)>=) cout<<"black"<<endl;
            else cout<<"white"<<endl;
        }
    }
    return ;
}

2.操作分块

分块这个东西有的时候的确简单巧妙。。

但一般我也不会去想分块。。

这个是看了别人题解的。。

我们以每$\sqrt{n}$个元素分一组

对块内的操作，我们等待$\sqrt{n}$都做完了再把这$\sqrt{n}$个操作加入树中

对于当前的询问，我们只需要树内的$\sqrt{n}$个节点的信息就可以了

我们可以建立虚树维护

本来打算学树上分块的。。。但发现这东西并没有啥用

会线段树合并/dsu on tree/树上莫队 应该不会也没啥关系

像这种利用虚树的题目还是比较多的