Las cadenas de paréntesis válidas consisten solo en "(" y ")" y cumplen una de las siguientes condiciones:
Una
concatenación de cadena vacía , que puede registrarse como AB (A y B están concatenadas), donde A y B son cadenas de paréntesis válidas
Anidadas, que pueden registrarse como (A), donde A es una cadena de paréntesis válida
De manera similar, podemos definir la profundidad de profundidad de anidamiento (S) de cualquier cadena de paréntesis válida s: cuando
s está vacío, la profundidad ("") = 0
s es cuando A y B están conectados, la profundidad (A + B) = max ( profundidad (A), profundidad (B)), donde A y B son ambas cadenas de paréntesis válidas
s están anidadas, profundidad ("(" + A + ")") = 1 + profundidad (A), donde A es Cadena de soporte válida
Por ejemplo: "", "() ()" y "() (() ())" son cadenas de paréntesis válidas, y la profundidad de anidación es 0, 1, 2, respectivamente, mientras que ") (" y "((( ) ”No son cadenas de paréntesis válidas.
Le da una secuencia de cadena de paréntesis válida, divídala en dos subsecuencias disjuntas A y B, y A y B satisfacen la definición de cadena de paréntesis válida (nota: A.length + B.length = seq.length).
Ahora, debe seleccionar cualquier conjunto de cadenas de paréntesis válidas A y B para minimizar los posibles valores de max (profundidad (A), profundidad (B)).
Devuelva la respuesta de la matriz de respuestas cuya longitud es longitud seq. La regla de codificación para elegir A o B es: Si seq [i] es parte de A, entonces responda [i] = 0. De lo contrario, responda [i] = 1. Incluso si hay varias respuestas que cumplen con los requisitos, solo necesita devolver una.
Ejemplo 1:
Entrada: seq = "(() ())"
Salida: [0,1,1,1,1,0]
Ejemplo 2:
Entrada: seq = "() (()) ()"
Salida: [0,0,0,1,1,0,1,1]
Consejo:
1 <= text.size <= 10000
Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings El
copyright pertenece a la red de deducción. Comuníquese con la autorización oficial para la reimpresión comercial e indique la fuente de la reimpresión no comercial.
Ideas
El título es muy problemático. Esta pregunta significa encontrar una manera de dividir la cadena original en dos subcadenas, de modo que ambas subcadenas sean paréntesis válidos, y la profundidad de los paréntesis de las dos subcadenas es la más pequeña. Hoy es un día tonto, así que pensé de un vistazo Esta pregunta es una mochila 01, engañada
De hecho, la idea es muy simple: queremos reducir la profundidad de la cadena formada por las subsecuencias dividiendo las dos subsecuencias. Esta profundidad es en realidad la profundidad de la pila entre paréntesis válidos .
Reduzca
la profundidad. La profundización causada por el anidamiento no se puede evitar, pero podemos compensar esta profundidad moviéndonos a una nueva secuencia . Por ejemplo, el corchete actual está anidado en un corchete con una profundidad de n, pero siempre que lo seleccionemos en una subsecuencia B (suponiendo que B está vacío en este momento), entonces su profundidad es 0
Sin embargo, como hay más y más pares de paréntesis seleccionados en B, debido a que la subsecuencia misma también tiene un anidamiento profundo, la profundidad de la secuencia B será cada vez más profunda. Cómo elegir una estrategia de selección para equilibrar la profundidad Que?
Estrategia de asignación ¿
Piensa en cómo los árboles binarios equilibrados equilibran la altura? Intenta dividir los nodos por igual en ambos lados
Del mismo modo, adoptamos la estrategia de división equitativa, colocando los corchetes con profundidades impares en la secuencia A, y los corchetes con profundidades pares en la secuencia B.
Por supuesto, puede haber otras estrategias, como el primer 1/2 de la profundidad se coloca en A, y el último 1 / 2 Póngalo en B, siempre que sean dos puntos
Código
Tenga en cuenta que no hay pila para simular. Debido a que la profundidad de la pila debe ser -1, y la profundidad de la pila debe ser +1, por lo que puede mantener el int. Tenga en cuenta que la profundidad se reduce después de que se elimina la pila, por lo que la declaración de profundidad se coloca después del juicio
class Solution {
public:
vector<int> maxDepthAfterSplit(string seq)
{
vector<int> ans(seq.length());
int depth = 0;
for(int i=0; i<seq.length(); i++)
{
if(seq[i]=='(') depth++;
if(depth%2==0) ans[i]=1;
else ans[i]=0;
if(seq[i]==')') depth--;
}
return ans;
}
};
