# 339. Nested List Weight Sum

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**.

Return *the sum of each integer in* `nestedList` *multiplied by its **depth***.

 

**Example 1:**

![](https://assets.leetcode.com/uploads/2021/01/14/nestedlistweightsumex1.png)

<pre><code><strong>Input: nestedList = [[1,1],2,[1,1]]
</strong><strong>Output: 10
</strong><strong>Explanation: Four 1's at depth 2, one 2 at depth 1. 1*2 + 1*2 + 2*1 + 1*2 + 1*2 = 10.
</strong></code></pre>

**Example 2:**

![](https://assets.leetcode.com/uploads/2021/01/14/nestedlistweightsumex2.png)

<pre><code><strong>Input: nestedList = [1,[4,[6]]]
</strong><strong>Output: 27
</strong><strong>Explanation: One 1 at depth 1, one 4 at depth 2, and one 6 at depth 3. 1*1 + 4*2 + 6*3 = 27.
</strong></code></pre>

**Example 3:**

<pre><code><strong>Input: nestedList = [0]
</strong><strong>Output: 0
</strong></code></pre>

&#x20;

**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`.

分析： dfs

```
# """
# 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
#        """
#
#    def add(self, elem):
#        """
#        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
#        The result is undefined 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
#        The result is undefined if this NestedInteger holds a single integer
#        :rtype List[NestedInteger]
#        """

class Solution:
        def depthSum(self, nestedList: List[NestedInteger]) -> int:
            def dfs(nestedList, level):
                if nestedList.isInteger():
                    return level*nestedList.getInteger()
                res = 0
                for nested in nestedList.getList():
                    res += dfs(nested, level+1)
                return res
            res = 0
            for i in nestedList:
                res += dfs(i, 1)   
            return res
```