Descripción del Título
En una matriz bidimensional compuesta por 0 y 1, encuentre el cuadrado más grande que contenga solo 1 y devuelva su área.
Ejemplo:
Entrada:
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 1 0 0 1 0
Salida: 4
Código pasado
(1) Mi código
class Solution {
public:
int maximalSquare(vector<vector<char>>& matrix) {
int row=matrix.size();
if(row==0)
return 0;
int col=matrix[0].size();
int dp[row+10][col+10];
int ans;
int anss;
int mid;
int flag;
ans=matrix[0][0]-'0';
for(int i=0;i<row;i++)
{
dp[i][0]=matrix[i][0]-'0';
if(dp[i][0]>ans)
ans=dp[i][0];
}
for(int j=0;j<col;j++)
{
dp[0][j]=matrix[0][j]-'0';
if(dp[0][j]>ans)
ans=dp[0][j];
}
for(int i=1;i<row;i++)
for(int j=1;j<col;j++)
{
mid=dp[i-1][j-1];
dp[i][j]=matrix[i][j]-'0';
if(mid!=0&&matrix[i][j]!='0')
{
for(int k=1;k<=mid;k++)
{
flag=1;
for(int m=1;m<=k;m++)
{
if(matrix[i-m][j]=='0'||matrix[i][j-m]=='0')
{
flag=0;
break;
}
}
if(flag==1)
dp[i][j]=max(k+1,dp[i][j]);
}
}
if(dp[i][j]>ans)
ans=dp[i][j];
}
anss=ans*ans;
return anss;
}
};
(2) El mejor código en línea
class Solution {
public:
int maximalSquare(vector<vector<char>>& matrix) {
int row=matrix.size();
if(row==0)
return 0;
int col=matrix[0].size();
int dp[row+10][col+10];
int ans=0;
int anss;
for(int i=0;i<=row;i++)
for(int j=0;j<=col;j++)
{
dp[i][j]=0;
}
for(int i=1;i<=row;i++)
for(int j=1;j<=col;j++)
{
if(matrix[i-1][j-1]!='0')
{
dp[i][j]=1+min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]));
if(dp[i][j]>ans)
ans=dp[i][j];
}
}
anss=ans*ans;
return anss;
}
};
Ideas para resolver problemas
Cuando vi este problema por primera vez, pensé que se resolvía con programación dinámica, pero cuando me di cuenta, no pensé claramente en la recurrencia de la programación dinámica. Entonces, si lo hice de acuerdo con mis propias ideas, descubrí que algunas de las muestras de prueba siempre fallaban porque todavía no las consideraba bien. Finalmente, finalmente pasé todas las muestras y descubrí que mi código tomó mucho tiempo. Entonces busqué las soluciones de otras personas y resultó que hay una recursividad, y siento que el problema de la programación dinámica se puede resolver muy bien siempre que la recursividad esté claramente pensada. Sea dp [i] [j] la longitud máxima del lado cuadrado que se puede formar tomando la i-ésima fila y la j-ésima columna como la esquina inferior derecha, entonces la fórmula de recurrencia es: dp [i] [j] = 1 + min (dp [i- 1] [j-1], dp [i-1] [j], dp [i] [j-1]); De hecho, cada vez que calcule el cuadrado más grande con la posición actual como la esquina inferior derecha, debe encontrar la parte superior izquierda , La menor de las tres posiciones superiores izquierdas, porque solo de esta manera se puede obtener el cuadrado más grande actual.
Cada vez que grabo el código que escribí y el mejor código en Internet, espero poder pensar rápidamente en el método recursivo cuando resuelva esta pregunta en el futuro y utilice el mejor método para resolverlo.