[LeetCode][H0329]矩阵中最长递增路径（Java）（记忆化搜索）

题目描述：

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

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

示例 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+dp，不多说废话，看示例一

因为要增序列，所以理论上说，我们只要找到每个点   走到它能到达的最大值的  路径长度，记录下来，之后每次走到它，直接用这个值就行了。。

int[][] memo = new int[行数][列数];//用来存储最大能做路长

看示例一：memo

[                       [
  [9,9,4],     memo      [1,1,2],
  [6,6,8],     ===>      [2,2,1],
  [2,1,1]                [3,4,2]
]                       ] 

也就是说，从第一个点开始遍历，dfs查找它能到达的最大点数，存到memo数组中；之后的点dfs到这个点时直接返回memo值。

Java代码（我自己的代码）：30ms

//记忆化搜索
//执行用时 : 30 ms, 在Longest Increasing Path in a Matrix的Java提交中击败了29.14% 的用户
//内存消耗 : 49.2 MB, 在Longest Increasing Path in a Matrix的Java提交中击败了2.94% 的用户
class Solution {
    int row,col;
    int[][] memo;
    int res = 0;
    public int longestIncreasingPath(int[][] matrix) {
        row = matrix.length;
        if(row==0)return 0;
        col = matrix[0].length;
        memo = new int[row][col];
        for(int i=0;i0&&matrix[x-1][y]>matrix[x][y]){
            temp = dfs(matrix,x-1,y)+1;
        }
        //down
        if(xmatrix[x][y]){
            temp = Math.max(temp,dfs(matrix,x+1,y)+1);
        }
        //left
        if(y>0&&matrix[x][y-1]>matrix[x][y]){
            temp = Math.max(temp,dfs(matrix,x,y-1)+1);
        }
        //right
        if(ymatrix[x][y]){
            temp = Math.max(temp,dfs(matrix,x,y+1)+1);
        }
        return memo[x][y]=temp==0?1:temp;
    }
}

更快的Java代码：9ms

//执行用时为 9 ms 的范例
//暂时看不出哪里有大的优化，就是代码量少点了，不理解，，留着以后好好想想
class Solution {
    // 全局dp
    int[][] visited;
    int m, n;

    public int longestIncreasingPath(int[][] matrix) {
        // null情况
        if (matrix.length == 0 || matrix[0].length == 0) return 0;

        // 变量
        m = matrix.length;
        n = matrix[0].length;
        int res = 1;
        visited = new int[m][n];
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++){
                if (visited[i][j] != 0) continue;
                res = Math.max(res, dfs(matrix, i, j, Integer.MIN_VALUE));
            }
        }

        return res;
    }

    public int dfs(int[][] matrix, int i, int j, int oldVal){
        // 检查当前坐标是否合法，是否递增
        if (i < 0 || i >= m || j < 0 || j >= n || matrix[i][j] <= oldVal) return 0;
        // 检查当前坐标是否已被访问
        if (visited[i][j] == 0){
            // 对四个方向递归调用dfs
            int curVal = matrix[i][j];
            int up = dfs(matrix, i + 1, j, curVal);
            int down = dfs(matrix, i - 1, j, curVal);
            int right = dfs(matrix, i, j + 1, curVal);
            int left = dfs(matrix, i, j - 1, curVal);
            // 设置当前坐标的最长递增路径
            visited[i][j] = 1 + Math.max(Math.max(up, down), Math.max(right, left));
        }

        return visited[i][j];
    }
}