Skip to content

Commit 46cce2a

Browse files
yanglbmeyanglbme
committedMar 14, 2022
feat: add solutions to lc problem: No.0456
No.0456.132 Pattern
·
v0.3.0v0.2.0
1 parent dbcdccd commit 46cce2a

File tree

4 files changed

+572
-1
lines changed

4 files changed

+572
-1
lines changed
 

‎solution/0400-0499/0456.132 Pattern/README.md

+239-1
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,22 @@
5050

5151
<!-- 这里可写通用的实现逻辑 -->
5252

53-
单调栈实现。
53+
**方法一：单调栈**
54+
55+
**方法二：树状数组**
56+
57+
树状数组，也称作“二叉索引树”（Binary Indexed Tree）或 Fenwick 树。 它可以高效地实现如下两个操作：
58+
59+
1. **单点更新** `update(x, delta)`： 把序列 x 位置的数加上一个值 delta；
60+
1. **前缀和查询** `query(x)`：查询序列 `[1,...x]` 区间的区间和，即位置 x 的前缀和。
61+
62+
这两个操作的时间复杂度均为 `O(log n)`。
63+
64+
树状数组最基本的功能就是求比某点 x 小的点的个数（这里的比较是抽象的概念，可以是数的大小、坐标的大小、质量的大小等等）。
65+
66+
比如给定数组 `a[5] = {2, 5, 3, 4, 1}`，求 `b[i] = 位置 i 左边小于等于 a[i] 的数的个数`。对于此例，`b[5] = {0, 1, 1, 2, 0}`。
67+
68+
解决方案是直接遍历数组，每个位置先求出 `query(a[i])`，然后再修改树状数组 `update(a[i], 1)` 即可。当数的范围比较大时，需要进行离散化，即先进行去重并排序，然后对每个数字进行编号。
5469

5570
<!-- tabs:start -->
5671

@@ -72,6 +87,47 @@ class Solution:
7287
return False
7388
```
7489

90+
```python
91+
class BinaryIndexedTree:
92+
def __init__(self, n):
93+
self.n = n
94+
self.c = [0] * (n + 1)
95+
96+
@staticmethod
97+
def lowbit(x):
98+
return x & -x
99+
100+
def update(self, x, delta):
101+
while x <= self.n:
102+
self.c[x] += delta
103+
x += BinaryIndexedTree.lowbit(x)
104+
105+
def query(self, x):
106+
s = 0
107+
while x:
108+
s += self.c[x]
109+
x -= BinaryIndexedTree.lowbit(x)
110+
return s
111+
112+
113+
class Solution:
114+
def find132pattern(self, nums: List[int]) -> bool:
115+
s = sorted(set(nums))
116+
m = {v: i for i, v in enumerate(s, 1)}
117+
n = len(m)
118+
tree = BinaryIndexedTree(n)
119+
for v in nums:
120+
tree.update(m[v], 1)
121+
mi = nums[0]
122+
for v in nums:
123+
tree.update(m[v], -1)
124+
# v 右侧存在 (mi, v - 1] 范围内的数字，说明符合 132
125+
if tree.query(m[v] - 1) - tree.query(m[mi]) > 0:
126+
return True
127+
mi = min(mi, v)
128+
return False
129+
```
130+
75131
### **Java**
76132

77133
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -95,6 +151,67 @@ class Solution {
95151
}
96152
```
97153

154+
```java
155+
class BinaryIndexedTree {
156+
private int n;
157+
private int[] c;
158+
159+
public BinaryIndexedTree(int n) {
160+
this.n = n;
161+
c = new int[n + 1];
162+
}
163+
164+
public void update(int x, int delta) {
165+
while (x <= n) {
166+
c[x] += delta;
167+
x += lowbit(x);
168+
}
169+
}
170+
171+
public int query(int x) {
172+
int s = 0;
173+
while (x > 0) {
174+
s += c[x];
175+
x -= lowbit(x);
176+
}
177+
return s;
178+
}
179+
180+
public static int lowbit(int x) {
181+
return x & -x;
182+
}
183+
}
184+
185+
class Solution {
186+
public boolean find132pattern(int[] nums) {
187+
TreeSet<Integer> ts = new TreeSet();
188+
for (int v : nums) {
189+
ts.add(v);
190+
}
191+
int idx = 1;
192+
Map<Integer, Integer> m = new HashMap<>();
193+
for (int v : ts) {
194+
m.put(v, idx++);
195+
}
196+
int n = m.size();
197+
BinaryIndexedTree tree = new BinaryIndexedTree(n);
198+
for (int v : nums) {
199+
tree.update(m.get(v), 1);
200+
}
201+
int mi = nums[0];
202+
for (int v : nums) {
203+
int x = m.get(v);
204+
tree.update(x, -1);
205+
if (tree.query(x - 1) - tree.query(m.get(mi)) > 0) {
206+
return true;
207+
}
208+
mi = Math.min(mi, v);
209+
}
210+
return false;
211+
}
212+
}
213+
```
214+
98215
### **TypeScript**
99216

100217
```ts
@@ -144,6 +261,127 @@ impl Solution {
144261
}
145262
```
146263

264+
### **C++**
265+
266+
```cpp
267+
class BinaryIndexedTree {
268+
public:
269+
int n;
270+
vector<int> c;
271+
272+
BinaryIndexedTree(int _n): n(_n), c(_n + 1){}
273+
274+
void update(int x, int delta) {
275+
while (x <= n)
276+
{
277+
c[x] += delta;
278+
x += lowbit(x);
279+
}
280+
}
281+
282+
int query(int x) {
283+
int s = 0;
284+
while (x > 0)
285+
{
286+
s += c[x];
287+
x -= lowbit(x);
288+
}
289+
return s;
290+
}
291+
292+
int lowbit(int x) {
293+
return x & -x;
294+
}
295+
};
296+
297+
class Solution {
298+
public:
299+
bool find132pattern(vector<int>& nums) {
300+
unordered_set<int> s(nums.begin(), nums.end());
301+
vector<int> alls(s.begin(), s.end());
302+
sort(alls.begin(), alls.end());
303+
unordered_map<int, int> m;
304+
int n = alls.size();
305+
for (int i = 0; i < n; ++i) m[alls[i]] = i + 1;
306+
BinaryIndexedTree* tree = new BinaryIndexedTree(n);
307+
for (int v : nums) tree->update(m[v], 1);
308+
int mi = nums[0];
309+
for (int v : nums)
310+
{
311+
tree->update(m[v], -1);
312+
if (tree->query(m[v] - 1) - tree->query(m[mi]) > 0) return true;
313+
mi = min(mi, v);
314+
}
315+
return false;
316+
}
317+
};
318+
```
319+
320+
### **Go**
321+
322+
```go
323+
type BinaryIndexedTree struct {
324+
n int
325+
c []int
326+
}
327+
328+
func newBinaryIndexedTree(n int) *BinaryIndexedTree {
329+
c := make([]int, n+1)
330+
return &BinaryIndexedTree{n, c}
331+
}
332+
333+
func (this *BinaryIndexedTree) lowbit(x int) int {
334+
return x & -x
335+
}
336+
337+
func (this *BinaryIndexedTree) update(x, delta int) {
338+
for x <= this.n {
339+
this.c[x] += delta
340+
x += this.lowbit(x)
341+
}
342+
}
343+
344+
func (this *BinaryIndexedTree) query(x int) int {
345+
s := 0
346+
for x > 0 {
347+
s += this.c[x]
348+
x -= this.lowbit(x)
349+
}
350+
return s
351+
}
352+
353+
func find132pattern(nums []int) bool {
354+
s := make(map[int]bool)
355+
for _, v := range nums {
356+
s[v] = true
357+
}
358+
var alls []int
359+
for v := range s {
360+
alls = append(alls, v)
361+
}
362+
sort.Ints(alls)
363+
m := make(map[int]int)
364+
for i, v := range alls {
365+
m[v] = i + 1
366+
}
367+
tree := newBinaryIndexedTree(len(m))
368+
for _, v := range nums {
369+
tree.update(m[v], 1)
370+
}
371+
mi := nums[0]
372+
for _, v := range nums {
373+
tree.update(m[v], -1)
374+
if tree.query(m[v]-1)-tree.query(m[mi]) > 0 {
375+
return true
376+
}
377+
if v < mi {
378+
mi = v
379+
}
380+
}
381+
return false
382+
}
383+
```
384+
147385
### **...**
148386

149387
```

‎solution/0400-0499/0456.132 Pattern/README_EN.md

+222
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,46 @@ class Solution:
6262
return False
6363
```
6464

65+
```python
66+
class BinaryIndexedTree:
67+
def __init__(self, n):
68+
self.n = n
69+
self.c = [0] * (n + 1)
70+
71+
@staticmethod
72+
def lowbit(x):
73+
return x & -x
74+
75+
def update(self, x, delta):
76+
while x <= self.n:
77+
self.c[x] += delta
78+
x += BinaryIndexedTree.lowbit(x)
79+
80+
def query(self, x):
81+
s = 0
82+
while x:
83+
s += self.c[x]
84+
x -= BinaryIndexedTree.lowbit(x)
85+
return s
86+
87+
88+
class Solution:
89+
def find132pattern(self, nums: List[int]) -> bool:
90+
s = sorted(set(nums))
91+
m = {v: i for i, v in enumerate(s, 1)}
92+
n = len(m)
93+
tree = BinaryIndexedTree(n)
94+
for v in nums:
95+
tree.update(m[v], 1)
96+
mi = nums[0]
97+
for v in nums:
98+
tree.update(m[v], -1)
99+
if tree.query(m[v] - 1) - tree.query(m[mi]) > 0:
100+
return True
101+
mi = min(mi, v)
102+
return False
103+
```
104+
65105
### **Java**
66106

67107
```java
@@ -83,6 +123,67 @@ class Solution {
83123
}
84124
```
85125

126+
```java
127+
class BinaryIndexedTree {
128+
private int n;
129+
private int[] c;
130+
131+
public BinaryIndexedTree(int n) {
132+
this.n = n;
133+
c = new int[n + 1];
134+
}
135+
136+
public void update(int x, int delta) {
137+
while (x <= n) {
138+
c[x] += delta;
139+
x += lowbit(x);
140+
}
141+
}
142+
143+
public int query(int x) {
144+
int s = 0;
145+
while (x > 0) {
146+
s += c[x];
147+
x -= lowbit(x);
148+
}
149+
return s;
150+
}
151+
152+
public static int lowbit(int x) {
153+
return x & -x;
154+
}
155+
}
156+
157+
class Solution {
158+
public boolean find132pattern(int[] nums) {
159+
TreeSet<Integer> ts = new TreeSet();
160+
for (int v : nums) {
161+
ts.add(v);
162+
}
163+
int idx = 1;
164+
Map<Integer, Integer> m = new HashMap<>();
165+
for (int v : ts) {
166+
m.put(v, idx++);
167+
}
168+
int n = m.size();
169+
BinaryIndexedTree tree = new BinaryIndexedTree(n);
170+
for (int v : nums) {
171+
tree.update(m.get(v), 1);
172+
}
173+
int mi = nums[0];
174+
for (int v : nums) {
175+
int x = m.get(v);
176+
tree.update(x, -1);
177+
if (tree.query(x - 1) - tree.query(m.get(mi)) > 0) {
178+
return true;
179+
}
180+
mi = Math.min(mi, v);
181+
}
182+
return false;
183+
}
184+
}
185+
```
186+
86187
### **TypeScript**
87188

88189
```ts
@@ -132,6 +233,127 @@ impl Solution {
132233
}
133234
```
134235

236+
### **C++**
237+
238+
```cpp
239+
class BinaryIndexedTree {
240+
public:
241+
int n;
242+
vector<int> c;
243+
244+
BinaryIndexedTree(int _n): n(_n), c(_n + 1){}
245+
246+
void update(int x, int delta) {
247+
while (x <= n)
248+
{
249+
c[x] += delta;
250+
x += lowbit(x);
251+
}
252+
}
253+
254+
int query(int x) {
255+
int s = 0;
256+
while (x > 0)
257+
{
258+
s += c[x];
259+
x -= lowbit(x);
260+
}
261+
return s;
262+
}
263+
264+
int lowbit(int x) {
265+
return x & -x;
266+
}
267+
};
268+
269+
class Solution {
270+
public:
271+
bool find132pattern(vector<int>& nums) {
272+
unordered_set<int> s(nums.begin(), nums.end());
273+
vector<int> alls(s.begin(), s.end());
274+
sort(alls.begin(), alls.end());
275+
unordered_map<int, int> m;
276+
int n = alls.size();
277+
for (int i = 0; i < n; ++i) m[alls[i]] = i + 1;
278+
BinaryIndexedTree* tree = new BinaryIndexedTree(n);
279+
for (int v : nums) tree->update(m[v], 1);
280+
int mi = nums[0];
281+
for (int v : nums)
282+
{
283+
tree->update(m[v], -1);
284+
if (tree->query(m[v] - 1) - tree->query(m[mi]) > 0) return true;
285+
mi = min(mi, v);
286+
}
287+
return false;
288+
}
289+
};
290+
```
291+
292+
### **Go**
293+
294+
```go
295+
type BinaryIndexedTree struct {
296+
n int
297+
c []int
298+
}
299+
300+
func newBinaryIndexedTree(n int) *BinaryIndexedTree {
301+
c := make([]int, n+1)
302+
return &BinaryIndexedTree{n, c}
303+
}
304+
305+
func (this *BinaryIndexedTree) lowbit(x int) int {
306+
return x & -x
307+
}
308+
309+
func (this *BinaryIndexedTree) update(x, delta int) {
310+
for x <= this.n {
311+
this.c[x] += delta
312+
x += this.lowbit(x)
313+
}
314+
}
315+
316+
func (this *BinaryIndexedTree) query(x int) int {
317+
s := 0
318+
for x > 0 {
319+
s += this.c[x]
320+
x -= this.lowbit(x)
321+
}
322+
return s
323+
}
324+
325+
func find132pattern(nums []int) bool {
326+
s := make(map[int]bool)
327+
for _, v := range nums {
328+
s[v] = true
329+
}
330+
var alls []int
331+
for v := range s {
332+
alls = append(alls, v)
333+
}
334+
sort.Ints(alls)
335+
m := make(map[int]int)
336+
for i, v := range alls {
337+
m[v] = i + 1
338+
}
339+
tree := newBinaryIndexedTree(len(m))
340+
for _, v := range nums {
341+
tree.update(m[v], 1)
342+
}
343+
mi := nums[0]
344+
for _, v := range nums {
345+
tree.update(m[v], -1)
346+
if tree.query(m[v]-1)-tree.query(m[mi]) > 0 {
347+
return true
348+
}
349+
if v < mi {
350+
mi = v
351+
}
352+
}
353+
return false
354+
}
355+
```
356+
135357
### **...**
136358

137359
```

‎solution/0400-0499/0456.132 Pattern/Solution.cpp

+51
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
class BinaryIndexedTree {
2+
public:
3+
int n;
4+
vector<int> c;
5+
6+
BinaryIndexedTree(int _n): n(_n), c(_n + 1){}
7+
8+
void update(int x, int delta) {
9+
while (x <= n)
10+
{
11+
c[x] += delta;
12+
x += lowbit(x);
13+
}
14+
}
15+
16+
int query(int x) {
17+
int s = 0;
18+
while (x > 0)
19+
{
20+
s += c[x];
21+
x -= lowbit(x);
22+
}
23+
return s;
24+
}
25+
26+
int lowbit(int x) {
27+
return x & -x;
28+
}
29+
};
30+
31+
class Solution {
32+
public:
33+
bool find132pattern(vector<int>& nums) {
34+
unordered_set<int> s(nums.begin(), nums.end());
35+
vector<int> alls(s.begin(), s.end());
36+
sort(alls.begin(), alls.end());
37+
unordered_map<int, int> m;
38+
int n = alls.size();
39+
for (int i = 0; i < n; ++i) m[alls[i]] = i + 1;
40+
BinaryIndexedTree* tree = new BinaryIndexedTree(n);
41+
for (int v : nums) tree->update(m[v], 1);
42+
int mi = nums[0];
43+
for (int v : nums)
44+
{
45+
tree->update(m[v], -1);
46+
if (tree->query(m[v] - 1) - tree->query(m[mi]) > 0) return true;
47+
mi = min(mi, v);
48+
}
49+
return false;
50+
}
51+
};

‎solution/0400-0499/0456.132 Pattern/Solution.go

+60
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,60 @@
1+
type BinaryIndexedTree struct {
2+
n int
3+
c []int
4+
}
5+
6+
func newBinaryIndexedTree(n int) *BinaryIndexedTree {
7+
c := make([]int, n+1)
8+
return &BinaryIndexedTree{n, c}
9+
}
10+
11+
func (this *BinaryIndexedTree) lowbit(x int) int {
12+
return x & -x
13+
}
14+
15+
func (this *BinaryIndexedTree) update(x, delta int) {
16+
for x <= this.n {
17+
this.c[x] += delta
18+
x += this.lowbit(x)
19+
}
20+
}
21+
22+
func (this *BinaryIndexedTree) query(x int) int {
23+
s := 0
24+
for x > 0 {
25+
s += this.c[x]
26+
x -= this.lowbit(x)
27+
}
28+
return s
29+
}
30+
31+
func find132pattern(nums []int) bool {
32+
s := make(map[int]bool)
33+
for _, v := range nums {
34+
s[v] = true
35+
}
36+
var alls []int
37+
for v := range s {
38+
alls = append(alls, v)
39+
}
40+
sort.Ints(alls)
41+
m := make(map[int]int)
42+
for i, v := range alls {
43+
m[v] = i + 1
44+
}
45+
tree := newBinaryIndexedTree(len(m))
46+
for _, v := range nums {
47+
tree.update(m[v], 1)
48+
}
49+
mi := nums[0]
50+
for _, v := range nums {
51+
tree.update(m[v], -1)
52+
if tree.query(m[v]-1)-tree.query(m[mi]) > 0 {
53+
return true
54+
}
55+
if v < mi {
56+
mi = v
57+
}
58+
}
59+
return false
60+
}

0 commit comments

Comments
 (0)
Please sign in to comment.