力扣329 矩阵中的最长递增路径

 方法一：dfs（效率更高）

思路：遍历二维数组，首先检查下标是否正确，其次设置了pre的值，用于存储上一个结点的值，visited数组中，visited[i][j]表示以matrix[i][j]为起点的最大路径长度，将matrix的每个数都作为路径的起点进行深度优先遍历，每访问一个起点，计算以它的上下左右为起点的最长路径是多少，取四个值中的最大值加一，得到当前数做起点的最大路径长度。

其中需要判断visited[i][j]是否为0，因为如果不为0，说明这个点已经被访问过了，visited[i][j]的值已经是当前的最大路径长度，可以直接返回。

public int longestIncreasingPath(int[][] matrix) {
        int m=matrix.length;
        int n=matrix[0].length;
        int[][] visited=new int[m][n];
        int res=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                res=Math.max(res,dfs(matrix,i,j,visited,Integer.MIN_VALUE));
            }
        }
        return res;
    }

    private int dfs(int[][] matrix,int i,int j,int[][] visited,int pre){
        if(i<0||i>=matrix.length||j<0||j>=matrix[0].length||pre>=matrix[i][j]) return 0;
        if(visited[i][j]!=0) return visited[i][j];
        int left=dfs(matrix,i,j-1,visited,matrix[i][j]);
        int right=dfs(matrix,i,j+1,visited,matrix[i][j]);
        int top=dfs(matrix,i-1,j,visited,matrix[i][j]);
        int down=dfs(matrix,i+1,j,visited,matrix[i][j]);
        visited[i][j]=Math.max(Math.max(left,right),Math.max(top,down))+1;
        return visited[i][j];
    }

方法二：排序+动态规划

思路：先创建dp数组，dp[i][j]表示以matrix[i][j]为结尾的最长路径，将所有点放入list中进行排序，然后遍历list中的每个节点，访问当前节点的上下左右并比较大小得到最终值。

class Solution {
    public int longestIncreasingPath(int[][] matrix) {
        if(matrix.length ==0 || matrix[0].length==0)return 0;
        int m=matrix.length;
        int n = matrix[0].length;
        List<Node> list = new ArrayList<>(m*n);
        int[][] dp = new int[m][n];//dp[i][j]表示以matrix[i][j]结尾的最长递增长度
        for(int i = 0 ; i<m;i++){
            for(int j = 0;j<n;j++){
                dp[i][j]=1;
                list.add(new Node(matrix[i][j], i , j));
            }
        }
        Collections.sort(list, new Comparator<Node>(){
            @Override
            public int compare(Node n1, Node n2){
                return n1.val-n2.val;
            }
        });
        int[][] dirs = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};//四个方向
        //按val从小到大的顺序找。试想遍历到val=x时，由于所有小于x的都求出dp了，所以x此时可求最优解，因为x的最优解只依赖于所有小于x的值。大于x的对于求x的递增路径没有关系
        int result = 1;
        for(Node node : list){
            int i = node.i;
            int j = node.j;
            for(int[] dir:dirs){
                int r=node.i+dir[0];
                int c= node.j+dir[1];
                if(r>=0&&r<m&&c>=0&&c<n&&matrix[i][j]>matrix[r][c]){
                    dp[i][j] = Math.max(dp[i][j], 1+dp[r][c]);
                }
                result=Math.max(result, dp[i][j]);
            }
        }
        return result;
    }

    class Node{
        int i;
        int j;
        int val;
        public Node(int val,int i,int j){
            this.i=i;
            this.j=j;
            this.val=val;
        }
    }
}