【bzoj3306】【树】【dfs序+线段树】

本文介绍了一种基于有根点权树的操作优化方法,支持换根、修改点权及查询子树最小值。通过深度优先搜索构建线段树并实现高效查询,适用于树形数据结构的高级操作。

Description

给定一棵大小为 n 的有根点权树,支持以下操作: 
  • 换根 
  • 修改点权  
     • 查询子树最小值 

Input

  第一行两个整数 n, Q ,分别表示树的大小和操作数。 
  接下来n行,每行两个整数f,v,第i+1行的两个数表示点i的父亲和点i的权。保证f < i。如 果f = 0,那么i为根。输入数据保证只有i = 1时,f = 0。 
  接下来 m 行,为以下格式中的一种: 
  • V x y表示把点x的权改为y 
  • E x 表示把有根树的根改为点 x 
  • Q x 表示查询点 x 的子树最小值 

Output

  对于每个 Q ,输出子树最小值。 

Sample Input


3 7
0 1
1 2
1 3
Q 1
V 1 6
Q 1
V 2 5
Q 1
V 3 4
Q 1


Sample Output



1
2
3
4

HINT

  对于 100% 的数据:n, Q ≤ 10^5。

题解:首先按dfs序建线段树。

           对于换根操作。我们分三种情况讨论(设root为当前根,x为要查询的子树)

           1.若root==x直接查询整棵树即可。

           2.若lca(root,x)!=x那就直接查询x这个子树即可。

           3.若lca(root,x)=x那就查询和x相连的和root最近的点的子树的补集即可。

画个图看看就明白了。

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 100010
using namespace std;
struct use{int st,en;}e[N*2];
int point[N],next[N*2],now,fa[N][30],v[N],tree[N*4],mx[N],n,q;
int d[N],pos[N],p,cnt,deep[N],x,y,f;
char ch[10];
inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x;
}
void add(int x,int y){
  next[++cnt]=point[x];point[x]=cnt;
  e[cnt].st=x;e[cnt].en=y; 
}
void dfs(int x){
  for (int i=1;(1<<i)<=deep[x];i++) fa[x][i]=fa[fa[x][i-1]][i-1];
  d[x]=mx[x]=++p;
  for (int i=point[x];i;i=next[i])
    if(e[i].en!=fa[x][0]){
      fa[e[i].en][0]=x;deep[e[i].en]=deep[x]+1;
      dfs(e[i].en);mx[x]=max(mx[e[i].en],mx[x]);    
    } 
}
int lca(int x,int y){
  if (deep[x]<deep[y]) swap(x,y);int t=deep[x]-deep[y];
  for (int i=0;i<=20;i++) if (t&(1<<i)) x=fa[x][i];
  for (int i=20;i>=0;i--) if (fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
  if (x==y) return x;else return fa[x][0];
}
void change(int k,int l,int r,int p,int v){
   int mid=(l+r)>>1;
   if (l==r){tree[k]=v;return;}
   if (p<=mid) change(k<<1,l,mid,p,v);
   else change(k<<1|1,mid+1,r,p,v);
   tree[k]=min(tree[k<<1],tree[k<<1|1]);
}
int query(int k,int l,int r,int ll,int rr){
  int mid=(l+r)>>1,ans(999999999);
  if (ll<=l&&r<=rr) return tree[k];
  if (ll<=mid) ans=min(ans,query(k<<1,l,mid,ll,rr));
  if (rr>mid) ans=min(ans,query(k<<1|1,mid+1,r,ll,rr));
  return ans;
} 
int cal(int x,int t){
  for (int i=0;i<=20;i++)if ((1<<i)&t) x=fa[x][i];
  return x;
}
int main(){
  n=read();q=read();now=1;
  for (int i=1;i<=n;i++){
   f=read();v[i]=read();
   if (f){add(f,i);add(i,f);}   
  }
  dfs(1);memset(tree,127/3,sizeof(tree));   
  for (int i=1;i<=n;i++) change(1,1,n,d[i],v[i]);
  for (int i=1;i<=q;i++){
    scanf("%s",&ch); 
    if (ch[0]=='V'){x=read();y=read();change(1,1,n,d[x],y);}
    if (ch[0]=='E'){x=read();now=x;}
    if (ch[0]=='Q'){
      x=read();f=lca(now,x);
      if (now==x) {printf("%d\n",query(1,1,n,1,mx[1]));continue;}
      if (f!=x) printf("%d\n",query(1,1,n,d[x],mx[x]));
      if (f==x){
        int u=cal(now,deep[now]-deep[x]-1);
        int ans=query(1,1,n,1,d[u]-1);
        if (mx[u]<n) ans=min(ans,query(1,1,n,mx[u]+1,n));
        printf("%d\n",ans);
      }
    }
  }
}


        

BZOJ 3306 是一道与相关的编程挑战题,涉及动态维护一棵的某些性质,并支持修改操作。题目通常要求处理以下两种操作: 1. **修改节点权值**:将某个节点的权值进行更新。 2. **查询子中的最小值**:给定一个节点作为根,求其子中所有节点权值的最小值。 ### 解题思路 为了解决此类问题,需要高效的结构维护方法。以下是常用的解题策略: #### 链剖分(Heavy-Light Decomposition) 链剖分是一种将结构转化为线性列的技术,通过这种方式可以使用线段树等数据结构来高效处理区间查询和单点更新操作。具体步骤包括: - 对进行轻重链划分,使得每个节点到根路径上的边被分成若干个连续的块。 - 使用线段树状数组来维护这些连续块的信息,例如最小值、最大值或总和。 #### DFS + 线段树 另一种常见的方法是利用深度优先搜索(DFS)遍历,并记录每个节点进入和离开的时间戳。这样可以将每个子表示为一个连续的区间。随后,使用线段树来维护这个线性列的最小值信息: - 在预处理阶段,通过 DFS 遍历并记录每个节点的入栈时间和出栈时间。 - 子的范围可以通过入栈时间确定,即从该节点的入栈时间到出栈时间之间的所有节点都属于该子。 - 使用线段树维护区间最小值,支持快速查询和更新操作[^1]。 #### 示例代码 以下是一个简单的线段树实现用于维护最小值的例子: ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 250000 + 10; int n, m; int val[MAXN]; vector<int> G[MAXN]; int in_time[MAXN], out_time[MAXN], dfs_clock; void dfs(int u, int fa) { in_time[u] = ++dfs_clock; for (int v : G[u]) { if (v != fa) { dfs(v, u); } } out_time[u] = dfs_clock; } struct SegmentTree { int tree[MAXN << 2]; void build(int node, int l, int r) { if (l == r) { tree[node] = val[l]; return; } int mid = (l + r) / 2; build(node * 2, l, mid); build(node * 2 + 1, mid + 1, r); tree[node] = min(tree[node * 2], tree[node * 2 + 1]); } void update(int node, int l, int r, int pos, int value) { if (l == r) { tree[node] = value; return; } int mid = (l + r) / 2; if (pos <= mid) { update(node * 2, l, mid, pos, value); } else { update(node * 2 + 1, mid + 1, r, pos, value); } tree[node] = min(tree[node * 2], tree[node * 2 + 1]); } int query(int node, int l, int r, int ql, int qr) { if (ql > r || qr < l) return INT_MAX; if (ql <= l && r <= qr) return tree[node]; int mid = (l + r) / 2; return min(query(node * 2, l, mid, ql, qr), query(node * 2 + 1, mid + 1, r, ql, qr)); } } st; int main() { scanf("%d%d", &n, &m); for (int i = 1; i <= n; ++i) { scanf("%d", &val[i]); } for (int i = 1; i < n; ++i) { int u, v; scanf("%d%d", &u, &v); G[u].push_back(v); G[v].push_back(u); } dfs(1, -1); for (int i = 1; i <= n; ++i) { val[in_time[i]] = val[i]; } st.build(1, 1, n); while (m--) { int op, x; scanf("%d%d", &op, &x); if (op == 1) { int y; scanf("%d", &y); st.update(1, 1, n, in_time[x], y); } else { printf("%d\n", st.query(1, 1, n, in_time[x], out_time[x])); } } return 0; } ``` ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值