矩阵中的最长递增路径-困难

问题描述

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

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

示例 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]。注意不允许在对角线方向上移动。

解题思路

深度优先遍历：
1、对矩阵中的每一个元素做一次深度优先遍历，深度从0开始往回递归，递归回来就是该元素对应的最大长度
2、创建一个相同大小的缓存矩阵，用来记录已经遍历过得结点深度，初始都为0
3、当遍历时遇到缓存矩阵中不为0的元素，说明对于此元素已经做过遍历，返回此元素的深度就可，这样避免了对子元素的重复遍历

代码

import java.util.ArrayList;
import java.util.List;

class Solution {
    
    public int longestIncreasingPath(int[][] matrix) {
        if(matrix==null||matrix.length<1){
            return 0;
        }
        int m=matrix.length;
        int n=matrix[0].length;
        int[][] flag=new int[m][n];//缓存数组，记录当前元素的最大深度
        List<Integer> list=new ArrayList<>();
        for (int i=0;i<m;i++){
            for (int j=0;j<n;j++){
                //深度遍历
                list.add(dp(matrix,i,j,flag));
            }
        }
        int max=0;
        for (int i:list
             ) {
            if(i>max){
                max=i;
            }
        }
        return max;
    }

    private int dp(int[][] matrix, int i, int j, int[][] flag) {
        if(flag[i][j]!=0){
            return flag[i][j];
        }
        int a=0;//记录下边的深度
        int b=0;//记录上边的深度
        int c=0;//记录右边的深度
        int d=0;//记录左边的深度
        //下边
        if(i<matrix.length-1&&matrix[i][j]<matrix[i+1][j]){
            a=dp(matrix,i+1,j,flag);
        }
        //上边
        if(i>0&&matrix[i][j]<matrix[i-1][j]){
            b=dp(matrix,i-1,j,flag);
        }
        //右边
        if(j<matrix[0].length-1&&matrix[i][j]<matrix[i][j+1]){
            c=dp(matrix,i,j+1,flag);
        }
        //左边
        if(j>0&&matrix[i][j]<matrix[i][j-1]){
            d=dp(matrix,i,j-1,flag);
        }
        //flag为缓存数组，返回四个方向最大的深度
        return flag[i][j]=Math.max(Math.max(a,b),Math.max(c,d))+1;
    }
}