Nested List Weight Sum II

Nested List Weight Sum II - Problem

You are given a nested list of integers nestedList. Each element is either an integer or a list whose elements may also be integers or other lists.

The depth of an integer is the number of lists that it is inside of. For example, the nested list [1,[2,2],[[3],2],1] has each integer's value set to its depth.

Let maxDepth be the maximum depth of any integer. The weight of an integer is maxDepth - (the depth of the integer) + 1.

Return the sum of each integer in nestedList multiplied by its weight.

Input & Output

Example 1 — Basic Nested Structure

$ Input: nestedList = [1,[4,6]]

› Output: 12

💡 Note: Max depth is 2. Elements: 1 at depth 1 (weight 2), 4 at depth 2 (weight 1), 6 at depth 2 (weight 1). Sum = 1×2 + 4×1 + 6×1 = 12

Example 2 — Deeper Nesting

$ Input: nestedList = [1,[2,2],[[3],2],1]

› Output: 17

💡 Note: Max depth is 3. Weights: depth 1→3, depth 2→2, depth 3→1. Sum = 1×3 + 2×2 + 2×2 + 3×1 + 2×2 + 1×3 = 17

Example 3 — Single Level

$ Input: nestedList = [1,2,3]

› Output: 6

💡 Note: All elements at depth 1, weight = 1. Sum = 1×1 + 2×1 + 3×1 = 6

Constraints

1 ≤ nestedList.length ≤ 50
The values of the integers in the nested list is in the range [-100, 100]
The maximum depth of any integer is less than or equal to 50

Visualization

Tap to expand

Asked in

Li LinkedIn 35 f Facebook 28 G Google 22

The key insight is that weight = maxDepth - currentDepth + 1 inverts the traditional depth weighting. Best approach uses BFS level processing to avoid needing max depth upfront. Time: O(n), Space: O(w) where w is maximum level width.

Common Approaches

✓ BFS Level Processing

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

Use BFS to process nested list level by level. Keep running sum and adjust weights as we discover deeper levels. This avoids needing to know max depth beforehand.

Two-Pass DFS

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

First DFS traversal finds the maximum depth in the nested structure. Second DFS traversal calculates the sum using weight = maxDepth - currentDepth + 1.

BFS Level Processing — Algorithm Steps

Step 1: Process elements level by level using queue
Step 2: Adjust sum when discovering new depth levels

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 1

Process [1,[4,6]] → sum = 1

Level 2

Process [4,6] → sum = 10

Calculate

1×2 + 10×1 = 12

Code -

solution.c — C

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

#define MAX_ELEMENTS 1000
#define MAX_DEPTH 100

typedef struct NestedElement {
    int is_int;
    int value;
    struct NestedElement* children[MAX_ELEMENTS];
    int child_count;
} NestedElement;

int max(int a, int b) {
    return a > b ? a : b;
}

int findMaxDepth(NestedElement** lst, int count, int depth) {
    int maxD = depth;
    for (int i = 0; i < count; i++) {
        if (!lst[i]->is_int) {
            maxD = max(maxD, findMaxDepth(lst[i]->children, lst[i]->child_count, depth + 1));
        }
    }
    return maxD;
}

int calculateSum(NestedElement** lst, int count, int depth, int maxDepth) {
    int total = 0;
    int weight = maxDepth - depth + 1;
    for (int i = 0; i < count; i++) {
        if (!lst[i]->is_int) {
            total += calculateSum(lst[i]->children, lst[i]->child_count, depth + 1, maxDepth);
        } else {
            total += lst[i]->value * weight;
        }
    }
    return total;
}

NestedElement* createElement(int is_int, int value) {
    NestedElement* elem = (NestedElement*)malloc(sizeof(NestedElement));
    elem->is_int = is_int;
    elem->value = value;
    elem->child_count = 0;
    return elem;
}

NestedElement* parseNestedList(const char* str, int* pos) {
    NestedElement* result = createElement(0, 0);
    
    if (str[*pos] != '[') return result;
    (*pos)++; // skip '['
    
    while (str[*pos] != ']' && str[*pos] != '\0') {
        while (str[*pos] == ' ' || str[*pos] == ',') (*pos)++;
        if (str[*pos] == ']') break;
        
        if (str[*pos] == '[') {
            NestedElement* nested = parseNestedList(str, pos);
            result->children[result->child_count++] = nested;
        } else {
            int num = 0;
            int sign = 1;
            if (str[*pos] == '-') {
                sign = -1;
                (*pos)++;
            }
            while (isdigit(str[*pos])) {
                num = num * 10 + (str[*pos] - '0');
                (*pos)++;
            }
            NestedElement* numElem = createElement(1, sign * num);
            result->children[result->child_count++] = numElem;
        }
    }
    
    if (str[*pos] == ']') (*pos)++; // skip ']'
    return result;
}

int solution(NestedElement* nestedList) {
    int maxDepth = findMaxDepth(nestedList->children, nestedList->child_count, 1);
    return calculateSum(nestedList->children, nestedList->child_count, 1, maxDepth);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    int pos = 0;
    NestedElement* nestedList = parseNestedList(input, &pos);
    
    int result = solution(nestedList);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single BFS traversal visiting all n elements once

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w elements where w is maximum width at any level

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS Level Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler