From 175aa2121b1dfdc5643c3c09d77a76614b07700a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E4=BD=B3=E5=B8=86?= <3151342895@qq.com>
Date: Tue, 9 Aug 2022 16:31:09 +0800
Subject: [PATCH 1/3] lcof2\040\c++

---
 .../README.md"                                | 43 ++++++++++++++++++-
 .../Solution.cpp"                             | 33 ++++++++++++++
 2 files changed, 75 insertions(+), 1 deletion(-)
 create mode 100644 "lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp"

diff --git "a/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md" "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md"
index b1aa65aea655f..33202e446127a 100644
--- "a/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md"	
+++ "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md"	
@@ -84,7 +84,48 @@
 ```java
 
 ```
-
+### **C++**
+
+- 首先在柱状图中求最大矩形面积可以通过单调栈，维护每一列的左边第一个比它小的位置L，和右边第一个比它小的位置R，就能得到以这一列为高的最大矩形面积为（R-L-1）*h。
+- 考虑每一行作为底边的柱状图中，能够得到的最大的矩形面积。再对每一行的最大面积取max就是最终的答案。
+- 柱状图中每一列的高可以通过类似前缀和的方式去维护。
+- 假设矩阵大小为n*m，那么时间复杂为 O(nm)，空间复杂度为 O(m)。
+
+```c++
+class Solution {
+public:
+    int h[210];
+    int l[210],r[210];
+    int maximalRectangle(vector<string>& matrix) {
+        int n = matrix.size();
+        if(n == 0) return 0;
+        int m = matrix[0].size();
+        int ans = 0;
+        stack<int> st;
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                h[j] = (matrix[i][j] == '1' ? h[j] + 1 : 0);
+                while(st.size() && h[j] <= h[st.top()]) 
+                {
+                    ans = max(ans,(j-l[st.top()]-1) * h[st.top()]);
+                    st.pop();
+                }
+                if(st.size()) l[j] = st.top();
+                else l[j] = -1;
+                st.push(j);
+            }
+            while(st.size())
+            {
+                ans = max(ans,(m-1-l[st.top()]) * h[st.top()]);
+                st.pop();
+            }
+        }
+        return ans;
+    }
+};
+```
 ### **...**
 
 ```
diff --git "a/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp" "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp"
new file mode 100644
index 0000000000000..00eed7a50cc88
--- /dev/null
+++ "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp"	
@@ -0,0 +1,33 @@
+class Solution {
+public:
+    int h[210];
+    int l[210],r[210];
+    int maximalRectangle(vector<string>& matrix) {
+        int n = matrix.size();
+        if(n == 0) return 0;
+        int m = matrix[0].size();
+        int ans = 0;
+        stack<int> st;
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                h[j] = (matrix[i][j] == '1' ? h[j] + 1 : 0);
+                while(st.size() && h[j] <= h[st.top()])
+                {
+                    ans = max(ans,(j-l[st.top()]-1) * h[st.top()]);
+                    st.pop();
+                }
+                if(st.size()) l[j] = st.top();
+                else l[j] = -1;
+                st.push(j);
+            }
+            while(st.size())
+            {
+                ans = max(ans,(m-1-l[st.top()]) * h[st.top()]);
+                st.pop();
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file

From 70a5b37be320d0868cd397aa954d389e990c0660 Mon Sep 17 00:00:00 2001
From: Yang Libin <contact@yanglibin.info>
Date: Tue, 9 Aug 2022 17:01:01 +0800
Subject: [PATCH 2/3] Update Solution.cpp

---
 .../Solution.cpp"                             | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git "a/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp" "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp"
index 00eed7a50cc88..02a0eb3f7e928 100644
--- "a/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp"	
+++ "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/Solution.cpp"	
@@ -1,33 +1,33 @@
 class Solution {
 public:
     int h[210];
-    int l[210],r[210];
+    int l[210], r[210];
     int maximalRectangle(vector<string>& matrix) {
         int n = matrix.size();
-        if(n == 0) return 0;
+        if (n == 0) return 0;
         int m = matrix[0].size();
         int ans = 0;
         stack<int> st;
-        for(int i=0;i<n;i++)
+        for (int i = 0; i < n; i++)
         {
-            for(int j=0;j<m;j++)
+            for (int j = 0; j < m; j++)
             {
                 h[j] = (matrix[i][j] == '1' ? h[j] + 1 : 0);
-                while(st.size() && h[j] <= h[st.top()])
+                while (st.size() && h[j] <= h[st.top()])
                 {
-                    ans = max(ans,(j-l[st.top()]-1) * h[st.top()]);
+                    ans = max(ans, (j - l[st.top()] - 1) * h[st.top()]);
                     st.pop();
                 }
-                if(st.size()) l[j] = st.top();
+                if (st.size()) l[j] = st.top();
                 else l[j] = -1;
                 st.push(j);
             }
-            while(st.size())
+            while (st.size())
             {
-                ans = max(ans,(m-1-l[st.top()]) * h[st.top()]);
+                ans = max(ans, (m - 1 - l[st.top()]) * h[st.top()]);
                 st.pop();
             }
         }
         return ans;
     }
-};
\ No newline at end of file
+};

From 5a5bb54b5cd047f4d6f20547ecf49c958d4cc72b Mon Sep 17 00:00:00 2001
From: Yang Libin <contact@yanglibin.info>
Date: Tue, 9 Aug 2022 17:03:22 +0800
Subject: [PATCH 3/3] Update README.md

---
 .../README.md"                                | 34 +++++++++++--------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git "a/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md" "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md"
index 33202e446127a..d864ddddb05c3 100644
--- "a/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md"	
+++ "b/lcof2/\345\211\221\346\214\207 Offer II 040. \347\237\251\351\230\265\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/README.md"	
@@ -67,6 +67,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：单调栈**
+
+-   首先在柱状图中求最大矩形面积可以通过单调栈，维护每一列的左边第一个比它小的位置 $L$，和右边第一个比它小的位置 $R$，就能得到以这一列为高的最大矩形面积为 $(R-L-1)*h$。
+-   考虑每一行作为底边的柱状图中，能够得到的最大的矩形面积。再对每一行的最大面积取 $max$ 就是最终的答案。
+-   柱状图中每一列的高可以通过类似前缀和的方式去维护。
+-   假设矩阵大小为 $n*m$，那么时间复杂为 $O(nm)$，空间复杂度为 $O(m)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -84,41 +91,37 @@
 ```java
 
 ```
-### **C++**
 
-- 首先在柱状图中求最大矩形面积可以通过单调栈，维护每一列的左边第一个比它小的位置L，和右边第一个比它小的位置R，就能得到以这一列为高的最大矩形面积为（R-L-1）*h。
-- 考虑每一行作为底边的柱状图中，能够得到的最大的矩形面积。再对每一行的最大面积取max就是最终的答案。
-- 柱状图中每一列的高可以通过类似前缀和的方式去维护。
-- 假设矩阵大小为n*m，那么时间复杂为 O(nm)，空间复杂度为 O(m)。
+### **C++**
 
-```c++
+```cpp
 class Solution {
 public:
     int h[210];
-    int l[210],r[210];
+    int l[210], r[210];
     int maximalRectangle(vector<string>& matrix) {
         int n = matrix.size();
-        if(n == 0) return 0;
+        if (n == 0) return 0;
         int m = matrix[0].size();
         int ans = 0;
         stack<int> st;
-        for(int i=0;i<n;i++)
+        for (int i = 0; i < n; i++)
         {
-            for(int j=0;j<m;j++)
+            for (int j = 0; j < m; j++)
             {
                 h[j] = (matrix[i][j] == '1' ? h[j] + 1 : 0);
-                while(st.size() && h[j] <= h[st.top()]) 
+                while (st.size() && h[j] <= h[st.top()])
                 {
-                    ans = max(ans,(j-l[st.top()]-1) * h[st.top()]);
+                    ans = max(ans, (j - l[st.top()] - 1) * h[st.top()]);
                     st.pop();
                 }
-                if(st.size()) l[j] = st.top();
+                if (st.size()) l[j] = st.top();
                 else l[j] = -1;
                 st.push(j);
             }
-            while(st.size())
+            while (st.size())
             {
-                ans = max(ans,(m-1-l[st.top()]) * h[st.top()]);
+                ans = max(ans, (m - 1 - l[st.top()]) * h[st.top()]);
                 st.pop();
             }
         }
@@ -126,6 +129,7 @@ public:
     }
 };
 ```
+
 ### **...**
 
 ```