【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 10005using namespace std;struct tree1{    int x,y,val;     void read(){scanf("%d%d%d",&x,&y,&val);}} e[N];vector<int> v[N];struct tree2{    int l,r,val;} tree[N*4];int dep[N],siz[N],fa[N],id[N],son[N],val[N],top[N];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;       }