bzoj1095

动态点分治

先建出点分树，每个点上维护两个堆，s1,s2,分别表示子树中到点分树中父亲的所有长度，每个儿子s1的最大值，那么对于每个点答案就是s2的最大+次大，再维护一个s3保存这个。

首先我们要搞一个带删除的堆，那么我们开两个堆就行了，一个保存元素，一个保存被删除的元素，每次一起弹出就行了

然后是为什么要维护三个堆，每个点记录所有儿子的路径不行吗》这里我想了很长时间，其实很简单，因为记录路径的话有可能最大和次大都是从一个儿子里来的。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + ;
int rd()
{
    int x = , f = ; char c = getchar();
    while(c < '' || c > '') { if(c == '-') f = -; c = getchar(); }
    while(c >= '' && c <= '') { x = x *  + c - ''; c = getchar(); }
    return x * f;
}
int n, sum, m, root;
int size[N], f[N], vis[N], val[N], dep[N], fa[N][], Fa[N];
vector<int> G[N];
struct Heap {
    priority_queue<int> A, B;
    void push(int x) { A.push(x); }
    void del(int x) { B.push(x); }
    int top()
    {
        while(!A.empty() && !B.empty() && A.top() == B.top()) A.pop(), B.pop();
        return A.top();
    }
    int sum()
    {
        int x = top();
        A.pop();
        int y = top();
        A.push(x);
        return x + y;
    }
    int size()
    {
        return A.size() - B.size();
    }
} s1[N], s2[N], s3;
void erase(Heap &s)
{
    if(s.size() > ) s3.del(s.sum());
}
void Insert(Heap &s)
{
    if(s.size() > ) s3.push(s.sum());
}
void dfs(int u, int last)
{
    for(int i = ; i < G[u].size(); ++i)
    {
        int v = G[u][i];
        if(v == last) continue;
        fa[v][] = u;
        dep[v] = dep[u] + ;
        dfs(v, u);
    }
}
int lca(int u, int v)
{
    if(dep[u] < dep[v]) swap(u, v);
    int d = dep[u] - dep[v];
    for(int i = ; i >= ; --i)
        if(d & ( << i))
            u = fa[u][i];
    if(u == v) return u;
    for(int i = ; i >= ; --i)
        if(fa[u][i] != fa[v][i])
            u = fa[u][i],
            v = fa[v][i];
    return fa[u][];
}
int getsize(int u, int last)
{
    int ret = ;
    for(int i = ; i < G[u].size(); ++i)
    {
        int v = G[u][i];
        if(v == last || vis[v]) continue;
        ret += getsize(v, u);
    }
    return ret;
}
void getroot(int u, int last, int S)
{
    f[u] = ;
    size[u] = ;
    for(int i = ; i < G[u].size(); ++i)
    {
        int v = G[u][i];
        if(v == last || vis[v]) continue;
        getroot(v, u, S);
        size[u] += size[v];
        f[u] = max(f[u], size[v]);
    }
    f[u] = max(f[u], S - size[u]);
    if(f[u] < f[root]) root = u;
}
void divide(int u)
{
    vis[u] = ;
    for(int i = ; i < G[u].size(); ++i)
    {
        int v = G[u][i];
        if(vis[v]) continue;
        root = ;
        getroot(v, u, getsize(v, u));
        Fa[root] = u;
        divide(root);
    }
}
int dis(int u, int v)
{
    int x = lca(u, v);
    return dep[u] + dep[v] -  * dep[x];
}
void join(int u)
{
    int tmp = u;
    erase(s2[u]);
    s2[u].push();
    Insert(s2[u]);
    while(Fa[u])
    {
        erase(s2[Fa[u]]);
        if(s1[u].size()) s2[Fa[u]].del(s1[u].top());
        s1[u].push(dis(Fa[u], tmp));
        s2[Fa[u]].push(s1[u].top());
        Insert(s2[Fa[u]]);
        u = Fa[u];
    }
}
void remove(int u)
{
    int tmp = u;
    erase(s2[u]);
    s2[u].del();
    Insert(s2[u]);
    while(Fa[u])
    {
        erase(s2[Fa[u]]);
        s2[Fa[u]].del(s1[u].top());
        s1[u].del(dis(tmp, Fa[u]));
        if(s1[u].size()) s2[Fa[u]].push(s1[u].top());
        Insert(s2[Fa[u]]);
        u = Fa[u];
    }

}
int main()
{
    f[] = 1e9;
    n = sum = rd();
    for(int i = ; i < n; ++i)
    {
        int u = rd(), v = rd();
        G[u].push_back(v);
        G[v].push_back(u);
    }
    dfs(, );
    for(int j = ; j <= ; ++j)
        for(int i = ; i <= n; ++i)
            fa[i][j] = fa[fa[i][j - ]][j - ];
    getroot(, , getsize(, ));
    divide(root);
    m = rd();
    for(int i = ; i <= n; ++i) join(i), val[i] = ;
    while(m--)
    {
        char opt[];
        scanf("%s", opt);
        if(opt[] == 'G')
        {
            if(sum < ) printf("%d\n", sum - );
            else printf("%d\n", s3.top());
        }
        if(opt[] == 'C')
        {
            int u = rd();
            if(val[u] == )
            {
                val[u] = ;
                remove(u);
                --sum;
            }
            else
            {
                val[u] = ;
                join(u);
                ++sum;
            }
        }
    }
    return ;
}