「CF838B」 Diverging Directions

#include <bits/stdc++.h>
#define N 1<<18
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))

using namespace std;

struct SegTree{
	int n;
	ll tree[N<<2],lazy[N<<2];
	void init(int _n){
		n=_n;
		mem(tree,0);
		mem(lazy,0);
	}
	void pushdown(int node){
		lazy[node<<1]+=lazy[node];
		tree[node<<1]+=lazy[node];
		lazy[node<<1|1]+=lazy[node];
		tree[node<<1|1]+=lazy[node];
		lazy[node]=0;
	}
	void update(int node,int l,int r,int L,int R,ll value){
		if(L>R || l>R || r<L) return;
		if(L<=l && r<=R){
			tree[node]+=value;
			lazy[node]+=value;
			return;
		}
		pushdown(node);
		update(node<<1,l,l+r>>1,L,R,value);
		update(node<<1|1,(l+r>>1)+1,r,L,R,value);

		tree[node]=min(tree[node<<1],tree[node<<1|1]);
	}
	ll query(int node,int l,int r,int L,int R){
		if(L>R || l>R || r<L) return numeric_limits < ll > ::max();
		if(L<=l && r<=R){
			return tree[node];
		}
		pushdown(node);
		return min(query(node<<1,l,l+r>>1,L,R),
				query(node<<1|1,(l+r>>1)+1,r,L,R));
	}
	void update(int L,int R,ll value){
		update(1,1,n,L,R,value);
	}
	ll query(int L,int R){
		return query(1,1,n,L,R);
	}
}from_root,from_root_and_back;

struct Edge{
	int to,next,w;
}e[N];
int head[N],cnt;
void add(int u,int v,int w){
	e[++cnt]=(Edge){v,head[u],w};
	head[u]=cnt;
}
int from[N<<1];

int L[N],R[N],idx;
ll dis[N];
void dfs(int x,int fa){
	L[x]=R[x]=++idx;
	for(int i=head[x];i;i=e[i].next){
		int v=e[i].to;
		if(v!=fa){
			dis[v]=dis[x]+e[i].w;
			dfs(v,x);
			R[x]=R[v];
		}
	}
}

ll dep(int x){
	return from_root.query(L[x],L[x]); 	
}

ll back[N];
int main(){
	int n,q;
	scanf("%d%d", &n, &q);
	int u,v,w;
	for(int i=1;i<n;++i){
		scanf("%d%d%d", &u, &v, &w);
		add(u,v,w);
		from[i]=u;
	}
	for(int i=1;i<n;++i){
		scanf("%d%d%d", &u, &v, &w);
		back[u]=w;
		from[i+n-1]=u;
	}
	
	from_root.init(n);
	from_root_and_back.init(n);
	
	dfs(1,0);

	for(int i=1;i<=n;++i){
		from_root.update(L[i],L[i],dis[i]);
		from_root_and_back.update(L[i],L[i],dis[i]+back[i]);
	}

	while(q--) {
		int o,x,y;
		scanf("%d%d%d", &o, &x, &y);
		if(o&1) {
			if(x<n) {
				int v=e[x].to,u=from[x],d=y-dep(v)+dep(u);
				from_root.update(L[v],R[v],d);
				from_root_and_back.update(L[v],R[v],d);
			}
			else {
				int u=from[x],d=y-back[u];back[u]=y;
				from_root_and_back.update(L[u],L[u],d);
			}
		}
		else {
			if(L[x]<=L[y]&&R[y]<=R[x])
				printf("%lld\n", dep(y)-dep(x));
			else
				printf("%lld\n",from_root_and_back.query(L[x],R[x])-dep(x)+dep(y));
		}
	}
	return 0;
}