Leetcode 931.下降路径最小和Java&Python

给定一个方形整数数组 A，我们想要得到通过 A 的下降路径的最小和。

下降路径可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列。

 

示例：

输入：[[1,2,3],[4,5,6],[7,8,9]]
输出：12
解释：
可能的下降路径有：

• [1,4,7], [1,4,8], [1,5,7], [1,5,8], [1,5,9]
• [2,4,7], [2,4,8], [2,5,7], [2,5,8], [2,5,9], [2,6,8], [2,6,9]
• [3,5,7], [3,5,8], [3,5,9], [3,6,8], [3,6,9]

和最小的下降路径是 [1,4,7]，所以答案是 12。

 

提示：

1. 1 <= A.length == A[0].length <= 100
2. -100 <= A[i][j] <= 100

分析：和之前博客介绍的动态规划题目思路一样，从上到下直接思考状态转移方程可能对于不是很熟悉动态规划的同学来讲有点困难，这时我们不妨先试试从下到上用递归的方式去思考问题，我们不妨先设计出递归函数，然后一步步的去分析问题。这道题目，寻找的是最小下降路径，那么我们只需要知道下降到level-1层的最小路径，就可以根据第level层的花费，计算出下降到level层的最小路径，所以定义递归函数getPathSumList（int[][] A, int level）来保存下降到level层级的最小路径。

Java递归代码：

public int minFallingPathSum(int[][] A) {
        if (A.length == 0 || A[0].length == 0) {
            return 0;
        }

        return Collections.min(getPathSumList(A, A.length - 1));
    }

    //保存下降到level层级的最小路径
    private List<Integer> getPathSumList(int[][] A, int level) {
        if (level == 0) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < A[0].length; i++) {
                list.add(A[0][i]);
            }
            return list;
        }

        List<Integer> list = new ArrayList<>();
        List<Integer> sumList = getPathSumList(A, level - 1);

        for (int i = 0; i < sumList.size(); i++) {
            if (i == 0) {
                list.add(Math.min(sumList.get(i), sumList.get(i + 1)) + A[level][i]);
            } else if (i == sumList.size() - 1) {
                list.add(Math.min(sumList.get(i), sumList.get(i - 1)) + A[level][i]);
            } else {
                list.add(Math.min(Math.min(sumList.get(i + 1), sumList.get(i - 1)), sumList.get(i)) + A[level][i]);
            }
        }

        System.out.println(list);

        return list;
    }

在有了上面的递归代码之后，状态转移方程就很明显了，此时，我们可以从上往下的写出动态规划的代码

Java：

public int minFallingPathSum(int[][] A) {
        if (A.length == 0 || A[0].length == 0) {
            return 0;
        }

        int[][] res = new int[A.length][A[0].length];

        for (int i = 0; i < A[0].length; i++) {
            res[0][i] = A[0][i];
        }

        for (int i = 1; i < A.length; i++) {
            for (int j = 0; j < A[i].length; j++) {
                if (j == 0) {
                    res[i][j] = Math.min(res[i - 1][j + 1], res[i - 1][j]) + A[i][j];
                } else if (j == A[i].length - 1) {
                    res[i][j] = Math.min(res[i - 1][j - 1], res[i - 1][j]) + A[i][j];
                } else {
                    res[i][j] = Math.min(Math.min(res[i - 1][j + 1], res[i - 1][j - 1]), res[i - 1][j]) + A[i][j];
                }
            }
        }

        int min = Integer.MAX_VALUE;

        for(int i = 0; i < res[res.length - 1].length; i++) {
            if(res[res.length - 1][i] < min) {
                min = res[res.length - 1][i];
            }
        }

        return min;
    }

Python：

def minFallingPathSum(self, A):
        """
        :type A: List[List[int]]
        :rtype: int
        """
        if not A : return 0
        
        res = [[0 for i in range(len(A))] for j in range(len(A))]
        
        for i in range(len(A[0])) :
            res[0][i] = A[0][i]
        
        for i in range(1, len(A)) :
            for j in range(len(A[i])) :
                if j == 0 :
                    res[i][j] = min(res[i - 1][j + 1], res[i - 1][j]) + A[i][j]
                elif j == len(A[i]) - 1 :
                    res[i][j] = min(res[i - 1][j - 1], res[i - 1][j]) + A[i][j]
                else :
                    res[i][j] = min(res[i - 1][j - 1], res[i - 1][j], res[i - 1][j + 1]) + A[i][j]
        
        return min(res[len(A) - 1])