LeetCode之“动态规划”：Maximal Square && Largest Rectangle in Histogram && Maximal Rectangle

　 1. Maximal Square

　　题目链接

　　题目要求：　

　　Given a 2D binary matrix filled with 0's and 1's, find the largest square containing all 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.

　　在GeeksforGeeks有一个解决该问题的方法：

1) Construct a sum matrix S[R][C] for the given M[R][C].
     a) Copy first row and first columns as it is from M[][] to S[][]
     b) For other entries, use following expressions to construct S[][]
         If M[i][j] is 1 then
            S[i][j] = min(S[i][j-1], S[i-1][j], S[i-1][j-1]) + 1
         Else /*If M[i][j] is 0*/
            S[i][j] = 0
2) Find the maximum entry in S[R][C]
3) Using the value and coordinates of maximum entry in S[i], print 
   sub-matrix of M[][]

　　构造完‘和矩阵S’后，我们只需求得该矩阵的最大值就可以了。

　　为什么只需求得该最大值就可以了？而且相同的最大值可能有很多个。细想下式我们就会知道‘和矩阵S’中的每一个值表示的都是从其他节点（本结点左上）到本节点所能构成的最大正方形的边长长度。

S[i][j] = min(S[i][j-1], S[i-1][j], S[i-1][j-1]) + 1

　　具体的程序如下：

class Solution {
public:
    int min(const int a, const int b, const int c)
    {
        int minVal = (a < b)?a:b;
        return (minVal < c)?minVal:c;
    }
    
    int maximalSquare(vector<vector<char>>& matrix) {
        int rows = matrix.size();
        if(rows == 0)
            return 0;
        
        int cols = matrix[0].size();
        if(cols == 0)
            return 0;
        
        int maxEdge = 0;
        vector<vector<int> > sum(rows, vector<int>(cols, 0));
        for(int i = 0; i < rows; i++)
        {
            if(matrix[i][0] == '1')
            {
                sum[i][0] = 1;
                maxEdge = 1;
            }
        }

        for(int j = 0; j < cols; j++)
        {
            if(matrix[0][j] == '1')
            {
                sum[0][j] = 1;
                maxEdge = 1;
            }
        }
        
        for(int i = 1; i < rows; i++)
            for(int j = 1; j < cols; j++)
            {
                if(matrix[i][j] == '0')
                    sum[i][j] = 0;
                else
                    sum[i][j] = min(sum[i-1][j-1], sum[i-1][j], sum[i][j-1]) + 1;
                    
                if(maxEdge < sum[i][j])
                    maxEdge = sum[i][j];
            }
            
        return maxEdge * maxEdge;
    }
};

　 2.  Largest Rectangle in Histogram

　　题目链接

　　题目要求：

　　Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

　　

　　Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

　　

　　The largest rectangle is shown in the shaded area, which has area = 10 unit.

　　For example,
　　Given height = [2,1,5,6,2,3],
　　return 10.

　　这道题目实际上跟动态规划没有什么关系，之所以将其放在这里是因为其跟下一道题关系很大。该题解法参考自一博文，程序如下：

class Solution {
public:
    int largestRectangleArea(vector<int>& height) {
        vector<int> s;
        
        int sz = height.size();
        height.resize(++sz);
        
        int maxArea = 0;
        int i = 0;
        while(i < sz)
        {
            if(s.empty() || height[i] >= height[s.back()])
            {
                s.push_back(i);
                i++;
            }
            else
            {
                int t = s.back();
                s.pop_back();
                maxArea = max(maxArea, height[t] * (s.empty() ? i : i - s.back() - 1));
            }
        }
        
        return maxArea;
    }
};

　　该博文还照题目要求中的例子[2，1，5，6，2，3]解析了这个函数：

　　首先，如果栈是空的，那么索引i入栈。那么第一个i=0就进去吧。注意栈内保存的是索引，不是高度。然后i++。

　　

　　然后继续，当i=1的时候，发现h[i]小于了栈内的元素，于是出栈。（由此可以想到，哦，看来stack里面只存放单调递增的索引）

　　这时候stack为空，所以面积的计算是h[t] * i.t是刚刚弹出的stack顶元素。也就是蓝色部分的面积。

　　

　　继续。这时候stack为空了，继续入栈。注意到只要是连续递增的序列，我们都要keep pushing，直到我们遇到了i=4，h[i]=2小于了栈顶的元素。

　　

　　这时候开始计算矩形面积。首先弹出栈顶元素，t=3。即下图绿色部分。

　　

　　接下来注意到栈顶的（索引指向的）元素还是大于当前i指向的元素，于是出栈，并继续计算面积，桃红色部分。

　　

　　最后，栈顶的（索引指向的）元素大于了当前i指向的元素，循环继续，入栈并推动i前进。直到我们再次遇到下降的元素，也就是我们最后人为添加的dummy元素0.

　　

　　同理，我们计算栈内的面积。由于当前i是最小元素，所以所有的栈内元素都要被弹出并参与面积计算。

　　

　　注意我们在计算面积的时候已经更新过了maxArea。

　　总结下，我们可以看到，stack中总是保持递增的元素的索引，然后当遇到较小的元素后，依次出栈并计算栈中bar能围成的面积，直到栈中元素小于当前元素。

　 3. 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.

　　这道题的解决方法可以借鉴上题求直方图最大面积的方法，即我们把每一列当作直方图的每一列，输入则是每一列连续的‘1’的个数，具体程序如下：

class Solution {
public:
    int largestRectangleArea(vector<int>& height) {
        vector<int> s;
        
        int sz = height.size();
        height.resize(++sz);
        
        int maxArea = 0;
        int i = 0;
        while(i < sz)
        {
            if(s.empty() || height[i] >= height[s.back()])
            {
                s.push_back(i);
                i++;
            }
            else
            {
                int t = s.back();
                s.pop_back();
                maxArea = max(maxArea, height[t] * (s.empty() ? i : i - s.back() - 1));
            }
        }
        
        return maxArea;
    }
    
    int maximalRectangle(vector<vector<char>>& matrix) {
        int rows = matrix.size();
        if(rows == 0)
            return 0;
        int cols = matrix[0].size();
        
        vector<vector<int> > height(rows, vector<int>(cols, 0));
        for(int i = 0; i < rows; i++)
            for(int j = 0; j < cols; j++)
            {
                if(matrix[i][j] != '0')
                    height[i][j] = (i == 0) ? 1 : height[i-1][j] + 1;
            }
        
        int maxArea = 0;
        for(int i = 0; i < rows; i++)
            maxArea = max(maxArea, largestRectangleArea(height[i]));
            
        return maxArea;
    }
};