339 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.

Given the list [[1,1],2,[1,1]], return 10. (four 1's at depth 2, one 2 at depth 1, 4 * 1 * 2 + 1 * 2 * 1 = 10)

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)

思路:

这道题定义了一种嵌套链表的结构，链表可以无限往里嵌套，规定每嵌套一层，深度加1，让我们求权重之和，就是每个数字乘以其权重，再求总和。那么我们考虑，由于嵌套层数可以很大，所以我们用深度优先搜索DFS会很简单，每次遇到嵌套的，递归调用函数，一层一层往里算就可以了.

代码:

public class Solution {
    public static int depthSum(List<NestedInteger> nestedList) {
        if (nestedList == null)
            return 0;
        return helper(nestedList, 1);
    }
    
    private static int helper(List<NestedInteger> nestedList, int deepth) {
        int res = 0;
        for (NestedInteger nest : nestedList) {
            if (nest.isInteger()) {
                res += nest.getInteger() * deepth;
            } else {
                res += helper(nest.getList(), deepth + 1);
            }
        }
        return res;
    }

    public static void main(String[] args) {
        NestedInteger n1 = new NestedInteger(2);
        NestedInteger n2 = new NestedInteger(1);
        NestedInteger n3 = new NestedInteger(1);
        NestedInteger n4 = new NestedInteger(1);
        NestedInteger n5 = new NestedInteger(1);
        
        List<NestedInteger> sublist1 = new ArrayList<>();
        sublist1.add(n2);
        sublist1.add(n3);
        NestedInteger list1 = new NestedInteger(null, sublist1);
        List<NestedInteger> sublist2 = new ArrayList<>();
        sublist2.add(n4);
        sublist2.add(n5);
        NestedInteger list2 = new NestedInteger(null, sublist2);
        
        List<NestedInteger> list = new ArrayList<>();
        list.add(list1);
        list.add(n1);
        list.add(list2);
        
        System.out.println(depthSum(list));
    }
}

class NestedInteger {
    Integer value;
    List<NestedInteger> list;

    NestedInteger(Integer value) {
        this.value = value;
    }
    NestedInteger(Integer value, List<NestedInteger> list) {
        this.value = value;
        this.list = list;
    }
    
    public boolean isInteger() { return value != null; }
    
    public Integer getInteger() { return value;}
    
    public List<NestedInteger> getList() { return list;}
}