数据结构与算法:矩阵最长递增路径

描述
给定一个 n 行 m 列矩阵 matrix ，矩阵内所有数均为非负整数。 你需要在矩阵中找到一条最长路径，使这条路径上的元素是递增的。并输出这条最长路径的长度。
这个路径必须满足以下条件：

1. 对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外。
2. 你不能走重复的单元格。即每个格子最多只能走一次。

使用dfs深度遍历

public class RecureSolve {

    int[][] direction = {{-1,0},{1,0},{0,-1},{0,1}};

    int dfs(int i,int j,int[][] dp,int[][] matrix,int r,int c){
        if(dp[i][j] != 0){
            return dp[i][j];
        }

        dp[i][j]++;
        for (int k = 0; k < direction.length; k++) {
            int nexti = i + direction[k][0];
            int nextj = j + direction[k][1];

            if(nexti >= 0 && nexti < r && nextj >=0 && nextj < c && matrix[nexti][nextj] > matrix[i][j]){
                dp[i][j] = Math.max(dp[i][j],dfs(nexti,nextj,dp,matrix,r,c)+1);
            }
        }

        return dp[i][j];
    }

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 递增路径的最大长度
     * @param matrix int整型二维数组 描述矩阵的每个数
     * @return int整型
     */
    public int solve (int[][] matrix) {
        if(matrix == null || matrix[0] == null){
            return 0;
        }

        int r = matrix.length;
        int c = matrix[0].length;

        int[][] dp = new int[r+1][c+1];
        int res = 0;
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                res = Math.max(res,dfs(i,j,dp,matrix,r,c));
            }
        }

        return res;
    }

    public static void main(String[] args) {
        int [][] matrix = {
                {4,3,3,6,6,3,2,1,0,7},
                {1,8,2,8,5,9,2,8,3,1},
                {8,0,9,2,4,3,2,4,3,7},
                {1,2,2,6,3,0,3,9,7,0},
                {7,4,3,8,8,3,2,4,6,8},
                {2,8,9,2,9,3,0,8,7,8},
                {8,9,9,4,6,3,3,4,9,6},
                {2,8,3,8,1,3,7,3,0,7},
                {2,1,1,6,4,1,0,8,1,6},
                {4,1,3,6,3,4,4,4,0,3}};

        RecureSolve solve = new RecureSolve();
        System.out.println(solve.solve(matrix));
    }
}