UESTC 912 树上的距离 --LCA+RMQ+树状数组

1.易知，树上两点的距离dis[u][v] = D[u]+D[v]-2*D[lca(u,v)] (D为节点到根节点的距离)

2.某条边<u,v>权值一旦改变，将会影响所有以v为根的子树上的节点到根节点的距离，很明显，DFS一遍后以v为根的子树在DFS序列中是连续的一段，及转化为区间更新问题，可以用树状数组。

做法：先把求LCA解决，LCA可以转化为RMQ问题，可参见：LCA转RMQ, 即转化为LCA(T,u,v) = RMQ(B,pos[u],pos[v])，其中B为深度序列。预先DFS可以处理出深度序列，我这里用的是“另一种”深度序列，即时间戳表示的深度序列，用时间戳来代表深度，以及欧拉序列和pos数组，还有in[],out[]数组，表示每个节点DFS进出的时间戳。在DFS时间戳序列上建树状数组，值为每个节点与原来到根节点的距离相比的该变量。要用树状数组需要用一个巧妙的方法转为前缀和问题：在时间戳序列中，如果要更新v的子树，即为更新in[v],out[v],令a = in[v],b=out[v]，则可以令A[a] = delta,A[b+1] = -delta。然后更新，就可以用树状数组来查询了。然后每次求两点间距离的时候，结果为固定的dis[u][v]+变动的值（树状数组query求出）。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define N 100007

struct Edge
{
    int u,v,w,next;
}G[2*N];

int first[N],tot,n,Time,ind,ola[3*N],id;
int pos[N],in[2*N],out[2*N],vis[3*N];
int d[2*N][24],dis[N],c[2*N],T[2*N],dp[3*N];

void RMQ_init()
{
    int i,j;
    for(i=1;i<=id;i++)
        d[i][0] = dp[i];
    for(j=1;(1<<j)<=id;j++)
    {
        for(i=1;i+(1<<j)-1<=id;i++)
            d[i][j] = min(d[i][j-1],d[i+(1<<(j-1))][j-1]);
    }
}

int RMQ(int l,int r)
{
    int k = 0;
    while((1<<(k+1)) <= r-l+1)
        k++;
    return min(d[l][k],d[r-(1<<k)+1][k]);
}

void addedge(int u,int v,int w)
{
    G[tot].u = u;
    G[tot].v = v;
    G[tot].w = w;
    G[tot].next = first[u];
    first[u] = tot++;
}

void init()
{
    memset(G,0,sizeof(G));
    memset(first,-1,sizeof(first));
    memset(c,0,sizeof(c));
    memset(d,0,sizeof(d));
    tot = 1;
    Time = 0;
    ind = 0;
    id = 0;
}

void DFS(int u,int fa)
{
    ++Time;
    int deep = Time;
    ola[++ind] = u;
    T[Time] = u;
    dp[++id] = Time;
    in[u] = Time;
    for(int i=first[u];i!=-1;i=G[i].next)
    {
        int v = G[i].v;
        if(v == fa)
            continue;
        DFS(v,u);
        dp[++id] = deep;  //深度序列
        ola[++ind] = u;   //欧拉序列
    }
    //if(flag)
        //ola[++ind] = u;
    out[u] = Time;
}

void DFSWG(int u,int w,int fa)
{
    dis[u] = w;
    for(int i=first[u];i!=-1;i=G[i].next)
    {
        int v = G[i].v;
        if(v == fa)
            continue;
        DFSWG(v,w+G[i].w,u);
    }
}

void Getpos()
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=ind;i++)
    {
        if(!vis[ola[i]])
        {
            vis[ola[i]] = 1;
            pos[ola[i]] = i;
        }
    }
}

int LCA(int u,int v)
{
    int L = min(pos[u],pos[v]);
    int R = max(pos[u],pos[v]);
    return T[RMQ(L,R)];
}

int lowbit(int x)
{
    return x&(-x);
}

void update(int k,int num)
{
    while(k <= n)
    {
        c[k] += num;
        k += lowbit(k);
    }
}

int query(int k)
{
    int sum = 0;
    while(k > 0)
    {
        sum += c[k];
        k -= lowbit(k);
    }
    return sum;
}

int main()
{
    int i,j,u,v,w,op,q;
    scanf("%d",&n);
    {
        init();
        for(i=0;i<n-1;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        scanf("%d",&q);
        DFS(1,-1);
        Getpos();
        RMQ_init();
        DFSWG(1,0,-1);  //算出dis
        while(q--)
        {
            scanf("%d%d%d",&op,&u,&v);
            if(op == 1)
            {
                int lca = LCA(u,v);
                printf("%d
",dis[u]+dis[v]-2*dis[lca]+query(in[u])+query(in[v])-2*query(in[lca]));
            }
            else
            {
                int s = G[2*u-1].u;
                int t = G[2*u-1].v;
                if(pos[s] > pos[t])  //保证s是t的父亲
                    swap(s,t);
                int delta = v - G[2*u-1].w;
                G[2*u-1].w = G[2*u].w = v;  //更新权值
                update(in[t],delta);
                update(out[t]+1,-delta);
            }
        }
    }
    return 0;
}