子矩阵问题

   矩阵中的最大正方形子矩阵(Maximal Square)     题目描述： 1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0     比如说，在这个矩阵中，由1构成的最大正方形子矩阵就是4.    题目分析：     matrix[ ][ ] 用来存放01，那么当求矩阵[i][j] 的最大矩阵时，用一个 max存放正方形的边长     如果[i][j] == 0 , 那么最大正方形边长就等于max,     如果[i][j] == 1 , 那么，就要看它的[i-1][j] , [i -1][j-1] , [i][j -1] , 取他们中的最小值 ， 然后加1 就是     [i][j] 能够成的最大矩阵，最后与max , 比较，更新最大边长。   递推公式：

m[i][j] = min(m[i-1][j] , m[i][j-1] , m[i-1][j-1] ) + 1;  matrix[i][j] = 1

m[i][j] = 0 ; matrix[i][j] = 0;

m为中间矩阵

      

public class Solution {
// 返回最大的正方形
public int maximalSquare(char[][] matrix) {
if(matrix == null) return 0;
int rows = matrix.length;
if(rows == 0) return 0;
int cols = matrix[0].length;
int[][] m = new int[rows+1][cols+1];
int max = 0;

for(int i = 1 ; i <= rows; i++) {
for(int j = 1 ; j <= cols ; j++) {
if(matrix[i - 1][j - 1] == '0') {
m[i][j] = 0;
continue;
}

m[i][j] = (Math.min(Math.min(m[i - 1][j] , m[i][j-1])
, m[i - 1][j - 1] ) )+ 1;
max = Math.max(max , m[i][j]);
}
}
return max * max;
}
}

     最大子矩阵和      N*N的矩阵中，求最大子矩阵的和？     先不要往动态规划上想，如果暴力的求解最大子矩阵该怎么求?     假如给你一个3x3的矩阵 matrix：     那么最大矩阵就可能在 ：     第1行中，1 2 行中 ，1 2 3 行中     或者 第2行中，2 3 行中     或者 第3行中 ----------- 这里就构成了下面代码外面的两层for循环     可是光知道在那些行中，还不能够求出矩阵和啊。这样就得遍历所有列     求出 i 到 j 行， k 到 m 列的矩阵和，到了这一步，就可以把求最大子矩阵和的过程化成了     求连续子数组的最大和。是不是一样的道理！遍历每一列求和sum，不就是等同于移动数组的下标就和?     然后把求的sum与之前的比较，如果大于则更新。然后，sum再与max比较，大于则更新max.     过程是这样，但是这道问题难点就在于怎么求 i 到 j 行， k 到 m列的矩阵和？     在下面的代码中，通过建立一个中间矩阵p , p[i][j] 就表示[1][1] 到 [i][j] 的矩阵和。     p[i][j] 就表示 1 到 i 行 ， 1 到 j 列 构成的这个子矩阵中所有元素的和。     比如说一个下面矩阵:  p[1][1] = 2 , p[2][2] = 2+3+(-2)+3 = 6     2    3     4     -2  3     5     0    -1    4    所以 ， 就可以得到求p[i][j] 的公式：

p[i][j] = p[i-1][j] + p[i][j-1] - p[i-1][j-1] + a[i][j]

    具体这个公式，怎么理解，画图!!! 很好理解的。     p[i][j] 就是一个中间矩阵，有了它，就可以很轻松的求得 i 到 j 行， k 到 m 行的 的 sum 了。     下面是公式：// 还是画图理解。

sum = p[j][m] - p[j][k-1] - p[i-1][m] + p[i-1][k-1]

    

int maxMatrixSum(int[][] a)
{
int n = a.length;
int m = a[0].length;
int[][] p = new int[n+1][m+1];
// 初始话p , 由矩阵a , p[i][j] 公式求得p中每一项的值
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= m; ++j)
p[i][j] = p[i-1][j] + p[i][j-1] - p[i-1][j-1] + a[i - 1][j - 1];
}

for(int i = 1 ; i <= 3 ; i++) {
System.out.println(Arrays.toString(p[i]));
}

int max = 0;
for (int i = 1; i <= n; ++i)
{
for (int j = i; j <= n; ++j)
{
// 这里的逻辑就是求连续子数组的最大和了。
int sum = 0;
for (int k = 1; k <= m; ++k)
{
int temp = p[j][k] - p[j][k-1] - p[i-1][k] + p[i-1][k-1];
if (sum > 0)
sum += temp;
else
sum = temp;
if (sum > max)
max = sum;
}
}
}
return max;
}