leetcode364题 加权嵌套序列和 -java解决

题目 ：给一个嵌套整数序列，请你返回每个数字在序列中的加权和，它们的权重由它们的深度决定。

序列中的每一个元素要么是一个整数，要么是一个序列（这个序列中的每个元素也同样是整数或序列）。

与 前一个问题 不同的是，前一题的权重按照从根到叶逐一增加，而本题的权重从叶到根逐一增加。

也就是说，在本题中，叶子的权重为1，而根拥有最大的权重。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/nested-list-weight-sum-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * // 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 null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
 //以上为力扣后台预定的接口
class Solution {
    
    public int depthSumInverse(List<NestedInteger> nestedList)
    {
        help1(nestedList,1);
        int nums = help2(nestedList,lev);
        return nums;
    }
    int lev = 0; //记录嵌套列表的最大深度
    public void help1(List<NestedInteger>nestedList,int n)
    {   
        if(nestedList==null)
            return;
         for(NestedInteger x: nestedList)
        {
            if(x.isInteger())
            {
                if(n>lev)
                    lev= n;
            }
            else
            {
                help1(x.getList(),n+1);
            }
        }
        
    }
    public int help2(List<NestedInteger>n,int m)//递归求和
    {
        int sum=0;
        for(NestedInteger x: n)
        {
            if(x.isInteger())
            {
                sum+=x.getInteger()*m;
            }
            else
            {
                sum+=help2(x.getList(),m-1);
            }
        }
        return sum;
    }
}

此题为339题的进阶题目，具体链接https://leetcode-cn.com/problems/nested-list-weight-sum/
应先选择339题进行解答，理解广义表的结构后，我们只需要先定义成员变量，对嵌套列表进行dfs，获得其最大深度后，对嵌套列表进行加权求值即可。不懂如何进行递归计算的，请参考339题的解题思路