221. Maximal Square

最新推荐文章于 2021-04-29 20:57:26 发布

转载最新推荐文章于 2021-04-29 20:57:26 发布 · 64 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/reboot329/p/5870951.html

本文介绍了一种利用滚动数组解决寻找矩阵中最大全1正方形的方法。通过两次实现对比，详细展示了如何优化空间复杂度，并给出了完整的Java代码示例。

最后更新

用DP. Trcky的地方是dp[i][j]保存的是以此格为右下的正方形的最大边长。
格子本身是0,自然就是0= =
不是0的话，他的值取决于3个方向的最小值：上面，左面，左上。分别是dp[i-1][j], dp[i][j-1], dp[i-1][j-1]。

用2D dp array记录的话，每次3个方向选最小+1。

然后用滚动2D array...

滚动数组需要注意设定每个方向的初始状态，剩下的用%连脑子都不用动。。

第一行另算，每行第一个另算。。

public class Solution {
    public int maximalSquare(char[][] matrix) {
        if (matrix.length <= 0) return matrix.length;
        
        int row = matrix.length;
        int col = matrix[0].length;
        
        int[][] dp = new int[2][col];
        
        int res = 0;
        
        for (int j = 0; j < col; j++) {
            dp[0][j] = matrix[0][j] - '0';
            res = Math.max(res, dp[0][j]);
        }
        
        for (int i = 1; i < row; i++) {
            
            dp[i%2][0] = matrix[i][0] - '0';
            res = Math.max(dp[i%2][0], res);
            
            for (int j = 1; j < col; j++) {
                if (matrix[i][j] == '0') {
                    dp[i%2][j] = 0;
                } else {
                    dp[i%2][j] = Math.min(dp[(i-1)%2][j], Math.min(dp[i%2][j-1], dp[(i-1)%2][j-1])) + 1;
                }
                res = Math.max(dp[i%2][j], res);
            }
        }
        
        return res * res;
        
    }
}

这个题做得不好。

一开始尝试滚动DP数组，失败，就决定先算普通的，结果太不细心，瞎鸡巴做。

dp[i][j]为i,j为右下角坐标的正方形，他的值取决于(i,j-1), (i-1,j), (i-1, j-1)中最小的一个。

当然如果他自己(i,j)是0，那就是0.

public class Solution {
    public int maximalSquare(char[][] matrix) {
        if (matrix.length == 0) return 0;
        
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] dp = new int[m][n];
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == '0') {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = 1;
                }
            }
        }
        
        int res = 0;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (dp[i][j] != 0) {
                    dp[i][j] = Math.min(dp[i-1][j], Math.min(dp[i][j-1], dp[i-1][j-1])) + 1;
                    res = Math.max(res, dp[i][j]);
                }
            }
        }
        
        return res * res;
    }
}

最后返还结果是边长 *　边长，我返还一个边长然后debug半天。

现在试试滚动数组。

首先要知道不需要保存二维，保存两行就行了，然后每行使用滚动数组。

public class Solution {
    public int maximalSquare(char[][] matrix) {
        if (matrix.length == 0) return 0;
        int m = matrix.length;
        int n = matrix[0].length;
        
        int[][] dp = new int[2][n];
        
        int res = 0;
        for (int j = 0; j < n; j++) {
            dp[0][j] = matrix[0][j] - '0';
            res = Math.max(dp[0][j], res);
        }
        
        for (int i = 1; i < m; i++) {
            dp[i%2][0] = matrix[i][0] - '0';
            res = Math.max(dp[i%2][0], res);
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] == '0') {
                    dp[i % 2][j] = 0;
                } else {
                    dp[i % 2][j] = Math.min(dp[(i-1) % 2][j], 
                                   Math.min(dp[i%2][j-1], dp[(i-1) % 2][j-1])) + 1;
                }
                res = Math.max(dp[i % 2][j], res);
            }
        }
        
        return res * res;
    }
}

转载于:https://www.cnblogs.com/reboot329/p/5870951.html