# Leetcode 364 Solution

This article provides solution to leetcode question 364 (nested-list-weight-sum-ii)

https://leetcode.com/problems/nested-list-weight-sum-ii

## 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;
}
};
``````