Algoritmos y Estructuras de Datos Ing. Informtica Segunda Parte Examen. 10 de Junio de 2.

005
1. Dada la funcin: operacin Pares (a: array[1,..,n] de tipo; izq, der: entero):entero m : 1,..,n

Hoja 1/1

m = (der+izq)/2 si m izq entonces si par(a[m]) entonces devolver ( Pares(a,izq,m)+1 ) finsi devolver 1 sino devolver 0 finsi Obtener (razonando y justificando las respuestas): a) Las entradas en los casos ms favorable y ms desfavorable. b) Unos buenos valores para y O del tiempo de ejecucin. Indicando qu ocurre con . c) o y del tiempo promedio. d) Frmulas de la ocupacin de memoria para los mismos casos para los que se ha estudiado el tiempo. Solucin: a) El caso ms favorable es cuando no hay que hacer ninguna llamada recursiva, lo que ocurre cuando a[(der+izq)/2] es impar. El caso ms desfavorable se da cuando se hacen ms llamadas recursivas. Esto ocurre cuando a[(der+izq)/2] es par, a[(izq+(der+izq)/2)/2]=a[(3izq+der)/4] es impar, ..., y en general cuando

k 1 izq + der a 2 k 2
para los sucesivos valores de k. Si izq=1 y der=n, y n es potencia de 2, esto ocurre cuando son pares los valores en las posiciones 2, 4, 8, ... n/2 del array. b) Como en el caso ms favorable no se hacen llamadas recursivas, se ejecuta un nmero constante de instrucciones, y t(n)(1). Para el caso ms desfavorable consideramos izq=1 y der=n. Cuando se hacen llamadas recursivas la funcin es t(n)=t(n/2)+a, y en el caso ms desfavorable se llega a izq=der=1. Resolviendo la ecuacin queda t(n)=c1log n+ c2, y t(n)O(log n). Como las dos notaciones son distintas no obtenemos el orden exacto. c) Lo haremos contando las instrucciones que se ejecutan. Tenemos: t(n)=3, si n=1 t(n)=3+1/2*1+1/2*t(n/2) pues hay la misma probabilidad de que el valor sea par que de que sea impar. Si es impar se ejecuta una instruccin y si es par se llama a la misma funcin con tamao la mitad (podramos aadir 1 si contamos la suma al valor que devuelve la funcin como una instruccin distinta). La ecuacin caracterstica es (x-1/2)*(x-1), con lo que t(n)= c1*(1/n)+ c2, y queda t(n)(1). Para calcular la o pequea slo hace falta obtener la constante. Se imponen los casos base 1 y 2 y queda: t(1)=3= c1+ c2 t(2)=5=c1/2+ c2 con lo que t(n)o(7). d) Para estudiar la ocupacin de memoria tenemos que decidir cmo consideramos que se pasan los parmetros. En cada llamada tenemos memoria para la variable m y los parmetros izq y der. Esta memoria es constante. Para el array podemos considerar que se pasa por referencia, con lo que la memoria total en cada llamada sigue siendo constante, o que se pasa una copia del array. En caso de pasar una copia del array puede ser el array completo o slo el subarray del tamao que se considera en esa llamada. En el caso ms favorable slo se hace una llamada. Si consideramos paso por referencia el coste sera constante, y m(n)(1). Si consideramos que se pasa el array ser m(n)(n). Si se hacen llamadas recursivas, tenemos las frmulas siguientes. Si el paso es por referencia: m(n)=a, si n=1 m(n)=a+m(n/2), si n>1

Algoritmos y Estructuras de Datos Ing. Informtica Segunda Parte Examen. 10 de Junio de 2.005

Hoja 2/2

y m(n)O(log n). Y para el coste promedio m(n)=a, si n=1 m(n)=a+1/2*m(n/2), si n>1 con lo que, al igual que en el estudio del tiempo, m(n)(1). Y para la o pequea hay que imponer los dos casos base y obtener la constante. Si se hace el paso copiando todo el array, la ecuacin queda: m(n)=a, si n=1 m(n)=a+N+m(n/2), si n>1 con N el tamao inicial, m(n)O(n*log n), y en promedio m(n)=a, si n=1 m(n)=a+N+1/2*m(n/2), si n>1 lo que da m(n)(n). Si se hace el paso copiando la parte del array con la que se trabaja, la ecuacin queda: m(n)=a, si n=1 m(n)=a+n+m(n/2), si n>1 con m(n)O(n), y en promedio m(n)=a, si n=1 m(n)=a+n+1/2*m(n/2), si n>1 lo que da m(n)(n). 2. Dada la funcin: operacin Comparar (a: array[1,..,n][1,..,n] fno1,cno1,fse1,cse1,fno2,cno2,fse2,cse2: 1,..,n; tol : entero): booleano cont , i , j : entero de tipo;

cont = 1 para i=fno1, fno1+1, ... , fse1 hacer para j=cno1, cno1+1, ..., cse1 hacer si a[i][j] a[i+fno2-fno1][j+cno2-cno1] entonces cont++ si cont > tol entonces devolver FALSE finsi finsi finpar finpara devolver TRUE Si se hace la llamada con Comparar (a,1,1,n/2,n/2,n/2+1,n/2+1,n,n,n/4), obtener (razonando y justificando las respuestas): a) Unos buenos valores para y O del tiempo de ejecucin. Indicando qu ocurre con . b) o y del promedio de comparaciones, si tol=1 y la probabilidad de que dos valores sean iguales es p. Solucin: a) En el caso ms favorable los n/4+1 primeros elementos son distintos, con lo que t(n)(n). Si todos los elementos son iguales se entra (n/2)2 veces en el bucle, y t(n)O(n2). Por tanto, no conocemos . b) Si llamamos m al nmero de datos que hay en la zona que se analiza ((n/2)2 ) y consideramos ese el tamao del problema, podemos poner el tiempo en funcin de ese tamao y del valor inicial de tol: t(m,1)=1, si m=1 t(m,1)=1+p*t(m-1,1)+(1-p)*t(m-1,0) Si tol=0, el nmero promedio de comparaciones es 1+(1-p)+(1-p)2+...+(1-p)m<1/p, con lo que la recurrencia queda t(m,1)=1+1/p+p*t(m-1,1), y resolvindola queda t(m)=c1 *pn+c2(1). Para obtener o se imponen los casos base m=1 y m=2, y queda t(m)((p2-2p-1)/( p2-p)). 3. Obtener las frmulas de los tiempos de ejecucin, en funcin del tamao del problema y del caso base, de los algoritmos cuyos tiempos tienen las siguientes recurrencias: 1. t(n) = 2 t(n/3) + 3 n, si n > b,

Algoritmos y Estructuras de Datos Ing. Informtica Segunda Parte Examen. 10 de Junio de 2.005

Hoja 3/3

t(n) = n2 , si n b. 2. t(n) = 3 t(n-6) + 2, si n > b, t(n) = n2 , si n b. (se piden las frmulas de los tiempos, no las notaciones asintticas) Solucin: a) Hacemos el cambio n= 3k. Queda t(k)-2t(k-1)=3*3k, y la ecuacin caracterstica es (x-2)*(x-3)=0. Queda t(n)= c1*nlog3 2+ c2*n. Sustituyendo los casos base b y 3b, obtenemos c2=9 y c1=b2-log3 2- 9*b1-log3 2. b) Se puede hacer con el cambio n= 6k. O expendiendo la recurrencia: t(n)=3*(3*t(n-2*6)+2)+2=32*(3*t(n-3*6)+2)+2*(1+3)== 3k*t(n-k*6)+2*(1+3++3k-1) = 3k*t(nk*6)+3k-1 En el caso base n-k*6=b, con lo que t(n)= 3(n-b)/6*(b2+1)-1. Se tienen dos listas de enteros largos, cada una con n enteros largos, y cada entero largo est formado por n nodos (el tamao del item en cada nodo es irrelevante). Se quiere obtener ordenados los enteros largos resultado de multiplicar el menor entero largo de la primera lista por cada uno de los n/2 enteros largos mayores de la segunda lista. Programar cmo se resuelve el problema utilizando funciones de las vistas en clase (no hay que programar las funciones). Con la solucin que se aporte se debe intentar obtener el menor tiempo promedio de ejecucin posible. Se obtendr una frmula, y se explicar, del tiempo promedio que se obtiene. Solucin: El esquema podra ser: operacin alg (LEL1,LEL2: listas de enteros largos; n : entero): lista de enteros largos menor : entero largo posicion : puntero a entero largo LEL3 : lista de enteros largos menor = obtenermenor(LEL1) //no hace falta ordenar la lista primera posicin=seleccin(LEL2,n/2) //ni la segunda crear(LEL3) mientras posicion NIL hacer insertar(LEL3,multrapida(menor,posicin.entero) posicin=posicin.siguiente finmientras ordenar(LEL3) devolver LEL3 Conocemos los costes de las operaciones de obtener el menor y seleccionar el de la posicin n/2. L seleccin nos deja los n/2 mayores a la derecha, aunque sin ordenar, por lo que en el bucle mientras se recorre desde la posicin donde se dej el pivote hasta el final de la lista, multiplicando cada entero largo por el menor de la primera lista. El resultado se incluye en otra lista de enteros largos que se ordena (por quicksort por ejemplo ya que queremos minimizar el coste promedio). Conocemos los costes de las operaciones de obtener el menor, de ordenar y de seleccionar el de la posicin n/2. Pero los conocemos considerando el coste de las comparaciones de elementos constante. Como en nuestro caso los elementos son enteros largos slo tenemos que obtener el tiempo promedio de comparacin de dos enteros largos. El nmero promedio de comparaciones de items en la comparacin de dos enteros largos es 1+p+p2+...+pn<1/(1-p), con p la probabilidad de que dos items sean iguales. Como el coste promedio de la comparacin de enteros largos tambin es constante, los mismos rdenes promedio para las operaciones sobre enteros nos sirven sobre enteros largos. Obtener el menor tiene coste lineal. Seleccionar un elemento tiene coste lineal en el caso ms favorable y cuadrtico en el ms desfavorable. Ordenar tiene coste n*log n. Por tanto, el coste del algoritmo viene dado por las n/2 multiplicaciones de enteros largos de tamao n, lo que nos da coste n2.59. 5. Un alumno tiene que aprobar un conjunto de asignaturas, con sus exmenes, prcticas, entrevistas y dems. En total tiene n tareas. Para cada una de ellas estima le llevar cierto tiempo, ti. Como est un poco apurado de tiempo, se las piensa repartir entre las convocatorias de junio, septiembre y diciembre. En cada convocatoria puede sacar M unidades de tiempo. Se supone que todas las tareas se deben hacer antes o despus, que las tareas no se pueden fraccionar (cada tarea va a una sola convocatoria), y que la suma de tiempos asignados a cada convocatoria no puede superar M. 4.

Algoritmos y Estructuras de Datos Ing. Informtica Segunda Parte Examen. 10 de Junio de 2.005

Hoja 4/4

El objetivo es conseguir un reparto dejando el menor nmero posible de tareas para el final. Es decir, minimizar el tiempo dedicado en la convocatoria de diciembre. En caso de empate en diciembre, minimizar el tiempo en la de septiembre. Solucin: Para resolver este problema podramos basarnos en el esquema general, ligeramente modificado: voraz (C: CjtoCandidatos; var S: CjtoSolucin) S:= conv[1..3]:=0 solucion:=TRUE indice:=1 mientras (indicen+1) Y solucin hacer x:= seleccionar si 1factible(x) 3 entonces insertar(S, x) sino solucion:=FALSE finsi indice++ finmientras si NO solucin entonces devolver No se puede encontrar solucin finsi


operacin seleccionar devolver t[i] operacin insertar (S,x,factible(x)) p:=factible(x) s[i]:= p conv[p]:= conv[p]+t[i]

operacin factible(x) si conv[1]+xM entonces devolver 1 finsi si conv[2]+xM entonces devolver 2 finsi si conv[3]+xM entonces devolver 3 finsi devolver 0

La solucin se representar mediante una tupla s = (s1, s2, ..., sn), siendo cada si = 1, 2 3, segn que la tarea i se asigne a la convocatoria de junio, septiembre o diciembre, respectivamente. Inicialmente si = 0 para todo i. Adems debemos llevar cuenta del tiempo que vamos empleando en cada convocatoria segn decidimos sobre cada candidato que vamos escogiendo; para ello usaremos un array conv: array [1..3] de enteros inicializado a 0. Cada uno de esos tres valores no podr superar el valor M. Los dos criterios de seleccin pueden ser seleccionar las tareas de mayor a menor tiempo, y otro puede ser el contrario. En ambos casos se requiere ordenar previamente el array de tareas t. Por lo tanto, la funcin de seleccin, una vez ordenado oportunamente el array t, seleccionara las tareas en orden, incrementando en cada paso el ndice del array. Como el propsito es emplear para la convocatoria de diciembre el menor tiempo posible, y en caso de empate en diciembre minimizar el tiempo en la de septiembre, iremos adjudicando a cada tarea la primera convocatoria para la cual se disponga de tiempo suficiente, es decir, primero junio; si no es posible, septiembre, y, si no, diciembre. La funcin factible lo que hace es comprobar si la tarea i se puede ejecutar, e indica la primera convocatoria c en la que se puede realizar, comprobando los valores del array conv. La operacin insertar le adjudicara a la tarea i la convocatoria c correspondiente actualizando el valor si e incrementara el valor correspondiente a conv[c] en ti. Es posible que no encontremos la solucin ptima. Incluso es posible que no encontremos solucin. Para controlar esto ltimo habra que sustituir la operacin solucin del esquema por una variable booleana inicializada oportunamente, que permitira seguir ejecutando el bucle principal siempre que las tareas se pudieran ir ejecutando. En caso de que la funcin factible detectara que una tarea no se puede realizar, cambiara el valor de la variable solucin para salir del bucle. Aplicamos el algoritmo anterior al ejemplo para los dos criterios de seleccin propuestos. a) n = 5, M = 10, t = {5, 4, 3, 3, 1}. s = [1, 1, 2, 2, 1]; conv = [10, 6, 0]

Algoritmos y Estructuras de Datos Ing. Informtica Segunda Parte Examen. 10 de Junio de 2.005
b) n = 5, M = 10, t = {1, 3, 3, 4, 5}. s = [1, 1, 1, 2, 2]; conv = [7, 9, 0]

Hoja 5/5

6. Resolver el problema anterior mediante programacin dinmica, definiendo la ecuacin recurrente, las tablas usadas, el algoritmo para rellenarlas y la forma de recomponer la solucin final. Solucin: Resolver el problema mediante algoritmos voraces, aunque no se garantice siempre la solucin ptima. Proponer y contrastar por lo menos dos criterios de seleccin diferentes. Aplicar el algoritmo al siguiente ejemplo: n = 5, M = 10, t = {5, 3, 1, 3, 4}. Solucin: Podemos interpretar el problema como una serie de toma de decisiones del tipo "dada una tarea i, ejecutarla en junio, en septiembre o en diciembre". Si la ejecutamos en junio, nos quedan i-1 tareas por decidir, y ti unidades de tiempo menos en junio. Lo mismo para septiembre y diciembre. Por lo tanto, podemos plantear la ecuacin: Tareas (i, j, s, d), consistente en resolver el problema con las i primeras tareas y con j, s y d unidades de tiempo disponibles en junio, septiembre y diciembre, respectivamente. La nica "pequea pega" es la funcin objetivo. Tenemos que minimizar el tiempo asignado a diciembre, pero en caso de empate debemos considerar el de septiembre. Si (j, s, d) son los tiempos asignados en cada convocatoria, la funcin objetivo podra ser: Valor(j, s, d) = d M + s. Una vez con esto, es sencillo deducir la ecuacin recurrente: Tareas(i, j, s, d) = min {Tareas(i-1, j-ti, s, d), ti + Tareas(i-1, j, s-ti, d), ti M + Tareas(i-1, j, s, d-ti)} Los casos base seran los siguientes: Tareas(0, j, s, d) = 0 ; Tareas(i<0, j, s, d) = +\

La construccin del algoritmo a partir de esta ecuacin es inmediata. La tabla ser de la forma, T: array [0..n, 0..M, 0..M, 0..M] de entero, siendo T[i, j, s, d] = Tareas(i, j, s, d). El valor final de la funcin objetivo se encuentra en T[n, M, M, M]. En definitiva, el algoritmo sera como el siguiente:
para i:= 0, ..., n hacer para j:= 0, ..., M hacer para s:= 0, ..., M hacer para d:= 0, ..., M hacer si i==0 entonces T[i, j, s, d]:= 0 sino T[i, j, s, d]:= min (T[i-1, j-t[i], s, d], t[i]+T[i-1, j, s-t[i], d], t[i]*M+T[i-1, j, s, d-t[i]]) escribir ("Tiempo en diciembre:", T[n, M, M, M] div M) escribir ("Tiempo en septiembre:", T[n, M, M, M] mod M)

En la operacin min anterior se supone que si un ndice se sale del array tenemos un caso base +. 7. Resolver el problema del ejercicio 5 de forma ptima mediante un algoritmo de backtracking. Indicar el esquema que se usa de los vistos en clase y explicar cmo es la representacin de la solucin, la forma del rbol, y programar las funciones genricas del esquema. Solucin Vamos a resolver el problema con backtracking. La solucin se representar mediante una tupla s = (s1, s2, ..., sn), siendo cada si = 1, 2 3, segn la tarea i se asigne a la convocatoria de junio, septiembre o diciembre, respectivamente. Obviamente, esto da lugar a un rbol de soluciones 3-ario. La inicializacin ser s = (0, 0, ..., 0). Para controlar el tiempo asignado a cada convocatoria, usaremos un array conv: array [0..3] de entero. La funcin objetivo ser la misma del ejercicio anterior. Las funciones bsicas del esquema seran las siguientes:
operacin Inicializar voa:= + nivel:= 1 s:= (0, 0, ..., 0) conv:= (0, 0, 0, 0) operacin Generar (nivel, s) conv[s[nivel]]:= conv[s[nivel]] - t[nivel] s[nivel]:= s[nivel] + 1 conv[s[nivel]]:= conv[s[nivel]] + t[nivel] operacin Criterio (nivel, s) devolver (nivel<n) AND (conv[s[nivel]]<=M) operacin MasHermanos (nivel, s) devolver s[nivel] < 3 operacin Retroceder (nivel, s) conv[s[nivel]]:= conv[s[nivel]] t[nivel] s[nivel]:= 0 nivel:= nivel - 1

Algoritmos y Estructuras de Datos Ing. Informtica Segunda Parte Examen. 10 de Junio de 2.005
operacin Solucin (nivel, s) devolver (nivel==n) AND (conv[s[nivel]]<=M)

Hoja 6/6

operacin Valor (s) devolver conv[3]*M + conv[2]

Con estas funciones, y suponiendo el esquema de maximizacin visto en clase, el algoritmo est ya completamente definido. Podramos mejorar un poco la eficiencia, haciendo una poda ms exhaustiva, por ejemplo, basada en la funcin objetivo: si el valor actual es mayor que el ptimo actual, podar el nodo. Esto se puede conseguir con una simple modificacin de la funcin criterio:
operacin Criterio (nivel, s) devolver (nivel<n) AND (conv[s[nivel]]<=M) AND (Valor(s) < voa)

8. Cierto problema de maximizacin se resuelve utilizando ramificacin y poda, aplicando una estrategia LC-LIFO. La solucin se representa mediante una tupla de tamao 4, s= (s1, s2, s3, s4), donde cada si puede tomar valor 0 1. Son soluciones todas las tuplas de 4 elementos en las que el nmero de unos sea menor o igual que 3. Mostrar el rbol generado en la ejecucin del algoritmo, indicando tambin la evolucin de la lista de nodos vivos, la variable de poda C, as como el orden de recorrido de los nodos, los nodos podados y la solucin final. Suponer que para cada tupla se calculan las cotas indicadas abajo. Cambiara el resultado, en este ejemplo, si se utilizara la estrategia LC-FIFO? Justifica la respuesta de forma breve.
Tupla Raz 0 1 00 01 10 11 000 001 010 011 CI 2 2 3 8 4 5 6 4 8 6 3 BE 6 7 8 8 7 7 6 6 8 7 4 CS 13 10 12 8 10 10 12 7 8 8 7 Tupla 100 101 110 111 0000 0001 0010 0011 0100 0101 0110 CI 6 4 4 5 6 5 2 8 1 7 4 BE 7 8 5 5 6 5 2 8 1 7 4 CS 10 8 9 11 6 5 2 8 1 7 4 Tupla 0111 1000 1001 1010 1011 1100 1101 1110 1111 CI 3 3 10 5 7 8 9 11 9 BE 3 3 10 5 7 8 9 11 9 CS 3 3 10 5 7 8 9 11 9

Solucin: Puesto que el problema es de maximizacin, la variable de poda ser: C = max {CI(j), Valor(s)}, y podamos un nodo i cuando CS(i) ^C. La ejecucin del algoritmo se muestra abajo. Denotamos los nodos por los valores de las tuplas indicados en el enunciado. x Raz 1 10 101 100 0 11 111 C 2 3 6 6 7 10 10 10 11 soa/voa LNV Raz 0, 1 0, 10, 11 0, 11, 100, 101 0, 11, 100 0, 11 11 111 Nodos podados
0 2 0 7 10 0 Raz 2 6 13 1 3 1 8 12 1 11 6 12 1 111 5 11 1 1111 8

1011/7 1001/10 " " 1110/11

0 (al sacarlo) 110 (al meterlo)

0 100 7 10 1 1001 10

10 7 10 1 0 4 1 1011 7 110 5 9

Si hubiramos usado la estrategia LC-FIFO la solucin final sera la misma (la tupla 1110), pero el recorrido habra sido ligeramente distinto. En concreto, en el 4 paso el nodo escogido, x, habra sido el 0 (en lugar del 10).

6 0 1000 3

4 0

101 8 8

5 0

1010 5

1110 11