| #include <algorithm> |
| #include <cassert> |
| #include <cstring> |
| #include <iostream> |
| #include <vector> |
| #include <utility> |
| using namespace std; |
|
|
| const int LIM = 1000001; |
|
|
| int N; |
| long long K; |
| int C[LIM]; |
| vector<int> ch[LIM]; |
|
|
| |
| pair<long long, int> DP[LIM][3]; |
| pair<long long, int> DP2[3][2], nxt[3][2]; |
|
|
| void rec(int i, int p, long long P) { |
| for (auto c : ch[i]) { |
| rec(c, i, P); |
| } |
| memset(DP2, 0, sizeof DP2); |
| DP2[1][1] = make_pair(C[i], 0); |
| memcpy(nxt, DP2, sizeof nxt); |
| for (auto c : ch[i]) { |
| for (int j = 2; j >= 0; j--) { |
| for (int b = 1; b >= 0; b--) { |
| auto d = DP2[j][b]; |
| for (int j2 = 0; j2 <= 2; j2++) { |
| auto d2 = DP[c][j2]; |
| for (int u = 0; u <= j2; u++) { |
| int r = j2 - u; |
| if (r > j) { |
| continue; |
| } |
| int j3 = j + u - r; |
| if (j3 < 0 || j3 > 2) { |
| continue; |
| } |
| int b2 = b | (j2 ? 1 : 0); |
| long long dv = d.first + d2.first + (!b && b2 ? C[i] : 0) - r * P; |
| int dk = d.second + d2.second - r; |
| nxt[j3][b2] = max(nxt[j3][b2], make_pair(dv, dk)); |
| } |
| } |
| } |
| } |
| memcpy(DP2, nxt, sizeof nxt); |
| } |
| for (int j = 0; j <= 2; j++) { |
| for (int j2 = 0; j2 <= j; j2++) { |
| int e = j - j2; |
| for (int b : {0, 1}) { |
| auto d = DP2[j][b]; |
| DP[i][j2] = max(DP[i][j2], make_pair(d.first - e * P, d.second - e)); |
| } |
| } |
| } |
| } |
|
|
| pair<long long, int> solve(long long P) { |
| memset(DP, 0, sizeof DP); |
| rec(0, -1, P); |
| auto d = DP[0][0]; |
| return make_pair(d.first + -d.second * P, -d.second - 1); |
| } |
|
|
| int solve() { |
| for (int i = 0; i < LIM; i++) { |
| ch[i].clear(); |
| } |
| |
| cin >> N >> K; |
| for (int i = 0; i < N; i++) { |
| cin >> C[i]; |
| } |
| for (int i = 1, j; i <= N - 1; i++) { |
| cin >> j; |
| ch[j - 1].push_back(i); |
| } |
| |
| long long r1 = -1, r2 = (long long)N * 1e9 + 1; |
| while (r2 > r1) { |
| long long m = (r1 + r2 + 1) >> 1; |
| auto ans = solve(m); |
| if (ans.first < K) { |
| r2 = m - 1; |
| } else { |
| r1 = m; |
| } |
| } |
| |
| int ans = -1; |
| if (r1 >= 0) { |
| pair<long long, int> ans1 = solve(r1), ans2 = solve(r1 + 1); |
| assert(ans2.first < K && K <= ans1.first && ans2.second < ans1.second); |
| long long diffV = ans1.first - ans2.first; |
| int diffK = ans1.second - ans2.second; |
| long long need = K - ans2.first; |
| ans = ans2.second + (need * diffK + diffV - 1) / diffV; |
| assert(ans2.second < ans && ans <= ans1.second); |
| } |
| return ans; |
| } |
|
|
| int main() { |
| int T; |
| cin >> T; |
| for (int t = 1; t <= T; t++) { |
| cout << "Case #" << t << ": " << solve() << endl; |
| } |
| return 0; |
| } |
|
|
