【NOI模拟】谈笑风生(主席树)

题目描述

设 T 为一棵有根树，我们做如下的定义：

• • 设 a 和 b 为 T 中的两个不同节点。如果 a 是 b 的祖先，那么称 “ a 比 b 不知道高明到哪里去了 ” 。
  • 设 a 和 b 为 T 中的两个不同节点。如果 a 与 b 在树上的距离不超过某个给定常数 x ，那么称 “ a 与 b 谈笑风生 ” 。

给定一棵 n 个节点的有根树 T ，节点的编号为 1～n ，根节点为 1 号节点。你需要回答 q 个询问，询问给定两个整数 p 和 k ，问有多少个有序三元组 (a,b,c) 满足：
1. a、b 和 c 为 T 中三个不同的点，且 a 为 p 号节点；
2. a 和 b 都比 c 不知道高明到哪里去了； 
3. a 和 b 谈笑风生。这里谈笑风生中的常数为给定的 k 。

输入格式

输入的第一行含有两个正整数n和q，分别代表有根树的点数与询问的个数。
接下来 n-1 行，每行描述一条树上的边。每行含有两个整数 u 和 v ，代表在节点 u 和 v 之间有一条边。
接下来 q 行，每行描述一个操作。第 i 行含有两个整数，分别表示第 i 个询问的 p 和 k 。

输出格式

输出 q 行，每行对应一个询问，代表询问的答案。

样例输入

5 3 
1 2 
1 3 
2 4 
4 5 
2 2 
4 1 
2 3

样例输出

3 
1 
3

题目分析

下图是样例数据：

　　对于询问2 2， b可以取1或4

• 　　b取1时， c可以取4， 5：

ans += 1 * 2

• b取4时， c只能取5：

ans += 1 * 1

• 综上ans = 3

• 可以发现对于询问a，k： 若根节点的dep为0, sze[i]表示以i为根的树的大小

1. b可以在根节点到a的路径上，此时c可以是a子树中的任意节点 ans += min(dep[a], k) * (sze[a] - 1)
2. b可以是a的子树节点中且与a的距离小于等于k, 对于每一个b, c可以是b子树结点中的任意一点

$$ans += \sum_{b} sze[b] - 1$$

• 由此， 先dfs出树的dep，sze

　　然后需要加上a子树结点中与a距离小于等于k的节点的子树大小之和.

• 我们可以使用可持久化线段树来完成这一任务。我们对深度建线段树，按照 DFS 序的
  顺序依次插入每个点。这样就可以通过全部的测试点。

• 具体可以看代码；

CODE:

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
using namespace std;
 
typedef long long ll;
const int N = ;
int n, q;
#define bug(x) cout<<#x<<":"<<x<<endl
 
inline int Re(){
    int i = , f = ; char ch = getchar();
    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
    if(ch == '-') f = -, ch = getchar();
    for(; ch >= '' && ch <= ''; ch = getchar())
        i = (i << ) + (i << ) + (ch - '');
    return i * f;
}
 
struct node{
    int lc, rc;
    ll sum;
}tr[N << ];
int pool, root[N], sze[N], dep[N], in[N], out[N], id;
 
int ecnt, adj[N], go[N << ], nxt[N << ], maxx, pos[N];
 
inline void Insert(const int &x, int &y, const int &l, const int &r, const int &pos, const int &v){
    tr[y = ++pool] = tr[x];
    tr[y].sum += v;
    if(l == r) return;
    int mid = l + r >> ;
    if(pos <= mid) Insert(tr[x].lc, tr[y].lc, l, mid, pos, v);
    else Insert(tr[x].rc, tr[y].rc, mid + , r, pos, v);
}
 
inline ll query(int pos, const int &nl, const int &nr, const int &l, const int &r){
    if(l <= nl && nr <= r) return tr[pos].sum;
    int mid = nl + nr >> ;
    ll ret = ;
    if(l <= mid) ret += query(tr[pos].lc, nl, mid, l, r);
    if(r > mid ) ret += query(tr[pos].rc, mid + , nr, l, r);
    return ret;
}
 
inline void addEdge(const int &u, const int &v){
    nxt[++ecnt] = adj[u], adj[u] = ecnt, go[ecnt] = v;
    nxt[++ecnt] = adj[v], adj[v] = ecnt, go[ecnt] = u;
}
 
inline void dfs(const int &u, const int &f){
    dep[u] = dep[f] + ;
    maxx = max(maxx, dep[u]);
    sze[u] = ;
    in[u] = ++id;
    pos[id] = u;
    int v;
    for(int e = adj[u]; e; e = nxt[e]){
        if((v = go[e]) == f) continue;
        dfs(v, u);
        sze[u] += sze[v];
    }
    out[u] = id;
}
 
inline void tree_init(){
    for(int i = ; i <= n; i++){
        Insert(root[i - ], root[i], , maxx, dep[pos[i]], sze[pos[i]] - );
    }
}
 
int main(){
    freopen("h.in", "r", stdin);
    n = Re(), q = Re();
    for(int i = ; i < n; i++){
        int u = Re(), v = Re();
        addEdge(u, v);
    }
    maxx = -; dep[] = -;
    dfs(, );
    tree_init();
//    for(int i = 1; i <= n; i++) bug(i),bug(dep[pos[i]]);
    for(int i = ; i <= q; i++){
        int p = Re();
        int k = Re();
        ll ans = ;
        ans += (ll)(sze[p] - ) * (ll)min(dep[p], k);
//        bug(ans);
        ans += query(root[out[p]], , maxx, min(dep[p] + , maxx), min(dep[p] + k, maxx));
//        bug(ans); bug(query(root[out[p]], 1, maxx, min(dep[p] + 1, maxx), min(dep[p] + k, maxx)));
        ans -= query(root[in[p] - ], , maxx, min(dep[p] + , maxx), min(dep[p] + k, maxx));
        cout<<ans<<endl;
    }
    return ;
}