[leetcode]364. Nested List Weight Sum II嵌套列表加权和II

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 [leetcode]339. Nested List Weight Sum嵌套列表加权和 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.

思路

跑的最快的方法是 DFS

1. We can observe that

1x + 2y + 3z  = (x+y+z) * (3+1)    -   (3x+2y+1z)

^ levelSum  ^maxDepth   ^ Nested List Weight Sum I problem

2. Use DFS recursion, converting this problem to Nested List Weight Sum I,  updating levelSum and maxPath at the same time when using DFS

代码

 class Solution {
     int levelSum = 0;
     int maxDepth = 1;

     public int depthSumInverse(List<NestedInteger> nestedList) {
         int depthSum = dfs(nestedList, 1);
         return levelSum * (maxDepth + 1) - depthSum;
     }

     private int dfs(List<NestedInteger> nestedList, int depth) {
         int sum = 0;
         for (NestedInteger n : nestedList) {
             if (n.isInteger()) {
                 // same as Nested List Weight Sum I
                 sum += n.getInteger() * depth;
                 // at the same time, use DFS to update levelSum and maxDepth
                 maxDepth = Math.max(depth, maxDepth);
                 levelSum += n.getInteger();
             } else {
                 // same as Nested List Weight Sum I
                 sum += dfs(n.getList(), depth + 1);
             }
         }
         return sum;
     }
 }

思路

最容易想到的方法 DFS

1. use helper function to get maxDepth

2. same as Nested List Weight Sum I, use dfs function to get result. Only concerning that do substraction instead of addition when entering next new level

 class Solution {
     public int depthSumInverse(List<NestedInteger> nestedList) {
         // corner case
         if(nestedList == null || nestedList.size() == 0) return 0;
         int depth = helper(nestedList);
         int sum = dfs(nestedList, depth);
         return sum;
     }
     // helper recursion function to get the maxDepth
     public int helper(List<NestedInteger> nestedList) {
         int depth = 0;
         for (NestedInteger n : nestedList) {
             if(n.isInteger()) {
                depth = Math.max(depth, 1);
             }
             else {
                 depth = Math.max(depth, helper(n.getList()) + 1);
             }
         }
         return depth;
     }

     // same as Nested List Weight Sum I
     public int dfs(List<NestedInteger> nestedList, int depth) {
         int result = 0;
         for (NestedInteger n : nestedList) {
             if (n.isInteger()) {
                 result += n.getInteger() * depth;
             } else {
                 result += dfs(n.getList(), depth - 1);
             }
         }
         return result;
     }
 }

思路

BFS(level order traversal)

if we want to get 3x + 2y + 1z, we can use preSum tech like that

levelSum    x

preSum      x

result        x

=======================

levelSum    x     y

preSum      x    x+y

result         x    x + x + y

=======================

levelSum    x     y             z

preSum      x    x+y           x+y+z

result         x    x + x + y    x + x + y + x + y + z

代码

 class Solution {
     public int depthSumInverse(List<NestedInteger> nestedList) {
         // corner case
         if(nestedList == null || nestedList.size() == 0) return 0;
          // initialize
         int preSum = 0;
         int result = 0;
         // put each item of list into the queue
         Queue<NestedInteger> queue = new LinkedList<>(nestedList);
         while(!queue.isEmpty()){
             //depends on different depth, queue size is changeable
             int size = queue.size();
             int levelSum = 0;
             for(int i = 0; i < size; i++){
                 NestedInteger n = queue.poll();
                 if(n.isInteger()){
                     levelSum += n.getInteger();
                 }
                 else{
                     // depends on different depth, queue size is changeable
                     queue.addAll(n.getList());
                 }
             }
             preSum += levelSum;
             result += preSum;
         }
         return result;
     }
 }