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 =  + ;
 const int MAXM =  + ;
 const double eps = 1e-;
 LL MOD = ;

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

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

     int dis[MAXN];

     void init(int n) {
         mem0(dep); mem0(K);
         node_cnt = ;
         rep (i, , 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, , sz - ) {
             int v = G[u][i].v;
             if(v == fa) continue;
             dfs(v, u, height + , dist + G[u][i].w);
             idx[++node_cnt] = u;
             dep[node_cnt] = height;
         }
     }
     void init_st_table() {
         dfs(, -, , );

         int n = node_cnt;
         rep (i, , n) {
             dp[i][] = i;
             while(( << (K[i] + )) <= i) K[i] ++;
         }
         for(int j = ; ( << j) <= n; j ++) {
             for(int i = ; i + ( << j) -  <= n; i ++) {
                 int l_pos = dp[i][j - ], r_pos = dp[i + ( << (j - ))][j - ];
                 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 + , k = K[len];
         return dep[dp[L][k]] < dep[dp[R - ( << k) + ][k]] ? dp[L][k] : dp[R - ( << k) + ][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 << ];
     void update(int k, int L, int R, int p, int v) {
         if(L == R) { s[k] = v; return ; }
         if(((L + R) >> ) >= p)  update(lson, p, v);
         else update(rson, p, v);
         s[k] = s[k << ] + s[k <<  | ];
     }
     int query_sum(int k, int L, int R, int p) {
         if(R <= p) return s[k];
         if( ((L + R) >> ) >= p ) return query_sum(lson, p);
         return s[k << ] + query_sum(rson, p);
     }
     int query_pos(int k, int L, int R, int x) {
         if(L == R) return L;
         if(s[k << ] >= x) return query_pos(lson, x);
         return query_pos(rson, x - s[k << ]);
     }
 }st;

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

 int main()
 {
 //    FIN;
     cin >> t;
     while(t--) {
         scanf("%d %d", &n, &m);
         lca.init(n);
         rep (i, , 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 = ;
         printf("Case #%d:\n", ++cas);
         while(m --) {
             scanf("%d %d", &u, &v);
             if( (u ==  && !vis[v]) || (u ==  && vis[v]) ) {
                 vis[v] = !vis[v];
                 if(u == ) st.update(, , lca.node_cnt, lca.P[v], );
                 if( st.s[] ) {
                     int x, y;
                     int sum = st.query_sum(, , lca.node_cnt, lca.P[v]);
                     if( !sum || sum == st.s[] ) x = , y = st.s[];
                     else x = sum, y = sum + ;
                     x = lca.idx[st.query_pos(, , lca.node_cnt, x)];
                     y = lca.idx[st.query_pos(, , 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 ==  ?  : -) * (lca.dis[v] - lca.dis[xv] - lca.dis[yv] + lca.dis[xy]);
                 }
                 else ans = ;
                 if(u == ) st.update(, , lca.node_cnt, lca.P[v], );
             }
             printf("%d\n", ans);
         }
     }
     return ;
 }