给你一个整数嵌套列表 nestedList ，每一个元素要么是一个整数，要么是一个列表（这个列表中的每个元素也同样是整数或列表）。

整数的 深度 取决于它位于多少个列表内部。例如，嵌套列表 [1,[2,2],[[3],2],1] 的每个整数的值都等于它的 深度 。令 maxDepth 是任意整数的 最大深度 。

整数的 权重 为 maxDepth - (整数的深度) + 1 。

将 nestedList 列表中每个整数先乘权重再求和，返回该加权和。

示例 1：

输入：nestedList = [[1,1],2,[1,1]]
输出：8
解释：4 个 1 在深度为 1 的位置， 一个 2 在深度为 2 的位置。
11 + 11 + 22 + 11 + 1*1 = 8

示例 2：

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

提示：

1 <= nestedList.length <= 50
嵌套列表中整数的值在范围 [-100, 100]
任意整数的最大 深度 小于等于 50

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/nested-list-weight-sum-ii

方法一：DFS

C++提交内容：

/**
 * // 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 res = 0;
        vector<vector<int>> integersListByDepth;
        for (auto& nl : nestedList) {
            dfs(nl, 0, integersListByDepth);
        }

        int N = integersListByDepth.size();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < integersListByDepth[i].size(); j++) {
                res += integersListByDepth[i][j] * (N - i);
            }
        }

        return res;
    }

private:
    void dfs(NestedInteger& ni, int depth, vector<vector<int>>& integersListByDepth) {
        if (depth == integersListByDepth.size()) {
            integersListByDepth.push_back(vector<int>());
        }

        if (ni.isInteger()) {
            integersListByDepth[depth].push_back(ni.getInteger());
        } else {
            for (auto& nl : ni.getList()) {
                dfs(nl, depth + 1, integersListByDepth);
            }
        }
    }
};