Nested List Weight Sum II - Practice Coding Problems

Nested List Weight Sum II - Problem

You're given a nested list of integers where each element can be either an integer or another list (which can contain integers or more nested lists). Think of it like Russian nesting dolls, but with numbers!

Here's the twist: instead of deeper elements having higher weights, they have lower weights. The weight of an integer equals maxDepth - depth + 1, where:

depth = how many lists contain this integer
maxDepth = the deepest level in the entire structure

Your goal is to return the sum of each integer multiplied by its weight.

Example: In [1,[4,[6]]], the depths are: 1(depth=1), 4(depth=2), 6(depth=3). Since maxDepth=3, the weights are: 1×3 + 4×2 + 6×1 = 17.

Input & Output

example_1.py — Basic Nested Structure

$ Input: [[1,1],2,[1,1]]

› Output: 8

💡 Note: Four 1's at depth 2 (weight=1), one 2 at depth 1 (weight=2). Sum = 4×1 + 1×2 = 6. Wait, let me recalculate: maxDepth=2, so weights are 2,1. Sum = 4×1 + 1×2 = 8.

example_2.py — Deep Nesting

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

› Output: 17

💡 Note: 1 at depth 1 (weight=3), 4 at depth 2 (weight=2), 6 at depth 3 (weight=1). Since maxDepth=3: 1×3 + 4×2 + 6×1 = 17.

example_3.py — Single Level

$ Input: [1,2,3,4,5]

› Output: 15

💡 Note: All elements at depth 1, maxDepth=1, so weight=1 for all. Sum = (1+2+3+4+5)×1 = 15.

Visualization

Tap to expand

Understanding the Visualization

Explore the Structure

Traverse the nested list like exploring each floor of the building to find all integers and their depths

Find Maximum Depth

Determine the highest floor (maximum nesting level) to establish the weight system

Calculate Reverse Weights

Apply the formula: weight = maxDepth - currentDepth + 1, so deeper elements get lower weights

Sum Weighted Values

Multiply each integer by its weight and sum all results for the final answer

Key Takeaway

🎯 Key Insight: The reverse weighting system rewards elements at shallower depths more than deeper ones. We can solve this efficiently in a single pass by collecting level sums and applying the mathematical relationship between depth and weight contributions.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal of all n elements in the nested structure

✓ Linear Growth

Space Complexity

O(d)

Only recursion stack space proportional to maximum depth d

✓ Linear Space

Constraints

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

Asked in

in LinkedIn 45 a Amazon 32 G Google 28 ⊞ Microsoft 22

The optimal approach uses a single DFS traversal with mathematical insight: instead of finding maxDepth first, we collect sums at each level and apply the formula levelSum[i] × (totalLevels - i). This achieves O(n) time and O(d) space complexity while being more elegant than the naive two-pass solution.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass DFS (Find Max Depth First)	O(n)	O(d)	First pass finds maximum depth, second pass calculates weighted sum
Level-Order BFS with Depth Tracking	O(n)	O(n + d)	Use BFS to collect values by level, then calculate with reverse weights
Single-Pass DFS with Mathematical Optimization	O(n)	O(d)	Eliminate need for max depth by using mathematical equivalence

Two-Pass DFS (Find Max Depth First) — Algorithm Steps

First DFS: Recursively traverse the entire structure to find maximum depth
Second DFS: Traverse again, calculating each integer's weight using maxDepth - depth + 1
Sum all weighted values and return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Traverse entire structure to find maximum depth = 3

Second Pass

Calculate weights using maxDepth - depth + 1 formula

Sum Calculation

Multiply each value by its weight and sum all results

Code -

solution.c — C

int findMaxDepth(struct NestedInteger** nested, int size, int depth) {
    int maxD = depth;
    for (int i = 0; i < size; i++) {
        if (!NestedIntegerIsInteger(nested[i])) {
            int listSize = NestedIntegerGetListSize(nested[i]);
            struct NestedInteger** list = NestedIntegerGetList(nested[i]);
            maxD = fmax(maxD, findMaxDepth(list, listSize, depth + 1));
        }
    }
    return maxD;
}

int calculateSum(struct NestedInteger** nested, int size, int depth, int maxDepth) {
    int total = 0;
    for (int i = 0; i < size; i++) {
        if (NestedIntegerIsInteger(nested[i])) {
            int weight = maxDepth - depth + 1;
            total += NestedIntegerGetInteger(nested[i]) * weight;
        } else {
            int listSize = NestedIntegerGetListSize(nested[i]);
            struct NestedInteger** list = NestedIntegerGetList(nested[i]);
            total += calculateSum(list, listSize, depth + 1, maxDepth);
        }
    }
    return total;
}

int depthSumInverse(struct NestedInteger** nestedList, int nestedListSize) {
    int maxDepth = findMaxDepth(nestedList, nestedListSize, 1);
    return calculateSum(nestedList, nestedListSize, 1, maxDepth);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through all n elements in the nested structure

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth equals maximum nesting depth d

✓ Linear Space

Constraints

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

28.5K Views

Medium Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass DFS (Find Max Depth First) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler