poj 2763 Housewife Wind

LCA+BIT，LCA用的是基于RMQ的方式实现的，RMQ又是采用传说中的稀疏表实现，也叫st方法

最核心的思想就是用dfs遍历一遍有根树，将遍历路径看做是一条链，这样就可以把树转化为链来做了，具体实现是运用了一个时间戳数组记录

ps：不知道是递归层数太多，还是vector太坑爹，g++会TLE，c++就AC了

#include<iostream>
#include<sstream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<stack>
#include<math.h>
#include<map>
#include<time.h>
#include<set>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
#define inf 0x7fffffff
#define lc l,m,index<<1
#define rc m+1,r,index<<1|1
#define max_n 200005
#define mod 10000007
#define LL  long long
struct edge
{
    int id,to,cost;
};
int n,p,s;
vector<edge>G[100005];
int w[max_n];
int es[max_n];
int depth[max_n];
int f[max_n][18];
int b[max_n];
int vs[max_n];
int id[max_n];
int root;
int k;
int sum(int i)
{
    int s=0;
    while(i>0)
    {
        s+=b[i];
        i-=(i&-i);
    }
    return s;
}
void add(int i,int x)
{
    while(i<=2*n-1)
    {
        b[i]+=x;
        i+=(i&-i);
    }
}
void rmq_init(int n,int a[])
{
    for(int i=0;i<n;i++)f[i][0]=i;

    for(int j=1;(1<<j)<=n;j++)
    {
        for(int i=0;i+(1<<j)-1<n;i++)
        {
            f[i][j]=a[f[i][j-1]]<a[f[i+(1<<(j-1))][j-1]]?f[i][j-1]:f[i+(1<<(j-1))][j-1];
        }
    }
}
void dfs(int v,int p,int d,int &k)
{
    id[v]=k;
    vs[k]=v;
    depth[k++]=d;
    for(int i=0;i<G[v].size();i++)
    {
        edge &e=G[v][i];
        if(e.to!=p)
        {
            es[e.id*2]=k;
            add(k,e.cost);
          //  printf("k==%d cost==%d\n",k,e.cost);
            dfs(e.to,v,d+1,k);
            vs[k]=v;
            add(k,-e.cost);
          //  printf("k==%d cost==%d\n",k,-e.cost);
            depth[k]=d;
            es[e.id*2+1]=k++;

        }
    }
}
void init(int n)
{
    memset(b,0,sizeof(b));
    k=0;
    dfs(root,-1,0,k);

/*
    printf("vs:");
    for(int i=0;i<k;i++)
    printf(" %d",vs[i]+1);
    printf("\n");

    printf("depth:");
    for(int i=0;i<k;i++)
    printf(" %d",depth[i]);
    printf("\n");

    printf("id:");
    for(int i=0;i<n;i++)
    printf(" %d",id[i]);
    printf("\n");


    system("pause");
    */

    rmq_init(2*n-1,depth);
}
int query(int l,int r)
{
    int k=int(log((r-l+1)*1.0)/log(2*1.0));
    return depth[f[l][k]]<depth[f[r-(1<<k)+1][k]]?f[l][k]:f[r-(1<<k)+1][k];
}
int lca(int u,int v)
{
    return vs[query(min(id[u],id[v]),max(id[u],id[v]))];
}
void inits()
{
    /*
    memset(f,0,sizeof(f));
    memset(vs,0,sizeof(vs));
    memset(id,-1,sizeof(id));
    memset(depth,-1,sizeof(depth));
    */
    for(int i=0;i<100005;i++)
    G[i].clear();
}
int main()
{
    while(~scanf("%d%d%d",&n,&p,&s))
    {
        inits();
        for(int i=0;i<n-1;i++)
        {
            int a,b;
            scanf("%d%d%d",&a,&b,&w[i]);
            edge e;
            e.id=i;
            e.to=b-1;
            e.cost=w[i];
            G[a-1].push_back(e);
            e.to=a-1;
            G[b-1].push_back(e);
        }
        root=0;
        init(n);
        int v=s-1;
        for(int i=0;i<p;i++)
        {
            int tp,u,x,val;
            scanf("%d",&tp);
            if(!tp)
            {
                scanf("%d",&u);
                u--;
                int q=lca(u,v);
              //  printf("q == %d\n",q+1);
                printf("%d\n",sum(id[u])+sum(id[v])-sum(id[q])*2);
                v=u;
            }
            else
            {
                scanf("%d%d",&x,&val);
                x--;
                add(es[x*2],val-w[x]);
                add(es[x*2+1],w[x]-val);
                w[x]=val;
            }
        }

    }
    return 0;
}