蓝桥杯——边界为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，故返回4。

暴力版思路：可以先假设最大子方阵有N阶，然后遍历每一个元素，看以此元素为子方阵的左上角是否满足N阶子方阵都是1，如果满足，就找到了最大的N，如果不满足，就让N减一，直到N为0。

#include<iostream>

using namespace std;

int solve(int matrix[][5],int N){
	int n = N;  //阶数
	bool flag = false;
	while(n>0){
		for(int i=0;i<N;i++,flag = false){
			if(i + n > N) break;
			for(int j=0;j<N;j++,flag = false){
			if(j + n > N) break;
				//当前节点开始查看是否满足均为1
				int r=i,c=j;
				while(c<j+n){  //往右走 
					if(matrix[r][c] == 0){
						flag = true;
						break;
					}
					c++; 
				} 
				if(flag){
					continue;
				}
				c--; //复原 
				while(r<i+n){  //往下走 
					if(matrix[r][c] == 0){
						flag = true;
						break;
					}
					r++;
				} 
				if(flag){
					continue;
				}
				r--;
				while(c>=j){  //往左走 
					if(matrix[r][c] == 0){
						flag = true;
						break;
					}
					c--;
				} 
				if(flag){
					continue;
				}
				c++;
				while(r>=i){  //往上走 
					if(matrix[r][c] == 0){
						flag = true;
						break;
					}
					r--;
				} 
				if(flag){
					continue;
				}
				r++;
				return n;
			}
		}
		n--;
	} 
	return n; //全是0，直接返回 
} 
int main(){
	int matrix[][5] = {
	{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}
	};
	int res = solve(matrix,5);
	cout<<"result: "<<res<<endl;
}

运行结果是：

大家也可以试试全是0的情况。

时间复杂度分析：while的N到0，内层遍历二维数组N✖N，在走一圈的过程中又有N+N-1+N-1+N-2也就是4N，所以也就是N✖N✖N✖N，即O(N^4)，这种情况就非常危险了，比赛可能会超时，所以我们可以对其进行优化，也就是对这个数组进行一个预处理（类似于动态规划），我也写了一篇文章，有兴趣的可以看一看：优化版