[算法]边界都是1的最大正方形大小

题目:

给定一个N*N的矩阵matrix，在这个矩阵中，只有0和1两种值，返回边框全是1的最大正方形的边长长度。

例如：

0     1     1     1     1

0     1     0     0     1

0     1     0     0     1

0     1     1     1     1

0     1     0     1     1

其中边框全是1的最大正方形的大小为4*4，return 4。

思路：

方法一：

1.矩阵中一共有N*N个位置。O(N²)

2.对每一个位置都可以成为边长为N~1的正方形左上角。比如，对于(0,0)位置，依次检查是否是边长为5的正方形的左上角，然后检查边长为4、3等。O(N)

3.如何检查一个位置是否可以成为边长为N的正方形的左上角？遍历这个边长为N的正方形边界看是否只由1组成，也就是走过四个边的长度(4N)。O(N)

总的时间复杂度：O(N²)*O(N)*O(N)=O(N⁴)

方法二：

时间复杂度为O(N³)

采用预处理方法。

1.预处理过程是根据matrix得到两个矩阵right和down，right[i][j]的值表示从位置(i,j)向右出发有多少个连续的1。down[i][j]的值表示从位置(i,j)向下出发有多少个连续的1。

2.right与down的计算。

• 从矩阵的右下角(n-1,n-1)位置开始计算，如果matrix[n-1][n-1]=1,那么，right[n-1][n-1]=1,down[n-1][n-1]=1,否则都等于0。

• 从右下角向上计算，即在matrix最后一列上计算，位置就表示为(i,n-1)。对right来说，最后一列的右边没有内容，所以，如果matrix[i][n-1]=1，             right[i][n-1]=1并且down[i][n-1]=down[i+1][n-1]+1,否则right[i][n-1]=0并且down[i][n-1]=0。
• 从右下角向左计算，即在matrix最后一行上计算，位置就表示为(n-1,j)。对down来说，最后一行的下边没有内容，所以，如果matrix[n-1][j]=1，           down[n-1][j]=1并且right[n-1][j]=down[n-1][j+1]+1,否则right[n-1][j]=0并且down[n-1][j]=0。
• 剩下的位置都是既有右，又有下，假设位置(i,j):
  • if matrix[i][j]=1, then right[i][j+1]=right[i][j]+1,down[i][j]=down[i+1][j]+1.

  • if matrix[i][j]=0,then right[i][j]=0,down[i][j]=0.

	public static void setBorderMap(int[][] m, int[][] right, int[][] down) {

		int r = m.length;

		int c = m[0].length;

		if (m[r - 1][c - 1] == 1) {

			right[r - 1][c - 1] = 1;

			down[r - 1][c - 1] = 1;

		}

		for (int i = r - 2; i != -1; i--) {

			if (m[i][c - 1] == 1) {

				right[i][c - 1] = 1;

				down[i][c - 1] = down[i + 1][c - 1] + 1;

			}

		}

		for (int i = c - 2; i != -1; i--) {

			if (m[r - 1][i] == 1) {

				right[r - 1][i] = right[r - 1][i + 1] + 1;

				down[r - 1][i] = 1;

			}

		}

		for (int i = r - 2; i != -1; i--) {

			for (int j = c - 2; j != -1; j--) {

				if (m[i][j] == 1) {

					right[i][j] = right[i][j + 1] + 1;

					down[i][j] = down[i + 1][j] + 1;

				}

			}

		}

	}


	public static int getMaxSize(int[][] m) {

		int[][] right = new int[m.length][m[0].length];

		int[][] down = new int[m.length][m[0].length];

		setBorderMap(m, right, down);

		for (int size = Math.min(m.length, m[0].length); size != 0; size--) {

			if (hasSizeOfBorder(size, right, down)) {

				return size;

			}

		}

		return 0;

	}


	public static boolean hasSizeOfBorder(int size, int[][] right, int[][] down) {

		for (int i = 0; i != right.length - size + 1; i++) {

			for (int j = 0; j != right[0].length - size + 1; j++) {

				if (right[i][j] >= size && down[i][j] >= size

						&& right[i + size - 1][j] >= size

						&& down[i][j + size - 1] >= size) {

					return true;

				}

			}

		}

		return false;

	}


	public static int[][] generateRandom01Matrix(int rowSize, int colSize) {

		int[][] res = new int[rowSize][colSize];

		for (int i = 0; i != rowSize; i++) {

			for (int j = 0; j != colSize; j++) {

				res[i][j] = (int) (Math.random() * 2);

			}

		}

		return res;

	}