Leetcode 364 Solution

/**
 * // 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 {
    vector<int> sums;
public:
    void depthSumInverse(NestedInteger& integer, int layer)
    {
        if (integer.isInteger())
        {
            if (sums.size() <= layer)
                sums.resize(layer + 1);
            sums[layer] += integer.getInteger();
            return;
        }
        else
        {
            auto subintegers = integer.getList();
            for (auto subinteger : subintegers)
                depthSumInverse(subinteger, layer + 1);
        }
    }

    int depthSumInverse(vector<NestedInteger>& nestedList) {
        for (auto integer : nestedList)
            depthSumInverse(integer, 1);

        int res = 0;
        for (int i = 1; i < sums.size(); i++)
        {
            int weight = sums.size() - i;
            res += weight * sums[i];
        }
        return res;
    }
};