HDU5296 Annoying problem(LCA)

//#pragma comment(linker, "/STACK:1677721600")
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = (a); i <= (b); i ++)
#define dec(i, a, b) for(int i = (a); i >= (b); i --)

template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

//typedef __int64 LL;
typedef long long LL;
const int MAXN = 100000 + 100;
const int MAXM = 2000000 + 100;
const double eps = 1e-8;
LL MOD = 1000000007;

struct Edge {
    int v, w;
    Edge(int _v = 0, int _w = 0) {
        v = _v; w = _w;
    }
};

struct LCA {
    int idx[MAXN << 1];
    int dep[MAXN << 1];
    int dp[MAXN << 1][20];
    int K[MAXN << 1];
    int node_cnt;
    vector<Edge>G[MAXN];
    int P[MAXN];

    int dis[MAXN];

    void init(int n) {
        mem0(dep); mem0(K);
        node_cnt = 0;
        rep (i, 0, n) G[i].clear();
    }
    void add_edge(int u, int v, int w) {
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));
    }
    void dfs(int u, int fa, int height, int dist) {
        idx[++node_cnt] = u;
        dep[node_cnt] = height;
        P[u] = node_cnt;
        dis[u] = dist;
        int sz = G[u].size();
        rep (i, 0, sz - 1) {
            int v = G[u][i].v;
            if(v == fa) continue;
            dfs(v, u, height + 1, dist + G[u][i].w);
            idx[++node_cnt] = u;
            dep[node_cnt] = height;
        }
    }
    void init_st_table() {
        dfs(1, -1, 0, 0);

        int n = node_cnt;
        rep (i, 1, n) {
            dp[i][0] = i;
            while((1 << (K[i] + 1)) <= i) K[i] ++;
        }
        for(int j = 1; (1 << j) <= n; j ++) {
            for(int i = 1; i + (1 << j) - 1 <= n; i ++) {
                int l_pos = dp[i][j - 1], r_pos = dp[i + (1 << (j - 1))][j - 1];
                dp[i][j] = dep[l_pos] < dep[r_pos] ? l_pos : r_pos;
            }
        }
    }
    int rmq_query(int L, int R) {
        if(L > R) swap(L, R);
        int len = R - L + 1, k = K[len];
        return dep[dp[L][k]] < dep[dp[R - (1 << k) + 1][k]] ? dp[L][k] : dp[R - (1 << k) + 1][k];
    }
    int lca_query(int u, int v) {
        int id = rmq_query(P[u], P[v]);
        return idx[id];
    }
}lca;

struct SegTree  {
    int s[MAXN << 3];
    void update(int k, int L, int R, int p, int v) {
        if(L == R) { s[k] = v; return ; }
        if(((L + R) >> 1) >= p)  update(lson, p, v);
        else update(rson, p, v);
        s[k] = s[k << 1] + s[k << 1 | 1];
    }
    int query_sum(int k, int L, int R, int p) {
        if(R <= p) return s[k];
        if( ((L + R) >> 1) >= p ) return query_sum(lson, p);
        return s[k << 1] + query_sum(rson, p);
    }
    int query_pos(int k, int L, int R, int x) {
        if(L == R) return L;
        if(s[k << 1] >= x) return query_pos(lson, x);
        return query_pos(rson, x - s[k << 1]);
    }
}st;

int t, n, m, cas = 0;
int u, v, w;
bool vis[MAXN << 1];

int main()
{
//    FIN;
    cin >> t;
    while(t--) {
        scanf("%d %d", &n, &m);
        lca.init(n);
        rep (i, 2, n) {
            scanf("%d %d %d", &u, &v, &w);
            lca.add_edge(u, v, w);
        }
        lca.init_st_table();

        mem0(st.s);
        mem0(vis);
        int ans = 0;
        printf("Case #%d:
", ++cas);
        while(m --) {
            scanf("%d %d", &u, &v);
            if( (u == 1 && !vis[v]) || (u == 2 && vis[v]) ) {
                vis[v] = !vis[v];
                if(u == 2) st.update(1, 1, lca.node_cnt, lca.P[v], 0);
                if( st.s[1] ) {
                    int x, y;
                    int sum = st.query_sum(1, 1, lca.node_cnt, lca.P[v]);
                    if( !sum || sum == st.s[1] ) x = 1, y = st.s[1];
                    else x = sum, y = sum + 1;
                    x = lca.idx[st.query_pos(1, 1, lca.node_cnt, x)];
                    y = lca.idx[st.query_pos(1, 1, lca.node_cnt, y)];
                    int xv = lca.lca_query(x, v);
                    int yv = lca.lca_query(y, v);
                    int xy = lca.lca_query(x, y);
                    ans += (u == 1 ? 1 : -1) * (lca.dis[v] - lca.dis[xv] - lca.dis[yv] + lca.dis[xy]);
                }
                else ans = 0;
                if(u == 1) st.update(1, 1, lca.node_cnt, lca.P[v], 1);
            }
            printf("%d
", ans);
        }
    }
    return 0;
}