Link: https://leetcode.cn/problems/nested-list-weight-sum-ii/

Question

difficulty: mid
adj diff: 3

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:

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:

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.

基本上跟 339. Nested List Weight Sum 一样。唯一的区别是：乘以 depth 跟 max depth 的差值。

Code

这是来自网友的代码

class Solution {
    public int depthSumInverse(List<NestedInteger> nestedList) {
        int dep = calDep(nestedList);
        return solve(nestedList, dep);
    }

    private int solve(List<NestedInteger> nestedList, int dep) {
        int sum = 0;
        for (NestedInteger e : nestedList) {
            if (e.isInteger()) {
                sum += e.getInteger() * dep;
            } else {
                sum += solve(e.getList(), dep - 1);
            }
        }
        return sum;
    }

    private int calDep(List<NestedInteger> l) {
        int dep = 1;
        for (NestedInteger e : l) {
            if (!e.isInteger()) {
                dep = Math.max(dep, calDep(e.getList()) + 1);
            }
        }
        return dep;
    }
}