leecode 解题总结：221. Maximal Square

最新推荐文章于 2025-08-07 21:19:58 发布
原创最新推荐文章于 2025-08-07 21:19:58 发布 · 271 阅读
0 ·
CC 4.0 BY-SA版权
leecode 专栏收录该内容
246 篇文章
订阅专栏
本文介绍了一种寻找二维矩阵中最大全1正方形区域的方法，通过动态规划算法优化时间复杂度，实现高效求解。
#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
using namespace std;
/*
问题:
Given a 2D binary matrix filled with 0's and 1's, find the largest square containing only 1's and return its area.

For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
Return 4.

分析：给定一个二维矩阵，只包含0和1.找到值包含1的最大面积。
好像是程序员面试金典的题目。最简单的方式。
暴力破解：罗列起点和终点，计算起点和终点只包含1的最大面积。
罗列起点和终点，时间复杂度为O(n^2)，计算起点和终点所在矩形中
包含全1面积的时间复杂度为O(n^2),总的时间复杂度O(n^4)。
计算起点和终点所在矩形的面积能否把时间优化到O(1)。
我们从右下角开始，设置一个变量right,
如果right[i]=0,right[i-1]左侧的right也为0；
否则right[i-1] = right[i]+1,表明当前位置右侧连续的1的个数
同理设置一个down数组，down[j]={down[j+1]+1,if down[j+1] 为1
                              {0, down[j+1]为0
right[i][j]:表示元素右侧一行中连续1的个数，包含该元素本身
down[i][j]:表示元素及元素下方一列中连续1的个数，包含元素本身
right[i][j]={right[i][j+1] + 1, if A[i][j] != 0
            {0 , else
down[i][j]={down[i+1][j] + 1 , if A[i][j] != 0
		   {0   , else
假设行数为row,列数为col
初始：最后一行，down[i][j]=A[i][j]
      最后一列:right[i][j]=A[i][j]
初始从右下角开始遍历到左上角： 先从下向上，然后从右到左
right[row-1][col-1]=A[row-1][col-1]
down[row-1][col-1]=A[row-1][col-1]
计算元素：（i,j）到(m,n)之间矩形的最大面积
之前是给定了行列长度相等的矩阵，因此直接设定长度范围，从而推得起点和终点。
题目要求的是square:是正方形，因此遍历的长度可以设定，主要是起点的设置
遍历起点，O(n^2)，对于每个起点遍历长度:1~min(row , col),总的时间复杂度为O(n^3)
假设起点为(i,j)长度为L,那么4个点分别为
(i,j)		(i , j+L-1)
(i+L-1,j)	(i+L-1,j+L-1)
求出right[i][j] - right[i][j+L] 得到上边一行中给定矩阵的连续1的个数，需要等于L
求出right[i+L-1][j] - right[i+L-1][j+L]得到下边一行中连续1的个数，需要等于L
求出down[i][j] - down[i+L][j]得到左边一列中连续1的个数，需要等于L
    down[i][j+L-1] - down[i+L][j+L-1] 得到右边一列中连续1的个数，需要等于L
	上述4个条件同时满足，记录此时最大面积为L*L，否则，继续处理下一个
对于当前位置(i,j),其遍历的长度为(1 , min(row - i , col - j)), i属于0到row-1.j属于0到col-1
不行，以上只能保证四条边都是1，如果需要整个矩形都为1，可以对每一行都判断都是1

输入:
4(行数) 5(列数)
1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

6 6
1 0 1 1 0 1
1 1 1 1 1 1
0 1 1 0 1 1
1 1 1 0 1 0
0 1 1 1 1 1
1 1 0 1 1 1
输出:
4
4


报错:
Input:
101101
111111
011011
111010
011111
110111

Output:
16
Expected:
4

关键:
1 动态规划方法，设dp[i][j]表示以点A[i][j]为右下角的正方形的最大边长
if A[i][j] == 1:
   dp[i][j] = min(dp[i-1][j-1] , dp[i-1][j] , dp[i][j-1]) + 1
else
   dp[i][j] = 0
对于边界：最上边和最左边，dp[i][j]=A[i][j]
所求目标就是dp中的最小值

2 求出
right[i][j]:表示元素右侧一行中连续1的个数，包含该元素本身
right[i][j]={right[i][j+1] + 1, if A[i][j] != 0
            {0 , else
遍历起始点+长度，确定每一行right对应两个点中长度都为L
for(int i = 0 ; i < row; i++)
{
	for(int j = 0 ; j < col ; j++)
	{
		//遍历长度
		lenMax = min(row - i , col - j);
		//应该还可以剪枝，如果当前遍历的长度L<=之前记录的最大长度，那么就无需遍历了
		for(int L = lenMax ; L > maxLen; L--)
		//for(int L = lenMax ; L >= 1; L--)
		{
			//每一行都要长度为L
			bool isFind = true;
			for(int k = i ; k <= i + L - 1 ; k++)
*/ 

class Solution {
public:
	int minNum(int a , int b ,int c)
	{
		return min( min(a, b), min(a,c) );
	}

    int maximalSquare(vector<vector<char>>& matrix) {
        if(matrix.empty())
		{
			return 0;
		}
		int row = matrix.size();
		int col = matrix.at(0).size();
		vector< vector<int> > dp( row , vector<int>(col , 0) );
		int maxArea = 0;
		//初始化最右边dp等于数组元素本身的值
		for(int j = 0 ; j < col ; j++)
		{
			if('0' == matrix.at(0).at(j))
			{
				dp[0][j] = 0;
			}
			else if('1' == matrix.at(0).at(j))
			{
				dp[0][j] = 1;
			}
			maxArea = max(maxArea ,dp[0][j] * dp[0][j] );
		}
		//初始化最左边dp
		for(int i = 0 ; i < row ; i++)
		{
			if('0' == matrix.at(i).at(0))
			{
				dp[i][0] = 0;
			}
			else if('1' == matrix.at(i).at(0))
			{
				dp[i][0] = 1;
			}
			maxArea = max(maxArea ,dp[i][0] * dp[i][0] );
		}
		
		//计算
		for(int i = 0 ; i < row ; i++)
		{
			for(int j = 0 ; j < col ; j++)
			{
				if(i > 0 && j > 0)
				{
					if('0' == matrix.at(i).at(j))
					{
						dp[i][j] = 0;
					}
					else if('1' == matrix.at(i).at(j))
					{
						dp[i][j] = minNum( dp[i-1][j-1] ,dp[i-1][j] , dp[i][j-1] ) + 1;
						maxArea = max(maxArea , dp[i][j] * dp[i][j]);
					}
				}
			}
		}

		return maxArea;
	}

	void preProcess(vector<vector<char>>& matrix , vector< vector<int> >& right , 
		vector< vector<int> >& down)
	{
		int row = matrix.size();
		int col = matrix.at(0).size();
		//预处理，计算right和down，自底向上，自右向左
		for(int i = row - 1 ; i >= 0 ; i--)
		{
			for(int j = col - 1 ; j >= 0 ; j--)
			{
				//最下面一行，down数组的值为元素的值
				if(row - 1 == i)
				{
					if('0' == matrix.at(i).at(j))
					{
						down[i][j] = 0;
					}
					else if('1' == matrix.at(i).at(j))
					{
						down[i][j] = 1;
					}
				}
				else
				{
					if('0' == matrix.at(i).at(j))
					{
						down[i][j] = 0;
					}
					else if('1' == matrix.at(i).at(j))
					{
						down[i][j] = down[i+1][j] + 1;
					}
				}
				//最右边一列，right数组元的值为元素的值
				if(col - 1 == j)
				{
					if('0' == matrix.at(i).at(j))
					{
						right[i][j] = 0;
					}
					else if('1' == matrix.at(i).at(j))
					{
						right[i][j] = 1;
					}
				}
				else
				{
					if('0' == matrix.at(i).at(j))
					{
						right[i][j] = 0;
					}
					else if('1' == matrix.at(i).at(j))
					{
						right[i][j] = right[i][j+1] + 1;
					}
				}
			}
		}
	}

    int maximalSquare2(vector<vector<char>>& matrix) {
        if(matrix.empty())
		{
			return 0;
		}
		int row = matrix.size();
		int col = matrix.at(0).size();
		vector< vector<int> > right( row , vector<int>(col , 0) );
		vector< vector<int> > down(  row , vector<int>(col , 0) );
		//预处理
		preProcess(matrix , right , down);
		int lenMax;
		int upperLen;
		int maxArea = 0;
		int iIndex = -1;
		int jIndex = -1;
		int maxLen = 0;
		//预处理结束后，开始遍历
/*
假设起点为(i,j)长度为L,那么4个点分别为
(i,j)		(i , j+L-1)
(i+L-1,j)	(i+L-1,j+L-1)
求出right[i][j] - right[i][j+L] 得到上边一行中给定矩阵的连续1的个数，需要等于L
求出right[i+L-1][j] - right[i+L-1][j+L]得到下边一行中连续1的个数，需要等于L
求出down[i][j] - down[i+L][j]得到左边一列中连续1的个数，需要等于L
    down[i][j+L-1] - down[i+L][j+L-1] 得到右边一列中连续1的个数，需要等于L
	上述4个条件同时满足，记录此时最大面积为L*L，否则，继续处理下一个
对于当前位置(i,j),其遍历的长度为(1 , min(row - i , col - j)), i属于0到row-1.j属于0到col-1
*/
		
		for(int i = 0 ; i < row; i++)
		{
			for(int j = 0 ; j < col ; j++)
			{
				//遍历长度
				lenMax = min(row - i , col - j);
				//应该还可以剪枝，如果当前遍历的长度L<=之前记录的最大长度，那么就无需遍历了
				for(int L = lenMax ; L > maxLen; L--)
				//for(int L = lenMax ; L >= 1; L--)
				{
					//每一行都要长度为L
					bool isFind = true;
					for(int k = i ; k <= i + L - 1 ; k++)
					{
						if(j + L < col)
						{
							upperLen = right[k][j] - right[k][j+L];
						}
						else
						{
							upperLen = right[k][j] ;
						}
						if(upperLen != L)
						{
							isFind = false;
							break;
						}
					}
					//如果上下左右都满足长度，这个必定是结果值，计算完了直接跳出
					if(isFind)
					{
						if(maxArea < L * L)
						{
							maxArea = L * L;
							iIndex = i;
							jIndex = j;
							maxLen = L;
						}
						break;
					}
				}
			}
		}
		//cout << "横坐标:" << iIndex << ",纵坐标:" << jIndex << ",长度:" << maxLen << endl;
		return maxArea;
    }
};

void process()
{
	 vector<vector<char>> matrix;
	 char value;
	 Solution solution;
	 int row;
	 int col;
	 while(cin >> row >> col )
	 {
		 matrix.clear();
		 for(int i = 0 ; i < row ; i++)
		 {
			 vector<char> nums;
			 for(int j = 0 ; j < col ; j++)
			 {
				 cin >> value;
				 nums.push_back(value);
			 }
			 matrix.push_back(nums);
		 }
		 int area = solution.maximalSquare(matrix);
		 cout << area << endl;
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}