Organice una cadena determinada en forma de Z de arriba a abajo y de izquierda a derecha de acuerdo con el número de líneas dado. Después de eso, su salida debe leerse línea por línea de izquierda a derecha para generar una nueva cadena.

Repita ss de izquierda a derecha, agregando cada carácter a la línea apropiada. La fila apropiada se puede rastrear usando la fila actual y las variables de dirección actual. La dirección actual solo cambiará cuando subamos a la fila superior o bajemos a la fila inferior.

solución de clase { conversión de cadena pública (cadena s, int numRows) { si (numRows == 1) devuelve s; List<StringBuilder> filas = new ArrayList<>() //Almacena los caracteres de cada fila después de la transformación. para (int i = 0; i < Math.min(numRows, s.length()); i ) filas.add(new StringBuilder()); int curRow = 0; booleano yendo hacia abajo = falso; for (char c : s.toCharArray()) { //Atraviesa s directamente, conviértelo en una matriz de caracteres y asígnalo a c uno por uno filas.get(curRow).append(c); if (curRow == 0 || curRow == numRows - 1) yendoAbajo = !yendoAbajo; curRow = yendo hacia abajo? 1: -1; } StringBuilder ret = nuevo StringBuilder(); para (StringBuilder fila: filas) ret.append(fila); devolver ret.toString(); } }

Tiempo O(n), donde n=len(s), espacio O(n)

La importación se realiza en la parte superior del archivo, después del comentario del archivo. La importación suele ser una importación de una sola línea o desde... importar.

1. Importación de biblioteca estándar 2. Importaciones de terceros relevantes 3. Importaciones de bibliotecas/aplicaciones locales específicas Coloque una línea en blanco entre cada grupo de importación. Se recomiendan las importaciones absolutas porque son más legibles; se pueden utilizar importaciones relativas explícitas en lugar de importaciones absolutas cuando se trata de diseños de paquetes complejos, que son demasiado detallados.

1.int(x)

2.flotar(x)

3.cadena(x)

mapa(evaluación,lista)

si tipo(n) == tipo(123):

pila.append()

pila.pop()

No hay ningún método de vista previa en la lista. Solo puede aparecer primero y luego agregar.

cola.append()

cola.pop(0)

cola.append()

cola.popleft()

A medida que el nivel de desarrollo de todos mejora y la complejidad del programa aumenta, se utilizarán cada vez más módulos y bibliotecas de terceros en el programa. El motivo de este error es que la biblioteca "XX" no está instalada, pip install ww.

Descargue el paquete de instalación de terceros correspondiente e ingrese al directorio de descarga para instalar el nombre completo del archivo descargado.

Instale Microsoft Visual C 14.0, el blog tiene la dirección de descarga visualcppbuildtools_full

rueda de instalación pip3

Si le pregunta qué archivo de módulo tiene un error, busque este módulo, elimínelo y reemplácelo con el mismo archivo de un amigo que pueda ejecutarse.

1. El nombre del archivo entra en conflicto con las palabras clave propias de Python y similares.

2. Dos archivos py se importan entre sí, lo que provoca que uno de ellos se elimine.

El problema de la versión 10.0 de pip no tiene main(), Es necesario degradar la versión: python -m pip install –upgrade pip==9.0.1

Algunas API cambiaron después de Pip v10, lo que resultó en incompatibilidad entre las versiones antiguas y nuevas, lo que afecta nuestra instalación y actualización de paquetes. ¡Simplemente actualice el IDE y listo! Al actualizar, el IDE también nos dio indicaciones amigables. PyCharm -> Ayuda -> Buscar actualizaciones

No actualice la versión descifrada; de lo contrario, la información de activación dejará de ser válida.

Nombraste un archivo asyncio py Si la verificación no es la primera, debe verificar su versión de Python porque python3.7 y versiones posteriores solo admiten el método de ejecución. 1 Actualizar la versión de Python 2 ejecución se reescribe de la siguiente manera bucle = asyncio.get_event_loop() resultado = loop.run_until_complete(coro)

Reemplazar archivos de constantes en asyncio

t=('a','b','c') para i en el rango (t):

Problema típico de error de tipo En el código anterior, la función range() espera que el parámetro entrante sea un número entero (entero), pero el parámetro entrante es una tupla (tupla). La solución es cambiar el parámetro de entrada tupla t a The. El número de tuplas puede ser de tipo entero len(t). Por ejemplo, cambie rango(t) en el código anterior a rango(len(t)).

Causado al intentar modificar el valor de una cadena, que es un tipo de datos inmutable

s[3] = 'a' se convierte en s = s[:3] 'a' s[4:]

Causado por intentar concatenar un valor que no es una cadena con una cadena, simplemente convierta el valor que no es una cadena en una cadena con str()

Cuando se utiliza la función set para construir un conjunto, los elementos de la lista de parámetros dada no pueden contener listas como parámetros.

Al cambiar entre python2 y python3, inevitablemente encontrará algunos problemas. Las cadenas Unicode en python3 están en el formato predeterminado (tipo str) y las cadenas codificadas en ASCII (tipo bytes) contienen valores de bytes y en realidad no lo son. un carácter. String, python3 y tipo de matriz de bytes bytearray) debe estar precedido por el operador b o B, en python2, es lo contrario, la cadena codificada en ASCII es la predeterminada y la cadena Unicode debe estar precedida por el operador u o U;

import chardet #Necesita importar este módulo y detectar el formato de codificación tipo_codificación = chardet.detect(html) html = html.decode(encode_type['encoding']) #Decodifica en consecuencia y asígnalo al identificador original (variable)

>>> f=abrir ("hola.py") >>> f.escribir ("prueba")

La causa del error es que el modo de parámetro del modo lectura-escritura no se agrega a los parámetros entrantes de open ("hello.py"), lo que significa que la forma predeterminada de abrir el archivo es de solo lectura.

La solución es cambiar el modo modo a permiso de modo de escritura w, f = open("hello. py", "w ")

Causado por olvidar agregar dos puntos al final de declaraciones como if, elif, else, for, while, class y def.

Usar incorrectamente "=" en lugar de "==" En los programas Python, "=" es un operador de asignación y "==" es una operación de comparación igual.

La mayoría de las veces esto se debe a que el archivo no está codificado en UTF8 (por ejemplo, puede estar codificado en GBK) y el sistema utiliza la decodificación UTF8 de forma predeterminada. La solución es cambiar al método de decodificación correspondiente: con open('acl-metadata.txt','rb') como datos:

abrir (ruta, '-modo-', codificación = 'UTF-8'), es decir, abrir (nombre del archivo de ruta, modo de lectura-escritura, codificación)

Modos de lectura y escritura más utilizados

Al llamar a una función, no hay suficientes variables para aceptar el valor de retorno.

1. Reinicie pycharm (básicamente inútil)

2. Establezca num_works en 0 (quizás inútil)

3. Aumente el tamaño del archivo de página (resuelva completamente el problema)

1. No solo se está ejecutando un proyecto, sino que también se está ejecutando el programa Python de otro proyecto, simplemente apáguelo.

2. El sistema operativo Windows no admite la operación multiproceso de Python. La red neuronal utiliza múltiples procesos en la carga de conjuntos de datos, así que establezca el parámetro num_workers en DataLoader en 0.

0. Recientemente, cuando estaba ejecutando un proyecto scrapy, el marco scrapy que se instaló de repente informó un error y me tomó por sorpresa.

1. Debido a que no es difícil instalar scrapy en Anaconda, no es tan simple y eficiente como reinstalar para encontrar una solución.

2. No puedo desinstalarlo por completo simplemente usando el comando conda remove scrapy. La razón puede ser que instalé scrapy dos veces usando pip y conda respectivamente. Los lectores pueden probar los comandos de desinstalación pip y conda.

pip desinstalar scrapy conda eliminar scrapy

Reinstale pip install scrapy

Solo modificamos A.x, ¿por qué también se modificó C.x? En los programas Python, las variables de clase se tratan internamente como diccionarios, que siguen el orden de resolución de métodos (MRO) comúnmente citado. Entonces, en el código anterior, dado que no se encuentra el atributo x en la clase C, buscará su clase base (aunque Python admite la herencia múltiple, solo hay A en el ejemplo anterior). En otras palabras, la clase C no tiene su propio atributo x, que es independiente de A. Por lo tanto, C.x es en realidad una referencia a A.x.

1. La variable local x no tiene valor inicial y la variable externa X no se puede introducir internamente.

Fool no asignó un valor a lst, pero Fool2 sí lo hizo. Ya sabes, lst = [5] es la abreviatura de lst = lst [5], y estamos intentando asignar un valor a lst (Python lo trata como una variable local). Además, nuestra asignación a lst se basa en el propio lst (que Python vuelve a tratarlo como una variable local), pero aún no se ha definido, por lo que se produce un error. Entonces aquí debemos distinguir entre el uso de variables locales y variables externas.

0.Obtén ayuda

0. Cambiar fuente de pips

1. Instale la biblioteca especificada

2. Instale la versión especificada de la biblioteca especificada.

3. Verifique qué bibliotecas están instaladas

4. Ver la información específica de la biblioteca.

5. ¿Dónde está instalado pip?

6. Biblioteca de instalación por lotes

7. Instale la biblioteca usando el archivo wheel.

8. Desinstalar la biblioteca

9.Actualizar biblioteca

10. Guarde la lista de bibliotecas en el archivo especificado.

11. Verifique las bibliotecas que deben actualizarse

12. Verifique si hay problemas de compatibilidad

13. Descargue la biblioteca a local.

pyinstaller -F nombre de archivo.py

1. Parámetros

2. Llamar

3.Método

subtema

1. Expresión de más y menos infinito

1. En Python / significa división normal con resto, // significa división entera sin resto.

2. ¡No! en Python está representado por no

3.El cuadrado en Python es **

1. Se deben agregar dos puntos después de todas las declaraciones relacionadas con palabras clave: excepto retorno

2. No es necesario agregar () a las condiciones en bucles, juicios y otras declaraciones similares, y no hay {} en los bloques de declaraciones. Utilice sangría para representar estrictamente el formato.

1. Comentario de una sola línea #

2. Comentarios de varias líneas ''' o """

dp = [[float('inf') para _ en rango(n)] para _ en rango(n)]

línea, = ax.plot(x, np.sin(x))

Comentarios de una sola línea#

También es la tecla de acceso directo de bloqueo de QQ. Cancela la configuración en QQ.

1.Barra de navegación barra de navegación

1.apariencia estilo general

2.configuración del sistemaconfiguración del sistema

1. Según la vista del sistema, puede buscar directamente (nota de comentario)

1. Fuente del código de fuente (tamaño ajustable)

2.Esquema de color Esquema de color del área del código

3. Estilo de código estilo de código

4.Inspecciones

5.Plantillas de archivos y códigos Plantillas de archivos y códigos

6.Codificación de archivos de codificaciones de archivos

7.Plantillas dinámicas Live Templates (fáciles de usar y dominar)

1.Intérprete del proyecto Project Interpret

1.Archivo

2.Nuevo archivo borrador

3.Directorio directorio

4.Archivo Python

5. Al crear un nuevo archivo HTML, puede hacer clic derecho en él y abrirlo en un navegador para ver el efecto de visualización.

1. Es lo mismo que el CMD del sistema. Puede instalar el paquete directamente aquí y usar el comando dos.

Puede escribir código Python directamente, ejecutarlo de forma interactiva y editarlo línea por línea.

Es equivalente a una nota. Escriba TODO ('') en el punto del código, para que pueda encontrarlo rápidamente y continuar trabajando. Puede usarse para la cooperación mutua.

El rigor de la verificación del código se puede ajustar. El modo de ahorro de energía equivale a colocar la flecha en el extremo izquierdo. No se verificarán todos los errores gramaticales.

max_v, m_i = flotante(-inf), 0 #Combinar un objeto de datos transitable (como una lista, tupla o cadena) en una secuencia de índice, Enumerar subíndices de datos y datos al mismo tiempo. para i, v en enumerar (numeros): si v > max_v: máx_v = v m_i = yo

max_v = max(núms) m_i = números.index(max_v)

1. Siempre que vea que la matriz proporcionada en la pregunta de la entrevista es una matriz ordenada, puede pensar si puede utilizar el método de dicotomía.

2. Los elementos de la matriz son continuos en la dirección de memoria. Un elemento de la matriz no se puede eliminar individualmente, solo se puede sobrescribir.

para (int i = 0; i < nums.length; i ) { for (int j = i 1; j < nums.length; j ) {

Cuando existe la restricción de que la cabeza y la cola no pueden estar al mismo tiempo, descomponga la matriz circular en varios problemas de matriz ordinarios y encuentre el valor máximo

1. Cerrado a la izquierda y cerrado a la derecha [izquierda, derecha]

2. Cerrar a la izquierda y abrir a la derecha [izquierda, derecha)

para (int i = 0; i < nums.length; i ) { int complemento = objetivo - nums[i]; if (map.containsKey(complemento) && map.get(complemento) != i)

1. En caso de inversión del orden: se deberá considerar por separado el posible problema de carry de la última incorporación.

2. En secuencia directa: invierta la lista vinculada/use la estructura de datos de la pila para lograr la inversión

Supongamos que el extremo izquierdo de la lista vinculada actual es el izquierdo, el extremo derecho es el derecho y la relación de inclusión es "cerrada a la izquierda, abierta a la derecha". La lista vinculada dada es una lista vinculada unidireccional. elementos posteriores, pero no puede acceder directamente a los elementos predecesores. Por lo tanto, después de encontrar el nodo mediano en el medio de la lista vinculada, si establece la relación de "cerrado a la izquierda, abierto a la derecha", puede usar directamente (izquierda, medio) y (medio.siguiente, derecha) para representar la lista correspondiente a los subárboles izquierdo y derecho no necesitan mid.pre, y la lista inicial también se puede representar convenientemente mediante (head, null)

Conjunto de hash: Set<Character> occ = new HashSet<Character>();

int suma = llevar x y; int llevar = suma/10;

Para "sacar" y "empujar" números sin la ayuda de una pila/matriz auxiliar, podemos usar las matemáticas, sacar primero el último dígito, luego dividir por 10 para eliminar el último dígito, invertir el número y seguir multiplicándose después de 10. , agregue el último dígito extraído y primero determine si se desbordará.

Da un paso hacia la izquierda y luego sigue caminando hacia la derecha hasta que no puedas avanzar más.

s = conjunto(ls); lt = lista(s)

lt = tupla(ls)

Si un problema tiene muchos subproblemas superpuestos, la programación dinámica es más efectiva.

1. Determinar el significado de la matriz dp (tabla dp) y los subíndices 2. Determinar la fórmula de recursividad. 3.Cómo inicializar la matriz dp 4. Determinar el orden transversal. 5. Derivación de la matriz dp con ejemplos.

¿Por qué determinar primero la fórmula de recursividad y luego considerar la inicialización? Porque en algunos casos la fórmula recursiva determina cómo inicializar la matriz dp

1. Imprima la matriz dp y vea si se deduce según sus propias ideas.

2. Antes de escribir código, asegúrese de simular la situación específica de la transferencia de estado en la matriz dp y asegúrese de que el resultado final sea el resultado deseado.

Cuando la ecuación recursiva solo está relacionada con unos pocos números adyacentes, se puede usar una matriz móvil para optimizar la complejidad del espacio a O (1)

Condición de terminación de la recursividad, qué hace esta recursividad y qué devuelve

El subíndice de una matriz es una matriz implícitamente útil, especialmente cuando se cuentan algunos números (tratando el valor de la matriz correspondiente como el subíndice temp[arr[i]] de la nueva matriz), o cuando se determina si aparecen algunos números enteros.

1. Cuando le damos una cadena de letras y le pedimos que determine la cantidad de veces que aparecen estas letras, podemos usar estas letras como subíndices al atravesar, si se atraviesa la letra a, entonces arr [a] se puede aumentar en. 1. Es decir, arr[a]. Mediante este uso inteligente de subíndices, no necesitamos juzgar letra por letra.

2. Se le proporcionan n matrices de enteros int desordenados, y el rango de valores de estos números enteros está entre 0 y 20. Debe ordenar estos n números de pequeño a grande en una complejidad de tiempo O (n). orden y use el valor correspondiente como subíndice de la matriz. Si este número ha aparecido antes, agregue 1 a la matriz correspondiente.

Al atravesar la matriz, se realizará un juicio fuera de límites. Si el subíndice está casi fuera de los límites, lo estableceremos en 0 y lo recorreremos nuevamente. Especialmente en algunas matrices en forma de anillo, como colas implementadas con matrices pos = (pos 1) % N

Para punteros dobles, es particularmente útil cuando se hacen preguntas sobre listas enlazadas individualmente.

1. Determinar si una lista enlazada individualmente tiene un ciclo

2. Cómo encontrar el nodo medio de la lista vinculada en un recorrido

3. El k-ésimo nodo del último en una lista enlazada individualmente

subtema

1. A veces, cuando realizamos operaciones de división o multiplicación, como n/2, n/4, n/8, podemos usar el método de cambio para realizar la operación. A través de la operación de cambio, la velocidad de ejecución será más rápida.

2. También existen algunas operaciones como & (y) y | (o), que también pueden acelerar la operación.

1. Para determinar si un número es impar, será mucho más rápido utilizar la operación AND.

1. En temas relacionados con listas vinculadas, a menudo configuramos un puntero principal, y este puntero principal no almacena ningún dato válido. Solo por conveniencia de operación, podemos llamar a este puntero principal bit centinela.

2. Al operar una matriz, también puede configurar un centinela, utilizando arr[0] como centinela.

1. Cuando queremos eliminar el primer nodo, si no se establece un bit centinela, la operación será diferente a la operación de eliminar el segundo nodo. Pero hemos configurado un centinela, por lo que eliminar el primer nodo y eliminar el segundo nodo tienen la misma operación, sin realizar juicios adicionales. Por supuesto, lo mismo ocurre al insertar nodos.

2. Cuando desee juzgar si dos elementos adyacentes son iguales, establecer un centinela no le preocupará el problema transfronterizo. Puede directamente arr[i] == arr[i-1]. No tengas miedo de cruzar el límite cuando i = 0

1. Cuando usamos la recursividad para resolver un problema, es fácil calcular repetidamente el mismo subproblema. En este momento, debemos considerar la preservación del estado para evitar cálculos repetidos.

2.Ejemplos

1. Para problemas recursivos, generalmente recurrimos de arriba a abajo hasta que la recursividad llega al final y luego devolvemos el valor capa por capa.

2. Sin embargo, a veces, cuando n es relativamente grande, como cuando n = 10000, es necesario recurrir 10000 niveles hasta n <= 2 antes de devolver lentamente el resultado. Si n es demasiado grande, es posible que no haya espacio en la pila. suficiente

3. Para esta situación, podemos considerar un enfoque ascendente.

4. Este enfoque ascendente también se denomina recursividad.

En Python, los parámetros pueden devolver directamente parte de la matriz nums[:i]. No es necesario rediseñar un método para interceptar la matriz según el subíndice como en Java.

para i, v en enumerar (numeros):

Una pila en la que los elementos de la pila aumentan o disminuyen monótonamente. Una pila monótona solo se puede operar en la parte superior de la pila.

1. Los elementos de la pila monótona son monótonos.

2. Antes de agregar elementos a la pila, todos los elementos que destruyan la monotonicidad de la pila se eliminarán de la parte superior de la pila.

3. Utilice la pila monótona para encontrar el elemento y recorrer hacia la izquierda hasta el primer elemento que es más pequeño que él (pila incremental)/buscar el elemento y recorrer hacia la izquierda hasta el primer elemento que es más grande que él.

1. Las claves de todos los nodos en el subárbol izquierdo son menores que las del nodo raíz.

2. Las palabras clave de todos los nodos en el subárbol derecho son mayores que las del nodo raíz.

3. Los subárboles izquierdo y derecho son cada uno de ellos un árbol de clasificación binario.

El recorrido en orden puede obtener una secuencia ordenada creciente

1. Árbol binario equilibrado: el valor absoluto de la diferencia de altura entre los subárboles izquierdo y derecho de cualquier nodo no supera 1

2. Factor de equilibrio: la diferencia de altura entre los subárboles izquierdo y derecho del nodo -1,0,1

Cualquier árbol que consta sólo de las aristas de G y contiene todos los vértices de G se llama árbol de expansión de G.

Conjunto de puntos: Hay una arista que conecta dos puntos cualesquiera.

Conjunto de puntos: no hay borde entre dos puntos.

Un gráfico no dirigido va desde un punto inicial específico hasta un punto final específico, pasando por todos los demás nodos solo una vez. Un camino hamiltoniano cerrado se llama ciclo hamiltoniano y un camino que contiene todos los vértices del gráfico se llama camino hamiltoniano.

Un algoritmo transversal jerárquico similar a un árbol binario, que da prioridad al nodo descubierto más temprano.

De manera similar al recorrido de un árbol en orden anticipado, se le da prioridad al último nodo descubierto.

1. Las dos estructuras de datos, "cola" y "pila", se pueden implementar mediante listas enlazadas o matrices. Si lo implementa con una matriz, debe lidiar con el problema de expansión y contracción; si lo implementa con una lista vinculada, no tiene este problema, pero necesita más espacio de memoria para almacenar punteros de nodo.

2. Dos métodos de representación de "gráfico", la lista de adyacencia es una lista vinculada y la matriz de adyacencia es una matriz bidimensional. La matriz de adyacencia determina la conectividad rápidamente y puede realizar operaciones matriciales para resolver algunos problemas, pero consume espacio si el gráfico es escaso. Las listas de adyacencia ahorran espacio, pero muchas operaciones definitivamente no son tan eficientes como las matrices de adyacencia.

3. La "tabla hash" asigna claves a una matriz grande mediante una función hash. Y como método para resolver conflictos de hash, el método de cremallera requiere características de lista vinculada, que es fácil de operar, pero requiere espacio adicional para almacenar punteros; el método de sondeo lineal requiere características de matriz para facilitar el direccionamiento continuo y no requiere espacio de almacenamiento para punteros; , pero la operación es un poco complicada algunos

4. "Árbol", implementado con una matriz es un "montón", porque el "montón" es un árbol binario completo para almacenar, no requiere punteros de nodo y la operación es relativamente simple para usar una lista vinculada; implementarlo es un "árbol" muy común, porque No es necesariamente un árbol binario completo, por lo que no es adecuado para el almacenamiento en matriz. Por esta razón, se han derivado varios diseños ingeniosos basados ​​en esta estructura de "árbol" de lista enlazada, como árboles de búsqueda binaria, árboles AVL, árboles rojo-negro, árboles de intervalo, árboles B, etc., para abordar diferentes problemas.

1. Dado que las matrices son compactas y de almacenamiento continuo, se puede acceder a ellas de forma aleatoria, los elementos correspondientes se pueden encontrar rápidamente a través de índices y se ahorra relativamente espacio de almacenamiento. Pero debido al almacenamiento continuo, el espacio de memoria debe asignarse al mismo tiempo. Por lo tanto, si la matriz desea expandirse, debe reasignar un espacio mayor y luego copiar todos los datos allí. La complejidad del tiempo es O (N); si desea Al insertar y eliminar en el medio de la matriz, todos los datos posteriores deben moverse cada vez para mantener la continuidad. La complejidad del tiempo es O (N).

2. Debido a que los elementos de una lista vinculada no son continuos, sino que dependen de punteros para señalar la ubicación del siguiente elemento, no hay problema de expansión de la matriz, si conoce el predecesor y el sucesor de un determinado elemento, puede eliminarlos; el elemento o inserte un nuevo elemento operando el puntero Complejidad de tiempo O (1). Sin embargo, debido a que el espacio de almacenamiento no es continuo, no se puede calcular la dirección del elemento correspondiente en función de un índice, por lo que el acceso aleatorio no es posible y debido a que cada elemento debe almacenar un puntero a la posición de los elementos anteriores, sí; consumirá relativamente más espacio de almacenamiento.

1.matriz

2. Lista enlazada

3. árbol binario

4.árbol N-ario

recorrido vacío (raíz de TreeNode) { // recorrido de reserva atravesar (raíz.izquierda) // recorrido en orden atravesar (raíz.derecha) // recorrido posterior al pedido }

La forma general de un problema de programación dinámica es encontrar el valor óptimo. La programación dinámica es en realidad un método de optimización en la investigación de operaciones, pero se usa más comúnmente en problemas informáticos. Por ejemplo, le pide que encuentre la subsecuencia creciente más larga y la distancia mínima de edición.

El problema central es el agotamiento. Como requerimos el mejor valor, debemos enumerar exhaustivamente todas las respuestas posibles y luego encontrar el mejor valor entre ellas.

1. Subproblemas superpuestos

2. Subestructura óptima

3. Ecuación de transición de estado

1.Código

2. árbol recursivo

3. Complejidad temporal del algoritmo recursivo.

1. Dado que el motivo que requiere mucho tiempo son los cálculos repetidos, podemos crear una "nota" antes de regresar después de calcular la respuesta a una determinada subpregunta. encuentre una subpregunta. Primero verifique el problema en "Nota". Si descubre que el problema se resolvió antes, simplemente saque la respuesta y úsela en lugar de perder tiempo calculando.

2. Generalmente, se utiliza una matriz como esta "nota". Por supuesto, también puede utilizar una tabla hash (diccionario).

3.Código

4. árbol recursivo

5. Complejidad

6.Comparación con la programación dinámica.

7. De arriba hacia abajo

8. De abajo hacia arriba

1. Pensamientos

2.Código

3. Ecuación de transición de estado

4. Compresión de estado

Te dan k monedas con valores nominales de c1, c2...ck. La cantidad de cada moneda es ilimitada. Luego te dan una cantidad total de dinero. Te pregunto cuántas monedas necesitas al menos para compensar. esta cantidad Si es imposible compensar la cantidad, el algoritmo devuelve -1.

1. En primer lugar, este problema es un problema de programación dinámica porque tiene una "subestructura óptima". Para cumplir con la "subestructura óptima", los subproblemas deben ser independientes entre sí.

2. Volviendo al problema de cobrar el cambio, ¿por qué se dice que está en consonancia con la subestructura óptima? Por ejemplo, si desea encontrar la cantidad mínima de monedas cuando la cantidad = 11 (pregunta original), si conoce la cantidad mínima de monedas cuando la cantidad = 10 (subpregunta), solo necesita agregar una a la respuesta a la subpregunta (elija otra moneda de 1 valor nominal) es la respuesta a la pregunta original. Debido a que la cantidad de monedas es ilimitada, no hay control mutuo entre los subproblemas y son independientes entre sí.

3. Cuatro pasos principales

4. Pseudocódigo

5.Código

6. Ecuación de transición de estado

7. árbol recursivo

8. Complejidad

1.Código

2. Complejidad

1.Definición de matriz dp

2.Código

3. Proceso

4.Detalles

Similar a la iteración del recorrido en orden, con ligeros cambios.

solución de clase { Lista pública <Integer> preorderTraversal (raíz de TreeNode) { Lista<Integer> res = new ArrayList<Integer>(); // Stack se implementa en función de matrices dinámicas, mientras que LinkedList se implementa en función de listas enlazadas bidireccionales. LinkedList es más eficiente para agregar, eliminar y modificar que Stack. Deque<TreeNode> stk = new LinkedList<TreeNode>();//Cola de doble extremo //El nodo no está vacío o la pila no está vacía y el ciclo continúa mientras (raíz != nulo || !stk.isEmpty()) { mientras (raíz! = nulo) { res.add(root.val);// Se accede directamente al nodo raíz y luego se inserta en la pila stk.push(raíz); root = root.left;//Después de que finalice el nodo raíz, acceda a su hijo izquierdo y conviértase en el nuevo nodo raíz } root = stk.pop();// Al salir del bucle, se accede a todos los hijos de la izquierda y luego se accede al hijo derecho raíz = raíz.derecha; } devolver resolución; } }

clase Solución: def preorderTraversal(self, raíz: TreeNode) -> Lista[int]: res = lista() si no es root: devolver resolución pila = [] nodo=raíz while pila o nodo:#El nodo no está vacío o la pila no está vacía y el ciclo continúa mientras nodo: res.append(node.val) #Se accede directamente al nodo raíz y luego se inserta en la pila pila.append(nodo) node = node.left #Después de que finalice el nodo raíz, acceda a su hijo izquierdo y conviértase en el nuevo nodo raíz node = stack.pop() #Al saltar del bucle, se accede a todos los hijos de la izquierda y luego se accede al hijo derecho nodo = nodo.derecha devolver resolución

Comenzando desde el nodo raíz, cada iteración extrae el elemento superior de la pila actual y empuja su nodo hijo dentro de la pila, primero presionando el hijo derecho y luego el hijo izquierdo.

solución de clase { Lista pública <Integer> preorderTraversal (raíz de TreeNode) { LinkedList<TreeNode> pila = nueva LinkedList<>(); LinkedList<Integer> salida = nueva LinkedList<>(); si (raíz == nulo) { salida de retorno; } pila.add(raíz); mientras (!stack.isEmpty()) { TreeNode node = stack.pollLast();//Recuperar y eliminar el último elemento de esta lista salida.add(nodo.val); if (node.right != null) {// Solo inserte un hijo derecho e izquierdo del nodo actual en la pila, independientemente de los demás pila.add(nodo.derecha); } si (nodo.izquierda! = nulo) { pila.add(nodo.izquierda); } } salida de retorno; } }

Tiempo: O(n), Espacio: O(n)

1. Acceda a los nodos predecesores del recorrido de pedido anticipado desde el nodo actual hacia abajo, y cada nodo predecesor se visita exactamente dos veces.

2. Primero comience desde el nodo actual, camine un paso hacia el hijo izquierdo y luego visite todo el camino hacia abajo a lo largo del hijo derecho hasta llegar a un nodo hoja (el nodo predecesor transversal en orden del nodo actual), por lo que actualizamos el genera y crea un predecesor de pseudo borde. right = root actualiza el siguiente punto de este predecesor. Si visitamos el nodo predecesor por segunda vez, dado que ya apunta al nodo actual, eliminamos el pseudo borde y pasamos al siguiente vértice.

3. Si el movimiento hacia la izquierda en el primer paso no existe, actualice directamente la salida y muévase hacia la derecha.

solución de clase { Lista pública <Integer> preorderTraversal (raíz de TreeNode) { Lista<Integer> res = new ArrayList<Integer>(); TreeNode predecesor = null;// El nodo predecesor del nodo actual, el nodo más a la derecha del subárbol izquierdo mientras (raíz! = nulo) { // Dependiendo de si hay un hijo izquierdo, determine si buscar su nodo predecesor o acceder directamente al hijo derecho si (raíz.izquierda! = nulo) { // Primero busque el predecesor, luego asigne un valor a su hijo derecho y luego recorra el hijo izquierdo del nodo actual // El nodo predecesor es el nodo raíz actual, da un paso hacia la izquierda y luego continúa caminando hacia la derecha hasta que ya no pueda avanzar. predecesor = raíz.izquierda; while (predecesor.derecho! = nulo && predecesor.derecho! = raíz) { predecesor = predecesor.derecho; } // Dependiendo de si el hijo derecho del predecesor está vacío, determine si acceder directamente al subárbol izquierdo y luego asignar el valor, o si se completa el acceso al subárbol izquierdo. // Deje que el puntero derecho del predecesor apunte a la raíz y continúe atravesando el subárbol izquierdo if (predecesor.derecho == nulo) { res.add(raíz.val); predecesor.derecho = raíz; raíz = raíz.izquierda; } // Indica que se ha visitado el subárbol izquierdo. Necesitamos desconectar el enlace y continuar visitando el subárbol derecho. demás { predecesor.derecho = nulo; raíz = raíz.derecha; } } // Si no queda ningún hijo, accede directamente al hijo derecho demás { res.add(raíz.val); raíz = raíz.derecha; } } devolver resolución; } }

clase Solución: def preorderTraversal(self, raíz: TreeNode) -> Lista[int]: res = lista() si no es root: devolver resolución p1 = raíz mientras p1: p2 = p1.left #El nodo predecesor del nodo actual, el nodo más a la derecha del subárbol izquierdo si p2: # Según si hay un hijo izquierdo, determine si buscar su nodo predecesor o acceder directamente al hijo derecho mientras p2.right y p2.right != p1: p2 = p2.derecha # De acuerdo con si el hijo derecho de p2 está vacío, determine si acceder directamente al subárbol izquierdo y luego asignar el valor, o si se completa el acceso al subárbol izquierdo. si no p2.right:#Deje que el puntero derecho de p2 apunte a p1 y continúe atravesando el subárbol izquierdo res.añadir(p1.val) p2.derecha = p1 p1 = p1.izquierda continuar else: #Indica que se ha visitado el subárbol izquierdo, debemos desconectar el enlace y continuar visitando el subárbol derecho p2.right = Ninguno else: #Si no queda ningún hijo izquierdo, accede directamente al hijo derecho res.añadir(p1.val) p1 = p1.derecha devolver resolución

Tiempo: O(n), Espacio: O(1)

Este árbol se recorre visitando el subárbol izquierdo - nodo raíz - subárbol derecho, y cuando visitamos el subárbol izquierdo o el subárbol derecho, atravesamos de la misma manera hasta atravesar el árbol completo. Por lo tanto, todo el proceso transversal es naturalmente recursivo. Podemos utilizar directamente funciones recursivas para simular este proceso.

solución de clase { Lista pública <Integer> inorderTraversal (raíz de TreeNode) { Lista<Integer> res = new ArrayList<Integer>(); orden(raíz, res); devolver resolución; } orden vacía pública (raíz de TreeNode, Lista <Integer> res) { si (raíz == nulo) { devolver; } orden(raíz.izquierda, res); res.add(raíz.val); inorder(raíz.derecha, res); } }

clase Solución: def preorderTraversal(self, raíz: TreeNode) -> Lista[int]: def dfs(cur): si no es curado: devolver # Recursión de pedidos anticipados res.append(cur.val) dfs(cur.izquierda) dfs (derecha actual) # # Recursión en orden #dfs(cur.izquierda) # res.append(cur.val) #dfs(derecha actual) # # Recursión posterior al pedido #dfs(cur.izquierda) #dfs(derecha actual) # res.append(cur.val) res = [] dfs(raíz) devolver resolución

Complejidad del tiempo: O (n), donde n es el número de nodos del árbol binario. En el recorrido del árbol binario, cada nodo será visitado una vez y sólo una vez.

Complejidad espacial: O (n). La complejidad del espacio depende de la profundidad de la pila recursiva, y la profundidad de la pila alcanzará el nivel O (n) cuando el árbol binario sea una cadena.

También podemos implementar la función recursiva del método 1 de forma iterativa. Los dos métodos son equivalentes. La diferencia es que una pila se mantiene implícitamente durante la recursión y necesitamos simular explícitamente esta pila durante la iteración.

solución de clase { Lista pública <Integer> inorderTraversal (raíz de TreeNode) { Lista<Integer> res = new ArrayList<Integer>(); // Stack se implementa en función de matrices dinámicas, mientras que LinkedList se implementa en función de listas enlazadas bidireccionales. LinkedList es más eficiente para agregar, eliminar y modificar que Stack. Deque<TreeNode> stk = new LinkedList<TreeNode>();//Cola de doble extremo //El nodo no está vacío o la pila no está vacía y el ciclo continúa mientras (raíz != nulo || !stk.isEmpty()) { //Recorre primero el hijo izquierdo hasta que esté vacío y finaliza el ciclo mientras (raíz! = nulo) { stk.push(raíz); raíz = raíz.izquierda; } // Al saltar del bucle, el hijo izquierdo está vacío. En este momento, el que salió de la pila es equivalente al nodo raíz, y luego es el turno del hijo derecho. raíz = stk.pop(); res.add(raíz.val); raíz = raíz.derecha; } devolver resolución; } }

clase Solución: def inorderTraversal(self, raíz: TreeNode) -> Lista[int]: res = lista() si no es root: devolver resolución pila = [] nodo=raíz while pila o nodo:#El nodo no está vacío o la pila no está vacía y el ciclo continúa mientras nodo: stack.append(nodo) #Recorre primero el hijo izquierdo hasta que esté vacío y finaliza el ciclo nodo = nodo.izquierda node = stack.pop() #El hijo izquierdo está vacío al saltar del bucle. En este momento, el que salió de la pila es equivalente al nodo raíz, y luego es el turno del hijo derecho. res.append(nodo.val) nodo = nodo.derecha devolver resolución

Tiempo: O(n), Espacio: O(n)

1. Si x no tiene un hijo izquierdo, primero agregue el valor de x a la matriz de respuesta y luego acceda al hijo derecho de x, es decir, x = x.right

2. Si x tiene un hijo izquierdo, busque el nodo más a la derecha en el subárbol izquierdo de x (es decir, el último nodo del subárbol izquierdo en el recorrido en orden y el nodo predecesor de x en el recorrido en orden) , que registramos como predecesor. Dependiendo de si el hijo derecho del predecesor está vacío, realice las siguientes operaciones

3. Si el hijo derecho del predecesor está vacío, apunte su hijo derecho a x y luego acceda al hijo izquierdo de x, es decir, x = x.left

4. Si el hijo derecho del predecesor no está vacío, entonces su hijo derecho apunta a x en este momento, lo que indica que hemos atravesado el subárbol izquierdo de x. Dejamos el hijo derecho del predecesor vacío y sumamos el valor de x. a la matriz de respuestas y luego acceda al hijo derecho de x, es decir, x=x.right

5. Repita las operaciones anteriores hasta visitar el árbol completo.

6. De hecho, haremos un paso más en todo el proceso: suponiendo que el nodo actualmente atravesado es x, apunte el hijo derecho del nodo más a la derecha en el subárbol izquierdo de x hacia x, de modo que después del recorrido del subárbol izquierdo sea completado, usaremos este puntero Devoluciones

solución de clase { Lista pública <Integer> inorderTraversal (raíz de TreeNode) { Lista<Integer> res = new ArrayList<Integer>(); TreeNode predecesor = null;// El nodo predecesor del nodo actual, el nodo más a la derecha del subárbol izquierdo mientras (raíz! = nulo) { // Dependiendo de si hay un hijo izquierdo, determine si buscar su nodo predecesor o acceder directamente al hijo derecho si (raíz.izquierda! = nulo) { // Primero busque el predecesor, luego asigne un valor a su hijo derecho y luego recorra el hijo izquierdo del nodo actual // El nodo predecesor es el nodo raíz actual, da un paso hacia la izquierda y luego continúa caminando hacia la derecha hasta que ya no pueda avanzar. predecesor = raíz.izquierda; while (predecesor.derecho! = nulo && predecesor.derecho! = raíz) { predecesor = predecesor.derecho; } //Determine si la asignación o el acceso al subárbol izquierdo finaliza en función de si el hijo derecho del predecesor está vacío. // Deje que el puntero derecho del predecesor apunte a la raíz y continúe atravesando el subárbol izquierdo if (predecesor.derecho == nulo) { predecesor.derecho = raíz; raíz = raíz.izquierda; } // Indica que se ha visitado el subárbol izquierdo. En este momento, visite el nodo raíz, luego desconecte el enlace y continúe visitando el subárbol derecho. demás { res.add(raíz.val); predecesor.derecho = nulo; raíz = raíz.derecha; } } // Si no queda ningún hijo, accede directamente al hijo derecho demás { res.add(raíz.val); raíz = raíz.derecha; } } devolver resolución; } }

clase Solución: def inorderTraversal(self, raíz: TreeNode) -> Lista[int]: res = lista() si no es root: devolver resolución p1 = raíz mientras p1: p2 = p1.left #El nodo predecesor del nodo actual, el nodo más a la derecha del subárbol izquierdo si p2: # Según si hay un hijo izquierdo, determine si buscar su nodo predecesor o acceder directamente al hijo derecho mientras p2.right y p2.right != p1: p2 = p2.derecha # De acuerdo con si el hijo derecho de p2 está vacío, determine si acceder directamente al subárbol izquierdo y luego asignar el valor, o si se completa el acceso al subárbol izquierdo. si no p2.right:#Deje que el puntero derecho de p2 apunte a p1 y continúe atravesando el subárbol izquierdo p2.derecha = p1 p1 = p1.izquierda continuar de lo contrario: #Indica que se ha visitado el subárbol izquierdo. En este momento, visite el nodo raíz, luego desconecte el enlace y continúe visitando el subárbol derecho. res.añadir(p1.val) p2.right = Ninguno else: #Si no queda ningún hijo izquierdo, accede directamente al hijo derecho res.añadir(p1.val) p1 = p1.derecha devolver resolución

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol de búsqueda binario. Cada nodo en el recorrido de Morris será visitado dos veces, por lo que la complejidad del tiempo total es O (2n) = O (n)

Complejidad espacial: O (1)

0. Tiene la eficiencia del método de iteración de pila y es tan conciso y fácil de entender como el método recursivo. Más importante aún, este método puede escribir código completamente consistente para el recorrido de pedido previo, medio y posterior.

1. Utilice colores para marcar el estado de los nodos. Los nodos nuevos son blancos y los nodos visitados son grises. Si el nodo encontrado es blanco, márquelo como gris y luego inserte su nodo secundario derecho, él mismo y el nodo secundario izquierdo en la pila en secuencia. Si el nodo encontrado es gris, se genera el valor del nodo

2. Si desea implementar un recorrido de pedido previo y posterior, solo necesita ajustar el orden de apilamiento de los nodos secundarios izquierdo y derecho.

clase Solución: def inorderTraversal(self, raíz: TreeNode) -> Lista[int]: BLANCO, GRIS = 0, 1 #BLANCO no ha sido visitado, GRIS ha visitado res = [] pila = [(BLANCO, raíz)] mientras se apila: color, nodo = pila.pop() si el nodo es Ninguno: continuar si color == BLANCO: # El orden del orden medio es izquierda raíz derecha, el orden de inserción en la pila es derecha raíz izquierda, ajuste el orden para completar otros recorridos stack.append((BLANCO, nodo.derecha)) stack.append((GRIS, nodo)) #El nodo actual se vuelve gris y ha sido visitado pila.append((BLANCO, nodo.izquierda)) demás: res.append(nodo.val) devolver resolución

Tiempo: O(n), Espacio: O(n)

Al regresar al nodo raíz, marque el nodo actual para determinar si regresar desde el subárbol izquierdo o desde el subárbol derecho. Cuando regrese desde el subárbol derecho, comience a atravesar el nodo.

solución de clase { Lista pública <Integer> postorderTraversal (raíz de TreeNode) { Lista<Integer> res = new ArrayList<Integer>(); Pila<TreeNode> pila = nueva Pila<>(); // El nodo previo se utiliza para registrar el nodo visitado anteriormente, distinguiendo entre devolver el nodo raíz del subárbol izquierdo o del subárbol derecho. TreeNode pre = nulo; while(raíz!=nulo || !pila.empty()){ mientras(raíz!=nulo){ stack.push(root); //Empuja continuamente el nodo izquierdo en la pila raíz = raíz.izquierda; } root = stack.peek();//Regresar desde el subárbol izquierdo, solo obtener el nodo raíz y no mostrarlo, aún no ha sido visitado if(root.right==null || root.right==pre){ //Si el nodo derecho está vacío o se ha visitado el nodo derecho res.add(root.val); //Puedes acceder al nodo raíz en este momento pre = raíz; pila.pop(); root = null; // En este momento, no inserte el subárbol izquierdo en la pila en el siguiente ciclo. Ya ha sido insertado y determine directamente el elemento superior de la pila. }demás{ root = root.right; //No lo saques de la pila todavía, empuja su nodo derecho hacia la pila } } devolver resolución; } }

clase Solución: def postorderTraversal(self, raíz: TreeNode) -> Lista[int]: si no es root: lista de retorno() res = lista() pila = lista() prev = Ninguno #El nodo anterior se utiliza para registrar el nodo visitado anteriormente, lo que distingue si se devuelve el nodo raíz del subárbol izquierdo o del subárbol derecho. mientras que root o pila: mientras que raíz: stack.append(root) # Empuje continuamente el nodo izquierdo hacia la pila raíz = raíz.izquierda #Esta aplicación se ve, pero no existe tal método en la lista. Solo puede aparecer primero y luego agregar. root = stack.pop() #Regresa desde el subárbol izquierdo, aún no ha sido visitado y se agregará a la pila más adelante. si no es root.right o root.right == prev:#Si el nodo correcto está vacío o se ha visitado el nodo correcto res.append(root.val) #Puedes acceder al nodo raíz en este momento prev = root #Registrar el nodo actual root = Ninguno # En este momento, no inserte el subárbol izquierdo en la pila en el siguiente ciclo. Ya ha sido insertado y determina directamente el elemento superior de la pila. demás: stack.append(root) #Si no se ha accedido antes, agréguelo a la pila raíz = raíz.derecha devolver resolución

//Modifica el código para escribir nodos en la lista vinculada de resultados en el código transversal del pedido previo: cambia la inserción al final de la cola por la inserción al principio de la cola // Modifica la lógica de verificar primero el nodo izquierdo y luego el nodo derecho en el código transversal de preorden: cambia para verificar primero el nodo derecho y luego el nodo izquierdo. // El recorrido de preorden son las raíces izquierda y derecha, el orden inverso es la raíz de derecha a izquierda y el recorrido de posorden son las raíces izquierda y derecha. solución de clase { Lista pública <Integer> postorderTraversal (raíz de TreeNode) { ListaEnlazada res = nueva ListaEnlazada(); Pila<TreeNode> pila = nueva Pila<>(); TreeNode pre = nulo; while(raíz!=nulo || !pila.empty()){ mientras(raíz!=nulo){ res.addFirst(root.val); //Inserta el primero de la cola pila.push(raíz); root = root.right; //Primero a la derecha y luego a la izquierda; } raíz = pila.pop(); raíz = raíz.izquierda; } devolver resolución; } }

Tiempo: O(n), Espacio: O(n)

1. La idea central del recorrido de Morris es utilizar una gran cantidad de punteros libres en el árbol para lograr la máxima reducción de la sobrecarga de espacio. Las reglas posteriores para el recorrido posterior al pedido se resumen a continuación:

2. Si el nodo secundario izquierdo del nodo actual está vacío, recorra el nodo secundario derecho del nodo actual.

3. Si el nodo secundario izquierdo del nodo actual no está vacío, busque el nodo predecesor del nodo actual en el recorrido en orden en el subárbol izquierdo del nodo actual.

4. Si el nodo secundario derecho del nodo predecesor está vacío, establezca el nodo secundario derecho del nodo predecesor en el nodo actual y actualice el nodo actual al nodo secundario izquierdo del nodo actual.

5. Si el nodo secundario derecho del nodo predecesor es el nodo actual, restablezca su nodo secundario derecho para que esté vacío. Genere todos los nodos en la ruta desde el nodo secundario izquierdo del nodo actual hasta el nodo predecesor en orden inverso. El nodo actual se actualiza al nodo secundario derecho del nodo actual

solución de clase { Lista pública <Integer> postorderTraversal (raíz de TreeNode) { Lista<Integer> res = new ArrayList<Integer>(); si (raíz == nulo) { devolver resolución; } TreeNode p1 = raíz, p2 = nulo //p1 nodo actual, p2 nodo predecesor mientras (p1 != nulo) { p2 = p1.izquierda; si (p2! = nulo) { mientras (p2.derecha! = nulo && p2.derecha! = p1) { p2 = p2.derecha; } si (p2.derecha == nulo) { p2.derecha = p1; p1 = p1.izquierda; continuar; } demás { p2.derecha = nulo; addPath(res, p1.izquierda); } } p1 = p1.derecha; } addPath(res, raíz); devolver resolución; } public void addPath(List<Integer> res, nodo TreeNode) { recuento int = 0; mientras (nodo!= nulo) { contar; res.add(nodo.val); nodo = nodo.derecha; } //Invertir los nodos recién agregados int izquierda = res.size() - contar, derecha = res.size() - 1; mientras (izquierda <derecha) { int temp = res.get(izquierda); res.set(izquierda, res.get(derecha)); res.set(derecha, temperatura); izquierda ; bien--; } } }

clase Solución: def postorderTraversal(self, raíz: TreeNode) -> Lista[int]: def addPath(nodo: TreeNode): contar = 0 mientras nodo: contar = 1 res.append(nodo.val) nodo = nodo.derecha #Invertir los nodos recién agregados i, j = len(res) - contar, len(res) - 1 mientras yo <j: res[i], res[j] = res[j], res[i] #No se requieren variables intermedias yo=1 j-= 1 si no es root: lista de retorno() res = lista() p1 = raíz mientras p1: p2 = p1.left #p2 nodo predecesor si p2: mientras p2.right y p2.right != p1: p2 = p2.derecha si no p2.derecha: p2.derecha = p1 p1 = p1.izquierda continuar demás: p2.right = Ninguno agregarRuta(p1.izquierda) p1 = p1.derecha agregar ruta (raíz) devolver resolución

Tiempo: O(n), Espacio: O(1)

1. Si conocemos la profundidad máxima l y r del subárbol izquierdo y del subárbol derecho, entonces la profundidad máxima del árbol binario es max (l, r) 1

2. La profundidad máxima del subárbol izquierdo y del subárbol derecho se puede calcular de la misma manera. Por lo tanto, cuando calculamos la profundidad máxima del árbol binario actual, primero podemos calcular de forma recursiva la profundidad máxima de su subárbol izquierdo y su subárbol derecho, y luego calcular la profundidad máxima del árbol binario actual en tiempo O (1). La recursión sale cuando se alcanza un nodo vacío

solución de clase { public int maxDepth (raíz de TreeNode) { if(root==null) return 0;//Cuando el último 1 es un nodo hoja, la altura volverá a 1 return Math.max(maxDepth(root.left),maxDepth(root.right)) 1; } }

clase Solución: def maxDepth(self, raíz: TreeNode) -> int: si no es root: devuelve 0 lefth = self.maxDepth(root.left) #Debes usar self.self cuando te llames a ti mismo derecha = self.maxDepth(raíz.derecha) retorno máximo (izquierda, derecha) 1

Complejidad del tiempo: O (n), donde n es el número de nodos del árbol binario. Cada nodo se atraviesa solo una vez en la recursividad.

Complejidad del espacio: O (altura), donde la altura representa la altura del árbol binario. Las funciones recursivas requieren espacio de pila, y el espacio de pila depende de la profundidad de la recursividad, por lo que la complejidad del espacio es equivalente a la altura del árbol binario.

La cola de búsqueda en amplitud almacena "todos los nodos de la capa actual". Cada vez que expandimos la siguiente capa, a diferencia de la búsqueda en amplitud que solo elimina un nodo de la cola a la vez, necesitamos eliminar todos los nodos de la cola para la expansión, a fin de garantizar que la cola se expanda cada vez. time Se almacenan todos los nodos de la capa actual, es decir, expandimos capa por capa. Finalmente, usamos una variable ans para mantener el número de expansiones. La profundidad máxima del árbol binario es ans.

solución de clase { public int maxDepth (raíz de TreeNode) { si (raíz == nulo) { devolver 0; } Cola<TreeNode> cola = nueva LinkedList<TreeNode>(); cola.oferta(raíz); int respuesta = 0; mientras (!queue.isEmpty()) { int tamaño = cola.tamaño(); while (tamaño > 0) { //operar una capa de elementos a la vez Nodo TreeNode = cola.poll(); si (nodo.izquierda! = nulo) { cola.oferta(nodo.izquierda); } si (nodo.derecho! = nulo) { cola.oferta(nodo.derecha); } tamaño--; } ans ;// Después de completar una capa de operación, el número de capas es 1 } volver y; } }

importar colecciones clase Solución: def maxDepth(self, raíz: TreeNode) -> int: si no es root: devuelve 0 cola = colecciones.deque() cola.append(raíz) respuesta = 0 mientras cola: respuesta = 1 for _ in range(len(queue)): #Recorre los elementos de un nivel cada vez nodo = cola.popleft() si nodo.izquierda: cola.append(nodo.izquierda) si nodo.derecho: cola.append(nodo.derecha) regresar y

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol binario. El mismo análisis que el método 1, cada nodo solo será visitado una vez

Complejidad del espacio: el consumo de espacio de este método depende de la cantidad de elementos almacenados en la cola, que alcanzará O (n) en el peor de los casos.

Comenzamos desde el nodo raíz, atravesamos el árbol de forma recursiva y comenzamos a voltear desde los nodos hoja primero. Si los subárboles izquierdo y derecho de la raíz del nodo actualmente atravesado se han invertido, entonces solo necesitamos intercambiar las posiciones de los dos subárboles para completar la inversión de todo el subárbol con raíz como nodo raíz.

solución de clase { árbol público TreeNode invertTree (raíz de TreeNode) { si (raíz == nulo) { devolver nulo; } //Atraviesa el árbol de forma recursiva y comienza a voltear desde los nodos de hoja primero TreeNode izquierda = invertTree(root.left); TreeNode derecha = invertTree(root.right); raíz.izquierda = derecha; raíz.derecha = izquierda; devolver raíz; } }

clase Solución: def invertTree(self, raíz: TreeNode) -> TreeNode: si no es root: devolver la raíz #Atraviesa el árbol de forma recursiva y comienza a voltear primero desde los nodos de las hojas. izquierda = self.invertTree(raíz.izquierda) derecha = self.invertTree(raíz.derecha) raíz.izquierda, raíz.derecha = derecha, izquierda devolver la raíz

Complejidad del tiempo: O (N), donde N es el número de nodos del árbol binario. Atravesaremos cada nodo del árbol binario y, para cada nodo, intercambiamos sus dos subárboles en tiempo constante.

Complejidad espacial: O (N). El espacio utilizado está determinado por la profundidad de la pila de recursividad, que es igual a la altura del nodo actual en el árbol binario. En circunstancias normales, la altura de un árbol binario tiene una relación logarítmica con el número de nodos, es decir, O (logN). En el peor de los casos, el árbol forma una cadena y la complejidad espacial es O (N)

Dado un número entero n, ¿cuántos árboles de búsqueda binarios hay con 1...n como nodos?

1. Recorra cada número i, use el número como raíz del árbol, use la secuencia 1⋯(i−1) como subárbol izquierdo y use la secuencia (i 1)⋯n como subárbol derecho. Entonces podemos construir recursivamente el subárbol izquierdo y el subárbol derecho de la misma manera.

2. Dado que los valores raíz son diferentes, podemos asegurarnos de que cada árbol de búsqueda binario sea único.

3. El problema original se puede descomponer en dos subproblemas más pequeños y las soluciones a los subproblemas se pueden reutilizar. La programación dinámica se puede utilizar para resolver este problema.

4. Podemos definir dos funciones: G (n): el número de árboles de búsqueda binarios diferentes que pueden formarse mediante una secuencia de longitud n. F (i, n): el número de árboles de búsqueda binarios diferentes con i como raíz y longitud de secuencia n (1≤i≤n). Se puede ver que G(n) es la función que necesitamos resolver

5. El número total de diferentes árboles de búsqueda binarios G (n) es la suma de F (i, n) que atraviesa todos los i (1≤i≤n)

6. Para casos límite, cuando la longitud de la secuencia es 1 (solo la raíz) o 0 (árbol vacío), solo hay una situación, a saber: G (0) = 1, G (1) = 1

7. Seleccione el número i como raíz, luego el conjunto de todos los árboles de búsqueda binarios con la raíz i es el producto cartesiano del conjunto de subárboles izquierdo y el conjunto de subárboles derecho.

8. Combina las dos fórmulas:

solución de clase { público int numTrees(int n) { int[] G = nuevo int[n 1]; G[0] = 1; GRAMO[1] = 1; para (int i = 2; i <= n; i) { para (int j = 1; j <= i; j) { G[i] = G[j - 1] * G[i - j]; } } devolver G[n]; } }

clase Solución: def numTrees(self, n): G = [0]*(n 1) #Lista de longitud n 1 G[0], G[1] = 1, 1 para i en el rango (2, n 1): #Atravesar desde G[2] hasta n para j en el rango (1, i 1): #Fórmula de suma correspondiente de 1 a n G[i] = G[j-1] * G[i-j] devolver G[n]

Complejidad del tiempo: O (n ^ 2), donde n representa el número de nodos en el árbol de búsqueda binario. La función G (n) tiene un total de n valores que deben resolverse. Cada solución requiere una complejidad de tiempo O (n), por lo que la complejidad de tiempo total es O (n ^ 2).

Complejidad espacial: O (n). Necesitamos espacio O(n) para almacenar la matriz G

1. El valor de la función G(n) obtenido en el método 1 se denomina matemáticamente número catalán Cn ​

solución de clase { público int numTrees(int n) { // Consejo: aquí debemos utilizar el tipo largo para evitar el desbordamiento durante el cálculo. largo C = 1; para (int i = 0; i < n; i) { C = C * 2 * (2 * yo 1) / (yo 2); } devolver (int) C; } }

clase Solución (objeto): def numTrees(self, n): C=1 para i en el rango (0, n): C = C * 2*(2*yo 1)/(yo 2) devolver entero(C)

Complejidad del tiempo: O (n), donde n representa el número de nodos en el árbol de búsqueda binario. Sólo necesitamos recorrerlo una vez.

Complejidad espacial: O(1). Solo necesitamos espacio constante para almacenar varias variables.

Dado un número entero n, genere todos los árboles de búsqueda binarios que constan de los nodos 1...n

1. Supongamos que la longitud de la secuencia actual es n, y si enumeramos el valor del nodo raíz como i, entonces, de acuerdo con las propiedades del árbol de búsqueda binario, podemos saber que el conjunto de valores de nodo del El subárbol izquierdo es [1...i−1] y el conjunto de valores de nodo del subárbol derecho es [1...i−1]. yo 1…n]. En comparación con el problema original, la generación del subárbol izquierdo y el subárbol derecho es un subproblema con una longitud de secuencia reducida, por lo que podemos pensar en utilizar métodos recursivos para resolver este problema.

2. Defina la función generateTrees(inicio, fin) para indicar que el valor actual establecido es [inicio, fin] y devuelva todos los árboles de búsqueda binarios factibles generados por la secuencia [inicio, fin]. De acuerdo con la idea anterior, consideramos que el valor ii en la enumeración [inicio, fin] es la raíz del árbol de búsqueda binario actual, luego la secuencia se divide en dos partes: [inicio, i−1] y [i 1 , fin]. Llamamos a estas dos partes de forma recursiva, es decir, generateTrees (inicio, i - 1) y generateTrees (i 1, end), para obtener todos los subárboles izquierdos factibles y los subárboles derechos factibles. Luego, en el último paso, solo necesitamos recopilar los subárboles izquierdos factibles. subárboles de los subárboles izquierdos factibles Seleccione uno, luego seleccione uno del conjunto de subárboles derechos factibles y empalme con el nodo raíz, y coloque el árbol de búsqueda binario generado en la matriz de respuesta.

3. El punto de entrada de la recursividad es generateTrees (1, n), y el punto de salida es cuando \textit{start}>\textit{end}start>end, el árbol de búsqueda binario actual está vacío, simplemente devuelve un nodo vacío.

clase Solución: def generarTrees(self, n: int) -> Lista[TreeNode]: def generarárboles(inicio, fin): si inicio > fin: devolver [Ninguno,] todos los árboles = [] for i in range(start, end 1): # Enumerar nodos raíz factibles #Primero complete la construcción recursiva de los subárboles izquierdo y derecho, y luego use el conjunto completo de subárboles izquierdo y derecho para construir un árbol completo leftTrees = generateTrees(start, i - 1) # Obtiene el conjunto de todos los subárboles izquierdos factibles rightTrees = generateTrees(i 1, end) # Obtener el conjunto de todos los subárboles derechos factibles # Seleccione un subárbol izquierdo del conjunto de subárboles izquierdo, seleccione un subárbol derecho del conjunto de subárboles derecho y empalme con el nodo raíz para l en leftTrees: #Relación del producto de Descartes para r en árboles derechos: currTree = TreeNode(i) #nodo raíz árbolcurr.izquierda = l árbolcurr.derecha = r allTrees.append(currTree) devolver todos los árboles devolver generarTrees(1, n) si n más []

Complejidad temporal: la complejidad temporal de todo el algoritmo depende del "número de árboles de búsqueda binarios factibles", y el número de árboles de búsqueda binarios generados para n puntos es equivalente al enésimo "número de Cattleya" en matemáticas, utilizando G_n significa. Se solicita a los lectores que verifiquen los detalles específicos del número de Cattleya por sí mismos. No entraré en detalles aquí y solo daré la conclusión. Generar un árbol de búsqueda binario requiere una complejidad de tiempo O (n). Hay G_n árboles de búsqueda binarios en total, que es O (nG_n).

Complejidad del espacio: hay Gn árboles de búsqueda binarios generados por n puntos, cada árbol tiene n nodos, por lo que el espacio de almacenamiento requiere O (nG_n)

Dados dos árboles binarios, imagina que cuando superpones uno sobre el otro, algunos de los nodos de los dos árboles binarios se superponen. Debes fusionarlos en un nuevo árbol binario. La regla de la fusión es que si dos nodos se superponen, sus valores se agregan como el nuevo valor después de que se fusiona el nodo. De lo contrario, el nodo que no es NULL se utilizará directamente como el nodo del nuevo árbol binario.

1. Atraviese dos árboles binarios simultáneamente desde el nodo raíz y combine los nodos correspondientes. Los nodos correspondientes de los dos árboles binarios pueden tener las siguientes tres situaciones. Utilice diferentes métodos de fusión para cada situación.

2. Si los nodos correspondientes de los dos árboles binarios están vacíos, los nodos correspondientes del árbol binario fusionado también estarán vacíos.

3. Si solo uno de los nodos correspondientes de los dos árboles binarios está vacío, el nodo correspondiente del árbol binario fusionado será el nodo no vacío.

4. Si los nodos correspondientes de los dos árboles binarios no están vacíos, el valor del nodo correspondiente del árbol binario fusionado es la suma de los valores de los nodos correspondientes de los dos árboles binarios. Los nodos deben fusionarse explícitamente.

5. Después de fusionar un nodo, los subárboles izquierdo y derecho del nodo deben fusionarse respectivamente. Este es un proceso recursivo.

solución de clase { Nodo de árbol público mergeTrees (Nodo de árbol t1, Nodo de árbol t2) { si (t1 == nulo) { devolver t2; } si (t2 == nulo) { devolver t1; } // Primero fusiona el nodo actual y luego recurre a sus subárboles izquierdo y derecho TreeNode fusionado = nuevo TreeNode(t1.val t2.val); fusionado.izquierda = mergeTrees(t1.izquierda, t2.izquierda); fusionado.derecho = mergeTrees(t1.derecho, t2.derecho); volver fusionado; } }

clase Solución: def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode: si no t1: regresar t2 si no t2: regresar t1 #Primero fusione el nodo actual y luego recurra a sus subárboles izquierdo y derecho fusionado = TreeNode(t1.val t2.val) fusionado.izquierda = self.mergeTrees(t1.izquierda, t2.izquierda) fusionado.derecho = self.mergeTrees(t1.derecho, t2.derecho) volver fusionado

Complejidad del tiempo: O (min (m, n)), donde myn son el número de nodos de los dos árboles binarios respectivamente. Realice una búsqueda en profundidad en dos árboles binarios al mismo tiempo. Solo cuando los nodos correspondientes en los dos árboles binarios no estén vacíos, el nodo se fusionará explícitamente. Por lo tanto, el número de nodos visitados no excederá el número de nodos. Árbol binario más pequeño. Número de nodos.

Complejidad espacial: O (min (m, n)), donde myn son el número de nodos de los dos árboles binarios respectivamente. La complejidad del espacio depende de la cantidad de niveles de llamadas recursivas. La cantidad de niveles de llamadas recursivas no excederá la altura máxima del árbol binario más pequeño. En el peor de los casos, la altura del árbol binario es igual a la cantidad de nodos. .

Implementar un iterador de árbol de búsqueda binario. Inicializará el iterador utilizando el nodo raíz del árbol de búsqueda binario. Llamar a next() devolverá el siguiente número más pequeño en el árbol de búsqueda binaria

1. La forma más sencilla de implementar un iterador es en una interfaz de contenedor similar a una matriz. Si tenemos un array, sólo necesitamos un puntero o índice para implementar fácilmente las funciones next() y hasNext()

2. Utilice una matriz adicional y expanda el árbol de búsqueda binaria para almacenarla. Queremos que los elementos de la matriz se ordenen en orden ascendente, luego debemos realizar un recorrido en orden del árbol de búsqueda binario y luego construimos una función iteradora en la matriz.

3. Una vez que todos los nodos están en la matriz, solo necesitamos un puntero o índice para implementar las funciones next() y hasNext. Siempre que se llama a hasNext(), solo necesitamos verificar si el índice llega al final de la matriz. Siempre que se llama a next(), simplemente devolvemos el elemento señalado por el índice y avanzamos un paso para simular el progreso del iterador.

clase BSTIterador { ArrayList<Integer> nodosSorted; índice entero; BSTIterator público (raíz de TreeNode) { this.nodesSorted = new ArrayList<Integer>(); este.índice = -1; this._inorder(raíz); } vacío privado _inorder (raíz de TreeNode) { si (raíz == nulo) retorno; this._inorder(root.left); this.nodesSorted.add(root.val); this._inorder(root.right); } público int siguiente() { devolver this.nodesSorted.get( this.index); } hasNext público booleano() { devolver this.index 1 < this.nodesSorted.size(); } }

clase BSTIterador: self.nodes_sorted = [] auto.índice = -1 self._inorder(raíz) def __init__(self, raíz: TreeNode): self.nodes_sorted = [] auto.índice = -1 self._inorder(raíz) def _inorder(yo, raíz): si no es root: devolver self._inorder(raíz.izquierda) self.nodes_sorted.append(raíz.val) self._inorder(raíz.derecha) def siguiente(yo) -> int: auto.índice = 1 devolver self.nodes_sorted[self.index] def tieneNext(self) -> bool: devolver self.index 1 <len(self.nodes_sorted)

Complejidad del tiempo: el tiempo dedicado a construir el iterador es O (N). El planteamiento del problema solo requiere que analicemos la complejidad de las dos funciones, pero al implementar la clase, también debemos prestar atención al tiempo necesario para inicializar el objeto de clase. , en este caso A continuación, la complejidad del tiempo está relacionada linealmente con el número de nodos en el árbol de búsqueda binario: next(): O(1), hasNext(): O(1)

Complejidad espacial: O (N), dado que creamos una matriz para contener todos los valores de los nodos en el árbol de búsqueda binario, que no cumple con los requisitos en el enunciado del problema, la complejidad espacial máxima de cualquier función debe ser O (h) , donde h se refiere a la altura del árbol. Para un árbol de búsqueda binario equilibrado, la altura suele ser logN.

1. El método utilizado anteriormente tiene una relación lineal en el espacio con el número de nodos en el árbol de búsqueda binario. Sin embargo, la razón por la que tenemos que utilizar este enfoque es que podemos iterar sobre la matriz y no podemos pausar la recursividad y luego iniciarla en algún momento. Sin embargo, si podemos simular la recursividad controlada con recorrido en orden, en realidad no necesitamos usar ningún otro espacio que el espacio en la pila utilizado para simular la recursividad.

2. Utilice un método iterativo para simular un recorrido en orden en lugar de un método recursivo. En el proceso de hacer esto, podemos implementar fácilmente las llamadas de estas dos funciones en lugar de utilizar otro espacio adicional;

3. Inicialice una pila vacía S, utilizada para simular el recorrido en orden de un árbol de búsqueda binario. Para el recorrido en orden usamos el mismo método que antes, excepto que ahora usamos nuestra propia pila en lugar de la pila del sistema. Dado que utilizamos una estructura de datos personalizada, la recursividad se puede pausar y reanudar en cualquier momento.

4. También se debe implementar una función auxiliar, que se llamará una y otra vez durante la implementación. Esta función se llama _inorder_left, que agrega todos los hijos izquierdos de un nodo determinado a la pila hasta que al nodo no le queden hijos.

5. Cuando se llama a la función next() por primera vez, se debe devolver el elemento mínimo del árbol binario de búsqueda, y luego simulamos la recursividad y debemos avanzar un paso, es decir, pasar al siguiente elemento mínimo de el árbol de búsqueda binaria. La parte superior de la pila siempre contiene el elemento devuelto por la función next(). hasNext() es fácil de implementar ya que solo necesitamos verificar si la pila está vacía

6. Primero, dado el nodo raíz del árbol de búsqueda binario, llamamos a la función _inorder_left, que garantiza que la parte superior de la pila siempre contenga el elemento devuelto por la función next()

7. Supongamos que llamamos a next(), necesitamos devolver el siguiente elemento más pequeño en el árbol de búsqueda binario, que es el elemento superior de la pila. Hay dos posibilidades: Una es que el nodo en la parte superior de la pila es un nodo hoja. Este es el mejor de los casos porque no tenemos que hacer nada más que sacar el nodo de la pila y devolver su valor. Entonces esta es una operación de tiempo constante. Otro caso es cuando el nodo en la parte superior de la pila posee el nodo correcto. No necesitamos verificar el nodo izquierdo porque ya se agregó a la pila. El elemento superior de la pila no tiene un nodo izquierdo o el nodo izquierdo ha sido procesado. Si hay un nodo derecho en la parte superior de la pila, entonces debemos llamar a la función auxiliar en el nodo derecho. La complejidad del tiempo depende de la estructura del árbol.

clase BSTIterador { Pila<TreeNode> pila; BSTIterator público (raíz de TreeNode) { this.stack = new Stack<TreeNode>();//Usa la pila para simular la recursividad this._leftmostInorder(root);//El algoritmo comienza con la llamada de la función auxiliar } //Función auxiliar, agrega todos los nodos secundarios izquierdos a la pila vacío privado _leftmostInorder (raíz de TreeNode) { mientras (raíz! = nulo) { esta.pila.push(raíz); raíz = raíz.izquierda; } } público int siguiente() { TreeNode topmostNode = this.stack.pop();//El elemento superior de la pila es el elemento más pequeño //Mantenga el elemento superior de la pila como el elemento más pequeño. Si el nodo tiene un hijo derecho, llame a la función de ayuda. if (topmostNode.right! = nulo) { this._leftmostInorder(topmostNode.right); } devolver topmostNode.val; } hasNext público booleano() { devolver this.stack.size() > 0; } }

clase BSTIterador: def __init__(self, raíz: TreeNode): self.stack = [] #Usa la pila para simular la recursividad self._leftmost_inorder(root) #El algoritmo comienza con la llamada de la función auxiliar #Función de ayuda, agregue todos los nodos secundarios izquierdos a la pila def _leftmost_inorder(self, raíz): mientras que raíz: self.stack.append(raíz) raíz = raíz.izquierda def siguiente(yo) -> int: topmost_node = self.stack.pop() #El elemento superior de la pila es el elemento más pequeño #Mantenga el elemento superior de la pila como el elemento más pequeño. Si el nodo tiene un hijo derecho, llame a la función auxiliar. si topmost_node.right: self._leftmost_inorder(topmost_node.right) devolver topmost_node.val def tieneNext(self) -> bool: devolver len(self.stack) > 0

Complejidad del tiempo: hasNext(): si todavía hay elementos en la pila, devuelve verdadero; de lo contrario, devuelve falso. Entonces esta es una operación O(1). next(): Contiene dos pasos principales. Una es sacar un elemento de la pila, que es el siguiente elemento más pequeño. Esta es una operación O(1). Sin embargo, luego tenemos que llamar a la función auxiliar _inorder_left, que debe ser recursiva, agregando el nodo izquierdo a la pila, que es una operación de tiempo lineal, O(N) en el peor de los casos. Pero solo lo llamamos en el nodo que contiene el nodo correcto y no siempre procesará N nodos. Sólo si tenemos un árbol sesgado, habrá N nodos. Por lo tanto, la complejidad temporal promedio de esta operación sigue siendo O (1), lo que está en línea con los requisitos del problema.

Complejidad del espacio: O (h), usando una pila para simular la recursividad

Dada una matriz de números enteros positivos arr, considere todos los árboles binarios que cumplan las siguientes condiciones: Cada nodo tiene 0 o 2 nodos secundarios. Los valores en la matriz arr corresponden uno a uno al valor de cada nodo de hoja en el recorrido en orden del árbol. El valor de cada nodo no hoja es igual al producto del valor máximo del nodo hoja en su subárbol izquierdo y subárbol derecho. En todos estos árboles binarios, devuelve la suma más pequeña posible de los valores de cada nodo que no es hoja.

El núcleo de esta pregunta es: Debe saber que el recorrido en orden determina que todos los elementos izquierdos (incluido él mismo) del k-ésimo elemento en la matriz arr (0...n-1) están en el subárbol izquierdo, y sus elementos derechos están todos en el subárbol derecho, y en este momento, el producto de los valores máximos seleccionados de los subárboles izquierdo y derecho es la raíz en este momento, que es el nodo no hoja mencionado en la pregunta, por lo que podemos suponer que desde. i a j, la suma mínima puede ser: k en este momento El subproblema producto del valor máximo de los elementos en los lados izquierdo y derecho de k es el valor mínimo del subproblema k en la izquierda (i, k), el valor mínimo del lado derecho de k dígitos (k 1, j), Es decir: dp[i][j]=min(dp[i][j], dp[i][k] dp[k 1][j] max[i][k]*max[k 1][ j ]) Esta pregunta es la misma que leetcode1039.

solución de clase { público int mctFromLeafValues(int[] arreglo) { int n = longitud del arreglo; // Encuentra el valor máximo de los elementos en arr de i a j y guárdalo en max[i][j]. int[][] máx = nuevo int[n][n]; para (int j=0;j<n;j) { int maxValue = arreglo[j]; para (int i=j;i>=0;i--) { maxValue = Math.max(maxValue, arreglo[i]); máx[i][j] = valormáx; } } int[][] dp = nuevo int[n][n]; para (int j=0; j<n; j ) { para (int i=j; i>=0; i--) { //k es un valor entre i y j, i<=k<j int min = Entero.MAX_VALUE; para (int k=i; k 1<=j; k ) { min = Math.min(min,dp[i][k] dp[k 1][j] max[i][k]*max[k 1][j]); dp[i][j] = min;//Mantenga siempre la suma mínima entre i y j } } } devolver dp[0][n-1]; } }

clase Solución: def mctFromLeafValues(self, arr: Lista[int]) -> int: n = longitud(arr) dp = [[float('inf') for _ in range(n)] for _ in range(n)] # Establece el valor inicial al máximo maxval = [[0 for _ in range(n)] for _ in range(n)] # Establece el valor máximo de la consulta de rango inicial en 0 para i en rango(n):# Encuentra el elemento más grande en el rango [i, j] para j en el rango (i, n): valormax[i][j] = max(arr[i:j 1]) para i en rango (n):# Los nodos hoja no participan en el cálculo dp[i][i] = 0 para l en rango (1, n): # Longitud del intervalo de enumeración para s en rango (n - l): # Enumerar el punto inicial del rango para k en rango(s, s l):# Enumere y divida dos subárboles, k es un valor entre s y l dp[s][s l] = min(dp[s][s l], dp[s][k] dp[k 1][s l] maxval[s][k] * maxval[k 1][s l]) devolver dp[0][n - 1]

Tiempo: O(n^3), Espacio: O(n^2)

1. Si desea minimizar el valor mct, entonces los nodos de hoja con valores más pequeños deben colocarse en la parte inferior tanto como sea posible, y los nodos de hoja con valores más grandes deben colocarse lo más alto posible. Porque los nodos de hoja en la parte inferior se usan para multiplicar más veces. Esto determina que necesitamos encontrar un valor mínimo. Puede encontrar un valor mínimo manteniendo una pila monótonamente decreciente, porque dado que es una pila monótonamente decreciente, el nodo de la izquierda debe ser mayor que el nodo en la parte superior de la pila, y el nodo actual (a la derecha) es también mayor que el nodo en la parte superior de la pila (porque el nodo actual es más pequeño que la parte superior de la pila), se empuja directamente a la pila)

2. Después de encontrar este valor mínimo, debe mirar hacia la izquierda y hacia la derecha para ver qué valor es más pequeño a la izquierda o a la derecha. El propósito es colocar el valor más pequeño en la parte inferior tanto como sea posible.

solución de clase { público int mctFromLeafValues(int[] arreglo) { Pila<Integer> st = nueva Pila(); st.push(Integer.MAX_VALUE); int mct = 0; // Comience a construir una pila decreciente. Si el elemento actual es mayor que el elemento en la parte superior de la pila, el elemento en la parte superior de la pila saldrá de la pila para encontrar el valor mínimo. para (int i = 0; i <arr.length; i) { mientras (arr[i] >= st.peek()) { //El elemento superior de la pila se saca de la pila y se combina con los elementos más pequeños en los lados izquierdo y derecho mct = st.pop() * Math.min(st.peek(), arreglo[i]); } st.push(arr[i]); } mientras (st.tamaño() > 2) { mct = st.pop() * st.peek(); } devolver mct; } }

clase Solución: def mctFromLeafValues(self, A: Lista[int]) -> int: res, n = 0, len(A) stack = [float('inf')] #Pon el valor máximo primero en la pila # Comience a construir una pila decreciente. Si el elemento actual es mayor que el elemento superior de la pila, el elemento superior de la pila saldrá de la pila. Se puede encontrar el valor mínimo. para a en A: mientras que a >= pila[-1]: mid = stack.pop() #El elemento superior de la pila se saca de la pila y se combina con los elementos más pequeños en los lados izquierdo y derecho res = medio * min(pila[-1], a) pila.añadir(a) mientras len(pila) > 2: res = pila.pop() * pila[-1] devolver resolución

Tiempo: O(n), Espacio: O(n)

Convierta una matriz ordenada en orden ascendente en un árbol de búsqueda binario con altura equilibrada. Un árbol binario con altura equilibrada significa que el valor absoluto de la diferencia de altura entre los subárboles izquierdo y derecho de cada nodo de un árbol binario no excede 1.

1. Seleccione el número del medio como nodo raíz del árbol de búsqueda binaria, de modo que el número de números asignados a los subárboles izquierdo y derecho sea el mismo o solo difiera en 1, lo que puede mantener el árbol equilibrado.

2. Después de determinar el nodo raíz del árbol de búsqueda binario equilibrado, los números restantes se ubican en el subárbol izquierdo y el subárbol derecho del árbol de búsqueda binario equilibrado, respectivamente. El subárbol izquierdo y el subárbol derecho también son árboles de búsqueda binarios equilibrados, respectivamente. Puede crear un árbol de búsqueda binario equilibrado de forma recursiva.

3. ¿Por qué se puede garantizar que tal logro sea "equilibrado"? Aquí puede consultar "1382. Equilibrar el árbol de búsqueda binaria"

4. La situación básica de la recursividad es que el árbol de búsqueda binario equilibrado no contiene ningún número. En este momento, el árbol de búsqueda binario equilibrado está vacío.

5. En el caso de una matriz de secuencia transversal en orden dada, los números en cada subárbol deben ser continuos en la matriz. Los números contenidos en el subárbol se pueden determinar mediante el rango de subíndices de la matriz. El rango de subíndice está marcado como [izquierda. , derecha], cuando izquierda>derecha, el árbol de búsqueda binario equilibrado está vacío

clase Solución: def sortedArrayToBST(self, nums: Lista[int]) -> TreeNode: def ayudante (izquierda, derecha): si es izquierda > derecha: #Condición de terminación de dicotomía regresar Ninguno mid = (izquierda derecha) // 2 #Seleccione siempre el número a la izquierda de la posición media como nodo raíz root = TreeNode(nums[mid]) #Primero determine el nodo raíz, luego recurra a los subárboles izquierdo y derecho root.left = ayudante(izquierda, mitad - 1) root.right = ayudante(mitad 1, derecha) devolver la raíz ayudante de retorno(0, len(nums) - 1)

Complejidad del tiempo: O (n), donde n es la longitud de la matriz. Visita cada número solo una vez

Complejidad del espacio: O (logn), donde n es la longitud de la matriz. La complejidad del espacio no considera el valor de retorno, por lo que la complejidad del espacio depende principalmente de la profundidad de la pila recursiva. La profundidad de la pila recursiva es O (logn).

Tiempo: O(n), Espacio: O(n)

1. Establezca el intervalo de apertura izquierda y derecha

2. Utilice los punteros rápido y lento para encontrar la mediana.

3. Construya el árbol de forma recursiva.

clase Solución: def sortedListToBST(self, head: ListNode) -> TreeNode: def getMedian(izquierda: ListNode, derecha: ListNode) -> ListNode: rápido=lento=izquierda while fast != right and fast.next != right:#Defina el intervalo como cerrado por la izquierda y abierto por la derecha fast = fast.next.next#El puntero rápido se mueve dos veces y el puntero lento se mueve una vez lento = lento.siguiente volver lento #El puntero lento es la mediana en este momento def buildTree(izquierda: ListNode, derecha: ListNode) -> TreeNode: si izquierda == derecha: regresar Ninguno mid = getMedian(izquierda, derecha) #El intervalo se cierra por la izquierda y se abre por la derecha root = TreeNode(mid.val) #Primero determine el nodo raíz, luego construya los subárboles izquierdo y derecho root.left = buildTree(izquierda, mitad) #No es necesario mid.pre root.right = buildTree(medio.siguiente, derecha) devolver la raíz devolver buildTree(cabeza, Ninguno)

Complejidad del tiempo: O (nlogn), donde n es la longitud de la lista vinculada. Suponga que el tiempo para construir un árbol de búsqueda binario a partir de una lista vinculada de longitud n es T (n), y la fórmula de recurrencia es T (n) = 2⋅T (n/2) O (n). teorema, T(n)= O(nlogn)

Complejidad del espacio: O (logn), aquí solo se calcula el espacio distinto de la respuesta devuelta. La altura del árbol binario equilibrado es O (logn), que es la profundidad máxima de la pila durante el proceso recursivo, que es el espacio requerido.

1. Suponga que el número del extremo izquierdo de la lista vinculada actual es el izquierdo, el número del extremo derecho es el derecho, la relación de inclusión es "doble cerrada", el número de nodos de la lista vinculada es [0, n) y el orden del recorrido en orden es "subárbol izquierdo - nodo raíz - subárbol derecho", luego, en el proceso de dividir y conquistar, no tenemos que apresurarnos a encontrar el nodo mediano de la lista vinculada, sino usar un nodo marcador de posición, y luego complete su valor cuando el nodo se recorra en orden

2. Realice un recorrido de orden medio calculando el rango de números: el número correspondiente al nodo mediano es mid = (izquierda derecha 1) / 2, y los rangos de números correspondientes a los subárboles izquierdo y derecho son [izquierda, mid-1] y [mid 1 respectivamente, derecha], si izquierda>derecha, entonces la posición recorrida corresponde a un nodo vacío; de lo contrario, corresponde a un nodo en el árbol de búsqueda binario.

3. Ya conocemos la estructura de este árbol de búsqueda binaria y la pregunta proporciona el resultado del recorrido en orden. Entonces solo necesitamos realizar un recorrido en orden para restaurar todo el árbol de búsqueda binaria.

4. Diagrama de proceso recursivo

clase Solución: def sortedListToBST(self, head: ListNode) -> TreeNode: def getLength(cabeza: ListNode) -> int: retiro = 0 mientras cabeza: retirar=1 cabeza = cabeza.siguiente regresar def buildTree(izquierda: int, derecha: int) -> TreeNode: si izquierda > derecha: #Condición final del recorrido de orden medio regresar Ninguno medio = (izquierda derecha 1) // 2 raíz = NodoÁrbol() # Utilice recorrido en orden, primero construya el subárbol izquierdo, luego regrese al nodo raíz y luego construya el subárbol derecho, comenzando desde el primer elemento root.left = buildTree(izquierda, mitad - 1) encabezado no local #puede modificar el encabezado de la variable externa no global root.val = head.val #Comenzar a asignar valores desde el primer nodo cabeza = cabeza.siguiente root.right = buildTree(mediados de 1, derecha) devolver la raíz longitud = obtenerLongitud(cabeza) devolver buildTree(0, longitud - 1)

Complejidad del tiempo: O (n), donde n es la longitud de la lista vinculada. Supongamos que el tiempo para construir un árbol de búsqueda binario a partir de una lista vinculada de longitud n es T (n), y la fórmula de recurrencia es T (n) = 2⋅T (n/2) O (1). teorema, T(n)= O(n)

Complejidad del espacio: O (logn), aquí solo se calcula el espacio distinto de la respuesta devuelta. La altura del árbol binario equilibrado es O (logn), que es la profundidad máxima de la pila durante el proceso recursivo, que es el espacio requerido.

La serialización es la operación de convertir una estructura de datos u objeto en bits continuos. Los datos convertidos pueden luego almacenarse en un archivo o memoria, y también pueden transmitirse a otro entorno informático a través de la red y reconstruirse de forma opuesta. datos. Diseñe un algoritmo para implementar la serialización y deserialización de árboles binarios. La lógica de ejecución de su algoritmo de secuencia/deserialización no está limitada aquí. Solo necesita asegurarse de que un árbol binario se pueda serializar en una cadena y deserializar la cadena en la estructura de árbol original.

1. Serialización

2.Deserialización

Códec de clase: def serialize(self, root): #El recorrido de preorden implementa la serialización si raíz == Ninguno: devuelve 'X,' leftserilized = self.serialize(raíz.izquierda) derechoserilizados = self.serialize(root.right) return str(root.val) ',' leftserilized righterilized def deserializar(yo, datos): datos = datos.split(',') raíz = self.buildTree(datos) devolver la raíz def buildTree(yo, datos): val = data.pop(0) #pop el primer carácter if val == 'X': return Ninguno #Devuelve nodo vacío nodo = NodoÁrbol(val) nodo.izquierda = self.buildTree(datos) nodo.derecho = self.buildTree(datos) nodo de retorno

Tiempo: O(n), Espacio: O(n)

Dados los nodos raíz p y q de dos árboles binarios, escriba una función para verificar si los dos árboles son iguales

1. Si ambos árboles binarios están vacíos, entonces los dos árboles binarios son iguales. Si uno y sólo uno de los dos árboles binarios está vacío, entonces los dos árboles binarios no deben ser iguales.

2. Si ambos árboles binarios no están vacíos, primero determine si los valores de sus nodos raíz son iguales. Si no son iguales, los dos árboles binarios deben ser diferentes. Si son iguales, determine si. los subárboles izquierdo y derecho de los dos árboles binarios son iguales. Este es un proceso recursivo, por lo que puede utilizar la búsqueda en profundidad para determinar de forma recursiva si dos árboles binarios son iguales.

clase Solución: def esSameTree(self, p: TreeNode, q: TreeNode) -> bool: si no p y no q: #Ambos árboles están vacíos y son iguales devolver verdadero elif not p o not q: #Solo uno de los árboles está vacío, los dos árboles no son iguales falso retorno elif p.val != q.val: falso retorno demás: devuelve self.isSameTree(p.izquierda, q.izquierda) y self.isSameTree(p.derecha, q.derecha)

Complejidad del tiempo: O(\min(m,n))O(min(m,n)), donde mm y n son el número de nodos de los dos árboles binarios respectivamente. Realice una búsqueda en profundidad en dos árboles binarios al mismo tiempo. Se accederá al nodo solo cuando los nodos correspondientes en los dos árboles binarios no estén vacíos, por lo que la cantidad de nodos visitados no excederá la cantidad de nodos en el más pequeño. árbol binario.

Complejidad espacial: O(\min(m,n))O(min(m,n)), donde mm y n son el número de nodos de los dos árboles binarios respectivamente. La complejidad del espacio depende de la cantidad de niveles de llamadas recursivas. La cantidad de niveles de llamadas recursivas no excederá la altura máxima del árbol binario más pequeño. En el peor de los casos, la altura del árbol binario es igual a la cantidad de nodos. .

1. Primero determine si los dos árboles binarios están vacíos. Si ambos árboles binarios no están vacíos, comience la búsqueda en amplitud desde los nodos raíz de los dos árboles binarios.

2. Utilice dos colas para almacenar los nodos de dos árboles binarios respectivamente. Inicialmente, los nodos raíz de los dos árboles binarios se agregan a las dos colas respectivamente. Cada vez, se saca un nodo de las dos colas y se realiza la siguiente operación de comparación. Compare los valores de dos nodos. Si los valores de los dos nodos no son iguales, los dos árboles binarios deben ser diferentes; Si los valores de dos nodos son iguales, determine si los nodos secundarios de los dos nodos están vacíos. Si solo el nodo secundario izquierdo de un nodo está vacío o el nodo secundario derecho de solo un nodo está vacío, las estructuras. de los dos árboles binarios son diferentes, por lo tanto los dos árboles binarios deben ser diferentes; Si las estructuras de los nodos secundarios de los dos nodos son las mismas, agregue los nodos secundarios no vacíos de los dos nodos a las dos colas respectivamente. Debe prestar atención al orden al agregar los nodos secundarios a la cola. los nodos secundarios izquierdo y derecho no están vacíos, agregue primero el nodo secundario izquierdo y luego agregue el nodo secundario derecho.

3. Si ambas colas están vacías al mismo tiempo al final de la búsqueda, los dos árboles binarios son iguales. Si solo una cola está vacía, la estructura de los dos árboles binarios es diferente, por lo que los dos árboles binarios son diferentes

clase Solución: def esSameTree(self, p: TreeNode, q: TreeNode) -> bool: si no p y no q: #Ambos árboles están vacíos y son iguales devolver verdadero si no p o no q: #Solo uno de los árboles está vacío, los dos árboles no son iguales falso retorno cola1 = colecciones.deque([p]) cola2 = colecciones.deque([q]) mientras cola1 y cola2: nodo1 = cola1.popleft() nodo2 = cola2.popleft() si nodo1.val! = nodo2.val: falso retorno izquierda1, derecha1 = nodo1.izquierda, nodo1.derecha izquierda2, derecha2 = nodo2.izquierda, nodo2.derecha if (not left1) ^ (not left2): # ^ significa XOR, si los dos son diferentes, son 1, y si son iguales, son 0 falso retorno si (no está bien1) ^ (no está bien2): falso retorno si queda1: #Ingrese el nodo en la cola cuando no esté vacío cola1.append(izquierda1) si es correcto1: cola1.append(derecha1) si queda2: cola2.append(izquierda2) si es correcto2: cola2.append(derecha2) devolver no cola1 y no cola2

Complejidad del tiempo: O(\min(m,n))O(min(m,n)), donde mm y n son el número de nodos de los dos árboles binarios respectivamente. Realice una búsqueda en amplitud en dos árboles binarios al mismo tiempo. Se accederá al nodo solo cuando los nodos correspondientes en los dos árboles binarios no estén vacíos, por lo que la cantidad de nodos visitados no excederá la cantidad de nodos en el más pequeño. árbol binario.

Complejidad espacial: O(\min(m,n))O(min(m,n)), donde mm y n son el número de nodos de los dos árboles binarios respectivamente. La complejidad del espacio depende de la cantidad de elementos en la cola. La cantidad de elementos en la cola no excederá la cantidad de nodos del árbol binario más pequeño.

1. Para cualquier árbol, la forma de recorrido de preorden es siempre [Nodo raíz, [resultado del recorrido en preorden del subárbol izquierdo], [resultado del recorrido en preorden del subárbol derecho]] Es decir, el nodo raíz es siempre el primer nodo en el recorrido del pedido previo. La forma de recorrido en orden es siempre [[Resultado del recorrido en orden del subárbol izquierdo], nodo raíz, [Resultado del recorrido en orden del subárbol derecho]]

2. Siempre que ubiquemos el nodo raíz en el recorrido en orden, podremos conocer el número de nodos en el subárbol izquierdo y el subárbol derecho respectivamente. Dado que las longitudes del recorrido de preorden y del recorrido de orden del mismo subárbol son obviamente las mismas, podemos corresponder a los resultados del recorrido de preorden y ubicar todos los corchetes izquierdo y derecho en el formulario anterior.

3. De esta manera, conocemos los resultados del recorrido en preorden y en orden del subárbol izquierdo, y los resultados del recorrido en preorden y en orden del subárbol derecho. Podemos construir recursivamente el. subárbol izquierdo y el subárbol derecho, y luego conecte estos dos subárboles a las posiciones izquierda y derecha del nodo raíz.

4. Optimización: al ubicar el nodo raíz en el recorrido en orden, un método simple es escanear directamente todo el resultado del recorrido en orden y encontrar el nodo raíz list.index (x), pero la complejidad del tiempo para hacerlo es relativamente alta alta. Podemos considerar usar un HashMap para ayudarnos a localizar rápidamente el nodo raíz. Para cada par clave-valor en el mapa hash, la clave representa un elemento (el valor del nodo) y el valor representa su posición de aparición en el recorrido en orden. Antes de construir el árbol binario, podemos escanear la lista recorrida una vez para construir este mapa hash. En el proceso posterior de construcción del árbol binario, solo necesitamos O (1) tiempo para ubicar el nodo raíz.

1. Optimizado oficialmente, pero hay muchos parámetros. Puede usar dos parámetros para ver la combinación de pedido posterior y pedido medio.

2. Versión sencilla

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol

Complejidad del espacio: O (n), además del espacio O (n) requerido para devolver la respuesta, también necesitamos usar el espacio O (n) para almacenar el mapa hash y O (h) (donde h es la altura del árbol) el espacio representa el espacio de la pila durante la recursividad

1. Usamos una pila y un puntero para ayudar en la construcción del árbol binario. Inicialmente, el nodo raíz (el primer nodo del recorrido en orden anticipado) se almacena en la pila, y el puntero apunta al primer nodo del recorrido en orden "el nodo final alcanzado por el nodo actual al caminar continuamente hacia el izquierda."

2. Enumere cada nodo en el recorrido del pedido previo, excepto el primer nodo. Si el índice apunta al nodo superior de la pila, entonces continuamente sacamos el nodo superior de la pila y movemos el índice hacia la derecha, y usamos el nodo actual como el hijo derecho del último nodo extraído.

3. Si el índice es diferente del nodo superior de la pila, usamos el nodo actual como el hijo izquierdo del nodo superior de la pila.

4. No importa cuál sea la situación, finalmente insertaremos el nodo actual en la pila.

clase Solución: def buildTree(self, preorder: Lista[int], inorder: Lista[int]) -> TreeNode: si no preordenar: regresar Ninguno raíz = TreeNode(preorder[0]) pila = [raíz] inorderIndex = 0 # El nodo final alcanzado por el nodo actual se mueve continuamente hacia la izquierda, de acuerdo con el recorrido en orden para i en rango (1, len (preorden)): # Recorrido de preorden a partir del segundo nodo preordenVal = preorden[i] nodo = pila[-1] #El nodo superior de la pila if node.val != inorder[inorderIndex]: #Cuando el nodo superior de la pila no es igual, es el hijo izquierdo node.left = TreeNode(preorderVal) #Construye el hijo izquierdo directamente stack.append(node.left) #Empuja al hijo izquierdo hacia la pila else: #Cuando los nodos superiores de la pila son iguales, se ha atravesado hasta el punto más a la izquierda y es necesario sacarlo de la pila y luego atravesarlo hasta el hijo derecho de un determinado nodo. mientras que apilar y apilar[-1].val == inorder[inorderIndex]: nodo = stack.pop() #El elemento superior de la pila sale de la pila inorderIndex = 1 #Reemplazar el elemento más a la izquierda node.right = TreeNode(preorderVal) #Cuando los dos son diferentes, se encuentra el nodo padre del elemento actual stack.append(node.right) #También empuja el elemento actual a la pila devolver la raíz

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol

Complejidad del espacio: O (n) Además del espacio O (n) requerido para la respuesta devuelta, también necesitamos usar el espacio O (h) (donde h es la altura del árbol) para almacenar la pila.

1. El último elemento de la matriz atravesado en orden posterior representa el nodo raíz y luego se divide en recorridos en orden.

2. Tenga en cuenta que existe una relación de dependencia en la que primero debe crear el subárbol derecho y luego el subárbol izquierdo. Se puede entender que en la matriz de recorrido posterior al orden, la matriz completa primero almacena los nodos del subárbol izquierdo, luego los nodos del subárbol derecho y finalmente el nodo raíz. Si selecciona "el último nodo del postorden". recorrido de orden" como raíz de cada nodo de tiempo, el primero construido debe ser el subárbol derecho

1.Oficial: dos parámetros

2. Versión sencilla

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol

Complejidad del espacio: O (n), además del espacio O (n) requerido para devolver la respuesta, también necesitamos usar el espacio O (n) para almacenar el mapa hash y O (h) (donde h es la altura del árbol) el espacio representa el espacio de la pila durante la recursividad

1. Si invierte el recorrido en orden, obtendrá un recorrido en orden inverso, es decir, atravesará al hijo derecho cada vez, luego atravesará el nodo raíz y finalmente atravesará al hijo izquierdo. Si invierte el recorrido posterior al orden, obtendrá el recorrido inverso del orden previo, es decir, atraviesa el nodo raíz cada vez, luego atraviesa el hijo derecho y finalmente atraviesa el hijo izquierdo.

2. La diferencia con la pregunta anterior es: todos los hijos de la izquierda se convierten en hijos de la derecha, todos los hijos de la derecha se convierten en hijos de la izquierda y el recorrido de orden directo se cambia a recorrido de orden inverso.

clase Solución: def buildTree(self, inorder: Lista[int], postorder: Lista[int]) -> TreeNode: si no postorder: regresar Ninguno raíz = TreeNode(postorder[-1]) pila = [raíz] inorderIndex = -1 #El nodo final alcanzado por el nodo actual se mueve continuamente hacia la derecha, de acuerdo con el recorrido en orden for i in range(len(postorder)-2, -1,-1):#Recorrer el recorrido posterior al orden comenzando desde el penúltimo nodo postordenVal = postorden[i] nodo = pila[-1] #El nodo superior de la pila if node.val != inorder[inorderIndex]: #Cuando el nodo superior de la pila no es igual, es el hijo correcto node.right = TreeNode(postorderVal) #Construye el hijo correcto directamente stack.append(node.right) #Empuja el elemento secundario correcto en la pila else: # Cuando los nodos superiores de la pila son iguales, se ha atravesado hasta el punto más a la derecha. Es necesario sacarlo de la pila y luego atravesarlo hasta el hijo izquierdo de un determinado nodo. mientras que apilar y apilar[-1].val == inorder[inorderIndex]: nodo = stack.pop() #El elemento superior de la pila sale de la pila inorderIndex -= 1 #Reemplazar el elemento más a la derecha node.left = TreeNode(postorderVal) #Cuando los dos son diferentes, se encuentra el nodo padre del elemento actual stack.append(node.left) #También empuja el elemento actual a la pila devolver la raíz

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol

Complejidad del espacio: O (n) Además del espacio O (n) requerido para la respuesta devuelta, también necesitamos usar el espacio O (h) (donde h es la altura del árbol) para almacenar la pila.

Una ruta se define como una secuencia que comienza desde cualquier nodo del árbol, se conecta a lo largo del nodo principal y el nodo secundario y llega a cualquier nodo. El mismo nodo aparece como máximo una vez en una secuencia de ruta. La ruta contiene al menos un nodo y no necesariamente pasa por el nodo raíz. La suma de la ruta es la suma de los valores de cada nodo en la ruta. Proporcionarle la raíz del nodo raíz de un árbol binario y devolver la suma máxima de su ruta.

1. Primero, considere implementar una función simplificada maxGain (nodo), que calcula el valor de contribución máximo de un nodo en el árbol binario. Específicamente, busca el nodo como punto de partida en el subárbol con el nodo como nodo raíz. una ruta que maximiza la suma de los valores de los nodos en la ruta

2. Específicamente, la función se calcula de la siguiente manera. El valor máximo de contribución de un nodo vacío es igual a 00. El valor de contribución máximo de un nodo no vacío es igual a la suma del valor del nodo y el valor de contribución máximo en sus nodos secundarios (para los nodos hoja, el valor de contribución máximo es igual al valor del nodo

3. El proceso de cálculo anterior es un proceso recursivo. Por lo tanto, llamando a la función maxGain en el nodo raíz, se puede obtener el valor de contribución máximo de cada nodo.

4. Después de obtener el valor de contribución máximo de cada nodo según la función maxGain, ¿cómo obtener la suma de ruta máxima del árbol binario? Para un nodo en un árbol binario, la suma de ruta máxima del nodo depende del valor del nodo y del valor de contribución máximo de los nodos secundarios izquierdo y derecho del nodo. Si el valor de contribución máximo del nodo secundario es positivo, está incluido en la suma de ruta máxima del nodo; de lo contrario, no se incluirá en la suma de ruta máxima del nodo. Mantenga una variable global maxSum para almacenar la suma de ruta máxima y actualice el valor de maxSum durante el proceso recursivo. El valor final de maxSum es la suma de ruta máxima en el árbol binario.

clase Solución: def __init__(yo): self.maxSum = float("-inf") #El valor máximo se inicializa a infinito negativo def maxPathSum(self, raíz: TreeNode) -> int: def maxGain(nodo): #Obtener el valor máximo de contribución del nodo si no es nodo: regresar 0 # Calcular recursivamente el valor máximo de contribución de los nodos secundarios izquierdo y derecho # Solo cuando el valor máximo de contribución sea mayor que 0, se seleccionará el nodo hijo correspondiente ganancia izquierda = max(gananciamax(nodo.izquierda), 0) ganancia derecha = max(gananciamax(nodo.derecha), 0) # Primero obtenga el valor de ruta máximo con el nodo actual como nodo raíz y luego devuelva el valor de contribución máximo del nodo #La suma de ruta máxima de un nodo depende del valor del nodo y del valor de contribución máximo de los nodos secundarios izquierdo y derecho del nodo. precioNewpath = node.val ganancia izquierda ganancia derecha self.maxSum = max(self.maxSum, priceNewpath) # Actualizar respuesta # Devuelve el valor de contribución máximo del nodo, que está determinado por el mayor entre el valor del nodo y el subárbol izquierdo/subárbol derecho devolver node.val max (ganancia izquierda, ganancia derecha) ganancia máxima(raíz) devolver self.maxSum

Complejidad del tiempo: O (N) O (N), donde NN es el número de nodos en el árbol binario. No más de 2 visitas a cada nodo.

Complejidad espacial: O (N) O (N), donde NN es el número de nodos en el árbol binario. La complejidad del espacio depende principalmente de la cantidad de niveles de llamadas recursivas. El número máximo de niveles es igual a la altura del árbol binario. En el peor de los casos, la altura del árbol binario es igual a la cantidad de nodos en el árbol binario. .

Dada una matriz de números enteros sin elementos duplicados. Un árbol binario máximo construido directa y recursivamente a partir de esta matriz se define de la siguiente manera: La raíz del árbol binario es el elemento más grande de la matriz nums. El subárbol izquierdo es el árbol binario más grande construido recursivamente a través de la parte izquierda del valor máximo en la matriz. El subárbol derecho es el árbol binario más grande construido de forma recursiva a través de la parte derecha del valor máximo de la matriz. Devuelve el árbol binario más grande construido con los números de matriz dados.

Sigue siendo una trilogía 1. Condición de terminación de la recursividad: cuando las matrices del subárbol izquierdo y del subárbol derecho están vacías 2. Qué hace esta recursividad: saque el valor máximo de la matriz, divida la matriz en matrices izquierda y derecha según el valor máximo y luego realice una asignación recursiva 3. Qué se devuelve: el nodo raíz del subárbol

clase Solución: def constructMaximumBinaryTree(self, nums: Lista[int]) -> TreeNode: si no números: devolver Ninguno # Aplicable cuando hay elementos repetidos # max_v, m_i = flotador(-inf), 0 # para i, v en enumerar(nums): # si v>max_v: #max_v=v # m_i = yo max_v = max(núms) m_i = números.index(max_v) raíz = TreeNode(max_v) root.left = self.constructMaximumBinaryTree(nums[:m_i]) root.right = self.constructMaximumBinaryTree(nums[m_i 1:]) devolver la raíz

Complejidad del tiempo: O (n ^ 2), la construcción del método se llama n veces en total. Cada vez que busca recursivamente el nodo raíz, debe recorrer todos los elementos en el rango de índice actual para encontrar el valor máximo. En general, la complejidad de cada recorrido es O (logn) y la complejidad total es O (nlogn). En el peor de los casos, la matriz numsnums está ordenada y la complejidad total es O(n^2)

Complejidad espacial: O (n) O (n). La profundidad de la llamada recursiva es nn. En promedio, la profundidad de llamada recursiva para una matriz de longitud n es O(logn)

1. Construya una pila decreciente y empújela hacia la pila en secuencia. Si el elemento en la parte superior de la pila es más pequeño que el elemento actual, el elemento en la parte superior de la pila se saca de la pila.

2. Compare el tamaño del elemento superior después de sacarlo de la pila con el tamaño del elemento actual. Si es más grande que el elemento actual, el elemento actual se usa como nodo principal y el elemento sacado se usa como nodo. hijo izquierdo; si el elemento superior de la pila es más pequeño que el elemento actual, el elemento superior de la pila se usa como nodo padre y lo saca de la pila. El elemento previamente extraído se usa como el hijo derecho y continúa. hasta que el nodo actual sea empujado a la pila.

3. Hasta el final del último elemento, se forma la pila decreciente y la pila se extrae secuencialmente. Los elementos extraídos se utilizan como los elementos secundarios correctos. El último que se extrae de la pila es el nodo raíz. .

Ejemplo

public TreeNode constructMaximumBinaryTree(int[] números) { Raíz de TreeNode = nulo, nodo = nulo; LinkedList<TreeNode> pila = nueva LinkedList<>(); para (int i = 0; i < nums.length; i) { nodo = nuevo TreeNode(nums[i]); // Construya una pila decreciente. Cuando el elemento superior de la pila es más pequeño que el elemento actual, el elemento superior de la pila se extraerá de la pila. mientras (!stack.isEmpty() && stack.peek().val < nodo.val) { root = stack.pop();//El elemento superior de la pila actual, el valor más pequeño // Compara el tamaño de la parte superior de la pila después de abrirla con el tamaño del elemento actual. Si es más grande que el elemento actual, el elemento actual se utilizará como nodo principal. if (pila.isEmpty() || pila.peek().val > nodo.val) { nodo.izquierda = raíz; } else {//Si es menor que el elemento actual, el elemento superior de la pila se utilizará como nodo principal pila.peek().right = raíz; } } stack.push(node);//Empuja el elemento actual a la pila } // La pila decreciente está completamente formada y puede extraerse como el hijo correcto. mientras (!stack.isEmpty()) { raíz = pila.pop(); si (!stack.isEmpty()) { pila.peek().right = raíz; } } return root;// Lo último que sale de la pila es root, regresa a este nodo }

Complejidad del tiempo: O (n), Complejidad del espacio: O (n)

Definición máxima de árbol: un árbol en el que el valor de cada nodo es mayor que cualquier otro valor en su subárbol. da la raíz del nodo raíz del árbol más grande. Al igual que la pregunta anterior, el árbol dado se construye recursivamente a partir de la lista A, no se nos proporciona A directamente, solo una raíz del nodo raíz, asumiendo que B es una copia de A con el valor val agregado al final. Los datos de la pregunta garantizan que los valores en B son diferentes. Construcción de retorno (B)

Cada vez que se compara con el nodo principal, si es más pequeño se comprueba su nodo derecho. Actualización: 1) El nodo existente se convierte en el nodo izquierdo del nuevo nodo, 2) el nuevo nodo se convierte en el nodo derecho del nodo principal

def insertIntoMaxTree(self, raíz: TreeNode, val: int) -> TreeNode: # variable ficticia, su hijo derecho apunta al nodo raíz ficticio = NodoÁrbol(0) tonto.derecha = raíz # buscar Si el valor del nodo raíz actual es mayor que val, continúe consultando su hijo derecho p, c = ficticio, ficticio.derecha mientras c y c.val > val: p, c = c, c.derecha # insert En este momento, val es mayor que el nodo raíz, val se usa como el hijo derecho del nodo raíz anterior y el nodo raíz actual se usa como el hijo izquierdo de val. n = NodoÁrbol(val) p.derecha = n n.izquierda = c return dummy.right #dummy no ha cambiado, su hijo derecho apunta al nodo raíz

El mismo procesamiento se realiza cuando es mayor que el nodo raíz. Cuando es menor que el nodo raíz, el hijo derecho del nodo raíz se procesa de forma recursiva.

def insertIntoMaxTree(self, raíz: TreeNode, val: int) -> TreeNode: si root es Ninguno: # Condición de terminación recursiva returnTreeNode(val) if val > root.val: #Cómo manejar val mayor que el nodo raíz actual tmp = NodoÁrbol(val) tmp.izquierda = raíz regresar tmp # Procesar recursivamente el hijo derecho del nodo raíz raíz.derecha = self.insertIntoMaxTree(raíz.derecha, val) return root # Valor de retorno recursivo, nodo raíz

Dado un árbol binario, determine si es un árbol binario de altura equilibrada. En esta pregunta, un árbol binario con altura equilibrada se define como: el valor absoluto de la diferencia de altura entre los subárboles izquierdo y derecho de cada nodo de un árbol binario no excede 1

1. Defina la altura de la función, que se utiliza para calcular la altura de cualquier nodo p en el árbol binario.

2. Similar al recorrido de pedido previo de un árbol binario, es decir, para el nodo actualmente atravesado, primero calcule la altura de los subárboles izquierdo y derecho. Si la diferencia de altura entre los subárboles izquierdo y derecho no excede 1, entonces. atraviesa recursivamente los subnodos izquierdo y derecho respectivamente y determina si los subárboles izquierdo y derecho están equilibrados. Este es un proceso recursivo de arriba hacia abajo.

solución de clase: #De arriba hacia abajo, similar al recorrido de pedido previo, calculará repetidamente la altura de los subárboles izquierdo y derecho def isBalanced(self, raíz: TreeNode) -> bool: def altura(raíz: TreeNode) -> int: si no es root: regresar 0 devolver max(altura(raíz.izquierda), altura(raíz.derecha)) 1 si no es root: devolver verdadero return abs(altura(raíz.izquierda) - altura(raíz.derecha)) <= 1 y self.isBalanced(root.left) y self.isBalanced(root.right)

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol binario. Utilizando la recursividad ascendente, la altura de cálculo de cada nodo y el juicio de si está equilibrado solo deben procesarse una vez. En el peor de los casos, es necesario atravesar todos los nodos del árbol binario, por lo que la complejidad del tiempo es O (. norte)

Complejidad espacial: O (n), donde n es el número de nodos en el árbol binario. La complejidad del espacio depende principalmente de la cantidad de niveles de llamadas recursivas. La cantidad de niveles de llamadas recursivas no excederá nn.

1. Dado que el método uno es recursivo de arriba hacia abajo, la función \texttt{height}height se llamará repetidamente para el mismo nodo, lo que generará una gran complejidad temporal. Si se utiliza el enfoque ascendente, la función \texttt{height}height solo se llamará una vez para cada nodo.

2. El método recursivo ascendente es similar al recorrido posterior al orden. Para el nodo actualmente atravesado, primero determine de forma recursiva si sus subárboles izquierdo y derecho están equilibrados y luego determine si el subárbol enraizado en el nodo actual está equilibrado. Si un subárbol está equilibrado, se devuelve su altura (la altura debe ser un número entero no negativo); de lo contrario, se devuelve -1−1. Si hay un subárbol desequilibrado, todo el árbol binario debe estar desequilibrado

solución de clase: # De abajo hacia arriba, similar al recorrido posterior al orden, primero determine los subárboles izquierdo y derecho, y luego determine el nodo raíz, asegurándose de que la altura de cada nodo solo se calcule una vez def isBalanced(self, raíz: TreeNode) -> bool: def altura(raíz: TreeNode) -> int: si no es root: regresar 0 AlturaIzquierda = altura(raíz.izquierda) alturaderecha = altura(raíz.derecha) si AlturaIzquierda == -1 o AlturaDerecha == -1 o abs(AlturaIzquierda - AlturaDerecha) > 1: regresar -1 demás: devolver max(alturaizquierda, alturaderecha) 1 altura de retorno (raíz) >= 0

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol binario. Utilizando la recursividad ascendente, la altura de cálculo de cada nodo y el juicio de si está equilibrado solo deben procesarse una vez. En el peor de los casos, es necesario atravesar todos los nodos del árbol binario, por lo que la complejidad del tiempo es O (. norte)

Complejidad espacial: O (n), donde n es el número de nodos en el árbol binario. La complejidad del espacio depende principalmente de la cantidad de niveles de llamadas recursivas. La cantidad de niveles de llamadas recursivas no excederá nn.

Dado un árbol binario, encuentre su profundidad mínima. La profundidad mínima es el número de nodos en el camino más corto desde el nodo raíz hasta el nodo hoja más cercano.

1. La clave de esta pregunta es descubrir la condición final recursiva. La definición de nodo hoja es que cuando tanto el hijo izquierdo como el hijo derecho son nulos, se denomina nodo hoja. Cuando los hijos izquierdo y derecho del nodo raíz están vacíos, devuelve 1 Cuando uno de los hijos izquierdo y derecho del nodo raíz está vacío, devuelve la profundidad del nodo hijo que no está vacío. Cuando los hijos izquierdo y derecho del nodo raíz están vacíos, devuelve los valores de nodo de menor profundidad de los hijos izquierdo y derecho.

clase Solución: def minDepth(self, raíz: TreeNode) -> int: si no es root: regresar 0 #Cuando los subárboles izquierdo y derecho están vacíos, es un nodo hoja y la distancia de retorno es 1 si no es root.left y no root.right: regresar 1 profundidad_min = 10**9 si root.left: #El subárbol izquierdo existe, compare la distancia mínima del subárbol izquierdo con la distancia mínima actual profundidad_min = min(self.profundidadmin(raíz.izquierda), profundidad_min) si root.right: profundidad_min = min(self.profundidadmin(raíz.derecha), profundidad_min) devolver min_profundidad 1

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol. Visita cada nodo una vez

Complejidad espacial: O (h), donde h es la altura del árbol. La complejidad del espacio depende principalmente de la sobrecarga del espacio de la pila durante la recursividad. En el peor de los casos, el árbol aparece en forma de cadena y la complejidad del espacio es O (n). En promedio, la altura del árbol está positivamente relacionada con el logaritmo del número de nodos y la complejidad del espacio es O (logN)

Cuando encontramos un nodo hoja, devolvemos directamente la profundidad del nodo hoja. La naturaleza de la búsqueda en amplitud garantiza que la profundidad del nodo hoja buscado primero debe ser la más pequeña.

clase Solución: def minDepth(self, raíz: TreeNode) -> int: si no es root: regresar 0 que = colecciones.deque([(raíz, 1)]) mientras que: nodo, profundidad = que.popleft() #El primer nodo hoja debe ser el nodo hoja más cercano si no es nodo.izquierda y nodo.derecha: profundidad de retorno si nodo.izquierda: que.append((nodo.izquierda, profundidad 1)) si nodo.derecho: que.append((nodo.derecha, profundidad 1)) regresar 0

Complejidad del tiempo: O (n), donde n es el número de nodos en el árbol. Visita cada nodo una vez

Complejidad del espacio: O (n), donde n es el número de nodos en el árbol. La complejidad del espacio depende principalmente de la sobrecarga de la cola. La cantidad de elementos en la cola no excederá la cantidad de nodos en el árbol.

La definición de dp[i] es: el valor de Fibonacci del i-ésimo número es dp[i]

Ecuación de transición de estado dp[i] = dp[i - 1] dp[i - 2]

La pregunta también nos da directamente cómo inicializar dp[0] = 0;dp[1] = 1;

dp [i] depende de dp [i - 1] y dp [i - 2], por lo que el orden de recorrido debe ser de adelante hacia atrás.

Cuando N es 10, la matriz dp debe tener la siguiente secuencia: 0 1 1 2 3 5 8 13 21 34 55 Si se escribe el código y se descubre que el resultado es incorrecto, imprima la matriz dp para ver si es coherente con la secuencia que derivamos.

Hay una forma de subir las escaleras al primer piso y hay dos formas de subir las escaleras al segundo piso. Luego da dos escalones más en el primer tramo de escaleras para llegar al tercer piso, y un escalón más en el segundo piso de escaleras para llegar al tercer piso. Entonces, el estado de las escaleras al tercer piso se puede deducir del estado de las escaleras al segundo piso y del estado de las escaleras al primer piso, entonces se puede pensar en programación dinámica.

dp[i]: Hay formas dp[i] de subir a la i-ésima escalera

De la definición de dp [i] se puede ver que dp [i] se puede derivar en dos direcciones. La primera es dp[i - 1]. Hay dp[i - 1] formas de subir las escaleras i-1. Luego, saltar un escalón a la vez es dp[i]. También hay dp[i - 2]. Hay dp[i - 2] formas de subir las escaleras i-2. Entonces saltar dos escalones en un solo paso es dp[i]. ¡Entonces dp[i] es la suma de dp[i - 1] y dp[i - 2]! Entonces dp[i] = dp[i - 1] dp[i - 2]

Entonces, si i es 0, ¿cuál debería ser dp[i]? Hay muchas explicaciones para esto, pero básicamente se explican directamente hacia la respuesta.

Por ejemplo, hay una forma de obligarte a consolarte y subir al piso 0. No hacer nada también es una forma: dp [0] = 1, que equivale a pararse directamente en la cima del edificio.

Pensé que cuando corrí al piso 0, el método era 0. Solo podía caminar uno o dos pasos a la vez, sin embargo, el piso era 0 y simplemente me quedé en el techo. No había ningún método, así que dp [0. ] debería ser 0.

La mayoría de las razones por las que dp[0] debería ser 1 son en realidad porque si dp[0]=1, puedo solucionar el problema comenzando desde 2 durante el proceso de recursividad y luego confiar en el resultado para explicar dp[0] = 1

La pregunta dice que n es un número entero positivo, pero no dice que n sea 0 en absoluto. Por lo tanto, esta pregunta no debería discutir la inicialización de dp [0].

Mi principio es: no considere la inicialización de dp [0], solo inicialice dp [1] = 1, dp [2] = 2 y luego comience la recursividad desde i = 3, de modo que cumpla con la definición de dp [i ]

De la fórmula recursiva se puede ver dp[i] = dp[i - 1] dp[i - 2] que el orden transversal debe ser de adelante hacia atrás;

Cuando N es 10, la matriz dp debe tener la siguiente secuencia: 0 1 1 2 3 5 8 13 21 34 55