P1505 [国家集训队]旅游

题目描述

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

说明

很容易的基础题哦>.<

吐槽

这是国家集训队的题目啊，还基础题！！！

这是国家集训队的题目啊，还基础题！！！

这是国家集训队的题目啊，还基础题！！！

思路

做了三四道树剖，这题算是技巧性较高的了。。

看了看其他大佬的题解，感觉有些难的地方根本就没解释啊，故写文以记之。

---

这题难点有二：

• 正常模板为点权，此题是边权

由于一个点有多个儿子，但只有一个父亲，易想到将原点权代替成与父亲的边权处理。1号节点边权为0。

既然对于边权维护硬核转换为点权，则在树链上反复跳的时候,LCA点的权值是不能取的，因为LCA维护的是与他父亲的边权，u与v的路径上并不经过。

此外的话对于操作C你在修改一条单边的时候，应当选择深度大的节点（只有深度大的节点维护的边权才是U,V间的边权），其中需要额外加一个判断。

• 线段树的懒标记下放

我们可以设neg[o]neg[o]为o节点的区间每个数是否取反，对区间和直接取反，对最大值用最小值的相反数替代，最小值同理。

对于neg[o]neg[o]就进行取反操作即可，这可以用异或计算实现，本蒟蒻直接用"neg[o]=!neg[o]neg[o]=!neg[o]"水过了。。

---

此外就是一些树剖基本操作啦，最后注意求最小值的时候初值不能为0，题目会出现负数。。

还有一个要我至死铭记的东西判断里是==不是=

还有一个要我至死铭记的东西判断里是==不是=

还有一个要我至死铭记的东西判断里是==不是=

所有树剖都必错的点

#include<bits/stdc++.h>
#define stop system("pause")
#define INF 2000000000

using namespace std;
const int maxn=1e6+10;
struct Edge
{
    int u, v, next, value;
}way[maxn << 1];
struct tree
{
    int l, r, value, maxn, minn, f;
}p[maxn << 2];

int head[maxn];
int top[maxn];
int father[maxn];
int  son[maxn];
int size[maxn];
int tuop[maxn];
int pre[maxn];
int deep[maxn];
int w[maxn];
char fh[10];
int tot = 0, cur = 0;
int n, m, ans;

inline int read()
{
    int f = 0, fu = 1;
    char c = getchar();
    while(c < '0' || c > '9')
    {
        if(c == '-') fu = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9')
    {
        f = (f << 3) + (f << 1) + c - 48;
        c = getchar();
    }
    return f * fu;
}
int add(int x,int y,int w)
{
    way[++tot].next=head[x];
   way[tot].v=y;
    way[tot].value=w;
    head[x]=tot;
}
inline void dfs1(int u)
{
    size[u] = 1;
    for(int i = head[u]; i; i = way[i].next)
    {
        int v = way[i].v;
        if(v == father[u]) continue;
        deep[v] = deep[u] + 1;
        w[v] = way[i].value;
        father[v] = u;
        dfs1(v);
        size[u] += size[v];
        if(size[v] > size[son[u]]) son[u] = v;
    }
}
int dfs2(int x,int tp)
{
    top[x]=tp;
    tuop[x]=++cur;
    pre[cur]=x;
    if(son[x])
    {
        dfs2(son[x],tp);
    }
    for(int i=head[x];i;i=way[i].next)
    {
        int to=way[i].v;
        if(to==father[x]||to==son[x])
        {
            continue;
        }
        dfs2(to,to);
    }
}
int lazy(int x)
{
    p[x<<1].f=(p[x].f+p[x<<1].f)%2;
    p[x<<1|1].f=(p[x].f+p[x<<1|1].f)%2;
    p[x<<1].value=-p[x<<1].value;
    p[x<<1|1].value=-p[x<<1|1].value;
    swap(p[x<<1].maxn,p[x<<1].minn);
    p[x<<1].maxn=p[x<<1].maxn*-1;
    p[x<<1].minn=p[x<<1].minn*-1;
    swap(p[x<<1|1].maxn,p[x<<1|1].minn );
    p[x<<1|1].maxn*=-1;
    p[x<<1|1].minn*=-1;
    p[x].f=0;
}

int update(int x)
{
    p[x].value=p[x<<1].value+p[x<<1|1].value;
    p[x].maxn=max(p[x<<1].maxn,p[x<<1|1].maxn);
    p[x].minn =min(p[x<<1].minn,p[x<<1|1].minn);
}
void create(int x,int l,int r)
{
    p[x].l=l;
    p[x].r=r;
    p[x].f=0;
    if(l==r)
    {
        p[x].value=w[pre[l]];
        p[x].maxn=w[pre[l]];
        p[x].minn=w[pre[l]];
        return ;
    }
    int mid=(l+r)>>1;
    create(x<<1,l,mid);
    create(x<<1|1,mid+1,r);
    update(x);
}
void change_point(int x,int l,int r)
{
    if(p[x].l==p[x].r)
    {
        p[x].value=r;
        p[x].maxn=r;
        p[x].minn=r;
        return ;
    }
    if(p[x].f)
    {
        lazy(x);
    }
    int mid=(p[x].l+p[x].r)>>1;
    if(l<=mid)
    {
        change_point(x<<1,l,r);
    }
    else
    {
        change_point(x<<1|1,l,r);
    }
    update(x);
}

void change_line(int x,int l,int r)
{
    if(p[x].l>=l&&p[x].r<=r)
    {
        p[x].f++;
        p[x].f%=2;
        p[x].value*=-1;
        swap(p[x].maxn,p[x].minn);
        p[x].maxn*=-1;
        p[x].minn*=-1;
        return ;
     } 
     if(p[x].f)
     {
         lazy(x);
     }
     int mid=(p[x].l+p[x].r)>>1;
     if(l<=mid)
     change_line(x<<1,l,r);
     if(r>mid)
     {
         change_line(x<<1|1,l,r);
     }
     update(x);
} 
inline void ask_sum(int x,int l,int r)
{
    if(p[x].l>=l&&p[x].r<=r)
    {
        ans+=p[x].value;
        return ;
    }
    if(p[x].f)
    {
        lazy(x);
    }
    int mid=(p[x].l+p[x].r)>>1;
    if(l<=mid)
    {
        ask_sum(x<<1,l,r);
    }
    if(r>mid)
    {
        ask_sum(x<<1|1,l,r);
    }
    update(x);
}
inline void ask_min(int x,int l,int r)
{
    if(p[x].l>=l&&p[x].r<=r)
    {
        ans=min(ans,p[x].minn);
        return;
    }
    if(p[x].f)
    {
        lazy(x);
    }
    int mid=(p[x].l+p[x].r)>>1;
    if(l<=mid)
    {
        ask_min(x<<1,l,r);
    }
    if(r>mid)
    {
        ask_min(x<<1|1,l,r);
    }
    update(x);
}

inline void ask_max(int x,int l,int r)
{
    if(p[x].l>=l&&p[x].r<=r)
    {
        ans=max(ans,p[x].maxn);
        return ;
    }
    if(p[x].f)
    {
        lazy(x);
    }
    int mid=(p[x].l+p[x].r)>>1;
    if(l<=mid)
    {
        ask_max(x<<1,l,r);
    }
    if(r>mid)
    {
       ask_max(x<<1|1,l,r);
    }
    update(x);
}
void qsum(int x,int to)
{
    ans=0;
    while(top[x]!=top[to])
    {
        if(deep[top[x]]<deep[top[to]])
        {
            swap(x,to);    
        }
        ask_sum(1,tuop[top[x]],tuop[x]);
        x=father[top[x]];
    }
    if(x==to)
    return ;
    if(tuop[x]>tuop[to])
    {
        swap(x,to);
    }
    ask_sum(1,tuop[x]+1,tuop[to]);
}

void qmin(int x,int to)
{
    ans=INF;
    while(top[x]!=top[to])
    {
        if(deep[top[x]]<deep[top[to]])
        {
            swap(x,to);
        }
        ask_min(1,tuop[top[x]],tuop[x]);
        x=father[top[x]];
    }
    if(x==to)
    return ;
    if(tuop[x]>tuop[to])
    {
        swap(x,to);
    }
    ask_min(1,tuop[x]+1,tuop[to]);
}

inline void qmax(int x,int to)
{
    ans=-INF;
    while(top[x]!=top[to])
    {
        if(deep[top[x]]<deep[top[to]])
        {
            swap(x,to);
        }
        ask_max(1,tuop[top[x]],tuop[x]);
        x=father[top[x]];
    }
    if(x==to)
    return ;
    if(tuop[x]>tuop[to])
    {
        swap(x,to);
    }
    ask_max(1,tuop[x]+1,tuop[to]);
}
inline void flip(int x,int to)
{
    while(top[x]!=top[to])
    {
        if(deep[top[x]]<deep[top[to]])
        {
            swap(x,to);
        }
        change_line(1,tuop[top[x]],tuop[x]);
        x=father[top[x]];
    }
    if(x==to)
    return ;
    if(tuop[x]>tuop[to])
    {
        swap(x,to);
    }
    change_line(1,tuop[x]+1,tuop[to]);
}
int main()
{
    cin>>n;
    for(int i=1;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        a++,b++;
        add(a,b,c);
        add(b,a,c);
    }
    dfs1(1);
    dfs2(1,1);
    create(1,1,n);
    cin>>m;
    for(int i=1;i<=m;i++)
    {
        scanf("%s",&fh);
        if(fh[0]=='C')
        {
            int a,b;
            cin>>a>>b;
            a++;
            change_point(1,tuop[a],b);
        }
        else
        if(fh[0]=='N')
        {
            int a,b;
            cin>>a>>b;
            a++,b++;
            flip(a,b);
        }
        else
        if(fh[0]=='S')
        {
            int a,b;
            cin>>a>>b;
            a++,b++;
            qsum(a,b);
            cout<<ans<<endl;
        }
        else
        if(fh[1]=='I')
        {
            int a,b;
            cin>>a>>b;
            a++,b++;
            qmin(a,b);
            cout<<ans<<endl;
        }
        else
        {
            int a,b;
            cin>>a>>b;
            a++,b++;
            qmax(a,b);
            cout<<ans<<endl;
        }
    }
    
    return 0;
}