POJ2763 Housewife Wind【LCA】

题意：给一棵树，有边权。两种查询，1.当前位置到y的距离 2.修改某条边

思路：LCA + 树状数组。按从根dfs访问的顺序把图转化为链，这样就能和树状数组结合了。记录下顶点序列vs和对应的深度depth。对于每个定点记录其首次出现的位置为id。这样求lca时便可，求id[u] 到  id[v]之间depth的最小值（线段树、RMQ），对应的顶点就是lca了。树状数组方面，每次按照走过的边的顺序放入树状数组add，叶子方向正边，根方向反边。并且把这些边在树状数组中的位置记录下来，修改操作时修改。u 到  v的距离 = sum( id[u] ) + sum( id[v] ) - 2 * sum( id[lca] )。纸上画一画就知道了，重边抵消了，正好等于lca到u的距离 + lca到v的距离。可能说的不清楚，《挑战程序设计》P330开始，讲得很好。

PS：以后养成用邻接表的习惯，有的题真得比用vector快好多，贴个模板

struct Edge
{
    int to,next;
}edge[maxn*maxn];
int head[maxn],tot;

void init()
{
    memset(head,-1,sizeof head);
    tot = 0;
}

void add(int x,int y)
{
    edge[tot].to = y;
    edge[tot].next = head[x];
    head[x] = tot++;
}//for(int i = head[x]; i != -1; i = edge[i].next)

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<stdlib.h>
#include<math.h>
#include<vector>
#include<list>
#include<map>
#include<stack>
#include<queue>
#include<algorithm>
#include<numeric>
#include<functional>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define lson(x) 2*x
#define rson(x) 2*x+1
const int maxn = 200005;
struct Edge
{
	int to,cost,id,next;
}edge[maxn*2];
int head[maxn],tot;
int rmq_n;
int vs[maxn*2],depth[maxn*2],id[maxn];
int es[maxn*2];
int tree[maxn*4],bit_n;
int root,w[maxn];

struct data
{
	int l,r,num,dep; //num -> 下标，dep -> depth最小值 
}node[maxn*4];

void init(int x)
{
	memset(tree,0,sizeof tree);
	memset(head,-1,sizeof head);
	tot = 0;
}

void addedge(int a,int b,int c,int id)
{
	edge[tot].to = b;
	edge[tot].cost = c;
	edge[tot].id = id;
	edge[tot].next = head[a];
	head[a] = tot++;
	
	edge[tot].to = a;
	edge[tot].cost = c;
	edge[tot].id = id;
	edge[tot].next = head[b];
	head[b] = tot++;
}

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

void add(int cnt,int val)
{
	while(cnt <= bit_n)       // n -> num of point
	{
		tree[cnt] += val;
		cnt += lowbit(cnt);
	}
}

int fid(int cnt) // 1 ~ k sum
{
	int sum = 0;
	while(cnt)
	{
		sum += tree[cnt];
		cnt -= lowbit(cnt);
	}
	return sum;
}

void pushup(int cnt)
{
	node[cnt].dep = min(node[lson(cnt)].dep,node[rson(cnt)].dep);
	if(node[lson(cnt)].dep < node[rson(cnt)].dep)
		node[cnt].num = node[lson(cnt)].num;
	else
		node[cnt].num = node[rson(cnt)].num;
}

void build(int x,int y, int cnt)
{
	node[cnt].l = x;
	node[cnt].r = y;
	if(x == y)
	{
		node[cnt].num = vs[x];
		node[cnt].dep = depth[x];
		return;
	}
	int mid = (x+y) / 2;
	build(x,mid,lson(cnt));
	build(mid+1,y,rson(cnt));
	pushup(cnt);
}

pii fidd(int x,int y,int cnt)
{
	pii a,b;
	a.second = 0x3f3f3f3f;
	b.second = 0x3f3f3f3f;
	if(x == node[cnt].l && y == node[cnt].r)
	{
		return make_pair(node[cnt].num,node[cnt].dep);
	}
	int fa = 2*cnt;
	if(x <= node[fa].r)
	{
		if(y <= node[fa].r)
			a = fidd(x,y,fa);
		else
			a = fidd(x,node[fa].r,fa);
	}
	fa++;
	if(y >= node[fa].l)
	{
		if(x >= node[fa].l)
			b = fidd(x,y,fa);
		else
			b = fidd(node[fa].l,y,fa);
	}
	if(a.second < b.second)
		return a;
	else
		return b;
}

void dfs(int v,int p,int d,int &k)
{
	id[v] = k;
	vs[k] = v;
	depth[k++] = d;
	for(int i = head[v]; i != -1; i = edge[i].next)
	{
		Edge &e = edge[i];
		if(e.to != p)
		{
			add(k,e.cost);
			es[e.id*2] = k;
			dfs(e.to,v,d+1,k);
			vs[k] = v;
			depth[k++] = d;
			add(k,-e.cost);
			es[e.id*2+1] = k;
		}
	}
}

void yu(int x)
{
	rmq_n = 2*x-1;
	root = (x+1) / 2;
	bit_n = 2 *(x-1); //走过几条边 
	int k = 1;
	dfs(root,-1,0,k);
	build(1,rmq_n,1);
}

int main(void)
{
	int n,m,x;
	while(scanf("%d%d%d",&n,&m,&x)!=EOF)
	{
		init(n);
		for(int i = 1; i < n; i++)
		{
			int a,b,c;
			scanf("%d%d%d",&a,&b,&c);
			addedge(a,b,c,i);
			w[i] = c;
		}
		yu(n);
		while(m--)
		{
			int op,a,b,y,gong;
			scanf("%d",&op);
			if(op == 0)
			{
				scanf("%d",&y);
				pii f = fidd(min(id[x],id[y]),max(id[x],id[y]),1);
				gong = f.first;
				printf("%d\n",fid(id[x])+fid(id[y])-2*fid(id[gong]));
				x = y;
			}
			else
			{
				scanf("%d%d",&a,&b);
				add(es[a*2],b-w[a]);
				add(es[a*2+1],w[a]-b);
				w[a] = b;
			}
		}
	}
	return 0;
}