# 0364. Nested List Weight Sum II

<https://leetcode.com/problems/nested-list-weight-sum-ii>

## Description

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**. Let `maxDepth` be the **maximum depth** of any integer.

The **weight** of an integer is `maxDepth - (the depth of the integer) + 1`.

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

**Example 1:**

![](https://assets.leetcode.com/uploads/2021/03/27/nestedlistweightsumiiex1.png)

```
**Input:** nestedList = [[1,1],2,[1,1]]
**Output:** 8
**Explanation:** Four 1's with a weight of 1, one 2 with a weight of 2.
1*1 + 1*1 + 2*2 + 1*1 + 1*1 = 8
```

**Example 2:**

![](https://assets.leetcode.com/uploads/2021/03/27/nestedlistweightsumiiex2.png)

```
**Input:** nestedList = [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
```

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

## ac

```java
class Solution {
    public int depthSumInverse(List<NestedInteger> nestedList) {
        int unweighted = 0, res = 0;
        while (nestedList.size() > 0) {
            List<NestedInteger> next = new ArrayList<>();
            for (NestedInteger ni : nestedList) {
                if (ni.isInteger()) unweighted += ni.getInteger();
                else next.addAll(ni.getList());
            }
            res += unweighted;
            nestedList = next;
        }

        return res;
    }
}

/*
1) use 2 vars: weighted/unweighted; 2) recursion until no more list, each time += unweighted, as they go one level further, they add once more;
*/
```
