2049. 统计最高分的节点数目

难度：中等

给你一棵根节点为 0 的 二叉树 ，它总共有 n 个节点，节点编号为 0 到 n - 1 。同时给你一个下标从 0 开始的整数数组 parents 表示这棵树，其中 parents[i] 是节点 i 的父节点。由于节点 0 是根，所以 parents[0] == -1 。

一个子树的 大小 为这个子树内节点的数目。每个节点都有一个与之关联的 分数 。求出某个节点分数的方法是，将这个节点和与它相连的边全部 删除 ，剩余部分是若干个 非空 子树，这个节点的 分数 为所有这些子树 大小的乘积 。

请你返回有 最高得分 节点的 数目 。

示例 1:

输入：parents = [-1,2,0,2,0]
输出：3
解释：
- 节点 0 的分数为：3 * 1 = 3
- 节点 1 的分数为：4 = 4
- 节点 2 的分数为：1 * 1 * 2 = 2
- 节点 3 的分数为：4 = 4
- 节点 4 的分数为：4 = 4
最高得分为 4 ，有三个节点得分为 4 （分别是节点 1，3 和 4 ）。

示例 2：

输入：parents = [-1,2,0]
输出：2
解释：
- 节点 0 的分数为：2 = 2
- 节点 1 的分数为：2 = 2
- 节点 2 的分数为：1 * 1 = 1
最高分数为 2 ，有两个节点分数为 2 （分别为节点 0 和 1 ）。

提示：

• n == parents.length
• 2 <= n <=
• parents[0] == -1
• 对于 i != 0 ，有 0 <= parents[i] <= n - 1
• parents 表示一棵二叉树。

代码（超时版）：

public class Solution {
    List<Integer>[] children;
    long max = 0;
    int maxCount = 1;
    int n;

    /**
     * 相连的线最多3条（连接父节点，左子节点和右子节点）
     * 即去掉某节点后，分为三个部分，左子树，右子树和父树的残余部分
     * 父树大小=总节点数-左子树节点数-右子树节点数-被删除的节点
     * 删除该节点的分数=父树大小*左子树大小*右子树大小
     *
     * @param parents
     * @return
     */
    public int countHighestScoreNodes(int[] parents) {
        n = parents.length;
        children = new List[n];
        //初始化
        for (int i = 0; i < n; i++) {
            children[i] = new ArrayList<>();
        }
        //遍历，存储子节点数据
        for (int i = 0; i < n; i++) {
            //若非根节点
            if (parents[i] != -1) {
                //将当前节点加至父节点的子节点列表中
                children[parents[i]].add(i);
            }
        }
        //挨个计算分数
        for (int i = 0; i < n; i++) {
            int left = 0;
            int right = 0;
            int parent = 0;
            if (children[i].size() > 0) {
                left = dfs(children[i].get(0)) + 1;
                if (children[i].size() > 1) {
                    right = dfs(children[i].get(1)) + 1;
                }
            }
            parent = n - left - right - 1;
            long mul = 1;
            if (left != 0) {
                mul *= left;
            }
            if (right != 0) {
                mul *= right;
            }
            if (parent != 0) {
                mul *= parent;
            }
            if (max == mul) {
                maxCount++;
            }
            if (max < mul) {
                max = mul;
                maxCount = 1;
            }
        }
        dfs(0);
        return maxCount;
    }

    /**
     * 查找孩子
     *
     * @param index
     */
    private int dfs(int index) {
        int count = 0;
        if (!children[index].isEmpty()) {
            for (Integer chil : children[index]) {
                count += dfs(chil) + 1;
            }
        }
        return count;
    }
}

代码（正确版）：

class Solution {
     List<Integer>[] children;
    long max = 0;
    int maxCount = 1;
    int n;

    /**
     * 相连的线最多3条（连接父节点，左子节点和右子节点）
     * 即去掉某节点后，分为三个部分，左子树，右子树和父树的残余部分
     * 父树大小=总节点数-左子树节点数-右子树节点数-被删除的节点
     * 删除该节点的分数=父树大小*左子树大小*右子树大小
     *
     * @param parents
     * @return
     */
    public int countHighestScoreNodes(int[] parents) {
        n = parents.length;
        children = new List[n];
        //初始化
        for (int i = 0; i < n; i++) {
            children[i] = new ArrayList<>();
        }
        //遍历，存储子节点数据
        for (int i = 0; i < n; i++) {
            //若非根节点
            if (parents[i] != -1) {
                //将当前节点加至父节点的子节点列表中
                children[parents[i]].add(i);
            }
        }
        dfs(0);
        return maxCount;
    }

    private int dfs(int node) {
        long score = 1;
        int sum = 1;
        for (int num : children[node]) {
            int t = dfs(num);
            score *= t;
            sum += t;
        }
        if (node != 0) {
            score *= n - sum;
        }
        if (max == score) {
            maxCount++;
        } else if (max < score) {
            max = score;
            maxCount = 1;
        }
        return sum;
    }
}