BZOJ-3083 遥远的国度 树链剖分+分类讨论 or DFS序

3083: 遥远的国度

Time Limit: 10 Sec Memory Limit: 1280 MB

Submit: 2165 Solved: 525

[Submit][Status][Discuss]

Description

描述

zcwwzdjn在追杀十分sb的zhx，而zhx逃入了一个遥远的国度。当zcwwzdjn准备进入遥远的国度继续追杀时，守护神RapiD阻拦了zcwwzdjn的去路，他需要zcwwzdjn完成任务后才能进入遥远的国度继续追杀。

问题是这样的：遥远的国度有n个城市，这些城市之间由一些路连接且这些城市构成了一颗树。这个国度有一个首都，我们可以把这个首都看做整棵树的根，但遥远的国度比较奇怪，首都是随时有可能变为另外一个城市的。遥远的国度的每个城市有一个防御值，有些时候RapiD会使得某两个城市之间的路径上的所有城市的防御值都变为某个值。RapiD想知道在某个时候，如果把首都看做整棵树的根的话，那么以某个城市为根的子树的所有城市的防御值最小是多少。由于RapiD无法解决这个问题，所以他拦住了zcwwzdjn希望他能帮忙。但zcwwzdjn还要追杀sb的zhx，所以这个重大的问题就被转交到了你的手上。

Input

第1行两个整数n m，代表城市个数和操作数。

第2行至第n行，每行两个整数 u v，代表城市u和城市v之间有一条路。

第n+1行，有n个整数，代表所有点的初始防御值。

第n+2行一个整数 id，代表初始的首都为id。

第n+3行至第n+m+2行，首先有一个整数opt，如果opt=1，接下来有一个整数id，代表把首都修改为id；如果opt=2，接下来有三个整数p1 p2 v，代表将p1 p2路径上的所有城市的防御值修改为v；如果opt=3，接下来有一个整数 id，代表询问以城市id为根的子树中的最小防御值。

Output

对于每个opt=3的操作，输出一行代表对应子树的最小点权值。

Sample Input

3 7

1 2

1 3

1 2 3

1

3 1

2 1 1 6

3 1

2 2 2 5

3 1

2 3 3 4

3 1

Sample Output

1

2

3

4

提示

对于20%的数据，n<=1000 m<=1000。

对于另外10%的数据，n<=100000，m<=100000，保证修改为单点修改。

对于另外10%的数据，n<=100000，m<=100000，保证树为一条链。

对于另外10%的数据，n<=100000，m<=100000，没有修改首都的操作。

对于100%的数据，n<=100000，m<=100000，0<所有权值<=2^31。

HINT

Source

zhonghaoxi提供

题解：

很明显的树链剖分

至于换根操作，不同于动态树问题中的换根，动态树问题的换根中，树的形态和结构发生了变化，所以需要用灵活的LCT之类的去维护，而这个题，仔细分析发现，只是名义上的根发生了变化，实际树的形态和结构并没有发生变化，所以还是可以用链剖去解决，只需要分类讨论一下即可；

操作1：记录下新的根即可

操作2：随便搞搞，求一下区间的最小即可，同T2

操作3：根据id和root分类讨论；

①root==id，询问整棵树

②fa[root]==id，询问除了root所在子树以外的整棵树

③root在id的子树里，且距离大于1，询问除了root的除了其祖先是id的儿子的祖先的子树以外的整棵树

④root不在id的子树里，询问id的子树

code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int read()
{
int x=0,f=1; char ch=getchar();
while (ch<'0' || ch>'9') {if (ch=='-') f=-1; ch=getchar();}
while (ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();}
return x*f;
}
#define maxn 200010
int n,m,sd;struct data{int next,to;}edge[maxn*2];
int head[maxn],cnt;
void add(int u,int v){cnt++;edge[cnt].next=head[u];head[u]=cnt;edge[cnt].to=v;}
void insert(int u,int v){add(u,v);add(v,u);}
//--------------------------------------------------------------------------------------
int deep[maxn],size[maxn],son[maxn],pl[maxn],sz,pr[maxn],pre[maxn],top[maxn],fa[maxn],father[maxn][25];
void dfs_1(int now)
{
size[now]=1;
for (int i=head[now]; i; i=edge[i].next)
if (edge[i].to!=fa[now])
{
fa[edge[i].to]=now;
deep[edge[i].to]=deep[now]+1;
dfs_1(edge[i].to);
if (size[son[now]]<size[edge[i].to]) son[now]=edge[i].to;
size[now]+=size[edge[i].to];
}
}
void dfs_2(int now,int chain)
{
pl[now]=++sz; pre[sz]=now; top[now]=chain;
if (son[now]) dfs_2(son[now],chain);
for (int i=head[now]; i; i=edge[i].next)
if (edge[i].to!=son[now] && edge[i].to!=fa[now])
dfs_2(edge[i].to,edge[i].to);
pr[now]=sz;
}
int LCA(int x,int y)
{
int dx=deep[x],dy=deep[y];
if (dx<dy) swap(dx,dy); int dd=dx-dy;
for (int i=0; i<=20; i++) if (dd&(1<<i)) x=father[x][i];
for (int i=20; i>=1; i++)
if (father[x][i]!=father[y][i])
x=father[x][i],y=father[y][i];
if (x==y) return x; else return father[x][0];
}
//--------------------------------------------------------------------------------------
int tree[maxn<<2],del[maxn<<2];
inline void update(int now)
{if (tree[now<<1]<tree[now<<1|1]) tree[now]=tree[now<<1];else tree[now]=tree[now<<1|1];}
inline void pushdown(int now,int l,int r)
{
if (!del[now]) return;
int mid=(l+r)>>1; int dd=del[now];
del[now]=0; del[now<<1]=dd; del[now<<1|1]=dd;
tree[now<<1]=dd; tree[now<<1|1]=dd;
}
void point_change(int now,int l,int r,int loc,int val)
{
pushdown(now,l,r);
if (l==r) {tree[now]+=val;return;}
int mid=(l+r)>>1;
if (loc<=mid) point_change(now<<1,l,mid,loc,val);
else point_change(now<<1|1,mid+1,r,loc,val);
update(now);
}
void segment_change(int now,int l,int r,int L,int R,int val)
{
pushdown(now,l,r);
if (L<=l && R>=r) {tree[now]=val;del[now]=val;return;}
int mid=(l+r)>>1;
if (L<=mid) segment_change(now<<1,l,mid,L,R,val);
if (R>mid) segment_change(now<<1|1,mid+1,r,L,R,val);
update(now);
}
int segment_ask(int now,int l,int r,int L,int R)
{
pushdown(now,l,r);
if (L<=l && R>=r) return tree[now];
int mid=(l+r)>>1; int ans=0x7fffffff;
if (L<=mid) ans=min(ans,segment_ask(now<<1,l,mid,L,R));
if (R>mid) ans=min(ans,segment_ask(now<<1|1,mid+1,r,L,R));
return ans;
}
//--------------------------------------------------------------------------------------
void solve1(int id)
{
sd=id;
}
void solve2(int p1,int p2,int val)
{
while (top[p1]!=top[p2])
{
int tp1=top[p1],tp2=top[p2];
if (deep[tp1]<deep[tp2]) swap(tp1,tp2),swap(p1,p2);
segment_change(1,1,n,pl[tp1],pl[p1],val);
p1=fa[p1]; tp1=top[p1];
}
if (deep[p1]>deep[p2]) swap(p1,p2);
segment_change(1,1,n,pl[p1],pl[p2],val);
}
void solve3(int id)
{
if(id==sd) printf("%d\n",segment_ask(1,1,n,1,n));
else if(fa[sd]==id)
printf("%d\n",min(segment_ask(1,1,n,1,pl[sd]-1),pr[sd]==n?0x7fffffff:segment_ask(1,1,n,pr[sd]+1,n)));
else if(pl[sd]>=pl[id]&&pl[sd]<=pr[id])
{
int U=sd;
while(fa[top[U]]!=id&&top[U]!=top[id]) U=fa[top[U]];
if(fa[top[U]]!=id)
U=pre[pl[id]+1];
else
U=top[U];
printf("%d\n",min(segment_ask(1,1,n,1,pl[U]-1),pr[U]==n?0x7fffffff:segment_ask(1,1,n,pr[U]+1,n)));
}
else
printf("%d\n",segment_ask(1,1,n,pl[id],pr[id]));
}
//--------------------------------------------------------------------------------------
int main()
{
n=read(),m=read();
for (int u,v,i=1; i<=n-1; i++)
u=read(),v=read(),insert(u,v);
dfs_1(1);  dfs_2(1,1);
for (int pro,i=1; i<=n; i++)
pro=read(),point_change(1,1,n,pl[i],pro);
sd=read();
for (int i=1; i<=m; i++)
{
int opt=read();int id,p1,p2,v;
switch (opt)
{
case 1: id=read(); solve1(id);break;
case 2: p1=read(),p2=read(),v=read(); solve2(p1,p2,v);break;
case 3: id=read(); solve3(id);break;
}
}
return 0;
}