mike_

www.wuolah.com/student/mike_

1049

Febrero-2014-Solucion.pdf
Enunciados y soluciones de examenes AMC

3º Algorítmica y Modelos de Computación

Grado en Ingeniería Informática

Escuela Técnica Superior de Ingeniería

Universidad de Huelva

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su
totalidad.
 a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Algorítmica y Modelos de Computación

Solución Febrero 2014

Solución Febrero 2014

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Algorítmica y Modelos de Computación Solución Febrero 2014

Ejercicio 1 (2 pts)

Pues viendo el pseudocódigo, obtenemos primero la función complejidad de MergeSort:

Sólo se realizan llamadas recursivas si se cumple la condición del if, por tanto, el caso en que no se
cumpla será el caso base, que sería cuando p y r sean iguales por ejemplo, ósea, n = 1.

En caso contrario, tenemos dos llamadas recursivas cuyos índices están separados por la mitad, seguidas
de la llamada a Merge, que sabemos que es O(n), entonces:

1 𝑠𝑖 𝑛 = 1
T(n) = { 𝑛
2𝑇 (2 ) + 𝑘𝑛 + 8 𝑠𝑖 𝑛 > 1

Como no sabemos la función que dé el tiempo exacto para Merge en función de n, lo ponemos como
k·n. Además, dado que 8 ∈ O(1) y O(1) ∈ O(n), debe existir una k’ tal que k’n sea siempre igual o mayor
que k·n + 8:

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
1 𝑠𝑖 𝑛 = 1
T(n) = { 𝑛
2𝑇 ( ) + 𝑘′𝑛 𝑠𝑖 𝑛 > 1
2

a) Por ecuación característica:

T(n) = 2T(n/2) + k’n → No lineal → Cambio de base: n = 2m
T(2m) = 2(2m/2) + k’·2m → T(2m) – 2T(2m-1) = k’·2m → k’·2m es distinto de 0, entonces es No Homogénea
Para pasarlo a la izquierda:
k’·2m → bm·p(m)d (una base b elevada a m por un polinomio de m de grado d)→ b = 2, d = 0 →
(x – b)d + 1 → (x – 2)1
T(2m) – 2T(2m-1) → (x – 2)
(x – 2)(x – 2) = 0 → r = 2, raíz doble
T(2m) = c0·2m·m0 + c1·2m·m1 → T(2m) = c0·2m + c1·2m·m
Deshacer el cambio de base: n = 2m → m = log(n)
T(n) = c0·n + c1·n·log(n) ∈ O(n·log(n))
b) Por el Teorema maestro:
Sabiendo la estructura para el Teorema maestro: T(n) = aT(n/b) + O(n k·logp(n))
a = 2, b = 2, k = 1, p = 0

Mirando qué caso se cumple: T(n) ∈ O(n·log(n))

c) MergeSort_bad:
1 𝑠𝑖 𝑛 = 1
T(n) = {
𝑇(𝑛 − 1) + 𝑘′𝑛 𝑠𝑖 𝑛 > 1
El caso de T(1), la llamada con tamaño 1, queda cubierto por k’·n.
T(n) = T(n – 1) + k’·n → Es lineal → T(n) – T(n – 1) = k’·n ≠ 0 → No homogénea
k’·n → bn · p(n)d → b = 1, d = 1 → (x – 1)1+1
T(n) – T(n – 1) → (x – 1)
(x – 1) (x – 1)2 = 0 → r = 1 triple
T(n) = c0·1n·n0 + c1·1n·n1 + c2·1n·n2 → T(n) = c0 + c1·n + c2·n2 ∈ O(n2)
Comparamos los dos algoritmos:
𝑛𝑙𝑜𝑔(𝑛) 𝑙𝑜𝑔(𝑛) 1
lim ( ) = lim ( ) = lim (1·log(𝑛)·ln(2)) = 0
𝑛→∞ 𝑛2 𝑛→∞ 𝑛 𝑛→∞
El segundo algoritmo crece más rápido → O(n·log(n)) ∈ O(n2)

Dedícanos un tweet y menciónanos. Somos de RT fácil: @Wuolah

a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Algorítmica y Modelos de Computación Solución Febrero 2014

Ejercicio 2 (3 pts)

Es como un problema de la mochila, pero en lugar de una mochila, hay 3, y en lugar de tener como
objetivo obtener un beneficio mayor, aquí se desea que la tercera mochila (la tercera conovocatoria)
quede lo menos cargada posible.

a) Los dos criterios posibles son:

- Primero las que menos tiempo requieren
- Primero las que más tiempo requieren
Dado que se desea minimizar el tiempo empleado en la convocatoria de diciembre, se aplicará el
primer criterio, haciendo que se realicen cuanto antes el mayor número posible de actividades.

El algoritmo diseñado, teniendo en cuenta el criterio a aplicar, es:

funcion convocatorias(M, N: enteros, t : vector de enteros)

S = matriz de ceros de dimensión 3xN, cada fila es una convocatoria

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
tiempoEmpleado = (0, 0, 0)
convocatoria = 1
i = 1
t_ord = ordenar(t) // Almacena en t_ord los índices de los elementos de t
// tal y como estaría si estuviera ordenado de menor a
// mayor
// Ej: t = (4,6,1) -> t_ord = (3,1,2)
C = t_ord(i)
mientras convocatoria ≤ 3 Y i ≤ N
si tiempoEmpleado(convocatoria) + t(c) ≤ M
tiempoEmpleado(convocatoria) += t(c)
S(convocatoria)(c) = 1
// Siguiente elemento sin cambiar de convocatoria
i = i + 1
si i ≤ N
c = t_ord(i)
fsi
sino
// Siguiente convocatoria sin cambiar de elemento
convocatoria = convocatoria + 1
fsi
fmientras
si i > N
devuelve S
sino
devuelve fallo
fsi
ffuncion

Para el caso: n = 5, M = 16, t = (7, 5, 3, 5, 6):

S = ( (0,0,0,0,0), (0,0,0,0,0), (0,0,0,0,0) )
tiempoEmpleado = (0,0,0)
t_ord = (3, 2, 4, 5, 1)
c = 3, t(c) = 3, tiempoEmpleado(1) + 3 == 3 ≤ M → SI → S = ( (0,0,1,0,0), (0,0,0,0,0), (0,0,0,0,0) )
c = 2, t(c) = 5, tiempoEmpleado(1) + 5 == 8 ≤ M → SI → S = ( (0,1,1,0,0), (0,0,0,0,0), (0,0,0,0,0) )
c = 4, t(c) = 5, tiempoEmpleado(1) + 5 == 13 ≤ M → SI → S = ( (0,1,1,1,0), (0,0,0,0,0), (0,0,0,0,0) )
c = 5, t(c) = 6, tiempoEmpleado(1) + 6 == 19 ≤ M → NO → convocatoria = 2
c = 5, t(c) = 6, tiempoEmpleado(2) + 6 == 6 ≤ M → SI → S = ( (0,1,1,1,0), (0,0,0,0,1), (0,0,0,0,0) )
c = 1, t(c) = 7, tiempoEmpleado(2) + 7 == 13 ≤ M → SI → S = ( (0,1,1,1,0), (1,0,0,0,1), (0,0,0,0,0) )
No es la solución óptima ya que existe una solución que hace que septiembre tenga menos carga:
S = ( (1,0,1,0,1), (0,1,0,1,0), (0,0,0,0,0) ) , septiembre tendría una carga de 10 en vez de 13.

Dedícanos un tweet y menciónanos. Somos de RT fácil: @Wuolah

a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Algorítmica y Modelos de Computación Solución Febrero 2014

b) La idea del algoritmo basado en programación dinámica será tomando como base la decisión “añadir
la tarea a la convocatoria actual o a una anterior”. El objetivo será minimizar el número de horas
dedicadas en la última convocatoria.
Ecuación recurrente:

0 𝑠𝑖 𝑁 = 0
Convocatorias(M,N,C) = {+∞ 𝑠𝑖 𝐶 = 0
min(𝐶𝑜𝑛𝑣(𝑀, 𝑁 − 1, 𝐶) + 𝑡𝑁 , 𝐶𝑜𝑛𝑣(𝑀, 𝑁, 𝐶 − 1)) 𝑠𝑖 𝑛 > 1

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
siendo M el tiempo máximo por convocatoria, N la tarea actual y C la convocatoria actual.

Casos base:
- Si no hay actividades, el número de horas dedicadas en la última convocatoria será 0.
- Si no hay convocatorias, sería una situación de error, expresada mediante +∞.

Tabla:

Sería una tabla de tantas filas como tareas haya, más una fila extra como caso de no haber tareas. Y
tantas columnas como convocatorias haya, más una extra para el caso de no haber convocatorias:

0 1 2 3
0 +∞ 0 0 0
1 +∞
2 +∞
3 +∞
4 +∞
5 +∞

Algoritmo que rellena la tabla:

Para la decisión de asignar la tarea a una convocatoria o a la anterior, se tomará aquella que minimice
el tiempo empleado en la última convocatoria que haya.

Convocatorias(T(1...N))
Actual = 0; Anterior = 0
para i = 0 hasta N Tabla[i][0] = +∞ fpara
para j = 1 hasta C Tabla[0][j] = 0 fpara
para i = 1 hasta N // Tarea
para j = 1 hasta C // Convocatoria
Actual = Tabla[i-1][j] + T[i] // Misma convocatoria, sumo el tiempo Ti
si Actual > M
Actual = +∞ // No cabe en la actual
fsi
Anterior = Tabla[i][j-1] + T[i] // Anterior convocatoria, suma Ti
si Anterior ≤ M
Anterior = 0 // Cabe en la anterior, la última conv está vacía
fsi
Tabla[i][j] = min(Actual, Anterior)
fpara
fpara
fConvocatorias

Como no se pide ningún algoritmo que recomponga la solución, no se hace.

c) Para el backtracking, hay que tener en cuenta los posibles valores que pueden darse en una decisión.
En este caso, para cada tarea, ésta podría ir, en principio, en cada una de las 3 convocatorias
existentes.
a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Algorítmica y Modelos de Computación Solución Febrero 2014

El árbol que se expandiría durante la ejecución del algoritmo se compondrá de nodos que tengan 3
hijos. Habrá tantos niveles como tareas. Podría darse poda también, dado que si una convocatoria
está llena en el momento de tomar la decisión de asignar una tarea, esta convocatoria quedaría
descartada automáticamente.
Los nodos se definirán internamente con una lista de asignaciones, de tantos elementos como
convocatorias haya y los valores que tomarán serán las convocatorias a las que serán asignadas.
Dado que no se pide que se obtenga la solución óptima, este algoritmo finalizará cuando haya
obtenido una solución posible.
Teniendo en cuenta que la solución será dada a través de dicha lista:
S = (0,...,0N)
M = capacidad máxima de tiempo por convocatoria
N = número de tareas
C = número de convocatorias
Convocatorias(0,...,0C) = tiempo empleado en cada convocatoria
Tiempos(1...N) = tiempos de cada tarea, los dados para el problema

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
Generar(nivel, S)
// Siguiente convocatoria posible
S(nivel) = S(nivel) + 1
fGenerar

Solucion(nivel, S)
// Es el último nivel y tiene una convocatoria asignada
devuelve nivel == N Y S(nivel) ≠ 0
fSolucion

Criterio(nivel, S)
devuelve nivel ≤ N Y Convocatorias(S(nivel)) + Tiempos(nivel) ≤ M
fCriterio

MasHermanos(nivel, S)
// Comprueba si aún quedan convocatorias
devuelve S(nivel) ≤ C
fMasHermanos

Retroceder(nivel, S)
// Quitar la convocatoria puesta a esta tarea, y pasar a una tarea anterior
S(nivel) = 0
nivel = nivel - 1
fRetroceder

Backtracking()
nivel = 1
// S y Convocatorias inicializadas fuera
fin = false
repetir
Generar(nivel, S)
si Solucion(nivel, S)
fin = true
sino
si Criterio(nivel, S)
Convocatorias(S(nivel)) += Tiempos(nivel)
nivel = nivel + 1
sino
mientras NO MasHermanos(nivel, S)
Retroceder(nivel, S)
hasta fin
fBacktracking

Dedícanos un tweet y menciónanos. Somos de RT fácil: @Wuolah

a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Algorítmica y Modelos de Computación Solución Febrero 2014

Ejercicio 3 (1.5 pts)

Dado el autómata siguiente:

f a b
→0 1 3
1 0 3
2 1 4
*3 5 5
4 3 3
*5 5 3
a) AFD mínimo
Agrupando inicialmente en finales y no finales:
Q/E0 = (c0 = {0, 1, 2, 4}, c1 = {3, 5})
f’(0, a) → 1 ∈ c0, f’(0, b) → 3 ∈ c1

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
f’(1, a) → 0 ∈ c0, f’(1, b) → 3 ∈ c1
f’(2, a) → 1 ∈ c0, f’(2, b) → 4 ∈ c0 → Nuevo conjunto c2 = {2}
f’(4, a) → 3 ∈ c1, f’(4, b) → 3 ∈ c1 → Nuevo conjunto c3 = {4}

f’(3, a) → 5 ∈ c1, f’(3, b) → 5 ∈ c1

f’(5, a) → 5 ∈ c1, f’(5, b) → 3 ∈ c1
Como los estados 3 y 5 van a su propio conjunto, ya no hay que hacer nada más en ellos.
Q/E1 = (c0 = {0, 1}, c1 = {3, 5}, c2 = {2}, c3 = {4}
f’(0, a) → 1 ∈ c0, f’(0, b) → 3 ∈ c1
f’(1, a) → 0 ∈ c0, f’(1, b) → 3 ∈ c1

f’(2, a) → 1 ∈ c0, f’(2, b) → 4 ∈ c3

f’(4, a) → 3 ∈ c1, f’(4, b) → 3 ∈ c1

No se puede reducir ningún conjunto más, este es el AFD mínimo:

f a b
→ c0 c0 c1
* c1
c1 c1
c2
c0 c3
c3
c1 c1
b) Expresión regular reconocida por el AFD mínimo
𝑥0 = 𝑎𝑥0 + 𝑏𝑥1 + 𝑏
𝑥1 = 𝑎𝑥1 + 𝑏𝑥1 + 𝑎 + 𝑏
Ecuaciones características del AFD: {
𝑥2 = 𝑎𝑥0 + 𝑏𝑥3
𝑥3 = 𝑎𝑥1 + 𝑏𝑥1 + 𝑎 + 𝑏
Para resolver x0, hace falta conocer x1. Para conocer x1, no es necesario profundizar más:
x1 = ax1 + bx1 + a + b → Regla de Inferencia → x1 = (a+b)*(a+b) → x1 = (a+b)*a + (a+b)*b
Sustituir en la primera ecuación:
x0 = ax0 + b[(a+b)*a + (a+b)*b] + b → ax0 + b(a+b)*a + b(a+b)*b + b → Regla de inferencia →
x0 = a*( b(a+b)*a + b(a+b)*b + b) → x0 = a*b(a+b)*a + a*b(a+b)*b + a*b
c) Gramática de tipo 3
G = ({c0, c1, c2, c3}, {a, b}, c0, P), siendo P:
- c0 ::= ac0 | bc1
- c1 ::= ac1 | bc1
- c2 ::= ac0 | bc3
- c3 ::= ac1 | bc1

Dedícanos un tweet y menciónanos. Somos de RT fácil: @Wuolah

a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Algorítmica y Modelos de Computación Solución Febrero 2014

Ejercicio 4 (1.5 pts)

a) El primer autómata no puede ser ya que no existe definida ninguna transición al estado final F,
ninguna cadena sería aceptada.
b) Este autómata podría reconocer el lenguaje. Empezando en A, podría ir a B sólo si recibe un 0, o a F
si no recibe nada (sería el caso en que n = 0). Y estando en B, sólo puede cambiar de estado si
recibe un 1, pasando a C o a F. Si es el último 1, se aceptaría la cadena, y si hubiera un 0 a
continuación, volvería al estado B, donde se esperará el 1 que siga a ese 0.
c) Este autómata no tiene bien definidas las transiciones. De un símbolo No Terminal con otro No
Terminal no se puede hacer una transición a un símbolo Terminal.
d) Este autómata no puede reconocer el lenguaje porque no hay ninguna transición que parta del
símbolo inicial.

El único autómata que reconoce el lenguaje es el autómata B.

AFD equivalente al autómata B

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
Q0 = λ-Clausura(A) = {A, F}

f’(Q0, 0) = {B} → λ-Clausura({B}) = {B} – Nuevo estado Q1

f’(Q0, 1) = {}

f’(Q1, 0) = {}

f’(Q1, 1) = {C, F} → λ-Clausura({C, F}) = {C, F} – Nuevo estado Q2

f’(Q2, 0) = {B} → λ-Clausura({B}) = {B} = Q1

f’(Q2, 1) = {}

f 0 1
→ * Q0 Q1
Q1 Q2
* Q2 Q1
AFD mínimo

Agrupamos inicialmente entre no finales y finales:

Q/E0 = (c0 = {Q1}, c1 = {Q0, Q2})

f’(Q1, 0) = vacío, f’(Q1, 1) = Q2 ∈ c1

f’(Q0, 0) = Q1 ∈ c0, f’(Q0, 1) = vacío

f’(Q2, 0) = Q1 ∈ c0, f’(Q2, 1) = vacío

No se pueden reducir los conjuntos, este sería el AFD mínimo:

f 0 1
→ * c1 c0
c0 c1

Dedícanos un tweet y menciónanos. Somos de RT fácil: @Wuolah

 a64b0469ff35958ef4ab887a898bd50bdfbbe91a-1746578

Ejercicio 5 (2 pts)
Algorítmica y Modelos de Computación
Solución Febrero 2014

Reservados todos los derechos. No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.