常考数据结构与算法:最大正方形

题目描述

给定一个由0和1组成的2维矩阵，返回该矩阵中最大的由1组成的正方形的面积

 

示例1

输入

[[1,0,1,0,0],[1,0,1,1,1],[1,1,1,1,1],[1,0,0,1,0]]

返回值

4

 

import java.util.HashMap;

public class SquareMe {
    public static void main(String[] args) {
        char [] [] matrix = {
                {'1','0','1','0','0'},
                {'0','0','1','1','1'},
                {'1','0','1','1','1'},
                {'0','0','0','0','0'},
                {'1','0','0','1','0'}
        };

        SquareMe squareMe = new SquareMe();
        System.out.println(squareMe.solve(matrix));
    }

    //在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。
    //暴力求解
    public int find_maximalSquare(char[][]matrix){
        int maxSide = 0;
        if (matrix==null || matrix.length==0|| matrix[0].length==0){
            return maxSide;
        }
        int rows = matrix.length;
        int cols = matrix[0].length;
        for (int i = 0; i <rows ; i++) {
            for (int j = 0; j <cols ; j++) {
                if (matrix[i][j]=='1'){
                    maxSide = Math.max(maxSide,1);
                    //计算可能的最大正方形边长
                    int currentMaxSide = Math.min(rows-i,cols-j);
                    for (int k = 1; k <currentMaxSide ; k++) {
                        //判断新增一行一列是否均为1
                        boolean flag = true;

                        // 如果对角的点不是1，那就形成不了一个正方形
                        if (matrix[i+k][j+k] == '0'){
                            break;
                        }

                        // 如果对角的点是1, 那么再判断边上的点是不是1,如果是1,那么就能组成一个正方形
                        for (int m = 0; m <k ; m++) {
                            if (matrix[i+k][j+m]=='0' || matrix[i+m][j+k]=='0'){
                                flag = false;
                                break;
                            }
                        }

                        if (flag){
                            maxSide = Math.max(maxSide,k+1);
                        }else {
                            break;
                        }
                    }
                }
            }
        }
        return maxSide* maxSide;
    }

    /**
     *
     * [1,0,1,0,0]
     * [1,0,1,1,1]
     * [1,1,1,1,1]
     * [1,0,0,1,0]
     *
     * 动态规划
     *
     * 最大正方形
     * @param matrix char字符型二维数组
     * @return int整型
     */
    public int solve (char[][] matrix) {
        int maxSide=0;
        if (matrix==null || matrix.length==0||matrix[0].length==0){
            return maxSide;
        }
        int rows = matrix.length,cols=matrix[0].length;
        int [][]dp=new int[rows][cols];
        for (int i = 0; i <rows ; i++) {
            for (int j = 0; j <cols ; j++) {
                if (matrix[i][j] =='1'){
                    // 动态规划 每次是1,就记录下此时的状态,以便下次使用
                    if (i==0 || j==0){
                        dp[i][j]=1;
                    }else {
                        dp[i][j] = Math.min(Math.min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1])+1;
                    }
                    maxSide = Math.max(maxSide,dp[i][j]);
                }
            }
        }
        return maxSide*maxSide;
    }
}