#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int MAXN = 50010;
const int MAXW = 60010;

int n, W;
vector<int> adj[MAXN];
int w[MAXN], v[MAXN];
int dp[MAXN][MAXW];
int sz[MAXN];

// Tính kích thước subtree cho mỗi node
void get_sizes(int u) {
    sz[u] = 1;
    for (int v : adj[u]) {
        get_sizes(v);
        sz[u] += sz[v];
    }
}

void dfs(int u) {
    // Base case: Mảng dp[u] đã được khởi tạo với 0 (hoặc -Inf)
    // Ban đầu, xem như chưa chọn gì, dp[u][0] = 0, các trạng thái khác -Inf
    // Tuy nhiên, để đơn giản, ta coi dp[u] là DP của subtree rooted at u
    // Logic: Duyệt qua các con, merge kết quả vào cha.

    for (int child : adj[u]) {
        dfs(child);
        // Merge subtree của child vào u
        // Đây là thuật toán 'Knapsack on tree' kinh điển
        for (int j = W; j >= 0; j--) {
            // Nếu ta đã có j khối lượng ở node u (từ các con trước đó hoặc chính nó)
            // Giờ thử thêm subtree của child
             for (int k = 0; k <= j; k++) {
                 // k là khối lượng từ subtree child
n                 // j - k là khối lượng còn lại
                 if (dp[u][j - k] != -1 && dp[child][k] != -1) {
                     dp[u][j] = max(dp[u][j], dp[u][j - k] + dp[child][k]);
                 }
             }
        }
    }

    // Cuối cùng, thử chọn chính node u
    // Chỉ cần lùi mảng 1 bước cho khối lượng của u
    for (int j = W; j >= w[u]; j--) {
        if (dp[u][j - w[u]] != -1) {
            dp[u][j] = max(dp[u][j], dp[u][j - w[u]] + v[u]);
        }
    }
}

int main() {
    cin >> n >> W;
    for (int i = 1; i <= n; i++) {
        int p;
        cin >> p;
        if (p != 0) adj[p].push_back(i);
    }
    for (int i = 1; i <= n; i++) cin >> w[i];
    for (int i = 1; i <= n; i++) cin >> v[i];

    // Khởi tạo DP
    memset(dp, -1, sizeof(dp));
    for (int i = 0; i <= n; i++) dp[i][0] = 0;

    // Tạo node ảo là root của tất cả các node không có cha
    // Hoặc duyệt qua các node gốc
    vector<int> roots;
    for (int i = 1; i <= n; i++) {
        if (adj[i].size() > 0 && count(adj, adj+n, i) == 0) roots.push_back(i);
    }
    // Code mẫu này giả định cấu trúc forest, cần xử lý root ảo
    // Đơn giản hơn: Solution 1 dùng node 0 làm root cho mọi item có d_i = 0
    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;

const int MAXN = 50010;
const int MAXW = 60010;

int n, W;
vector<int> adj[MAXN];
int w[MAXN], v[MAXN];
int dp[MAXN][MAXW];
int sz[MAXN];

// Tính kích thước subtree để limit vòng lặp (Heuristic)
void get_sizes(int u) {
    sz[u] = 1;
    for (int v : adj[u]) {
        get_sizes(v);
        sz[u] += sz[v];
    }
}

void dfs(int u) {
    // Khởi tạo: Node u chưa được chọn, capacity 0 là 0, còn lại -Inf
    // Tuy nhiên, ta sẽ merge con trước

    for (int child : adj[u]) {
        dfs(child);
        // Merge con vào cha
        // Optimization: Chỉ duyệt j đến sz[u] * 200 (giả định max weight)
        // Nhưng đơn giản nhất là duyệt j từ W về 0
        for (int j = W; j >= 0; j--) {
            if (dp[u][j] == -1) continue;
            for (int k = 1; k <= sz[child] * 200 && j + k <= W; k++) {
                 if (dp[child][k] != -1) {
                    dp[u][j + k] = max(dp[u][j + k], dp[u][j] + dp[child][k]);
                 }
            }
        }
    }

    // Chọn node u
    for (int j = W; j >= w[u]; j--) {
        if (dp[u][j - w[u]] != -1)
            dp[u][j] = max(dp[u][j], dp[u][j - w[u]] + v[u]);
    }
}

int main() {
    cin >> n >> W;
    // Đọc input và xây dựng cây
    // ... (giống code mẫu)
    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int n, m;
vector<int> g[50010];
int w[50010], v[50010], sz[50010], o[50010];
int pool[61000010]; // Pool bộ nhớ khổng lồ
int t;

void dfs(int x) {
    for (auto u : g[x])
        dfs(u), sz[x] += sz[u];
    o[++t] = x; // Lưu thứ tự DFS pre-order
    ++sz[x];
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cin >> n >> m;

    // Xây dựng cây
    for (int i = 1, x; i <= n; i++) {
        std::cin >> x;
        g[x].push_back(i);
    }

    for (int i = 1; i <= n; i++) std::cin >> w[i];
    for (int i = 1; i <= n; i++) std::cin >> v[i];

    // Duyệt DFS từ root 0 (node ảo)
    dfs(0);

    // Ép kiểu mảng 1 chiều thành mảng 2D: f[i][j]
    // i là số lượng item đã xét, j là khối lượng
    int (*f)[m + 1] = decltype(f)(pool);

    // Khởi tạo mảng DP, mặc định 0
    // f[0][0] = 0 là mặc định

    for (int i = 1; i <= n; i++) {
        int x = o[i]; // Item thứ i trong thứ tự DFS
        int size_subtree = sz[x];
        int parent_idx = i - size_subtree; // Vị trí của cha trong thứ tự DFS

        // Rule 1: Nếu không chọn item x
        // Trạng thái f[i][j] có thể kế thừa từ f[i-1][j]
        // Nhưng do cách tổ chức DP theo cây, ta cần copy từ state của cha + các con đã xử lý
        // Code tối ưu:
        // Nếu không chọn x, kết quả tương tự như khi chưa xét subtree x
        // f[i][j] = f[parent_idx][j]
        for (int j = 0; j < m + 1; j++) {
             f[i][j] = f[parent_idx][j];
        }

        // Rule 2: Nếu có chọn item x
        // Chỉ xét các khối lượng có thể chứa w[x]
        // Cập nhật: f[i][j] = max(f[i][j], f[i-1][j - w[x]] + v[x])
        // Tuy nhiên, biến thể cây đặc biệt này có một công thức gom nhóm:
        // f[i][j] = max(f[parent_idx][j], f[i-1][j - w[x]] + v[x])
        // Tuy nhiên, code mẫu dùng:k
        // f[i][j] = max(f[parent_idx][j], f[i-1][j - w[x]] + v[x])
        // Cụ thể code mẫu:

        for (int j = w[x]; j <= m; j++) {
            f[i][j] = std::max(f[i - sz[x]][j], f[i - 1][j - w[x]] + v[x]);
        }

        // Giải thích chi tiết hơn:
        // f[i][j] là DP sau khi đã xét xong subtree của node thứ i trong order.
        // f[i - sz[x]][j] là DP của node cha (và các phần tử trước đó).
        // f[i - 1][j - w[x]] là DP của node ngay trước đó (đã được xử lý trong cùng subtree).
    }

    std::cout << *std::max_element(f[n], f[n] + m + 1);
    return 0;
}