Introducción

1

¿Ya tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?

Lista Enlazada

2

Estructura de datos: Lista Enlazada

3

Programando listas enlazadas con Java

4

Cómo Invertir una Lista Enlazada

5

Odd Even Linked List: análisis del problema

6

Solución de Odd Even Linked List

7

Playground: Odd Even Liked List

8

Programando Odd Even Linked List con C++

9

Linked List Cycle: análisis del problema

10

Solución de Linked List Cycle

11

Playground: Linked List Cycle

12

Programando Linked List Cycle con Python

13

Palindrome Linked List: análisis del problema

14

Solución de Palindrome Linked List

15

Playground: Palindrome Linked List

16

Programando Palindrome Linked List con Java

17

Reorder List: análisis del problema

18

Solución de Reorder List

19

Programando Reorder List con JavaScript

20

Playground: Reorder List Without Repeated Values

21

Reto: LRU Caché

22

Ejercicios Prácticos con Listas Enlazadas y Historial de Navegador

23

Operaciones con Listas Enlazadas: Suma, Intercambio y Navegador

Pilas y colas

24

Estructura de datos: Pilas y Colas

25

Paréntesis Válido: análisis del problema

26

Solución de Paréntesis Válido

27

Playground: Paréntesis Válido

28

Programando Paréntesis Válido con C++

29

Comparación de Cadenas con Backspaces

Colas de prioridad

30

Estructura de datos: Colas de Prioridad

31

K Closest Points to Origin: análisis del problema

32

Solución de K Closest Points to Origin

33

Playground: K Closest Points to Origin

34

Programando K Closest Points to Origin con Python

35

Reorganize String: análisis del problema

36

Solución de Reorganize String

37

Playground: Reorganize String

38

Programando Reorganize String con Python

39

Colas de Prioridad: Ejercicios Prácticos y Soluciones

40

Colas de Prioridad y Gestión de Eventos

Próximos pasos

41

Toma el Curso Avanzado de Algoritmos: Grafos y Árboles

Colas de Prioridad y Gestión de Eventos

40/41

Lectura

Ejercicios resueltos de Colas de Prioridad

Organizador de Tareas

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 1

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Dejo como resolvi el ejercicio de Car Pooling:

def car_pooling(trips: list[list[int]], capacity: int) -> bool:
    trips.sort(key=lambda x: x[1]) # Ordenamos por inicios de viajes
    ongoing_trips = [] # heap para registrar los viajes que aceptas [[kilometroFinal, noPasajeros]]
    kilometer = 0

    while trips:

        while ongoing_trips and kilometer == ongoing_trips[0][0]:
            capacity += ongoing_trips[0][1]
            heapq.heappop(ongoing_trips)

        while trips and kilometer == trips[0][1]:
            if capacity >= trips[0][0]:
                heapq.heappush(ongoing_trips, [trips[0][2], trips[0][0]])
                capacity -= trips[0][0]
                trips.pop(0) # Eliminamos de la lista el viaje tomado
            else:
                return False # No se pudo aceptar un viaje
            
        kilometer += 1
    return True