[bzoj2157][树链剖分]旅游

最新推荐文章于 2021-09-22 18:41:38 发布
最新推荐文章于 2021-09-22 18:41:38 发布
阅读量442 收藏
点赞数
分类专栏： bzoj 树链剖分 OI路漫漫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rose_max/article/details/78960455
版权
bzoj 同时被 3 个专栏收录
483 篇文章 2 订阅
订阅专栏
OI路漫漫
109 篇文章 4 订阅
订阅专栏
树链剖分
15 篇文章 0 订阅
订阅专栏

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;
}
Rose_max
关注
专栏目录
BZOJ 2157 旅游 (树链剖分)
xcatf的博客
07-30 203
2157: 旅游 Description Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。Ray 发现...
BZOJ 2157: 旅游( 树链剖分 )
weixin_30549175的博客
06-26 273
树链剖分..样例太大了根本没法调...顺便把数据生成器放上来--------------------------------------------------------------------------------#include<cstdio>#include<cstring>#include<algorithm>#include<iostrea...
[国家集训队]旅游——[树链剖分]
sleepyNick
10-01 275
【题目描述】 Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。 Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座桥定义一个愉悦度w，也就是说，Ray 经过这座桥会...
洛谷P1505 [国家集训队]旅游 (树链剖分)
weixin_43519763的博客
10-25 209
洛谷P1505 [国家集训队]旅游 题目描述 Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。 Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座桥定义一个愉悦度w...
BZOJ[2157]旅游 树链剖分+线段树
谁能代表肯德基
10-18 481
题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=2157 DescriptionRay 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。Ray 发现，有些桥上可以
bzoj2157 旅游 树链剖分
olahiuj的博客
12-21 285
DescriptionRay 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座桥定义一个愉悦度w，也就是说，Ray 经过这座
BZOJ 2157 旅游 树链剖分
(╯°口°)╯(┴—┴
01-02 1099
题目大意：给出一棵树，支持以下操作：1.改变一条边的边权。2.将x到y路径的权值取反。3.查询x到y路径上最大值，最小值和权值和。 思路：好裸的链剖水题啊，唯一麻烦一点地是权值放在了边上，注意一下处理就没问题了。。 CODE： #include #include #include #include #define MAX 40010 #define INF 0
BZOJ2157:旅游 树链剖分
Oakley
09-26 454
2157: 旅游 Time Limit: 10 Sec  Memory Limit: 259 MB Submit: 1090  Solved: 539 [Submit][Status][Discuss] Description Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约
BZOJ 2157 「国家集训队」旅游（树链剖分，线段树，边权转点权）【BZOJ计划】
繁凡さん的博客
09-22 1299
【BZOJ修复计划 #20】BZOJ 2157 旅游 【国家集训队2011】
树链剖分_王天懿.ppt
09-14
4. **BZOJ 3589**：动态树的子树权值修改和链上的点权值求和，需要用到树链剖分的链上修改和查询能力。 5. **BZOJ 3626**：求最近公共祖先（LCA）与深度的累加，可以结合LCA算法和树链剖分优化查询。 总之，树链...
BZOJ 4034 树上操作（树链剖分）
Roll_Keyboard的博客
04-22 239
题意：思路：这题让我对树剖的体会更加深入了 因为我们在组链（也就是划分轻重边）的时候，是使用dfs序来进行划分的，所以我们子树的节点也依旧是在一起的，也就是说，树剖的时候顺便标记下dfs完自己子树时候的标号，就可以顺便完成dfs序时的标号要求了错误及反思：这题没什么难的。。主要是对树剖的体会更深了代码：#include<bits/stdc++.h> using namespace std; con
BZOJ 4034浅谈树链剖分及线段树维护
BerryKanry的博客
07-05 474
世界真的很大 这道题还是很良心的 上来就说是数据结构的题 这类题的特点是代码量大，叙述简单，支持修改和查询，数据规模在10^5左右 还是先看一下题： description：有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个 操作，分为三种： 操作 1 ：把某个节点 x 的点权增加 a 。 操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。 操作 3 ：询
【BZOJ 2243】染色 【树链剖分】
skysys的研究小屋
10-28 766
静态查错能力显著提升233，这次3分钟就查出bug#include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #include<iostream> #include<cctype> using namespace std; #define N 100010 #define g() getchar() #define d
2018.06.29 洛谷P1505 [国家集训队]旅游（树链剖分）
weixin_30437481的博客
06-29 114
旅游 题目描述 Ray 乐忠于旅游，这次他来到了T 城。T 城是一个水上城市，一共有 N 个景点，有些景点之间会用一座桥连接。为了方便游客到达每个景点但又为了节约成本，T 城的任意两个景点之间有且只有一条路径。换句话说， T 城中只有N − 1 座桥。 Ray 发现，有些桥上可以看到美丽的景色，让人心情愉悦，但有些桥狭窄泥泞，令人烦躁。于是，他给每座...
[bzoj3531][树链剖分]旅行
Rose_max的博客
12-03 1537
Description S国有N个城市，编号从1到N。城市间用N-1条双向道路连接，满足 从一个城市出发可以到达其它所有城市。每个城市信仰不同的宗教，如飞天面条神教、隐形独角兽教、绝地教都是常见的信仰。为了方便，我们用不同的正整数代表各种宗教， S国的居民常常旅行。旅行时他们总会走最短路，并且为了避免麻烦，只在信仰和他们相同的城市留宿。当然旅程的终点也是信仰与他相同的城市。S国政府为
[bzoj1103][树链剖分]大都市
Rose_max的博客
09-26 879
Description 在经济全球化浪潮的影响下,习惯于漫步在清晨的乡间小路的邮递员Blue Mary也开始骑着摩托车传递邮件了。 不过，她经常回忆起以前在乡间漫步的情景。昔日，乡下有依次编号为1..n的n个小村庄，某些村庄之间有一些双向的土路。从每个村庄都恰好有一条路径到达村庄1（即比特堡）。并且，对于每个村庄，它到比特堡的路径恰好只经过编号比它的编号小的村庄。另外，对于所有道路而言，它
[bzoj2243][树链剖分]染色
Rose_max的博客
12-25 652
Description 给定一棵有n个节点的无根树和m个操作，操作有2类： 1、将节点a到节点b路径上所有点都染成颜色c； 2、询问节点a到节点b路径上的颜色段数量（连续相同颜色被认为是同一段）， 如“112221”由3段组成：“11”、“222”和“1”。 请你写一个程序依次完成这m个操作。 Input 第一行包含2个整数n和m，分别表示节点数和操作数； 第二行包含n个正整数表
[bzoj3083][树链剖分][lca]遥远的国度
Rose_max的博客
11-29 505
Description 描述 zcwwzdjn在追杀十分sb的zhx，而zhx逃入了一个遥远的国度。当zcwwzdjn准备进入遥远的国度继续追杀时，守护神RapiD阻拦了zcwwzdjn的去路，他需要zcwwzdjn完成任务后才能进入遥远的国度继续追杀。 问题是这样的：遥远的国度有n个城市，这些城市之间由一些路连接且这些城市构成了一颗树。这个国度有一个首都，我们可以把这个首都看做
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值