Una [categoría de tema]

matriz

Dos [dificultad de la pregunta]

dificultad

Tres [número de tema]

85. Rectángulo más grande

Cuatro [descripción del título]

Dada una matriz binaria 2D de filas de tamaño x columnas que contienen solo 0 y 1, encuentre el rectángulo más grande que contenga solo 1 y devuelva su área.

Cinco [ejemplo de tema]

Ejemplo 1:
- Entrada: matriz = [["1","0","1","0","0"],["1","0","1","1","1"],[ "1", "1", "1", "1", "1"], ["1", "0", "0", "1", "0"]]
- Salida: 6
- Explicación: El rectángulo más grande se muestra en la figura de arriba.
Ejemplo 2:
- Entrada: matriz = []
- salida: 0
Ejemplo 3:
- Entrada: matriz = [["0"]]
- salida: 0
Ejemplo 4:
- Entrada: matriz = [["1"]]
- Salida: 1
Ejemplo 5:
- Entrada: matriz = [["0","0"]]
- salida: 0

Seis [mensaje de tema]

$filas__== matriz_____longitud_____$
$co l s == matriz [0] .____longitud_____$
$1 <= fila,_co l s <= 200$
$ma t r i x [i] [j] es^{'} 0^{'} o^{'} 1^{'}$

Siete [ideas para resolver problemas]

Primero cree una matriz auxiliar a la izquierda para registrar el número de '1' consecutivos a la izquierda de cada posición
Luego, para cada punto en la matriz bidimensional, calculamos el área del rectángulo con este punto como la esquina inferior derecha, usamos el método de "expansión hacia arriba", el ancho de la matriz es el ancho más corto en el proceso de "expansión hacia arriba", y la altura pasa a través de la actual Reste la posición atravesada de la posición y agregue uno (porque la matriz comienza a contar desde cero)
Luego obtenga el área del rectángulo más grande comparando el máximo
Finalmente devuelve el resultado.

Ocho 【Frecuencia de tiempo】

Complejidad del tiempo: $O(m^2n)$ , $m y n$ son el número de filas y columnas de la matriz bidimensional entrante, respectivamente
Complejidad del espacio: $O (mn)$ ， $m y n$ son el número de filas y columnas de la matriz bidimensional entrante, respectivamente

Nueve [implementación de código]

Versión del lenguaje Java

class Solution {
    
    
    public int maximalRectangle(char[][] matrix) {
    
    
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] left = new int[m][n];
        for(int i = 0;i < m;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                if(matrix[i][j] == '1'){
    
    
                    left[i][j] = (j == 0 ? 0 : left[i][j - 1]) + 1;
                }
            }
        }
        int res = 0;
        for(int i = 0;i < m;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                if(matrix[i][j] == '0'){
    
    
                    continue;
                }
                int width = left[i][j];
                int area = width;
                for(int k = i - 1;k >= 0;k--){
    
    
                    width = Math.min(width, left[k][j]);
                    area = Math.max(area,(i - k + 1) * width);
                }
                res = Math.max(res, area);
            }
        }
        return res;
    }
}

Versión en lenguaje C

int maximalRectangle(char** matrix, int matrixSize, int* matrixColSize)
{
    
    
    int m = matrixSize;
    int n = matrixColSize[0];
    int** left = (int **)malloc(sizeof(int*) * m);
    for(int i = 0;i < m;i++)
    {
    
    
        left[i] = (int*)calloc(n, sizeof(int));
    }
    for(int i = 0;i < m;i++)
    {
    
    
        for(int j = 0;j < n;j++)
        {
    
    
            if(matrix[i][j] == '1')
            {
    
    
                left[i][j] = (j == 0 ? 0 : left[i][j - 1]) + 1;
            }
        }
    }
    int res = 0;
    for(int i = 0;i < m;i++)
    {
    
    
        for(int j = 0;j < n;j++)
        {
    
    
            if(matrix[i][j] == '0')
            {
    
    
                continue;
            }
            int width = left[i][j];
            int area = width;
            for(int k = i - 1;k >= 0;k--)
            {
    
    
                width = fmin(width, left[k][j]);
                area = fmax(area, (i - k + 1) * width);
            }
            res = fmax(res, area);
        }
    }
    return res;
}

Versión en lenguaje Python

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        m = len(matrix)
        n = len(matrix[0])
        left = [[0 for _ in range(n)] for _ in range (m)]
        for i in range(0, m):
            for j in range(0, n):
                if matrix[i][j] == '1':
                    left[i][j] = (0 if j == 0 else left[i][j - 1]) + 1
        res = 0
        for i in range(0, m):
            for j in range(0, n):
                if matrix[i][j] == '0':
                    continue
                width = left[i][j]
                area = width
                for k in range(i - 1, -1, -1):
                    width = min(width, left[k][j])
                    area = max(area, (i - k + 1) * width)
                res = max(res, area)
        return res

Versión del lenguaje C++

class Solution {
    
    
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
    
    
        int m = matrix.size();
        int n = matrix[0].size();
        vector<vector<int>> left(m, vector<int>(n, 0));
        for(int i = 0;i < m;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                if(matrix[i][j] == '1'){
    
    
                    left[i][j] = (j == 0 ? 0 : left[i][j - 1]) + 1;
                }
            }
        }
        int res = 0;
        for(int i = 0;i < m;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                if(matrix[i][j] == '0'){
    
    
                    continue;
                }
                int width = left[i][j];
                int area = width;
                for(int k = i - 1;k >= 0;k--){
    
    
                    width = fmin(width, left[k][j]);
                    area = fmax(area, (i - k + 1) * width);
                }
                res = fmax(res, area);
            }
        }
        return res;
    }
};