Introduction

In this blog post, we will explore how to solve the LeetCode problem "3223" 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 string s. You can perform the following process on s any number of times: Choose an index i in the string such that there is at least one character to the left of index i that is equal to s[i], and at least one character to the right that is also equal to s[i]. Delete the closest occurrence of s[i] located to the left of i. Delete the closest occurrence of s[i] located to the right of i. Return the minimum length of the final string s that you can achieve. Example 1: Input: s = "abaacbcbb" Output: 5 Explanation: We do the following operations: Choose index 2, then remove the characters at indices 0 and 3. The resulting string is s = "bacbcbb". Choose index 3, then remove the characters at indices 0 and 5. The resulting string is s = "acbcb". Example 2: Input: s = "aa" Output: 2 Explanation: We cannot perform any operations, so we return the length of the original string. Constraints: 1 <= s.length <= 2 * 105 s consists only of lowercase English letters.

Explanation

Here's a breakdown of the approach and the code:

• Identify Removable Sections: The core idea is to efficiently identify and remove sections of the string that meet the removal criteria. A section can be removed if it's surrounded by identical characters.

• Iterative Removal: We repeatedly scan the string, identifying and removing these sections. The process continues until no more removable sections are found.

• Optimization: The key optimization is to maintain left and right pointers for each character in the string. This avoids redundant searches for matching characters during the removal process.

• Runtime & Storage Complexity: O(N) for runtime complexity and O(N) for storage complexity, where N is the length of the string.

Code

    def min_length(s: str) -> int:
    """
    Given a string s, return the minimum length of the final string s that you can achieve.
    """
    n = len(s)
    left = list(range(-1, n - 1))
    right = list(range(1, n + 1))
    alive = [True] * n
    q = []

    for i in range(n):
        if left[i] >= 0 and right[i] < n and s[left[i]] == s[i] == s[right[i]]:
            q.append(i)

    while q:
        i = q.pop(0)
        if not alive[i]:
            continue

        l, r = left[i], right[i]
        if l >= 0 and r < n and s[l] == s[i] == s[r]:
            alive[i] = False
            alive[l] = False
            alive[r] = False
            right[l] = right[r]
            left[right[r]] = left[l]

            if left[l] >= 0 and right[right[r]] < n and s[left[l]] == s[right[r]]:
                q.append(right[r])
            if left[l] >= 0 and right[l] < n and s[left[l]] == s[l] == s[right[l]]:
                q.append(l)

    return sum(alive)