newCoder Wannafly挑战赛4：D 树的距离（补）

题目链接：https://www.nowcoder.com/acm/contest/35/D

解题思路：

DFS序+线段树。

DFS序就是按照深搜给节点进行编号，设立in，out数组，in[i]代表进入

节点i的时间，out[i]代表出节点i的时间。则我们按照节点的搜索顺序构

建线段树，则in[i]到out[i]是节点i的所有子节点，我们求出所有节点到根

节点的距离，则X的子节点Y两者之间的距离可以通过distY-distX求得。

之前没听说过dfs序，补了这个题目后，dfs序就是dfs时对节点编号，还

是普通的深搜。不过给它又起了个名字一样。

AC代码:

#include 
#include 
#include 
#include 
#define lchild left,mid,root<<1
#define rchild mid+1,right,root<<1|1

using namespace std;

const int maxn = 2*1e5+10;
typedef long long LL;
struct Edge{
    int to;
    int nex;
    LL weight;
}edge[maxn];
int head[maxn],cnt;

///head是相当于链表头节点，cnt用来统计边数,index是时间标记

int in[maxn],out[maxn];
long long depth[maxn],a[maxn];

/**in[i]代表dfs时进入第i个点的时间，
out[i]代表dfs时出(回溯到)第i个点的时间.
depth[i]代表根到i节点的距离**/

void addEdge(int from,int to,LL weight) {
    edge[cnt].to = to;
    edge[cnt].weight = weight;
    edge[cnt].nex = head[from];
    head[from] = cnt++;
}
void dfs(int u) {
    in[u] = ++cnt;   ///进入节点u的时间是index
    for(int i = head[u]; i != -1; i = edge[i].nex) {
        int v = edge[i].to;
        depth[v] = depth[u] + edge[i].weight;
        dfs(v);
    }
    out[u] = cnt;   ///出节点u的时间是index.也就是访问其最后一个子节点的时间。
}
/**Max[i]代表节点i所包含区间中所有节点到根节点的最大距离
Min[i]代表节点i所包含区间中所有节点到根节点的最小距离
sum[i]代表节点i所包含区间中所有接单到根节点的距离之和。**/
LL Max[maxn<<2],Min[maxn<<2],sum[maxn<<2];
void push_up(int root) {
    Max[root] = max(Max[root<<1],Max[root<<1|1]);
    Min[root] = min(Min[root<<1],Min[root<<1|1]);
    sum[root] = sum[root<<1] + sum[root<<1|1];
}
void build(int left,int right,int root) {
    ///到叶子节点
    if(left == right) {
        Max[root] = a[left];
        Min[root] = a[left];
        sum[root] = a[left];
        return;
    }
    int mid = (left+right)>>1;
    build(lchild);
    build(rchild);
    push_up(root);
}
long long query(int L,int R,int x,int k,int left,int right,int root) {
    ///当前节点是欲查询节点的子区间
    if(L<=left && right<=R) {
        /**子区间中所有节点到x的距离都大于k
        如果y是x的子节点，则x到y的距离等于根
        到y的距离减去根到x的距离。**/
        if(Min[root] >= depth[x]+k) {
            LL temp = sum[root] - (right-left+1)*depth[x];
            return temp;
        }
        if(Max[root]< depth[x]+k) {
            return 0;
        }
    }
    int mid = (left+right)>>1;
    LL ans = 0;
    if(L <= mid) ans += query(L,R,x,k,lchild);
    if(R > mid) ans += query(L,R,x,k,rchild);
    return ans;
}

int main() {
    int N;    ///N个节点
    int p,d;
    while(~scanf("%d",&N)) {
        memset(head,-1,sizeof(head));
        cnt = 0;
        for(int i = 2; i <= N; i++) {
            scanf("%d%d",&p,&d);
            addEdge(p,i,d);
        }
        cnt = 0;
        memset(depth,0,sizeof(depth));
        dfs(1);
        for(int i = 1; i <= N; i++) {
            a[in[i]] = depth[i];
        }
        ///按照节点的访问时间建立顺序,和dfs里面的搜索顺序是一样的
        build(1,N,1);
        int Q,x,k;
        scanf("%d",&Q);  ///Q次询问
        while(Q--) {
            scanf("%d%d",&x,&k);
            LL ans = query(in[x],out[x],x,k,1,N,1);
            printf("%lld\n",ans);
        }
    }
    return 0;
}