Estructura de Datos y Algoritmos

Universidad Carlos III de Madrid

Curso 2022-2023

Examen Convocatoria Ordinaria (evaluación continua). 19 mayo 2023.

Nombre y Apellidos

Grupos reducido

Instrucciones:
- Escribe tu nombre en el cuadernillo y en las hojas de cuadro.
- La duración del examen es de 120 minutos.
- Los móviles deben estar apagados y nunca pueden estar encima de la mesa.
- Utiliza las hojas de cuadros para preparar tu solución. Cada ejercicio se
entregará en una hoja separada.
- Cuida al máximo la presentación de tu solución. Es imprescindible que tu
código sea claro, bien ordenado y limpio.
- No puedes pedir tipex, bolígrafo, etc a tus compañeros. Si necesitas algo,
pídeselo al profesor.
- No puedes salir del examen antes de que pasen 30 minutos.
- No está permitido ir al baño.
- Cuando termines, entrega el enunciado al profesor junto con las hojas de
cuadros de tu solución (una hoja por ejercicio).

RECUERDA CADA EJERCICIO HAY QUE ENTREGARLO EN HOJAS

SEPARADAS.
Problema 1 (2 puntos). Tiempo estimado 45 minutos:
La clase MyGraph es una implementación basada en diccionarios para representar un grafo
dirigido y no ponderado. Los vértices del mismo son números enteros que se darán en una
lista de Python como parámetro en la creación del grafo.
Se pide:
1. Implementar el método has_path_to_odd(k) que recibe como parámetro un número
entero k (mayor que 1) y devuelve una lista de Python con todos los vértices del grafo
que se encuentran a menor distancia que k de un vértice impar (que no sea él mismo).
Se considera distancia al número de aristas que hay entre dos vértices.
Es decir, el método retorna una lista de Python con los vértices del grafo que tienen
una distancia menor que k hasta un vértice impar (número de aristas menor que k).
Se excluyen rutas desde un vértice impar hasta sí mismo.

2. Además, tu solución debe respetar las siguientes reglas:

● La lista de retorno no necesita estar ordenada según ningún criterio.
● Si un vértice no tiene adyacentes no debe figurar en la lista de retorno.
● Si ningún vértice cumple las condiciones, se retorna una lista vacía.
● La solución NO tiene que estar basada en el algoritmo del camino mínimo
(algoritmo de Dijkstra).
● La solución tiene que ser recursiva (no iterativa).
● Cualquier método asociado al grafo es necesario implementarlo.
A continuación, se muestran algunos ejemplos y la implementación de la clase MyGraph:

Ejemplo 1

Sea G1 el MyGraph:

Llamada al método: G1.has_path_to_odd(2)

Retorno del método: [20,24]
Explicación: Devuelve una lista en Python con los vértices (pares o impares) que tienen
una distancia menor a 2 hacia otro vértice impar: 20 y 24.

Llamada al método: G1.has_path_to_odd(3)

Retorno del método: [16,20,22,24,25]
Explicación: Devuelve una lista en Python con los vértices (pares o impares) que tienen
una distancia menor a 3 hacia otro vértice impar: 16,20,22,24,25

Llamada al método: G1.has_path_to_odd(13)

Retorno del método: [2,4,6,8,10,14,16,20,22,24,25]
Explicación: Devuelve una lista en Python con los vértices (pares o impares) que tienen
una distancia menor a 13 hacia otro vértice impar: 2,4,6,8,10,14,16,20,22,24,25.
 No hay camino desde el vértice 12 hasta un vértice impar.
No hay camino desde el vértice 17 hasta un vértice impar (que no sea el mismo).

class MyGraph:

def __init__(self, list_vertices):

self._vertices = {}
for i in list_vertices:
self._vertices[i] = []

def add_edge(self, i, j):

if i not in self._vertices.keys():
return
if j not in self._vertices.keys():
return
self._vertices[i].append(j)

def has_path_to_odd(self, k) -> []:

#completar
Problema 2 (2 puntos). Tiempo estimado 45 minutos:

Se pide implementar una función que reciba una lista de Python de enteros e implemente el
algoritmo Quicksort para ordenar dicha lista de forma descendente (es decir, de mayor a
menor). Por ejemplo, dada la lista l = [3, 5, 0, -1, 8], tras aplicar el algoritmo Quicksort, la lista
deberá ser l = [8, 5, 3, 0, -1]. La función transforma la lista de entrada en una lista ordenada,
es decir, la función no devuelve nada. Además de estar basada en el algoritmo Quicksort, tu
solución debe ser lo más eficiente en términos de complejidad espacial (es decir, no se
recomienda el uso de listas auxiliares). También debes tener en cuenta las siguientes
condiciones:
● Si el tamaño de la partición de entrada es impar, el pivote será el elemento que está
en mitad de la partición. Por ejemplo, supongamos que recibimos la partición [3, 4, 5,
1, 2], que tiene un número impar de elementos, en este caso el pivote será p=5.
● Sin embargo, si la partición de entrada tiene un tamaño par, también seleccionaremos
un pivote central (es decir, en mitad de la partición de entrada) pero teniendo en cuenta
que la nueva partición izquierda sea más pequeña que la partición derecha. Veamos
algunos ejemplos:
o Si la partición es [3, 4, 5, 1], el pivote debe ser 4.
o Si la partición es [3, 4, 5, 1, 2, 8], el pivote debe ser 5.
o Si la partición es [0, -1, 2, -2, 3, 0, 5, 8], el pivote debe ser -2.
● El algoritmo debe funcionar para listas con duplicados, por ejemplo, si l = [3,1,5,3,5],
después de llamar al algoritmo, l será [5, 5, 3, 3, 1].
Problema 3. 1 punto. Tiempo estimado 30 minutos:

Implementa una función, intersection, que reciba dos árboles AVL y devuelva un nuevo árbol
AVL que contenga los elementos que comparten ambos árboles. Recuerda que tu solución
debe tener la menor complejidad espacial y temporal posible.

Además, tu solución debe respetar las siguientes reglas:

1. Debe ser recursiva. Enfoques no recursivos no serán evaluados.
2. No está permitido usar estructuras de Python como listas, diccionarios, conjuntos, etc.
3. No se pueden modificar los árboles de entrada al método (es decir, no puedes añadir
o eliminar elementos).

from avl import AVLTree

from bintree import BinaryNode

def intersection(t1: AVLTree, t2: AVLTree) -> AVLTree:

# completar