给定一个二维数组matrix，可以从任何位置出发，每一步可以走向上、下、左、右，四个方向，返回最大递增链的长度。

问题描述：

        给定一个二维数组matrix，可以从任何位置出发，每一步可以走向上、下、左、右，四个方向。返回最大递增链的长度。
例子：
matrix = 5 4 3
              3 1 2
              2 1 3
从最中心的1出发，是可以走出1 2 3 4 5的链的，而且这是最长的递增链。所以返回长度5。

思想：

        在二维数组matrix中，从i行j列出发，查找能走出的最大递增路径的方法是：依次查看上下左右各点的最大递增路径取最大值最后加上一即为该点的最大递增路径长度。二维数组的最大递增链长度方法为依次遍历二维数组的每一个位置的最大路径长度，其最大值。

        我们分析整个过程发现有很多位置的值是重复计算的，所以我么可以使用记忆化搜索的方法，使用缓存表记录每一次计算后的值，当下一次使用该位置的值时无需重复计算，直接拿取就可以了。

代码：

暴力方法代码

    public static int maxPath(int[][] matrix) {
        int ans = Integer.MIN_VALUE;
        for (int row = 0; row < matrix.length; row++) {
            for (int col = 0; col < matrix[0].length; col++) {
                ans = Math.max(ans, process1(matrix, row, col));
            }
        }
        return ans;
    }

    //假设在matrix中，从i行j列出发，能走出的最长递增路径，返回最长递增路径的长度
    public static int process1(int[][] matrix, int i, int j) {
        if (i < 0 || i >= matrix.length || j < 0 || j >= matrix[0].length) {
            return -1;
        }
        int up = 0;
        int down = 0;
        int left = 0;
        int right = 0;
        if (i - 1 >= 0 && matrix[i - 1][j] > matrix[i][j]) {
            up = process1(matrix, i - 1, j);
        }
        if (i + 1 < matrix.length && matrix[i + 1][j] > matrix[i][j]) {
            down = process1(matrix, i + 1, j);
        }
        if (j - 1 >= 0 && matrix[i][j - 1] > matrix[i][j]) {
            left = process1(matrix, i, j - 1);
        }
        if (j + 1 < matrix[0].length && matrix[i][j + 1] > matrix[i][j]) {
            right = process1(matrix, i, j + 1);
        }
        return 1 + Math.max(Math.max(up, down), Math.max(left, right));
    }

记忆化搜索代码

    public static int maxPath2(int[][] matrix) {
        int ans = Integer.MIN_VALUE;
        int[][] dp = new int[matrix.length][matrix[0].length];
        for (int row = 0; row < matrix.length; row++) {
            for (int col = 0; col < matrix[0].length; col++) {
                ans = Math.max(ans, process2(matrix, row, col, dp));
            }
        }
        return ans;
    }

    public static int process2(int[][] matrix, int i, int j, int[][] dp) {
        if (i < 0 || i >= matrix.length || j < 0 || j >= matrix[0].length) {
            return -1;
        }
        if (dp[i][j] != 0) {
            return dp[i][j];
        }

        int up = 0;
        int down = 0;
        int left = 0;
        int right = 0;
        if (i - 1 >= 0 && matrix[i - 1][j] > matrix[i][j]) {
            up = process1(matrix, i - 1, j);
        }
        if (i + 1 < matrix.length && matrix[i + 1][j] > matrix[i][j]) {
            down = process1(matrix, i + 1, j);
        }
        if (j - 1 >= 0 && matrix[i][j - 1] > matrix[i][j]) {
            left = process1(matrix, i, j - 1);
        }
        if (j + 1 < matrix[0].length && matrix[i][j + 1] > matrix[i][j]) {
            right = process1(matrix, i, j + 1);
        }
        int ans = 1 + Math.max(Math.max(up, down), Math.max(left, right));
        dp[i][j] = ans;
        return ans;
    }

测试代码

    public static void main(String[] args) {
        int[][] matrix = new int[][]{
                {6,5,4,3},
                {2,3,1,2},
                {1,2,1,3}
        };
        System.out.println(maxPath(matrix));
        System.out.println(maxPath2(matrix));
    }