BZOJ 3653 谈笑风生 dfs序 可持久化线段树

3653: 谈笑风生

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 628  Solved: 245
[Submit][Status][Discuss]

Description

设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。

Input

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

Output

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

Sample Input

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

Sample Output

3
1
3

HINT

1<=P<=N
1<=K<=N
N<=300000
Q<=300000

Source

Solution

对于一组询问(p,k)，其答案为min(k, dep[p]-1)*(siz[p]-1)+∑(siz[v]-1)(v∈p的子树)

前面的东西可以直接求，后面的东西考虑在dfs序上建一棵线段树，然后根据深度把点扔进去，可持久化。

Code

#include <bits/stdc++.h>

using namespace std;

#define REP(i, a, b) for (int i = (a), i##_end_ = (b); i <= i##_end_; ++i)
#define REP_EDGE(i, a) for (int i = (a); i != -1; i = e[i].nxt)
#define mset(a, b) memset(a, b, sizeof(a))
const int maxn = 3e5+10;
int n, q;
struct Edge
{
    int v, nxt;
    Edge (int v = 0, int nxt = 0): v(v), nxt(nxt) {}
}e[maxn*2];
int head[maxn], label;
int siz[maxn], dfn[maxn], to[maxn], dep[maxn], dfn_clock;
struct Node
{
    int u, u_dep, u_siz;
    Node (int u = 0, int u_dep = 0, int u_siz = 0): u(u), u_dep(u_dep), u_siz(u_siz) {}
    bool operator < (const Node &AI) const { return u_dep < AI.u_dep; }
}d[maxn];

void ins(int u, int v)
{
    e[++label] = Edge(v, head[u]), head[u] = label;
    e[++label] = Edge(u, head[v]), head[v] = label;
}

void dfs(int u, int fa)
{
    dep[u] = dep[fa]+1, siz[u] = 1, dfn[u] = ++dfn_clock, to[dfn_clock] = u;
    REP_EDGE(i, head[u])
    {
        int v = e[i].v;
        if (v == fa) continue ;
        dfs(v, u), siz[u] += siz[v];
    }
}

struct Tree
{
    int ls[maxn*50], rs[maxn*50], sum[maxn*50], t_cnt;
    Tree() { t_cnt = 0; }
    void pushup(int rt)
    {
        sum[rt] = sum[ls[rt]]+sum[rs[rt]];
    }
    void insert(int rt, int las_rt, int l, int r, int p, int d)
    {
        if (l == r)
        {
            sum[rt] = d;
            return ;
        }
        int mid = (l+r)>>1;
        if (p <= mid)
        {
            ls[rt] = ++t_cnt, rs[rt] = rs[las_rt];
            insert(ls[rt], ls[las_rt], l, mid, p, d);
        }
        else
        {
            ls[rt] = ls[las_rt], rs[rt] = ++t_cnt;
            insert(rs[rt], rs[las_rt], mid+1, r, p, d);
        }
        pushup(rt);
    }
    int query(int rt_1, int rt_2, int l, int r, int L, int R)
    {
        if (L <= l && r <= R)
            return sum[rt_2]-sum[rt_1];
        int mid = (l+r)>>1, ret = 0;
        if (L <= mid) ret = query(ls[rt_1], ls[rt_2], l, mid, L, R);
        if (R > mid) ret += query(rs[rt_1], rs[rt_2], mid+1, r, L, R);
        return ret;
    }
}T;
int rt[maxn], st_p[maxn];

int main()
{
    scanf("%d %d", &n, &q);
    REP(i, 1, n) head[i] = -1;
    label = -1;
    REP(i, 1, n-1)
    {
        int u, v;
        scanf("%d %d", &u, &v);
        ins(u, v);
    }
    dfn_clock = 0, dfs(1, 0);
    REP(i, 1, n) d[i] = Node(i, dep[i], siz[i]);
    sort(d+1, d+n+1);
    rt[0] = 0;
    REP(i, 1, n)
    {
        rt[i] = ++T.t_cnt;
        T.insert(rt[i], rt[i-1], 1, n, dfn[d[i].u], d[i].u_siz-1);
        if (d[i].u_dep != d[i-1].u_dep) st_p[d[i].u_dep] = i;
    }
    int max_dep = d[n].u_dep;
    st_p[max_dep+1] = n+1;
    while (q --)
    {
        int p, k;
        scanf("%d %d", &p, &k);
        int ret = min(dep[p]-1, k)*(siz[p]-1);
//        printf("dep_st : %d
", dep[p]+1);
//        printf("dep_en : %d 
", min(max_dep, dep[p]+k)+1);
        ret += T.query(rt[st_p[dep[p]+1]-1], rt[st_p[min(max_dep, dep[p]+k)+1]-1], 1, n, dfn[p], dfn[p]+siz[p]-1);
        printf("%d
", ret);
    }
    return 0;
}