2265. Count Nodes Equal to Average of Subtree

class Solution {
    int count = 0;
    public int averageOfSubtree(TreeNode root) {
        dfs(root);
        return count;
    }
    private int[] dfs(TreeNode node) {
        if (node == null) return new int[]{0, 0};
        int[] left  = dfs(node.left);
        int[] right = dfs(node.right);
        int sum      = left[0] + right[0] + node.val;
        int nodeCount = left[1] + right[1] + 1;
        int avg = sum / nodeCount;
        if (avg == node.val) count++;
        return new int[]{sum, nodeCount};
    }
}

class Solution:
    def averageOfSubtree(self, root):
        self.count = 0

        def dfs(node):
            if node is None:
                return 0, 0

            leftSum, leftCount = dfs(node.left)
            rightSum, rightCount = dfs(node.right)

            totalSum = leftSum + rightSum + node.val
            totalCount = leftCount + rightCount + 1

            average = totalSum // totalCount

            if average == node.val:
                self.count += 1

            return totalSum, totalCount

        dfs(root)
        return self.count

class Solution {
    int count = 0;

    pair<int, int> dfs(TreeNode* node) {
        if (node == nullptr)
            return {0, 0};

        auto left = dfs(node->left);
        auto right = dfs(node->right);

        int sum = left.first + right.first + node->val;
        int nodeCount = left.second + right.second + 1;

        int average = sum / nodeCount;

        if (average == node->val)
            count++;

        return {sum, nodeCount};
    }

public:
    int averageOfSubtree(TreeNode* root) {
        dfs(root);
        return count;
    }
};

class Solution {
    averageOfSubtree(root) {
        let count = 0;

        const dfs = (node) => {
            if (node === null) {
                return [0, 0];
            }

            const [leftSum, leftCount] = dfs(node.left);
            const [rightSum, rightCount] = dfs(node.right);

            const totalSum = leftSum + rightSum + node.val;
            const totalCount = leftCount + rightCount + 1;

            const average = Math.floor(totalSum / totalCount);

            if (average === node.val) {
                count++;
            }

            return [totalSum, totalCount];
        };

        dfs(root);
        return count;
    }
}