[国家集训队]旅游

                                       题目传送门

 

题目描述

Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。

Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座桥定义一个愉悦度w，也就是说，Ray 经过这座桥会增加w 的愉悦度，这或许是正的也可能是负的。有时，Ray 看待同一座桥的心情也会发生改变。

现在，Ray 想让你帮他计算从u 景点到v 景点能获得的总愉悦度。有时，他还想知道某段路上最美丽的桥所提供的最大愉悦度，或是某段路上最糟糕的一座桥提供的最低愉悦度。

输入输出格式

输入格式：

输入的第一行包含一个整数N，表示T 城中的景点个数。景点编号为 0...N − 1。

接下来N − 1 行，每行三个整数u、v 和w，表示有一条u 到v，使 Ray 愉悦度增加w 的桥。桥的编号为1...N − 1。|w| <= 1000。 输入的第N + 1 行包含一个整数M，表示Ray 的操作数目。

接下来有M 行，每行描述了一个操作，操作有如下五种形式：

• C i w，表示Ray 对于经过第i 座桥的愉悦度变成了w。

• N u v，表示Ray 对于经过景点u 到v 的路径上的每一座桥的愉悦度都变成原来的相反数。

• SUM u v，表示询问从景点u 到v 所获得的总愉悦度。

• MAX u v，表示询问从景点u 到v 的路径上的所有桥中某一座桥所提供的最大愉悦度。

• MIN u v，表示询问从景点u 到v 的路径上的所有桥中某一座桥所提供的最小愉悦度。

测试数据保证，任意时刻，Ray 对于经过每一座桥的愉悦度的绝对值小于等于1000。

输出格式：

对于每一个询问(操作S、MAX 和MIN)，输出答案。

输入输出样例

输入样例#1： 

3
0 1 1
1 2 2
8
SUM 0 2
MAX 0 2
N 0 1
SUM 0 2
MIN 0 2
C 1 3
SUM 0 2
MAX 0 2

输出样例#1： 

3
2
1
-1
5
3

说明

很容易的基础题哦>.<

　　一道码农题=-=

　　节点记录该节点与父亲之间的边的边权，然后树剖+线段树即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define mid ((l+r)>>1)
using namespace std ;
const int INF = 0x7ffffff ;
const int N = 1e5 + 10 ;

inline int read() {
    int k = 0 , f = 1 ; char c = getchar() ;
    for( ; !isdigit(c) ; c = getchar())
      if(c == '-') f = -1 ;
    for( ; isdigit(c) ; c = getchar())
      k = k*10 + c-'0' ;
    return k*f ;
}
struct eee {
    int x, y ;
}ee[N] ;
inline void add1(int xx,int yy) {
    static int cnt = 0 ;
    ee[++cnt].x = xx, ee[cnt].y = yy ;
}

struct Node {
    int maxx, minn, sum, laz ;
    Node *ls, *rs ;
    inline void pushup() {
        maxx = max(ls->maxx,rs->maxx) ; minn = min(ls->minn,rs->minn) ;
        sum = ls->sum + rs->sum ;
    }
    inline void pushdown() {
        if(!laz) return ;
        ls->sum *= -1, rs->sum *= -1 ;
        int t = ls->maxx ;
        ls->maxx = -ls->minn, ls->minn = -t ;
        t = rs->maxx ;
        rs->maxx = -rs->minn, rs->minn = -t ;
        ls->laz ^= 1 ; rs->laz ^= 1 ;  laz = 0 ;
    }
}pool[N<<1], *root ;   int res ;  int wt[N] ;
inline Node *newNode() {
    static int cnt = 0 ;
    return &pool[++cnt] ;
}
Node *build(int l,int r) {
    Node *cur = newNode() ;  cur->laz = 0 ;
    if(l == r) {
        cur->maxx = cur->minn = cur->sum = wt[l] ;
    } else {
        cur->ls = build(l,mid) ; cur->rs = build(mid+1,r) ;
        cur->pushup() ;
    }
    return cur ;
}
void change_interval(Node *cur,int l,int r,int a,int b) {
    if(l >= a && r <= b) {
        cur->laz ^= 1 ;  cur->sum *= -1 ; 
        int t = cur->maxx ; cur->maxx = -cur->minn, cur->minn = -t ;
        return ;
    }
    cur->pushdown() ;
    if(a <= mid) change_interval(cur->ls,l,mid,a,b) ;
    if(b > mid) change_interval(cur->rs,mid+1,r,a,b) ;
    cur->pushup() ;
}
void change_point(Node *cur,int l,int r,int k,int x) {
    if(l == r) {
        cur->sum = cur->maxx = cur->minn = x ; return ;
    }
    cur->pushdown() ;
    if(k <= mid) change_point(cur->ls,l,mid,k,x) ;
    else change_point(cur->rs,mid+1,r,k,x) ;
    cur->pushup() ;
}
void get_sum(Node *cur,int l,int r,int a,int b) {
    if(l >= a && r <= b) {
        res += cur->sum ; return ;
    }
    cur->pushdown() ;
    if(a <= mid) get_sum(cur->ls,l,mid,a,b) ;
    if(b > mid) get_sum(cur->rs,mid+1,r,a,b) ;
}
void get_max(Node *cur,int l,int r,int a,int b) {
    if(l >= a && r <= b) {
        res = max(res,cur->maxx) ; return ;
    }
    cur->pushdown() ;
    if(a <= mid) get_max(cur->ls,l,mid,a,b) ;
    if(b > mid) get_max(cur->rs,mid+1,r,a,b) ;
}
void get_min(Node *cur,int l,int r,int a,int b) {
    if(l >= a && r <= b) {
        res = min(res,cur->minn) ; return ;
    }
    cur->pushdown() ;
    if(a <= mid) get_min(cur->ls,l,mid,a,b) ;
    if(b > mid) get_min(cur->rs,mid+1,r,a,b) ;
}

struct Edge {
    int to, nex, val ;
}e[N<<1] ;
int n ;  int head[N], top[N], fa[N], w[N], dep[N], siz[N], son[N], bl[N], bll[N] ;
inline void add_edge(int x,int y,int z) {
    static int cnt = 0 ;
    e[++cnt].to = y, e[cnt].nex = head[x], head[x] = cnt, e[cnt].val = z ;
}

void dfs1(int x,int f,int deep,int vv) {
    w[x] = vv ; fa[x] = f ; dep[x] = deep ; siz[x] = 1 ;
    for(int i=head[x];i;i=e[i].nex) {
        int y = e[i].to ; if(y == f) continue ;
        dfs1(y,x,deep+1,e[i].val) ; siz[x] += siz[y] ;
        if(siz[y] > siz[son[x]]) son[x] = y ;
    }
}
int cnt = 0 ;
void dfs2(int x,int topf) {
    top[x] = topf ; wt[++cnt] = w[x] ; bl[x] = cnt ;
    if(!son[x]) return ;
    dfs2(son[x],topf) ;
    for(int i=head[x];i;i=e[i].nex) {
        int y = e[i].to ; if(y == fa[x] || y == son[x]) continue ;
        dfs2(y,y) ;
    }
}

inline void change1() {
    int x = read()+1, y = read()+1 ;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x,y) ;
        change_interval(root,1,n,bl[top[x]],bl[x]) ;
        x = fa[top[x]] ;
    }
    if(dep[x] > dep[y]) swap(x,y) ;
    if(bl[x] < bl[y]) change_interval(root,1,n,bl[x]+1,bl[y]) ;
}
inline void query1() {
    int x = read()+1, y = read()+1 ;  res = 0 ;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x,y) ;
        get_sum(root,1,n,bl[top[x]],bl[x]) ;
        x = fa[top[x]] ;
    }
    if(dep[x] > dep[y]) swap(x,y) ;
    if(bl[x] < bl[y]) get_sum(root,1,n,bl[x]+1,bl[y]) ;
    printf("%d
",res) ;
}
inline void query2() {
    int x = read()+1, y = read()+1 ;  res = -INF ;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x,y) ;
        get_max(root,1,n,bl[top[x]],bl[x]) ;
        x = fa[top[x]] ;
    }
    if(dep[x] > dep[y]) swap(x,y) ;
    if(bl[x] < bl[y]) get_max(root,1,n,bl[x]+1,bl[y]) ;
    printf("%d
",res) ;
}
inline void query3() {
    int x = read()+1, y = read()+1 ;  res = INF ;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x,y) ;
        get_min(root,1,n,bl[top[x]],bl[x]) ;
        x = fa[top[x]] ;
    }
    if(dep[x] > dep[y]) swap(x,y) ;
    if(bl[x] < bl[y]) get_min(root,1,n,bl[x]+1,bl[y]) ;
    printf("%d
",res) ;
}

int main() {
    n = read() ;
    for(int i=1;i<n;i++) {
        int x = read()+1, y = read()+1, z = read() ;
        add_edge(x,y,z) ; add_edge(y,x,z) ;
        add1(x,y) ;
    }
    dfs1(1,0,1,0) ; dfs2(1,1) ;
    root = build(1,n) ;
    for(int i=1;i<n;i++) {
        int xx = ee[i].x, yy = ee[i].y ;
        bll[i] = fa[xx] == yy ? xx : yy ;
    }
    int m = read() ;  char ss[10] ;
    while(m--) {
        scanf("%s",&ss) ;
        if(ss[0] == 'C') {
            int k = read(), x = read() ;
            change_point(root,1,n,bl[bll[k]],x) ;
        } else if(ss[0] == 'N') {
            change1() ;
        } else if(ss[0] == 'S') {
            query1() ;
        } else if(ss[1] == 'A') {
            query2() ;
        } else query3() ;
    }
    return 0 ;
}