矩阵中的最长递增路径

矩阵中的最长递增路径

给定一个整数矩阵，找出最长递增路径的长度。
对于每个单元格，你可以往上，下，左，右四个方向移动。
你不能在对角线方向上移动或移动到边界外（即不允许环绕）




题解：
      首先看到这道题，突然想到岛屿那题，每次向着四个方向不断递归
只是条件是只递归比当前数大的数，所以使用深度搜索，并且返回搜索中深度最大的一个，然后就就开始巴拉巴拉一顿操作，测试，没问题，上线，超时，一口老血吐出来（意料中）
所以就做了优化，每次我们都对一个数进行了一次深搜，所以超时的部分其实是很多点都做了重复的计算
那么就借助一个记忆区间记录已经查找过的数，如果当前的数已经计算过，那么就可以在记忆区直接拿，不用再次计算

public class longestIncreasingPath {
	//记忆区间
    public static int[][] memo;
    public static int longestIncreasingPath(int[][] matrix){
        if (matrix==null||matrix.length==0){
            return 0;
        }
        int ans=0;
        memo=new int[matrix.length][matrix[0].length];
        for (int i=0;i<matrix.length;i++){
            for (int j=0;j<matrix[0].length;j++){
            //寻找每一个点的最大递增路径数
                ans=Math.max(ans,dfs(matrix,i,j));
            }
        }
        return ans;
    }
    private static int dfs(int[][] matrix,int r,int c){
        if (r<0||c<0||r>matrix.length||c>matrix[0].length){
            return 0;
        }
        int top=0;
        int bottom=0;
        int left=0;
        int right=0;
        //向上递归
        if (matrix[r][c]!=-1&&r>=1&&matrix[r-1][c]>matrix[r][c]){
           //如果要递归的点已经计算过最大递增数那么直接取数就行，否则递归
            if (memo[r-1][c]!=0){
                top=memo[r-1][c];
            }else {
                top=dfs(matrix,r-1,c);
            }

        }
        //向下递归
        if (matrix[r][c]!=-1&&r<=matrix.length-2&&matrix[r+1][c]>matrix[r][c]){
            if (memo[r+1][c]!=0){
                bottom=memo[r+1][c];
            }else {
                bottom=dfs(matrix,r+1,c);
            }
        }
        //向左递归
        if (matrix[r][c]!=-1&&c>=1&&matrix[r][c-1]>matrix[r][c]){
            if (memo[r][c-1]!=0){
                left=memo[r][c-1];
            }else {
                left=dfs(matrix,r,c-1);
            }

        }
        //向右递归
        if (matrix[r][c]!=-1&&c<=matrix[0].length-2&&matrix[r][c+1]>matrix[r][c]){
            if (memo[r][c+1]!=0){
                right=memo[r][c+1];
            }else {
                right=dfs(matrix,r,c+1);
            }
        }
        memo[r][c]=Math.max(top,Math.max(bottom,Math.max(left,right)))+1;
        return memo[r][c];
    }
}