SPOJ QTREE - Query on a tree

#include <bits/stdc++.h>

using namespace std;

const int maxn=10005;
vector <pair<int,int> > g[maxn];
int num;
const int inf=1<<29;
int id[maxn],deep[maxn],siz[maxn],son[maxn],fa[maxn];
int val[maxn],top[maxn];

struct Edge
{
    int x,y,val;
    void read()
    {
        scanf("%d %d %d",&x,&y,&val);
        g[x].push_back(make_pair(y,val));
        g[y].push_back(make_pair(x,val));
    }
}edges[maxn+20];

void dfs1(int u,int father,int d,int va)
{
    deep[u]=d;
    siz[u]=1;
    son[u]=0;
    fa[u]=father;

    val[u] = va;

    for(int i=0;i<(int)g[u].size();i++)
    {
        int v=g[u][i].first;
        if(v==father)   continue;
        dfs1(v,u,d+1,g[u][i].second);
        siz[u]+=siz[v];
        if(siz[son[u]]<siz[v])  son[u]=v;
    }
}

void dfs2(int u,int tp)
{
    top[u]=tp;
    id[u]=++num;
    if(son[u])  dfs2(son[u],tp);
    for(int i=0;i<(int)g[u].size();i++)
    {
        int v=g[u][i].first;
        if(v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}

int qL,qR;
int p,v;
int _max;
int n;
struct IntervalTree {
    int maxv[maxn*4];

    void build(int o,int L,int R) {
        int M = L + (R-L)/2;
        if(L==R) maxv[o] = val[L];
        else {
            build(o*2,L,M);
            build(o*2+1,M+1,R);
            maxv[o] = max(maxv[o*2],maxv[o*2+1]);
        }
    }

    void update(int o,int L,int R) {
        int M = L + (R-L)/2;
        if(L==R) maxv[o] = v;
        else {
            if(p<=M) update(o*2,L,M);
            else update(o*2+1,M+1,R);
            maxv[o] = max(maxv[o*2],maxv[o*2+1]);
        }
    }

    int qurey(int o,int L,int R) {
        int M = L + (R-L)/2, ans = -inf;
        if(qL<=L&&R<=qR) return maxv[o];
        if(qL<=M) ans = max(ans,qurey(o*2,L,M));
        if(M<qR) ans = max(ans,qurey(o*2+1,M+1,R));
        return ans;
    }

}sol;

int yougth(int u,int v) {
    int f1 = top[u],f2 = top[v];
    int ret = -inf;

    while(f1!=f2) {

        if(deep[f1]<deep[f2]) {
            swap(u,v);
            swap(f1,f2);
        }

        qL = id[f1],qR = id[u],_max = -inf;
        _max = max(_max,sol.qurey(1,1,n));
        ret = max(ret,_max);
        u = fa[f1];
        f1 = top[u];
    }

    if(u==v) return ret;
    if(deep[u]>deep[v]) swap(u,v);
    qL = id[son[u]],qR=id[v],_max = -inf;
    _max = max(_max,sol.qurey(1,1,n));
    ret = max(ret,_max);
    return ret;
}


int main(int argc, char const *argv[])
{
   // freopen("in.txt","r",stdin);
    int t;
    scanf("%d",&t);
    while(t--) {
        scanf("%d",&n);

        for (int i = 0; i < maxn; ++i)
            g[i].clear();

        for (int i = 1; i < n; ++i)
            edges[i].read();

        num = 0;
        dfs1(1,0,1,-inf);
        dfs2(1,1);

        for(int i=1; i <=n; i++) {
            p = id[i];
            v = val[i];
            sol.update(1,1,n);
        }


        char cmd[20];
        while(scanf("%s",cmd),strcmp(cmd,"DONE")!=0) {
            if(strcmp(cmd,"QUERY")==0) {
                int u,v;
                scanf("%d%d",&u,&v);

                printf("%d\n",yougth(u,v));
            }
            else {
                int a,b;
                scanf("%d%d",&a,&b);
                int t = fa[edges[a].y] == edges[a].x ? edges[a].y : edges[a].x;
                p = id[t],v = b;
                sol.update(1,1,n);
            }
        }
    }
    return 0;
}