最大稳定数值

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    head = new int[n + 1];
    nxt = new int[n + 1];
    to = new int[n + 1];
    a = new int[n + 1]; // 权值
    sum = new long[n + 1]; // 子树的权值和
    count = new int[n + 1]; // 子树的支撑节点计数
    require = new long[n + 1]; // 还差多少权值变成支撑节点
    for (int i = 1; i <= n; i++) a[i] = in.nextInt();
    in.nextInt(); // 根节点没有parent，跳过
    for (int i = 2; i <= n; i++) addEdge(in.nextInt(), i);
    dfs1(1, 0); // 第1次遍历：求取sum、count、require
    FenwickTree tree = new FenwickTree(Arrays.copyOfRange(require, 2, n + 1));
    int max = dfs2(1, tree, 0); // 第2次遍历：求取删除子树的最大收益
    System.out.print((count[1] + max) + "\n");
}
private static void dfs1(int u, long ancestor) {
    for (int i = head[u]; i > 0; i = nxt[i]) {
        int v = to[i];
        dfs1(v, ancestor + a[u]);
        sum[u] += sum[v]; // 子树的权值和
        count[u] += count[v]; // 子树的支撑节点计数
    }
    if (ancestor >= a[u]) { // 祖先节点权值和大于等于当前节点
        if (sum[u] <= a[u]) { // 子孙节点权值和小于等于当前节点
            count[u]++; // 是支撑节点
        } else { // 不是支撑节点，还差多少
            require[u] = sum[u] - a[u];
        }
    }
    sum[u] += a[u]; // 子树的权值和是包含当前节点的
}
private static int dfs2(int u, FenwickTree tree, int max) {
    if (require[u] > 0) tree.add(require[u], 1);
    for (int i = head[u]; i > 0; i = nxt[i]) {
        max = dfs2(to[i], tree, max);
    }
    if (require[u] > 0) tree.add(require[u], -1);
    return Math.max(max, tree.query(sum[u]) - count[u]);
}

private static class FenwickTree { // 带离散映射的树状数组
    private int[] array;
    private long[] mapping;
    private FenwickTree(long[] mapping) {
        Arrays.sort(mapping);
        this.mapping = mapping;
        this.array = new int[mapping.length + 1];
    }
    private int translate(long val) {
        int idx = Arrays.binarySearch(mapping, val);
        return idx < 0 ? -(idx + 2) : idx;
    }
    private void add(long val, int x) {
        int i = translate(val) + 1;
        while (i < array.length) {
            array[i] += x;
            i += Integer.lowestOneBit(i);
        }
    }
    private int query(long val) {
        int i = translate(val) + 1;
        int x = 0;
        while (i > 0) {
            x += array[i];
            i -= Integer.lowestOneBit(i);
        }
        return x;
    }
}