[LeetCode] 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.

思路：

动态规划：

f[i][j] 表示在第i行中以(i,j)点结束点的前面有多少个连续的1,就是用f[i][j]来记录i行以j列为结尾，往前连续的1的个数。

然后用O(n^3)的循环来找以(i, j)为右下角的矩形最大的矩形的面积。

例如数组为

0  0  1

1  1  1

0  1  1

那么f数组为

0  0  1

1  2  3

0  1  2

在计算f[i][j]时使用的是一维动态规划

计算(i, j)为右下角的矩形最大的矩形的面积时，就是就去第0行到i行中以j结尾矩形的最大值，就是之前求过的 Largest Rectangle in Histogram

相当于是每一列，求一次Largest Rectangle in Histogram，然后求其所有列的最大值。。

方法一： O（n^3）

转载 http://www.cnblogs.com/remlostime/archive/2012/11/12/2766566.html

class Solution {
    private:
        int f[1000][1000];
    public:
        int maximalRectangle(vector<vector<char> > &matrix) {
            // Start typing your C/C++ solution below
            // DO NOT write int main() function
            for(int i = 0; i < matrix.size(); i++)
                f[i][0] = matrix[i][0] == '1' ? 1 : 0;

            for(int i = 0; i < matrix.size(); i++)
                for(int j = 1; j < matrix[i].size(); j++)
                    f[i][j] = matrix[i][j] == '1' ? f[i][j-1] + 1 : 0;

            int ret = 0;
            for(int i = 0; i < matrix.size(); i++)
            {
                for(int j = 0; j < matrix[i].size(); j++)
                {
                    int wid = INT_MAX;
                    for(int k = i; k >=0; k--)
                    {
                        if(f[i][j] == 0)
                            break;
                        wid = min(wid, f[k][j]);
                        ret = max(ret, wid* (i-k +1));
                    }

                }
            }
            return ret;

        }
};

 方法二，基于largestRectangleArea

将matrxi看出n行，求出每行的高度，然后调用largestRectangleArea

求解每行的高度的时候，使用的动态规划方法和方法一类似，

f[i][j]表示第i列中以（i，j）为结束连续1的个数

重点是

if(matrix[i][j] == '1')
f[i][j] = f[i-1][j] + 1;
else
f[i][j] = 0;

 共n行，每行调用largestRectangleArea的复杂度为O(n)，所以是O（n^2）,空间复杂度由于有矩阵f的存在，也是O（n^2）

class Solution
{
    public:
        int largestRectangleArea(vector<int> &height) {

            //add 0 to the end
            height.push_back(0);

            int size = height.size(); //this new_size is 1 + old_size
            stack<int> st;

            int max_area = 0;



            for(int i = 0; i< size; )
            {
                if(st.empty() || height[i] > height[st.top()])
                {
                    st.push(i);
                    i++;
                }
                else
                {
                    //st must be not empty here
                    // i can't ++; handle many times perhaps

                    int idx = st.top();
                    st.pop();

                    int area;

                    if(st.empty())
                    {
                        area = height[idx] * i;
                    }
                    else
                    {
                        area = height[idx] * (i-st.top()-1);
                    }

                    max_area = max(max_area, area);

                }
            }
            return max_area;
        }

        int maximalRectangle(vector<vector<char> > &matrix)
        {
            if(matrix.empty() || matrix[0].empty())
                return 0;
            size_t row = matrix.size();
            size_t col = matrix[0].size();

            //construct matrix f;
            vector<vector<int> > f(row);
            vector<int> array;
            array.resize(col, 0);

            for(int i = 0; i < row; i++)
                f[i] = array;

            // initial f[0], the first row
            for(int j = 0; j < col; j++)
            {
                if(matrix[0][j] == '1')
                    f[0][j] = 1;
                else
                    f[0][j] = 0;
            }

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

            int ret = 0;
            for(int i = 0; i < row; i++)
            {

                ret = max(ret, largestRectangleArea(f[i]));
            }

            return ret;

        }
} ;

 适当的优化：

　　由于f[i][j] = f[i-1][j] + 1;的关系，二期在计算第i行时，第i-1行的数据有用，再之前的数据就没有了，所以我么可以不用保留整个col*row的矩阵，而只用一个数组就够了

　　空间复杂度O（n），时间复杂度还是O（n^2）

class Solution
{
    public:
        int largestRectangleArea(vector<int> &height) {

            //add 0 to the end
            height.push_back(0);

            int size = height.size(); //this new_size is 1 + old_size
            stack<int> st;

            int max_area = 0;



            for(int i = 0; i< size; )
            {
                if(st.empty() || height[i] > height[st.top()])
                {
                    st.push(i);
                    i++;
                }
                else
                {
                    //st must be not empty here
                    // i can't ++; handle many times perhaps

                    int idx = st.top();
                    st.pop();

                    int area;

                    if(st.empty())
                    {
                        area = height[idx] * i;
                    }
                    else
                    {
                        area = height[idx] * (i-st.top()-1);
                    }

                    max_area = max(max_area, area);

                }
            }
            return max_area;
        }

        int maximalRectangle(vector<vector<char> > &matrix)
        {
            if(matrix.empty() || matrix[0].empty())
                return 0;
            size_t row = matrix.size();
            size_t col = matrix[0].size();

            vector<int> f;
            f.resize(col, 0);

            int ret = 0;
            for(int i = 0; i < row; i++)
            {
                // update f
                for(int j = 0; j < col; j++)
                {
                    // the first row 
                    if(i == 0)
                    {
                        if(matrix[0][j] == '1')
                            f[j] = 1;
                        else
                            f[j] = 0;
                    }
                    // other rows
                    else
                    {
                        if(matrix[i][j] == '1')
                            f[j] = f[j] + 1;
                        else
                            f[j] = 0;
                    }
                }

                ret = max(ret, largestRectangleArea(f));
            }

            return ret;

        }
} ;