# Solution For Nested List Weight Sum

The Nested List Weight Sum problem on leetcode asks us to find the sum of all integers in a nested list of integers, where each element can be either an integer or a list. The weight of each integer is its depth in the nested list multiplied by its value.

For example, consider the following nested list [[1,1],2,[1,1]], the depth of the integers 1 and 1 is 2 (they are nested within a list nested within another list), and the depth of integer 2 is 1 (it is at the top level). Therefore, the weight of the nested list is (12) + (21) + (12) + (12) = 8.

To solve this problem, we can use recursion. We can define a function nestedListWeightSum that takes in a nested list and the current depth, and recursively calculates the sum. If the element is an integer, we simply add its weight to the total sum. If it is a list, we recursively call the function with the nested list and the current depth + 1.

Here is the detailed solution in Python:

`def nestedListWeightSum(nestedList, depth=1): totalSum = 0 for item in nestedList: if isinstance(item, int): totalSum += item * depth elif isinstance(item, list): totalSum += nestedListWeightSum(item, depth+1) return totalSum`

The function takes a nestedList and a depth (which is optional and defaults to 1). We initialize the totalSum to 0 and loop through each item in the nested list.

If the item is an integer, we add its weight to the total sum by multiplying it with the current depth. If the item is a list, we recursively call the function with the nested list and the current depth + 1, and add the result to the total sum.

Finally, we return the total sum.

We can test this function with the example nested list [[1,1],2,[1,1]] as follows:

```nestedList = [[1,1],2,[1,1]] print(nestedListWeightSum(nestedList))```

This should output 8 as expected.

This solution has a time complexity of O(n), where n is the total number of integers in the nested list. This is because we need to visit every integer once to calculate its weight. It also has a space complexity of O(d), where d is the maximum depth of the nested list, because we need to store the depth for each recursive call.

## Step by Step Implementation For Nested List Weight Sum

```/**
* // This is the interface that allows for creating nested lists.
* // You should not implement it, or speculate about its implementation
* public interface NestedInteger {
*     // Constructor initializes an empty nested list.
*     public NestedInteger();
*
*     // Constructor initializes a single integer.
*     public NestedInteger(int value);
*
*     // @return true if this NestedInteger holds a single integer, rather than a nested list.
*     public boolean isInteger();
*
*     // @return the single integer that this NestedInteger holds, if it holds a single integer
*     // Return null if this NestedInteger holds a nested list
*     public Integer getInteger();
*
*     // Set this NestedInteger to hold a single integer.
*     public void setInteger(int value);
*
*     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
*
*     // @return the nested list that this NestedInteger holds, if it holds a nested list
*     // Return null if this NestedInteger holds a single integer
*     public List getList();
* }
*/
public class Solution {
public int depthSum(List nestedList) {
// Corner case
if (nestedList == null || nestedList.size() == 0) {
return 0;
}

// Normal case
return helper(nestedList, 1);
}

private int helper(List nestedList, int depth) {
int sum = 0;

for (NestedInteger ni : nestedList) {
if (ni.isInteger()) {
sum += depth * ni.getInteger();
} else {
sum += helper(ni.getList(), depth + 1);
}
}

return sum;
}
}```
```# This is the interface that allows for creating nested lists.
# You should not implement it, or speculate about its implementation
#
#class NestedInteger:
#    def __init__(self, value=None):
#        """
#        If value is not specified, initializes an empty list.
#        Otherwise initializes a single integer equal to value.
#        """
#
#    def isInteger(self):
#        """
#        @return True if this NestedInteger holds a single integer, rather than a nested list.
#        :rtype bool
#        """
#
#        """
#        Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
#        :rtype void
#        """
#
#    def setInteger(self, value):
#        """
#        Set this NestedInteger to hold a single integer equal to value.
#        :rtype void
#        """
#
#    def getInteger(self):
#        """
#        @return the single integer that this NestedInteger holds, if it holds a single integer
#        Return None if this NestedInteger holds a nested list
#        :rtype int
#        """
#
#    def getList(self):
#        """
#        @return the nested list that this NestedInteger holds, if it holds a nested list
#        Return None if this NestedInteger holds a single integer
#        :rtype List[NestedInteger]
#        """

class Solution:
def depthSum(self, nestedList: List[NestedInteger]) -> int:
# Initialize sum as 0
sum = 0

# Create an empty queue for level order traversal
queue = []

# Enqueue first level and initialize height
queue.append(nestedList)

# Process all nodes of current level and enqueue their
# non-empty children
while queue:

# Get the size of queue when the level order
# traversal for one level finishes
size = len(queue)

# Dequeue all nodes of current level and Enqueue
# all nodes of next level
for i in range(size):

# Extract the node from list
node = queue.pop(0)

# Get the current node's value
val = node.getInteger()

# If current node is not integer
if not node.isInteger():

# Get the list of children
lst = node.getList()

# Append the children to queue
for j in range(len(lst)):
queue.append(lst[j])

# Else append the current node's value to sum
else:
sum += val

return sum```
```/**
* // This is the interface that allows for creating nested lists.
* // You should not implement it, or speculate about its implementation
* function NestedInteger() {
*
*     Return true if this NestedInteger holds a single integer, rather than a nested list.
*     @return {boolean}
*     this.isInteger = function() {
*         ...
*     };
*
*     Return the single integer that this NestedInteger holds, if it holds a single integer
*     Return null if this NestedInteger holds a nested list
*     @return {integer}
*     this.getInteger = function() {
*         ...
*     };
*
*     Set this NestedInteger to hold a single integer equal to value.
*     @return {void}
*     this.setInteger = function(value) {
*         ...
*     };
*
*     Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
*     @return {void}
*         ...
*     };
*
*     Return the nested list that this NestedInteger holds, if it holds a nested list
*     Return null if this NestedInteger holds a single integer
*     @return {NestedInteger[]}
*     this.getList = function() {
*         ...
*     };
* };
*/
/**
* @param {NestedInteger[]} nestedList
* @return {number}
*/
var depthSum = function(nestedList) {
// Initialize depth to 1
let depth = 1;
// Initialize sum to 0
let sum = 0;
// Helper function to recursively calculate sum
const helper = function(nestedList, depth) {
// Base case: if nestedList is empty, return
if (nestedList.length === 0) {
return;
}
// Iterate through each element in nestedList
for (let i = 0; i < nestedList.length; i++) {
// If element is an integer, add depth * element to sum
if (nestedList[i].isInteger()) {
sum += depth * nestedList[i].getInteger();
// Otherwise, element is a nested list
} else {
// Recursively call helper function with nested list and depth + 1
helper(nestedList[i].getList(), depth + 1);
}
}
}
// Call helper function with initial nestedList and depth
helper(nestedList, depth);
// Return sum
return sum;
};```
```/**
* // This is the interface that allows for creating nested lists.
* // You should not implement it, or speculate about its implementation
* class NestedInteger {
*   public:
*     // Constructor initializes an empty nested list.
*     NestedInteger();
*
*     // Constructor initializes a single integer.
*     NestedInteger(int value);
*
*     // Return true if this NestedInteger holds a single integer, rather than a nested list.
*     bool isInteger() const;
*
*     // Return the single integer that this NestedInteger holds, if it holds a single integer
*     // The result is undefined if this NestedInteger holds a nested list
*     int getInteger() const;
*
*     // Set this NestedInteger to hold a single integer.
*     void setInteger(int value);
*
*     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
*
*     // Return the nested list that this NestedInteger holds, if it holds a nested list
*     // The result is undefined if this NestedInteger holds a single integer
*     const vector &getList() const;
* };
*/
class Solution {
public:
// @param nestedList a list of NestedInteger
// @return a list of integer
vector flatten(vector &nestedList) {
vector result;
for (auto n : nestedList) {
if (n.isInteger()) {
result.push_back(n.getInteger());
}
else {
vector flat = flatten(n.getList());
result.insert(result.end(), flat.begin(), flat.end());
}
}
return result;
}
};```
`using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace nested_list_weight_sum { class Program { static void Main(string[] args) { List input = new List(); input.Add(new NestedInteger(1)); input.Add(new NestedInteger(2)); input.Add(new NestedInteger(3)); Console.WriteLine(NestedListWeightSum(input)); Console.ReadKey(); } public static int NestedListWeightSum(List nestedList) { //ToDo: Implement logic to calculate sum of weights return 0; } } public class NestedInteger { // Constructor initializes an empty nested list. public NestedInteger() { } // Constructor initializes a single integer. public NestedInteger(int value) { } // @return true if this NestedInteger holds a single integer, rather than a nested list. public bool IsInteger() { return false; } // @return the single integer that this NestedInteger holds, if it holds a single integer // Return null if this NestedInteger holds a nested list public int GetInteger() { return 0; } // Set this NestedInteger to hold a single integer. public void SetInteger(int value) { } // Set this NestedInteger to hold a nested list and adds a nested integer to it. public void Add(NestedInteger ni) { } // @return the nested list that this NestedInteger holds, if it holds a nested list // Return null if this NestedInteger holds a single integer public IList GetList() { return null; } } }`

Scroll to Top
[gravityforms id="5" description="false" titla="false" ajax="true"]