BZOJ 2157 旅游 树链剖分(边权)+线段树(单点修改 区间修改 区间求和 RMQ)

https://www.lydsy.com/JudgeOnline/problem.php?id=2157
Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座桥定义一个愉悦度w，也就是说，Ray 经过这座桥会增加w 的愉悦度，这或许是正的也可能是负的。有时，Ray 看待同一座桥的心情也会发生改变。现在，Ray 想让你帮他计算从u 景点到v 景点能获得的总愉悦度。有时，他还想知道某段路上最美丽的桥所提供的最大愉悦度，或是某段路上最糟糕的一座桥提供的最低愉悦度。
Input

输入的第一行包含一个整数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。

Output

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

Sample Input
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
Sample Output
3
2
1
-1
5
3
Hint

一共有10 个数据，对于第i (1 <= i <= 10) 个数据， N = M = i * 2000。

思路：点权化为边权，树链剖分后就是线段树的知识了。lazy标记初始为0，每次区间修改应该取非，而不是简单的赋值为1，因为两次取反相当于没有取反，赋值为1会导致答案错误。(因为这个rz错误WA了半天orz)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;

const int maxn=1e5+5;

struct node
{
    int l,r,sum,MAX,MIN,lazy;
}tree[maxn<<2]; //线段树

 struct edge
 {
     int to,nxt;
 }Edge[maxn<<1];

struct e
{
    int u,v,dis;
}E[maxn];

int head[maxn];
int siz[maxn];//子树大小
int son[maxn];//重儿子
int fa[maxn];//父节点
int deep[maxn];//深度
int top[maxn];//所在链链顶
int pos[maxn];//dfs序编号
int v[maxn];//映射到序列后的值 线段树依照此序列建树
int a[maxn];//树上各节点的值
char op[10];
int n,m,tot=0,cnt=0;

inline void addedge(int u,int v)
{
    Edge[++cnt].to=v,Edge[cnt].nxt=head[u],head[u]=cnt;
    Edge[++cnt].to=u,Edge[cnt].nxt=head[v],head[v]=cnt;
}

void dfs1(int u,int f)//处理出重儿子 深度 父亲 子树大小等信息
{
    siz[u]=1;
    son[u]=0;
    fa[u]=f;
    deep[u]=deep[f]+1;
    int to;
    for(int i=head[u];i;i=Edge[i].nxt)
    {
        to=Edge[i].to;
        if(to!=f)
        {
            dfs1(to,u);
            siz[u]+=siz[to];
            if(siz[son[u]]<siz[to])
                son[u]=to;
        }
    }
}

void dfs2(int u,int f,int k)//处理出 链顶 dfs序 映射后的值 等信息
{
    top[u]=k;
    pos[u]=++tot;
    v[tot]=a[u];
    if(son[u])
        dfs2(son[u],u,k);
    int to;
    for(int i=head[u];i;i=Edge[i].nxt)
    {
        to=Edge[i].to;
        if(to!=f&&to!=son[u])
            dfs2(to,u,to);
    }
}

void down(int i)
{
    int l=i<<1,r=i<<1|1;
    tree[l].sum=-tree[l].sum;
    tree[r].sum=-tree[r].sum;
    swap(tree[l].MAX,tree[l].MIN);
    tree[l].MAX=-tree[l].MAX;
    tree[l].MIN=-tree[l].MIN;
    swap(tree[r].MAX,tree[r].MIN);
    tree[r].MAX=-tree[r].MAX;
    tree[r].MIN=-tree[r].MIN;
    tree[l].lazy=!tree[l].lazy;
    tree[r].lazy=!tree[r].lazy;
    tree[i].lazy=0;
}

void up(int i)
{
    int l=i<<1,r=i<<1|1;
    tree[i].sum=tree[l].sum+tree[r].sum;
    tree[i].MAX=max(tree[l].MAX,tree[r].MAX);
    tree[i].MIN=min(tree[l].MIN,tree[r].MIN);
}

void build(int i,int l,int r)//建线段树
{
    tree[i].l=l,tree[i].r=r;
    tree[i].lazy=0;
    if(l==r)
    {
        tree[i].sum=tree[i].MAX=tree[i].MIN=v[l];
        return ;
    }
    int mid=(l+r)>>1;
    build(i<<1,l,mid);
    build(i<<1|1,mid+1,r);
    up(i);
}

int querysum(int i,int l,int r)
{
    if(l==tree[i].l&&r==tree[i].r)
        return tree[i].sum;
    if(tree[i].lazy)
        down(i);
    int mid=(tree[i].l+tree[i].r)>>1;
    if(r<=mid)
        return querysum(i<<1,l,r);
    else if(l>mid)
        return querysum(i<<1|1,l,r);
    else
        return querysum(i<<1,l,mid)+querysum(i<<1|1,mid+1,r);
}

int calsum(int u,int v)//计算路径和
{
    int ans=0;
    while(top[u]!=top[v])//不在同一条链上 每次链顶深度较大的点往上爬
    {
        if(deep[top[u]]<deep[top[v]])
            swap(u,v);
        ans+=querysum(1,pos[top[u]],pos[u]);
        u=fa[top[u]];//进入新的链
    }
    if(u==v) //关键
        return ans;
    if(deep[u]>deep[v])//进入同一条链上时再求一遍区间和 深度小的点在前面
        swap(u,v);
    ans+=querysum(1,pos[son[u]],pos[v]); //关键
    return ans;
}

int querymax(int i,int l,int r)
{
    if(tree[i].l==l&&tree[i].r==r)
        return tree[i].MAX;
    int mid=(tree[i].l+tree[i].r)>>1;
    if(tree[i].lazy)
        down(i);
    if(r<=mid)
        return querymax(i<<1,l,r);
    else if(l>mid)
        return querymax(i<<1|1,l,r);
    else
        return max(querymax(i<<1,l,mid),querymax(i<<1|1,mid+1,r));
}

int calmax(int u,int v)
{
    int ans=-300000;
    while(top[u]!=top[v])//不在同一条链上 每次链顶深度较大的点往上爬
    {
        if(deep[top[u]]<deep[top[v]])
            swap(u,v);
        ans=max(ans,querymax(1,pos[top[u]],pos[u]));
        u=fa[top[u]];//进入新的链
    }
    if(u==v)
        return ans;
    if(deep[u]>deep[v])//进入同一条链上时再求一遍区间和 深度小的点在前面
        swap(u,v);
    ans=max(ans,querymax(1,pos[son[u]],pos[v]));
    return ans;
}

int querymin(int i,int l,int r)
{
    if(tree[i].l==l&&tree[i].r==r)
        return tree[i].MIN;
    int mid=(tree[i].l+tree[i].r)>>1;
    if(tree[i].lazy)
        down(i);
    if(r<=mid)
        return querymin(i<<1,l,r);
    else if(l>mid)
        return querymin(i<<1|1,l,r);
    else
        return min(querymin(i<<1,l,mid),querymin(i<<1|1,mid+1,r));
}

int calmin(int u,int v)
{
    int ans=300000;
    while(top[u]!=top[v])//不在同一条链上 每次链顶深度较大的点往上爬
    {
        if(deep[top[u]]<deep[top[v]])
            swap(u,v);
        ans=min(ans,querymin(1,pos[top[u]],pos[u]));
        u=fa[top[u]];//进入新的链
    }
    if(u==v)
        return ans;
    if(deep[u]>deep[v])//进入同一条链上时再求一遍区间和 深度小的点在前面
        swap(u,v);
    ans=min(ans,querymin(1,pos[son[u]],pos[v]));
    return ans;
}

void update1(int i,int p,int v)//单点修改
{
    if(tree[i].l==tree[i].r&&tree[i].l==p)
    {
        tree[i].sum=tree[i].MAX=tree[i].MIN=v;
        return ;
    }
    if(tree[i].lazy)
        down(i);
    int mid=(tree[i].l+tree[i].r)>>1;
    if(p<=mid)
        update1(i<<1,p,v);
    else
        update1(i<<1|1,p,v);
    up(i);
}

void update2(int i,int l,int r)//区间置数
{
    if(tree[i].l==l&&tree[i].r==r)
    {
        tree[i].lazy=!tree[i].lazy;
        tree[i].sum=-tree[i].sum;
        swap(tree[i].MAX,tree[i].MIN);
        tree[i].MAX=-tree[i].MAX;
        tree[i].MIN=-tree[i].MIN;
        return ;
    }
    if(tree[i].lazy)
        down(i);
    int mid=(tree[i].l+tree[i].r)>>1;
    if(r<=mid)
        update2(i<<1,l,r);
    else if(l>mid)
        update2(i<<1|1,l,r);
    else
        update2(i<<1,l,mid),
        update2(i<<1|1,mid+1,r);
    up(i);
}

void updatework(int u,int v)
{
    while(top[u]!=top[v])//不在同一条链上 每次链顶深度较大的点往上爬
    {
        if(deep[top[u]]<deep[top[v]])
            swap(u,v);
        update2(1,pos[top[u]],pos[u]);
        u=fa[top[u]];//进入新的链
    }
    if(u==v)
        return ;
    if(deep[u]>deep[v])//进入同一条链上时再求一遍区间和 深度小的点在前面
        swap(u,v);
    update2(1,pos[son[u]],pos[v]);
}

inline void prework()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].dis);
        ++E[i].u,++E[i].v;
        addedge(E[i].u,E[i].v);
    }
    dfs1(1,0);
    for(int i=1;i<n;i++)
    {
        if(deep[E[i].u]>deep[E[i].v])
            a[E[i].u]=E[i].dis;
        else
            a[E[i].v]=E[i].dis;
    }
    dfs2(1,0,1);
    build(1,1,n);
}

inline void mainwork()
{
    scanf("%d",&m);
    int u,v,d;
    for(int i=0;i<m;i++)
    {
        scanf("%s",op);
        if(op[0]=='C')
        {
            scanf("%d%d",&v,&d);
            if(deep[E[v].u]>deep[E[v].v])
                update1(1,pos[E[v].u],d);
            else
                update1(1,pos[E[v].v],d);
        }
        else if(op[0]=='N')
        {
            scanf("%d%d",&u,&v);
            ++u,++v;
            updatework(u,v);
        }
        else if(op[0]=='S')
        {
            scanf("%d%d",&u,&v);
            ++u,++v;
            printf("%d\n",calsum(u,v));
        }
        else if(op[1]=='A')
        {
            scanf("%d%d",&u,&v);
            ++u,++v;
            printf("%d\n",calmax(u,v));
        }
        else
        {
            scanf("%d%d",&u,&v);
            ++u,++v;
            printf("%d\n",calmin(u,v));
        }
    }
}

int main()
{
    prework();
    mainwork();
    return 0;
}