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

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.

Example 1:

Input: [[1,1],2,[1,1]]
Output: 10
Explanation: Four 1's at depth 2, one 2 at depth 1.

Example 2:

Input: [1,[4,[6]]]
Output: 27
Explanation: One 1 at depth 1, one 4 at depth 2, and one 6 at depth 3; 1 + 4*2 + 6*3 = 27.

题意：

嵌套列表加权和

Solution1： BFS(level order traversal) 是最快的

code

 class Solution {
    public int depthSum(List<NestedInteger> nestedList) {
        // corner case
         if(nestedList == null){return 0;}
        // initialize
         int result = 0;
         int depth = 1;
        // 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();
             for(int i = 0; i < size; i++){
                 NestedInteger n = queue.poll();
                 if(n.isInteger()){
                     result += n.getInteger() * depth;
                 }else{
                     // put each item of list into the queue
                     queue.addAll(n.getList());
                 }
             }
             depth++;
         }
     return result;
     }
 }

注意：   put each item of list into the queue 的写法有：

Queue<NestedInteger> queue = new LinkedList<>(nestedList); 

for（NestedInteger n :nestedList）{
　　　　queue.add(n)
}

queue.addAll(nestedList)

Solution2: DFS

code

 class Solution {
     public int depthSum(List<NestedInteger> nestedList) {
         if(nestedList == null) return 0;
         return dfs(nestedList, 1);
     }

     private int dfs(List<NestedInteger> nestedList, int depth){
         int result = 0;
         for(NestedInteger n : nestedList ){
             if(n.isInteger()){
                 result = result + n.getInteger()*depth;
             }else{
                 result = result + dfs(n.getList() , depth+1);
             }
         }
         return result ;
     }
 }