1class Solution {
2    private char[] s; // Character array to store the string
3
4    // Main method to count the number of specific subsequences
5    public long numOfSubsequences(String S) {
6        s = S.toCharArray();
7
8        int countL = 0; // Counts number of 'L's seen so far (to the left)
9        int countT = 0; // Counts number of 'T's remaining (to the right, including current)
10        for (char c : s) {
11            if (c == 'T') {
12                ++countT;
13            }
14        }
15
16        long total = 0;   // Final answer
17        long maxVal = 0;  // Maximum l * r seen for 'C' position
18
19        // Traverse the string to calculate the number of valid subsequences
20        for (char c : s) {
21            if (c == 'T') {
22                countT--;
23            }
24            if (c == 'C') {
25                // For each 'C', add number of valid subsequences "L...C...T"
26                total += 1L * countL * countT;
27            }
28            if (c == 'L') {
29                countL++;
30            }
31            // Keep track of the maximum l * r for use later
32            maxVal = Math.max(maxVal, 1L * countL * countT);
33        }
34
35        // Also consider the maximum values for "LC" and "CT" subsequences
36        maxVal = Math.max(maxVal, Math.max(calc("LC"), calc("CT")));
37        total += maxVal;
38
39        return total;
40    }
41
42    // Helper method to count subsequences of type "ab" in the string
43    // For each 'b', add the current count of 'a' before it
44    private long calc(String pattern) {
45        long count = 0;
46        int countA = 0;
47        for (char c : s) {
48            if (c == pattern.charAt(1)) {
49                count += countA;
50            }
51            if (c == pattern.charAt(0)) {
52                countA++;
53            }
54        }
55        return count;
56    }
57}
58

1class Solution {
2public:
3    long long numOfSubsequences(string s) {
4        // Helper lambda to count subsequences "ab" in string s
5        auto countSubseq = [&](string ab) {
6            long long count = 0;
7            long long count_a = 0;
8            for (char c : s) {
9                if (c == ab[1]) {
10                    // For each 'b', add number of previous 'a's
11                    count += count_a;
12                }
13                if (c == ab[0]) {
14                    ++count_a;
15                }
16            }
17            return count;
18        };
19
20        long long count_L = 0;                        // Number of 'L's seen so far
21        long long count_T_remain = count(s.begin(), s.end(), 'T'); // Number of 'T's to the right
22        long long total = 0;                          // Accumulated answer
23        long long max_any_pattern = 0;                // Track the max of possible patterns
24
25        // Pass through the string to count the "L C T" triplet patterns
26        for (char c : s) {
27            if (c == 'T') {
28                --count_T_remain;
29            }
30            if (c == 'C') {
31                total += count_L * count_T_remain; // Count "L C T" for every 'C'
32            }
33            if (c == 'L') {
34                ++count_L;
35            }
36            // Track the max product of current counts for any update
37            max_any_pattern = max(max_any_pattern, count_L * count_T_remain);
38        }
39
40        // Consider the max of the pure pairs "LC" and "CT"
41        max_any_pattern = max(max_any_pattern, countSubseq("LC"));
42        max_any_pattern = max(max_any_pattern, countSubseq("CT"));
43
44        // Add the best possible extra pair to the overall answer
45        total += max_any_pattern;
46        return total;
47    }
48};
49

1/**
2 * Calculates the number of specific subsequences in a string.
3 * @param s Input string consisting of 'L', 'C', 'T'
4 * @returns Number of subsequences as per the logic
5 */
6function numOfSubsequences(s: string): number {
7    /**
8     * Helper function to count the number of subsequences
9     * for a given two-character pattern (first, second) in s.
10     * @param pattern String of length 2 (e.g., 'LC', 'CT')
11     * @returns Count of such subsequences in s
12     */
13    const calc = (pattern: string): number => {
14        let count = 0; // Count of subsequences found
15        let firstCharCount = 0; // Number of times pattern[0] has appeared so far
16
17        for (const c of s) {
18            if (c === pattern[1]) count += firstCharCount; // Every previous pattern[0] forms a subsequence
19            if (c === pattern[0]) firstCharCount++;        // Increment count of pattern[0] found
20        }
21        return count;
22    };
23
24    // Initial pass: count number of 'T' for use in next loop
25    let leftL = 0;     // Number of 'L's to the left (encountered so far)
26    let rightT = 0;    // Number of 'T's to the right (remaining)
27    for (const c of s) {
28        if (c === 'T') rightT++;
29    }
30
31    let answer = 0;    // The answer to be returned
32    let maxCombo = 0;  // Maximum number of valid subsequences involving 'L'...'C'...'T'
33
34    for (const c of s) {
35        if (c === 'T') rightT--;          // Decrement count when passing over 'T'
36        if (c === 'C') answer += leftL * rightT; // For every 'C', all previous 'L's and remaining 'T's form sequences
37        if (c === 'L') leftL++;           // Count encountered 'L's for later subsequences
38        maxCombo = Math.max(maxCombo, leftL * rightT); // Track largest L-T pairing after current index
39    }
40
41    // Calculate max subsequences from ('L','C') and ('C','T') pairs for optimal combination
42    maxCombo = Math.max(maxCombo, calc('LC'));
43    maxCombo = Math.max(maxCombo, calc('CT'));
44
45    answer += maxCombo; // Add maximum possible combinations from any single best pattern
46    return answer;
47}
48
49// Example usage (remove/comment when testing in actual LeetCode):
50// console.log(numOfSubsequences("LCTLTTC")); // Example test
51