题目链接
题意：给你一个N个点的树，再给一个L和W，分别代表你可以取边的个数小于等于L条的一条链，并且还要满足链上的权重，也就是链上的边的权值和小于等于W的链有多少种取法？
思路：记得男人八题里面的一道点分治，这道题以那道题为基础增加了难度，现在，我们如果不是考虑二维的只去求一维的贡献的话，那么实际上可以用容斥来得到答案，我们可以先求一棵树上的所有两点之间的贡献，以某个点为端点，另外一个点可以最远选取到哪里，那么，这个区间的选取长度，就是需要增加的可能性。
现在。变成了二维的了，那么就是说，这个选取的长度之中还可能存在不可行的解了，所以，这里我用数据结构来维护掉一维，我们可以选择维护掉1e5的那一维，因为1e9的没办法使用数据结构来实现，所以我们对1e9的W范围，还是当作区间的长度来操作，所以，我们对W进行排序，对L进行树状数组上的查询即可。
当然，这里有个不能添加的东西，就是我们尺取的时候，不能再额外判断L之间的关系，因为或许我们在这一位上是不满足的，但是不代表下一个就不可以了，举个例子：
10 3 100000
1 4372
1 8809
2 2085
2 2202
3 9004
3 5568
4 8984
4 1650
5 2369还有
10 3 100000
1 1
1 1
2 1
2 1
3 1
3 1
4 1
4 1
5 1这两个答案应该是相等的。
ans = 30最后，贴上代码：
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
int N, L, W, head[maxN], cnt;
ll ans;
struct Eddge
{
int nex, to, val;
Eddge(int a=-1, int b=0, int c=0):nex(a), to(b), val(c) {}
}edge[maxN << 1];
inline void addEddge(int u, int v, int w)
{
edge[cnt] = Eddge(head[u], v, w);
head[u] = cnt++;
}
inline void _add(int u, int v, int w) { addEddge(u, v, w); addEddge(v, u, w); }
int siz[maxN], son[maxN], maxx, rt, all;
bool vis[maxN];
void findroot(int u, int fa)
{
siz[u] = 1; son[u] = 0;
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(vis[v] || v == fa) continue;
findroot(v, u);
siz[u] += siz[v];
son[u] = max(son[u], siz[v]);
}
son[u] = max(son[u], all - siz[u]);
if(maxx > son[u]) { maxx = son[u]; rt = u; }
}
struct node
{
int deep, dis;
node(int a=0, int b=0):deep(a), dis(b) {}
friend bool operator < (node e1, node e2) { return e1.dis == e2.dis ? e1.deep < e2.deep : e1.dis < e2.dis; }
}Stap[maxN];
int Stop;
int t[maxN], zero;
inline void update(int i, int x) { if(!i) { zero += x; return; } while(i <= N) { t[i] += x; i += lowbit(i); } }
inline int query(int x) { int sum = 0; while(x) { sum += t[x]; x -= lowbit(x); } return sum; }
void get_Dis(int u, int fa, int deep, int dis)
{
Stap[++Stop] = node(deep, dis);
update(deep, 1);
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(v == fa || vis[v]) continue;
get_Dis(v, u, deep + 1, dis + edge[i].val);
}
}
inline ll solve()
{
ll sum = 0;
sort(Stap + 1, Stap + Stop + 1);
int l = 1, r = Stop;
while(l < r)
{
while(l <= r && Stap[l].dis + Stap[r].dis > W) { update(Stap[r].deep, -1); r--; }
if(l >= r) break;
update(Stap[l].deep, -1);
if(L - Stap[l].deep >= 0) sum += query(L - Stap[l].deep) + zero;
l++;
}
while(l <= r)
{
update(Stap[r].deep, -1);
r--;
}
return sum;
}
void divide(int u)
{
vis[u] = true;
int totsiz = all;
Stop = 0;
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(vis[v]) continue;
get_Dis(v, u, 1, edge[i].val);
}
ans += solve();
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(vis[v]) continue;
Stop = 0;
get_Dis(v, u, 1, edge[i].val);
for(int j=1; j<=Stop; j++) if(Stap[j].deep <= L && Stap[j].dis <= W) ans++;
ans -= solve();
}
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(vis[v]) continue;
all = siz[v] > siz[u] ? totsiz - siz[u] : siz[v];
maxx = INF; rt = 0;
findroot(v, u);
divide(rt);
}
}
inline void init()
{
cnt = 0; ans = 0; all = N;
for(int i=1; i<=N; i++) head[i] = -1;
}
int main()
{
scanf("%d%d%d", &N, &L, &W);
init();
for(int i=2, p, val; i<=N; i++)
{
scanf("%d%d", &p, &val);
_add(p, i, val);
}
maxx = INF; rt = 0;
findroot(1, 0);
divide(rt);
printf("%lld\n", ans);
return 0;
}