矩阵中的最长递增路径java实现

矩阵中的最长递增路径

https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix/

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

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

示例 1:

输入: nums = 
[
  [9,9,4],
  [6,6,8],
  [2,1,1]
] 
输出: 4 
解释: 最长递增路径为 [1, 2, 6, 9]。
示例 2:

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

方法一：DFS深度优先遍历，会超时

class Solution {
    int maxvalue=0;
    public int longestIncreasingPath(int[][] matrix) {
        if(matrix==null||matrix.length==0||matrix[0].length==0){
            return 0;
        }
        int res=0;
        int row=matrix.length;
        int col=matrix[0].length;
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                //每次最大长度初值复位0
                maxvalue=0;
                res=Math.max(res,DFS(matrix,i,j,row,col,0));
            }
        }
        return res+1;
    }
    public int DFS(int[][] matrix,int i,int j,int row,int col,int res){
        //当四周的点都不满足递增时DFS到底，返回当前长度
        if(!find(matrix,i,j,row,col)){
            maxvalue=Math.max(maxvalue,res);
            return maxvalue;
        }
        //上方点递增，递归DFS，长度加1
        if(i-1>=0&&matrix[i-1][j]>matrix[i][j]){
            DFS(matrix,i-1,j,row,col,res+1);
        }
        //下方点递增，递归DFS，长度加1
        if(i+1<row&&matrix[i+1][j]>matrix[i][j]){
            DFS(matrix,i+1,j,row,col,res+1);
        }
        //左侧点递增，递归DFS，长度加1
        if(j-1>=0&&matrix[i][j-1]>matrix[i][j]){
            DFS(matrix,i,j-1,row,col,res+1);
        }
        //右侧点递增，递归DFS，长度加1
        if(j+1<col&&matrix[i][j+1]>matrix[i][j]){
           DFS(matrix,i,j+1,row,col,res+1);
        }
        //返回当前最大长度
        return maxvalue;
    }
    //判断四周点是否满足递增
    public boolean find(int[][] matrix,int i,int j,int row,int col){
        if(i-1>=0&&matrix[i-1][j]>matrix[i][j]){
            return true;
        }
        if(i+1<row&&matrix[i+1][j]>matrix[i][j]){
            return true;
        }
        if(j-1>=0&&matrix[i][j-1]>matrix[i][j]){
            return true;
        }
        if(j+1<col&&matrix[i][j+1]>matrix[i][j]){
            return true;
        }
        return false;
    }
}

方法二：DFS+记忆化搜索

class Solution {
    public int longestIncreasingPath(int[][] matrix) {
        if(matrix==null||matrix.length==0||matrix[0].length==0){
            return 0;
        }
        int row=matrix.length;
        int col=matrix[0].length;
        //dp[i][j]为以(i,j)为起点的最长递增路径长度，实现记忆化
        int[][]dp=new int[row][col];
        int res=0;
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                //查询每个点为起点的最大长度
                res=Math.max(res,DFS(matrix,i,j,Integer.MIN_VALUE,dp));
            }
        }
        return res;
    }
    public int DFS(int[][] matrix,int i,int j,int cur,int[][]dp){
        int row=matrix.length;
        int col=matrix[0].length;
        //当该点不满足递增时返回
        if(i<0||i>=row||j<0||j>=col||matrix[i][j]<=cur){
            return 0;
        }
        //之前已求过的可以直接返回
        if(dp[i][j]!=0){
            return dp[i][j];
        }
        //每个点为起点的初始长度0
        int max=0;
        //分别求上下左右四个点
        max=Math.max(max,DFS(matrix,i-1,j,matrix[i][j],dp));
        max=Math.max(max,DFS(matrix,i+1,j,matrix[i][j],dp));
        max=Math.max(max,DFS(matrix,i,j-1,matrix[i][j],dp));
        max=Math.max(max,DFS(matrix,i,j+1,matrix[i][j],dp));
        //求解完当前点最大长度将其赋值给dp
        dp[i][j]=max+1;
        //返回最大值
        return max+1;
    }
}