96 矩阵中的最长递增路径

转载：https://blog.csdn.net/zangdaiyang1991/article/details/94560545
96 矩阵中的最长递增路径

作者: Turbo时间限制: 1S章节: 宽度优先搜索

问题描述 :

给定一个整数矩阵，找出最长递增路径的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

示例 1:

输入矩阵:

[9,9,4],

[6,6,8],

[2,1,1]

输出: 4

解释: 最长递增路径为 [1, 2, 6, 9]。

示例 2:

输入:

[3,4,5],

[3,2,6],

[2,2,1]

输出: 4

解释: 最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

输入说明 :

首先输入两个整数m和n， m<=50, n<=50

然后输入m行，每行n个整数，表示m*n矩阵的元素

行内元素之间用空格分隔。

输出说明 :

输出一个整数，表示结果

输入范例 :

3 3
9 9 4
6 6 8
2 1 1
输出范例 :

4

import java.util.Scanner;

public class test_96 {
    /**
     * 96 矩阵中的最长递增路径
     * /**
     * 思路：
     * DFS+dp
     * 1、dp[i][j]表示数组中以(i,j)为起点的最长递增路径的长度，初始将dp数组都赋为0，
     * 2、递归调用时，遇到某个位置(x, y), 如果dp[x][y]不为0的话，我们直接返回dp[x][y]即可，不需要重复计算。
     * 3、以数组中每个位置都为起点调用递归来做，比较找出最大值。在以一个位置为起点用DFS搜索时，对其四个相邻位置进行判断，
     * 如果相邻位置的值大于上一个位置，则对相邻位置继续调用递归，并更新一个最大值，搜素完成后返回即可
     */
    private static int[][] paths = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        sc.nextLine();
        int[][] arr = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = Integer.valueOf(sc.next().trim());
            }
            //sc.nextLine();
        }
        System.out.println(maxPath(arr));
    }

    public static int maxPath(int[][] matrix) {
        if (matrix == null || matrix.length <= 0 || matrix[0].length <= 0) {
            return 0;
        }
        int max = 0;
        int row = matrix.length;
        int col = matrix[0].length;
        int[][] dp = new int[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                max = Math.max(max, dfs(matrix, dp, row, col, i, j));
            }
        }
        return max;
    }


    private static int dfs(int[][] matrix, int[][] dp, int row, int col, int i, int j) {
        if (dp[i][j] > 0) {
            return dp[i][j];
        }
        int max = 1;
        for (int[] path : paths) {
            int x = i + path[0];
            int y = j + path[1];
            // 可以继续搜索
            if (x >= 0 && x < row && y >= 0 && y < col && matrix[x][y] > matrix[i][j]) {
                int len = 1 + dfs(matrix, dp, row, col, x, y);
                max = Math.max(max, len);
            }
        }
        dp[i][j] = max;
        return max;
    }
}