[329. 矩阵中的最长递增路径]

[329. 矩阵中的最长递增路径]

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

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

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

思路：记忆化搜索，也可以用拓扑排序来做，这里用的时BFS，用DFS会更快

public int longestIncreasingPath(int[][] matrix) {
        
        int max = 0;
        int n = matrix.length;

        if(n == 0){
            return max;
        }

        int m = matrix[0].length;
        //方向数组
        int[][] dir = new int[][]{
                {0,1},{0,-1},{1,0},{-1,0}
        };

        //存放每次搜索后以当前位置为起点的最长路径长度
        int[][] val = new int[n][m];
        for (int i = 0; i < val.length; i++) {
            for (int j = 0; j < val[0].length; j++) {
                val[i][j] = 1;
            }
        }
        //这里用了优先队列，其实用不用差别不大
        Queue<int[]> q = new PriorityQueue<>((m1, m2) -> m2[2] - m1[2]);

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                    q.offer(new int[]{i, j, 1});
            }
        }
        max = 1;
        while (!q.isEmpty()){

            int[] tmp = q.poll();

            for (int i = 0; i < 4; i++) {

                int sx = tmp[0]+dir[i][0];
                int sy = tmp[1]+dir[i][1];

                //边界判断，并且下一个位置必须比当前位置小，且val要大于下一个位置
                if(sx >= 0 && sx < n && sy >= 0 && sy < m && matrix[tmp[0]][tmp[1]] > matrix[sx][sy] && val[tmp[0]][tmp[1]] >= val[sx][sy] ){

                    val[sx][sy] = val[tmp[0]][tmp[1]]+1;
                    q.offer(new int[]{sx ,sy, val[sx][sy]});
                    max = Math.max(max, val[sx][sy]);

                }

            }

        }
        return max;
    }