Skip to content

Commit 63410c9

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0084. Largest Rectangle in
Histogram
1 parent ab3bdc4 commit 63410c9

File tree

6 files changed

+285
-67
lines changed

6 files changed

+285
-67
lines changed

‎solution/0000-0099/0084.Largest Rectangle in Histogram/README.md

+112-2
Original file line numberDiff line numberDiff line change
@@ -29,27 +29,137 @@
2929
<pre><strong>输入:</strong> [2,1,5,6,2,3]
3030
<strong>输出:</strong> 10</pre>
3131

32-
3332
## 解法
3433

3534
<!-- 这里可写通用的实现逻辑 -->
3635

36+
单调栈。
37+
38+
单调栈常见模型：找出每个数左/右边**离它最近的**且**比它大/小的数**。模板：
39+
40+
```python
41+
stk = []
42+
for i in range(n):
43+
while stk and check(stk[-1], i):
44+
stk.pop()
45+
stk.append(i)
46+
```
47+
48+
枚举每根柱子的高度 h 作为矩形的高度，向左右两边找第一个高度小于 h 的下标 `left[i]`, `right[i]`。那么此时矩形面积为 `h * (right[i] - left[i] - 1)`，求最大值即可。
49+
3750
<!-- tabs:start -->
3851

3952
### **Python3**
4053

4154
<!-- 这里可写当前语言的特殊实现逻辑 -->
4255

4356
```python
44-
57+
class Solution:
58+
def largestRectangleArea(self, heights: List[int]) -> int:
59+
res, n = 0, len(heights)
60+
stk = []
61+
left = [-1] * n
62+
right = [n] * n
63+
for i, h in enumerate(heights):
64+
while stk and heights[stk[-1]] >= h:
65+
right[stk[-1]] = i
66+
stk.pop()
67+
if stk:
68+
left[i] = stk[-1]
69+
stk.append(i)
70+
for i, h in enumerate(heights):
71+
res = max(res, h * (right[i] - left[i] - 1))
72+
return res
4573
```
4674

4775
### **Java**
4876

4977
<!-- 这里可写当前语言的特殊实现逻辑 -->
5078

5179
```java
80+
class Solution {
81+
public int largestRectangleArea(int[] heights) {
82+
int res = 0, n = heights.length;
83+
Deque<Integer> stk = new ArrayDeque<>();
84+
int[] left = new int[n];
85+
int[] right = new int[n];
86+
Arrays.fill(right, n);
87+
for (int i = 0; i < n; ++i) {
88+
while (!stk.isEmpty() && heights[stk.peek()] >= heights[i]) {
89+
right[stk.pop()] = i;
90+
}
91+
left[i] = stk.isEmpty() ? -1 : stk.peek();
92+
stk.push(i);
93+
}
94+
for (int i = 0; i < n; ++i) {
95+
res = Math.max(res, heights[i] * (right[i] - left[i] - 1));
96+
}
97+
return res;
98+
}
99+
}
100+
```
101+
102+
### **C++**
103+
104+
```cpp
105+
class Solution {
106+
public:
107+
int largestRectangleArea(vector<int>& heights) {
108+
int res = 0, n = heights.size();
109+
stack<int> stk;
110+
vector<int> left(n, -1);
111+
vector<int> right(n, n);
112+
for (int i = 0; i < n; ++i)
113+
{
114+
while (!stk.empty() && heights[stk.top()] >= heights[i])
115+
{
116+
right[stk.top()] = i;
117+
stk.pop();
118+
}
119+
if (!stk.empty()) left[i] = stk.top();
120+
stk.push(i);
121+
}
122+
for (int i = 0; i < n; ++i)
123+
res = max(res, heights[i] * (right[i] - left[i] - 1));
124+
return res;
125+
}
126+
};
127+
```
52128
129+
### **Go**
130+
131+
```go
132+
func largestRectangleArea(heights []int) int {
133+
res, n := 0, len(heights)
134+
var stk []int
135+
left, right := make([]int, n), make([]int, n)
136+
for i := range right {
137+
right[i] = n
138+
}
139+
for i, h := range heights {
140+
for len(stk) > 0 && heights[stk[len(stk)-1]] >= h {
141+
right[stk[len(stk)-1]] = i
142+
stk = stk[:len(stk)-1]
143+
}
144+
if len(stk) > 0 {
145+
left[i] = stk[len(stk)-1]
146+
} else {
147+
left[i] = -1
148+
}
149+
stk = append(stk, i)
150+
}
151+
for i, h := range heights {
152+
res = max(res, h*(right[i]-left[i]-1))
153+
}
154+
return res
155+
}
156+
157+
func max(a, b int) int {
158+
if a > b {
159+
return a
160+
}
161+
return b
162+
}
53163
```
54164

55165
### **...**

‎solution/0000-0099/0084.Largest Rectangle in Histogram/README_EN.md

+98-2
Original file line numberDiff line numberDiff line change
@@ -31,21 +31,117 @@ The largest rectangle is shown in the red area, which has an area = 10 units.
3131
<li><code>0 &lt;= heights[i] &lt;= 10<sup>4</sup></code></li>
3232
</ul>
3333

34-
3534
## Solutions
3635

3736
<!-- tabs:start -->
3837

3938
### **Python3**
4039

4140
```python
42-
41+
class Solution:
42+
def largestRectangleArea(self, heights: List[int]) -> int:
43+
res, n = 0, len(heights)
44+
stk = []
45+
left = [-1] * n
46+
right = [n] * n
47+
for i, h in enumerate(heights):
48+
while stk and heights[stk[-1]] >= h:
49+
right[stk[-1]] = i
50+
stk.pop()
51+
if stk:
52+
left[i] = stk[-1]
53+
stk.append(i)
54+
for i, h in enumerate(heights):
55+
res = max(res, h * (right[i] - left[i] - 1))
56+
return res
4357
```
4458

4559
### **Java**
4660

4761
```java
62+
class Solution {
63+
public int largestRectangleArea(int[] heights) {
64+
int res = 0, n = heights.length;
65+
Deque<Integer> stk = new ArrayDeque<>();
66+
int[] left = new int[n];
67+
int[] right = new int[n];
68+
Arrays.fill(right, n);
69+
for (int i = 0; i < n; ++i) {
70+
while (!stk.isEmpty() && heights[stk.peek()] >= heights[i]) {
71+
right[stk.pop()] = i;
72+
}
73+
left[i] = stk.isEmpty() ? -1 : stk.peek();
74+
stk.push(i);
75+
}
76+
for (int i = 0; i < n; ++i) {
77+
res = Math.max(res, heights[i] * (right[i] - left[i] - 1));
78+
}
79+
return res;
80+
}
81+
}
82+
```
83+
84+
### **C++**
85+
86+
```cpp
87+
class Solution {
88+
public:
89+
int largestRectangleArea(vector<int>& heights) {
90+
int res = 0, n = heights.size();
91+
stack<int> stk;
92+
vector<int> left(n, -1);
93+
vector<int> right(n, n);
94+
for (int i = 0; i < n; ++i)
95+
{
96+
while (!stk.empty() && heights[stk.top()] >= heights[i])
97+
{
98+
right[stk.top()] = i;
99+
stk.pop();
100+
}
101+
if (!stk.empty()) left[i] = stk.top();
102+
stk.push(i);
103+
}
104+
for (int i = 0; i < n; ++i)
105+
res = max(res, heights[i] * (right[i] - left[i] - 1));
106+
return res;
107+
}
108+
};
109+
```
48110
111+
### **Go**
112+
113+
```go
114+
func largestRectangleArea(heights []int) int {
115+
res, n := 0, len(heights)
116+
var stk []int
117+
left, right := make([]int, n), make([]int, n)
118+
for i := range right {
119+
right[i] = n
120+
}
121+
for i, h := range heights {
122+
for len(stk) > 0 && heights[stk[len(stk)-1]] >= h {
123+
right[stk[len(stk)-1]] = i
124+
stk = stk[:len(stk)-1]
125+
}
126+
if len(stk) > 0 {
127+
left[i] = stk[len(stk)-1]
128+
} else {
129+
left[i] = -1
130+
}
131+
stk = append(stk, i)
132+
}
133+
for i, h := range heights {
134+
res = max(res, h*(right[i]-left[i]-1))
135+
}
136+
return res
137+
}
138+
139+
func max(a, b int) int {
140+
if a > b {
141+
return a
142+
}
143+
return b
144+
}
49145
```
50146

51147
### **...**

‎solution/0000-0099/0084.Largest Rectangle in Histogram/Solution.cpp

+15-35
Original file line numberDiff line numberDiff line change
@@ -1,42 +1,22 @@
11
class Solution {
22
public:
33
int largestRectangleArea(vector<int>& heights) {
4-
if(heights.empty())return 0;
5-
int len = heights.size();
6-
7-
stack<int> s_stack;
8-
int ans = 0;
9-
10-
for(int i = 0;i < len;i++){
11-
if(s_stack.empty() || heights[i] >= s_stack.top())
12-
{//满足升序条件
13-
s_stack.push(heights[i]);
4+
int res = 0, n = heights.size();
5+
stack<int> stk;
6+
vector<int> left(n, -1);
7+
vector<int> right(n, n);
8+
for (int i = 0; i < n; ++i)
9+
{
10+
while (!stk.empty() && heights[stk.top()] >= heights[i])
11+
{
12+
right[stk.top()] = i;
13+
stk.pop();
1414
}
15-
else
16-
{//不满足升序
17-
int count = 0;
18-
while(!s_stack.empty() && s_stack.top() > heights[i])
19-
{
20-
count++;
21-
ans = max(ans,s_stack.top() * count);
22-
s_stack.pop();
23-
}
24-
while(count > 0)
25-
{
26-
s_stack.push(heights[i]);
27-
count--;
28-
}
29-
s_stack.push(heights[i]);
30-
}
31-
}
32-
33-
int count = 1;
34-
while(!s_stack.empty()){
35-
ans = max(ans,s_stack.top() * count);
36-
s_stack.pop();
37-
count++;
15+
if (!stk.empty()) left[i] = stk.top();
16+
stk.push(i);
3817
}
39-
40-
return ans;
18+
for (int i = 0; i < n; ++i)
19+
res = max(res, heights[i] * (right[i] - left[i] - 1));
20+
return res;
4121
}
4222
};

‎solution/0000-0099/0084.Largest Rectangle in Histogram/Solution.go

+31
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
func largestRectangleArea(heights []int) int {
2+
res, n := 0, len(heights)
3+
var stk []int
4+
left, right := make([]int, n), make([]int, n)
5+
for i := range right {
6+
right[i] = n
7+
}
8+
for i, h := range heights {
9+
for len(stk) > 0 && heights[stk[len(stk)-1]] >= h {
10+
right[stk[len(stk)-1]] = i
11+
stk = stk[:len(stk)-1]
12+
}
13+
if len(stk) > 0 {
14+
left[i] = stk[len(stk)-1]
15+
} else {
16+
left[i] = -1
17+
}
18+
stk = append(stk, i)
19+
}
20+
for i, h := range heights {
21+
res = max(res, h*(right[i]-left[i]-1))
22+
}
23+
return res
24+
}
25+
26+
func max(a, b int) int {
27+
if a > b {
28+
return a
29+
}
30+
return b
31+
}

0 commit comments

Comments
 (0)