Nested List Weight Sum II

原创已于 2022-02-06 09:09:44 修改 · 551 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#list #数据结构

于 2016-09-10 05:25:19 首次发布

DFS 专栏收录该内容

80 篇文章

订阅专栏

本文介绍了一种针对嵌套整数列表的加权深度求和算法，该算法从底部向上定义权重，即叶级整数权重为1，根级整数具有最大权重。通过两个示例展示了算法的具体应用，并提供了详细的实现思路及Java代码。

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:
Given the list [[1,1],2,[1,1]], return 8. (four 1's at depth 1, one 2 at depth 2)

Example 2:
Given the list [1,[4,[6]]], return 17. (one 1 at depth 3, one 4 at depth 2, and one 6 at depth 1; 1*3 + 4*2 + 6*1 = 17)

思路：首先dfs求出depth，然后再按照Nest Weigth Sum的方法求和。注意[[1,1],2,[1,1]] 的情况下，两个[1,1]是同一层，所以用depth作为参数，然后用array[0] 来记录层数，这样递归的时候，才能避免depth的计算错误。

/**
 * // 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.
 *     public void add(NestedInteger ni);
 *
 *     // @return the nested list that this NestedInteger holds, if it holds a nested list
 *     // Return empty list if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
class Solution {
    public int depthSumInverse(List<NestedInteger> nestedList) {
        int[] maxDepth = new int[]{0};
        int[] res = new int[]{0};
        getDepth(nestedList, maxDepth, 1);
        getRes(nestedList, res, maxDepth[0]);
        return res[0];
    }
    
    private void getDepth(List<NestedInteger> nestedList, int[] maxDepth, int curdepth) {
        maxDepth[0] = Math.max(maxDepth[0], curdepth);
        for(NestedInteger nestedInteger: nestedList) {
            if(!nestedInteger.isInteger()) {
                getDepth(nestedInteger.getList(), maxDepth, curdepth + 1);
            }
        }
    }
    
    private void getRes(List<NestedInteger> nestedList, int[] res, int depth) {
        for(NestedInteger nestedInteger: nestedList) {
            if(nestedInteger.isInteger()) {
                res[0] += nestedInteger.getInteger() * depth;
            } else {
                getRes(nestedInteger.getList(), res, depth - 1);
            }
        }
    }
}