SPOJ QTREE Query on a tree

题意：
给一颗n个点的树，有两种操作
CHANGE i ti : 把第i条边的权变为ti
QUERY a b : 问点a 到 点b 之间的边的最大权

思路：
树剖处理边权。
由于是边，所以只需要把边权处理到子节点上即可(查询的时候从节点2开始查询，或者把0处理成负无穷)

 

具体见代码：

const int maxn = 10000 + 10;
const int maxnode = maxn * 4;

//线段树部分
int set_value, qL, qR;
int maxv[maxnode];

void update(int o, int L, int R) 
{
    if (qL <= L && R <= qR) 
    {
        maxv[o] = set_value;
        return;
    }
    int M = L + (R - L) / 2;
    if (qL <= M) update(lson);
    if (qR > M) update(rson);
    maxv[o] = max(maxv[o*2], maxv[o*2+1]);
}

int query(int o, int L, int R) {
    if (qL <= L && R <= qR) 
    {
        return maxv[o];
    }
    int M = L + (R - L) / 2;
    int ret = -INF;
    if (qL <= M) ret = max(ret, query(lson));
    if (qR > M) ret = max(ret, query(rson));
    return ret;
}

//树链剖分部分：
//
//u为连接的点，w为边权
struct Edge { int u, v, w; };
vector<int> G[maxn];
vector<Edge> e;
//往往是双向边
void add_edge(int u, int v, int w)
{
    e.push_back((Edge){u, v, w});
    G[u].push_back(v);
    G[v].push_back(u);
}

struct Node
{
    int size, dep, son, top, fa, ti;
    //依次表示第i个节点的：
    //子节点数量，深度，所在链的顶端，重儿子，dfs序
} t[maxn];

int dfs_clock;//DFS时间序列

void dfs1(int u, int pa, int depth)//第一次DFS，得到size,dep,fa以及son的数据
{
    t[u].son = 0; //重儿子，为0表示没有重儿子
    t[u].size = 1;    //节点数量
    t[u].dep = depth;
    t[u].fa = pa;
    for (int i = 0; i != G[u].size(); ++ i)
    {
        int v = G[u][i];
        if (v == pa) continue;
        dfs1(v, u, depth + 1);
        t[u].size += t[v].size;
        if (t[v].size > t[t[u].son].size) t[u].son = v;
    }
}

void dfs2(int u, int pa)    // 得到时间戳等数据,u为当前节点，pa为父链顶端节点
{
    t[u].ti = ++ dfs_clock; //u这个节点的时间戳是dfs_clock,dfs_clock下标是从1开始的，没有0！
    t[u].top = pa;        //top是u所在链的顶端
    if (t[u].son != 0) dfs2(t[u].son, t[u].top);    //如果节点有重儿子，那么依旧是以pa为链顶端的一条链
    for (int i = 0; i != G[u].size(); ++ i)
    {
        int v = G[u][i];
        if (v == t[u].son || v == t[u].fa)    continue;//重儿子或者父节点，则跳过
        dfs2(v, v);//新的一条链
    }
}

int n;
int lca(int x, int y)//更新x到y的之间所有的区间
{
    int ret = -INF;
    while (t[x].top != t[y].top)
    {
        if (t[t[x].top].dep < t[t[y].top].dep) swap(x,y); //x深 y浅
        qL=t[t[x].top].ti;
        qR=t[x].ti;
        ret = max(ret, query(1, 2, n));
        x = t[t[x].top].fa;
    }
    if (t[x].dep > t[y].dep) swap(x, y);//x是上面一些的节点
    if (x != y)
    {
        qL = t[x].ti + 1;
        qR = t[y].ti;
        ret = max(ret, query(1, 2, n));
    }
    return ret;
}


void init()
{
    memset(maxv, 0, sizeof(maxv));
    dfs_clock = 0;
    scanf("%d", &n);
    for (int i = 0; i <= n; i++) G[i].clear();
    e.clear();
    int u, v, w;
    for (int i = 1; i < n; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        add_edge(u, v, w);
    }
}

void solve()
{
    dfs1(1, 0, 1);
    dfs2(1, 1);

    for (int i = 1; i < n; i++)
    {
        set_value = e[i-1].w;
        if (t[e[i-1].u].dep < t[e[i-1].v].dep) 
            qL = qR = t[e[i-1].v].ti;
        else
            qL = qR = t[e[i-1].u].ti;
        update(1, 2, n);
    }
    char op[10];
    int u, v;
    while (true)
    {
        scanf("%s", op);
        if (op[0] == 'D') break;
        scanf("%d%d", &u, &v);
        if (op[0] == 'Q') 
        {
            printf("%d\n", lca(u, v));
        }
        else
        {
            set_value = v;
            if (t[e[u-1].u].dep < t[e[u-1].v].dep) 
                qL = qR = t[e[u-1].v].ti;
            else
                qL = qR = t[e[u-1].u].ti;
            update(1, 2, n);
        }
    }
    printf("\n");
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        init();
        solve();
    }
    return 0;
}