LintCode 597: Subtree with MaximumAverage (Binary Tree经典题)

最新推荐文章于 2022-03-09 22:42:35 发布

原创最新推荐文章于 2022-03-09 22:42:35 发布 · 940 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文介绍了一种在二叉树中寻找具有最大平均值的子树的方法，通过后序遍历和递归策略，实现了一个高效的算法解决方案。文章详细解释了自定义ResultType结构体的应用，以及如何通过比较子树的平均值来确定最大平均子树。

Subtree with Maximum Average
Description
Given a binary tree, find the subtree with maximum average. Return the root of the subtree.

Example 1
Input：
{1,-5,11,1,2,4,-2}
Output：11
Explanation:
The tree is look like this:

     1
   /   \
 -5     11
 / \   /  \
1   2 4    -2

The average of subtree of 11 is 4.3333, is the maximun.
Example 2

Input：
{1,-5,11}
Output：11
Explanation:

     1
   /   \
 -5     11

The average of subtree of 1,-5,11 is 2.333,-5,11. So the subtree of 11 is the maximun.

Notice
LintCode will print the subtree which root is your return node.
It’s guaranteed that there is only one subtree with maximum average.

思路: postread 遍历 + 递归。
这种题目都必须自定义ResultType。

解法1：
代码如下：
注意：

int的除法要注意除数不为0，并且结果要转换为double!)
maxResult的初始化用ResultType(NULL, INT_MIN, 0) 或 ResultType(NULL, 0, 0) 都可以。因为最后是用count==0来判断。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
#include <limits>
struct ResultType {
    TreeNode * node;
    int sum;
    int count;
    ResultType(TreeNode * t = NULL, int s = 0, int c = 0) : node(t), sum(s), count(c) {}
};

class Solution {
public:
    /**
     * @param root: the root of binary tree
     * @return: the root of the maximum average of subtree
     */
    TreeNode * findSubtree2(TreeNode * root) {
        if (!root) return NULL;
        
        maxResult = ResultType(NULL, 0, 0);
        helper(root);
        return maxResult.node;
    }
    
    ResultType helper(TreeNode * root) {
        if (!root) return ResultType();
        ResultType left = helper(root->left);
        ResultType right = helper(root->right);
        
        int sum = left.sum + right.sum + root->val;
        int count = left.count + right.count + 1;

        ResultType newResult = ResultType(root, sum, count);

        if ((maxResult.count == 0) || 
            ((double)maxResult.sum / maxResult.count < (double)newResult.sum / newResult.count)) {
            
            maxResult = newResult;
        } 
        return newResult;
    }
    
private:
    ResultType maxResult;
};

解法2：
参考网上的。思路差不多，但将除法变成乘法，去掉很多麻烦，还提高效率。很妙。
代码如下：

class Solution {
public:
    /**
     * @param root: the root of binary tree
     * @return: the root of the maximum average of subtree
     */
    TreeNode * findSubtree2(TreeNode * root) {
        if (!root) return NULL;
        
        maxResult = ResultType(NULL, INT_MIN, 0);
        
        helper(root);
        return maxResult.node;
    }
    
    ResultType helper(TreeNode * root) {
        if (!root) return ResultType();
        ResultType left = helper(root->left);
        ResultType right = helper(root->right);
        
        int sum = left.sum + right.sum + root->val;
        int count = left.count + right.count + 1;
        ResultType newResult = ResultType(root, sum, count);
         //division -> multiply, reducing time!!!
        if (sum * maxResult.count > maxResult.sum * count) {
            maxResult = newResult;
        } 
        return newResult;
    }
    
private:
    ResultType maxResult;
};

三刷：

class Solution {
public:
    /**
     * @param root: the root of binary tree
     * @return: the root of the maximum average of subtree
     */
    TreeNode * findSubtree2(TreeNode * root) {
        int cnt = 0;
        getSum(root, cnt);
        return maxAvgNode;
    }
private:
    double maxAvg = LLONG_MIN;
    TreeNode *maxAvgNode = NULL;
    double getSum(TreeNode *root, int &cnt) {
        if (!root) {
            cnt = 0;
            return 0;
        }
        int cnt_left, cnt_right;
        double res = getSum(root->left, cnt_left) + getSum(root->right, cnt_right) + root->val;
        cnt = cnt_left + cnt_right + 1;
        if (maxAvg < res / cnt) {
            maxAvg = res / cnt;
            maxAvgNode = root;
        }
        return res;
    }
};