【算法】矩阵中的最长递增路径 （记忆化dfs）

题目

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

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

示例 1：

输入：matrix = [[9,9,4],[6,6,8],[2,1,1]]
输出：4
解释：最长递增路径为 [1, 2, 6, 9]。
示例 2：

输入：matrix = [[3,4,5],[3,2,6],[2,2,1]]
输出：4
解释：最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。
示例 3：

输入：matrix = [[1]]
输出：1

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 200
• 0 <= matrix[i][j] <= 231 - 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix

题解

首先很自然的想到使用dfs求解，但写完后发现超时，所以需要进一步考虑如何优化时间

发现每个格子的数字的最长递增路径是固定的，我们可以求解每个格子之后对结果进行记录，采取记忆化dfs的方式，之后经过记录过的格子无需dfs可直接取得结果。

实现

未采取记忆化的dfs

class Solution {
    private static final int[][] DIRECTIONS = new int[][]{{1,0},{0,1},{-1,0},{0,-1}};
    private int[][] matrix;
    private int rows, cols;

    public int longestIncreasingPath(int[][] matrix) {
        this.rows = matrix.length;
        if (rows == 0) return 0;
        this.cols = matrix[0].length;
        if (cols == 0) return 0;

        this.matrix = matrix;

        int max = Integer.MIN_VALUE;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                max = Math.max(max, dfs(i, j, 0));
            }
        }
        return max;
    }

    private int dfs(int x, int y, int sum) {

        sum++;
        int max = Integer.MIN_VALUE;
        boolean flag = false;
        for (int[] direction: DIRECTIONS) {
            int newX = x + direction[0];
            int newY = y + direction[1];
            if (inMap(newX, newY) && matrix[newX][newY] > matrix[x][y]) {
                flag = true;
                max = Math.max(max, dfs(newX, newY, sum));
            }
        }
        if (flag) return max;
        return sum;
    }

    private boolean inMap(int x, int y) {
        return x >= 0 && x < rows && y >= 0 && y <cols;
    }

}

记忆化dfs （自解）

class Solution {
    private static final int[][] DIRECTIONS = new int[][]{{1,0},{0,1},{-1,0},{0,-1}};
    private int[][] matrix;
    private int[][] marked;
    private int rows, cols;

    public int longestIncreasingPath(int[][] matrix) {
        this.rows = matrix.length;
        if (rows == 0) return 0;
        this.cols = matrix[0].length;
        if (cols == 0) return 0;

        this.matrix = matrix;
        this.marked = new int[rows][cols];

        int max = Integer.MIN_VALUE;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                max = Math.max(max, dfs(i, j));
            }
        }
        return max;
    }

    private int dfs(int x, int y) {

        int res = 1;
        int max = 0;
        for (int[] direction: DIRECTIONS) {
            int newX = x + direction[0];
            int newY = y + direction[1];
            if (inMap(newX, newY) && matrix[newX][newY] > matrix[x][y]) {
                int t;
                if (marked[newX][newY] != 0) {
                    t = marked[newX][newY];
                }else {
                    t = dfs(newX, newY);
                }
                max = Math.max(max, t);
            }
        }
        res += max;
        marked[x][y] = res;
        return res;
    }

    private boolean inMap(int x, int y) {
        return x >= 0 && x < rows && y >= 0 && y <cols;
    }

}

记忆化dfs （代码优化）

class Solution {
    private static final int[][] DIRECTIONS = new int[][]{{1,0},{0,1},{-1,0},{0,-1}};
    private int[][] matrix;
    private int[][] marked;
    private int rows, cols;

    public int longestIncreasingPath(int[][] matrix) {
        this.rows = matrix.length;
        if (rows == 0) return 0;
        this.cols = matrix[0].length;
        if (cols == 0) return 0;

        this.matrix = matrix;
        this.marked = new int[rows][cols];

        int max = Integer.MIN_VALUE;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                max = Math.max(max, dfs(i, j));
            }
        }
        return max;
    }

    private int dfs(int x, int y) {
        if (marked[x][y] != 0) {
            return marked[x][y];
        }

        marked[x][y] = 1;
        for (int[] direction: DIRECTIONS) {
            int newX = x + direction[0];
            int newY = y + direction[1];
            if (inMap(newX, newY) && matrix[newX][newY] > matrix[x][y]) {
                marked[x][y] = Math.max(marked[x][y], dfs(newX, newY) + 1);
            }
        }
        return marked[x][y];
    }

    private boolean inMap(int x, int y) {
        return x >= 0 && x < rows && y >= 0 && y <cols;
    }

}