【LeetCode】931 and 2049（动态规划 and DFS）

931. 下降路径最小和

该题为求最值，同时涉及到面临不同选择取最优的问题，各个选择之间彼此关联，因此可以考虑用dp来求解。因为最后一行 A 的值就是 其dp的值。因此我们从倒数第二行开始，从下往上进行动态规划。
解法：递归+备忘录
终点可能在 matrix[n-1] 的任意⼀列，故求得到达每一列的最小路径后，取其最小值即为结果。利用递归+备忘录进行求解。
这里要注意base case和备忘录的使用。

class Solution:
    def minFallingPathSum(self, matrix: List[List[int]]) -> int:
        def dp(matrix, row, col, mamo):
            # 边界情况
            if row < 0 or col < 0 or col >= len(matrix):
                return float("inf")
            # base case
            if row == 0:
                return matrix[row][col]
            if mamo[row][col] != "None":
                return mamo[row][col]
            directions = [(-1, -1), (-1, 1), (-1, 0)]
            min_value = float("inf")
            # 该状态下，遍历所有选择
            for i, j in directions:
                min_value = min(min_value, dp(matrix, row+i, col+j, mamo))
            # 状态转移
            mamo[row][col] = min_value + matrix[row][col]
            return mamo[row][col]
        res = float("inf")
        n = len(matrix)
        # 备忘录，用特殊值初始化，和合法的答案有所区分。标明其未出现过/未被计算过
        mamo = [["None"]*n for _ in range(n)]
        # 终点可能在 matrix[n-1] 的任意⼀列
        for i in range(n):
            res = min(res, dp(matrix, n-1, i, mamo))
        return res

解法2：动态规划

class Solution(object):
    def minFallingPathSum(self, A):
        while len(A) >= 2:
            row = A.pop()            
            for i in range(len(row)):
                A[-1][i] += min(row[max(0,i-1): min(len(row), i+2)])
        return min(A[0])

2049. 统计最高分的节点数目

解法：DFS
对于每个节点，节点的分数计算如下，左子树大小*右子树大小*移除以该节点为根节点的子树后剩余节点数量。因此该题最关键的点在于计算每个节点作为根节点的子树的大小，可以用DFS进行计算，有了这个信息后我们可以很简单的对每个节点的分数进行计算。

class Solution:
    def countHighestScoreNodes(self, parents: List[int]) -> int:
        children = collections.defaultdict(list)
        # 根据parents 数组找到每个节点的左右子节点
        for i, parent in enumerate(parents):
            children[parent].append(i)
        # 存储每个节点的子树大小
        count = [0]*len(parents)
        max_value, res = 0, 1

        def dfs(node):
            value = 1
            for child in children[node]:
                value += dfs(child)
            count[node] = value
            return count[node]

        dfs(0)
        for i in range(len(parents)):
            value = 1
            for child in children[i]:
                value *= count[child]
            # 根节点要特殊对待
            if i!= 0:
                value *= (len(parents) - count[i])
            if value == max_value:
                res += 1
            elif value > max_value:
                max_value = value
                res = 1
            # print(value)
        # print(max_value)
        return res