Codeforces 1110F(DFS序+线段树）

题面

传送门

分析

next_id = 1
id = array of length n filled with -1
visited = array of length n filled with false

function dfs(v):
    visited[v] = true
    id[v] = next_id
    next_id += 1
    for to in neighbors of v in increasing order:
        if not visited[to]:
            dfs(to)

观察题目中的这段伪代码，发现实际上就是求出每个节点的DFS序，

注意for to in neighbors of v in increasing order:，要按编号从小到大访问每个节点，所以要对邻接表排序（可以用vector实现）

对询问离线，每个结点保存由该节点出发所有询问

第一次DFS，

求出每个点到根节点的距离，以及DFS序。顺便把每个节点的子树对应的DFS序范围求出，记为l[x],r[x]

用一棵线段树存储距离，第i个节点存储DFS序为i的树结点到当前询问节点的距离（初始询问节点为1）（注意到求的是到叶子节点的最近距离，所以把非叶子节点的值设为INF

第二次DFS，

当DFS到节点x时，线段树中存储的距离恰好是询问节点x到各节点的距离，

对于每个询问，直接在线段树上查询区间最小值即可

对从x到儿子y，我们需要更新线段树的值，将x到各节点的距离改成y到各节点的距离

设x到y的距离为len,发现对于y的子树中的节点，距离会减少len,而对于其他节点，距离会增加len

由于DFS序的性质，y子树中的节点的DFS序是连续的一段，所以我们只要在线段树上进行区间更新即可

更新完之后继续DFS y节点，回溯时记得把线段树恢复

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define maxn 500005
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
vector<pair<int,int> >E[maxn];
int n,t;
int cnt=0;
int l[maxn],r[maxn];
long long dis[maxn];
void dfs1(int x,int fa){
	l[x]=++cnt;
	for(int i=0;i<E[x].size();i++){
		int y=E[x][i].first;
		if(y!=fa){
			dis[y]=dis[x]+E[x][i].second;
			dfs1(y,x);
		}
	}
	r[x]=cnt;
}

struct node{
	int l;
	int r;
	long long mark;
	long long v;
}tree[maxn<<2];
void push_up(int pos){
	tree[pos].v=min(tree[pos<<1].v,tree[pos<<1|1].v);
}
void build(int l,int r,int pos){
	tree[pos].l=l;
	tree[pos].r=r;
	if(l==r){
		tree[pos].mark=tree[pos].v=0;
		return;
	}
	int mid=(l+r)>>1;
	build(l,mid,pos<<1);
	build(mid+1,r,pos<<1|1);
	push_up(pos);
}
void push_down(int pos){
	if(tree[pos].mark){
		tree[pos<<1].mark+=tree[pos].mark;
		tree[pos<<1|1].mark+=tree[pos].mark;
		tree[pos<<1].v+=tree[pos].mark;
		tree[pos<<1|1].v+=tree[pos].mark;
		tree[pos].mark=0;
	}
}
void update(int L,int R,long long v,int pos){
	if(L<=tree[pos].l&&R>=tree[pos].r){
		tree[pos].v+=v;
		tree[pos].mark+=v;
		return;
	}
	push_down(pos);
	int mid=(tree[pos].l+tree[pos].r)>>1;
	if(L<=mid)  update(L,R,v,pos<<1);
	if(R>mid) update(L,R,v,pos<<1|1);
	push_up(pos);
}
long long query(int L,int R,int pos){
	if(L<=tree[pos].l&&R>=tree[pos].r){
		return tree[pos].v;
	}
	push_down(pos);
	int mid=(tree[pos].l+tree[pos].r)>>1;
	long long ans=INF;
	if(L<=mid)  ans=min(ans,query(L,R,pos<<1));
	if(R>mid) ans=min(ans,query(L,R,pos<<1|1));
	return ans;
}

struct range{
	int l;
	int r;
	long long ans;
	int id;
	range(){
		
	}
	range(int L,int R,int i){
		l=L;
		r=R;
		id=i;
		ans=0;
	}
	void debug(){
		printf("[%d,%d]",l,r);
	}
};
vector<range>q[maxn];

void dfs2(int x,int fa){
	for(int i=0;i<q[x].size();i++){//处理询问
		q[x][i].ans=query(q[x][i].l,q[x][i].r,1);
	}
	for(int i=0;i<E[x].size();i++){
		int y=E[x][i].first;
		int len=E[x][i].second;
		if(y!=fa){
			update(l[y],r[y],-len,1);//更新距离
			if(l[y]>1) update(1,l[y]-1,len,1);//注意边界条件
			if(r[y]<n) update(r[y]+1,n,len,1); 
			dfs2(y,x); 
			update(l[y],r[y],len,1);//记得把线段树恢复成原状
			if(l[y]>1) update(1,l[y]-1,-len,1);
			if(r[y]<n) update(r[y]+1,n,-len,1); 
		}
	}
}

long long ans[maxn];
int main(){
	int u,v,w,x,ll,rr;
	scanf("%d %d",&n,&t);
	for(int i=2;i<=n;i++){
		scanf("%d %d",&v,&w);
		E[v].push_back(make_pair(i,w));
		E[i].push_back(make_pair(v,w));
	}
	for(int i=1;i<=n;i++){
		sort(E[i].begin(),E[i].end());
	} 
	for(int i=1;i<=t;i++){
		scanf("%d %d %d",&x,&ll,&rr);
		q[x].push_back(range(ll,rr,i)); 
	}
	dfs1(1,0);
	build(1,n,1);
	for(int i=1;i<=n;i++){
		if(l[i]==r[i]) update(l[i],l[i],dis[i],1);//如果不是叶子节点，距离要设为INF
		else update(l[i],l[i],INF,1);
	}
	dfs2(1,0);
	for(int i=1;i<=n;i++){
		for(int j=0;j<q[i].size();j++){//按照输入顺序输出
			ans[q[i][j].id]=q[i][j].ans;
		}
	}
	for(int i=1;i<=t;i++){
		printf("%I64d\n",ans[i]);
	}
}