子矩阵问题

 

  矩阵中的最大正方形子矩阵(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;  
	}