Leetcode 01 矩阵问题中的优化DFS

问题描述

我正在尝试使用 DFS 解决 LeetCode 中的 01 矩阵问题 https://leetcode.com/problems/01-matrix/。我的天真的 DFS 解决方案超出了时间限制。我用记忆优化了它。但是，解决方案并不正确。代码如下，谁能帮我找出我的代码的哪一部分有问题？我还在下面附上了天真的 DFS 解决方案。

    import java.util.Arrays

    //This is buggy optimized DFS Solution
    public class Solution {
    public int[][] updateMatrix(int[][] matrix) {
        int m = matrix.length,n = matrix[0].length;
        int[][] dp = new int[m][n];
        for (int[] row : dp) {
            Arrays.fill(row,Integer.MAX_VALUE);
        }
        boolean[][] marked;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                marked = new boolean[m][n];
                dp[i][j] = DFS(matrix,dp,i,j,marked);
            }
        }
        return dp;
    }

    public int DFS(int[][] matrix,int[][] dp,int i,int j,boolean[][] marked) {
        if (i < 0 || i >= matrix.length || j < 0 || j >= matrix[0].length || marked[i][j]) {
            return 10001;
        }
        if (matrix[i][j] == 0) {
            return 0;
        }
        if (dp[i][j] != Integer.MAX_VALUE) {
            return dp[i][j];
        }
        marked[i][j] = true;
        int up = 1 + DFS(matrix,i - 1,marked);
        int down = 1 + DFS(matrix,i + 1,marked);
        int vertical = Math.min(up,down);
        int left = 1 + DFS(matrix,j - 1,marked);
        int right = 1 + DFS(matrix,j + 1,marked);
        int horizontal = Math.min(left,right);
        int res = Math.min(vertical,horizontal);
        marked[i][j] = false;
        dp[i][j] = Math.min(dp[i][j],res);
        return res;
    }
}

        import java.util.Arrays
        //This is my naive solution
        public class Solution {
        public int[][] updateMatrix(int[][] matrix) {
            int m = matrix.length,n = matrix[0].length;
            int[][] dp = new int[m][n];
            for (int[] row : dp) {
                Arrays.fill(row,Integer.MAX_VALUE);
            }
            boolean[][] marked;
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    marked = new boolean[m][n];
                    dp[i][j] = DFS(matrix,marked);
                }
            }
            return dp;
        }
        public int DFS(int[][] matrix,boolean[][] marked) {
            if (i < 0 || i >= matrix.length || j < 0 || j >= matrix[0].length || marked[i][j]) {
                return 10001;
            }
            if (matrix[i][j] == 0) {
                return 0;
            }
            marked[i][j] = true;
            int up = 1 + DFS(matrix,marked);
            int down = 1 + DFS(matrix,marked);
            int vertical = Math.min(up,down);
            int left = 1 + DFS(matrix,marked);
            int right = 1 + DFS(matrix,marked);
            int horizontal = Math.min(left,right);
            int res = Math.min(vertical,horizontal);
            marked[i][j] = false;
            return res;
        }
    }

   

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）