2021/finals/vacation.cpp

#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];

// <sum, negative # of paths>
pair<long long, int> DP[LIM][3];            // [node][# of incoming paths]
pair<long long, int> DP2[3][2], nxt[3][2];  // [# of ongoing paths][counted node?]

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();
  }
  // Input.
  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);
  }
  // Binary search for appropriate path penalty.
  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;
    }
  }
  // Compute final answer.
  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;
}