刷
July-29-2019
以i j为当前位置，它为右下角组成的最大的正方形是，如果上左斜上3个位置都是1，那么它的最大长度取决于刚才3个点里面最小的+它自己的1.
就是这个DP规则，不是很难。 理论上说这种二维的DP，只需要2行或者2列作为DP保存上一轮的值就行，就是滚动。
public int maximalSquare(char[][] matrix) {
if (matrix.length == 0 || matrix[0].length == 0) return 0;
int res = 0;
int col = matrix[0].length;
int[][] dp = new int[2][col];
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < col; j++) {
if (matrix[i][j] == '0') {
dp[i%2][j] = 0;
} else {
int l = i - 1;
int u = j - 1;
dp[i%2][j] = 1;
if (l >= 0 && u >= 0 && matrix[l][u] == '1' && matrix[l][j] == '1' && matrix[i][u] == '1') {
dp[i%2][j] += Math.min(Math.min(dp[l%2][j], dp[l%2][u]), dp[i%2][u]);
}
}
res = Math.max(res, dp[i%2][j]);
}
}
return res * res;
}
OLD
用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，想到蓄水池那个题上了，结果发现是正方形，那就容易很多了。
2-D dp array.
dp[i][j]为右下角的最大正方形的边长。
从它左，上，左上3个方向取最小。
dp[i][j] = minimum(dp[i-1][j],dp[i][j-1],dp[i-1][j-1]) 然后要+1，因为还有他自己。。
当然如果它是0，那么就没法组成正正方形，直接=0.
public class Solution
{
public int maximalSquare(char[][] matrix)
{
if(matrix.length == 0) return 0;
int[][] dp = new int[matrix.length][matrix[0].length];
int max = 0;
for(int i = 0; i < matrix.length;i++)
for(int j = 0 ; j < matrix[0].length;j++)
{
dp[i][j] = matrix[i][j] == '1'? 1:0;
max = Math.max(max,dp[i][j]);
}
for(int i = 1; i < dp.length;i++)
{
for(int j = 1; j < dp[0].length;j++)
{
if(dp[i][j] == 0) continue;
dp[i][j] = Math.min(dp[i][j-1],Math.min(dp[i-1][j-1],dp[i-1][j]))+1;
max = Math.max(max,dp[i][j]);
}
}
return max*max;
}
}
标准答案里面是不需要用MN extra space
用1D也能做。
A B
C D E
大概意思是dp[i][j]是D，我们从A B C中得出。
运算D的前一个是C，E的前一个是D，可以通过temp variable to keep.那其实只需要上面一行A B...来保留就OK了。
标准答案里DP的长度比原来长度大1，这样可以解决每行第一个的取舍。
我没想到这个，手动解决，还挺麻烦的。
A B
C D 来说，A是PREV，B是DP[J] C是DP[J-1]（上一步的DP[J])
但是每行第一个又不是这个规律，因为每行第一个的DP[J-1]明显不是从上一步算算出来的。
所以每行第一个来说 C是PREV A是上一行开始记录的matrix[i][0]，B是正确的。
public class Solution
{
public int maximalSquare(char[][] matrix)
{
if(matrix.length == 0) return 0;
int[] dp = new int[matrix[0].length];
int max = 0;
for(int i = 0; i < matrix[0].length;i++)
{
dp[i] = matrix[0][i] == '1'? 1:0;
max = Math.max(max,dp[i]);
}
int upFirst = 0;
for(int i = 1; i < matrix.length;i++)
{
int prev = matrix[i][0] == '1'? 1:0;
for(int j = 1; j < matrix[0].length;j++)
{
if(matrix[i][j] == '0')
{
prev = dp[j];
dp[j] = 0;
}
else
{
int temp = Math.min(dp[j],Math.min(dp[j-1],prev))+1;
prev = dp[j];
dp[j] = temp;
max = Math.max(max,dp[j]);
}
if(j == matrix[0].length-1) dp[0] = matrix[i][0] == '1'? 1:0;
}
}
return max*max;
}
}
这个题做得不好。
一开始尝试滚动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;
}
}