feat: add solutions to lc problems: No.0152,2213

- No.0152.Maximum Product Subarray
- No.2213.Longest Substring of One Repeating Character

Author: maolonglong

solution/0100-0199/0152.Maximum Product Subarray/README.md

@@ -176,6 +176,25 @@ func min(a, b int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn max_product(nums: Vec<i32>) -> i32 {
+        let mut min = nums[0];
+        let mut max = nums[0];
+        let mut res = nums[0];
+        for &num in nums.iter().skip(1) {
+            let (pre_min, pre_max) = (min, max);
+            min = num.min(num * pre_min).min(num * pre_max);
+            max = num.max(num * pre_min).max(num * pre_max);
+            res = res.max(max);
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0152.Maximum Product Subarray/README_EN.md

@@ -156,6 +156,25 @@ func min(a, b int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn max_product(nums: Vec<i32>) -> i32 {
+        let mut min = nums[0];
+        let mut max = nums[0];
+        let mut res = nums[0];
+        for &num in nums.iter().skip(1) {
+            let (pre_min, pre_max) = (min, max);
+            min = num.min(num * pre_min).min(num * pre_max);
+            max = num.max(num * pre_min).max(num * pre_max);
+            res = res.max(max);
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0152.Maximum Product Subarray/Solution.rs

@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn max_product(nums: Vec<i32>) -> i32 {
+        let mut min = nums[0];
+        let mut max = nums[0];
+        let mut res = nums[0];
+        for &num in nums.iter().skip(1) {
+            let (pre_min, pre_max) = (min, max);
+            min = num.min(num * pre_min).min(num * pre_max);
+            max = num.max(num * pre_min).max(num * pre_max);
+            res = res.max(max);
+        }
+        res
+    }
+}

solution/2200-2299/2213.Longest Substring of One Repeating Character/README.md

@@ -390,6 +390,91 @@ public:
 };
 ```
 
+### **Go**
+
+```go
+type segmentTree struct {
+	str []byte
+	mx  []int
+	lmx []int
+	rmx []int
+}
+
+func newSegmentTree(s string) *segmentTree {
+	n := len(s)
+	t := &segmentTree{
+		str: []byte(s),
+		mx:  make([]int, n<<2),
+		lmx: make([]int, n<<2),
+		rmx: make([]int, n<<2),
+	}
+	t.build(0, 0, n-1)
+	return t
+}
+
+func (t *segmentTree) build(x, l, r int) {
+	if l == r {
+		t.lmx[x] = 1
+		t.rmx[x] = 1
+		t.mx[x] = 1
+		return
+	}
+	m := int(uint(l+r) >> 1)
+	t.build(x*2+1, l, m)
+	t.build(x*2+2, m+1, r)
+	t.pushup(x, l, m, r)
+}
+
+func (t *segmentTree) pushup(x, l, m, r int) {
+	lch, rch := x*2+1, x*2+2
+	t.lmx[x] = t.lmx[lch]
+	t.rmx[x] = t.rmx[rch]
+	t.mx[x] = max(t.mx[lch], t.mx[rch])
+	// can be merged
+	if t.str[m] == t.str[m+1] {
+		if t.lmx[lch] == m-l+1 {
+			t.lmx[x] += t.lmx[rch]
+		}
+		if t.rmx[rch] == r-(m+1)-1 {
+			t.rmx[x] += t.rmx[lch]
+		}
+		t.mx[x] = max(t.mx[x], t.rmx[lch]+t.lmx[rch])
+	}
+}
+
+func (t *segmentTree) update(x, l, r, pos int, val byte) {
+	if l == r {
+		t.str[pos] = val
+		return
+	}
+	m := int(uint(l+r) >> 1)
+	if pos <= m {
+		t.update(x*2+1, l, m, pos, val)
+	} else {
+		t.update(x*2+2, m+1, r, pos, val)
+	}
+	t.pushup(x, l, m, r)
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+func longestRepeating(s string, queryCharacters string, queryIndices []int) []int {
+	ans := make([]int, len(queryCharacters))
+	t := newSegmentTree(s)
+	n := len(s)
+	for i, c := range queryCharacters {
+		t.update(0, 0, n-1, queryIndices[i], byte(c))
+		ans[i] = t.mx[0]
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2200-2299/2213.Longest Substring of One Repeating Character/README_EN.md

@@ -16,9 +16,9 @@
 <pre>
 <strong>Input:</strong> s = &quot;babacc&quot;, queryCharacters = &quot;bcb&quot;, queryIndices = [1,3,3]
 <strong>Output:</strong> [3,3,4]
-<strong>Explanation:</strong> 
+<strong>Explanation:</strong>
 - 1<sup>st</sup> query updates s = &quot;<u>b<strong>b</strong>b</u>acc&quot;. The longest substring consisting of one repeating character is &quot;bbb&quot; with length 3.
-- 2<sup>nd</sup> query updates s = &quot;bbb<u><strong>c</strong>cc</u>&quot;. 
+- 2<sup>nd</sup> query updates s = &quot;bbb<u><strong>c</strong>cc</u>&quot;.
   The longest substring consisting of one repeating character can be &quot;bbb&quot; or &quot;ccc&quot; with length 3.
 - 3<sup>rd</sup> query updates s = &quot;<u>bbb<strong>b</strong></u>cc&quot;. The longest substring consisting of one repeating character is &quot;bbbb&quot; with length 4.
 Thus, we return [3,3,4].
@@ -367,6 +367,91 @@ public:
 };
 ```
 
+### **Go**
+
+```go
+type segmentTree struct {
+	str []byte
+	mx  []int
+	lmx []int
+	rmx []int
+}
+
+func newSegmentTree(s string) *segmentTree {
+	n := len(s)
+	t := &segmentTree{
+		str: []byte(s),
+		mx:  make([]int, n<<2),
+		lmx: make([]int, n<<2),
+		rmx: make([]int, n<<2),
+	}
+	t.build(0, 0, n-1)
+	return t
+}
+
+func (t *segmentTree) build(x, l, r int) {
+	if l == r {
+		t.lmx[x] = 1
+		t.rmx[x] = 1
+		t.mx[x] = 1
+		return
+	}
+	m := int(uint(l+r) >> 1)
+	t.build(x*2+1, l, m)
+	t.build(x*2+2, m+1, r)
+	t.pushup(x, l, m, r)
+}
+
+func (t *segmentTree) pushup(x, l, m, r int) {
+	lch, rch := x*2+1, x*2+2
+	t.lmx[x] = t.lmx[lch]
+	t.rmx[x] = t.rmx[rch]
+	t.mx[x] = max(t.mx[lch], t.mx[rch])
+	// can be merged
+	if t.str[m] == t.str[m+1] {
+		if t.lmx[lch] == m-l+1 {
+			t.lmx[x] += t.lmx[rch]
+		}
+		if t.rmx[rch] == r-(m+1)-1 {
+			t.rmx[x] += t.rmx[lch]
+		}
+		t.mx[x] = max(t.mx[x], t.rmx[lch]+t.lmx[rch])
+	}
+}
+
+func (t *segmentTree) update(x, l, r, pos int, val byte) {
+	if l == r {
+		t.str[pos] = val
+		return
+	}
+	m := int(uint(l+r) >> 1)
+	if pos <= m {
+		t.update(x*2+1, l, m, pos, val)
+	} else {
+		t.update(x*2+2, m+1, r, pos, val)
+	}
+	t.pushup(x, l, m, r)
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+func longestRepeating(s string, queryCharacters string, queryIndices []int) []int {
+	ans := make([]int, len(queryCharacters))
+	t := newSegmentTree(s)
+	n := len(s)
+	for i, c := range queryCharacters {
+		t.update(0, 0, n-1, queryIndices[i], byte(c))
+		ans[i] = t.mx[0]
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2200-2299/2213.Longest Substring of One Repeating Character/Solution.go

@@ -0,0 +1,80 @@
+type segmentTree struct {
+	str []byte
+	mx  []int
+	lmx []int
+	rmx []int
+}
+
+func newSegmentTree(s string) *segmentTree {
+	n := len(s)
+	t := &segmentTree{
+		str: []byte(s),
+		mx:  make([]int, n<<2),
+		lmx: make([]int, n<<2),
+		rmx: make([]int, n<<2),
+	}
+	t.build(0, 0, n-1)
+	return t
+}
+
+func (t *segmentTree) build(x, l, r int) {
+	if l == r {
+		t.lmx[x] = 1
+		t.rmx[x] = 1
+		t.mx[x] = 1
+		return
+	}
+	m := int(uint(l+r) >> 1)
+	t.build(x*2+1, l, m)
+	t.build(x*2+2, m+1, r)
+	t.pushup(x, l, m, r)
+}
+
+func (t *segmentTree) pushup(x, l, m, r int) {
+	lch, rch := x*2+1, x*2+2
+	t.lmx[x] = t.lmx[lch]
+	t.rmx[x] = t.rmx[rch]
+	t.mx[x] = max(t.mx[lch], t.mx[rch])
+	// can be merged
+	if t.str[m] == t.str[m+1] {
+		if t.lmx[lch] == m-l+1 {
+			t.lmx[x] += t.lmx[rch]
+		}
+		if t.rmx[rch] == r-(m+1)-1 {
+			t.rmx[x] += t.rmx[lch]
+		}
+		t.mx[x] = max(t.mx[x], t.rmx[lch]+t.lmx[rch])
+	}
+}
+
+func (t *segmentTree) update(x, l, r, pos int, val byte) {
+	if l == r {
+		t.str[pos] = val
+		return
+	}
+	m := int(uint(l+r) >> 1)
+	if pos <= m {
+		t.update(x*2+1, l, m, pos, val)
+	} else {
+		t.update(x*2+2, m+1, r, pos, val)
+	}
+	t.pushup(x, l, m, r)
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+func longestRepeating(s string, queryCharacters string, queryIndices []int) []int {
+	ans := make([]int, len(queryCharacters))
+	t := newSegmentTree(s)
+	n := len(s)
+	for i, c := range queryCharacters {
+		t.update(0, 0, n-1, queryIndices[i], byte(c))
+		ans[i] = t.mx[0]
+	}
+	return ans
+}