题意:
给出一颗边上有权的树和三种操作;
QUERY x y:查询x节点到y节点上的最大权值;
CHANGE x y:将编号为x的边权值改为y;
NEGATE x y:将节点x与节点y之间的路上所有边的权值取相反数数;
节点数n<=10000;
题解:
显然是树链剖分的算法,但是这里的权值在边上不太方便;
所以就将边的权赋在这条边所连的较深点上(就是儿子节点啦);
根节点的值没有意义;
处理这些随便乱搞就好,但是在处理Q和N询问时,对轻重链的操作又有所不同;
对于两个节点x , y,他们不在同一重链时,是和正常的链剖一样的;
而在同一重链,则略有不同;
1:x !=y 这时应该取deep较小的一个节点取重儿子,与另一个查询最大;
2:x==y 这时不需要任何处理,因为事实上我们已经处理了所有边可以返回值了;
(就是说当前链上最上面的点代表的边不属于这个路径所有)
因为要取相反数,所以同时维护max和min,这样就可以O(1)让线段树节点临时维护完成;
多组数据总是要清点什么;
(然而我总是忘了清点什么)
代码:
#include
#include
#include
#include
#define N 100001
#define lson l,mid,no<<1
#define rson mid+1,r,no<<1|1
using namespace std;
vectorto[N],val[N];
int n,tot,ma[N<<2],mi[N<<2],X[N],Y[N],a[N],rank[N];
int fa[N],deep[N],size[N],son[N],top[N],p[N];
bool cov[N<<2];
void init()
{
for(int i=1;i<=n;i++) to[i].clear(),val[i].clear();
tot=0;
memset(son,0,sizeof(son));
}
void dfs1(int x,int pre,int d)
{
fa[x]=pre,deep[x]=d,size[x]=1;
int i,y,ms=0;
for(i=0;ims)
ms=size[y],son[x]=y;
}
}
}
void dfs2(int x,int pre,int t)
{
p[x]=++tot;
rank[tot]=x;
top[x]=t;
if(son[x])
dfs2(son[x],x,t);
int i,y;
for(i=0;i>1;
build(lson);
build(rson);
Pushup(no);
}
}
void update(int l,int r,int no,int st,int en)
{
if(st<=l&&r<=en)
nega(no);
else
{
int mid=(l+r)>>1;
Pushdown(no);
if(en<=mid) update(lson,st,en);
else if(st>mid) update(rson,st,en);
else update(lson,st,en),update(rson,st,en);
Pushup(no);
}
}
void change(int l,int r,int no,int k,int val)
{
if(l==r)
ma[no]=mi[no]=val;
else
{
int mid=(l+r)>>1;
Pushdown(no);
if(k<=mid) change(lson,k,val);
else change(rson,k,val);
Pushup(no);
}
}
int query(int l,int r,int no,int st,int en)
{
if(st<=l&&r<=en)
return ma[no];
else
{
int mid=(l+r)>>1;
Pushdown(no);
if(en<=mid) return query(lson,st,en);
else if(st>mid) return query(rson,st,en);
else return max(query(lson,st,en),query(rson,st,en));
}
}
void find(int x,int y)
{
while(top[x]!=top[y])
{
if(deep[top[x]]deep[Y[x]]?X[x]:Y[x]],y);
else if(str[0]=='N')
find(x,y);
else if(str[0]=='Q')
printf("%d\n",ask(x,y));
}
}
return 0;
}