【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[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;       
}