[LeetCode] 678. Cadena de paréntesis válida

Dada una cadena que contiene solo tres tipos de caracteres: '(', ')' y '*', escriba una función para verificar si esta cadena es válida. Definimos la validez de una cadena por estas reglas:

• Cualquier paréntesis izquierdo '(' debe tener un paréntesis derecho correspondiente ')'.
• Cualquier paréntesis derecho ')' debe tener un paréntesis izquierdo correspondiente '('.
• Paréntesis izquierdo '(' debe ir antes del paréntesis derecho correspondiente ')'.
• '*' podría tratarse como un paréntesis derecho único ')' o un paréntesis izquierdo único '(' o una cadena vacía.
• Una cadena vacía también es válida.

Ejemplo 1:

Input: "()"
Output: True

Ejemplo 2

Input: "(*)"
Output: True

Ejemplo 3

Input: "(*))"
Output: True

Nota:

• El tamaño de la cadena estará en el rango [1, 100]. Esta
  pregunta la conté desde el principio, pero resultó que el orden es muy importante, y el conteo simple no funciona. Luego cambié a otro método, que es crear una matriz y leer un carácter. Si es (y #, simplemente agregue la matriz primero, si es así), luego mire por primera vez la última de esta matriz (, elimine esto (aquí Solía ​​# para reemplazar), si no hay (, luego encuentre el último , cuando todos los bucles hayan terminado, y luego lea la matriz de atrás hacia adelante, vea (¿se puede neutralizar todo?

class Solution:
    def checkValidString(self, s: str) -> bool:
        if not s: return True
        chars = []
        for char in s:
            if char == "(" or char == "*":
                chars.append(char)
            else:
                index = self.find_last_element('(', chars)
                if index != -1:
                    chars[index] = '#'
                else:
                    index = self.find_last_element('*', chars)
                    if index != -1:
                        chars[index] = '#'
                    else:
                        return False

        count = 0
        for i in range(len(chars)-1, -1 , -1):
            if chars[i] == '*':
                count += 1
            elif chars[i] == '(':
                if count > 0:
                    count -= 1
                else:
                    return False
            
        return True
    
    def find_last_element(self, char: str, chars: list) -> int:
        for i in range(len(chars)-1, -1, -1):
            if chars[i] == char:
                return i
        return -1

Pero, de hecho, esta pregunta es porque quiero encontrar la última (o eliminarla. Hay una estructura de datos que es adecuada para esto, que es la pila. Puede construir dos pilas, una de almacenamiento izquierda (índice, índice de almacenamiento de una estrella y luego encontrar) Solo haga estallar la pila izquierda primero y haga estallar la estrella si está vacía. Si ambas están vacías, devuelva falso. Si las dos últimas tienen excedente, entonces vea si la parte superior de la izquierda pop siempre es más pequeña que la estrella. El tiempo es complicado El grado es O (N), la complejidad del espacio es O (N)

class Solution:
    def checkValidString(self, s: str) -> bool:
        if not s: return True
        left, star = [], []
        for i in range(len(s)):
            if s[i] == '(': left.append(i)
            elif s[i] == '*': star.append(i)
            else:
                if not left and not star: return False
                if left: left.pop()
                else: star.pop()
        while left and star:
            if left[-1] > star[-1]: return False
            left.pop()
            star.pop()
        return not left

Hay otra solución que vi en Internet, es la codicia. Es utilizar dos valores, bajo y alto, registro bajo si todos * son corchetes correctos, el valor mínimo del corchete izquierdo. registros altos si todas las estrellas son paréntesis izquierdos, el valor máximo que puede tener el paréntesis izquierdo. Si bajo es mayor que 0, significa que hay demasiados corchetes izquierdos, incluso si todas las estrellas se consideran corchetes correctos, no es suficiente para neutralizar, si alto es menor que cero, significa que hay demasiados corchetes derechos y no es suficiente contar todas las estrellas como corchetes izquierdos. . Cuando leemos un número que queda entre paréntesis, tanto bajo como alto aumentan en uno. Si leemos un paréntesis derecho, si bajo es mayor que 0, disminuye en uno y alto disminuye en uno. Si la lectura es una estrella, entonces si Cuando bajo es mayor que 0, bajo disminuye en uno y alto aumenta en uno. Si alto es menor que cero en este momento, es falso. Finalmente, determine si bajo es 0. De esta manera, la complejidad del tiempo es O (N), y la complejidad del espacio es O (1).

class Solution:
    def checkValidString(self, s: str) -> bool:
        low, high = 0, 0
        for char in s:
            if char == '(':
                low += 1
                high += 1
            elif char == ')':
                if low > 0: low -= 1
                high -= 1
            else:
                if low > 0: low -= 1
                high += 1
            if high < 0: return False
        return low == 0