Maximum Level Sum of a Binary Tree

Maximum Level Sum of a Binary Tree - Problem

Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.

Return the smallest level x such that the sum of all the values of nodes at level x is maximal.

Input & Output

Example 1 — Basic Case

$ Input: root = [1,7,0,7,-8,null,null]

› Output: 2

💡 Note: Level 1: sum = 1. Level 2: sum = 7 + 0 = 7. Level 3: sum = 7 + (-8) = -1. Maximum sum is 7 at level 2.

Example 2 — Single Node

$ Input: root = [989,null,10250,98693,-89388,null,null,null,-32127]

› Output: 2

💡 Note: Level 1: sum = 989. Level 2: sum = 10250. Level 3: sum = 98693 + (-89388) = 9305. Level 4: sum = -32127. Maximum sum is 10250 at level 2.

Example 3 — Negative Values

$ Input: root = [-100,-200,-300,-20,-5,-10,null]

› Output: 3

💡 Note: Level 1: sum = -100. Level 2: sum = -200 + (-300) = -500. Level 3: sum = -20 + (-5) + (-10) = -35. Maximum sum is -35 at level 3.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

f Facebook 25 a Amazon 20 M Microsoft 15 G Google 12

The key insight is to use BFS (breadth-first search) to naturally process nodes level by level, calculating the sum for each complete level and tracking which level has the maximum sum. The optimal approach uses a queue to implement BFS traversal. Time: O(n), Space: O(w) where w is the maximum width of the tree.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Bit Manipulation

⏱️ Time: N/A Space: N/A

BFS Level Order Traversal

⏱️ Time: O(n) Space: O(w)

Use breadth-first search with a queue to process all nodes at each level together. Calculate the sum for each level and track which level has the maximum sum.

DFS with Level Tracking

⏱️ Time: O(n) Space: O(h + l)

Traverse the tree using depth-first search while keeping track of each node's level. Use a hash map to accumulate sums for each level, then find the level with maximum sum.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_STATES 10000

struct MemoEntry {
    int index, mask1, mask2, result;
};

struct MemoEntry memo[MAX_STATES];
int memoSize = 0;
char s[20];
int n;

int isPalindrome(const char* str) {
    int len = strlen(str);
    int left = 0, right = len - 1;
    while (left < right) {
        if (str[left] != str[right]) return 0;
        left++;
        right--;
    }
    return 1;
}

int findMemo(int index, int mask1, int mask2) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].index == index && memo[i].mask1 == mask1 && memo[i].mask2 == mask2) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int index, int mask1, int mask2, int result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].index = index;
        memo[memoSize].mask1 = mask1;
        memo[memoSize].mask2 = mask2;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int dp(int index, int mask1, int mask2) {
    if (index == n) {
        char seq1[20] = "", seq2[20] = "";
        
        for (int i = 0; i < n; i++) {
            if (mask1 & (1 << i)) {
                strncat(seq1, &s[i], 1);
            }
            if (mask2 & (1 << i)) {
                strncat(seq2, &s[i], 1);
            }
        }
        
        if (strlen(seq1) > 0 && strlen(seq2) > 0 &&
            (mask1 & mask2) == 0 &&  // Ensure disjoint
            isPalindrome(seq1) && isPalindrome(seq2)) {
            return strlen(seq1) * strlen(seq2);
        }
        return 0;
    }
    
    int cached = findMemo(index, mask1, mask2);
    if (cached != -1) return cached;
    
    int choice1 = dp(index + 1, mask1 | (1 << index), mask2);
    int choice2 = dp(index + 1, mask1, mask2 | (1 << index));
    int choice3 = dp(index + 1, mask1, mask2);
    
    int result = choice1 > choice2 ? choice1 : choice2;
    result = result > choice3 ? result : choice3;
    
    addMemo(index, mask1, mask2, result);
    return result;
}

int solution(const char* str) {
    strcpy(s, str);
    n = strlen(s);
    memoSize = 0;
    return dp(0, 0, 0);
}

int main() {
    char s[20];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

945 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen