```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

const INF int64 = 1000000000000000000 + 10

var N int
var B int64
var C, D, Size [5010]int64
var Child [5010][]int
var dpNot, dpUse [5010][]int64

func dfs(u int) {
	var costs []int64
	costs = append(costs, C[u])
	Size[u] = 1
	for _, v := range Child[u] {
		dfs(v)
		Size[u] += Size[v]
		ssv := int(Size[v])
		for k := 1; k <= ssv; k++ {
			costs = append(costs, dpNot[v][k]-dpNot[v][k-1])
		}
	}
	sort.Slice(costs, func(i, j int) bool { return costs[i] < costs[j] })
	sz := int(Size[u])
	dpNot[u] = make([]int64, sz+1)
	dpNot[u][0] = 0
	for i := 1; i <= sz; i++ {
		dpNot[u][i] = dpNot[u][i-1] + costs[i-1]
	}
	dpUse[u] = make([]int64, sz+1)
	for i := 0; i <= sz; i++ {
		dpUse[u][i] = INF
	}
	if len(Child[u]) == 0 {
		dpUse[u][1] = C[u] - D[u]
		return
	}
	maxv := -1
	maxsz := int64(0)
	for _, v := range Child[u] {
		if Size[v] > maxsz {
			maxsz = Size[v]
			maxv = v
		}
	}
	cur := make([]int64, sz+1)
	copy(cur, dpUse[maxv])
	for _, v := range Child[u] {
		if v == maxv {
			continue
		}
		nxt := make([]int64, sz+1)
		for i := 0; i <= sz; i++ {
			nxt[i] = INF
		}
		ssv := int(Size[v])
		maxI := sz - ssv
		for i := 0; i <= maxI; i++ {
			if cur[i] == INF {
				continue
			}
			for j := 0; j <= ssv; j++ {
				ni := i + j
				nxt[ni] = min(nxt[ni], cur[i] + dpNot[v][j])
			}
			for j := 1; j <= ssv; j++ {
				if dpUse[v][j] == INF {
					continue
				}
				ni := i + j
				if ni > sz {
					break
				}
				nxt[ni] = min(nxt[ni], cur[i] + dpUse[v][j])
			}
		}
		cur = nxt
	}
	for i := 0; i < sz; i++ {
		if cur[i] == INF {
			continue
		}
		dpUse[u][i+1] = cur[i] + C[u] - D[u]
	}
}

func main() {
	fmt.Fscan(reader, &N, &B)
	for i := 1; i <= N; i++ {
		fmt.Fscan(reader, &C[i], &D[i])
		if i >= 2 {
			var x int
			fmt.Fscan(reader, &x)
			Child[x] = append(Child[x], i)
		}
	}
	dfs(1)
	l, r := 0, N
	for l < r {
		mid := (l + r + 1) / 2
		var minc int64 = INF
		if mid < len(dpNot[1]) {
			minc = dpNot[1][mid]
		}
		if mid < len(dpUse[1]) {
			minc = min(minc, dpUse[1][mid])
		}
		if minc <= B {
			l = mid
		} else {
			r = mid - 1
		}
	}
	fmt.Println(l)
}
```