递归矩阵中的最长递增路径

Question

我正在实现leetcode的最长递增路径问题

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

您可以从每个单元格向四个方向移动：左、右、上或下。您不得沿对角线移动或移动到边界外（即不允许环绕）。

示例 1：

输入：nums = [ [9,9,4], [6,6,8], [2,1,1] ] 输出：4 解释：最长的递增路径是[1, 2, 6, 9].

所以下面是我的实现在递归上尝试了很多，但无法理解为什么它没有给出正确的结果，为什么 maxDist 在这个例子中从 4 减少到 3 再到 2，因为这个变量是全局的而不是局部的。

public class LongestIncreasingPath {

    private static final int[][] dirs = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
    private int m, n;
    int maxDist;

    public int longestIncreasingPath(int[][] matrix) {
        if (matrix.length == 0)
            return 0;
        m = matrix.length;
        n = matrix[0].length;
        int ans = 1;
        for (int i = 0; i < m; ++i)
            for (int j = 0; j < n; ++j) {
                dfs(matrix, i, j, 1);
                ans = Math.max(ans, maxDist);
            }
        return ans;
    }
    private int dfs(int[][] matrix, int i, int j, int dist) {
        for (int[] d : dirs) {
            int x = i + d[0], y = j + d[1];
            if (0 <= x && x < m && 0 <= y && y < n && matrix[x][y] > matrix[i][j]) {
                maxDist = Math.max(maxDist, dfs(matrix, x, y, dist+1));
            }
        }
        return dist;
    }

    public static void main(String[] args) {
        int[][] nums = { { 9, 9, 4 }, { 6, 6, 8 }, { 2, 1, 1 } };
        LongestIncreasingPath lIP = new LongestIncreasingPath();
        System.out.println(lIP.longestIncreasingPath(nums));
    }
}

Answer 1

以下是一个工作版本，测试了 2 个测试用例（仅）。请注意有关错误和一些结构更改的评论：

public class LongestIncreasingPath {

    private static final int[][] dirs = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
    private int rows, cols;
    //avoid non-volatile class variable that may be updated by more than one thread
    //use local variables instead
    //private int maxDist;

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

        int maxDist = 0; //retain max found
        for (int row = 0; row < rows; ++row) {
            for (int col = 0; col < cols; ++col) {
                //bug fix: use distance (matrix[row][col]) instead of 1
                int  distance = dfs(matrix, row, col, matrix[row][col]);
                maxDist = Math.max(distance, maxDist);
            }
        }
        return maxDist;
    }

    private int dfs(int[][] matrix, int row, int newCol, int dist) {

        int maxDist = dist; 
        for (int[]dir : dirs) {
            int newRow = row + dir[0], y = newCol + dir[1];
            if (0 <= newRow && newRow < rows && 0 <= y && y < cols &&
                                        matrix[newRow][y] > matrix[row][newCol]) {
                //bug fix: //add new distance matrix[x][y] instead of 1
                maxDist = Math.max(maxDist, dfs(matrix, newRow, y, dist + matrix[newRow][y]));
            }
        }
        return maxDist;
    }

    public static void main(String[] args) {

        LongestIncreasingPath lIP = new LongestIncreasingPath();
        int[][] nums = { { 9, 9, 4 },
                         { 6, 6, 8 },
                         { 2, 2, 1 }
                        };
        //printout test case 1
        System.out.println(lIP.longestIncreasingPath(nums));
        nums = new int[][]{ { 5, 6, 7 },
                            { 4, 9, 8 },
                            { 3, 2, 1 }
                        };
        //printout test case 2
        System.out.println(lIP.longestIncreasingPath(nums));
    }
}

递归矩阵中的最长递增路径

Recursion Longest Increasing Path in matrix

java

recursion

depth-first-search