用途
解决树的上路径修改,查询等操作,时间复杂度 O(R×log2n) (R为维护的其它数据结构复杂度,一般为线段树 R=log2n )。
主要思路
将整棵树的边分为轻边和重边,将每个重边连成的链当作一个区间,用维护区间的数据结构去维护它。
如何选择重边
一般选连接子树所含节点最多的儿子作为重边,如图:
这样可以保证从根节点到任何一个节点,最多只有
log2n
个重边链。
简单说明最坏情况:
实现技巧
标号
我们可以给这棵树重新标号,使得每一条重链的点编号为连续的,更方便使用线段树维护,如上图的树:
构建数据结构
有两种实现
一种是使用一棵线段树,维护整个区间,代码复杂度很低,缺点是不能在
O(1)
的时间复杂度下查询整个重链。
另一种是给每一个重链建一棵线段树,代码复杂度就很恶心了,但可以
O(1)
查询重链信息。
查询路径
初始化时记录每个节点所在重链的最高点top,节点到根的距离(深度dep)。
更新从a到b的路径的信息:
1.如果a与b不在同一个重链(top[a]!=top[b])
2.选择a与b更深的一个点c(dep更大)
3.更新c到top[c]重链
4.c:=top[c]的父亲
5.重复1
6.此时a与b在同一个重链,更新a到b的路径
代码
SPOJ QTREE(使用一棵线段树)
//SPOJ QTREE
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=20005;
struct Edge
{
int v;
Edge *nxt;
}E[MAXN*2],*V[MAXN],*cur;
void add_edge(int u,int v)
{
cur->v=v,cur->nxt=V[u];
V[u]=cur++;
cur->v=u,cur->nxt=V[v];
V[v]=cur++;
}
int val[MAXN];
//Heavy-Light Decomposition
int fa[MAXN],dep[MAXN],siz[MAXN],son[MAXN];
int tid[MAXN],rnk[MAXN],top[MAXN],dcnt;
void dfs1(int u,int pa,int deep)
{
fa[u]=pa;
dep[u]=deep;
siz[u]=1;
son[u]=0;
int mx=0;
for(Edge *p=V[u];p;p=p->nxt)
{
int v=p->v;
if(v!=pa)
{
dfs1(v,u,deep+1);
siz[u]+=siz[v];
if(mx<siz[v])
mx=siz[v],son[u]=v;
}
}
}
void dfs2(int u,int tp)
{
tid[u]=++dcnt;
rnk[dcnt]=u;
top[u]=tp;
if(son[u]==0)return;
dfs2(son[u],tp);
for(Edge *p=V[u];p;p=p->nxt)
{
int v=p->v;
if(v!=fa[u]&&v!=son[u])
dfs2(v,v);
}
}
//segment tree
int mx[MAXN*4],mxpos;
void PushUp(int u)
{mx[u]=max(mx[u*2],mx[u*2+1]);}
void Build(int u=1,int L=1,int R=mxpos)
{
if(L==R)
{
mx[u]=val[rnk[L]];
return;
}
int mid=(L+R)/2;
Build(u*2,L,mid);
Build(u*2+1,mid+1,R);
PushUp(u);
}
void Modify(int pos,int nval,int u=1,int L=1,int R=mxpos)
{
if(L==pos&&R==pos)
{
mx[u]=nval;
return;
}
int mid=(L+R)/2;
if(pos<=mid)
Modify(pos,nval,u*2,L,mid);
if(pos>mid)
Modify(pos,nval,u*2+1,mid+1,R);
PushUp(u);
}
int Query(int l,int r,int u=1,int L=1,int R=mxpos)
{
if(R<l||r<L)return 0;
if(l<=L&&R<=r)
return mx[u];
int mid=(L+R)/2,res=0;
res=Query(l,r,u*2,L,mid);
res=max(res,Query(l,r,u*2+1,mid+1,R));
return res;
}
int QueryPath(int a,int b)
{
int ans=0;
while(top[a]!=top[b])
{
if(dep[top[a]]>dep[top[b]])
swap(a,b);
ans=max(ans,Query(tid[top[b]],tid[b]));
b=fa[top[b]];
}
if(dep[a]>dep[b])
swap(a,b);
ans=max(ans,Query(tid[a],tid[b]));
return ans;
}
void Init(int n)
{
cur=E;
memset(V,0,sizeof V);
memset(val,0,sizeof val);
memset(mx,0,sizeof mx);
mxpos=n+n-1;
dcnt=0;
}
int main()
{
int T,n;
char op[10];
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
Init(n);
for(int i=1,a,b,c;i<n;i++)
{
scanf("%d%d%d",&a,&b,&c);
val[n+i]=c;
add_edge(a,n+i);
add_edge(n+i,b);
}
dfs1(1,0,1);
dfs2(1,1);
Build();
while(true)
{
scanf("%s",op);
if(op[0]=='D')
break;
int a,b;
scanf("%d%d",&a,&b);
if(op[0]=='C')
Modify(tid[a+n],b);
else
printf("%d\n",QueryPath(a,b));
}
}
return 0;
}
SPOJ QTREE5(使用多棵线段树维护)
//SPOJ QTREE5
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=100005;
const int IMAX=0x7F7F7F7F,IMIN=0x80808080;
struct Heap
{
priority_queue< int,vector<int>,greater<int> >heap,del;
void push(int u)
{heap.push(u);}
void erase(int u)
{del.push(u);}
int top()
{
while(!del.empty()&&heap.top()==del.top())
heap.pop(),del.pop();
return heap.top();
}
int size()
{return heap.size()-del.size();}
};
struct Edge
{
int v;
Edge *nxt;
}E[MAXN*2],*V[MAXN],*ecnt=E;
void add_edge(int u,int v)
{
ecnt->v=v;ecnt->nxt=V[u];
V[u]=ecnt++;
ecnt->v=u;ecnt->nxt=V[v];
V[v]=ecnt++;
}
int fa[MAXN],son[MAXN],siz[MAXN],dep[MAXN];
int top[MAXN],tid[MAXN],rnk[MAXN],csiz[MAXN],dcnt;
void dfs1(int u,int pa,int deep)
{
fa[u]=pa;dep[u]=deep;
siz[u]=1;son[u]=0;
int best=0;
for(Edge *p=V[u];p;p=p->nxt)
{
int v=p->v;
if(v!=pa)
{
dfs1(v,u,deep+1);
siz[u]+=siz[v];
if(best<siz[v])
best=siz[v],son[u]=v;
}
}
}
void dfs2(int u,int tp)
{
tid[u]=++dcnt;
rnk[dcnt]=u;
top[u]=tp;
csiz[tp]++;
if(son[u]==0)return;
dfs2(son[u],tp);
for(Edge *p=V[u];p;p=p->nxt)
{
int v=p->v;
if(v!=fa[u]&&v!=son[u])
dfs2(v,v);
}
}
struct Node
{
int mnl,mnr;
Node *lc,*rc;
};
Node *root[MAXN],nodes[MAXN*2],*ncnt=nodes;
bool col[MAXN];
Heap oth[MAXN];
void Update(Node *u,int id)
{
int res=IMAX;
if(col[id])
res=0;
if(oth[id].size())
res=min(res,oth[id].top()+1);
u->mnl=u->mnr=res;
}
void PushUp(Node *u,int L,int R)
{
int mid=(L+R)/2;
u->mnl=min(u->lc->mnl,u->rc->mnl+mid+1-L);
u->mnr=min(u->lc->mnr+R-mid,u->rc->mnr);
}
void Build(Node *&u,int L,int R)
{
if(u==NULL)u=ncnt++;
if(L==R)
{
int t=rnk[L];
for(Edge *p=V[t];p;p=p->nxt)
{
int v=p->v;
if(v!=fa[t]&&top[v]!=top[t])
{
Build(root[top[v]],tid[v],tid[v]+csiz[top[v]]-1);
oth[t].push(root[top[v]]->mnl+1);
}
}
Update(u,t);
return;
}
int mid=(L+R)/2;
Build(u->lc,L,mid);
Build(u->rc,mid+1,R);
PushUp(u,L,R);
}
void Modify(int pos,int od,int nw,Node *u,int L,int R)
{
if(pos==L&&R==pos)
{
if(od!=-1)
{
int t=rnk[pos];
oth[t].erase(od);
oth[t].push(nw);
}
Update(u,rnk[pos]);
return;
}
int mid=(L+R)/2;
if(pos<=mid)
Modify(pos,od,nw,u->lc,L,mid);
else
Modify(pos,od,nw,u->rc,mid+1,R);
PushUp(u,L,R);
}
int Query(int l,int r,bool f,Node *u,int L,int R)
{
if(l<=L&&R<=r)
return f?u->mnr:u->mnl;
int mid=(L+R)/2,r1=IMAX,r2=IMAX;
if(l<=mid)
{
r1=Query(l,r,f,u->lc,L,mid);
if(f&&r>mid)r1+=r-mid;
}
if(r>mid)
{
r2=Query(l,r,f,u->rc,mid+1,R);
if(!f&&l<=mid)r2+=mid+1-l;
}
return min(r1,r2);
}
void Modify(int u)
{
int od=-1,nw=-1,t;
while(u)
{
t=root[top[u]]->mnl;
Modify(tid[u],od,nw,root[top[u]],tid[top[u]],tid[top[u]]+csiz[top[u]]-1);
od=t;
nw=root[top[u]]->mnl;
u=fa[top[u]];
}
}
int Query(int u)
{
int res=IMAX,dis=0,last=u;
while(u)
{
res=min(res,Query(tid[u],tid[top[u]]+csiz[top[u]]-1,0,root[top[u]],tid[top[u]],tid[top[u]]+csiz[top[u]]-1)+dis);
res=min(res,Query(tid[top[u]],tid[u],1,root[top[u]],tid[top[u]],tid[top[u]]+csiz[top[u]]-1)+dis);
last=u;
u=fa[top[u]];
dis+=dep[last]-dep[u];
}
return res;
}
int main()
{
int N,Q,op,a,b,cnt=0;
scanf("%d",&N);
for(int i=1;i<N;i++)
{
scanf("%d%d",&a,&b);
add_edge(a,b);
}
dfs1(1,0,1);
dfs2(1,1);
Build(root[1],tid[1],tid[1]+csiz[1]-1);
scanf("%d",&Q);
for(int i=1;i<=Q;i++)
{
scanf("%d%d",&op,&a);
if(op==0)
{
if(col[a])
cnt--,col[a]=0;
else
cnt++,col[a]=1;
Modify(a);
}
else
{
if(cnt==0)puts("-1");
else printf("%d\n",Query(a));
}
}
return 0;
}