SPOJ 2666 QTREE4 - Query on a tree IV

第一次写链分治 ， 其实想清楚后写起来并不麻烦。
先看看论文吧！ qzc论文

首先 ， 你需要对树产生这样的一个印象：

首先 ， 这玩意被剖分了。 若干的个链之间有父子关系 ， 每次维护信息和普通的树链剖分没有很大区别。

这个题的主体思路还是延续了分治的思想 ， 每次我们都只处理经过链的答案（在树的点分治里是处理经过根的答案）由于点的下方可能连接多条链 ， 所以我们还需要维护一些大根堆来记录一些必要的信息。

这只是一个大概的轮廓 ， 论文里讲的很详细。 关于大根树我用的是multiset(注意删除操作)当然 ， 有兴趣的同学可以手写替代

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <deque>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>

using namespace std;
const int maxn = 2e5+1e2;
const int INF  = 0x3f3f3f3f;
struct edge{ int t , v; edge(int t=0 , int v=0):t(t),v(v){} };

int n , cs;
int c[maxn] , fa[maxn] , fv[maxn] , Size[maxn];
vector<edge> g[maxn];

void dfs(int u)
{
    Size[u] = 1;
    for(int i=0;i<g[u].size();i++)
    {
        edge& e = g[u][i];
        if(e.t == fa[u]) continue;
        fa[e.t] = u;
        fv[e.t] = e.v;
        dfs(e.t);
        Size[u] += Size[e.t];
    }
}

int dfsCnt , id[maxn] , reid[maxn] , bl[maxn] , prex[maxn] , s[maxn];
void dfs(int u , int num , int dis=0)
{
    id[u] = ++dfsCnt;
    bl[u] = num;

    prex[id[u]] = dis;
    reid[dfsCnt] = u;
    s[num]++;

    int mx = 0 , w , v;
    for(int i=0;i<g[u].size();i++)
    {
        edge& e = g[u][i];
        if(e.t == fa[u]) continue;
        if(Size[e.t] > mx) mx = Size[e.t] , w = e.t , v = e.v;
    }

    if(mx) dfs(w, num , dis+v);

    for(int i=0;i<g[u].size();i++)
    {
        edge& e = g[u][i];
        if(e.t == fa[u] || e.t == w) continue;
        dfs(e.t, e.t);
    }
}

template <typename T>
struct sortDescending
{
    bool operator ()(const T& l , const T& r)const { return l>r; }
};
multiset<int , sortDescending<int> > ch[maxn] , al[maxn];

struct node{ int op , l , r; node(int op=0 , int l=0 , int r=0):op(op),l(l),r(r){} };

int cnt , ls[maxn*4] , rs[maxn*4] , root[maxn];
node seg[maxn*4];

node merge(node& a , node& b , int l1 , int l2 , int l3)
{
    node res;
    res.l = max(a.l , l1+l2+b.l);
    res.r = max(b.r , l2+l3+a.r);
    res.op = max(a.op , b.op);
    res.op = max(res.op , a.r+b.l+l2);
    return res;
}

void maintain(int o , int x)
{
    int d1 = -INF , d2 = -INF; if(c[x]) d1 = d2 = 0;
    if(ch[x].size()) d1 = max(d1 , *ch[x].begin());
    if(ch[x].size()>1) d2 = max(d2 , *(++ch[x].begin()));
    seg[o].l = seg[o].r = d1;

    if(c[x]) seg[o].op = max(d1+d2 , d1);
    else seg[o].op = d1+d2;
    if(al[x].size()) seg[o].op = max(seg[o].op , *al[x].begin());
}

void build(int o , int l , int r)
{
    if(l==r)
    {
        int x = reid[l];
        for(int i=0;i<g[x].size();i++)
        {
            edge& e = g[x][i];
            if(bl[e.t] == bl[x] || e.t==fa[x]) continue;
            build(root[e.t] = ++cnt, id[e.t], id[e.t]+s[e.t]-1);
            ch[x].insert(seg[root[e.t]].l+e.v);
            al[x].insert(seg[root[e.t]].op);
        }

        maintain(o, x);
    }
    else 
    {
        int mid = (l+r)/2;
        build(ls[o] = ++cnt, l, mid);
        build(rs[o] = ++cnt, mid+1, r);
        seg[o] = merge(seg[ls[o]], seg[rs[o]] , prex[mid]-prex[l] , prex[mid+1]-prex[mid] , prex[r]-prex[mid+1]);
    }
}

deque<int> pat;
void findPath(int x)
{
    pat.clear();
    while(x)
    {
        int f = bl[x];
        pat.push_front(x);
        pat.push_front(f);
        x = fa[f];
    }
}

void modify(int o , int l , int r , int i)
{
    if(l == r)
    {
        int x = reid[l];
        if(i+1 < pat.size())
        {   
            int ne = pat[i+1];
            ch[x].erase(ch[x].find(seg[root[ne]].l + fv[ne]));
            al[x].erase(al[x].find(seg[root[ne]].op));
            modify(root[ne], id[ne], id[ne]+s[ne]-1, i+2);
            ch[x].insert(seg[root[ne]].l + fv[ne]);
            al[x].insert(seg[root[ne]].op);
        }
        maintain(o, x);
    }
    else 
    {
        int mid = (l+r)/2;
        if(id[pat[i]] <= mid) modify(ls[o], l, mid, i);
        else modify(rs[o], mid+1, r, i);
        seg[o] = merge(seg[ls[o]], seg[rs[o]] , prex[mid]-prex[l] , prex[mid+1]-prex[mid] , prex[r]-prex[mid+1]);
    }
}

int main(int argc, char *argv[]) {

    cin>>n;
    cs = n;
    for(int i=1;i<n;i++)
    {
        int a , b , c;
        scanf("%d%d%d" , &a , &b , &c);
        g[a].push_back(edge(b , c));
        g[b].push_back(edge(a , c));
    }
    for(int i=1;i<=n;i++) c[i] = 1;

    dfs(1);
    dfs(1, 1);
    build(root[1] = ++cnt, id[1], id[1]+s[1]-1);

    int Q;
    cin>>Q;

    while(Q--)
    {
        char oper[3];
        scanf("%s" , oper);
        if(oper[0]=='A') 
        {
            if(cs) printf("%d\n" , seg[1].op);
            else puts("They have disappeared.");
        }
        else 
        {
            int who;
            scanf("%d" , &who);
            cs += 1-c[who]*2;
            c[who] = 1-c[who];
            findPath(who);
            modify(1, 1, s[1], 1);
        }
    }

    return 0;
}