LeetCode 364. 加权嵌套序列和 II（重复叠加）

示例 1:
输入: [[1,1],2,[1,1]]
输出: 8 
解释: 四个 1 在深度为 1 的位置， 一个 2 在深度为 2 的位置。

示例 2:
输入: [1,[4,[6]]]
输出: 17 
解释: 一个 1 在深度为 3 的位置， 一个 4 在深度为 2 的位置，
一个 6 在深度为 1 的位置。 1*3 + 4*2 + 6*1 = 17。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *   public:
 *     // Constructor initializes an empty nested list.
 *     NestedInteger();
 *
 *     // Constructor initializes a single integer.
 *     NestedInteger(int value);
 *
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     bool isInteger() const;
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     int getInteger() const;
 *
 *     // Set this NestedInteger to hold a single integer.
 *     void setInteger(int value);
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     void add(const NestedInteger &ni);
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     const vector<NestedInteger> &getList() const;
 * };
 */
class Solution {
public:
    int depthSumInverse(vector<NestedInteger>& nestedList) {
    	int presum = 0, ans = 0, i;
    	vector<NestedInteger> nextLevel;
    	for(i = 0; i < nestedList.size(); ++i)
    	{
    		if(nestedList[i].isInteger())
    			presum += nestedList[i].getInteger();
    		else
    		{
                auto temp = nestedList[i].getList();
                for(auto& t : temp)
                    nextLevel.push_back(t);
            }
    		if(i == nestedList.size()-1)
    		{
    			ans += presum;
    			swap(nestedList,nextLevel);
                nextLevel.clear();
                i = -1;
    		}
    	}
    	return ans;
    }
};