POJ - 2763 Housewife Wind LCA+dfs序+线段树

q次询问求两个点之间的距离，并且可以随时修改某条边的长度，最短距离可以用lca来求，但是树上维护每一个点到root的距离必须要用dfs序来记录时间戳，在dfs的时候顺便记录每一条边（u,v）对应的v节点，更改某条边时需要更新的是将L[v]~R[v]的值加上这一条边的变化量，然后log查询每个点到root的距离即可。

改变这一条边u->v的值,要记录v点，因为其实改变这条边的值改变的是L[v]~R[v]的值

对应的线段树的操作就是区间更新，单点查询。

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<math.h>
#include<set>
#include<stack>
#include<vector>
#include<map>
#include<queue>
#define myself i,l,r
#define lson i<<1
#define rson i<<1|1
#define Lson i<<1,l,mid
#define Rson i<<1|1,mid+1,r
#define half (l+r)/2
#define inff 0x3f3f3f3f
#define lowbit(x) x&(-x)
#define PI 3.14159265358979323846
#define me(a,b) memset(a,b,sizeof(a))
#define min4(a,b,c,d) min(min(a,b),min(c,d))
#define min3(x,y,z) min(min(x,y),min(y,z))
#define pii make_pair
const int dir[4][2]= {0,-1,-1,0,0,1,1,0};
typedef long long ll;
const ll inFF=9223372036854775807;
typedef unsigned long long ull;
using namespace std;
const int maxn=1e5+5;
int f[maxn][33],head[maxn],dis[maxn],s[maxn],d[maxn];///d表示深度，dis和s是dfs过程中暂时记录到root点的距离
int L[maxn],R[maxn];///L,R分别记录dfs序的时间戳，
int way[maxn],eg[maxn];///记录边对应dfs中开始的点以及那条边的权值，eg一直在更新
int root,sign,t,n,q;
struct node
{
    int to,p,val;
}edge[maxn<<1];
int tree[maxn<<2],lazy[maxn<<2];
void init()
{
    sign=t=0;
    for(int i=0;i<=n;i++)
        head[i]=-1;
}
void add(int u,int v,int val)
{
    edge[sign].to=v;
    edge[sign].val=val;
    edge[sign].p=head[u];
    head[u]=sign++;
}
void dfs(int u)
{
    L[u]=++t;
    s[t]=dis[u];
    for(int i=1;(1<<i)<=n;i++)
        f[u][i]=f[f[u][i-1]][i-1];
    for(int i=head[u];~i;i=edge[i].p)
    {
        int v=edge[i].to;
        if(f[u][0]==v) continue;
        dis[v]=dis[u]+edge[i].val;
        way[i/2+1]=v;///这一条边u->v,记录v点，因为改变这条边的值改变的是L[v]~R[v]的值
        eg[i/2+1]=edge[i].val;///因为改变量，所以更新后要记录
        d[v]=d[u]+1;///深度
        f[v][0]=u;///父亲
        dfs(v);
    }
    R[u]=t;
}
void pushdown(int i)
{
    if(lazy[i])
    {
        lazy[lson]+=lazy[i];
        lazy[rson]+=lazy[i];
        lazy[i]=0;
    }
}
void build(int i,int l,int r)
{
    lazy[i]=0;
    if(l==r)
    {
        tree[i]=s[l];
        return;
    }
    int mid=half;
    build(Lson);
    build(Rson);
}
void update(int i,int l,int r,int ql,int qr,int val)
{
    if(ql<=l&&qr>=r){
        lazy[i]+=val;
        return;
    }
    int mid=half;
    if(qr<=mid) update(Lson,ql,qr,val);
    else if(ql>=mid+1) update(Rson,ql,qr,val);
    else {
        update(Lson,ql,mid,val);
        update(Rson,mid+1,qr,val);
    }
}
int query(int i,int l,int r,int x)
{
    if(l==r) return tree[i]+lazy[i];
    int mid=half;
    pushdown(i);
    if(x<=mid) return query(Lson,x);
    else return query(Rson,x);
}
int lca(int a,int b)
{
    if(d[a]<d[b]) swap(a,b);
    int x=d[a]-d[b];
    for(int i=0;(1<<i)<=x;i++)
        if((1<<i)&x) a=f[a][i];
    if(a!=b)
    {
        for(int i=(int)log2(n);i>=0;i--)
            if(f[a][i]!=f[b][i]) a=f[a][i],b=f[b][i];
        a=f[a][0];
    }
    return a;
}
int find(int a,int b)
{
    int r=lca(a,b);
    return query(1,1,n,L[a])+query(1,1,n,L[b])-2*query(1,1,n,L[r]);
}
int main()
{
    int op,x,y,val;
    while(cin>>n>>q>>root)
    {
        init();
        for(int i=1;i<n;i++)
        {
            scanf("%d %d %d",&x,&y,&val);
            add(x,y,val),add(y,x,val);
        }
        f[root][0]=root,d[root]=0,dis[root]=0;
        dfs(root);
        build(1,1,n);
        while(q--)
        {
            scanf("%d",&op);
            if(!op)
            {
                scanf("%d",&x);
                printf("%d\n",find(root,x));
                root=x;
            }
            else
            {
                scanf("%d %d",&x,&y);
                int v=way[x];
                update(1,1,n,L[v],R[v],y-eg[x]);
                eg[x]=y;
            }
        }
    }
    return 0;
}