【Leetcode】329. 矩阵中的最长递增路径

题目描述

给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。

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

题解

回溯搜索，其实是可以这样的：

但是时间复杂度会超。

class Solution {
    int[][] direction = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    int[][] matrix;
    int res = 0;
    int row;int col;
    int path = 0;
    
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
            return 0;
        this.matrix = matrix;
        this.row = matrix.length;
        this.col = matrix[0].length;
        boolean[][] marked = new boolean[row][col];
        
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                dfs(marked, i, j);
            }
        }
        return res;
    }
    
    public void dfs(boolean[][] marked, int r, int c) {
        if (r < 0 || r >= row || c < 0 || c >= col || marked[r][c]) {
            return;
        }
        
        marked[r][c] = true;
        path++;
        for (int[] dic : direction) {
            int x = dic[0] + r;
            int y = dic[1] + c;
            if (0 <= x && x < row && 0 <= y && y < col && matrix[x][y] > matrix[r][c]) {
                dfs(marked, x, y);
            }
            res = Math.max(res, path);
        }
        marked[r][c] = false;
        path--;
        
        return;
    }
}

答案是直接用一个矩阵memo记录每个位置能够搜索出来的最长路径，这样后面如果路过这个地方，就不需要再搜索了，而是直接加上记录好的路径。

执行用时：9 ms, 在所有 Java 提交中击败了74.78%的用户

内存消耗：38.8 MB, 在所有 Java 提交中击败了29.80%的用户

class Solution {
    int m = 0;
    int n = 0;
    int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    int[][] memo;
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) 
            return 0;
        this.m = matrix.length;
        this.n = matrix[0].length;
        this.memo = new int[m][n];  // 记录每个出发点所能搜索到的最长路径。这是减少时间复杂度的关键。
        
        int res = 1;  // res默认为1
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                res = Math.max(res, dfs(matrix, i, j));
            }
        }
        return res;
    }
    
    // dfs回溯搜索
    public int dfs(int[][] matrix, int i, int j) {
        if (memo[i][j] > 0)  // 如果memo[i][j]位置已搜索过，则直接返回记录好的memo[i][j]的最长路径
            return memo[i][j];
        int len = 1;  // 路径长度
        for (int[] d : dirs) {
            int x = i + d[0];
            int y = j + d[1];
            if (x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j]) {
                int nextLen = 1 + dfs(matrix, x, y);
                len = Math.max(len, nextLen);
            }
        }
        memo[i][j] = len;
        return len;
    }
}