Ejercicios 1. Análisis de Algoritmos.

Profesor: Héctor Soza P.

1. Describa un algoritmo que use dividir para reinar para determinar los
tres datos menores de un conjunto de n ≥ 3 datos enteros distintos.
Analice su algoritmo contando la cantidad de comparaciones de datos
realizados en el peor caso. ¿Cómo es su resultado respecto a un
algoritmo que use sólo comparaciones (fuerza bruta)?

2. Sea F(n, m) la cantidad de particiones de n en que los sumandos forman

una sucesión decreciente de números positivos enteros menores o
iguales a m. Se define recursivamente esta cantidad de la siguiente
manera:
F(1, m) = 1, si m > 0
F(n, 1) = 1, si n > 0
F(n, n) = F(n, n – 1) + 1, si n = m
F(n, m) = F(n, m – 1) + F(n – m, m) si n > m
F(n, m) = 0 si n < m
Escribir un algoritmo de Programación Dinámica para calcular
F(n, m) para n y m enteros positivos y analizarlo contando las sumas
realizadas.

3. El problema es dar cambio de n pesos usando el mínimo número de

monedas posibles. Considerando monedas de m1, m2,…,mk
denominaciones se pide describir un algoritmo Greedy que resuelva
el problema en forma óptima, describiendo las cantidades de cada
moneda que corresponda entregar. Determinar el orden de su algoritmo.
Por ejemplo: si se tienen monedas de 10, 50, 100 y 500 pesos entonces
para cambiar n = 3820 pesos se necesitan 7 monedas de 500, 3 de 100 y
2 de 10, en total 12 monedas.

4. Se pide analizar la cantidad de comparaciones que realiza el siguiente

algoritmo para ordenar n ≥ 1 datos distintos de un arreglo A. Para ello
escriba la ecuación de recurrencia que corresponde para Ordena(A, 1, n)
y resuélvala. Suponga que Mezcla(A, B, p, q, r) ordena los datos de los
arreglos A[p],…,A[q] y B[q+1],…,B[r] usando r – p comparaciones.
 Ordena(A, i, j)
{if(j < 3)
{ if(j ≤ 1) return(A); }
else if(j ≥ 3)
{A1 = Ordena(A, i, j/3);
A2 = Ordena(A, j/3 + 1, 2j/3);
A3 = Ordena(A, 2j/3 + 1, j);
A4 = Mezcla(A1, A2, i, i/3, 2i/3);
A5 = Mezcla(A4, A3, i, 2j/3, j);
return(A5);
}
}}

5. Para un conjunto A de n > 0 datos y un valor k, 1 ≤ k ≤ n, se quiere

determinar su k-ésimo menor dato. Para ello se propone usar un árbol
de búsqueda binaria T en que al insertar un dato se agrega además en
cada nodo la cantidad de datos insertados en su subárbol izquierdo
(llamado ni ≥ 0). El algoritmo siguiente, BUSCAR(T, k) retorna el
k-ésimo dato buscado en el árbol T:

BUSCAR(T, k)
{if(T = NULL) return(NULL); /* no hay datos en T */
if(T  ni = k–1) /* apunta al valor ni del nodo hijo */
return(T); /* la raíz es el k-ésimo */
else if(T  ni ≥ k)
return(BUSCAR(T  izq, k)); /* busca dato k en subárbol izq */
else
return(BUSCAR(T  der, k – 1 – T ni)); /* busca en der */
}
a) Analizar el algoritmo BUSCAR(T, k) para determinar la cantidad de
comparaciones en el peor caso para hallar el dato k (excluyendo la
de T = NULL). Escriba la ecuación de recurrencia y resuelva.

b) Aplicar el algoritmo a los datos: A = {5, 3, 8, 4, 2, 6, 7} y grafique el

árbol resultante.

Observaciones:
1. Los ejercicios se deben resolver en forma individual. La copia de
ejercicios entre alumnos se calificará con nota 1,0.
2. Las respuestas se pueden escribir en Word, o a mano (legible) y
escaneada, para enviarlas al correo del profesor: hsoza@ucn.cl El
archivo debe traer el nombre y apellido del alumno.
3. La entrega de estos ejercicios resueltos queda para el lunes 23 de
diciembre (durante todo el día).