[HDU5756] Boss Bo [2016 Multi-University Training Contest 3(2016多校联合训练3) E]

题意

给出一棵树，每次询问删掉一些子树问剩下的点到某个点P的距离和，距离最大值，距离最小值。

题解

求出$root$，也就是$1$号节点的$dfs$序，建一棵树，每个点的权值为它的深度减一，这样就可以求$P=1$的答案了。
考虑$1$的儿子$u$，$u$子树中节点的距离是到$1$的距离减一，不在$u$的子树中的节点是到$1$的距离加一，也就是对关于$1$号节点的线段树进行了区间的增减(因为一棵子树中的节点在$dfs$序中连续)，这就可以询问$u$的答案了。
那么对每个节点都如此操作，做成一棵有$n$个根的主席树就完成第一步了，在主席树上维护区间求和，区间最大值，区间最小值。
需要注意的是，这道题区间增减的标记并不需要像陈立杰《可持久化数据结构研究》中写的那样下传标记，因为操作单一。否则浪费空间（我是不知道为啥RE）。

对于每次询问，所给的子树都对应一些$dfs$序区间，我们把这些区间取并，然后取补集。这一步可以$sort$一下，这样整个序会有$K+1$段区间是合法的。 $\sum{K} = 200000$我们对于每一段区间进行询问即可。

效率：$O((N+Q+\sum{K}) \log N)$

代码

/****************************************\
* Author : ztx
* Title  : E - Boss Bo
* ALG    : 主席树,区间修改
* CMT    : 主席树的具体实现中在一个区间打了标记并不用再把标记下传。
也就是所谓的静态标记。查询过程中直接加上区间以及上层的lazy们代表的值就可以了
* Time   :
\****************************************/

#include <cstdio>
#define Rep(i,l,r) for(i=(l);i<=(r);i++)
#define rep(i,l,r) for(i=(l);i< (r);i++)
#define Rev(i,r,l) for(i=(r);i>=(l);i--)
#define rev(i,r,l) for(i=(r);i> (l);i--)
typedef long long ll ;
typedef double lf ;
int CH , NEG ;
template <typename TP>inline void read(TP& ret) {
    ret = NEG = 0 ; while (CH=getchar() , CH<'!') ;
    if (CH == '-') NEG = true , CH = getchar() ;
    while (ret = ret*10+CH-'0' , CH=getchar() , CH>'!') ;
    if (NEG) ret = -ret ;
}
template <typename TP>inline void readc(TP& ret) {
    while (ret=getchar() , ret<'!') ;
    while (CH=getchar() , CH>'!') ;
}
template <typename TP>inline void reads(TP *ret) {
    ret[0]=0;while (CH=getchar() , CH<'!') ;
    while (ret[++ret[0]]=CH,CH=getchar(),CH>'!') ;
    ret[ret[0]+1]=0;
}

#include <algorithm>

#define  infi  0x7f7f7f7fLL
#define  maxn  50010LL

int n, m, idx;
int in[maxn], out[maxn], dep[maxn];
int P, T, K;
ll ans;

/// Edges
#define  nxt(p) e[1][p]
#define  to(p)  e[0][p]
int e[2][maxn<<1] , star[maxn] , tote ;
inline void AddEdge(int u,int v) {
    tote ++ ; to(tote) = v ; nxt(tote) = star[u] ; star[u] = tote ;
}
/// The Tree
#define  maxt  5000010LL
#define  M (L+R)/2
struct node {
    node *lc, *rc;
    int sz, maxx, minn;
    ll sum, lazy;
    inline void maintain();
    inline void add(ll);
}nodes[maxt], *rt[maxn]; int tott ;
inline node* newnode(int sz,int w = 0) {
    nodes[++tott].sz = sz, nodes[tott].lazy = 0;
    nodes[tott].sum = nodes[tott].maxx = nodes[tott].minn = w ;
    return &nodes[tott] ;
}
inline node* copy(node *p) {
    nodes[++tott] = *p; return &nodes[tott];
}
inline void node::maintain() {
    sum = lc->sum + rc->sum + lazy*sz;
    maxx = std::max(lc->maxx,rc->maxx) + lazy;
    minn = std::min(lc->minn,rc->minn) + lazy;
}
inline void node::add(ll v) {
    lazy += v, sum += v*sz, maxx += v, minn += v;
}
void build(node*&o,int L,int R) {
    if (L == R) { o = newnode(1,dep[L]); return; } ;
    o = newnode(R-L+1);
    build(o->lc,L,M), build(o->rc,M+1,R);
    o->maintain();
}
int ql, qr;
void insert(node*last,node*&o,int L,int R) {
    o = copy(last);
    if (ql<=L && R<=qr) { o->add(-1); return ; }
    if (R<ql || L>qr) { o->add(1); return ; }
    insert(last->lc,o->lc,L,M); insert(last->rc,o->rc,M+1,R);
    o->maintain();
}
void query(node*o,int L,int R,ll lazys) {
    if (ql<=L && R<=qr) {
        if (T == 1) ans += o->sum+lazys*o->sz;
        if (T == 2) ans = std::min(ans,o->minn+lazys);
        if (T == 3) ans = std::max(ans,o->maxx+lazys);
        return;
    }
    if (ql<=M) query(o->lc,L,M,lazys+o->lazy);
    if (qr>M) query(o->rc,M+1,R,lazys+o->lazy);
}

/// dfs to build the tree 1
void dfs(int u,int fa,int d) {
    in[u] = ++idx, dep[idx] = d;
    for (int p = star[u]; p; p=nxt(p))
        if (to(p)!=fa) dfs(to(p),u,d+1);
    out[u] = idx;
}
void dfs(int u,int fa) {
    for (int p = star[u]; p; p=nxt(p))
        if (to(p)!=fa) {
            ql = in[to(p)], qr = out[to(p)];
            insert(rt[u],rt[to(p)],1,n);
            dfs(to(p),u);
        }
}
/// analyse the query
#define  maxk  50010LL
struct Seg {
    int l, r;
    bool operator <(const Seg&b) const { return l < b.l; }
}s[maxk]; int top;

inline void work() {
    int i, u, v;
    Rep (i,1,n) star[i] = 0;
    tote = idx = tott = 0;
    rep (i,1,n)
        read(u), read(v), AddEdge(u,v), AddEdge(v,u);
    dfs(1,0,0);
    build(rt[1],1,n);
    dfs(1,0);
    ans = 0;
    while (m --> 0) {
        read(K), read(P), read(T);
        if (ans == -1) ans = 0;
        P = ((ll)P+ans) % n + 1;
        Rep (i,1,K) {
            read(u);
            s[i].l = in[u], s[i].r = out[u];
            if (u == 1) ans = -1;
        }
        if (ans == -1) { puts("-1"); continue; }
        top = 0;
        if (K) {
            std::sort(s+1,s+K+1);
            top = 1;
            Rep (i,2,K)
                if (s[i].l > s[top].r) s[++top] = s[i];
        }
        s[0].r = 0;
        s[top+1].l = n+1;
        ans = (T==2?infi:0) ;
        Rep (i,0,top) {
            ql = s[i].r+1, qr = s[i+1].l-1 ;
            if (ql > qr) continue;
            query(rt[P],1,n,0);
        }
        printf("%lld\n", ans);
    }
}

int main() {
//  #define READ
    #ifdef  READ
        freopen(".in" ,"r",stdin ) ;
        freopen(".out","w",stdout) ;
    #endif
    while (scanf("%d%d",&n,&m)!=EOF) work() ;
    #ifdef  READ
        fclose(stdin) ; fclose(stdout) ;
    #else
        getchar() ; getchar() ;
    #endif
    return 0 ;
}