[bzoj2157][树链剖分]旅游

最新推荐文章于 2024-07-29 13:48:13 发布

原创最新推荐文章于 2024-07-29 13:48:13 发布 · 503 阅读

0 ·

CC 4.0 BY-SA版权

bzoj 同时被 3 个专栏收录

482 篇文章

订阅专栏

OI路漫漫

108 篇文章

订阅专栏

树链剖分

14 篇文章

订阅专栏

本文介绍了一道关于树剖分与线段树结合应用的算法题目解析，包括问题描述、输入输出格式、示例及解题思路。通过树剖分预处理和线段树动态维护，解决路径查询与更新等问题。

Description

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。

题解

真的是困~~看错两次题~~
这个题面太恶心了。。看完输入才发现还有两个操作
修改的是修改第i座桥啊啊啊啊不是修改第i个点。。
树剖呗。
单点修改大家都会我不bb
成段反转的话，最大最小值互换，然后取反。总权直接取反，打上lazy标记
给了个经验就是。。明确一下lazy的定义。。
真的是个毒瘤题

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
struct node
{
    int x,y,c,next;
}a[611000];int len,last[311000];
void ins(int x,int y,int c)
{
    len++;
    a[len].x=x;a[len].y=y;a[len].c=c;
    a[len].next=last[x];last[x]=len;
}
int fa[311000],dep[311000],tot[311000],son[311000];
void pre_tree_node(int x)
{
    son[x]=0;tot[x]=1;
    for(int k=last[x];k;k=a[k].next)
    {
        int y=a[k].y;
        if(y!=fa[x])
        {
            fa[y]=x;
            dep[y]=dep[x]+1;
            pre_tree_node(y);
            if(tot[son[x]]<tot[y])son[x]=y;
            tot[x]+=tot[y];
        }
    }
}
int ys[311000],z,top[311000];
void pre_tree_edge(int x,int tp)
{
    ys[x]=++z;top[x]=tp;
    if(son[x]!=0)pre_tree_edge(son[x],tp);
    for(int k=last[x];k;k=a[k].next)if(a[k].y!=fa[x] && a[k].y!=son[x])pre_tree_edge(a[k].y,a[k].y);
}
struct trnode
{
    int lc,rc,l,r,s;
    int mx,mn;
    bool up;
}tr[1111000];int trlen;
void bt(int l,int r)
{
    int now=++trlen;
    tr[now].l=l;tr[now].r=r;
    tr[now].lc=tr[now].rc=-1;tr[now].s=0;
    tr[now].mx=tr[now].mn=0;
    tr[now].up=false;
    if(l<r)
    {
        int mid=(l+r)/2;
        tr[now].lc=trlen+1;bt(l,mid);
        tr[now].rc=trlen+1;bt(mid+1,r);
    }
}
void upd(int now)
{
    int lc=tr[now].lc,rc=tr[now].rc;
    swap(tr[lc].mx,tr[lc].mn);
    tr[lc].mx=tr[lc].mx*-1;
    tr[lc].mn=tr[lc].mn*-1;
    tr[lc].s=tr[lc].s*-1;
    swap(tr[rc].mx,tr[rc].mn);
    tr[rc].mx=tr[rc].mx*-1;
    tr[rc].mn=tr[rc].mn*-1;
    tr[rc].s=tr[rc].s*-1;
    tr[lc].up^=1;tr[rc].up^=1;
    tr[now].up=false;
}
void change(int now,int l,int r,int c)
{
    if(tr[now].l==l && tr[now].r==r){tr[now].s=tr[now].mx=tr[now].mn=c;return ;}
    int lc=tr[now].lc,rc=tr[now].rc;
    int mid=(tr[now].l+tr[now].r)/2;
    if(tr[now].up)upd(now);
    if(r<=mid)change(lc,l,r,c);
    else if(mid+1<=l)change(rc,l,r,c);
    else {change(lc,l,mid,c);change(rc,mid+1,r,c);}
    tr[now].s=tr[lc].s+tr[rc].s;
    tr[now].mx=max(tr[lc].mx,tr[rc].mx);
    tr[now].mn=min(tr[lc].mn,tr[rc].mn);
}
void change_mul(int now,int l,int r)
{
    if(tr[now].l==l && tr[now].r==r)
    {
        tr[now].up^=1;
        tr[now].s=tr[now].s*-1;
        swap(tr[now].mx,tr[now].mn);
        tr[now].mx=tr[now].mx*-1;
        tr[now].mn=tr[now].mn*-1;
        return ;
    }
    int lc=tr[now].lc,rc=tr[now].rc;
    int mid=(tr[now].l+tr[now].r)/2;
    if(tr[now].up)upd(now);
    if(r<=mid)change_mul(lc,l,r);
    else if(mid+1<=l)change_mul(rc,l,r);
    else {change_mul(lc,l,mid);change_mul(rc,mid+1,r);}
    tr[now].s=tr[lc].s+tr[rc].s;
    tr[now].mx=max(tr[lc].mx,tr[rc].mx);
    tr[now].mn=min(tr[lc].mn,tr[rc].mn);
}
int solsum(int now,int l,int r)
{
    if(tr[now].l==l && tr[now].r==r){return tr[now].s;}
    int lc=tr[now].lc,rc=tr[now].rc;
    int mid=(tr[now].l+tr[now].r)/2;
    if(tr[now].up)upd(now);
    if(r<=mid)return solsum(lc,l,r);
    else if(mid+1<=l)return solsum(rc,l,r);
    else return solsum(lc,l,mid)+solsum(rc,mid+1,r);
}
int solmax(int now,int l,int r)
{
    if(tr[now].l==l && tr[now].r==r){return tr[now].mx;}
    int lc=tr[now].lc,rc=tr[now].rc;
    int mid=(tr[now].l+tr[now].r)/2;
    if(tr[now].up)upd(now);
    if(r<=mid)return solmax(lc,l,r);
    else if(mid+1<=l)return solmax(rc,l,r);
    else return max(solmax(lc,l,mid),solmax(rc,mid+1,r));
}
int solmin(int now,int l,int r)
{
    if(tr[now].l==l && tr[now].r==r){return tr[now].mn;}
    int lc=tr[now].lc,rc=tr[now].rc;
    int mid=(tr[now].l+tr[now].r)/2;
    if(tr[now].up)upd(now);
    if(r<=mid)return solmin(lc,l,r);
    else if(mid+1<=l)return solmin(rc,l,r);
    else return min(solmin(lc,l,mid),solmin(rc,mid+1,r));
}
int solx(int x,int y)
{
    int tx=top[x],ty=top[y];
    int ans=-999999999;
    while(tx!=ty)
    {
        if(dep[tx]>dep[ty])swap(x,y),swap(tx,ty);
        ans=max(ans,solmax(1,ys[ty],ys[y]));
        y=fa[ty];ty=top[y];
    }
    if(x==y){return ans;}
    else
    {
        if(dep[x]>dep[y])swap(x,y);
        return max(ans,solmax(1,ys[son[x]],ys[y]));
    }
}
int soln(int x,int y)
{
    int tx=top[x],ty=top[y];
    int ans=999999999;
    while(tx!=ty)
    {
        if(dep[tx]>dep[ty])swap(x,y),swap(tx,ty);
        ans=min(ans,solmin(1,ys[ty],ys[y]));
        y=fa[ty];ty=top[y];
    }
    if(x==y){return ans;}
    else
    {
        if(dep[x]>dep[y])swap(x,y);
        return min(ans,solmin(1,ys[son[x]],ys[y]));
    }
}
int sols(int x,int y)
{
    int tx=top[x],ty=top[y];
    int ans=0;
    while(tx!=ty)
    {
        if(dep[tx]>dep[ty])swap(x,y),swap(tx,ty);
        ans+=solsum(1,ys[ty],ys[y]);
        y=fa[ty];ty=top[y];
    }
    if(x==y){return ans;}
    else
    {
        if(dep[x]>dep[y])swap(x,y);
        ans+=solsum(1,ys[son[x]],ys[y]);
        return ans;
    }
}
void change_x(int x,int y)
{
    int tx=top[x],ty=top[y];
    while(tx!=ty)
    {
        if(dep[tx]>dep[ty])swap(x,y),swap(tx,ty);
        change_mul(1,ys[ty],ys[y]);
        y=fa[ty];ty=top[y];
    }
    if(x==y){return ;}
    else
    {
        if(dep[x]>dep[y])swap(x,y);
        change_mul(1,ys[son[x]],ys[y]);
    }
}
int n,m;
char ss[10];
int main()
{
    len=0;memset(last,0,sizeof(last));
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        int x,y,c;
        scanf("%d%d%d",&x,&y,&c);
        x++;y++;
        ins(x,y,c);ins(y,x,c);
    }
    fa[1]=0;dep[1]=1;
    pre_tree_node(1);
    z=0;pre_tree_edge(1,1);
    trlen=0;bt(1,z);
    for(int i=1;i<=len;i+=2)
    {
        int cnt,x=a[i].x,y=a[i].y;
        if(dep[x]<dep[y])cnt=y;
        else cnt=x;
        change(1,ys[cnt],ys[cnt],a[i].c);
    }
    scanf("%d",&m);
    while(m--)
    {
        int u,v;
        scanf("%s%d%d",ss+1,&u,&v);
        if(ss[1]=='C')
        {
            int cnt,x=a[u*2-1].x,y=a[u*2-1].y;
            if(dep[x]<dep[y])cnt=y;
            else cnt=x;
            change(1,ys[cnt],ys[cnt],v);    
        }
        else if(ss[1]=='N'){u++;v++;change_x(u,v);}
        else if(ss[2]=='A'){u++;v++;printf("%d\n",solx(u,v));}
        else if(ss[2]=='I'){u++;v++;printf("%d\n",soln(u,v));}
        else {u++;v++;printf("%d\n",sols(u,v));}
    }
    return 0;
}