LeetCode Maximal Rectangle

Maximal Rectangle

Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.

一道超难的题目，思想难，同时实现也难。

本题是动态规划法的高级应用，还依据题目特征优化，难度相当高。

经提示，知道是max histogram这个题目的思想的灵活运用，就是每一行运用max histogram算法思想计算。

原来LeetCode把max histogram放在这一题之前是有原因的。没有max histogram这一题的思想基础垫底，是很难理解的。

LeetCode论坛上的讨论，其实也是这一思想的变种运用，不过感觉讲得并不清楚，他所谓的拖线法，其实就是histogram的倒置。

只不过并没有严格按照histogram的算法来进行，而是优化了。

我按histogram算法写的程序用了大概100ms左右，他的算法程序能在40-50ms左右，很快。

所以我也不得不研究一下他的算法到底优化了什么。

他使用了三个表L，R，H表，我也画了三个表，对比看看，填填这个表，就能理解这个算法了：

下面是标准的histogram题目算法的应用程序：

class Solution {
public:
	int maximalRectangle(vector<vector<char> > &matrix) 
	{
		int row = matrix.size();
		if (row < 1) return 0;
		int col = matrix[0].size();
		vector<int> his(col);
		int maxArea = 0;

		for (int i = row-1; i >= 0; i--)
		{
			formHistogram(matrix, i, his);
			maxArea = max(maxArea, maxHistogram(his));
		}
		return maxArea;
	}

	void formHistogram(vector<vector<char> > &m, int row, vector<int> &his)
	{
		for (size_t j = 0; j < m[0].size(); j++)
		{
			if (m[row][j]-'0' == 0) his[j] = 0;
			else if (row != m.size()-1 && m[row+1][j]-'0' == 1)
			{
				his[j]--;
			}
			else
			{
				for (int i = row; i >= 0; i--)
				{
					if (m[i][j]-'0' == 1) his[j]++;
					else break;
				}
			}
		}
	}
	int maxHistogram(vector<int> &h)
	{
		h.push_back(0);
		int n = h.size();
		int maxArea = 0;
		stack<int> stk;

		for (int i = 0; i < n; )
		{
			if (stk.empty() || h[stk.top()] <= h[i]) stk.push(i++);
			else
			{
				int t = stk.top();
				stk.pop();
				maxArea = max(maxArea, h[t]*(stk.empty()? i:i-stk.top()-1));
			}
		}
		return maxArea;
	}
};

优化一点histogram算法的程序：

int maxHistogram(vector<int> &h)
	{
		h.push_back(0);
		int n = h.size();
		int maxArea = 0;
		stack<int> stk;

		for (int i = 0; i < n; )
		{
			if (stk.empty() || h[stk.top()] <= h[i]) stk.push(i++);
			else
			{
				int t = stk.top();
				stk.pop();
				maxArea = max(maxArea, h[t]*(stk.empty()? i:i-stk.top()-1));
			}
		}
		return maxArea;
	}
	//================histogram，拖线法实现
	int maximalRectangle2(vector<vector<char> > &matrix) 
	{
		int row = matrix.size();
		if (row < 1) return 0;
		int col = matrix[0].size();
		vector<int> his(col);
		int maxArea = 0;

		for (int i = row-1; i >= 0; i--)
		{
			for (int j = 0; j < col; j++)
			{
				if ( matrix[i][j]-'0' == 1) his[j]++;
				else his[j] = 0;
			}

			maxArea = max(maxArea, maxHistogram(his));
		}
		return maxArea;
	}

最后是leetcode上的优化算法，也是上图示意图的算法实现：

int maximalRectangle(vector<vector<char> > &matrix) {
		if (matrix.empty()) {
			return 0;
		}

		int n = matrix[0].size();
		vector<int> H(n);
		vector<int> L(n);
		vector<int> R(n, n);

		int ret = 0;
		for (int i = 0; i < matrix.size(); ++i) {
			int left = 0, right = n;
			// calculate L(i, j) from left to right
			for (int j = 0; j < n; ++j) {
				if (matrix[i][j] == '1') {
					++H[j];
					L[j] = max(L[j], left);
				}
				else {
					left = j+1;
					H[j] = 0; L[j] = 0; R[j] = n;
				}
			}
			// calculate R(i, j) from right to right
			for (int j = n-1; j >= 0; --j) {
				if (matrix[i][j] == '1') {
					R[j] = min(R[j], right);
					ret = max(ret, H[j]*(R[j]-L[j]));
				}
				else {
					right = j;
				}
			}
		}

		return ret;
	}

2014-2-27 update：

还是下面这个程序比较保险，虽然leetcode上测试，是上一个程序比较快，但是按照理论上计算，两个算法的时间复杂度都是O(n*n)，而空间复杂度也都是O(n)，那么其实两个方法的实际运行速度都应该差不多的。

而且主要是下面这个程序更加模块化，更简易；上一个程序很容易出错，下标处理起来很麻烦的，一不小心结果就会出错。

int maximalRectangle(vector<vector<char> > &matrix) 
	{
		if (matrix.empty() || matrix[0].empty()) return 0;
		vector<int> height(matrix[0].size()+1);
		int max_area = 0;
		for (int i = 0; i < matrix.size(); i++)
		{
			for (int j = 0; j < matrix[0].size(); j++)
			{
				if (matrix[i][j] == '1') height[j]++;
				else height[j] = 0;
			}
			max_area = max(max_area, maxHistogram(height));
		}
		return max_area;
	}
	int maxHistogram(vector<int> &height)
	{
		int ans = 0;
		stack<int> stk;
		for (int i = 0; i < height.size(); )
		{
			if (stk.empty() || height[stk.top()] < height[i]) stk.push(i++);
			else
			{
				int idx = stk.top();
				stk.pop();
				ans = max(ans, (stk.empty()? i:i-stk.top()-1)*height[idx]);
			}
		}
		return ans;
	}