【SPOJ 375】Query on a tree&树链剖分详解

SPOJ 375

题意

给你一棵树每条边的权值，有两种操作：修改某一条边的权值；询问两点之间的路径和。（多组数据）

样例输入

1

3

1 2 1

2 3 2

QUERY 1 2

CHANGE 1 3

QUERY 1 2

DONE

样例输出

1

3

树链剖分详解

树链剖分是一种把树上询问转换为链状询问的方法，也就是说只要是单链能做树上也能做，并且只会加一个很小的常数。所以一般如果部分分是单链的话，后面的点肯定能用树剖做。

剖分

预处理时，把一棵树剖成若干条链，然后用单链的方式维护。我们把链上的边叫做重边，重边与重边之间的边叫做轻边。下图中粗的边就是重边。不过每条链单独维护太复杂，那就直接把所有链接在一起维护。

有一个性质：如果按照重边dfs每条链的dfs序编号一定是连续的。询问时，把每个询问拆成若干条链，在数据结构上查询。

启发式剖分

剖分也有好坏之分。感性的想一想（后面有证明），由于重边用数据结构维护，复杂度为logn，轻边直接直接访问，复杂度为n，那么我们希望每次尽量多的访问重边，这里用到一个启发式剖分。

定义：

dep[x] x节点的深度

siz[x] x的子树大小

fa[x] x的父节点

id[x] x节点的编号（转换到树链后的编号）

son[x] x的重儿子

top[x] x所在重链的顶端

重儿子的定义：所有儿子中siz最大的一个

首先dfs一次，找出所有节点的重儿子，同时可以处理出dep、siz、fa；然后再dfs一次，每次优先搜索重儿子，这样就能向下拉出一条重链，回溯的时候，其他非重儿子依次继续向下拉出一条重链。比如上图中一开始拉出了1、4、9、13、14，然后回溯到1的时候，访问2，然后2再向下拉出一条重链。

void dfs1(int x,int ftr,int d)
{
dep[x] = d; siz[x] = 1; son[x] = 0; fa[x] = ftr;
for (int i = 0;i < v[x].size(); i++)
{
int nxt = v[x][i];
if (nxt == ftr) continue;
dfs1(nxt,x,d+1);
siz[x] += siz[nxt];
if (siz[nxt] > siz[son[x]]) son[x] = nxt;
}
}

void dfs2(int x,int tp)
{
top[x] = tp; id[x] = ++num;
if (son[x] > 0) dfs2(son[x],tp);
for (int i = 0;i < v[x].size(); i++)
{
int nxt = v[x][i];
if (nxt == fa[x] || nxt == son[x]) continue;
dfs2(nxt,nxt);
}
}

关于这样的剖分有如下性质：

1、轻边(u,v)中，size(v)<=size(u/2)。 用反证法显然。

2、从根到某一点的路径上，不超过logn条轻边和不超过logn条重路径。虽然我不会证这个，但我知道这就保证了『每次尽量多的访问重边』。

维护

这里我用的是线段树维护。之前的剖分做完之后问题完全转化为单链怎么做，那就很简单了。

查询

下面讲讲怎么查询(u,v)。

分成两种情况考虑：

1、u和v在同一条重链上，即top[u] = top[v]，这个时候直接在线段树里找就好了，因为之前说过u到v的节点是连续的。

2、u和v不在同一条重链上。比较两条链的起点，哪个比较低，哪个节点就跑到这条链的顶端，此时再向上爬一条边（轻边）就来到了一条新的重链，然后循环。显然这个点到顶点也是连续的，而向上爬一层轻边的时间复杂度仅为o(1)。

int link(int u,int v)
{
int top1 = top[u]; int top2 = top[v];
int res = 0;
while (top1 != top2)
{
if (dep[top1] < dep[top2])
{swap(top1,top2); swap(u,v);}
res = max(query(1,id[top1],id[u]),res);
u = fa[top1];
top1 = top[u];
}
if (u == v) return res;
if (dep[u] > dep[v]) swap(u,v);
res = max(query(1,id[son[u]],id[v]),res);
return res;
}

完整代码

感觉树剖封装性比较好。。。大部分时候只要先研究一下单链，然后拖个树剖，改一下link函数里面的查询操作就行了。

#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iomanip>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#define ll long long
#define inf 1000000000
#define mod 1000000007
#define N 10005
using namespace std;
struct tree1
{
int x,y,val;
void read(){scanf("%d%d%d",&x,&y,&val);}
} e
;
vector<int> v
;
struct tree2
{
int l,r,val;
} tree[N*4];
int dep
,siz
,fa
,id
,son
,val
,top
;
int T,num,i,n,x,y;

void dfs1(int x,int ftr,int d)
{
dep[x] = d; siz[x] = 1; son[x] = 0; fa[x] = ftr;
for (int i = 0;i < v[x].size(); i++)
{
int nxt = v[x][i];
if (nxt == ftr) continue;
dfs1(nxt,x,d+1);
siz[x] += siz[nxt];
if (siz[nxt] > siz[son[x]]) son[x] = nxt;
}
}

void dfs2(int x,int tp)
{
top[x] = tp; id[x] = ++num;
if (son[x] > 0) dfs2(son[x],tp);
for (int i = 0;i < v[x].size(); i++)
{
int nxt = v[x][i];
if (nxt == fa[x] || nxt == son[x]) continue;
dfs2(nxt,nxt);
}
}

void build(int l,int r,int rt)
{
tree[rt].l = l; tree[rt].r = r;
if (l == r) {tree[rt].val = val[l]; return;}
int mid = (l + r) >> 1;
build(l,mid,rt << 1);
build(mid+1,r,rt << 1 | 1);
tree[rt].val = max(tree[rt<<1].val,tree[rt<<1|1].val);
}
void update(int rt,int key,int val)
{
if (tree[rt].l == tree[rt].r)
{tree[rt].val = val; return;}
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (key <= mid) update(rt<<1,key,val);
else update(rt<<1|1,key,val);
tree[rt].val = max(tree[rt<<1].val,tree[rt<<1|1].val);
}
int query(int rt,int l,int r)
{
if (tree[rt].l >= l && tree[rt].r <= r) return tree[rt].val;
int mid = (tree[rt].l + tree[rt].r) >> 1;
int res = 0;
if (l <= mid) res = max(res,query(rt<<1,l,r));
if (r > mid) res = max(res,query(rt<<1|1,l,r));
return res;
}

int link(int u,int v)
{
int top1 = top[u]; int top2 = top[v];
int res = 0;
while (top1 != top2)
{
if (dep[top1] < dep[top2])
{swap(top1,top2); swap(u,v);}
res = max(query(1,id[top1],id[u]),res);
u = fa[top1];
top1 = top[u];
}
if (u == v) return res;
if (dep[u] > dep[v]) swap(u,v);
res = max(query(1,id[son[u]],id[v]),res);
return res;
}

int main()
{
scanf("%d",&T);
while (T--)
{
scanf("%d",&n);
for (i = 1;i < n; i++)
{
e[i].read();
v[e[i].x].push_back(e[i].y);
v[e[i].y].push_back(e[i].x);
}

num = 0; dfs1(1,0,1); dfs2(1,1);

for (i = 1;i <= n; i++)
{
if (dep[e[i].x] < dep[e[i].y]) swap(e[i].x,e[i].y);
val[id[e[i].x]] = e[i].val;//val数组用来记录每个点上面的那条边的权值
}
build(1,n,1);
char s[40]; scanf("%s",&s);
while (s[0] != 'D')
{
scanf("%d%d",&x,&y);
if (s[0] == 'Q') printf("%d\n",link(x,y));
if (s[0] == 'C') update(1,id[e[x].x],y);
scanf("%s",&s);
}
for(int i = 1;i <= n; i++) v[i].clear();
}
return 0;
}