chore: sync automated leetcode submissions with Runtime - 0 ms (100.00%), Memory - 3 MB (100.00%)

Author: bufferwise

1116-maximum-level-sum-of-a-binary-tree/README.md

@@ -0,0 +1,31 @@
+<p>Given the <code>root</code> of a binary tree, the level of its root is <code>1</code>, the level of its children is <code>2</code>, and so on.</p>
+
+<p>Return the <strong>smallest</strong> level <code>x</code> such that the sum of all the values of nodes at level <code>x</code> is <strong>maximal</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/05/03/capture.JPG" style="width: 200px; height: 175px;" />
+<pre>
+<strong>Input:</strong> root = [1,7,0,7,-8,null,null]
+<strong>Output:</strong> 2
+<strong>Explanation: </strong>
+Level 1 sum = 1.
+Level 2 sum = 7 + 0 = 7.
+Level 3 sum = 7 + -8 = -1.
+So we return the level with the maximum sum which is level 2.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [989,null,10250,98693,-89388,null,null,null,-32127]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>

1116-maximum-level-sum-of-a-binary-tree/solution.rs

@@ -0,0 +1,47 @@
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::collections::VecDeque;
+
+impl Solution {
+    pub fn max_level_sum(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        let root = match root {
+            Some(node) => node,
+            None => return 0,
+        };
+
+        let mut max_sum = i32::MIN;
+        let mut max_level = 1;
+        let mut current_level = 1;
+        
+        let mut queue = VecDeque::new();
+        queue.push_back(root);
+
+        while !queue.is_empty() {
+            let level_size = queue.len();
+            let mut level_sum = 0;
+
+            for _ in 0..level_size {
+                if let Some(node) = queue.pop_front() {
+                    let node_borrow = node.borrow();
+                    level_sum += node_borrow.val;
+
+                    if let Some(left) = node_borrow.left.clone() {
+                        queue.push_back(left);
+                    }
+                    if let Some(right) = node_borrow.right.clone() {
+                        queue.push_back(right);
+                    }
+                }
+            }
+            
+            if level_sum > max_sum {
+                max_sum = level_sum;
+                max_level = current_level;
+            }
+
+            current_level += 1;
+        }
+
+        max_level
+    }
+}