feat: add solutions to lc problem: No.0456

No.0456.132 Pattern

Author: yanglbme

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

@@ -52,20 +52,23 @@
 
 **方法一：单调栈**
 
-**方法二：树状数组**
+我们可以枚举从右往左枚举整数 $nums[i]$，并维护一个单调栈，栈中的元素从栈底到栈顶单调递减。维护一个变量 $vk$，表示 $nums[i]$ 右侧且小于 $nums[i]$ 的最大值。初始时，$vk$ 的值为 $-\infty$。
 
-树状数组，也称作“二叉索引树”（Binary Indexed Tree）或 Fenwick 树。 它可以高效地实现如下两个操作：
+我们从右往左遍历数组，对于遍历到的每个元素 $nums[i]$，如果 $nums[i]$ 小于 $vk$，则说明我们找到了一个满足 $nums[i] \lt nums[k] \lt nums[j]$ 的三元组，返回 `true`。否则，如果栈顶元素小于 $nums[i]$，则我们循环将栈顶元素出栈，并且更新 $vk$ 的值为出栈元素，直到栈为空或者栈顶元素大于等于 $nums[i]$。最后，我们将 $nums[i]$ 入栈。
 
-1. **单点更新** `update(x, delta)`： 把序列 x 位置的数加上一个值 delta；
-1. **前缀和查询** `query(x)`：查询序列 `[1,...x]` 区间的区间和，即位置 x 的前缀和。
+如果遍历结束后仍未找到满足条件的三元组，说明不存在这样的三元组，返回 `false`。
 
-这两个操作的时间复杂度均为 $O(\log n)$。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。
 
-树状数组最基本的功能就是求比某点 x 小的点的个数（这里的比较是抽象的概念，可以是数的大小、坐标的大小、质量的大小等等）。
+**方法二：离散化 + 树状数组**
 
-比如给定数组 `a[5] = {2, 5, 3, 4, 1}`，求 `b[i] = 位置 i 左边小于等于 a[i] 的数的个数`。对于此例，`b[5] = {0, 1, 1, 2, 0}`。
+我们可以用树状数组维护比某个数小的元素的个数，用一个数组 $left$ 记录 $nums[i]$ 左侧的最小值。
 
-解决方案是直接遍历数组，每个位置先求出 `query(a[i])`，然后再修改树状数组 `update(a[i], 1)` 即可。当数的范围比较大时，需要进行离散化，即先进行去重并排序，然后对每个数字进行编号。
+我们从右往左遍历数组，对于遍历到的每个元素 $nums[i]$，我们将 $nums[i]$ 离散化为一个整数 $x$，将 $left[i]$ 离散化为一个整数 $y$，如果此时 $x \gt y$，并且树状数组中存在比 $y$ 大但比 $x$ 小的元素，则说明存在满足 $nums[i] \lt nums[k] \lt nums[j]$ 的三元组，返回 `true`。否则，我们将 $nums[i]$ 的离散化结果 $x$ 更新到树状数组中。
+
+如果遍历结束后仍未找到满足条件的三元组，说明不存在这样的三元组，返回 `false`。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。
 
 <!-- tabs:start -->
 
@@ -117,7 +120,7 @@ class Solution:
         for i in range(n - 1, -1, -1):
             x = bisect_left(s, nums[i]) + 1
             y = bisect_left(s, left[i]) + 1
-            if x > y and (tree.query(x - 1) - tree.query(y) > 0):
+            if x > y and tree.query(x - 1) > tree.query(y):
                 return True
             tree.update(x, 1)
         return False
@@ -191,7 +194,7 @@ class Solution {
         for (int i = n - 1; i >= 0; --i) {
             int x = search(s, m, nums[i]);
             int y = search(s, m, left[i]);
-            if (x > y && tree.query(x - 1) - tree.query(y) > 0) {
+            if (x > y && tree.query(x - 1) > tree.query(y)) {
                 return true;
             }
             tree.update(x, 1);
@@ -237,6 +240,61 @@ public:
 };
 ```
 
+```cpp
+class BinaryIndexedTree {
+public:
+    BinaryIndexedTree(int n) {
+        this->n = n;
+        this->c = vector<int>(n + 1, 0);
+    }
+
+    void update(int x, int val) {
+        while (x <= n) {
+            c[x] += val;
+            x += x & -x;
+        }
+    }
+
+    int query(int x) {
+        int s = 0;
+        while (x > 0) {
+            s += c[x];
+            x -= x & -x;
+        }
+        return s;
+    }
+
+private:
+    int n;
+    vector<int> c;
+};
+
+class Solution {
+public:
+    bool find132pattern(vector<int>& nums) {
+        vector<int> s = nums;
+        sort(s.begin(), s.end());
+        s.erase(unique(s.begin(), s.end()), s.end());
+        BinaryIndexedTree tree(s.size());
+        int n = nums.size();
+        int left[n + 1];
+        memset(left, 63, sizeof(left));
+        for (int i = 0; i < n; ++i) {
+            left[i + 1] = min(left[i], nums[i]);
+        }
+        for (int i = nums.size() - 1; ~i; --i) {
+            int x = lower_bound(s.begin(), s.end(), nums[i]) - s.begin() + 1;
+            int y = lower_bound(s.begin(), s.end(), left[i]) - s.begin() + 1;
+            if (x > y && tree.query(x - 1) > tree.query(y)) {
+                return true;
+            }
+            tree.update(x, 1);
+        }
+        return false;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -257,6 +315,69 @@ func find132pattern(nums []int) bool {
 }
 ```
 
+```go
+type BinaryIndexedTree struct {
+	n int
+	c []int
+}
+
+func newBinaryIndexedTree(n int) *BinaryIndexedTree {
+	c := make([]int, n+1)
+	return &BinaryIndexedTree{n, c}
+}
+
+func (this *BinaryIndexedTree) update(x, val int) {
+	for x <= this.n {
+		this.c[x] += val
+		x += x & -x
+	}
+}
+
+func (this *BinaryIndexedTree) query(x int) int {
+	s := 0
+	for x > 0 {
+		s += this.c[x]
+		x -= x & -x
+	}
+	return s
+}
+
+func find132pattern(nums []int) bool {
+	n := len(nums)
+	s := make([]int, n)
+	left := make([]int, n+1)
+	left[0] = 1 << 30
+	copy(s, nums)
+	sort.Ints(s)
+	m := 0
+	for i := 0; i < n; i++ {
+		left[i+1] = min(left[i], nums[i])
+		if i == 0 || s[i] != s[i-1] {
+			s[m] = s[i]
+			m++
+		}
+	}
+	s = s[:m]
+	tree := newBinaryIndexedTree(m)
+	for i := n - 1; i >= 0; i-- {
+		x := sort.SearchInts(s, nums[i]) + 1
+		y := sort.SearchInts(s, left[i]) + 1
+		if x > y && tree.query(x-1) > tree.query(y) {
+			return true
+		}
+		tree.update(x, 1)
+	}
+	return false
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -276,6 +397,73 @@ function find132pattern(nums: number[]): boolean {
 }
 ```
 
+```ts
+class BinaryIndextedTree {
+    n: number;
+    c: number[];
+
+    constructor(n: number) {
+        this.n = n;
+        this.c = new Array(n + 1).fill(0);
+    }
+
+    update(x: number, val: number): void {
+        while (x <= this.n) {
+            this.c[x] += val;
+            x += x & -x;
+        }
+    }
+
+    query(x: number): number {
+        let s = 0;
+        while (x) {
+            s += this.c[x];
+            x -= x & -x;
+        }
+        return s;
+    }
+}
+
+function find132pattern(nums: number[]): boolean {
+    let s: number[] = [...nums];
+    s.sort((a, b) => a - b);
+    const n = nums.length;
+    const left: number[] = new Array(n + 1).fill(1 << 30);
+    let m = 0;
+    for (let i = 0; i < n; ++i) {
+        left[i + 1] = Math.min(left[i], nums[i]);
+        if (i == 0 || s[i] != s[i - 1]) {
+            s[m++] = s[i];
+        }
+    }
+    s = s.slice(0, m);
+    const tree = new BinaryIndextedTree(m);
+    for (let i = n - 1; i >= 0; --i) {
+        const x = search(s, nums[i]);
+        const y = search(s, left[i]);
+        if (x > y && tree.query(x - 1) > tree.query(y)) {
+            return true;
+        }
+        tree.update(x, 1);
+    }
+    return false;
+}
+
+function search(nums: number[], x: number): number {
+    let l = 0,
+        r = nums.length - 1;
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] >= x) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return l + 1;
+}
+```
+
 ### **Rust**
 
 ```rust