codeforces293E （树上点分治+树状数组）

和poj1747相比起来，只不过是限制条件多了一维。 

而多了这一维，所以需要用树状数组来维护，从而快速得到答案。

因为没注意传进树状数组函数的参数可能是<=0的，导致超时了好久。

#pragma warning(disable:4996)
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <algorithm>
#include <iostream>
#include <string>
#include <functional>
const int INF = 1 << 30;
typedef __int64 LL;
/**/
const int N = 100000 + 10;

int n, L, W;
struct Edge
{
    int to, dis, next;
}g[N*2];
struct Node
{
    int l, w;
    bool operator<(const Node&rhs)const
    {
        return w < rhs.w;
    }
}a[N];
int head[N], e;
int tree[N];
int size[N], p, total, mins, root;
bool vis[N];
LL ans;
int maxL;
int lowbit(int x)
{
    return x &(-x);
}

//树状数组如果pos<=0，那么会死循环， 卡这里超时了好久。
void modify(int pos, int val)
{
    pos += 1;
    while (pos <= maxL+1)
    {
        tree[pos] += val;
        pos += lowbit(pos);
    }
}
int getSum(int pos)
{
    pos += 1;
    if (pos <= 0) return 0;
    int ret = 0;
    while (pos > 0)
    {
        ret += tree[pos];
        pos -= lowbit(pos);
    }
    return ret;
}

void addEdge(int u, int v, int dis)
{
    g[e].to = v;
    g[e].dis = dis;
    g[e].next = head[u];
    head[u] = e++;
}

void getRoot(int u, int fa)
{
    int maxs = 0;
    size[u] = 1;
    for (int i = head[u];i != -1;i = g[i].next)
    {
        int v = g[i].to;
        if (v == fa || vis[v]) continue;
        getRoot(v, u);
        size[u] += size[v];
        maxs = std::max(maxs, size[v]);
    }
    maxs = std::max(maxs, total - size[u]);
    if (mins > maxs)
    {
        mins = maxs;
        root = u;
    }
}
void getA(int u, int fa, int l, int w)
{
    a[p].l = l;
    a[p++].w = w;
    maxL = std::max(maxL, l);
    for (int i = head[u];i != -1;i = g[i].next)
    {
        int v = g[i].to;
        if (v == fa || vis[v]) continue;
        getA(v, u, l + 1, w + g[i].dis);
    }
}

LL counts(int u, int ll, int ww)
{
    p = 0;
    maxL = 0;
    getA(u, -1, ll, ww);
    std::sort(a, a + p);
    int l = 0, r = p - 1;
    LL ret = 0;
    while (l < r &&a[l].w + a[r].w>W)
        r--;
    if (l < r)
    {
        for (int i = l+1;i <= r;++i)
            modify(a[i].l,1);
        while (l < r)
        {
            if (a[l].w + a[r].w <= W)
            {
                ret += getSum(std::min(L - a[l].l,maxL));
                l++;
                modify(a[l].l,-1);
            }
            else
            {
                modify(a[r].l,-1);
                r--;
            }
        }
    }
    return ret;
}

void go(int u)
{
    vis[u] = true;
    ans += counts(u, 0, 0);
    for (int i = head[u];i != -1;i = g[i].next)
    {
        int v = g[i].to;
        if (vis[v]) continue;
        ans -= counts(v, 1, g[i].dis);
        mins = INF;
        total = size[v];
        getRoot(v, -1);
        go(root);
    }
}
int main()
{
    scanf("%d%d%d", &n, &L, &W);
    
    int u, v, dis;
    memset(head, -1, sizeof(head));
    for (int i = 1;i < n;++i)
    {
        u = i + 1;
        scanf("%d%d", &v, &dis);
        addEdge(u, v, dis);
        addEdge(v, u, dis);
    }
    mins = INF;
    total = n;
    getRoot(1, -1);
    go(root);
    printf("%I64d
", ans);
    
    return 0;
}