每天一道算法题之矩阵中最长递增路径

题目描述：

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

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

示例 1:

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

• 寻路：寻找最大递增路径的长度
• 减少搜索时间，采用备忘录进行优化；int[][] memo记录当前位置最大递增路径数
• 模板:也可以作为寻路的模板框架，相比于一般的寻路模板，多一个备忘录(记录已查找过得点，避免重复计算)模板

public int dps(int[][] matrix,int,x,int y){
    if(当前位置已经查找过，即当前位置在备忘录中的值非0)
        return memo[x][y];
    
    //对当前位置的操作
    memo[x][y] ++;//当前位置作为路径中一个节点，路径数加一
    
    //搜索范围
    int[] nx = new int[]{0,0,1,-1};
    int[] ny = new int[]{1,-1,0,0};
    for(int i = 0; i< 4;i++){
        //检查下一次选择的合理性，即不超过矩阵索引范围，还有一个就是要保证是递增
        //对于一般的寻路模板，只需检查不越界即可
        if(newx >= 0 && newx < matrix.length &&
            newy >= 0 && newy < matrix[0].length&& matrix[x][y] < matrix[newx][newy]){
            memo[x][y] = Math.max(memo[x][y],dps(matrix,newx,newy)+1);
        }
    }
}

• 代码：

   public int[][] memo;//存储当前位置最大递增路径数
    public int longestIncreasingPath(int[][] matrix) {
        int m = matrix.length;
        if(m == 0) return 0;
                
        int n = matrix[0].length;
        memo = 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,dps(matrix,i,j));
            }
        }
        return res;

    }
    public int dps(int[][] matrix,int x,int y){
        //检查备忘录
        if(memo[x][y] != 0) return memo[x][y];
        //当前点操作
        memo[x][y] += 1;
		//下一次查找范围
        int[] nx = new int[]{1,-1,0,0};
        int[] ny = new int[]{0,0,1,-1};
        for(int i = 0;i < 4;i++){
            int newx = x + nx[i];
            int newy = y + ny[i];
            //检查新点合理性，对于合理的点进行下一次查找
            if(newx >= 0 && newx < matrix.length &&
            newy >= 0 && newy < matrix[0].length&& matrix[x][y] < matrix[newx][newy]){
                memo[x][y] = Math.max(memo[x][y],dps(matrix,newx,newy)+1); 
            }
        }
        return memo[x][y];
    }

---

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