Codestin Search App

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

Single-Pass DFS with Mathematical Optimization — Algorithm Steps

For each integer at depth d, it contributes d times to the unweighted sum
It also contributes 1 time for each level below it in the final weighted sum
Use single DFS to collect: sum of all values and sum of (depth × value)
Apply formula: total = (maxDepth + 1) × unweightedSum - depthWeightedSum

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Level Sums

Single DFS pass collects sum of integers at each depth level

Apply Weight Formula

Each level contributes (levels_below + 1) times to final sum

Calculate Result

Sum all weighted contributions without knowing max depth beforehand

Code -

solution.c — C

void collectLevelSums(struct NestedInteger** nested, int size, int depth, int* levelSums, int* maxDepth) {
    if (depth > *maxDepth) *maxDepth = depth;
    
    for (int i = 0; i < size; i++) {
        if (NestedIntegerIsInteger(nested[i])) {
            levelSums[depth] += NestedIntegerGetInteger(nested[i]);
        } else {
            int listSize = NestedIntegerGetListSize(nested[i]);
            struct NestedInteger** list = NestedIntegerGetList(nested[i]);
            collectLevelSums(list, listSize, depth + 1, levelSums, maxDepth);
        }
    }
}

int depthSumInverse(struct NestedInteger** nestedList, int nestedListSize) {
    int levelSums[1000] = {0};
    int maxDepth = 0;
    
    collectLevelSums(nestedList, nestedListSize, 0, levelSums, &maxDepth);
    
    int result = 0;
    for (int i = 0; i <= maxDepth; i++) {
        result += levelSums[i] * (maxDepth - i + 1);
    }
    
    return result;
}

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

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

Single-Pass DFS with Mathematical Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler