题解 | #矩阵的最小路径和#

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param matrix int整型二维数组 the matrix
     * @return int整型
     */
    public int minPathSum (int[][] matrix) {
        // write code here
        // 算法核心思想：记忆化搜索

        // dp[i][j]表示当位置落在i,j上时，到n-1,m-1位置的最小路径和
        // 初始化-1
        int[][] dp = new int[matrix.length][matrix[0].length];
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < dp[0].length; j++) {
                dp[i][j] = -1;
            }
        }

        return process(matrix, 0, 0, dp);
    }

    public int process (int[][] matrix, int i, int j, int[][] dp) {
        int m = matrix.length;
        int n = matrix[0].length;
        // 递归出口
        if (i == m - 1 && j == n - 1) {
            dp[i][j] = matrix[i][j];
            return dp[i][j];
        }

        // 递归分支
        if (dp[i][j] != -1) {
            return dp[i][j];
        }
        // 往下走
        // 若不能往下走，则d也不影响Math.min(d, r)的取值
        int d = Integer.MAX_VALUE;
        if (i < m - 1) {
            // 不会越界，可以走
            if (dp[i + 1][j] == -1) {
                dp[i + 1][j] = process(matrix, i + 1, j, dp);
            }
            // 本位值路径和 = 向下走之后的路径和 + 本位值路径值
            d = dp[i + 1][j] + matrix[i][j];
        }
        // 往右走
        // 若不能往右走，则r也不影响Math.min(d, r)的取值
        int r = Integer.MAX_VALUE;
        if (j < n - 1) {
            // 不会越界，可以走
            if (dp[i][j + 1] == -1) {
                dp[i][j + 1] = process(matrix, i, j + 1, dp);
            }
            // 本位值路径和 = 向右走之后的路径和 + 本位值路径值
            r = dp[i][j + 1] + matrix[i][j];
        }

        // 本位置的走法，等于向右走的走法 + 向下走的走法
        dp[i][j] = Math.min(d, r);
        return dp[i][j];
    }
}