feat: add solutions to lc problem: No.3628 (#4601)

No.3628.Maximum Number of Subsequences After One Inserting

Author: yanglbme

solution/3600-3699/3628.Maximum Number of Subsequences After One Inserting/README.md

@@ -75,32 +75,201 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3628.Ma
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：枚举
+
+我们可以先计算出原字符串中 "LCT" 的子序列数量，然后考虑插入一个字母的情况。
+
+计算 "LCT" 子序列的数量可以通过遍历字符串来实现。我们可以枚举中间的 "C"，用两个变量 $l$ 和 $r$ 分别维护左右两侧的 "L" 和 "T" 的数量。对于每个 "C"，我们可以计算出它左侧的 "L" 的数量和右侧的 "T" 的数量，从而得到以该 "C" 为中间的 "LCT" 子序列数量为 $l \times r$，累加到总数中。
+
+接下来，我们需要考虑插入一个字母的情况。考虑到插入一个 "L" 或 "C" 或 "T" 的情况：
+
+-   插入一个 "L"，那么我们只需要统计原字符串中 "CT" 的子序列数量。
+-   插入一个 "T"，那么我们只需要统计原字符串中 "LC" 的子序列数量。
+-   插入一个 "C"，那么我们只需要统计原字符串中 "LT" 的子序列数量，这种情况下，我们可以在前面枚举的过程中，维护一个变量 $\textit{mx}$，表示当前最大的 $l \times r$ 的值。
+
+最后，我们将原字符串中 "LCT" 的子序列数量加上插入一个字母后的最大子序列数量，得到最终结果。
+
+时间复杂度 $O(n)$，其中 $n$ 是字符串的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def numOfSubsequences(self, s: str) -> int:
+        def calc(t: str) -> int:
+            cnt = a = 0
+            for c in s:
+                if c == t[1]:
+                    cnt += a
+                a += int(c == t[0])
+            return cnt
+
+        l, r = 0, s.count("T")
+        ans = mx = 0
+        for c in s:
+            r -= int(c == "T")
+            if c == "C":
+                ans += l * r
+            l += int(c == "L")
+            mx = max(mx, l * r)
+        mx = max(mx, calc("LC"), calc("CT"))
+        ans += mx
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private char[] s;
+
+    public long numOfSubsequences(String S) {
+        s = S.toCharArray();
+        int l = 0, r = 0;
+        for (char c : s) {
+            if (c == 'T') {
+                ++r;
+            }
+        }
+        long ans = 0, mx = 0;
+        for (char c : s) {
+            r -= c == 'T' ? 1 : 0;
+            if (c == 'C') {
+                ans += 1L * l * r;
+            }
+            l += c == 'L' ? 1 : 0;
+            mx = Math.max(mx, 1L * l * r);
+        }
+        mx = Math.max(mx, Math.max(calc("LC"), calc("CT")));
+        ans += mx;
+        return ans;
+    }
+
+    private long calc(String t) {
+        long cnt = 0;
+        int a = 0;
+        for (char c : s) {
+            if (c == t.charAt(1)) {
+                cnt += a;
+            }
+            a += c == t.charAt(0) ? 1 : 0;
+        }
+        return cnt;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long numOfSubsequences(string s) {
+        auto calc = [&](string t) {
+            long long cnt = 0, a = 0;
+            for (char c : s) {
+                if (c == t[1]) {
+                    cnt += a;
+                }
+                a += (c == t[0]);
+            }
+            return cnt;
+        };
+
+        long long l = 0, r = count(s.begin(), s.end(), 'T');
+        long long ans = 0, mx = 0;
+        for (char c : s) {
+            r -= (c == 'T');
+            if (c == 'C') {
+                ans += l * r;
+            }
+            l += (c == 'L');
+            mx = max(mx, l * r);
+        }
+        mx = max(mx, calc("LC"));
+        mx = max(mx, calc("CT"));
+        ans += mx;
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func numOfSubsequences(s string) int64 {
+	calc := func(t string) int64 {
+		cnt, a := int64(0), int64(0)
+		for _, c := range s {
+			if c == rune(t[1]) {
+				cnt += a
+			}
+			if c == rune(t[0]) {
+				a++
+			}
+		}
+		return cnt
+	}
+
+	l, r := int64(0), int64(0)
+	for _, c := range s {
+		if c == 'T' {
+			r++
+		}
+	}
+
+	ans, mx := int64(0), int64(0)
+	for _, c := range s {
+		if c == 'T' {
+			r--
+		}
+		if c == 'C' {
+			ans += l * r
+		}
+		if c == 'L' {
+			l++
+		}
+		mx = max(mx, l*r)
+	}
+	mx = max(mx, calc("LC"), calc("CT"))
+	ans += mx
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function numOfSubsequences(s: string): number {
+    const calc = (t: string): number => {
+        let [cnt, a] = [0, 0];
+        for (const c of s) {
+            if (c === t[1]) cnt += a;
+            if (c === t[0]) a++;
+        }
+        return cnt;
+    };
+
+    let [l, r] = [0, 0];
+    for (const c of s) {
+        if (c === 'T') r++;
+    }
+
+    let [ans, mx] = [0, 0];
+    for (const c of s) {
+        if (c === 'T') r--;
+        if (c === 'C') ans += l * r;
+        if (c === 'L') l++;
+        mx = Math.max(mx, l * r);
+    }
+
+    mx = Math.max(mx, calc('LC'));
+    mx = Math.max(mx, calc('CT'));
+    ans += mx;
+    return ans;
+}
 ```
 
 <!-- tabs:end -->