# 364. Nested List Weight Sum II

**<font color=red>难度: Medium</font>**

## 刷题内容

> 原题连接

* https://leetcode.com/problems/nested-list-weight-sum-ii/description/

> 内容描述

```
Given a nested list of integers, return the sum of all integers in the list weighted by their depth.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

Different from the previous question where weight is increasing from root to leaf, now the weight is defined from bottom up. i.e., the leaf level integers have weight 1, and the root level integers have the largest weight.

Example 1:

Input: [[1,1],2,[1,1]]
Output: 8 
Explanation: Four 1's at depth 1, one 2 at depth 2.
Example 2:

Input: [1,[4,[6]]]
Output: 17 
Explanation: One 1 at depth 3, one 4 at depth 2, and one 6 at depth 1; 1*3 + 4*2 + 6*1 = 17.
```

## 解题方案

> 思路 1
******- 时间复杂度: O(N)******- 空间复杂度: O(N)******



很简单，原来基础上稍微改改就行了

假设nestedList铺平开来，里面一共有N个NestedInteger的话，时间复杂度就是O(N), 空间也是O(N)

beats 99.64%

```python
class Solution:
    def depthSumInverse(self, nestedList):
        """
        :type nestedList: List[NestedInteger]
        :rtype: int
        """
        def helper(nestedList, depth):
            for nested in nestedList:
                if nested.isInteger():
                    lookup[depth].append(nested.getInteger())
                else:
                    helper(nested.getList(), depth+1)
                    
        lookup = collections.defaultdict(list)
        helper(nestedList, 1)    
        max_depth = max(lookup.keys()) if lookup.keys() else 0
        return sum([(max_depth + 1 - depth) * value for depth, values in lookup.items() for value in values])
```
