P4315 月下“毛景树” 树链剖分+线段树

传送门

树链剖分+线段树维护的模板题，但要注意的是边权到点权的转换以及绝对标记和相对标记的关系。

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;
const int N = 1e5 + 10;

struct edge
{
    int to, next, cost;
}Edge[N<<1];

struct node //记录边的信息
{
    int a, b;
}Node[N];

int n, a[N], cnt, head[N], MAX[N<<2], lazy[N<<2], lazy1[N<<2]; //lazy[]记录绝对标记,lazy1[]记录相对标记
int top[N], son[N], f[N], size[N], id[N], rk[N], dep[N];

void add_edge(int from,int to,int cost)
{
    Edge[++cnt].to = to;
    Edge[cnt].cost = cost;
    Edge[cnt].next = head[from];
    head[from] = cnt;
}

void dfs1(int v,int fa,int depth)
{
    size[v] = 1;
    f[v] = fa;
    dep[v] = depth;
    for(int i = head[v]; i; i = Edge[i].next){
        int to = Edge[i].to;
        if(to == fa) continue;
        a[to] = Edge[i].cost; //将边权赋给深度更大的点，完成边权到点权的转化
        dfs1(to,v,depth+1);
        size[v] += size[to];
        if(size[to] > size[son[v]])
            son[v] = to;
    }
}

void dfs2(int v,int tp)
{
    top[v] = tp;
    id[v] = ++cnt;
    rk[cnt] = v;
    if(!son[v]) return ;
    dfs2(son[v],tp);
    for(int i = head[v]; i; i = Edge[i].next){
        int to = Edge[i].to;
        if(to == son[v] || to == f[v]) continue;
        dfs2(to,to);
    }
}

void pushUp(int rt)
{
    MAX[rt] = max(MAX[rt<<1], MAX[rt<<1|1]);
}

void pushDown(int rt)
{
    if(lazy[rt] != -1){	//当该节点有绝对标记时，其子节点及自身的相对标记全部失效
        lazy[rt<<1] = lazy[rt<<1|1] = lazy[rt];
        MAX[rt<<1] = MAX[rt<<1|1] = lazy[rt];
        lazy1[rt<<1] = lazy1[rt<<1|1] = 0;
        lazy1[rt] = 0;
        lazy[rt] = -1;
    }
    if(lazy1[rt] != 0){ //当该节点有相对标记时，如果子节点有绝对标记，那么子节点的绝对标记需加上该节点的相对标记
        lazy1[rt<<1] += lazy1[rt], lazy1[rt<<1|1] += lazy1[rt];
        MAX[rt<<1] += lazy1[rt], MAX[rt<<1|1] += lazy1[rt];
        if(lazy[rt<<1] != -1) lazy[rt<<1] += lazy1[rt];
        if(lazy[rt<<1|1] != -1) lazy[rt<<1|1] += lazy1[rt];
        lazy1[rt] = 0;
    }
}

void build(int l,int r,int rt)
{
    lazy[rt] = -1;
    lazy1[rt] = 0;
    if(l==r){
        MAX[rt] = a[rk[l]];
        return ;
    }
    int m = (l+r)>>1;
    build(l,m,rt<<1);
    build(m+1,r,rt<<1|1);
    pushUp(rt);
}

void update(int L,int R,int C,int type,int l,int r,int rt)
{
    pushDown(rt);
    if(L <= l && r <= R){
        if(!type){
            MAX[rt] = C;
            lazy[rt] = C;
        }
        else{
            MAX[rt] += C;
            lazy1[rt] += C;
        }
        return ;
    }
    int m = (l+r)>>1;
    if(L <= m) update(L,R,C,type,l,m,rt<<1);
    if(m <  R) update(L,R,C,type,m+1,r,rt<<1|1);
    pushUp(rt);
}

int queryMax(int L,int R,int l,int r,int rt) 
{
    if(L <= l && r <= R)
        return MAX[rt];
    pushDown(rt);
    int m = (l+r)>>1, ans = 0;
    if(L <= m) ans = max(ans, queryMax(L,R,l,m,rt<<1));
    if(m <  R) ans = max(ans, queryMax(L,R,m+1,r,rt<<1|1));
    pushUp(rt);
    return ans;
}
//由于将边权转化成了点权，那么LCA的点权是不属于我们所查找的路径的
int queryMaxs(int A,int B)
{
    int ans = 0;
    while(top[A] != top[B]){
        if(dep[top[A]] < dep[top[B]]) swap(A,B);
        ans = max(ans, queryMax(id[top[A]],id[A],1,n,1));
        A = f[top[A]];
    }
    if(id[A] > id[B]) swap(A,B);
    return max(ans, queryMax(id[A]+1,id[B],1,n,1));
}

void updates(int A,int B,int C,int type)
{
    while(top[A] != top[B]){
        if(dep[top[A]] < dep[top[B]]) swap(A,B);
        update(id[top[A]],id[A],C,type,1,n,1);
        A = f[top[A]];
    }
    if(id[A] > id[B]) swap(A,B);
    update(id[A]+1,id[B],C,type,1,n,1);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int A, B, C;
    string oper;
    cin>>n;
    for(int i = 0; i < n-1; ++i){
        cin>>A>>B>>C;
        add_edge(A,B,C);
        add_edge(B,A,C);
        Node[i+1].a = A, Node[i+1].b = B;
    }
    cnt = 0;
    dfs1(1,0,0);
    dfs2(1,1);
    build(1,n,1);
    while(cin>>oper && oper != "Stop"){
        cin>>A>>B;
        if(oper == "Max"){
            cout<<queryMaxs(A,B)<<'\n';
        }
        else if(oper == "Change"){ //修改某一边的边权，即修改该边中的子节点或者深度更大的点的点权
            int t = Node[A].a == f[Node[A].b] ? Node[A].b : Node[A].a;
            update(id[t],id[t],B,0,1,n,1);
        }
        else if(oper == "Cover"){
            cin>>C;
            updates(A,B,C,0);
        }
        else{
            cin>>C;
            updates(A,B,C,1);
        }
    }
    return 0;
}