leetcode每日一题 2049. 统计最高分的节点数目

321 阅读1分钟

题目:

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

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

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

难度:

中等难度

示例 1:

example-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 (分别是节点 134 )。

示例 2:

example-2

输入:parents = [-1,2,0]
输出:2
解释:
- 节点 0 的分数为:2 = 2
- 节点 1 的分数为:2 = 2
- 节点 2 的分数为:1 * 1 = 1
最高分数为 2 ,有两个节点分数为 2 (分别为节点 01 )。

提示:

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

解题思路:

这是一道图论的题

可以利用深度优先遍历的方式进行解题

首先,利用一个HashMap来存储整个树,key为节点,value为当前节点的子节点

深度遍历每一个节点,从树的底层开始计算节点的score,并且进行动态比较,保存最大的score

score的计算思路为:

  • 如果当前节点currootcur_{root}为根节点的时候,score=curleftcurrightscore = cur_{left} *cur_{right}, 特别的curleftcur_{left}是当前节点左子树联通区的节点数目,currightcur_{right}为当前节点右子树联通区的节点数目
  • 如果当前节点curnorcur_{nor}不为根节点,则score=curleftcurright(ncurleftcurright1)score = cur_{left} *cur_{right}*(n-cur_{left} -cur_{right}-1), 特别的ncurleftcurright1n-cur_{left} -cur_{right}-1为当前节点的父节点所在联通区域的节点数
  • 总结一下,将根节点和非根节点公式进行合并,score=curleftcurright(ncurleftcurright1)score = cur_{left} *cur_{right}*(n-cur_{left} -cur_{right}-1),当为根节点时ncurleftcurright1n-cur_{left} -cur_{right}-1为0,所以规定公式的中乘积的各个部分最小值为1

Code:

class Solution {
    private int ans, n;
    private long maxScore;
    private Map<Integer, List<Integer>> graph;
    public int countHighestScoreNodes(int[] parents) {
        maxScore = ans = 0;
        n = parents.length;
        graph = new HashMap<>();
        for(int i = 1; i < n; i++) {
            List<Integer> list = graph.getOrDefault(parents[i], new ArrayList<>());
            list.add(i);
            graph.put(parents[i], list);
        }
        //从根节点开始
        dfs(0);
        return ans;
    }

    private int dfs(int node) {
        int left, right;
        if(graph.containsKey(node)) {
            //构造当前节点的子节点信息
            List<Integer> list = graph.get(node);
            //先定一边
            left = dfs(list.get(0));
            right = list.size() > 1 ? dfs(list.get(1)) : 0;
        } else {
            //叶子节点
            left = right = 0;
        }
        //计算score
        long score = (long)Math.max(1, left) * (long)Math.max(1, right) * (long)Math.max(1, n - 1 - left - right);
        //校验 最大score
        if(score > maxScore) {
            maxScore = score;
            ans = 1;
        } else if(score == maxScore)
            ans++;
        //返回其子树的节点数和 +1(加上当前节点)
        return left + right + 1;
    }
}