spoj qtree IV

2666. Query on a tree IV

Problem code: QTREE4

 

You are given a tree (an acyclic undirected connected graph) with N nodes, and nodes numbered 1,2,3...,N. Each edge has an integer value assigned to it(note that the value can be negative). Each node has a color, white or black. We define dist(a, b) as the sum of the value of the edges on the path from node a to node b.

All the nodes are white initially.

We will ask you to perfrom some instructions of the following form:

• C a : change the color of node a.(from black to white or from white to black)
  
• A : ask for the maximum dist(a, b), both of node a and node b must be white(a can be equal to b). Obviously, as long as there is a white node, the result will alway be non negative.

Input

• In the first line there is an integer N (N <= 100000)
• In the next N-1 lines, the i-th line describes the i-th edge: a line with three integers a b c denotes an edge between a, b of value c (-1000 <= c <= 1000)
• In the next line, there is an integer Q denotes the number of instructions (Q <= 100000)
• In the next Q lines, each line contains an instruction "C a" or "A"

Output

For each "A" operation, write one integer representing its result. If there is no white node in the tree, you should write "They have disappeared.".

Example

Input:
3
1 2 1
1 3 1
7
A
C 1
A
C 2
A
C 3
A

Output:
2
2
0
They have disappeared.


大意:
给出一棵树,每个点非白即黑.求树上最远的两个白点之间的距离,中间必须支持动态修改每个点的黑白状态.

思考:
树分治真是个好东西......
边分治有一个非常好的性质:就是一条边能将整棵树分成两个部分.(二分)
所以合并信息是非常方便的.

我们将每个点到中心边的距离求出来并且保存.对于每条中心边,用一个优先队列来保存对应的最优值.
最后我们合并答案即可.

但是边分治的缺点也显而易见.就是菊花树的时候复杂度经常退化.
那么怎么做呢? 我们将这棵树重构,就不会那么退化得厉害了.


代码比较慢,凑合着看....

#include<cstdlib>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cctype>
#include<ctime>
using namespace std;
const int maxn = (int)4e5, inf = 0x3f3f3f3f;
struct E{
    int t,w,last;
}e[maxn * 8][3];
int last[maxn * 8][3],edg[3]={1,1,1},ext;
void add1(int x,int y,int w){
    e[++edg[ext]][ext] = (E){y,w,last[x][ext]}; last[x][ext] = edg[ext];
}
void add(int x,int y,int w){
    add1(x,y,w); add1(y,x,w);
}
int getint(){
    int ret = 0,t = 1; char ch = getchar();
    while(!isdigit(ch)) t = ch == '-' ? -1 : t, ch = getchar();
    while(isdigit(ch)) ret = ret * 10 + ch - '0', ch = getchar();
    return ret * t;
}
int n,img;
int col[maxn * 4];
void rebuild(int x,int fa){
    int las = x;
    for(int i = last[x][0]; i; i = e[i][0].last)
        if(e[i][0].t != fa){
            if(i == last[x][0]) add(x,e[i][0].t,e[i][0].w);
            else col[++img] = 1, add(las,img,0), add(img,e[i][0].t,e[i][0].w),las = img;
        }
    for(int i = last[x][0]; i; i = e[i][0].last)
        if(e[i][0].t != fa) rebuild(e[i][0].t, x);
}
struct D{    
    int x,dis;
    bool operator <(const D &b) const{
        return dis < b.dis;
    }
};
struct SEG{
    int ans;
    int l,r,mid;
    priority_queue<D>q;
    void pop(){
        while(!q.empty() && col[q.top().x] == 1) q.pop();
    }
}T[maxn * 4];
int cnt,mid,node,tmax,p;
int sz[maxn * 4],vis[maxn * 8];
void pushup(int x){
    T[x].ans = -1;
    T[x].pop();
    int l = T[x].l, r = T[x].r;
    if(l == 0 && r == 0){
        if(!T[x].q.empty()) T[x].ans = 0;
    }else{
        if(T[x].ans < T[l].ans) T[x].ans = T[l].ans;
        if(T[x].ans < T[r].ans) T[x].ans = T[r].ans;
        if(!T[l].q.empty() && !T[r].q.empty())
            T[x].ans = max(T[x].ans, T[l].q.top().dis + T[r].q.top().dis + T[x].mid);
    }
}
void getsize(int x,int fa,int dis){
    sz[x] = 1;
    add1(x,p,dis);
    if(col[x] == 0) T[p].q.push((D){x,dis});
    for(int i = last[x][1]; i; i = e[i][1].last)
        if(e[i][1].t != fa && !vis[i]){
            getsize(e[i][1].t, x, dis + e[i][1].w);
            sz[x] += sz[e[i][1].t];
        }
}
void getmid(int x,int id){
    int Max = max(sz[x], node - sz[x]);
    if(tmax > Max) tmax = Max, mid = id;
    for(int i = last[x][1]; i; i = e[i][1].last)
        if(!vis[i] && i != id && i != (id^1)) getmid(e[i][1].t, i);
}
void work(int tp,int x){
    p = tp;
    getsize(x,0,0);
    tmax = inf; node = sz[x]; getmid(x,mid = 0);
    vis[mid] = vis[mid^1] = 1;
    if(mid){
        int l = e[mid][1].t, r = e[mid^1][1].t;
        T[tp].mid = e[mid][1].w;
        work(T[tp].l = ++cnt, l);
        work(T[tp].r = ++cnt, r);
    }
    pushup(tp);
}
void solve(){
    int Q = getint(),x;
    char ch;
    while(Q--){
        scanf("%c
",&ch);
        if(ch == 'A'){
            if(T[1].ans >= 0) printf("%d
",T[1].ans);
            else printf("They have disappeared.
");
        }
        else{
            x = getint();
            col[x] ^= 1;
            for(int i = last[x][2]; i; i = e[i][2].last){
                if(col[x] == 0)T[e[i][2].t].q.push((D){x,e[i][2].w});
                pushup(e[i][2].t);
            }                
        }
    }
}
int main()
{
    freopen("qtree.in","r",stdin);
    freopen("qtree.out","w",stdout);
    img = n = getint();
    for(int i = 1; i < n; ++i){
        int u = getint(), v = getint(), w = getint();
        add(u,v,w);
    }
    ext = 1; rebuild(1,0);
    ext = 2; work(cnt = 1, 1);
    solve();
    return 0;
}