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

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

 

Analyse: Use recursion to solve this problem. 

Runtime: 3ms

 1 /**
 2  * // This is the interface that allows for creating nested lists.
 3  * // You should not implement it, or speculate about its implementation
 4  * class NestedInteger {
 5  *   public:
 6  *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 7  *     bool isInteger() const;
 8  *
 9  *     // Return the single integer that this NestedInteger holds, if it holds a single integer
10  *     // The result is undefined if this NestedInteger holds a nested list
11  *     int getInteger() const;
12  *
13  *     // Return the nested list that this NestedInteger holds, if it holds a nested list
14  *     // The result is undefined if this NestedInteger holds a single integer
15  *     const vector<NestedInteger> &getList() const;
16  * };
17  */
18 class Solution {
19 public:
20     int depthSum(vector<NestedInteger>& nestedList) {
21         int result = 0;
22         helper(nestedList, 1, result);
23         return result;
24     }
25     
26     void helper(vector<NestedInteger>& nestedList, int depth, int& result) {
27         for (int i = 0; i < nestedList.size(); i++) {
28             if (nestedList[i].isInteger()) {
29                 result += depth * nestedList[i].getInteger();
30             } else {
31                 vector<NestedInteger> newNestedList = nestedList[i].getList();
32                 helper(newNestedList, depth + 1, result);
33             }
34         }
35     }
36 };

 

转载于:https://www.cnblogs.com/amazingzoe/p/5947865.html