RT，蒟蒻调了好久，只得了10分， 求助！！

#include <bits/stdc++.h>
using namespace std;
#define N 200010
#define int long long
const int inf = 2147483645; 

template <class T>
inline void read(T& a){
    T x = 0, s = 1;
    char c = getchar();
    while(!isdigit(c)){
        if(c == '-') s = -1;
        c = getchar();
    }
    while(isdigit(c)){
        x = x * 10 + (c ^ '0');
        c = getchar(); 
    }
    a = x * s;
    return ; 
}

struct node{
    int u, v, w, next;
} t[N << 1], edge[N];
int f[N];

int bian = 0;
inline void add(int u, int v, int w){
    t[++bian] = (node){u, v, w, f[u]}, f[u] = bian;
    return ; 
}

int n; 
int a[N], b[N]; 

int top[N], siz[N], son[N], fa[N], deth[N];
int dfn[N], rev[N], id = 0; 

void dfs1(int now, int father){
    siz[now] = 1;
    fa[now] = father;
    deth[now] = deth[father] + 1;
    for(int i = f[now]; i; i = t[i].next){
        int v = t[i].v;
        if(v != father){
            b[v] = t[i].w; 
            dfs1(v, now);
            siz[now] += siz[v];
            if(siz[v] > siz[son[now]])
                son[now] = v; 
        }
    }
    return ; 
}

void dfs2(int now, int tp){
    top[now] = tp;
    dfn[now] = ++id;  rev[id] = now;
    a[id] = b[now]; 
    if(!son[now]) return ;
    dfs2(son[now], tp); 
    for(int i = f[now]; i; i = t[i].next){
        int v = t[i].v;
        if(v != fa[now] && v != son[now])
            dfs2(v, v); 
    }
    return ; 
}

struct Segment_tree{
    struct node{
        int tag;
		int w, maxn, minn;
    } e[N << 2];

    #define lson (o<<1)
    #define rson (o<<1|1)
    inline void pushup(int o){
        e[o].w = e[lson].w + e[rson].w;
        e[o].maxn = max(e[lson].maxn, e[rson].maxn);
        e[o].minn = min(e[lson].minn, e[rson].minn);
        return ; 
    }

    inline void pushdown(int o, int l, int r){
        if(e[o].tag){
            e[lson].w *= -1; e[rson].w *= -1; 
            e[lson].maxn *= -1; e[rson].minn *= -1;
            e[rson].maxn *= -1; e[rson].minn *= -1; 
            swap(e[lson].maxn, e[lson].minn);
            swap(e[rson].maxn, e[rson].minn); 
            e[lson].tag ^= 1;
            e[rson].tag ^= 1; 
            e[o].tag  = 0; 
        }
        return ; 
    }

    void build(int o, int l, int r){
        if(l == r){
            e[o].w = e[o].maxn = e[o].minn = a[l];
            return ; 
        }
        int mid = l + r >> 1;
        build(lson, l, mid);
        build(rson, mid + 1, r);
        pushup(o);
        return ; 
    }

    void update1(int o, int l, int r, int x, int k){
        if(l > x || r < x) return ;
        if(l == r && l == x){
            e[o].w = e[o].minn = e[o].maxn = k;
            return ; 
        }
        int mid = l + r >> 1;
        pushdown(o, l, r);
        update1(lson, l, mid, x, k);
        update1(rson , mid + 1, r, x, k);
        pushup(o);
        return ; 
    }

    void update2(int o, int l, int r, int in, int end){   // 取反 
        if(l > end || r < in) return ;
        if(l >= in && r <= end){
            e[o].tag ^= 1;
            e[o].w *= -1;
            e[o].maxn *= -1; e[o].minn *= -1;
            swap(e[o].maxn, e[o].minn);
            return ; 
        }
        pushdown(o, l, r);
        int mid = l + r >> 1;
        update2(lson, l, mid, in, end);
        update2(rson, mid + 1, r, in, end);
        pushup(o);
        return ; 
    }

    int queryhe(int o, int l, int r, int in, int end){
        if(l > end || r < in) return 0;
        if(l >= in && r <= end) return e[o].w;
        pushdown(o, l, r);
        int mid = l + r >> 1;
        return queryhe(lson, l, mid, in, end) + queryhe(rson, mid + 1, r, in, end); 
    }

    int querymax(int o, int l, int r, int in, int end){
        if(l > end || r < in) return -inf;
        if(l >= in && r <= end) return e[o].maxn;
        pushdown(o, l, r);
        int mid = l + r >> 1;
        return max(querymax(lson, l, mid, in, end), querymax(rson, mid + 1, r, in, end)); 
    }

    int querymin(int o, int l, int r, int in, int end){
        if(l > end || r < in) return inf;
        if(l >= in && r <= end) return e[o].minn ;
        pushdown(o, l, r); 
        int mid = l + r >> 1;
        return min(querymin(lson, l, mid, in, end), querymin(rson, mid + 1, r, in, end)); 
    }

} tree; 

void qufan(int x, int y){
    while(top[x] != top[y]){
        if(deth[top[x]] < deth[top[y]]) swap(x, y);
        tree.update2(1, 1, n, dfn[top[x]], dfn[x]);
        x = fa[top[x]]; 
    }
    if(deth[x] > deth[y]) swap(x, y);
    if(x != y) tree.update2(1, 1, n, dfn[x] + 1, dfn[y]);
    return ; 
}

int ask_he(int x, int y){
    int sum = 0;
    while(top[x] != top[y]){
        if(deth[top[x]] < deth[top[y]]) swap(x, y);
        sum += tree.queryhe(1, 1, n, dfn[top[x]], dfn[x]);
        x = fa[top[x]]; 
    }
    if(deth[x] > deth[y]) swap(x, y);
    if(x != y) sum += tree.queryhe(1, 1, n, dfn[x] + 1, dfn[y]);
    return sum; 
}

int ask_max(int x, int y){
    int sum = -inf;
    while(top[x] != top[y]){
        if(deth[top[x]] < deth[top[y]]) swap(x, y);
        sum = max(sum, tree.querymax(1, 1, n, dfn[top[x]], dfn[x])); 
        x = fa[top[x]]; 
    }
    if(deth[x] > deth[y]) swap(x, y); 
    if(x != y) sum = max(sum, tree.querymax(1, 1, n, dfn[x] + 1, dfn[y]));
    return sum; 
}

int ask_min(int x, int y){
    int sum = inf;
    while(top[x] != top[y]){
        if(deth[top[x]] < deth[top[y]]) swap(x, y);
        sum = min(sum, tree.querymin(1, 1, n, dfn[top[x]], dfn[x])); 
        x = fa[top[x]]; 
    }
    if(deth[x] > deth[y]) swap(x, y); 
    if(x != y) sum = min(sum, tree.querymin(1, 1, n, dfn[x] + 1, dfn[y]));
    return sum; 
}

signed main(){
//	freopen("hh.txt", "r", stdin); 
//	freopen("mine.txt", "w", stdout); 
    read(n);
    for(int i = 1; i < n; i++){
        int x, y, w;
        read(x), read(y), read(w);
        x++, y++; 
        add(x, y, w);  add(y, x, w); 
        edge[i].u = x, edge[i].v = y; 
    }
    dfs1(1, 0);
    dfs2(1, 0); 
    tree.build(1, 1, n); 
    char ch[10];
    int q; read(q);
    while(q--){
        scanf("%s", ch + 1);
        int x, y; 
        if(ch[1] == 'C'){
            int i, w;
            read(i), read(w);
            int u = edge[i].u, v = edge[i].v;
            if(deth[u] < deth[v]) swap(u, v);
            tree.update1(1, 1, n, dfn[u], w); 
        }
        else if(ch[1] == 'N'){
            read(x), read(y); 
            x++, y++; 
            qufan(x, y); 
        }
        else if(ch[1] == 'S'){
            read(x), read(y); 
            x++, y++; 
            cout << ask_he(x, y) << endl; 
        }
        else if(ch[1] == 'M' && ch[2] == 'A'){
            read(x), read(y); 
            x++, y++; 
            cout << ask_max(x, y) << endl; 
        }
        else if(ch[1] == 'M' && ch[2] == 'I'){
            read(x), read(y);
            x++, y++; 
            cout << ask_min(x, y) << endl; 
        }
    }
    return 0; 
}