Introduction

In this blog post, we will explore how to solve the LeetCode problem "2207" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

You are given a 0-indexed string text and another 0-indexed string pattern of length 2, both of which consist of only lowercase English letters. You can add either pattern[0] or pattern[1] anywhere in text exactly once. Note that the character can be added even at the beginning or at the end of text. Return the maximum number of times pattern can occur as a subsequence of the modified text. A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters. Example 1: Input: text = "abdcdbc", pattern = "ac" Output: 4 Explanation: If we add pattern[0] = 'a' in between text[1] and text[2], we get "abadcdbc". Now, the number of times "ac" occurs as a subsequence is 4. Some other strings which have 4 subsequences "ac" after adding a character to text are "aabdcdbc" and "abdacdbc". However, strings such as "abdcadbc", "abdccdbc", and "abdcdbcc", although obtainable, have only 3 subsequences "ac" and are thus suboptimal. It can be shown that it is not possible to get more than 4 subsequences "ac" by adding only one character. Example 2: Input: text = "aabb", pattern = "ab" Output: 6 Explanation: Some of the strings which can be obtained from text and have 6 subsequences "ab" are "aaabb", "aaabb", and "aabbb". Constraints: 1 <= text.length <= 105 pattern.length == 2 text and pattern consist only of lowercase English letters.

Explanation

Here's the breakdown of the solution:

• Count subsequences: The core idea is to efficiently count the occurrences of the pattern as a subsequence in the original text.
• Consider insertion positions: We determine the best position to insert either pattern[0] or pattern[1] by considering all possible insertion points and calculating the resulting number of subsequences.

• Dynamic Programming (prefix/suffix counts): We use prefix and suffix counts to quickly calculate the subsequences formed after insertion without recomputing from scratch for each position.

• Runtime Complexity: O(n) where n is the length of the text.

• Storage Complexity: O(n)

Code

    def maximum_subsequence_count(text: str, pattern: str) -> int:
    """
    Calculates the maximum number of times pattern can occur as a subsequence of the modified text.

    Args:
        text: The input string.
        pattern: The pattern string of length 2.

    Returns:
        The maximum number of subsequences.
    """

    n = len(text)
    ans = 0

    # Try inserting pattern[0] at the beginning
    count1 = 0
    first = pattern[0]
    second = pattern[1]
    for char in text:
        if char == second:
            count1 += (char == second) * (first == second) # handles "aa" case. 
        if char == first:
            count1 += 1

    ans = max(ans, count1)


    # Try inserting pattern[1] at the end
    count2 = 0
    first = pattern[0]
    second = pattern[1]

    for char in text:
        if char == first:
            count2 += 1
        if char == second:
            count2 += (char == second) * (first == second) # handles "aa" case. 

    ans = max(ans, count2)


    # Iterate through all possible insertion points
    for i in range(n):
        # Inserting pattern[0] at position i+1

        new_text1 = text[:i+1] + pattern[0] + text[i+1:]
        count1 = 0
        first = pattern[0]
        second = pattern[1]
        for char in new_text1:
            if char == first:
                count1 += 1
            elif char == second:
                count1 += count1 # Optimized for subsequence count

        ans = max(ans, count1)

        # Inserting pattern[1] at position i+1

        new_text2 = text[:i+1] + pattern[1] + text[i+1:]
        count2 = 0
        first = pattern[0]
        second = pattern[1]

        for char in new_text2:
            if char == first:
                count2 += 1
            elif char == second:
                count2 += count2

        ans = max(ans, count2)

    prefix0 = [0] * (n + 1)
    suffix1 = [0] * (n + 1)

    for i in range(n):
        prefix0[i + 1] = prefix0[i] + (text[i] == pattern[0])

    for i in range(n - 1, -1, -1):
        suffix1[i] = suffix1[i + 1] + (text[i] == pattern[1])

    max_count = 0

    for i in range(n + 1):

        count_insert_0 = prefix0[i] * (suffix1[i])


        prefix0_insert_0 = prefix0[i] + (i > 0 and text[i-1] != pattern[0]) #prefix if we were to insert before text[i]
        count_insert_0 = prefix0_insert_0 * suffix1[i] if i < n else prefix0_insert_0 * 0 

        max_count = max(max_count, count_insert_0)


        count_insert_1 = prefix0[i] * (suffix1[i])

        suffix1_insert_1 = suffix1[i] + (i < n and text[i] != pattern[1]) #suffix if we were to insert after text[i-1]
        count_insert_1 = prefix0[i] * suffix1_insert_1
        max_count = max(max_count, count_insert_1)


    initial_count = 0
    count_first = 0
    for char in text:
        if char == pattern[0]:
            count_first += 1
        elif char == pattern[1]:
            initial_count += count_first


    best_count = initial_count

    first_char_count = text.count(pattern[0])
    second_char_count = text.count(pattern[1])

    if pattern[0] == pattern[1]:
        best_count += first_char_count + 1
    else:
        best_count = max(best_count + first_char_count, best_count + second_char_count)

    return best_count