Programacion III

EXMENES RESUELTOS PROGRAMACIN III
Recopilacin de Exmenes de Programacin III
Esta recopilacin de exmenes incluye desde el ao 1996 hasta septiembre de 2008. Llevo unos dos aos hacindola y no hubiera sido posible sin la inestimable ayuda de Ali, por ello cre conveniente nombrarla ya que ha sido de gran ayuda en la resolucin de problemas y dudas que han hecho posible esta coleccin de exmenes.
Antonio Rivero Cuesta Alicia Snchez Ferro Palma de Mallorca, septiembre de 2008
Problemas de Programacin III

Febrero 1996-1..................Calcular T ( n) = 2n ................................... Divide y Vencers Febrero 1996-1..................Calcular recubrimiento de vrtices................ Voraz Febrero 1996-2..................Domin ......................................................... Vuelta Atrs Febrero 1996-2..................Fibonacci....................................................... Divide y Vencers Septiem 1996 ....................Cartgrafo ..................................................... Voraz Septiem 1996 ....................Calcular 2 = d(d(m(d(7)))) ............................ Vuelta Atrs Septiem 1996-R ................f x c Alumnos ................................................ Divide y Vencers Septiem 1996-R ................Seleccionar carreteras ................................... Voraz Febrero 1997-1..................n Cintas n Registros ...................................... Voraz Febrero 1997-1..................El 31.............................................................. Vuelta Atrs Febrero 1997-2..................Grabar n Canciones....................................... Voraz Septiem 1997 ....................n Motos n Clientes ........................................ Ramificacin y Poda Septiem 1997 ....................Tablero .......................................................... Vuelta Atrs Febrero 1998-1..................El Continental. .............................................. Vuelta Atrs Febrero 1998-1..................Metro Japn. ................................................. Voraz Febrero 1998-2..................Lnea Horizonte ............................................ Voraz Febrero 1998-2..................Mecano 8 piezas............................................ Ramificacin y Poda Septiem 1998 ....................n rectngulos ................................................. Voraz Septiem 1998 ....................Cadena euleriana ........................................... Voraz Febrero 1999-1..................Nave Mir. ...................................................... Ramificacin y Poda Febrero 1999-1..................Colorear 3 colores. ........................................ Vuelta Atrs Febrero 1999-2..................Mnimo Colores ............................................ Vuelta Atrs Febrero 1999-2..................Liga n equipos............................................... Divide y Vencers Febrero 2000-1..................Tablero Genrico........................................... Vuelta Atrs Febrero 2000-2..................Base Aerea .................................................... Ramificacin y Poda Septiem 2000 ....................Mayoritario ................................................... Divide y Vencers Febrero 2001-1..................Ro Guadalhorce ........................................... Vuelta Atrs, Ramificacin y Poda Febrero 2001-2..................Torneo n participantes................................... Divide y Vencers Septiem 2001 ....................Tablero .......................................................... Vuelta Atrs, Ramificacin y Poda Febrero 2002-1..................Caja de Bombones ........................................ Divide y Vencers Febrero 2002-2..................8 casillas........................................................ Vuelta Atrs Septiem 2002 ....................Laberinto ....................................................... Ramificacin y Poda Septiem 2002-R ................Buscaminas ................................................... Divide y Vencers Diciem 2002.....................Multiplicacin de polinomios ....................... Vuelta Atrs Febrero 2003-1..................Laberinto ....................................................... Vuelta Atrs Febrero 2003-2..................Fibonacci....................................................... Divide y Vencers Septiem 2003 ....................Operadora Teleco.......................................... Voraz Septiem 2003-R ................Daniel Tesoros .............................................. Ramificacin y Poda Diciem 2003.....................Taller Sleepy ................................................. Voraz Febrero 2004-1..................Matriz de 3 colores........................................ Vuelta Atrs Febrero 2004-2..................Grafo dirigido................................................ Recorrido profundidad Septiem 2004 ....................Vectores texto ............................................... Ramificacin y Poda Septiem 2004-R ................n Agentes n Tareas........................................ Ramificacin y Poda Febrero 2005-1..................Conjunto operaciones.................................... Vuelta Atrs Febrero 2005-2..................Estructura Montculo..................................... Divide y Vencers Septiem 2005 ....................Votacin Elecciones...................................... Divide y Vencers Septiem 2005-R ................Sudoku .......................................................... Vuelta Atrs Febrero 2006-1..................n montadores................................................. Ramificacin y Poda Febrero 2006-2..................Dos socios ..................................................... Vuelta Atrs Septiem 2006 ....................Salto caballo.................................................. Vuelta Atrs Septiem 2006-R ................Repartidor de Pizzas...................................... Voraz Diciem 2006......................Grabacin Cd ................................................ Ramificacin y Poda Febrero 2007-1..................Taller Sleepy ................................................. Voraz Febrero 2007-2..................Suma exacta C............................................... Vuelta Atrs Septiem 2007 ....................n objetos volumen ......................................... Ramificacin y Poda Septiem 2007-R ................Parejas estables ............................................. Vuelta Atrs Febrero 2008-1..................n Huertas ....................................................... Ramificacin y Poda Febrero 2008-2..................n Agentes n Tareas........................................ Ramificacin y Poda Septiem 2008 ....................n Agentes n Tareas........................................ Ramificacin y Poda Septiem 2008-R ................n Agentes n Tareas........................................ Ramificacin y Poda
2
Escuela Universitaria de Informatica de la UNED Ingenier a Tecnica de Sistemas e Ingenier a Tecnica de Gestion
Programacion III - Convocatoria de Febrero

Examen primera semana - Curso 1995-96
Problema 1 (5 puntos). El tiempo de ejecucion de un algoritmo viene dado por T (n) = 2n2 . Encontrar una forma e ciente de calcular T (n), suponiendo que el coste de multiplicar dos enteros es proporcional a su tama~o en representacion n binaria. Problema 2 (5 puntos). Un recubrimiento de vertices de un grafo no dirigido G = hV Ai es un conjunto de vertices tales que cada arista del grafo incide en, al menos, un vertice de V. Dise~ar un algoritmo que, dado un grafo no dirigido, n calcule un recubrimiento de vertices de tama~o m nimo para un grafo dado. n
La resolucion de cada problema debe incluir: Eleccion razonada del esquema algor tmico. Descripcion del esquema usado e identi cacion con el problema. Estructuras de datos. Algoritmo completo a partir del re namiento del esquema general. Estudio del coste. Segun el esquema elegido hay que especi car, ademas:
Voraz: demostracion de optimalidad. Divide y venceras: preorden bien fundado. Vuelta atras: descripcion del arbol de busqueda asociado.
RESPUESTAS EXAMEN Programacin III. Febrero 1996 (Primera Semana) Problema 2 (5 puntos). Un recubrimiento R de vrtices de un grafo no dirigido G = +N,A, es un conjunto de vrtices tales que cada arista del grafo incide en, al menos, un vrtice de R. Disear un algoritmo que, dado un grafo no dirigido, calcule un recubrimiento de vrtices de tamao mnimo. Solucin:
Eleccin razonada del esquema

El esquema voraz se adapta perfectamente al problema, ya que: Se trata de un problema de optimizacin: No solo hay que encontrar un recubrimiento, sino que ste ha de ser de tamao mnimo. De entre un conjunto de vrtices (candidatos) hay que seleccionar un subconjunto que ser la solucin. Solo hay que encontrar la funcin de seleccin adecuada (si existe) para resolver el problema mediante un algoritmo voraz. El esquema de divide y vencers es descartable, pues no hay forma obvia de dividir el problema en subproblemas idnticos cuyas soluciones puedan combinarse en una solucin global. El esquema de vuelta atrs es un esquema muy general y casi siempre muy costoso que no debemos usar si podemos dar un algoritmo voraz que resuelva el problema.
Esquema general e identificacin con el problema

El esquema voraz se aplica a problema de optimizacin. Consiste en ir seleccionando elementos de un conjunto de candidatos que se van incorporando a la solucin. Se caracterizan porque nunca se deshace una decisin ya tomada: los candidatos desechados no vuelven a ser considerados y los incorporados a la solucin permanecen en ella hasta al final del algoritmo. Es crucial determinar la funcin de seleccin adecuada que nos asegure que la solucin obtenida es ptima. Esta notacin algortmica puede escribirse as (libro de Brassard pgina 214):
fun voraz (C: conjunto) dev (S: conjunto) S mientras solucion (S) C hacer x elemento que maximiza objetivo (x) C C \ {x} si completable (S {x}) entonces S S {x} fsi dev S ffun
donde: C: Conjunto de vrtices del grafo. S: Recubrimiento del grafo. La forma ms intuitiva de garantizar que el recubrimiento sea mnimo es tomar vrtices de los que salgan muchas aristas, esto es, elegir vrtices con mayor grado. La funcin de seleccin debe escoger el candidato con ms vrtices de los que aun estn en el conjunto de candidatos. Para ello, cada vez que seleccionemos un vrtice tendremos que disminuir en uno el grado de cada uno de los vrtices candidatos con el. Hay que seguir los siguientes pasos: 1. Elegir el vrtice de mayor grado. 2. Recorrer su lista asociada (aquellos vrtices con los que est conectado) y restar 1 al grado de cada uno de ellos en el campo correspondiente en el vector de vrtices.
De esta forma, cuando el grado de todos los candidatos sea cero todas las aristas del grafo tocan al conjunto de seleccin y ser, por tanto, un recubrimiento. Segn este criterio, las funciones del esquema principal tendrn el siguiente significado: 1. solucin(S): Todas las aristas del grafo tocan al menos un vrtice de S. 2. objetivo(x): Grado del vrtice. 3. factible(S) (o completable): Siempre es cierto, ya que se selecciona cada vez un nico vrtice correcto. En estos problemas aadimos la demostracin de optimalidad, que ser el siguiente: Este problemas es un ejemplo de que los algoritmos voraces, en determinadas ocasiones, no proporcionan la solucin ptima, aunque si una buena aproximacin a la misma. Ocurre tambin en el ejemplo que se cita en el captulo de metodologa del texto con el algoritmo de devolucin de monedas en el sistema britnico antiguo. Aunque la intuicin nos indique, a veces una heurstica que no puede fallar, un sencillo contraejemplo nos puede hacer ver ms claramente lo dificultoso, a veces, del estudio de algoritmia. Se deja al lector que busque dicho contraejemplo para este caso.
Estructuras de datos
En el problema intervienen grafos, vrtices de un grafo y conjunto de vrtices. Para representar el grafo podemos utilizar cualquiera de las dos formas habituales, teniendo en cuenta que el uso de la matriz de adyacencia har menos eficiente el algoritmo. Aqu representar el grafo como un vector de vrtices, teniendo asociado cada vrtice una lista enlazada con los vrtices adyacentes a ste. Como los costes no juegan ningn papel en el algoritmo, lo excluiremos (por comodidad) de la estructura de datos.
grafo = vrtice [1..N] de vrtice vertice = tupla indice: entero // Posicin en el vector grado: entero // Grado del vrtice adyacentes: apuntador a nodo_adyacente nodo_adyacente = tupla adyacente: entero siguiente: apuntador a nodo_adyacente
Algoritmo completo a partir del refinamiento del esquema

Adaptamos el algoritmo general a lo dicho anteriormente:
fun recubrimiento-minimo (G: grafo) dev (S: conjunto de vrtices) S mientras solucion (S) C hacer x elemento que maximiza objetivo (x) C C \ {x} disminuir-grado (x,C) dev S ffun
Las funciones son las siguientes: Solucin: El conjunto S ser una solucin cuando el grado de todos los elementos que restan en C ser cero. Ser en pseudocdigo as:
fun solucin (C: Conjunto de vrtices) dev (b:booleano) b cierto para c en C hacer si G[i].grado 0 hacer b (G[i].grado =0) fpara dev b ffun
Tal como comentbamos anteriormente, las soluciones aportadas en estos ejercicios hay algunas que no cuadran, debido a sintaxis, debido a que no es entendible, etc etc. En este caso, es una de ellas, ya que dentro del bucle para hay un bucle si que no comprendo muy bien que hace, por lo que calculamos la variable b (que es un booleano) para averiguar si es solucin o no. Cabe destacar que la solucin no es ma personal, la aporto otro compaero en los cursos virtuales, por ello gracias ;) La funcin de seleccin devuelve el grado del vrtice en consideracin:
fun seleccionar (v: vertice) dev (g:entero) dev vertice.grado ffun
Por ltimo, la funcin disminuir-grado resta 1 al grado de todos los elementos conectados con el vrtice elegido:
fun disminuir_grado(v: vrtice, C) para w C en sucesores (v) hacer w.grado w.grado - 1 fpara ffun
Anlisis del coste

El tamao del problema viene dado por el nmero de vrtices del grafo. El nmero de veces que se ejecuta el bucle voraz es, en el peor de los casos, n. Dentro del bucle se realizan dos operaciones: encontrar el vrtice de mayor grado, que tiene un coste lineal y disminuir en uno el grado de los dems, que tiene tambin coste lineal. De modo que el coste del bucle es (n) y el coste del algoritmo es (n2)
Programacion III - Convocatoria de Febrero

Examen segunda semana - Curso 1995-96
Problema 1 (5 puntos). Las 28 chas de domino son de la forma (i j ) con = 1 : : : 6. Una cha de domino puede colocarse a continuacion de la anterior si coinciden los valores de los extremos que se tocan. Por ejemplo, a continuacion de la cha (1 2) puede colocarse la (2 4). Dise~ar un algoritmo que produzca n todas las cadenas permisibles que contengan todas las chas del domino.
i j
cfn fn
Sugerencia: Utilizad la siguiente relacion:

0 10 0 1 0 B 0 0 1 CB @ A@
a b c
Problema 2 (5 puntos). Dada la sucesion de nida como fn = afn;3 + bfn;2 + n ;1 se pide dise~ar un algoritmo que calcule en tiempo logar tmico el termino
;3 fn;2 fn;1
fn
1 0 C=B A @
;2 fn;1
fn fn
1 C A
La resolucion de cada problema debe incluir: Eleccion razonada del esquema algor tmico. Descripcion del esquema usado e identi cacion con el problema. Estructuras de datos. Algoritmo completo a partir del re namiento del esquema general. Estudio del coste. Segun el esquema elegido hay que especi car, ademas:
Programacion III - Convocatoria de Septiembre 96

Examen Original
Problema 1 (5 puntos). Un cartografo acaba de terminar el plano de su pais, que incluye informacion sobre las carreteras que unen las principales ciudades y sus longitudes. Ahora quiere a~adir una tabla en la que se recoja la distancia n entre cada par de ciudades del mapa (entendiendo por distancia la longitud del camino mas corto entre las dos). Escribir un algoritmo que le permita realizar esa tabla. Problema 2 (5 puntos). Se consideran las funciones m(x) = 3x y d(x) = x 2 (donde ` ' representa la division entera). Dise~ar un algoritmo que, dados dos n numeros a y b, encuentre una forma de llegar de a a b mediante aplicaciones sucesivas de m y d. Por ejemplo, se puede pasar de 7 a 2 mediante
2 = d(d(m(d(7))))
La resolucion de cada problema debe incluir, por este orden: 1. Eleccion razonada del esquema algor tmico. 2. Descripcion del esquema usado e identi cacion con el problema. 3. Estructuras de datos. 4. Algoritmo completo a partir del re namiento del esquema general. 5. Estudio del coste. Segun el esquema elegido hay que especi car, ademas:
Soluciones a los examenes de Septiembre 1996

Equipo docente de la asignatura
Programacion III
Problema 1
Un cartografo acaba de terminar el plano de su pais, que incluye informacion sobre las carreteras que unen las principales ciudades y sus longitudes. Ahora quiere a~adir una tabla en la que se recoja la distancia entre cada par de ciudades del n mapa (entendiendo por distancia la longitud del camino mas corto entre las dos). Escribir un algoritmo que le permita realizar esa tabla.
Eleccion razonada del esquema algor tmico.

Para hallar la distancia m nima desde un vertice de un grafo a cada uno de los demas vertices contamos con el algoritmo voraz de Dijkstra. Basta, pues, con aplicarlo para cada una de las ciudades, siendo estas los vertices, las carreteras las aristas del grafo, y sus longitudes los pesos de las aristas.
Cuidado: no hay que confundir este problema (llamado \de caminos m nimos) con el problema de dar un arbol de expansion m nimo, que resuelven algoritmos como el de Prim o Kruskal. En este caso, un arbol de expansion m nimo ser a un subconjunto de carreteras que conectara todas las ciudades y cuya longitud total fuera m nima pero esa condicion no nos asegura que la distancia entre cada par de ciudades sea la m nima posible. Pensad contrajemplos en caso de duda.
Descripcion del esquema usado e identi cacion con el problema.

Nos ahorramos la explicacion, que podeis encontrar en el Brassard/Bratley, pag. 89.
Estructuras de datos.
El conjunto de ciudades y carreteras viene representado por un grafo no orientado con pesos. Podemos implementarlo como una matriz de adyacencia, como una lista de listas de adyacencia, etc. Ademas necesitaremos otra matriz que acumule las distancias m nimas entre ciudades y que sirva como resultado.
Algoritmo completo a partir del re namiento del esquema general.

La unica variacion respecto al algoritmo de Dijkstra es que necesitamos saber la distancia m nima entre cada par de ciudades, no solo entre una ciudad y todas las demas. Por ello, es necesario aplicar Dijkstra n veces, siendo n el numero de ciudades (en rigor, no es necesario aplicarlo sobre la ultima ciudad, pues los caminos m nimos a esa ciudad ya han sido obtenidos en aplicaciones anteriores.
vector 1. . . N,1. . . N] para cada vertice v hacer m dijkstra(g,v,m) m
fun mapa (g:grafo) dev vector 1. . . N,1. . . N] de entero
fpara dev m fun
donde el algoritmo de dijkstra se implementa mediante una funcion dijkstra(g,v,m) que devuelve la matriz m con la informacion a~adida correspondiente a las distancias entre el n grafo v y todos los demas grafos de g.
Estudio del coste.

El coste del algoritmo depende de la implementacion para grafos que se escoja. Si se implementa como una matriz de adyacencia, sabemos que el coste del algoritmo de Dijkstra es cuadratico (O(n2 )). Como hemos de aplicarlo n veces (o n ; 1, que tambien es de orden n), el coste del algoritmo completo es O(n3 ). 2
Problema 2
Se consideran las funciones m(x) = 3x y d(x) = x 2 (donde ` ' representa la division entera). Dise~ar un algoritmo que, dados dos numeros a y b, encuentre n una forma de llegar de a a b mediante aplicaciones sucesivas de m(x) y d(x). Por ejemplo, se puede pasar de 7 a 2 mediante 2 = d(d(m(d(7))))
Como este problema esta en relacion muy estrecha con la practica del curso 96-97, no ofrecemos todav a la solucion.
Problema 3
En una clase hay f las y c columnas de pupitres. Delante de la primera la se encuentra la pizarra. a) Dise~ar un algoritmo que reparta los f c alumnos de forma que, al mirar hacia n la pizarra, ninguno se vea estorbado por otro alumno mas alto que el. b) A mitad de curso se coloca una pizarra adicional en una de las paredes adyacentes con la primera pizarra. Dise~ar un algoritmo que coloque a los alumnos de forma n que puedan mirar tambien a esa segunda pizarra sin estorbarse. Este algoritmo debe sacar partido de la colocacion anterior.

Para que nadie tenga un alumno mas alto que el al mirar a la pizarra, es necesario que, dentro de cada columna, los alumnos esten ordenados segun su altura de mayor a menor. 3
Para resolver el apartado a) de forma e ciente basta con dividir los f c alumnos en c subconjuntos de f elementos escogidos al azar, y a continuacion debe ordenarse cada uno de esos subconjuntos. Cada uno de ellos sera una columna en la clase. Como algoritmo de ordenacion puede escogerse cualquiera de los estudiados nosotros utilizaremos el algoritmo divide y venceras de fusion, por ser mas e ciente asintoticamente en el caso peor (es O(n log n)). Al colocar una segunda pizarra adyacente a la primera, los alumnos de cada la deben estar, a su vez, ordenados entre s . Para que esten ordenadas las columnas y las las, es necesario ordenar a todos los alumnos de menor a mayor, y colocarlos en la clase de forma que el mas bajito ocupe el pupitre que esta en la interseccion de las dos pizarras, y el mas alto en el vertice opuesto de la clase. Por lo tanto, para obtener la disposicion nal de los alumnos en el apartado b) debe hacerse una ordenacion de f c elementos. Pero si aprovechamos la disposicion anterior no es necesario, esta vez, aplicar ningun algoritmo de ordenacion: basta con realizar una fusion de los c subconjuntos ya ordenados (equivaldr a al ultimo paso de un algoritmo de ordenacion por fusion en el que el factor de division fuera c). As , la ordenacion nal puede obtenerse en tiempo lineal.

El esquema divide y venceras es una tecnica recursiva que consiste en dividir un problema en varios subproblemas del mismo tipo. Las soluciones a estos subproblemas se combinan a continuacion para dar la solucion al problema. Cuando los subproblemas son mas peque~os n que un umbral pre jado, se resuelven mediante un algoritmo espec co. Si su tama~o es n mayor, se vuelven a descomponer. El esquema es el siguiente:
fun divide y venceras (problema) si su cientemente-simple (problema) entonces dev solucion-simple (problema) si no hacer
fp
fsi un
: : : pk g descomposicion(problema) para cada si hacer si divide y venceras(pi) fpara dev combinacion(s1 : : : sk )

1
Tama~o umbral y solucion simple: El preorden bien fundado para los problemas se deriva n directamente del orden total entre el tama~o de los subconjuntos problema. Podemos tomar n como tama~o umbral n=1, caso en el que la ordenacion es trivial y consiste simplemente en n devolver el elemento.
Descomposicion: Dividiremos el conjunto problema en dos subbconjuntos formados por los n 2 primeros elementos por un lado y el resto por otro. Combinacion: Es necesario fundir los dos subconjuntos ordenados, mediante un bucle que toma cada vez el menor elemento de entre los primeros de uno y otro subconjunto todav a sin seleccionar.
Estructuras de datos.
La unica estructura de datos que necesitamos es una matriz de enteros de tama~o c f que n almacene las alturas de los alumnos. Tambien podemos utilizar un vector de tama~o c f , n sabiendo que cada f elementos representan una columna.
Algoritmo completo a partir del re namiento del esquema general.

Llamaremos a a la funcion que obtiene la ordenacion requerida en el apartado a), y b a la que soluciona el apartado b), es decir, obtiene una ordenacion total a partir de la que se tiene en a). La funcion a es la siguiente:
fun a (clase: vector 1. . . f,1... . . c] de enteros) dev vector 1. . . f,1... . . c] de enteros para i=1 hasta c hacer fpara dev clase un
clase 1 : : : f i] ordenacion(clase 1 : : : f i])
La funcion de ordenacion equivale a la funcion general divide y venceras, que modi caremos ligeramente para incluir como argumento vectores que sean siempre del mismo tama~o: n
proc ordenacion (v: vector 1. . . n] i,j: entero ) dev vector 1. . . n] si i = j entonces dev v si no hacer
k (i + j 2) ordenacion (v,i,k) ordenacion (v,k+1,j) fusion (v,i,j,2)
fsi fproc
La funcion de fusion tiene cuatro parametros: el vector, el principio y nal del tramo que contiene a los dos subvectores que hay que fusionar, y el factor de division empleado. Para el apartado a) podr amos ahorrarnos este ultimo argumento (es 2), pero esa generalizacion nos permitira usar la misma funcion en el apartado b).
f Inicializa el vector solucion g v' vector 1. . . n] f Inicializa punteros al comienzo de los vectores por fusionar g para k = 1 hasta factor hacer i inicio + factor (k ; 1) fpara I f i ::: i g f Selecciona el menor elemento de entre los principios de vector para incluirlo en la solucion, y a continuacion lo borra para que no vuelva a ser considerado g
k
1
proc fusion (v: vector 1. . . n] inicio, nal,factor: entero ) dev vector 1. . . n]
factor
elemento que maximiza v ix] v' h] v ix] si ix < inicio + factor x ; 1 hacer ix ix + 1 v
ix
para h=inicio hasta nal hacer
si no hacer fsi fpara

v'
I Infi g
x
fproc
La funcion b debe conseguir una ordenacion completa del conjunto de alumnos, pero debe tener en cuenta que ya existe una ordenacion parcial entre ellos: los alumnos de cada columna estan ordenados entre s . Si representamos el conjunto de los alumnos como un vector de c f elementos, en el que los f primeros elementos corresponden a la primera columna, los f siguientes a la segunda, etc, el problema queda solucionado llamando a la funcion de fusion de nida anteriormente, pero utilizando un factor de division c en lugar de 2:
fusion (v,1,c*f,c)
proc b (v: vector 1. . . c*f], entero: c) dev vector 1. . . c*f]
fproc
Estudio del coste.

apartado a
La ordenacion por fusion tiene un coste que cumple: ya que el algoritmo de fusion tiene un coste O(n) (consta de dos bucles consecutivos). De esa igualdad se obtiene un coste O(n log n. Como se realizan c ordenaciones de f elementos cada una, el coste total es O(cf log f ). Mediante una ordenacion total habr amos resuelto n tambien el problema, pero con un coste O(cf log cf ) (ya que el tama~o del problema ser a c f ).
apartado b
T (n) = 2T (n=2) + cte n
Se resuelve mediante una llamada al algoritmo de fusion, que tiene un coste lineal como el tama~o del problema es c f , el coste es O(c f ). El coste es mucho menor que en el caso n en que no aprovecharamos la ordenacion parcial que se obtiene en el apartado a.
Problema 4
Se planea conectar entre s todos los pueblos de una cierta region mediante carreteras que sustituyan los antiguos caminos vecinales. Se dispone de un estudio que enumera todas las posibles carreteras que podr an construirse y cual ser a el coste de construir cada una de ellas. Encontrar un algoritmo que permita seleccionar, de entre todas las carreteras posibles, un subconjunto que conecte todos los pueblos de la region con un coste global m nimo.

Si interpretamos los datos como un grafo en el que los pueblos son los vertices y las carreteras son aristas cuyos pesos son el coste de construccion, el problema no es otro que el de hallar un arbol de expansion m nimo para ese grafo. En efecto, un arbol de expansion m nimo es un conjunto de aristas que conectan todos los vertices del grafo en el que la suma de los pesos es m nima (por tanto, el coste de construir el subconjunto de carreteras es m nimo). 7
Para resolverlo podemos usar cualquiera de los dos algoritmos voraces estudiados que resuelven este problema: el de Kruskal o el de Prim.
<Cuidado! No debe confundirse este problema con el de encontrar los caminos m nimos entre un vertice y el resto. Ver problema 1

Nos ahorramos la descripcion del resto del problema. Podeis encontrarla en la pagina 83 del Brassard/Bratley.
Programacion III - Convocatoria de Septiembre 96

Examen de reserva
Problema 1 (5 puntos). En una clase hay f las y c columnas de pupitres. Delante de la primera la se encuentra la pizarra. a) Dise~ar un algoritmo que reparta los f c alumnos de forma que, al mirar n hacia la pizarra, ninguno se vea estorbado por otro alumno mas alto que el. b) A mitad de curso se coloca una pizarra adicional en una de las paredes adyacentes con la primera pizarra. Dise~ar un algoritmo que coloque a los alumnos n de forma que puedan mirar tambien a esa segunda pizarra sin estorbarse. Este algoritmo debe sacar partido de la colocacion anterior. Problema 2 (5 puntos). Se planea conectar entre s todos los pueblos de una cierta region mediante carreteras que sustituyan los antiguos caminos vecinales. Se dispone de un estudio que enumera todas las posibles carreteras que podr an construirse y cual ser a el coste de construir cada una de ellas. Encontrar un algoritmo que permita seleccionar, de entre todas las carreteras posibles, un subconjunto que conecte todos los pueblos de la region con un coste global m nimo.
Voraz:
demostracion de optimalidad. preorden bien fundado. descripcion del arbol de busqueda asociado.
Divide y venceras: Vuelta atras:
Programacion III - Convocatoria de Febrero de 1997

Examen primera semana
denados cada una, se pretende mezclarlas a pares hasta lograr una unica cinta ordenada. La secuencia en la que se realiza la mezcla determinara la e ciencia del proceso. Dise~ar un algoritmo que busque la solucion optima minimizando el n numero de movimientos.
Problema 1 (5 puntos). Dado un conjunto de n cintas con n registros ori
Por ejemplo: 3 cintas: A con 30 registros, B con 20 y C con 10 1. Mezclamos A con B (50 movimientos) y el resultado con C (60 movimientos), con lo que realizamos en total 110 movimientos 2. Mezclamos C con B (30 Movimientos) y el resultado con A (60). Total = 90 movimientos >Hay alguna forma mas e ciente de ordenar el contenido de las cintas? Problema 2 (5 puntos). El juego del 31 utiliza las cartas de la baraja espa~ola: n 1,2,3,4,5,6,7,10(sota),11(caballo) y 12(rey) con los 4 palos: oros, copas, espadas y bastos. Dise~ar un algoritmo que calcule todas las posibles formas de obtener n 31 utilizando a lo sumo 4 cartas y 2 palos distintos en cada combinacion.
RESPUESTAS EXAMEN Programacin III. Febrero 1997 (Primera Semana) Problema 1 (5 puntos). Dado un conjunto de n cintas no vacas con ni registros ordenados cada uno, se pretende mezclarlos a pares hasta lograr una nica cinta ordenada. La secuencia en la que se realiza la mezcla determinara la eficiencia del proceso. Disese un algoritmo que busque la solucin ptima minimizando el nmero de movimientos. Por ejemplo: 3 cintas: A con 30 registros, B con 20 y C con 10. 1. Mezclamos A con B (50 movimientos) y el resultado con C (60 movimientos), con la que realiza en total 110 movimientos. 2. Mezclamos C con B (30 movimientos) y el resultado con A (60 movimientos), con la que realiza en total 90 movimientos. Hay alguna forma ms eficiente de ordenar el contenido de las cintas? Solucin:
Eleccin razonada del esquema

El problema presenta una serie de elementos caractersticos de un esquema voraz: Por un lado, se tienen un conjunto de candidatos (las cintas) que vamos eligiendo uno a uno hasta completar determinada tarea. Por otro lado, el orden de eleccin de dichos elementos determina la optimalidad de la solucin, de manera que para alcanzar una solucin ptima es preciso seleccionar adecuadamente al candidato mediante un criterio determinado. Una vez escogido, habremos de demostrar que nos lleva a una solucin ptima. El criterio de eleccin de las cintas para alcanzar una solucin ptima ser el de elegir en cada momento aquella con menor nmero de registros.
Demostracin de optimalidad:
La demostracin corresponde con la de minimizacin del tiempo en el sistema, dada ya en ejercicios antes, por lo que evitamos escribirla de nuevo.
Esquema general e identificacin con el problema

El esquema voraz se aplica a problema de optimizacin. Consiste en ir seleccionando elementos de un conjunto de candidatos que se van incorporando a la solucin. Se caracterizan porque nunca se deshace una decisin ya tomada: los candidatos desechados no vuelven a ser considerados y los incorporados a la solucin permanecen en ella hasta al final del algoritmo. Es crucial determinar la funcin de seleccin adecuada que nos asegure que la solucin obtenida es ptima. Esta notacin algortmica puede escribirse as (libro de Brassard pgina 214):
Hemos de particularizar las siguientes funciones: Solucin (S): El nmero de cintas, que es n. Objetivo (x): Funcin que devuelve la cinta con menor nmero de registros de entre el conjunto de cintas disponibles. Factible (x) (o completable): Esta funcin es siempre cierta, pues cualquier orden de combinacin es vlido.
Estructuras de datos
Se utilizarn vectores de n valores naturales para representar los conjuntos. Por ejemplo, para el conjunto C se define la variable c como vector de naturales, siendo c[i] = ni la expresin de que la cinta i consta de ni registros. El conjunto S puede representarse de manera anloga. Para representar la ausencia de un elemento puede usarse cualquier marcador (por ejemplo, el valor ).
Algoritmo completo a partir del refinamiento del esquema

Adaptamos el algoritmo general a lo dicho anteriormente:
fun voraz (c: vector) dev (s: vector) para i 0 hasta n hacer s[i] 0 fpara i 0 mientras i < n hacer x seleccionar (c) c[i] 0 s[i] x i i+1 fmientras dev S ffun
Esta solucin est modificada respecto de la solucin aportada en el libro de problemas. Se han aadido una lnea (la de ii+1) y se ha modificado la lnea c[i]0. Con esto trato de decir, que no es seguro que est correcta la respuesta, slo que pienso que haba algunas erratas. La nica funcin (de seleccin) por desarrollar es aquella que obtiene en cada momento la cinta con menor nmero de registros de entre las cintas no usadas todava y almacenadas en el vector de cintas. La funcin devuelve la cinta, pero no la elimina del conjunto de candidatos. Los argumentos sin c, vector de cintas y cinta que es un vector de ni registros.
fun seleccionar (c: vector) dev cinta: vector min 1 para j 1 hasta n hacer si c[j] < c[min] entonces min j fsi fpara dev c[min] ffun
Demostracin de optimalidad
La demostracin corresponde con la de minimizacin del tiempo en el sistema, dada ya en ejercicios antes, por lo que evitamos escribirla de nuevo.
Anlisis del coste

La funcin objetivo (para nosotros seleccionar) tiene coste de (n) y el bucle principal (mientras) se repite n veces, por lo que el coste es (n2).

Examen segunda semana
Queremos grabar canciones de duraciones P . duracion =1
n T <
n i
t1 : : : tn
en una cinta de audio de
ti
numero de canciones en el espacio disponible. Problema 2(5 puntos). Dise~ar un algoritmo que seleccione las canciones de n forma que se minimice el espacio vac o que queda en la cinta.
Problema 1(5 puntos). Dise~ar un algoritmo que permita almacenar el maximo n
Programacion III - Convocatoria de Septiembre de 1997

Original Problema 1 (5 puntos). Una empresa de mensajer a dispone de tres motoristas en distintos puntos de la ciudad, y tiene que atender a tres clientes en otros tres puntos. Se puede estimar el tiempo que tardar a cada motorista en atender a cada uno de los clientes (en la tabla, en minutos):
cliente1 cliente2 cliente3 Moto 1 Moto 2 30 40 60 20 40 90 Moto 3 70 10 20
Dise~ar un algoritmo que distribuya un cliente a cada motorista de forma que se minimice el n coste total (en tiempo) de atender a los tres clientes.
Problema 2 (5 puntos). Sea un juego de tablero para dos personas, en el que se turnan para
mover las piezas del tablero segun unas reglas determinadas. Daremos por conocidos: Una estructura de datos jugada que nos da dos tipos de informacion: en un registro tablero, por un lado, la situacion de las chas en el tablero. Y en un registro turno, por otro lado, quien debe mover a continuacion (o, en caso de ser una posicion nal, quien es el ganador), con la siguiente convencion: 1 signi ca que le toca mover al jugador que comenzo. 2, al segundo jugador. 3, que la partida acabo con triunfo del primer jugador, y 4, que la partida acabo con triunfo del segundo jugador. Una funcion
funcion movimientos (j: jugada) devolver l:lista de jugada
que da todas las jugadas posibles a partir de una dada. Supondremos que en el juego no se pueden dar ciclos (volver a una situacion previa en el juego), que no se puede prolongar inde nidamente y que la partida no puede acabar en tablas. Dise~ar n un algoritmo que averigue si existe una estrategia optima para el jugador que mueve primero, de forma que se asegure la victoria siguiendo esa estrategia. >Se puede aplicar el algoritmo, en teor a, al juego del ajedrez? >Y en la practica?
La resolucion de cada problema debe incluir, por este orden: 1. Eleccion razonada del esquema algor tmico. 2. Descripcion del esquema usado e identi cacion con el problema. 3. Estructuras de datos. 4. Algoritmo completo a partir del re namiento del esquema general. 5. Estudio del coste. Segun el esquema elegido hay que especi car, ademas: Voraz: demostracion de optimalidad. Divide y venceras: preorden bien fundado. Exploracion en grafos: descripcion del arbol de busqueda asociado.

Primera Semana Problema 1 (5 puntos). Se considera un juego solitario en el que el tablero se compone de varios huecos dispuestos en forma de cruz y un conjunto de bolas que, inicialmente, cubren todos ellos excepto el hueco central (ver gura izquierda). Siempre que haya dos bolas y un hueco vac o consecutivos, se puede saltar con la primera bola al hueco vac o, retirando la bola intermedia (ver un posible primer movimiento en g. derecha). Solo se consideran movimientos horizontales o verticales, nunca en diagonal. El objetivo del juego es eliminar progresivamente todas las bolas del tablero hasta que solo quede una. Dise~ar un algoritmo que encuentre una solucion al juego. n
Problema 2 (5 puntos). En la compleja red de metro de Japon, la cantidad que se paga por un billete es proporcional a la distancia que se recorre. Por tanto, es necesario instalar en cada estacion un panel informativo que informe del precio del billete a cualquier otra estacion de la red. Describir un algoritmo que deduzca la informacion de todos esos paneles, basando el calculo en la suposicion de que el viajero se trasladara de una estacion a otra por el camino mas corto.
La resolucion de cada problema debe incluir, por este orden: 1. Eleccion razonada del esquema algor tmico. 2. Breve descripcion del esquema usado e identi cacion con el problema. 3. Estructuras de datos requeridas. 4. Algoritmo completo a partir del re namiento del esquema general. 5. Estudio del coste. Segun el esquema elegido hay que especi car, ademas: Voraz: demostracion de optimalidad. Divide y venceras: preorden bien fundado entre los ejemplares del problema. Exploracion en grafos: descripcion del grafo de busqueda asociado.
RESPUESTAS EXAMEN Programacin III. Febrero 1998 (Primera Semana) Problema 1 (5 puntos). Se considera un juego solitario en el que el tablero se compone de varios huecos dispuestos en forma de cruz y un conjunto de bolas que, inicialmente, cubren todos ellos excepto el hueco central (ver figura izquierda). Siempre que haya dos bolas y un hueco vaco consecutivos, se puede saltar con la primera bola al hueco vaco, retirando la bola intermedia (ver un posible primer movimiento en fig. derecha). Slo se consideran movimientos horizontales o verticales, nunca en diagonal. El objetivo del juego es eliminar progresivamente todas las bolas del tablero hasta que slo quede una. Disear un algoritmo que encuentre una solucin al juego. Solucionado por Vuelta atrs.
X X X X X X X X X X X X X
X X X O X X X
===>
X X X X O O X
El tablero de juego se puede representar mediante una matriz 7*7 con tres valores posibles:
0 si la casilla est vaca. 1 si la casilla tiene una pieza. -1 si la casilla es no vlida. Se utiliza para deshabilitar las posiciones de las esquinas, que no forman parte del tablero.
La solucin consiste en la secuencia de movimientos hasta llegar a la posicin final. Es posible que una casilla del tablero sea visitada varias veces por distintas piezas a lo largo de una partida: no podemos utilizar un tablero para representar la solucin Utilizaremos una secuencia X = (x1,,xm), en la que xi representa el movimiento i -simo. Adems, m = 31. Cada movimiento debe contener informacin para deshacerlo si es necesario:
posicin del tablero desde la que se mueve. posicin a la que se mueve. posicin de la _cha que se salta.
dX = (1, 0, -1, 0) ; dY = (0, 1, 0, -1) //constantes globales fun continental(D[1..7,1..7],sol[1..31],etapa) si esFin(D,etapa) entonces devolver cierto desde i 1 hasta 7 hacer desde j 1 hasta 7 hacer si D[i,j] = 1 entonces desde v 1 hasta 4 hacer si esValido(D,i,j,v) entonces sol[etapa].origen.x i ; sol[etapa].origen.y j sol[etapa].destino.x i+2*dX[v] ; sol[etapa].destino.y j+2*dY[v] sol[etapa].comido.x i+dX[v] ; sol[etapa].comido.y j+dY[v] hacerMovimiento(D,sol[etapa]) si continental(D,sol,etapa+1) entonces devolver cierto si no deshacerMovimiento(D,sol[etapa]) fin si fin desde fin si fin desde fin desde devolver falso fin fun
fun esFin(D,etapa) si etapa = 31 ^ D[4,4] = 1 entonces devolver cierto devolver falso fin fun
fun esValido(D,i,j,v) // Ya se ha comprobado que D[i,j]=1 destX i+2*dX[v] ; destY j+2*dY[v] comX i+dX[v] ; comY j+dY[v] si 1 destX 7 ^ 1 destY 7^ D[destX,destY]=0 ^ D[comX,comY]=1 entonces devolver cierto si no devolver falso fin fun
proc hacerMovimiento(D,mov) D[mov.origen.x,mov.origen.y] 0 D[mov.destino.x,mov.destino.y] 1 D[mov.comido.x,mov.comido.y] 0 fin proa
proc deshacerMovimiento(D,sol[etapa]) D[mov.origen.x,mov.origen.y] 1 D[mov.destino.x,mov.destino.y] 0 D[mov.comido.x,mov.comido.y] 1 fin proa
fun llamador continental(sol) crear D[1..7,1..7] D {{-1,-1, 1, 1, 1,-1,-1}, {-1,-1, 1, 1, 1,-1,-1}, { 1, 1, 1, 1, 1, 1, 1}, { 1, 1, 1, 0, 1, 1, 1}, { 1, 1, 1, 1, 1, 1, 1}, {-1,-1, 1, 1, 1,-1,-1}, {-1,-1, 1, 1, 1,-1,-1}} devolver continental(D,sol,1) fin fun
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. 2. Descripcin del esquema usado e identificacin con el problema. 3. Estructuras de datos. 4. Algoritmo completo a partir del refinamiento del esquema general. 5. Estudio del coste.
Segn el esquema elegido hay que especificar, adems: Voraz: demostracin de optimalidad. Divide y vencers: preorden bien fundado. Exploracin en grafos: descripcin del rbol de bsqueda asociado.

Segunda Semana
Problema 1 (5 Puntos) Sobre un eje de coordenadas positivo se tienen representados edi cios en forma de rectangulos. Cada rectangulo descansa sobre el eje horizontal y se representa por sus abscisas inicial y nal y por su altura. La linea de horizonte es el contorno que forman los edi cios. Se pide programar un algoritmo e ciente que encuentre la linea de horizonte que forma un conjunto de edi cios. Ej. Una ciudad = f(0 4 7) (2 14 4) (7 12 5) (8 17 2) (19 21 10)g tendr a una linea de horizonte = f(0 4 7) (4 7 4) (7 12 5) (12 14 4) (14 17 2) (17 19 0) (19 21 10)g:
C H
Problema 2 (5 Puntos) Se tiene un mecano de 8 piezas. Las piezas se acoplan entre s mediante tornillos, formando distintos juguetes dependiendo de como se combinen. Un juguete completo es aquel formado por las 8 piezas. El gasto de tornillos de cada acoplamiento es el indicado en la siguiente tabla: (Un ; indica que las piezas no encajan)
p1 p2 p3 p4 p5 p6 p7 p8
7 12 4 -
p1
p2
7 2 6 1 1 -
12 2 4 10 3
p3
p4
6 4 3 2 -
4 - 1 - 1 - 10 - 3 2 - 20 10 20 - 5 10 5 - - -
p5
p6
p7
p8
3 -
Se pide construir un algoritmo que calcule la combinacion de piezas que forman un juguete completo minimizando el gasto de tornillos.
La resolucion de cada problema debe incluir, por este orden: 1. Eleccion razonada del esquema algor tmico. 2. Breve descripcion del esquema usado e identi cacion con el problema. 3. Estructuras de datos requeridas. 4. Algoritmo completo a partir del re namiento del esquema general. 5. Estudio del coste. Segun el esquema elegido hay que especi car, ademas: Voraz: demostracion de optimalidad. Divide y venceras: preorden bien fundado entre los ejemplares del problema. Exploracion en grafos: descripcion del grafo de busqueda asociado.

Original
a los ejes del plano, hallar el rectangulo interseccion de todos los rectangulos mediante un algoritmo e ciente.
Problema 1 (5 puntos). Dado un conjunto de n rectangulos cuyos lados son paralelos
Problema 2 (5 puntos). Una cadena euleriana en un grafo no orientado es una cadena
que une cada arista del grafo exactamente una vez. Escribir un algoritmo que decida si un grafo dado tiene una cadena euleriana y, si es as , que devuelva esa cadena.
La resolucion de cada problema debe incluir, por este orden: 1. Eleccion razonada del esquema algor tmico. 2. Breve descripcion del esquema usado e identi cacion con el problema. 3. Estructuras de datos requeridas. 4. Algoritmo completo a partir del re namiento del esquema general. 5. Estudio del coste. Segun el esquema elegido hay que especi car, ademas:
Voraz: demostracion de optimalidad. Divide y venceras: preorden bien fundado entre los ejemplares del problema. Exploracion en grafos: descripcion del grafo de busqueda asociado.
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 1999 Segunda Semana
Problema 1 (5 puntos). Disear un algoritmo que tome un mapa poltico y coloree el mapa con el mnimo nmero de colores posible de manera que dos pases fronterizos no tengan el mismo color.
Problema 2 (5 puntos). Una liga de n equipos ei juega a un juego donde solo se pierde o se gana, pero no se empata. Disear un algoritmo que realice una pseudo-ordenacin (e1,e2 . - - ,en) a partir de la tabla de resultados de lo equipos de manera que e1 haya ganado a e2, e2 a e3, etc. El coste debe ser a lo sumo O(nlogn)
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. 2. Descripcin del esquema usado e identificacin con el problema. 3. Estructuras de datos. 4. Algoritmo completo a partir del refinamiento del esquema general. 5. Estudio del coste. Segn el esquema elegido hay que especificar, adems: Voraz: demostracin de optimalidad. Divide y vencers: preorden bien fundado. Exploracin en grafos: descripcin del rbol de bsqueda asociado.
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2000 Primera Semana Cuestin 1 (2 puntos). Comparar la eficiencia de los algoritmos de ordenacin Quicksort (ordenacin rpida) y Mergesort (ordenacin por fusin).
Cuestin 2 (1 puntos). Comenta las condiciones de poda que has utilizado en la realizacin de la prctica del Nim.
Cuestin 3 (2 puntos). Que variante del problema de la mochila admite una solucin voraz y por qu? Qu variante no admite solucin voraz? Poner un ejemplo del segundo caso en el que la solucin voraz no nos lleve a la solucin ptima.
PROBLEMA (5 puntos). Se considera un juego de tablero genrico con las siguientes caractersticas: - Juegan dos oponentes entre s. Cada jugador mueve alternativamente. El juego acaba con la victoria de uno de los dos jugadores, o en tablas. - Se supone conocido: - Una estructura de datos situacin que nos da la situacin actual del juego: qu jugador tiene el turno, disposicin de las fichas en el tablero, etc. - Una funcin funcion movimientos(j: situacion) devolver l:lista de situacin que nos da todas las jugadas posibles a partir de una dada. Aceptaremos que, si nos devuelve una lista vaca, es porque el juego ha terminado. Se pide disear un algoritmo que encuentre cul es el nmero de movimientos de la (o las) partidas ms cortas.
RESPUESTAS EXAMEN Programacin III. Febrero 2000 (Primera Semana) Cuestin 1. Comparar la eficiencia de los algoritmos de ordenacin Quicsort (ordenacin rpida) y Mergesort (ordenacin por fusin). (Respuesta: Fundamentos de Algoritmia, pag. 260). El algoritmo Quicksort emplea un tiempo promedio de nlogn, en el peor caso de n2. El algoritmo por fusin mergesort utiliza un tiempo de nlogn (siempre observando la precaucin de equilibrar los subcasos a tratar). Pese a esto, en la prctica Quicksort es ms rpido en un tiempo c constante. Adems el algoritmo mergesort requiere de un espacio extra para tratar los distintos casos sin perder eficiencia (hacer la ordenacin in situ lleva asociado un incremento de la constante oculta bastante alto). Cuestin 2. Comenta las condiciones de poda que has utilizado en la realizacin de la prctica del Nim.
Cuestin 3.Qu variante del problema de la mochila admite solucin voraz, y porqu?Qu variante no admite solucin voraz? Poner un ejemplo del segundo caso en el que la solucin voraz no nos lleve a la solucin ptima. (Respuesta: Fundamentos de algoritmia, pag 227, contraejemplo en pag. 300). La variante del problema de la mochila que admite solucin voraz es la variante continua, donde podemos fragmentar los objetos. Esta variante admite solucin voraz porque encontramos una funcin de seleccin que nos permite escoger del candidato a cada paso de forma que obtengamos una solucin ptima. Dicha funcin consiste en escoger los objetos por orden decreciente (de mayor a menor) segn su relacin valor/peso, lo que nos lleva a una solucin ptima. La variante que no admite solucin optima es la que no nos permite fragmentar los objetos, veamos esto con un ejemplo. Dada la siguiente relacin de objetos valor-peso para una mochila de capacidad 10 (W=10 , peso mximo de la mochila) . a 6 8 b 5 5 c 5 5
wi vi
Segn el algoritmo voraz de la variante continua tomaramos los objetos segn su orden decreciente en funcin de la relacin valor/peso. De este modo tendramos: a (vi/wi = 1,333) , b (vi/wi= 1) y c(vi/wi=1) . La sucesin a, b y c. Sin embargo como en esta ocasin no podemos fragmentar los objetos al introducir en la mochila el objeto a de peso 6 ya no podemos introducir ninguno ms, el valor conseguido ser entonces de 6; mientras que si introducimos primero el objeto b, queda an espacio para el objeto c, con lo que en esta ocasin hemos utilizado el peso total mximo de la mochila y el valor conseguido es de 10. Siendo esta la solucin ptima. Vemos con este ejemplo como el criterio seguido en la variante continua del problema no puede aplicarse en el caso en el que los objetos no puedan fragmentarse.
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2000 Segunda semana Cuestin 1 (1 puntos). Poner algn ejemplo en el que un enfoque de Divide y Vencers nos
lleve a un coste exponencial de forma innecesaria.
Cuestin 2 (2 puntos). Puedes explicar brevemente que papel desempea un montculo en el algoritmo de Ramificacin y Poda? Cul es el criterio general para realizar la poda en este algoritmo?. Cuestin 3 (2 puntos). En una exploracin de un rbol de juego con dos oponentes a nivel
de profundidad 4 (contando la raz como nivel 1) y siguiendo la estrategia del MINIMAX nos encontramos con la siguiente puntuacin: [[[-7,5] [-3] [-10,-20,0]] [[-5,-10] [-15,20]] [[1] [6,-8,14] [-30,0] [-8,-9]]] donde los corchetes indican agrupacin de nodos por nodo padre comn. Se pide propagar las puntuaciones y elegir la rama ms adecuada a partir de la raz sabiendo que el nodo raz corresponde al jugador A, a mayor valor, mejor jugada para A, y que se alternan para mover. En que se diferencia esta estrategia de juego de la utilizada para resolver la prctica?.
Problema (5 Puntos). La Base Area de Gando (Gran Canaria) posee una flota variada de n cazas de combate ci (con i {1..n}). Cada caza tiene que salir del bunker y superar un tiempo de rodadura ki ms un tiempo de despegue ti para estar en el aire y operativo. Durante este proceso la nave es vulnerable. Suponiendo que se produce un ataque sorpresa, construir un algoritmo que averige el orden de despegue de las aeronaves de manera que se minimice el tiempo medio durante el cual son vulnerables. Supongamos ahora que cada aeronave ci posee un ndice acumulativo bi de importancia estratgica siempre que despegue antes de la ranura temporal hi (con i {1..n}). Si queremos maximizar la importancia estratgica una vez que hayan despegado todas Qu tipo de problema es ste? Con que esquema se resuelve?. Explica en un prrafo breve el funcionamiento del algoritmo.
RESPUESTAS EXAMEN Programacin III. Febrero 2000 (Segunda Semana)

Cuestin 1.Poner algn ejemplo en el que un enfoque divide y vencers nos lleve a un coste exponencial de forma innecesaria. (Respuesta: Fundamentos de Algoritmia, pag.83). Un ejemplo claro de esto es utilizar la definicin recursiva de la funcin de Fibonacci sin ms, de este modo el siguiente algoritmo conlleva un coste exponencial, existiendo formas de obtener la solucin en un coste inferior utilizando un enfoque distinto al de divide y vencers.
Fun Fib(n) si (n < 2) entonces devolver n sino Devolver Fib(n - 1) + Fib(n - 2) Fsi Ffun
Cuestin 2.Puedes explicar brevemente qu papel desempea un montculo en el algoritmo de ramificacin y poda? Cul es el criterio general para realizar la poda en este algoritmo? (Respuesta Fundamentos de Algoritmia, pag. 354, y 348). El montculo es la forma ideal de mantener la lista de nodos que han sido generados pero no explorados en su totalidad en los diferentes niveles del rbol, tomando como valor el de la funcin de cota. De este modo tendremos ordenados los nodos segn la cota, de manera que el elemento en la cima ser el ms factible de ser explorado a continuacin. El criterio consiste en calcular una cota del posible valor de aquellas soluciones que el grafo pudiera tomar ms adelante, si la cota muestra que cualquiera de estas soluciones ser necesariamente peor que la mejor solucin hallada hasta el momento entonces no seguimos explorando esa parte del grafo. Cuestin 3.En una exploracin de un rbol de juego con dos oponentes a nivel de profundidad 4 (Contando la raiz como nivel 1) y siguiendo la estrategia MINIMAX nos encontramos con la siguiente puntuacin: [[[-7,5][-3][-10,-20,0]] [[-5,-10][-15,20]] [[1] [6,-8,14] [-30,0] [-8,-9]]] Donde los corchetes indican agrupacin de nodos por nodo padre comn. Se pide propagar las puntuaciones y elegir la rama ms adecuada a partir de la raz sabiendo que el nodo raz corresponde al jugador A, a mayor valor, mejor jugada para A, y que se alternan en mover. En que se diferencia esta estrategia de juego de la utilizada para resolver la prctica? (Alg. Minimax pag. 354) El nodo raz corresponde al jugador A, el nodo 2 a B, el nodo 3 a A y consecuentemente el nodo 4 a B, segn lo cual los valores correspondern por tanto a una jugada de B. Como anteriormente juega A, y los mejores valores para A son los mayores, coger por tanto los mayores valores de las jugadas posibles. Cuando juegue B es lgico que este tomar aquellas jugadas que sean peores para A, luego coger los valores ms pequeos.
Problema (5 Puntos). La Base Area de Gando (Gran Canaria) posee una flota variada de n cazas de combate ci (con i {1..n}). Cada caza tiene que salir del bunker y superar un tiempo de rodadura ki ms un tiempo de despegue ti para estar en el aire y operativo. Durante este proceso la nave es vulnerable. Suponiendo que se produce un ataque sorpresa, construir un algoritmo que averige el orden de despegue de las aeronaves de manera que se minimice el tiempo medio durante el cual son vulnerables. Supongamos ahora que cada aeronave ci posee un ndice acumulativo bi de importancia estratgica siempre que despegue antes de la ranura temporal hi (con i {1..n}). Si queremos maximizar la importancia estratgica una vez que hayan despegado todas Qu tipo de problema es ste? Con que esquema se resuelve?. Explica en un prrafo breve el funcionamiento del algoritmo.
Programacion III - Septiembre 2.000 - Original

Cuestion 1. (1 punto). A la hora de hacer una exploracion ciega en un
grafo, >que criterios nos pueden decidir por una busqueda en profundidad o en anchura?
f ib
f ib
Cuestion 2 (2 puntos). La sucesion de Fibonacci se de ne como (0) = (1) = 1 ( ) = ( ; 1)+ ( ; 2)si 2. Que ocurre si aplicamos
una estrategia divide y venceras para calcular ( ) usando directamente la de nicion? >Que otras opciones existen? (2 puntos).
f ib n f ib n f ib n f ib n n
seleccion y la ordenacion por mont culo? >Como se re eja en la e ciencia de los dos algoritmos? (2 puntos).
T :::n n
Cuestion 3 (2 puntos). >Cual es la relacion entre la ordenacion por
Problema (5 puntos). Sea 1 ] un vector de elementos. La unica comparacion que se permite entre esos elementos es el test de igualdad. Llamemos elemento mayoritario de , si existe, a aquel que aparece estrictamente mas de 2 veces en . Dise~ar un algoritmo que encuentre el n elemento mayoritario de un vector (si existe) en un tiempo que sea, a lo sumo, O( log ). Sugerencia: el elemento mayoritario de un vector debe serlo tambien, al menos, de una de sus dos mitades.
T n= T n n
La resolucion del problema debe incluir, por este orden: 1. Eleccion razonada del esquema algor tmico. 2. Descripcion del esquema usado e identi cacion con el problema. 3. Estructuras de datos. 4. Algoritmo completo a partir del re namiento del esquema general. 5. Estudio del coste. Segun el esquema elegido hay que especi car, ademas: Voraz: demostracion de optimalidad. Divide y venceras: preorden bien fundado. Exploracion en grafos: descripcion del arbol de busqueda asociado.
RESPUESTAS EXAMEN Programacin III. Septiembre 2000 Cuestin 1.A la hora de hacer una exploracin ciega en un grafo qu criterios nos pueden decidir por una bsqueda en profundidad o en anchura? (Respuesta: Fundamentos de Algoritmia, pag 340). A la hora de escoger un criterio u otro fundamentaremos nuestra decisin segn el problema en cuestin y el tamao del grafo generado. Si el problema consiste en encontrar el camino ms corto desde un punto del grafo hasta otro, la exploracin en anchura es la ms adecuada. Del mismo modo, si el grafo a tratar es de un tamao muy grande, de forma que no resulte manejable, o infinito, utilizaremos la exploracin en anchura para realizar una exploracin parcial de dicho grafo. En otro caso nos decidiremos por la exploracin en profundidad. Cuestin 2.La sucesin de fibonacci se define como Fib(1)=1; fib(n)=fib(n-1)+fib(n-1) si n >= 2 Qu ocurre si aplicamos una estrategia divide y vencers para calcular fib(n) usando directamente la definicin?Qu otras opciones existen?. (Respuesta. Fundamentos de Algoritmia pag. 83). Si utilizamos directamente la definicin obtendremos un algoritmo con un coste exponencial. Dicho algoritmo sera el siguiente:
Fun Fibrec(n) si (n < 2) entonces devolver n sino devolver Fibrec(n - 1) + Fibrec(n - 2) Fsi Ffun
Fun Fibiter(n) i 1; j 0; para k 1 hasta n hacer j j + i; i j i; Fpara devolver j; Ffun
Y el principal problema es que calculara varias veces los mismos valores, para evitar esto existe otra opcin dada por el algoritmo iterativo, que requiere de un tiempo de orden n. Implementacin en java de los dos algoritmos, con los tiempos de ejecucin:
import java.io.*; public class fibrec { public static long fib(int n) { if (n <= 1) return n; else return fib(n-1) + fib(n-2); } public static void main(String[] args) throws IOException { System.out.print("numero: "); BufferedReader b=new BufferedReader (new InputStreamReader (System.in)); String numero2 =b.readLine (); int N=Integer.parseInt (numero2); double timeInicial = System.currentTimeMillis(); for (int i = 1; i <= N; i++){ System.out.print(i + ": " + fib(i)); double timeFinal = System.currentTimeMillis(); System.out.println ("\tTiempo: "+(timeFinal-timeInicial)/1000 + " s."); } } }
import java.io.*; public class fibiter { public static void main(String[] args) throws IOException{ System.out.print("numero: "); BufferedReader b=new BufferedReader (new InputStreamReader (System.in)); String numero2 =b.readLine (); double N=Double.parseDouble (numero2); double f = 0, g = 1; double timeInicial = System.currentTimeMillis(); for (int i = 1; i <= N; i++) { f = f + g; g = f - g; System.out.print(i+": "+f); double timeFinal = System.currentTimeMillis(); System.out.println("\tTiempo: "+(timeFinal-timeInicial)/1000 + " s."); } } }
fibrec 1: 1 Tiempo: 2: 1 Tiempo: 3: 2 Tiempo: 4: 3 Tiempo: 5: 5 Tiempo: . . 33: 3524578 34: 5702887 35: 9227465 36: 14930352 37: 24157817 38: 39088169 39: 63245986 40: 102334155 41: 165580141 42: 267914296 55: 56: 57: 58: 59: 139583862445 225851433717 365435296162 591286729879 956722026041 0.0 0.0 0.0 0.0 0.0 s. s. s. s. s.
fibiter 1: 1.0 Tiempo: 0.0 s. 2: 1.0 Tiempo: 0.0 s. 3: 2.0 Tiempo: 0.0 s. 4: 3.0 Tiempo: 0.0 s. 5: 5.0 Tiempo: 0.0 s. . . . 1456: 8.64010861026715E303 1457: 1.3979989397902865E304 1458: 2.2620098008170014E304 1459: 3.660008740607288E304 1460: 5.922018541424289E304
Tiempo: Tiempo: Tiempo: Tiempo: Tiempo:
0.266 0.266 0.266 0.266 0.266
s. s. s. s. s.
Tiempo: Tiempo: Tiempo: Tiempo: Tiempo: Tiempo: Tiempo: Tiempo: Tiempo: Tiempo:
0.266 0.422 0.672 1.094 1.766 2.844 4.625 7.485 12.11 19.61
s. s. s. s. s. s. s. s. s. s.
Tiempo: Tiempo: Tiempo: Tiempo: Tiempo:
11211.5 s. 18116.5 s. 29307.125 s. 47427.625 s. 76710.469 s.
Existe una tercera opcin con la que tendramos un algoritmo de fibonacci de orden O ( logn )
fun fibo (n:nat) dev f:nat si n 1 entonces f := n sino (a,b):= potF(n-1) f := a+b fsi ffun
fun potF (n:nat) dev (a,b:nat) casos n=0 (a,b):= (1,0) n=1 (a,b):= (0,1) n>1 ^ par (n) (a,b):= potF(ndiv2) (a,b):= (a*a+b*b, a*b+b*(a+b)) n<1 ^ impar (n) (a,b):= potF(ndiv2) (a,b):= (b*a+(a+b)*b, b*b+(a+b)*(a+b))) fcasos ffun
Cuestin 3.Cul es la relacin entre la ordenacin por seleccin y la ordenacin por montculo? Cmo se refleja en la eficiencia de los dos algoritmos?
ORDENACIN POR SELECCIN: (pgina 121) La ordenacin se hace sobre un array, seleccionando el menor elemento del array v [0 ] ..v [ n ] e intercambindolo con v [0 ] , luego el menor elemento del array v [1] ..v [ n ] y se intercambia con v [1] , as sucesivamente hasta llegar al elemento v [ n 1] , de esta manera se obtiene el array ordenado ascendentemente La ordenacin por seleccin requiere un tiempo que est en ( n 2 )
ORDENACIN POR MONTCULO: (pgina 188) El montculo organiza sus datos como un rbol que es la nica estructura que proporciona cotas de tiempo logartmico. El montculo requiere un tiempo que est en ( n log n ) para ordenar n elementos. Es una variante del mtodo de ordenacin por seleccin, donde la bsqueda del elemento mnimo de un array se realiza mediante tcnicas basadas en la construccin del montculo. Se cumple que para un nodo que ocupa la posicin i del array, su hijo izquierdo ocupa la posicin 2i , y su hijo derecho la posicin 2i +1
Problema (5 puntos). Sea T[1..n] un vector de n elementos. La nica comparacin que se permite entre esos elementos es el test de igualdad. Llamemos elemento mayoritario de T, si existe, a aquel que aparece estrictamente ms de n/2 veces en T. Disear un algoritmo que encuentre el elemento mayoritario de un vector (si existe) en un tiempo que sea, a lo sumo, O(nlogn). Sugerencia: el elemento mayoritario de un vector debe serlo tambin, al menos, de una de sus dos mitades.
1. Eleccin razonada del esquema algortmico No es un problema de optimizacin, por lo tanto descarto el esquema voraz y ramificacin y poda, como nos piden que el coste sea logartmico y el problema se puede dividir en subproblemas ms pequeos utilizar el esquema de divide y vencers. ESQUEMA GENRICO.
funcin divide y vencers (problema) si suficientemente simple (problema) entonces devolver solucin simple (problema) sino hacer {p1 pk} descomponer (problema) para cada pi hacer si divide_y_vencers (pi) fpara devolver combinacin (s1, ..., sk) fsi ffuncin
Si el vector tiene un elemento mayoritario, este tiene que ser mayoritario en al menos una de las mitades del vector. Utilizando esta idea, podemos mirar de forma recursiva si existe un elemento mayoritario en cada una de las dos mitades del vector y si aparece en ms de la mitad de las posiciones, ser el elemento mayoritario buscado. El algoritmo que busca el mayoritario de V [ c.. f ] es el siguiente:
fun mayoritario (V [1..n ] de elemento, c, f : nat ) dev existe : bool, mayor : elemento si c = f entonces existe, mayor := cierto,V [ c ] sino m := ( c + f ) div2 existe1 , mayor1 := mayoritario (V,c,m ) existe2 , mayor2 := mayoritario (V,m+1, f ) existe := falso si existe1 entonces {comprobamos el primer candidato} existe, mayor := comprobar (V,mayor1 ,c, f ) ,mayor1 fsi si existe existe2 entonces {comprobamos el segundo candidato} existe, mayor := comprobar (V,mayor2 ,c, f ) ,mayor2 fsi fsi ffun
fun comprobar (V [1..n ] de elemento, x : elemento, c, f : nat ) dev valido : bool veces := 0 para i = c hasta f hacer si V [i ] = x entonces veces := veces +1 fsi fpara valido := veces > ( f - c +1) div2 ffun
Para calcular el coste podemos utilizar la siguiente recurrencia:

cn k , si 1 n b k n b
Tenemos a=2, b=2, k=1;

T ( n ) ( n log n )
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico mas eficiente para resolver el problema (0,5 puntos). 2. Demuestra que el problema se puede resolver con el esquema elegido (0,5 puntos). 3. Estructuras de datos (0,5 puntos). 4. Algoritmo completo a partir del refinamiento del esquema general (1,5 puntos). 5. Estudio del coste (1 punto).
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Septiembre 2000 Reserva
Cuestin 1. En el algoritmo quicksort, qu implicaciones tiene para la eficiencia el escoger como pivote la mediana exacta del vector?.
Cuestin 2. Los algoritmos de Prim y Kruskal calculan, de distintas formas, el rbol de expansin mnimo de un grafo. Cul de los dos es ms eficiente para un grafo con alta densidad de aristas?. Razonar la repuesta.
Cuestin 3. Explicar cmo funciona el algoritmo que dota a un vector de la propiedad de montculo en tiempo lineal (no es necesario demostrar que ese es el coste).
RESPUESTAS EXAMEN Programacin III. Septiembre 2000 Reserva Cuestin 1. En el algoritmo quicksort, qu implicaciones tiene para la eficiencia el escoger como pivote la mediana exacta del vector?.(Respuesta en: Fundamentos de Algoritmia, pag. 266). El algoritmo Quicksort tiene un tiempo promedio de ( nlogn ) . En la prctica es ms rpido que la ordenacin por montculo (heapsort) y la ordenacin por fusin (mergesort) en un tiempo constante. Al ser un algoritmo recursivo sera ideal poder dividir el caso en subcasos de tamaos similares de manera que cada elemento sea de profundidad logn , es decir, poder equilibrar los subcasos. Sin embargo, aunque seleccionemos la mediana del vector en el peor caso (todos los elementos a ordenar son iguales) el orden ser cuadrtico. Para obtener alguna ventaja utilizando como pivote la mediana tendremos que hacer algunas modificaciones al algoritmo original. Utilizaremos una nueva funcin pivote que divida en tres secciones el vector, de modo que dado un pivote p una parte conste de elementos menores que l, otra de elementos iguales y finalmente otra parte con los ms grandes que p. Tras hacer esto se haran las llamadas recursivas correspondientes al algoritmo, una para con el sub-vector de elementos menores que p, y otra para el de los mayores que p. Esta modificacin consigue que, utilizando la mediana como pivote el orden del algoritmo sea ( nlogn ) incluso en el peor caso. Pero el coste que implica esta modificacin hace que el tiempo constante crezca haciendo mejor el algoritmo de ordenacin por montculo que el Quicksort en todos los casos, lo que hace que la modificacin no sea factible. Cuestin 2. Los algoritmos de Prim y Kruskal calculan, de distintas formas, el rbol de expansin mnimo de un grafo. Cul de los dos es ms eficiente para un grafo con alta densidad de aristas?. Razonar la repuesta. (Respuesta en: Fundamentos de Algoritmia, pag. 223). alta el nmero de aristas a tiende a ser n(n-1)/2, con lo que el tiempo pasara a ( n 2logn ) , y el El algoritmo de Kruskal tiene un tiempo ( a log n ) , siendo a el nmero de aristas. Si la densidad es
algoritmo de Prim podra implementarse de forma que fuera mejor. En el caso de un grafo disperso (pocas aristas) el nmero de aristas tendera a n, siendo en este caso el tiempo ( nlogn ) , siendo mejor que algunas implementaciones del algoritmo de Prim. Pero si implementamos el algoritmo de Prim utilizando montculos el tiempo requerido ser de ( a log n ) (al igual que el algoritmo de Kruskal). Cuestin 3. Explicar cmo funciona el algoritmo que dota a un vector de la propiedad de montculo en tiempo lineal (no es necesario demostrar que ese es el coste). (Respuesta en: Fundamentos de Algoritmia, pag. 190) El algoritmo que convierte un vector en un montculo en tiempo lineal es:
Proc CrearMontculo (V[1...N]) Para i n/2 bajando hasta 1 hacer hundir(V,i) Fin_proc
Proc Hundir(V[1...n],i) k i Repetir jk Si 2j n y V[2j] > V[k] entonces k 2j fsi Si 2j < n y V[2j +1] > V[k] entonces k 2j + 1 fsi Intercambiar V[j] y V[k] hasta j = k Fin_proc
La idea es considerar el vector como un montculo, empezamos convirtiendo inicialmente en montculos los sub-rboles del nivel ms bajo, para progresivamente seguir modificando en niveles superiores sucesivos. Veamos su funcionamiento con un ejemplo V=[4,3,7,7,10,1] con n=6 Si consideramos este vector cmo un montculo tendremos... Ejecutaramos el algoritmo CrearMontculo
Para i 3 hasta 1 hundir(V,i) i = 3, hundir (V,3) k = 3, j = 3 no habra ningn cambio dado que V[6] < V[3] k=j fin del bucle i=2 hundir (V,2) k=2, j=2 Como V[4]>V[2] k = 4 Pero V[5]>V[2], k=5 intercambia V[5],V[2] V=[4,10,7,7,3,1] k=5 y j=5, termina el bucle. i=1 hundir (V,1) k=1, j=1 Resulta que V[2]>V[1] k=2 Y NO (V[3] > V[2]) Intercambia V[2],V[1] V=[10,4,7,7,3,1] k=2, j=2 Como V[4]>V[2] k = 4 Pero NO(V[3]>V[4]) as que k=4 Intercambia V[4],V[2] V=[10,7,7,4,3,1] k=3, j=3 NO(V[6]>V[4]) con lo que no hay cambio y termina el bucle. Hemos obtenido finalmente el montculo. Si dibujamos los vectores como montculos, observamos que el proceso es el descrito anteriormente, vamos al nivel ms bajo y obtenemos los montculos correspondientes. Y as sucesivamente hasta llegar a la raz. V=[4,3,7,7,10,1]
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2001 Primera semana
Cuestin 1. (1 punto). Dado el siguiente montculo: [10,6,3,5,2,3,2] se pide insertar el valor 6 describiendo toda la secuencia de cambios en el mismo. Cuestin 2. (2 puntos). Suponemos que para el juego del ajedrez hemos programado una funcin esttica perfecta de evaluacin eval(u) para cada situacin de juego u. Se supone conocida otra funcin, compleciones(u) que devuelve la lista de las jugadas legales a partir de la posicin del tablero u. Explica, incluyendo pseudocdigo si es preciso, como programar un algoritmo que juegue al ajedrez. Qu pasa si (como ocurre en la realidad) la funcin eval(u) no existe?Qu papel desempea entonces la estrategia MINIMAX? Cuestin 3. (2 puntos). Un vector T contiene n elementos. Se quieren encontrar los m mayores elementos del vector y se supone que n >>m. Describe una forma eficiente de hacer esto sin ordenar el vector y calcula qu coste tiene. PROBLEMA (5 puntos). A orillas del ro Guadalhorce, se encuentran 3 alumnos y 3 profesores del tribunal de la UNED que deben cruzar el ro para ir juntos al Centro Asociado. Se dispone de una pequea canoa de 2 plazas. Disear un algoritmo que encuentre una solucin al problema de cruzar el ro considerando las siguientes restricciones: La canoa no puede viajar sola. En ningn momento puede haber grupos en las orillas donde el nmero de alumnos supere al de los profesores.
Disear ahora el algoritmo para que calcule la solucin con menor nmero de movimientos. Explica los cambios que hay que hacer al anterior algoritmo.
RESPUESTAS EXAMEN Programacin III. Febrero 2001 (Primera Semana) Cuestin 1.Dado el siguiente montculo [10,6,3,5,2,3,2] se pide insertar el valor 6 describiendo toda la secuencia de cambios en el mismo. El algoritmo de insercin es el siguiente:
Proc aadir - nodo (T[1...n],v) T[n+1] v Flotar(T[1...n+1],n+1) Fproc
Proc Flotar(T[1...n],i) k i Repetir jk Si j > 1 y T[j/2] < T[k] entonces k j/2 Intercambiar T[j] y T[k] Hasta j = k Fproc
De este modo, dado el montculo [10,6,3,5,2,3,2], aadimos 6 al final [10,6,3,5,2,3,2,6] y procedemos a comparar y subir T[n+1] para cada sub-rbol hasta no tener que hacer ningn cambio. Veamos como ira cambiando: Se llamara a flotar (T[1...8],8). Se compara T[8] con su padre, que viene dado por T[8/2]=4, como es mayor se intercambiara resultando [10,6,3,6,2,3,2,5]. El valor de k queda actualizado a 4. Se vuelven a comparar T[4] y T[2], como son iguales no se hace nada y j queda igual que k, luego termina el bucle.
Cuestin 2. Suponemos que para el juego del ajedrez hemos programado una funcin esttica perfecta de evaluacin eval(u) para cada situacin de juego u. Se supone conocida otra funcin, compleciones (u) que devuelve la lista de las jugadas legales a partir de la posicin del tablero u. Explica, incluyendo pseudocdigo si es preciso, como programar un algoritmo que juegue al ajedrez. Qu pasa si (como ocurre en la realidad) la funcin eval(u) no existe?Qu papel desempea entonces la estrategia MINIMAX? (Respuesta: Fundamentos de Algoritmia, pag.355)
Gracias a la informacin perfecta suministrada por la funcin eval(u) podremos saber en cada momento cul es la mejor jugada posible. De este modo si jugaran por ejemplo las blancas dado un estado u, tomaramos como mejor movimiento el que maximice el valor de eval(u) (suponiendo que eval(u) nos devuelve el valor ms grande cuanto mejor sea la jugada para las blancas), sin importarnos qu decisin puedan tomar las negras tras nuestro movimiento, ya que eval(u) nos asegura que nuestro movimiento es el ms acertado. Sin embargo no existe una funcin eval(u) perfecta en el caso del ajedrez, deberemos entonces buscar una funcin eval aproximada con una relacin coste/precisin lo mejor posible. En este caso, eval(u) no nos confirma que el mejor movimiento considerado por ella sea en realidad el ms adecuado. Y es aqu donde entra la estrategia MINIMAX, considerando que si para las blancas ser la mejor jugada la marcada como mayor valor de eval(u), las negras ejecutarn aquella que minimice dicho valor. De este modo si queremos anticipar un nmero determinado de jugadas, tomaremos al anterior criterio, minimizar el valor de eval(u) paras las negras y maximizarlo paras las blancas.
Cuestin 3. Un vector T contiene n elementos. Se quieren encontrar los m mayores elementos del vector y se supone que n >>m. Describe una forma eficiente de hacer esto sin ordenar el vector y calcula qu coste tiene.
Podemos utilizar un enfoque similar a como hacemos en la ordenacin por fusin, pero en este caso iremos generando un sub-vector con aquellos elementos mayores que m. Dividimos por tanto el vector original de forma equilibrada y progresivamente, hasta llegar a un tamao base adecuado (lo suficientemente pequeo) para aplicar en el la bsqueda de todo elemento menor que m, cada vez que encontremos un elemento menor que m lo almacenaremos en un vector resultado, que posteriormente se fusionar con los encontrados en las distintas llamadas. Igualmente podemos utilizar otro algoritmo de Ordenacin pero sin ordenar el vector, si no almacenar en otro vector los ndices en el orden correspondiente, por ejemplo.
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2001 Segunda semana
Cuestin 1. (1 punto). Mostrar mediante un ejemplo que el algoritmo de Dijkstra no siempre encuentra el camino mnimo si existe una distancia negativa. Cuestin 2. (2 puntos). Poner un ejemplo de un vector de 10 elementos que suponga un ejemplo de caso peor para el algoritmo de ordenacin Quicksort. Ordenar el vector mediante este algoritmo detallando cada uno de los pasos. Cuestin 3. (2 puntos). Dado un montculo T[1...n] programar completamente en pseudocdigo una funcin recursiva flotar(T,i) para flotar el elemento de la posicin i del vector T. Explica como usar esta funcin para insertar un elemento en el montculo. PROBLEMA (5 puntos). Se tiene que organizar un torneo con n participantes (con n potencia de 2). Cada participante tiene que competir exactamente una vez con todos los posibles oponentes. Adems cada participante tiene que jugar exactamente 1 partido al da. Se pide construir un algoritmo que permita establecer al calendario del campeonato para que concluya en n-1 das. Sugerencia: dos grupos disjuntos de m jugadores pueden jugar entre ellos en m das mediante rotacin. Ejemplo: {a,b,c} contra {d,e,f} juegan: Da 1: ad, be y cf. Da 2: ae, bf, y cd. Y finalmente Da 3: af, bd y ce.
RESPUESTAS EXAMEN Programacin III. Febrero 2001 (Segunda Semana) Cuestin 1.Mostrar mediante un ejemplo que el algoritmo de Dijkstra no siempre encuentra el camino mnimo si existe una distancia negativa. (Respuesta: Fundamentos de Algoritmia pag. 224) El algoritmo de Dijkstra nos devuelve los caminos mnimos desde el origen, y su pseudo cdigo es: Probaremos este algoritmo para el siguiente grafo:
F Dijkstra (L[1...n,1..n]) : matriz [2...n] Matriz D[2...n] {Inicializacin} C {2,3,....n} Para i 2 hasta n hacer D[i] L[1,i] Finpara {Bucle voraz} Repetir n - 2 veces v algn elemento de C que minimiza D[v] C C \ {v} Para cada w C hacer D[w] min (D[w], D[v] + L[v,w]) Finpara FinRepite Finpara FFuncin
Observando el grafo apreciamos los caminos ms cortos desde 1 a cualquier nodo son: 1-2 con coste 2, 1-3 con coste 4, 1-3-5 con coste 9, 1-3-5-6 con coste 0 y 1-3-5-6-4 con coste 1, veremos si el algoritmo de Dijkstra nos devuelve esta solucin. Tenemos para cada paso y tras la inicializacin...
Distancias desde 1 Nodo Precedente
Nodo Seleccionado Nodo No Seleccionado
Paso Inicializa 1 2 3 4
2 2 2 2 2 2
3 4 4 4 4 4
4 3 3 3 3
5 9 9
6 0
2 1 1 1 1 1
3 1 1 1 1 1
4 1 2 2 2 6
5 1 1 1 3 3
6 1 1 1 1 5
{1} {1,2} {1,2,4} {1,2,4,3} {1,2,4,3,5}
{2,3,4,5,6} {3,4,5,6} {3,5,6} {5,6} {6}
Observamos como la solucin devuelta no es la correcta ya que los costes no son los mnimos, con lo que los caminos seran 1-2 (coste 2), 1-2-4 (coste 3) aqu est el fallo, porque una vez que se aade el nodo al conjunto S establece el camino mnimo y ya no puede modificarse como ocurre aqu, 1-3 (coste 4), 1-3-5(coste 9) y 1-3-5-6 (coste 0).
Cuestin 2. Poner un ejemplo de un vector de 10 elementos que suponga un ejemplo de caso peor para el algoritmo de ordenacin Quicksort. Ordenar el vector mediante este algoritmo detallando cada uno de los pasos. (Respuesta Fundamentos de Algoritmia, pag 261)
Tomaremos un vector con 10 elementos ya ordenados como peor caso. {1,2,3,4,5,6,7,8,9,10} El algoritmo Quicksort es...
Proc pivote(T[i...j],var L ) p T[i] k i ; L j +1 repetir k k +1 hasta que T[k] > p o k >= j fin_repite repetir L L 1 hasta que T[L] <= p fin_repite mientras k < L hacer Intercambiar T[k] y T[L] repetir k k +1 hasta que T[k] > p fin_repite repetir L L+1 hasta que T[L] <= p fin_repite fmientras intercambiar T[i] y T[L] Fin_proc
Proc quicksort(T[i...j]) Si j - i es suficientemente pequeo entonces insertar (T[i...j] ) Sino Pivote (T[i...j],L) Quicksort (T[i..L - 1]) Quicksort(T[L +1.. j]) Fsi Fin_proc
T[1..10]={1,2,3,4,5,6,7,8,9,10} Pivote(T[1..10], L) Luego i=1 y j=10 p=1, k=1, L=11 1. primer bucle, se mueve k hasta 2, ya que T[2]>p 2. segundo bucle, L llega hasta 1, ya que es el nico elemento tq T[L]<=p Llegamos al 3er bucle k=2 y L=1 (k>L), no existe por tanto intercambio alguno, excepto la ltima instruccin Intercambiar T[i] por T[L], como L apunta a 1, e i es uno T[L] queda igual. A continuacin se llamara a: Quicksort(T[1...0]), Llamada a un caso de tamao cero. Quicksort (T[2....10]). Llamamos al resto del vector. Ignoramos la primera llamada al ser de un tamao 0, la segunda llamada tendra el mismo efecto que la primera vez, en este caso en el procedimiento pivote L descendera hasta llegar al T[2], y k quedara en el tercer elemento; no se provoca cambio alguno, y vuelve a hacerse una tercera llamada a Quicksort, una de ellas para un caso de tamao 0: Quicksort(T[2..1]), y otra para el resto del vector, Quicksort(T[3...10]). Como vemos el proceso se repite hasta llegar al ltimo elemento, producindose tantas llamadas como elementos posee el vector.
Cuestin 3. Dado un montculo T[1...n] programar completamente en pseudocdigo una funcin recursiva flotar(T,i) para flotar el elemento de la posicin i del vector T. Explica como usar esta funcin para insertar un elemento en el montculo. (Respuesta. Fundamentos de Algoritmia, pag. 188) Tomar el algoritmo iterativo de la pag 188 y transformar en recursivo.
Proc Flotar ( i, T [1...n ]) ; i_padre := i div 2; Si ( i > 1) y T [i ] > T [i_padre ] entonces Intercambiar (T [i ] , T [i_padre ]) ; Flotar ( i_padre,T ) ; fFlotar;
Proc crear_monticulo (T [1..n ] ,i ) si i > n devuelve (T ) sino flotar (T , i ) crear_monticulo (T,i +1) fsi fproc
La llamada inicial ser crear _ monticulo (T , 2 ) . Otra versin pero en este caso sin usar funciones auxiliares es sustituir el cdigo de flotar por su versin iterativa e insertarlo en la funcin anterior. Para insertar un elemento en el montculo utilizo:
Proc aadir_nodo (T [1..n ] ,v ) T [ n+1] v; Flotar (T [1..n+1] ,n+1) ; FProc;
PROBLEMA (5 puntos). Se tiene que organizar un torneo con n participantes (con n potencia de 2). Cada participante tiene que competir exactamente una vez con todos los posibles oponentes. Adems cada participante tiene que jugar exactamente 1 partido al da. Se pide construir un algoritmo que permita establecer al calendario del campeonato para que concluya en n-1 das. Sugerencia: dos grupos disjuntos de m jugadores pueden jugar entre ellos en m das mediante rotacin. Ejemplo: {a,b,c} contra {d,e,f} juegan: Da 1: ad, be y cf. Da 2: ae, bf, y cd. Y finalmente Da 3: af, bd y ce.
Escuela Tecnica Superior de Ingenieros Informaticos de la UNED Ingenier a Tecnica de Sistemas e Ingenier a Tecnica de Gestion

Original Cuestion 1 (2 punto). Halla el grafo de expansion m nimo del grafo de la gura mediante Cuestion 2 (1 punto). Explica porque una estructura de mont culo suele ser adecuada
el algoritmo de Kruskal. Detalla cada paso. para representar el conjunto de candidatos en un algoritmo voraz. Cuestion 3 (1 punto). Explica en que consiste un problema de plani cacion con plazo jo. Pon un ejemplo con n = 4 y resuelvelo aplicando el algoritmo voraz correspondiente. de n las y m columnas con n m casillas y suponemos que el tablero descansa sobre uno de sus lados de tama~o m al que denominaremos base, y donde cada casilla puede contener n s mbolos de k tipos diferentes. Al comienzo del juego el usuario comienza con un tablero lleno de s mbolos. En cada movimiento el jugador elige un s mbolo del tablero y este es eliminado del mismo junto con (si las hay) las agrupaciones adyacentes (en horizontal o vertical) de su mismo s mbolo siempre que mantengan la continuidad. Una vez eliminada la agrupacion, los huecos dejados por esta se rellenan deslizando hacia la base los s mbolos de su columna que queden por encima del hueco dejado por los s mbolos eliminados. El objetivo del juego es el de dejar el tablero vac o. Para ilustrar el enunciado supongamos un tablero de 4 las y 5 columnas con 4 s mbolos o,+,*,x y donde - representa una casilla vac a. Una secuencia de juego ser a la siguiente:
oox+x o++x+ o**ox oo*xx --x+x --+x+ -+*ox -**xx ---+x ---x+ --xox -++xx -------+--xxx -++o+ -----------+-++o+ -----------+---o+ --------------++-----------------
Problema 2 (5 puntos). Se plantea el siguiente juego: Tenemos un rectangulo (tablero)
Se pide programar un algoritmo que resuelva el juego. Explicar ademas (si las hay) las diferencias que habr a que introducir a este algoritmo si se exigiera resolver el juego en el menor numero de movimientos.
La resolucion de cada problema debe incluir, por este orden: Eleccion razonada del esquema algor tmico. Breve descripcion del esquema usado e identi cacion con el problema. Estructuras de datos requeridas. Algoritmo completo a partir del re namiento del esquema general. Estudio del coste. Segun el esquema elegido hay que especi car, ademas: Voraz: demostracion de optimalidad. Divide y venceras: preorden bien fundado entre los ejemplares del problema. Exploracion en grafos: descripcion del grafo de busqueda asociado.
RESPUESTAS EXAMEN Programacin III. Septiembre 2001 (Original) Cuestin 1.Comenta de qu formas se puede mejorar la eficiencia del algoritmo de Dijkstra mediante el uso de estructuras de datos apropiadas. (Respuesta. Fundamentos de Algoritmia. Pag 227) Utilizando una matriz de adyacencia y matrices para representar los datos el algoritmo se sitan en ( n 2 ) (con un tiempo ( n ) para inicializar la matriz de adyacencia y un tiempo ( n 2 ) en los bucles que conforman el algoritmo voraz). Si resulta que el nmero de aristas a es mayor que el nmero de nodos al cuadrado, n 2 , resulta apropiado utilizar en vez de una matriz de adyacencia, una lista de adyacencia, evitando examinar entradas innecesarias -dnde no existe arista- , ahorrando as tiempo en el bucle ms interno del algoritmo. Por otro lado podemos utilizar un montculo invertido para representar el camino mnimo que se ir generando (que llamaremos D), esto hace que buscar un nodo que minimice el costo requiera slo eliminar la raz del montculo lo que conlleva un gasto de O(log n) , siendo la inicializacin del montculo ( n ) . Igualmente las operaciones empleadas en el bucle ms interno del algoritmo reducirn su coste (al ser D un montculo), situndose en O(log n) . Si se produce la eliminacin de la raz del montculo n-2 veces (el bucle se ejecuta n-2 veces) y hay que flotar un mximo de a nodos (siendo a el nmero de aristas) obtenemos un tiempo total de ((a + n) log n) . Si el grafo es conexo, es decir, a >= n - 1 el tiempo corresponde a (a log n) . Si el grafo es denso ser preferible la implementacin con matrices, si el grafo es disperso es mejor la implementacin con montculos. Cuestin 2. Explica porqu una estructura de montculo suele ser adecuada para representar el conjunto de candidatos de un algoritmo voraz. En un algoritmo voraz iremos eligiendo el candidato ms apropiado a cada paso para la hallar la solucin segn el valor de una funcin de seleccin. Para agilizar esa eleccin podemos tener dichos candidatos almacenados en un montculo, de forma que el valor considerado para su mantenimiento sea el valor de dicha funcin de seleccin. De este modo la eleccin de candidato consistir en ir escogiendo la cima de dicho montculo y actualizar este cuando as proceda, operaciones estas que resultan ms eficientes en los montculos que en otros tipos de estructura de datos. Cuestin 3. Explica en que consiste un problema de planificacin con plazo fijo. Pon un ejemplo con n=4 y resulvelo aplicando el algoritmo correspondiente. (Respuesta: Fundamentos de Algoritmia pag.233) Un problema de planificacin con plazo fijo consiste en: Dado un conjunto de n tareas, cada una de las cuales requiere un tiempo unitario, en cualquier instante T=1,2,... podemos ejecutar nicamente una tarea. Cada tarea nos producir un beneficio mayor que cero, slo en el caso en el que su ejecucin sea en un instante anterior a di. Habr que buscar la secuencia de tareas ms apropiada de manera que el beneficio obtenido sea mayor. (Bastara con aplicar el algoritmo que aparece en la pag. 240, ilustrado con un ejemplo para seis tareas, como se ve la solucin bastara con eliminar las tareas 5 y 6 y el resultado sera igual con lo que ya tenemos un ejemplo con n=4 i beneficio tiempo 1 20 3 2 15 1 3 10 1 4 7 3
Observar que tenemos las tareas ya ordenadas segn su beneficio de mayor a menor, si no fuera as para utilizar el algoritmo convendra proceder a esta ordenacin)
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Septiembre 2001 Reserva
Cuestin 1.Compara la eficiencia de los algoritmos de ordenacin Quicksort y Mergesort. Cuestin 2. Programa un algoritmo recursivo para implementar la operacin de hundir un elemento i en un montculo representado por el vector T[1...n] (Se supone que salvo por T[i], el vector T posee la propiedad del montculo). (Respuesta Fundamentos de Algoritmia, pag 188) Cuestin 3. En los algoritmos de vuelta atrs explica la diferencia entre una condicin de poda y una condicin de retroceso.
RESPUESTAS EXAMEN Programacin III. Septiembre 2001 (Reserva) Cuestin 1.Compara la eficiencia de los algoritmos de ordenacin Quicksort y Mergesort. El algoritmo Quicksort emplea un tiempo promedio de nlogn, en el peor caso de n2. El algoritmo por fusin Mergesort utiliza un tiempo de nlogn (siempre observando la precaucin de equilibrar los subcasos a tratar). Pese a esto, en la prctica Quicksort es ms rpido en un tiempo c constante. Adems el algoritmo Mergesort requiere de un espacio extra para tratar los distintos casos sin perder eficiencia (hacer la ordenacin in situ lleva asociado un incremento de la constante oculta bastante alto). Cuestin 2. Programa un algoritmo recursivo para implementar la operacin de hundir un elemento i en un montculo representado por el vector T[1...n] (Se supone que salvo por T[i], el vector T posee la propiedad del montculo). (Respuesta Fundamentos de Algoritmia, pag 188)
Proc crear_monticulo (V [1..n ] ,i ) si i < 1 devuelve (V ) sino hundir ( i,V ) crear_monticulo (V,i 1) fsi fproc
Proc Hundir(i, V[1...n]) k i Si 2i n y V[2i] > V[k] entonces k 2i fsi Si 2i n y V[2i +1] > V[k] entonces k 2i + 1 fsi Si k > i entonces Intercambiar (V[i] y V[k] ) hundir ( k , V ) Fin_proc
Proc Intercambiar(int j,k); var aux; aux := V[j]; V[j] := V[k]; V[k] := aux; Fproc Intercambiar;
Cuestin 3. En los algoritmos de vuelta atrs explica la diferencia entre una condicin de poda y una condicin de retroceso.
El algoritmo de vuelta atrs bsico consiste en una bsqueda exhaustiva en el rbol, si el recorrido del rbol no tiene xito porque la solucin parcial hasta ese momento no puede ser completada se produce un retroceso, igualmente si ya existiera una solucin mejor a la que est siendo actualmente calculado volveramos atrs. Si queremos limitar ms an nuestro espacio de bsqueda podemos utilizar condiciones de poda, dado un determinado problema intentamos encontrar informacin que nos permita decidir detener la bsqueda (volviendo consecuentemente atrs) si hay claros indicios de que el estado actual no nos conducir a una solucin.
En vuelta atrs no hay condicin de poda, slo comprobacin de que las soluciones parciales son k-prometedoras antes de continuar la exploracin del grafo. Lourdes Araujo.
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION
Programacin III Febrero 2002 Primera semana
Cuestin 1 (2 puntos). Describir la estrategia de seleccin voraz para el problema de la planificacin con un plazo fijo. Aplicarla a la resolucin del siguiente ejemplo detallado cada paso: Tarea i Instante di Beneficios gi 1 4 10 2 3 30 3 1 20 4 1 30 5 2 50 6 2 20
Cuestin 2 (1 puntos). Explica la diferencia entre una condicin de poda y una condicin de retroceso en el esquema de bsqueda vuelta atrs.
Cuestin 3 (2 puntos). Programar en pseudocdigo un algoritmo recursivo para la operacin de hundir un elemento en un montculo.
Problema (5 puntos). Una caja con n bombones se considera aburrida si se repite un mismo tipo de bombn (denominado bombn pesado) ms de n/2 veces. Programar en pseudocdigo un algoritmo que decida si una caja es aburrida y devuelva (en su caso) el tipo de bombn que le confirme dicha propiedad. El coste debe ser a lo sumo O(n log n). NOTA: Si una caja tiene un bombn pesado, entonces necesariamente tambin lo es al menos una de sus mitades. (Resuelto Universidad de Mlaga pag 121, y EDMA 331).
RESPUESTAS EXAMEN Programacin III. Febrero 2002 (Primera Semana) Cuestin 1 (2 puntos). Describir la estrategia de seleccin voraz para el problema de la planificacin con un plazo fijo. Aplicarla a la resolucin del siguiente ejemplo detallado cada paso: Tarea i Instante di Beneficios gi 1 4 10 2 3 30 3 1 20 4 1 30 5 2 50 6 2 20
Lo primero lo ordeno en funcin de los costes de forma decreciente. Tarea i Instante di Beneficios gi 5 2 50 2 3 30 4 1 30 3 1 20 6 2 20 1 4 10
p = min ( 6, 4 ) = 4
Aplico el algoritmo y calculo p = min ( 6, max ( d i ) )

Para d1 = 2 Se asigna la Tarea 5 en la posicin 2 Para d2 = 3 Se asigna la Tarea 2 en la posicin 3 Para d3 = 1 Se asigna la Tarea 4 en la posicin 1 Para d4 =1 No hay posiciones Libres Para d5 = 2 No hay posiciones Libres Para d6 = 4 Se asigna la Tarea 1 en la posicin 4
4 4
5 5 5 5
2 2 2 1
La secuencia ptima es 4,5,2,1. Con un valor de 120. Cuestin 2 (1 puntos). Explica la diferencia entre una condicin de poda y una condicin de retroceso en el esquema de bsqueda vuelta atrs. El algoritmo de vuelta atrs bsico consiste en una bsqueda exhaustiva en el rbol, si el recorrido del rbol no tiene xito porque la solucin parcial hasta ese momento no puede ser completada se produce un retroceso, igualmente si ya existiera una solucin mejor a la que est siendo actualmente calculado volveramos atrs. Si queremos limitar ms an nuestro espacio de bsqueda podemos utilizar condiciones de poda, dado un determinado problema intentamos encontrar informacin que nos permita decidir deterger la bsqueda (volviendo consecuentemente atrs) si hay claros indicios de que el estado actual no nos conducir a una solucin.
Cuestin 3 (2 puntos). Programar en pseudocdigo un algoritmo recursivo para la operacin de hundir un elemento en un montculo.
Proc Hundir(i, V[1...n]) k i Si 2i n y V[2i] > V[k] entonces k 2i fsi Si 2i n y V[2i +1] > V[k] entonces k 2i + 1 fsi Si k > i entonces Intercambiar (V[i] y V[k] ) hundir ( k , V ) Fin_proc
Problema (5 puntos). Una caja con n bombones se considera aburrida si se repite un mismo tipo de bombn (denominado bombn pesado) ms de n/2 veces. Programar en pseudocdigo un algoritmo que decida si una caja es aburrida y devuelva (en su caso) el tipo de bombn que le confirme dicha propiedad. El coste debe ser a lo sumo O(n log n). NOTA: Si una caja tiene un bombn pesado, entonces necesariamente tambin lo es al menos una de sus mitades. (Resuelto Universidad de Mlaga pag 121, y EDMA 331). 1. Eleccin razonada del esquema algortmico No es un problema de optimizacin, por lo tanto descarto el esquema voraz y ramificacin y poda, como nos piden que el coste sea logartmico y el problema se puede dividir en subproblemas ms pequeos utilizar el esquema de divide y vencers. ESQUEMA GENRICO.
funcin divide y vencers (problema) si suficientemente simple (problema) entonces devolver solucin simple (problema) sino hacer {p1 pk} descomponer (problema) para cada pi hacer si divide_y_vencers (pi) fpara devolver combinacin (s1, ..., sk) fsi ffuncin
Si el vector tiene un elemento mayoritario, este tiene que ser mayoritario en al menos una de las mitades del vector. Utilizando esta idea, podemos mirar de forma recursiva si existe un elemento mayoritario en cada una de las dos mitades del vector y si aparece en ms de la mitad de las posiciones, ser el elemento mayoritario buscado. El algoritmo que busca el mayoritario de V [ c.. f ] es el siguiente:
fun mayoritario (V [1..n ] de elemento, c, f : nat ) dev existe : bool, mayor : elemento si c = f entonces existe, mayor := cierto,V [ c ] sino m := ( c + f ) div2 existe1 , mayor1 := mayoritario (V,c,m ) existe2 , mayor2 := mayoritario (V,m+1, f ) existe := falso si existe1 entonces {comprobamos el primer candidato} existe, mayor := comprobar (V,mayor1 ,c, f ) ,mayor1 fsi si existe existe2 entonces {comprobamos el segundo candidato} existe, mayor := comprobar (V,mayor2 ,c, f ) ,mayor2 fsi fsi ffun
fun comprobar (V [1..n ] de elemento, x : elemento, c, f : nat ) dev valido : bool veces := 0 para i = c hasta f hacer si V [i ] = x entonces veces := veces +1 fsi fpara valido := veces > ( f - c +1) div2 ffun
Para calcular el coste podemos utilizar la siguiente recurrencia: cn k , si 1 n b k n b
Tenemos a=2, b=2, k=1;

T ( n ) ( n log n )
Escuela Universitaria de Informatica de la UNED Ingenier Tecnica de Sistemas e Ingenier Tecnica de Gestion a a
Programacin III - Febrero 2.002 - Segunda Semana o

Cuestin 1 (1 puntos). Escribe la secuencia completa de pasos para oro denar por fusin el vector [3,2,7,5,9,3,4,8]. o Cuestin 2 (1 punto). Un algoritmo de coste O(n2 ) tarda 15 segundos o en realizar un determinado procesamiento sobre un ordenador a 450 MHz. Cunto tiempo se tarda en realizar el mismo procesamiento con el mismo a algoritmo sobre una mquina 3 veces ms lenta? a a Cuestin 3 (3 puntos). Programar en pseudocdigo todos los proceo o dimientos necesarios para fusionar dos conjuntos implementados con mont culos. Suponer que los conjuntos no pueden tener elementos repetidos. Problema (5 puntos). Se dispone de un tablero de 8 casillas similar al que muestra la gura. En la situacin inicial, las casillas estn ocupadas por o a cuatro O y cuatro X distribuidas de forma aleatoria. En cada paso la unica operacin posible es intercambiar dos chas adyacentes. Programar de la o forma ms eciente posible el algoritmo que devuelva la secuencia de pasos a ms corta para ordenar el tablero de forma que todas las chas tengan al a menos otra igual adyacente. X O X X O O O X
La resolucin del problema debe incluir, por este orden: o 1. Eleccin razonada del esquema algor o tmico. 2. Descripcin del esquema usado e identicacin con el problema. o o 3. Estructuras de datos. 4. Algoritmo completo a partir del renamiento del esquema general. 5. Estudio del coste. Segn el esquema elegido hay que especicar, adems: u a Voraz: demostracin de optimalidad. o Divide y vencers: preorden bien fundado. a Exploracin en grafos: descripcin del rbol de bsqueda asociado. o o a u
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Septiembre 2002 Original Cuestin 1 (2 puntos). En el algoritmo de ordenacin por montculo (heapsort). Cules son las mejores y peores disposiciones iniciales de los ejemplos que hay que ordenar en cuanto al tiempo de ejecucin? Razonar la respuesta y poner ejemplos. Cuestin 2 (2 puntos). Aplicar el algoritmo de Dijkstra al grafo dirigido representado por la siguiente matriz adyacencia. 1 2 3 4 5 50 30 100 10 5 - -30 20 - 10 -
1 2 3 4 5
Tomando el nodo 1 como nodo origen. Encuentra los caminos mnimos? Si la respuesta es negativa Cules serian los caminos mnimos y porque no los encuentra el algoritmo de Dijkstra? Qu pasara si se invierte el sentido de la arista que une el nodo 3 con el 2?. Cuestin 3 (1 punto). De los algoritmos de ordenacin que has estudiado. Cul es el ms eficiente en trminos de coste asinttico temporal en el caso peor?. Razonar la respuesta. PROBLEMA (5 puntos). Escribir un algoritmo que descubra cmo encontrar el camino ms corto desde la entrada hasta la salida de un laberinto (suponer que hay slo una entrada y slo una salida)
RESPUESTAS EXAMEN Programacin III. Septiembre 2002(Original) Cuestin 1 (2 puntos). En el algoritmo de ordenacin por montculo (heapsort). Cules son las mejores y peores disposiciones iniciales de los ejemplos que hay que ordenar en cuanto al tiempo de ejecucin? Razonar la respuesta y poner ejemplos.
Cuestin 2 (2 puntos). Aplicar el algoritmo de Dijkstra al grafo dirigido representado por la siguiente matriz adyacencia. 10 1 1 2 3 4 5 2 3 4 5 50 30 100 10 5 20 -30 10 5 100 10 4 20 5 -30 3 1 50 30 2
Tomando el nodo 1 como nodo origen. Encuentra los caminos mnimos? Si la respuesta es negativa Cules serian los caminos mnimos y porque no los encuentra el algoritmo de Dijkstra? Qu pasara si se invierte el sentido de la arista que une el nodo 3 con el 2?.
Distancias desde 1 Nodo Precedente
PASO INICIO
Nodo Seleccionado Conjunto S
Nodo No Seleccionado Conjunto C
1 2 3
{1} {1,5} {1,5,4} {1,5,4,3}
{2,3,4,5} {2,3,4} {2,3} {2}
2 50 50 40 20
3 4 5 30 100 10 30 20 10 30 20 10 30 0 10
2 1 1 4 4
3 1 1 1 1
4 1 5 5 3
5 1 1 1 1
El fallo est en el camino 1-5-4 que tiene como resultado 20, pero resulta no ser un camino mnimo al haber el camino 1-3-4 de valor 0. Se supone que una vez que se aade un nodo al conjunto S no se puede modificar la distancia.
Cuestin 3 (1 punto). De los algoritmos de ordenacin que has estudiado. Cul es el ms eficiente en trminos de coste asinttico temporal en el caso peor?. Razonar la respuesta. Quicksort: Mergesort: Montculo:
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Diciembre 2002 Original Cuestin 1 (2 puntos). Dado un vector T [1..n ] que alberga un montculo en T [1..i ] , programar una funcin recursiva que flote el elemento i + 1 . Cuestin 2 (2 puntos). siguiente algoritmo: Calcular la ecuacin de recurrencia y hallar el coste del
Procedimiento P(n){ var i, j : enteros; j 1; si n 1 entonces terminar; sino { para i 1 hasta 7 hacer P ( n div 2 ) para i 1 hasta 4n 3 hacer j j + 1;
} }
Cuestin 3 (2 puntos). Ordenar ascendentemente mediante el algoritmo de Quicksort el vector V = [2,3,8,1,9,4,2,2,6,5,4,3,7,4] detallando todos los pasos. PROBLEMA (5 puntos). Se tienen dos polinomios de grado n representados por dos vectores [ 0..n ] de enteros, siendo la posicin i de ambos vectores la correspondiente al termino x del polinomio. Se pide disear un algoritmo que multiplique ambos polinomios, valorndose especialmente que sea con un coste ms eficiente que ( n 2 ) , en concreto hay una solucin fcil de hallar con coste nlog2 3 .
RESPUESTAS EXAMEN Programacin III. Diciembre 2002 Cuestin 1 (2 puntos). Dado un vector T [1..n ] que alberga un montculo en T [1..i ] , programar una funcin recursiva que flote el elemento i + 1 .
Llamada inicial
(T,i+1)
Cuestin 2 (2 puntos). Calcular la ecuacin de recurrencia y hallar el coste del siguiente algoritmo:
Procedimiento P(n){ var i, j : enteros; j 1; si n 1 entonces terminar; sino { para i 1 hasta 7 hacer P ( n div 2 ) para i 1 hasta 4n 3 hacer j j + 1;
cn k , si 1 n b k
} }
El primer para es: Una asignacin y 7 llamadas recursivas a = 7. El problema se llama recursivamente con ejemplares de tamao n/2, ( b = 2). El segundo para ser: desde 1 hasta 4n3. Por lo que el grado k del polinomio ser 3 ( k = 3 ). La ecuacin de recurrencia quedara: a = 7, b = 2, k = 3.
Autor: MIGUEL RODRIGUEZ ARTACHO
(n
7 veces p(n/2) y luego un proceso de coste 4n^3 a=7, b=2 y k=3
OK
Cuestin 3 (2 puntos). Ordenar ascendentemente mediante el algoritmo de Quicksort el vector V=[2,3,8,1,9,4,2,2,6,5,4,3,7,4] detallando todos los pasos.
Pivote 2 2 2 2 2 1 1 1 1 1 1 3 3 3 3 1 2 2 2 2 2 2 8 4 4 4 4 4 2 2 2 2 2 1 1 1 1 3 3 3 2 2 2 2 9 9 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 3 3 3 2 2 2 2 2 2 2 3 4 4 4 2 2 2 2 2 2 4 4 4 4 4 6 6 6 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 4 4 4 6 6 6 6 6 6 6 6 3 3 9 9 9 9 9 9 9 7 7 7 7 7 7 7 7 7 7 7 9 8 4 8 8 8 8 8 8 8 8 8 9
PROBLEMA (5 puntos). Se tienen dos polinomios de grado n representados por dos vectores [ 0..n ]
de enteros, siendo la posicin i de ambos vectores la correspondiente al termino x del polinomio. Se pide disear un algoritmo que multiplique ambos polinomios, valorndose especialmente que sea con un coste ms eficiente que ( n 2 ) , en concreto hay una solucin fcil de hallar con coste nlog2 3 .
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. 2. Descripcin del esquema usado e identificacin con el problema. 3. Estructuras de datos. 4. Algoritmo completo a partir del refinamiento del esquema general. 5. Estudio del coste. Segn el esquema elegido hay que especificar, adems: Voraz: demostracin de Optimalidad. Divide y vencers: preorden bien fundado. Exploracin en grafos: descripcin del rbol de bsqueda asociado.
Programacin III Febrero 2003 Primera semana Cuestin 1 (2 puntos). Para qu se pueden utilizar montculos en el algoritmo de Kruskal? Qu mejoras introduce en trminos de complejidad?
Cuestin 2 (1 puntos). Dado el grafo de la figura, aplicar el algoritmo de Dijkstra para hallar los caminos ms cortos desde el nodo 1 hasta cada uno de los otros nodos, indicando en cada paso: nodos seleccionados, nodos no seleccionados, vector de distancias y vector de nodos precedentes.
Distancias desde 1
PASO Nodo Seleccionado Nodo No Seleccionado
Nodo Precedente 2 3 4 5
INICIO 1 2 3
Cuestin 3 (2 puntos). Se desea implementar una funcin para desencriptar un mensaje numrico. La funcin desencriptar recibe tres enteros: el mensaje cifrado c, la clave privada s y la clave pblica z; y devuelve el mensaje original a. El mensaje original se recompone con la frmula: Problema (5 puntos). Teseo se adentra en el laberinto en busca de un minotauro que no sabe dnde est. Se trata de implementar una funcin ariadna que le ayude a encontrar el minotauro y a salir despus del laberinto. El laberinto debe representarse como una matriz de entrada a la funcin cuyas casillas contienen uno de los siguientes tres valores: 0 para camino libre, 1 para pared (no se puede ocupar) y 2 para minotauro. Teseo sale de la casilla (1,1) y debe encontrar la casilla ocupada por el minotauro. En cada punto, Teseo puede tomar la direccin Norte, Sur, Este u Oeste siempre que no haya una pared. La funcin ariadna debe devolver la secuencia de casillas que componen el camino de regreso desde la casilla ocupada por el minotauro hasta la casilla (1,1).
RESPUESTAS EXAMEN Programacin III. Febrero 2003 (Primera Semana)

Cuestin 1 (2 puntos). Para qu se pueden utilizar montculos en el algoritmo de Kruskal? Qu mejoras introduce en trminos de complejidad? (Respuesta. Fundamentos de Algo. Pag 220 y 223) Para tener en la raz del montculo la arista ms corta. Esto permite efectuar una inicializacin en un tiempo ( a ) . Esto es ventajoso si se encuentra el rbol de recubrimiento mnimo en un momento que quede por probar un nmero considerable de aristas. El algoritmo original perdera bastante tiempo ordenando aristas intiles. Esta en ( a log n ) , a es el nmero de aristas.
Si es un grafo denso a tiende a n ( n 1) / 2 y necesita un tiempo n 2 log n . Si es un grafo disperso a tiende a n y necesita un tiempo ( n log n ) . Utilizando montculos necesita un tiempo ( a log n ) . Cuestin 2 (1 puntos). Dado el grafo de la figura, aplicar el algoritmo de Dijkstra para hallar los caminos ms cortos desde el nodo 1 hasta cada uno de los otros nodos, indicando en cada paso: nodos seleccionados, nodos no seleccionados, vector de distancias y vector de nodos precedentes.
Distancias desde 1
Nodo Precedente 2 1 1 1 3 3 1 4 4 4 4 1 1 1 1 5 1 1 1 1
2 20 20 20 19
INICIO 1 2 3
{1} {1,4} {1,4, 5} {1,4,5,3}
{2,3,4,5} {2,3,5} {2,3} {2}
12 12 12
4 5 5 5 5
5 7 7 7 7
Cuestin 3 (2 puntos). Se desea implementar una funcin para desencriptar un mensaje numrico. La funcin desencriptar recibe tres enteros: el mensaje cifrado c, la clave privada s y la clave pblica z; y devuelve el mensaje original a. El mensaje original se recompone con la frmula:
a := c s mod z
Sabiendo que no se dispone del operador de potencia, implementar la funcin utilizando el esquema divide y vencers. a) expoDV en Brassard, pgina 276.
desencriptar (c, s, z : entero){ devolver expoDV(c,s) mod z si ( s = 1) entonces dev c si ( s es par ) entonces dev expoDV ( c,s 2 ) sino dev c expoDV ( c, s - 1) }
2
b) implementarlo como expomod, Brassard, pgina 279. funcion desencriptar ( c,s,z )
{Calculamos c
mod z}
mientras ( i > 0 ) hacer si ( i es impar ) entonces r x mod z x x 2 mod z i i 2 devolver r
Problema (5 puntos). Teseo se adentra en el laberinto en busca de un minotauro que no sabe dnde est. Se trata de implementar una funcin ariadna que le ayude a encontrar el minotauro y a salir despus del laberinto. El laberinto debe representarse como una matriz de entrada a la funcin cuyas casillas contienen uno de los siguientes tres valores: 0 para camino libre, 1 para pared (no se puede ocupar) y 2 para minotauro. Teseo sale de la casilla (1,1) y debe encontrar la casilla ocupada por el minotauro. En cada punto, Teseo puede tomar la direccin Norte, Sur, Este u Oeste siempre que no haya una pared. La funcin ariadna debe devolver la secuencia de casillas que componen el camino de regreso desde la casilla ocupada por el minotauro hasta la casilla (1,1). Solucin: 5.1 Eleccin razonada del esquema algortmico Como no se indica nada al respecto de la distancia entre casillas adyacentes, y ya que se sugiere utilizar nicamente una matriz, es lcito suponer que la distancia entre casillas adyacentes es siempre la misma (1, sin prdida de generalidad). Por otra parte, no se exige hallar el camino ms corto entre la entrada y el minotauro, sino que el enunciado sugiere, en todo caso, que el algoritmo tarde lo menos posible en dar una de las posibles soluciones (y ayudar a salir a Teseo cuanto antes). Tras estas consideraciones previas ya es posible elegir el esquema algortmico ms adecuado. El tablero puede verse como un grafo en el que los nodos son las casillas y en el que como mximo surgen cuatro aristas (N, S, E, O). Todas las aristas tienen el mismo valor asociado (por ejemplo, 1). En primer lugar, el algoritmo de Dijkstra queda descartado. No se pide el camino ms corto y si se hiciera, las particularidades del problema hacen que el camino ms corto coincida con el camino de menos nodos y, por tanto, una exploracin en anchura tendr un coste menor siempre que no se visiten nodos ya explorados, como mucho se recorrer todo el tablero una vez (coste lineal con respecto al nmero de nodos versus coste cuadrtico para Dijkstra). En segundo lugar, es previsible esperar que el minotauro no est cerca de la entrada (estar en un nivel profundo del rbol de bsqueda) por lo que los posibles caminos solucin sern largos. Como no es necesario encontrar el camino ms corto, sino encontrar un camino lo antes posible,
una bsqueda en profundidad resulta ms adecuada que una bsqueda en anchura. En el peor de los casos en ambas habr que recorrer todo el tablero una vez, pero ya que buscamos un nodo profundo, se puede esperar que en media una bsqueda en profundidad requiera explorar menos nodos que una bsqueda en anchura. Si se supone que el laberinto es infinito entonces una bsqueda en profundidad no sera adecuada porque no garantiza que se pueda encontrar una solucin. En este enunciado se puede presuponer que el laberinto es finito. En tercer lugar, es posible que una casilla no tenga salida por lo que es necesario habilitar un mecanismo de retroceso. Por ltimo, es necesario que no se exploren por segunda vez casillas ya exploradas anteriormente. Por estos motivos, se ha elegido el esquema de vuelta atrs. 5.2. Descripcin del esquema usado
Vamos a utilizar el esquema de vuelta atrs modificado para que la bsqueda se detenga en la primera solucin y para que devuelva la secuencia de ensayos que han llevado a la solucin en orden inverso (es decir, la secuencia de casillas desde el minotauro hasta la salida). fun vuelta-atrs (ensayo) dev (es_solucin, solucin) si vlido (ensayo) entonces solucin crear_lista(); solucin aadir (solucin, ensayo); devolver (verdadero, solucin); si no hijos crear_lista(); hijos compleciones (ensayo) es_solucion falso; mientras es_solucin vacia (hijos) hijo primero (hijos) si cumple_poda (hijo) entonces (es_solucin, solucin) vuelta-atrs(hijo) fsi fmientras si es_solucin entonces solucin aadir (solucin, ensayo); fsi devolver (es_solucin, solucin); fsi ffun
5.3 Estructuras de datos Para almacenar las casillas bastar un registro de dos enteros x e y. Vamos a utilizar una lista de casillas para almacenar la solucin y otra para las compleciones. Para llevar control de los nodos visitados bastar una matriz de igual tamao que el laberinto pero de valores booleanos. Ser necesario implementar las funciones de lista: crear_lista vacia aadir primero 5.4 Algoritmo completo Suponemos laberinto inicializado con la configuracin del laberinto y visitados inicializado con todas las posiciones a falso. tipoCasilla = registro x,y: entero; fregistro tipoLista fun vuelta-atrs ( laberinto: vector [1..LARGO, 1..ANCHO] de entero; casilla: tipoCasilla visitados: vector [1..LARGO, 1..ANCHO] de booleano; ) dev (es_solucin: booleano; solucin: tipoLista) visitados [casilla.x, casilla.y] verdadero; si laberinto[casilla.x, casilla.y] == 2 entonces solucin crear_lista(); solucin aadir (solucin, casilla); devolver (verdadero, solucin); si no hijos crear_lista(); hijos compleciones (laberinto, casilla) es_solucin falso; mientras es_solucin vacia (hijos) hijo primero (hijos) si visitados [hijo.x, hijo.y] entonces (es_solucin, solucin) vuelta-atrs (laberinto,hijo,visitados); fsi fmientras si es_solucin entonces solucin aadir (solucin, casilla); fsi devolver (es_solucin, casilla); fsi
ffun
En el caso de encontrar al minotauro se detiene la exploracin en profundidad y al deshacer las llamadas recursivas se van aadiendo a la solucin las casillas que se han recorrido. Como se aaden al final de la lista, la primera ser la del minotauro y la ltima la casilla (1,1), tal como peda el enunciado. La funcin compleciones comprobar que la casilla no es una pared y que no est fuera del laberinto fun compleciones ( laberinto: vector [1..LARGO, 1..ANCHO] de entero; casilla: tipoCasilla) dev tipoLista hijos crear_lista(); si casilla.x+1 <= LARGO entonces si laberinto[casilla.x+1,casilla.y] <> 1 entonces casilla_aux.x=casilla.x+1; casilla_aux.y=casilla.y; hijos aadir (solucin, casilla_aux); fsi fsi si casilla.x-1 >= 1 entonces si laberinto[casilla.x-1,casilla.y] <> 1 entonces casilla_aux.x=casilla.x-1; casilla_aux.y=casilla.y; hijos aadir (solucin, casilla_aux); fsi fsi si casilla.y+1 <= ANCHO entonces si laberinto[casilla.x,casilla.y+1] <> 1 entonces casilla_aux.x=casilla.x; casilla_aux.y=casilla.y+1; hijos aadir (solucin, casilla_aux); fsi fsi si casilla.y-1 >= 1 entonces si laberinto[casilla.x,casilla.y-1] <> 1 entonces casilla_aux.x=casilla.x; casilla_aux.y=casilla.y-1; hijos aadir (solucin, casilla_aux); fsi fsi ffun 5.5 Estudio del coste Todas las operaciones son constantes salvo la llamada recursiva a vuelta-atrs. En cada nivel, pueden realizarse hasta 4 llamadas. Sin embargo, las llamadas no se realizan si la casilla ya ha sido visitada. Esto quiere decir que, en el caso peor, slo se visitar una vez cada casilla. Como las operaciones para una casilla son de complejidad constante, la complejidad ser O(ANCHO*LARGO), lineal con respecto al nmero de casillas.
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2003 Segunda semana Cuestin 1 (2 puntos). Explica cmo pueden ordenarse n valores enteros positivos en tiempo lineal, sabiendo que el rango de dichos valores es limitado. Explica las ventajas e inconvenientes de este mtodo
Cuestin 2 (1 punto). Puede un grafo tener dos rboles de recubrimiento mnimo diferentes? En caso afirmativo poner un ejemplo. En caso negativo justificar la respuesta.
Cuestin 3 (3 puntos). Aplicar el algoritmo de planificacin con plazo fijo para las actividades ai maximizando el beneficio gi en el plazo di. Detallar todos los pasos con claridad. Tarea ai Beneficios gi Instante di 1 20 4 2 10 5 3 7 1 4 15 1 5 25 2 6 15 3 7 5 1 8 30 2
PROBLEMA (5 puntos). Se pide disear completamente un algoritmo que calcule en tiempo logartmico el valor de f n de la sucesin definida como f n = af n-1 +bf n-2 con f0 = 0 y f1 = 1. Sugerencia: Pudiera ser de utilidad razonar el problema utilizando la siguiente igualdad entre matrices:
a b f n 1 f n 1 0 f = f n 2 n 1
RESPUESTAS EXAMEN Programacin III. Febrero 2003 (Segunda Semana)
Cuestin 1 (2 puntos). Explica cmo pueden ordenarse n valores enteros positivos en tiempo lineal, sabiendo que el rango de dichos valores es limitado. Explica las ventajas e inconvenientes de este mtodo. (Pgina 79 Brassard) Suponiendo que el rango de los valores a ordenar es limitado, es decir, sabemos que por ejemplo el rango de nmeros a ordenar va de 0 a 2000, podemos generar un vector de 2000 elementos de tipo entero que almacenar almacenar el nmero de ocurrencias de cada valor de la lista a ordenar en la posicin del vector correspondiente. 1- El vector esta inicializado a 0 (O(n)). 2- Recorremos la lista de valores a ordenar (O(n)). a. Por cada valor i extrado de la lista, incrementamos el valor de la posicin i del vector. 3- Recorremos el vector generado mostrando los valores generados en el paso anterior (2) y omitiendo aquellas posiciones del vector que contengan un 0.
Cuestin 2 (1 punto). Puede un grafo tener dos rboles de recubrimiento mnimo diferentes? En caso afirmativo poner un ejemplo. En caso negativo justificar la respuesta. (Pgina 215 Brassard) Si. Siendo G=(N,A) un grafo conexo no dirigido en donde N es el conjunto de nodos y A es el conjunto de aristas. Suponiendo que cada arista posee una longitud no negativa. Encontrar un rbol de recubrimiento mnimo consiste en hallar un subconjunto T de las aristas de G tal que utilizando solamente las aristas de T, todos los nodos deben quedar conectados, y adems la suma de las longitudes de las aristas de T debe ser tan pequea como sea posible.
Cuestin 3 (3 puntos). Aplicar el algoritmo de planificacin con plazo fijo para las actividades ai maximizando el beneficio gi en el plazo di. Detallar todos los pasos con claridad. Tarea ai Beneficios gi Instante di 1 20 4 2 10 5 3 7 1 4 15 1 5 25 2 6 15 3 7 5 1 8 30 2
Inicialmente procederemos a ordenar la matriz de costes y plazos de mayor a menor en funcin de los costes. Una vez realizado este paso, procederemos a aplicar el algoritmo rpido (pginas 237-241 Brassard) de planificacin con plazo fijo.
Resultado de la ordenacin: i Tarea ai Beneficios gi Instante di 1 8 30 2 2 5 25 2 3 1 20 4 4 4 15 1 5 6 15 3 6 2 10 5 7 3 7 1 8 7 5 1
i=2, d[2]=2. Seleccionamos K(1)

0 0,1,2 3 3 4 4 5 5 1 2 2 1 3 0 4 0 5 0 j[]

0 0,1,2 3 3,4 5 5 1 2 2 1 3 0 4 3 5 0 j[]
i=4, d[4]=1. Tarea rechazada i=5, d[5]=3. Seleccionamos K(3)

0 0,1,2,3,4 5 5 1 2 2 1 3 5 4 3 5 0 j[]

0 1 2 2 1 3 5 4 3 5 6 j[]
0,1,2,3,4,5
Resto de tareas rechazadas. Fin del Algoritmo. Orden de ejecucin de las tareas: a5, a8, a6, a1, a2. (Pgina 237-241 Brassard)
Problema (5 Puntos)
Se pide disear completamente un algoritmo que calcule en tiempo logertmico el valor de fn de la sucesin definida como fn=afn-1+bfn-2 con f0=0 y f1=1. Sugerencia: Pudiera ser de utilidad razonar el problema utilizando la siguiente igualdad entre matrices:
a b f n1 f n 1 0 f = f n2 n1
Solucin
La solucin trivial se basa en resolver recursivamente el caso n resolviendo los n trminos anteriores, lo cual supondra un coste lineal que no es lo que nos piden en el enunciado del problema. Planteamiento a b Si llamamos F a la matriz 1 0 , vamos a intentar encontrar una frmula que nos permita expresar la solucin del problema en funcin de los casos base que se proporcionan en el enunciado que son f0=0 y f1=1.
fn f = F n1 f f n1 n2 f n1 f n2 f f f f = F f n = F 2 n2 = ..... = F n1 1 f f n2 n3 f n1 n3 0 .......................... f f2 = F 1 f f 1 0 Con esta simplificacin, es posible calcular el valor de fn con slo calcular Fn-1 y hacer una multiplicacin por el vector de casos base. La forma ms eficiente de calcular exponenciaciones es mediante la tcnica de divide y vencers, aplicada sobre:
F n = F ndiv 2 F n mod 2
n 2 F 2 si n es par = 2 n 1 2 F F si n es impar
Como puede observarse, reducimos el problema n a uno de n/2 que nos permite obtener una eficiencia de O(log n) frente a O(n) como ocurra si aplicbamos el algoritmo inicial.
Descripcin del Esquema Algortimico Para resolver el problema de elevar una matriz F a un determinado exponente utilizaremos la tcnica de divide y vencers aplicada a la frmula de potencia descrita en el apartado anterior.
El esquema algortmico de divide y vencers se basa en la idea de dividir un problema en varios subproblemas del mismo tipo cuya solucin ser combinada posteriormente para obtener la solucin al problema inicial.
Como en toda funcin que resuelva un problema recursivamente, existirn casos umbral para los cuales la solucin del problema pueda ser obtenida directamente mediante el uso de una sencilla funcin. En nuestro caso concreto: 1- Tamao umbral y solucin simple: En nuestro caso, para n=1 y n=0 existen soluciones triviales y, por tanto, nuestro tamao umbral lo podemos poner en n=1. 2- Descomposicin: Fn siempre lo vamos a descomponer en un nico subproblema Fn/2. En este caso, el algoritmo de divide y vencers realiza una reduccin en lugar de una descomposicin. 3- Combinacin: La funcin de combinacin en nuestro caso ser la que hemos desarrollado al final del apartado anterior.
Estructuras de Datos. En nuestro caso utilizaremos enteros y matrices de 2x2. Algoritmo Completo. Suponiendo que conocemos a, b, f0 y f1.
fun f(n:entero) dev entero F . caso
a b 1 0
n=0: dev f0 n=1: dev f1 verdadero: hacer S . s . exp_mat(F,n-1) S
f1 f 0
dev s[1] fcaso ffun fun exp_mat(M:vector[2,2]; n:entero) dev vector[2,2] si n <= 1 entonces dev solucion_simple(M,n) si no hacer p . n div 2 r . n mod 2 T . exp_mat(M,p) dev combinacion(T,r,M) fsi ffun fun combinacin (T:vector[2,2]; r:entero; M:vector[2,2]) dev vector[2,2] dev TT*Mr ffun Donde M1=M y M0=
1 0 0 1
fun solucion_simple (M:vector[2,2], n:entero) dev vector[2,2] si n=1 dev M si no dev fsi ffun
1 0 0 1
Estudio del Coste Funcin de recurrencia:

c n k si 1 = n 1
Resolucin de la funcin de recurrencia: k=0, b=2; a=1

n k si a b k
( )
De acuerdo a los valores extrados del caso particular de nuestra funcin, podemos concluir que la complejidad del problema solucionado ser de O(log n) como nos pedan en el enunciado. (Pginas 55-59 Esquemas Algortmicos: Enfoque Metodolgico y Problemas Resueltos. J. Gonzalo Arroyo y M. Rodrguez Artacho)
Programacin III
Cdigos de asignatura: Sistemas: 402048; Gestin: 41204UNIVERSIDAD NACIONAL DE EDUCACIN A DISTANCIA
Nacional Original Septiembre de 2003 Duracin: 2 horas Material permitido: NINGUNO

DNI: _______________________
Prueba Presencial
Apellidos: ___________________________________________________________________________________ Nombre: _____________________________________
Centro Asociado en el que entreg la prctica: _______________________
Cuestin 1 (2 puntos). Hallar el coste de los siguientes algoritmos, siendo h(n,r,k)O(n).
PROCEDIMIENTO uno(n,k:entero):entero; VAR i,r:entero; COMIENZO SI n<3 ENTONCES DEVOLVER(1); SINO COMIENZO r!uno(n DIV 3,k-1); r! r + uno(n DIV 3,k+1); DEVOLVER(r); FIN FIN
PROCEDIMIENTO dos(n,k:entero):entero; VAR i,r:entero; COMIENZO SI n<4 ENTONCES DEVOLVER(1); SINO COMIENZO r ! dos(n DIV 4,k-1); r ! r + dos(n DIV 4,k+1); PARA i! 1 HASTA n HACER COMIENZO r ! h(n,r,i) r ! r + h(n,r-1,i) FIN r ! r + dos(n DIV 4,k+2); DEVOLVER(r); FIN FIN
Cuestin 2 (2 puntos). Una matriz T contiene n elementos. Se desea encontrar los m elementos ms pequeos de T (con m<<n). Explicar cmo hacer esto de la manera ms eficiente. Cuestin 3 (1 puntos). Explicar de qu manera se puede implementar mediante un esquema voraz el conocido problema de la bsqueda del camino ms corto hacia la salida a un laberinto descrito por una matriz rectangular de casillas de tipos libre y ocupada, y otras dos de tipo entrada y salida. Compararlo en trminos de coste con otras soluciones. Problema (5 puntos). Una operadora de telecomunicaciones dispone de 10 nodos conectados todos entre s por una tupida red de conexiones punto a punto de fibra ptica. Cada conexin c(i,j) entre el nodo i y j ( Con i,j {1..10}) tiene un coste asignado que sigue la frmula c(i,j)= (i + j) MOD 8. La operadora quiere reducir gastos, para lo cual est planificando asegurar la conectividad de su red de nodos minimizando el coste. Disear un algoritmo que resuelva el problema (4 puntos) y aplicarlo a los datos del enunciado (1 punto).
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico 2. Descripcin del esquema usado e identificacin con el problema 3. Estructuras de datos 4. Algoritmo completo a partir del refinamiento del esquema general 5. Estudio del coste Segn el esquema elegido hay que especificar, adems: Voraz: demostracin de optimalidad Divide y Vencers: preorden bien fundado Exploracin en grafos: descripcin del rbol de bsqueda asociado
RESPUESTAS EXAMEN Programacin III. Septiembre 2003(Original) Cuestin 1 (2 puntos). Hallar el coste de los siguientes algoritmos, siendo h(n,r,k) O(n) .
PROCEDIMIENTO uno (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 3 ENTONCES DEVOLVER(1); SINO COMIENZO r uno (n DIV 3, k-1); r r + uno (n DIV 3, k+1); DEVOLVER (r); FIN FIN
PROCEDIMIENTO dos (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 4 ENTONCES DEVOLVER(1); SINO COMIENZO r dos (n DIV 4, k-1); r r + dos (n DIV 4, k+1); PARA i 1 HASTA n HACER COMIENZO r h (n,r,i); r r + h (n,r-1,i); FIN r r + b (n DIV 4, k+2); DEVOLVER (r); FIN FIN
El procedimiento uno tiene una instruccin condicional de coste constante. Dentro de la condicin tiene: o bien una instruccin constante, que no tenemos en cuenta para el clculo, o bien dos llamadas recursivas, ambas invocan la funcin con un tamao n/3. //En el segundo caso de la llamada recursiva hay otra instruccin simple aadida. La expresin queda T(n) = T(n/3) + T(n/3) + 1 lo que equivale a que T(n) = 2T(n/3) + c. Aplicando la resolucin genrica de las expresiones del tipo T(n) = aT(n/b)+cnk con k = 0, a=2 y b=3 queda que 2 > 30 y por tanto la funcin T(n) tiene un coste O n
log3 2
De forma anloga, el segundo algoritmo: est formado por una instruccin condicional de coste constante cuyo cuerpo incluye secuencialmente: (i) una llamada recursiva de tamao n/4, //(ii) una instruccin simple, (iii) otra llama recursiva de tamao n/4, (iv) un bucle en el que se repite n veces un clculo consistente en llamar dos veces a una funcin h(n; r; i) de coste lineal, /*ms una instruccin simple*/, y por ltimo (v) una instruccin simple /* que no tenemos en cuenta para el calculo*/ y otra llamada recursiva de tamao n/4. Sumando los trminos nos sale T(n) = T(n/4) +T(n/4)+n (2n) +T(n/4), lo que equivale a T(n) = 3T(n/4) + 2n2 Aplicando la resolucin genrica de las expresiones del tipo T(n) = aT(n/b) + cnk y siendo 3 < 42 el coste es O(n2). a = 3, b = 4, k = 2
cn k , si 1 n b k n b
Cuestin 2 (2 puntos). Una matriz T contiene n elementos. Se desea encontrar los m elementos ms pequeos de T (con m<<n). Explicar cmo hacer esto de la manera ms eficiente.
Un procedimiento parcial de ordenacin por seleccin nos da los m elementos ms pequeos con coste O(m n) . Una ordenacin eficiente sin embargo lo hara en O(n log n) . Si m n , el coste vendra a ser cuadrtico, lo cual nos hara desechar el procedimiento de seleccin, sin embargo con m << n el orden O(m n) se puede considerar lineal, y en este caso el algoritmo de seleccin puede ser ms eficiente.
Cuestin 3 (1 punto). Explicar de qu manera se puede implementar mediante un esquema voraz el conocido problema de la bsqueda del camino ms corto hacia la salida a un laberinto descrito por una matriz rectangular de casillas de tipos libre y ocupada, y otras dos de tipo entrada y salida. Compararlo en trminos de coste con otras soluciones. Cada casilla se asimila a un nodo. Casillas libres adyacentes tendran aristas dirigidas en ambas direcciones. El peso sera unitario para cada arista. Las casillas de tipo ocupada no tienen aristas origen ni destino. De esta forma, un algoritmo de Dijkstra puede hallar el camino ms corto de un nodo llegada a todos los dems, incluyendo el nodo salida. En trminos de coste, sin embargo es necesario tener en cuenta que si el laberinto es un cuadrado de lado n, el grafo tendr v = n 2 nodos y alrededor de a = 4n 2 aristas. En el anlisis de coste de la resolucin de Dijkstra si v (nmero de nodos del grafo) es lo suficientemente grande hace cierta la expresin a << v 2 y por tanto podemos aproximarnos al coste O((a + v) log v)
Problema (5 puntos). Una operadora de telecomunicaciones dispone de 10 nodos conectados todos entre s por una tupida red de conexiones punto a punto de fibra ptica. Cada conexin c(i,j) entre el nodo i y j ( Con i,j 0{1..10}) tiene un coste asignado que sigue la frmula c(i,j) = (i + j) MOD 8. La operadora quiere reducir gastos, para lo cual est planificando asegurar la conectividad de su red de nodos minimizando el coste. Disear un algoritmo que resuelva el problema (4 puntos) y aplicarlo a los datos del enunciado (1 punto). Se trata de un grafo no dirigido de 10 nodos n1 , n2 ,..., n10 con una matriz simtrica de costes:
1 2 3 4 5 6 7 8 9 10
1 3 4 5 6 7 0 1 2 3
2 3 5 6 7 0 1 2 3 4
3 4 5 7 0 1 2 3 4 5
4 5 6 7 1 2 3 4 5 6
5 6 7 0 1 3 4 5 6 7
6 7 0 1 2 3 5 6 7 0
7 0 1 2 3 4 5 7 0 1
8 1 2 3 4 5 6 7 1 2
9 2 3 4 5 6 7 0 1 3
10 3 4 5 6 7 0 1 2 3 -
Se trata de conseguir minimizar el coste de los enlaces asegurando nicamente la conectividad de la red. El enunciado describe un problema de optimizacin en el que se nos pide que el grafo sea conexo ("asegurar la conectividad de la red") y contenga un rbol de expansin mnimo ("que el coste sea mnimo"), ya que la conectividad se asegura no dejando subgrafos no conexos. Eleccin del esquema: Con las condiciones descritas podemos usar algoritmos que resuelvan el problema del rbol de expansin mnimo, dentro de la familia de los algoritmos voraces. Descripcin del esquema: Se elige cualquiera de los algoritmos expuestos en el temario Kruskal o Prim, por ejemplo ste ltimo.
funcin Prim(G : grafo) : T : conjunto de aristas T B 1 mientras B N hacer { buscar e = {u, v} de longitud minima tal que uB y v N \ B T T {e} B B {v} } dev T ffuncin
Hemos tomado 1 como nodo arbitrario. El conjunto B va a ir conteniendo los nodos del subgrafo ya conexo y el conjunto T ir teniendo en cada iteracin aquellas aristas del rbol de expansin mnimo que contiene los nodos de B. El conjunto de candidatos es B, la condicin de finalizacin es que B = N y la funcin de optimizacin es elegir aquella arista del subgrafo B que conecte con algn nodo de N\B con menor coste. Estructuras de datos: El grafo se representar mediante una matriz de costes. La estructura de datos tendr un mtodo que implementa el clculo de la distancia entre dos nodos. En el caso de esta implementacin la distancia entre dos nodos i y j es el valor de la matriz de distancias, y su coste O(1).
Algoritmo completo a partir del esquema general:

funcin Prim(G : grafo) : T : conjunto de aristas T B 1 para i 2 hasta n hacer masProximo[i] 1 distanciaMin[i] G : distancia[i; 1] repetir n 1 veces{ min para j 2 hasta n hacer { \* Selecciona la mejor arista entre B y N \ B * \ si (distanciaMin[j] 0) ^ (distanciaMin[j] < min) ent { distanciaMin[k] G : distancia(j; k) masProximo[j] k } } T T SfmasProximo[k]; kg \* Aade la arista * \ distanciaMin[k] 1 para j 2 hasta n hacer { si G : distancia(j; k) < distanciaMin[j] ent { distanciaMin[k] G : distancia(j; k) masProximo[j] k } } } dev T
Coste: El coste del algoritmo de Prim es O(n2), que puede mejorarse utilizando una representacin de montculos para el vector distanciaMin[] Optimalidad: El algoritmo de Prim encuentra la solucin ptima. Se puede demostrar por induccin sobre T que aadir la arista ms corta {e} que sale de T (Lema 6.3.1 del texto base) forma en T {e} un rbol de recubrimiento mnimo que contendr al final n-1 aristas y todos los nodos del grafo G. Aplicacin al problema: Tenemos los siguientes conjuntos inicialmente B = {1} y la arista mnima entre un nodo de B y otro de N\B es u = (1, 7) con valor 0. Los valores de B y la u elegida en cada momento evolucionan como sigue:
B = {1,7} u = (7; 9) Coste: 0 B = {1,7,9} u = (7; 2) Coste: 1 B = {1,2,7,9} u = (2; 6) Coste: 0 B = {1,2,6,7,9} u = (6; 10) Coste: 0 B = {1,2,6,7,9,10} u = (6; 3) Coste: 1 B = {1,2,3,6,7,9,10} u = (3; 5) Coste: 0 B = {1,2,3,5,6,7,9,10} u = (6; 3) Coste: 0 B = {1,2,3,5,6,7,8,9,10} u = (9; 8) Coste: 1 B = {1,2,3,4,5,6,7,8,9,10} u = (9; 8) Coste: 1
Coste del rbol de expansin mnimo: 4
Programacin III Septiembre 2003 Reserva
Cuestin 1 (2 puntos). Ordenar completamente el vector en orden no decreciente por el mtodo de Quicksort indicando claramente cual es el contenido del vector en cada paso.
Cuestin 2 (2 puntos). Con el criterio de tomar primero la moneda de mayor valor que sea menor o igual que el cambio que queda por devolver, existe un algoritmo voraz para el problema de devolver el cambio con el menor nmero de monedas en cualquier sistema monetario? Justifique su respuesta.
(Respuesta: Fundamentos de Algoritmia, pag. 211 y Esquemas algortmicos Pg. 12).
Cuestin 3 (1 puntos). Se puede aplicar el procedimiento de bsqueda binaria sobre rboles con estructura de montculo? Razonar la respuesta. (Respuesta: Fundamentos de Algoritmia, pag. 255, 179, 184).
Problema (5 puntos). Daniel se va de veraneo y tiene que decidir qu tesoros se lleva (el coche de hojalata, el madelman, el pauelo de Mara, etc). Su madre le ha dado una bolsa de Vb cm3 con la orden expresa de que no se puede llevar nada que no quepa en la bolsa. Daniel tiene N objetos candidatos. Cada objeto i ocupa un volumen Vi y tiene un valor sentimental Si para l. Se trata de llenar la bolsa, maximizando el valor sentimental de los objetos que contiene. Evidentemente, Daniel no est dispuesto a romper en pedazos sus tesoros.
RESPUESTAS EXAMEN Programacin III. Septiembre 2003 (Reserva) Cuestin 1 (2 puntos). Ordenar completamente el vector en orden no decreciente por el mtodo de Quicksort indicando claramente cual es el contenido del vector en cada paso. 3 4 5 1 3 7 6 2
Solucin:
Tomo como pivote el primer elemento.
3 3 3 1 1 1
4 2 2 2 2 2
5 5 3 3 3 3
1 1 1 3 3 3
3 3 5 5 5 4
7 7 7 7 4 5
6 6 6 6 6 6
2 4 4 4 7 7
Cuestin 2 (2 puntos). Con el criterio de tomar primero la moneda de mayor valor que sea menor o igual que el cambio que queda por devolver, existe un algoritmo voraz para el problema de devolver el cambio con el menor nmero de monedas en cualquier sistema monetario? Justifique su respuesta.
(Respuesta: Fundamentos de Algoritmia, pag. 211 y Esquemas algortmicos Pg. 12).
No. Para aplicar el esquema voraz, el problema ha de ser de optimizacin. Se debe distinguir un conjunto de candidatos y que la solucin pase por ir escogindolos o rechazndolos. La funcin de seleccin debe asegurar que la solucin alcanzada es la ptima. Si no, puede que hayamos confundido el problema con uno de exploracin de grafos. En el problema de las monedas, la solucin es ptima tomando el conjunto de monedas espaolas (cuando se utilizaban pesetas, no euros como ahora), es decir, C = {100, 25, 10 5 1}. Sin embargo, si tomamos las monedas inglesas en peniques C = {30,24,12,6,3,1}, para un cambio de 48 peniques, nuestro algoritmo nos dara un conjunto solucin S = {30,12,6}, pero la solucin ptima sera S = {24,24}.
Cuestin 3 (1 puntos). Se puede aplicar el procedimiento de bsqueda binaria sobre rboles con estructura de montculo? Razonar la respuesta. (Respuesta: Fundamentos de Algoritmia, pag. 255, 179, 184). No. El motivo es que la ordenacin de los nodos es distinta, a continuacin har una breve resea de cada uno: Procedimiento de bsqueda binaria: El vector tiene que estar ordenado totalmente, por orden no decreciente. Sea T [1..n ] una matriz ordenada por orden no decreciente, tenemos T [i ] T [ j ] , siempre que sea 1 i j n . Montculo: Es un rbol binario esencialmente completo, cada nodo incluye un elemento de informacin denominado valor del nodo y la propiedad de que el valor de cada nodo interno es mayor o igual que los valores de sus hijos. Esto se llama propiedad de montculo. Se dice que un rbol binario es esencialmente completo si todo nodo interno, con la posible excepcin de un nodo especial, tiene exactamente dos hijos. El nodo especial, si existe uno, est situado en el nivel 1 y posee un hijo izquierdo, pero no tiene hijo derecho.
Ejemplo de montculo: 10 7 9 4 7 5 2 2 1 6
Problema (5 puntos). Daniel se va de veraneo y tiene que decidir qu tesoros se lleva (el coche de hojalata, el madelman, el pauelo de Mara, etc). Su madre le ha dado una bolsa de Vb cm3 con la orden expresa de que no se puede llevar nada que no quepa en la bolsa. Daniel tiene N objetos candidatos. Cada objeto i ocupa un volumen Vi y tiene un valor sentimental Si para l. Se trata de llenar la bolsa, maximizando el valor sentimental de los objetos que contiene. Evidentemente, Daniel no est dispuesto a romper en pedazos sus tesoros.
1. Eleccin razonada del esquema algortmico mas eficiente para resolver el problema.
Se trata de un problema de optimizacin, por lo tanto descarto divide y vencers y vuelta atrs, ya que se exige en el enunciado que no se pueden romper los tesoros, tengo que descartar el esquema voraz ya que no se encuentra una funcin de seleccin que sea ptima para resolver el problema, se podra utilizar el esquema voraz en el casos que se pudieran trocear los tesoros, eligindolos por orden decreciente de vi/wi con un coste total de ( nlogn ) . Por lo tanto elijo para resolver este problema el esquema de
Ramificacin y Poda. 2. Estructuras de datos.
Montculo de mnimos
tipos nodo = reg sol[1..n]de 0..1 k:0..n peso, beneficio:real beneficio-opt:real {prioridad} freg ftipos
4. Algoritmo completo a partir del refinamiento del esquema general (1,5 puntos).
fun tesoros-rp(P[1..n], V[1..n]de real, M: real)dev (sol-mejor[1..n]de 0..1, beneficio-mejor:real) var X,Y: nodo,C:colapr[nodo] {generamos raz} X.k:=0; Y.peso :=0; Y.beneficio:=0; (Y.beneficio.opt,beneficio-mejor):= calculo-estimaciones(P, V, M, Y.k, Y.peso, Y.beneficio) C:= cp-vacia(); aadir(C,Y) mientras es-cp-vacia?(C)^(minimo(C).beneficio-opt beneficio-mejor) hacer Y:= maximo C); eliminar-max(C) X.k:=Y.k+1; X.sol:=Y.sol; {probamos a meter el objeto en la mochila} si Y.peso + [X.k] M entonces {es factible y, por tanto, las estimaciones coinciden con las de Y} {beneficio-opt(X) = beneficio-opt(Y) beneficio-mejor } X.sol[X.k]:=1; X.peso:= Y.peso + P[X.k] X.beneficio:= Y.beneficio + V[X.k]; X.beneficio-opt := Y.beneficio-opt si X.k = n entonces { beneficio(X) = beneficio-opt(X) beneficio-mejor } sol-mejor:=X.sol; beneficio-mejor:= X.beneficio sino aadir(C,X) {no se puede mejorar beneficio mejor} fsi fsi {probamos a no meter el objeto (siempre es factible)} (X.beneficio-opt, pes) := calculo-estimaciones (P, V, M, Y.k, Y.peso, Y.beneficio) si X.beneficio-opt beneficio-mejor entonces X.sol[X.k] := 0; X.peso := Y.peso X.beneficio := Y.beneficio si X.k = n enteonces sol-mejor := X.sol; beneficio-mejor := X.beneficio sino aadir(C,X) beneficio-mejor := max(beneficio-mejor, pes) fsi fsi fmientras ffun
fun calculo-estimaciones (P[1..n], V[1..n] de real, M: real, k: 0..n, peso, beneficio:real) dev (opt, pes: real) hueco := M-peso; pes := beneficio; opt := beneficio; j := k+1 mientras j n ^ P[j] hueco hacer {podemos coger el objeto j entero} hueco := hueco-P[j] opt := opt + V[j]; pes:= pes + V[j] j := j+1 ; fmientras si j n entonces {quedan objetos por probar} {fraccionamos el objeto j (solucion voraz)} opt := opt + (hueco/P[j]*V[j] {extendemos a una solucin en la versin 0/1} j := j+1 mientras j n ^ hueco > 0 hacer si P[j] hueco entonces hueco := hueco P[j] pes := pes + V[j] fsi j := j+1 fmientras fsi ffun
Estudio del coste.
Programacin III
Extraordinario Diciembre de 2003
Prueba Presencial
Duracin: 2 horas Material permitido: NINGUNO

DNI: _______________________
Apellidos: ___________________________________________________________________________________
Nombre: ______________________________ Centro donde entreg la prctica: ____________________ Especialidad: ____________
Cuestin 1 (2 puntos). Qu significa que el tiempo de ejecucin de un algoritmo est en el orden exacto de f(n)?. Demostrar que T(n)=52n+n2 est en el orden exacto de 2n. Cuestin 2 (2 punto). Qu diferencias hay entre un montculo y un rbol binario de bsqueda? Cuestin 3 (2 puntos). Cules son los casos mejor y peor para el algoritmo de ordenacin rpida (Quicksort)? Cul es el orden de complejidad en cada uno de ellos? Razona tu respuesta. Problema (4 puntos). Hoy es un da duro para el taller Sleepy. Llegan las vacaciones y a las 8:00 de la maana n clientes han pedido una revisin de su coche. Como siempre, todos necesitan que les devuelvan el coche en el menor tiempo posible. Cada coche necesita un tiempo de revisin ri y al mecnico le da lo mismo por cul empezar: sabe que en revisar todos los coches tardar lo mismo independientemente del orden que elija. Pero al jefe de taller no le da lo mismo, la satisfaccin de sus clientes es lo que importa: es mejor tener satisfechos al mayor nmero de ellos. Al fin y al cabo, la planificacin la hace l y, evidentemente, un cliente estar ms satisfecho cuanto menos tarden en devolverle el coche. Implementar un programa que decida el orden en el que revisar uno a uno los coches para maximizar la satisfaccin de los clientes de Sleepy.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico 2. Descripcin del esquema usado e identificacin con el problema 3. Estructuras de datos 4. Algoritmo completo a partir del refinamiento del esquema general 5. Estudio del coste
RESPUESTAS EXAMEN Programacin III. Diciembre 2003 Cuestin 1 (2 puntos). Qu significa que el tiempo de ejecucin de un algoritmo est en el orden exacto de f(n)?. Demostrar que T ( n ) = 5 2n + n 2 est en el orden exacto de 2n . Hace referencia a la notacin Theta, representada por , decimos que t ( n ) est en
( f ( n)) .
Theta de f ( n ) y lo denotamos como t ( n ) ( f ( n ) ) , si pertenece tanto a O ( f ( n ) ) como a
( f ( n )) = O ( f ( n )) ( f ( n))
REGLA DEL LMITE: 1. Si lim 2. Si lim 3. Si lim
f (n) 0 , entonces f ( n ) O ( g ( n ) ) pero f ( n ) ( g ( n ) ) g ( n)
f ( n) + , entonces f ( n ) ( g ( n ) ) g ( n)
f ( n) + , entonces f ( n ) ( g ( n ) ) pero f ( n ) ( g ( n ) ) g ( n)
2
f (n) f ( n) 5 2n log ( 2 ) + 2n 5 2n log ( 2 ) + 2 5 2n + n 2 = lim = lim = lim = lim = lim 2 n g ( n ) n g ( n ) n n n 2n 2n log ( 2 ) 2n log ( 2 ) lim 5 2n log ( 2 ) 2n log ( 2 )
3 3
=5
Por lo tanto:
f ( n ) ( g ( n ))
Cuestin 2 (2 puntos). Qu diferencias hay entre un montculo y un rbol binario de bsqueda? rbol binario de bsqueda: Un rbol binario es un rbol binario de bsqueda si el valor contenido en todos los nodos internos es mayor o igual que los valores contenidos en su hijo izquierdo o en cualquiera de los descendientes de ese hijo y menor o igual que los valores contenidos en su hijo derecho o cualquiera de los descendientes de ese hijo.
20
20 12 12 34 27 12 6 20 34
34 27
18 12 18
35
34 35
Montculo: Es un rbol binario esencialmente completo, cada nodo incluye un elemento de informacin denominado valor del nodo y la propiedad de que el valor de cada nodo interno es mayor o igual que los valores de sus hijos. Esto se llama propiedad de montculo. Se dice que un rbol binario es esencialmente completo si todo nodo interno, con la posible excepcin de un nodo especial, tiene exactamente dos hijos. El nodo especial, si existe uno, est situado en el nivel 1 y posee un hijo izquierdo, pero no tiene hijo derecho. Todas las hojas se encuentran en el nivel 0 bien estn en los niveles 0 y 1 y ninguna hoja del nivel 1 est a la izquierda de un nodo interno del mismo nivel.
Ejemplo de montculo: 10 7 9 4 7 5 2 2 1 6
Cuestin 3 (1 puntos). Cules son los casos mejor y peor para el algoritmo de ordenacin rpida (Quicksort)? Cual es el orden de complejidad en cada uno de ellos? Razona tu respuesta. Pgina 261.
Si la matriz que hay que ordenar se encuentra inicialmente en orden aleatorio, entonces es probable que la mayora de los subejemplares que haya que ordenar estn suficientemente bien equilibrados. En el caso peor si la matriz se encuentra ordenada implica una llamada recursiva a un caso de tamao cero y otra a un caso cuyo tamao slo se reduce en una unidad. Para el mejor caso el orden de complejidad es O ( nlogn ) . Para el peor caso el orden de complejidad es ( n 2 ) .
Problema (4 puntos). Hoy es un da duro para el taller Sleepy. Llegan las vacaciones y a las 8:00 de la maana n clientes han pedido una revisin de su coche. Como siempre, todos necesitan que les devuelvan el coche en el menor tiempo posible. Cada coche necesita un tiempo de revisin ri y al mecnico le da lo mismo por cul empezar: sabe que en revisar todos los coches tardar lo mismo independientemente del orden que elija. Pero al jefe de taller no le da lo mismo, la satisfaccin de sus clientes es lo que importa: es mejor tener satisfechos al mayor nmero de ellos. Al fin y al cabo, la planificacin la hace l y, evidentemente, un cliente estar ms satisfecho cuanto menos tarden en devolverle el coche. Implementar un programa que decida el orden en el que revisar uno a uno los coches para maximizar la satisfaccin de los clientes de Sleepy. Eleccin razonada del esquema algortmico ms eficiente para resolver el problema.
Se trata de un problema de optimizacin, por lo tanto descarto el esquema de divide y vencers, para este problema se puede encontrar una funcin de seleccin que lo resuelva, de esta manera descarto el esquema de ramificacin y poda, debemos elegir a los clientes por orden creciente de tiempo de finalizacin, este problema se corresponde con el problema de minimizacin del tiempo en el sistema.
Esquema general:
Estructuras de datos: Tres vectores de enteros, un vector booleano y la funcin auxiliar ordenar ndices. Algoritmo completo a partir del refinamiento del esquema general
fun taller (C[1..n]nat, D[1..n]nat) dev sol[1..n] bool var F[1..n]nat ; I[1..n]1..n ; para i=1 hasta n hacer F[i]:= C[i]+D[i]; sol[i]:= falso; fpara I:= ordenar-indices(F) sol[I[1]]:= cierto; final := F[I[1]]; para i=2 hasta n hacer si C[I[i]] final entonces sol[I[i]]:= cierto; final := F[I[i]]; fsi fpara ffun fun ordenar-indices(V[1..n])dev indice [1..n]1..n merge-indice(V,indice,1,n) ffun
Estudio del coste El bucle voraz es de complejidad lineal respecto al nmero de clientes y el orden de complejidad del algoritmo completo corresponde al de la ordenacin del vector de tiempos finales ( nlogn ) .
Cuestin 1 (2 puntos). Programar Una funcin potencia (n,m) que halle nm, Se supone que no existe la operacin potencia y que el coste de una operacin de multiplicacin es (1) , mediante divide y vencers con coste en ( log n ) . (Respuesta:
Cuestin 2 (1 puntos). Se tienen 4 productos infraccionables p1, p2, p3, p4 en cantidades ilimitadas cuyo beneficio es respectivamente 23, 12, 21, 11 y cuyos pesos son respectivamente 2,4,3,5 Kgs. Tenemos un camin que carga un mximo de 55 Kgs. El problema consiste en llenar un camin con la carga de mayor valor. Qu algoritmo nos permite resolver el problema? Aplicando al enunciado y detallarlo paso por paso.
Cuestin 3 (2 puntos). Resolver mediante el algoritmo de Kruskal el rbol de expansin mnimo del grafo definido por la siguiente matriz de adyacencias: 1 . . . . . 2 4 . . . . 3 5 6 . . . 4 3 . . 5 9 1 1 .
1 2 3 4 5
Problema (5 puntos). Se tiene una matriz de n x n cuyas casillas contienen valores del conjunto C = {rojo, verde, amarillo} excepto una que es blanco. El nico movimiento permitido consiste en que cada casilla de valor blanco puede intercambiarse por cualesquiera de sus adyacentes no diagonales. Una solucin es una tabla con una fila llena de valores iguales. Desarrollar un algoritmo que dada una matriz inicial averige cuantas soluciones se pueden encontrar aplicando movimientos permitidos a partir de aquella.
RESPUESTAS EXAMEN Programacin III. Febrero 2004 (Primera Semana) Cuestin 1 (2 puntos). Programar Una funcin potencia (n,m) que halle nm, Se supone que no existe la operacin potencia y que el coste de una operacin de multiplicacin es (1) , mediante divide y vencers con coste en ( log n ) . (Respuesta: Fundamentos de Algoritmia, pag. 276 y EDMA 342).
public int potencia(int x, int n){ if ( n == 0 ){ return 1; } else{ return x * potencia(x, n - 1); } }
cn k T (n) = k aT ( n b ) + cn
, si 0 n 1
( n k ) T ( n ) ( n k +1 ) n div b ) ( a
a = 1, b = 1, k = 0 T ( n ) n k T ( n ) ( n )
( )
Versin del Libro Estructura de datos y mtodos algortmicos

fun potencia (x: numero, n: nat) dev y: numero casos n=0 y:= 1 n=1 y:= x n>1 ^ par(n) {xn = x2(n div 2) = (xn div 2)2 } y:= potencia (x, n div 2); y:= y*y n>1 ^ impar(n) {xn = x2(n div 2)+1 = x(xn div 2)2 } y:= potencia (x, n div 2); y:= x(y*y) fcasos ffun
cn k T (n) = k aT ( n / b ) + cn ( n k ) T ( n ) ( n k log n ) log a n b
, si 1 n b k
a = 1, b = 2, k = 0 T ( n ) n k log n T ( n ) ( log n )
Cuestin 2 (2 puntos). Se tienen 4 productos infraccionables p1, p2, p3, p4 en cantidades ilimitadas cuyo beneficio es respectivamente 23, 12, 21, 11 y cuyos pesos son respectivamente 2,4,3,5 Kgs. Tenemos un camin que carga un mximo de 55 Kgs. El problema consiste en llenar un camin con la carga de mayor valor. Qu algoritmo nos permite resolver el problema? Aplicando al enunciado y detallarlo paso por paso.
wi vi
p1 p2 p3 p4 2 4 3 5 23 12 21 1
Ya que el enunciado impone que los productos sean infraccionables aplicar el algoritmo de Vuelta Atrs. Lo Primero que har ya que el algoritmo me permite ordenar los objetos en cualquier orden los ordenar por orden decreciente de su valor/peso ya que tras hacer varias comprobaciones con ms ejemplos funciona igual pero reduzco el tamao del rbol. Quedando de la siguiente manera: p1 2 23 11,5 p3 p2 3 4 21 12 7 3 p4 5 1 0,2
wi vi vi wi
Inicialmente la solucin parcial est vaca, el algoritmo de vuelta atrs explora el rbol como un recorrido en profundidad, construyendo nodos y soluciones parciales a medida que avanza. Har un pequeo grfico. Con la siguiente notacin: cada cuadro es un nodo, los nmeros a la izquierda del punto y coma son los pesos de los objetos y los de la derecha el valor de la carga, que es lo que pretendemos optimizar.
;0
2; 23
2,..,2; 598
2,..,2,3; 619
Inicio el recorrido en profundidad hasta que tengo 27 pesos con 2 que hace un total de 54, por esta rama ya no puedo continuar ya que me pasara del peso en una unidad 56 y me exigen 55, por lo tanto retrocedo al nodo anterior y sigo la bsqueda por la siguiente rama que se corresponde con 26 pesos con 2 y 1 peso con 3 que hacen un total de 55 Kg. tal como me piden y un valor de 619 que resulta la solucin ptima para este ejemplo.
Cuestin 3 (2 puntos). Resolver mediante el algoritmo de Kruskal el rbol de expansin mnimo del grafo definido por la siguiente matriz de adyacencias:
(Respuesta: Fundamentos de Algoritmia, pag. 217, 218).
1 2 3 4 5
1 . . . . .
2 4 . . . .
3 5 6 . . .
4 3 . .
5 9 1 1 .
4 2 1 6 1
4 3 3
Se ordenan las aristas de menor a mayor coste: (2,5),(3,5),(3,4),(1,2)

EVOLUCION EVOLUCION COMPONENTES SOLUCION {1}{2}{3}{4}{5} INICIO {1}{2,5}{3}{4} (2,5) 1 {(2,5)} {1}{2,3,5}{4} (3,5) 2 {(2,5), (3,5)} {1}{2,3,4,5} (3,4) 3 {(2,5), (3,5),( 3,4)} {1,2,3,4,5} (1,2) 4 {(2,5), (3,5),( 3,4),( 1,2)} Proceso terminado porque slo queda una nica componente conexa PASO ARISTA
Problema (4 puntos). Se tiene una matriz de n x n cuyas casillas contienen valores del conjunto C = {rojo, verde, amarillo} excepto una que es blanco. El nico movimiento permitido consiste en
que cada casilla de valor blanco puede intercambiarse por cualesquiera de sus adyacentes no diagonales. Una solucin es una tabla con una fila llena de valores iguales. Desarrollar un algoritmo que dada una matriz inicial averige cuantas soluciones se pueden encontrar aplicando movimientos permitidos a partir de aquella.
Programacin III Febrero 2004 Segunda semana
Cuestin 1 (1 punto). En qu orden est el tiempo de ejecucin del siguiente algoritmo? Justifica tu respuesta.
Procedimiento h(n,i, j) si n > 0 entonces h(n - 1,i,6 - i - j); escribir i " " j; h(n - 1,6 - i - j, j); fsi;
Cuestin 2 (2 puntos). Aplica el algoritmo de Kruskal al siguiente grafo indicando claramente en cada paso qu arista se selecciona, la evolucin de las componentes conexas y la evolucin de la solucin.
Cuestin 3 (2 puntos). Cundo resulta ms apropiado utilizar una exploracin en anchura que en profundidad?
Problema (5 puntos). Dado un grafo dirigido, finito, con ciclos y con todas las aristas de coste unitario, implementar un algoritmo que devuelva el nmero de nodos que contiene el camino ms largo sin ciclos que se puede recorrer desde un determinado nodo.
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2004 Segunda semana
Cuestin 1 (1 punto). En qu orden est el tiempo de ejecucin del siguiente algoritmo? Justifica tu respuesta.
Procedimiento h(n,i, j) si n > 0 entonces h(n - 1,i,6 - i - j); escribir i " " j; h(n - 1,6 - i - j, j); fsi;
T(n)= aT(n - b)+ cn k luego T(n)= 2T(n - 1)+1 nmero de llamadas: a=2 reduccin por sustraccin: b=1 cn k = 1, k = 0 Aplicando la recurrencia para el caso cuando a > 1 : T(n) T(a n div b ); T(n) T(2 n ) Cuestin 2 (2 puntos). Aplica el algoritmo de Kruskal al siguiente grafo indicando claramente en cada paso qu arista se selecciona, la evolucin de las componentes conexas y la evolucin de la solucin.
Se ordenan las aristas de menor a mayor coste: {(2,3),(4,5),(2,4),(3,5),(3,6),(2,5),(1,2),(1,3),(5,6)} EVOLUCION EVOLUCION PASO ARISTA COMPONENTES SOLUCION INICIO {1}{2}{3}{4}{5}{6} 1 (2,3) {1}{2,3}{4}{5}{6} {(2,3)} 2 (4,5) {1}{2,3}{4,5}{6} {(2,3),(4,5)} 3 (2,4) {1}{2,3,4,5}{6} {(2,3) ,(4,5), (2,4)} Se rechaza por formar ciclo 4 (3,5) 5 (3,6) {1}{2,3,4,5,6} {(2,3), (4,5), (2,4), (3,6)} Se rechaza por formar ciclo 6 (2,5) 7 (1,2) {1,2,3,4,5,6} {(2,3) (4,5) (2,4) (3,6) (1,2)}
Proceso terminado porque slo queda una nica componente conexa
Cuestin 3 (2 puntos). Cundo resulta ms apropiado utilizar una exploracin en anchura que en profundidad?
- Cuando el grafo tiene ramas infinitas. - Cuando se busca el camino de menor nmero de nodos o aristas. - Cuando los nodos finales se encuentran cerca del nodo raz. En que casos puede que la exploracin en anchura no encuentre solucin aunque sta exista? - Que exista una solucin quiere decir que existe un camino desde el nodo inicial al nodo final. No tiene sentido, entonces, hablar de que la solucin est en una componente conexa diferente. Por otro lado, el caso en que un nodo genere infinitos hijos es un caso excepcional que no debera darse. Por todo ello, y salvo esta ltima excepcin, la exploracin en anchura siempre encuentra la solucin, si sta existe. Y la exploracin en profundidad? Razona tus respuestas. - Si existen ramas infinitas sin nodos finales puede que la exploracin en profundidad quede atrapada en una de ellas y no encuentre solucin aunque sta exista.
Problema (5 puntos). Dado un grafo dirigido, finito, con ciclos y con todas las aristas de coste unitario, implementar un algoritmo que devuelva el nmero de nodos que contiene el camino ms largo sin ciclos que se puede recorrer desde un determinado nodo. Eleccin del esquema.
Hallar el camino ms largo desde un nodo en un grafo finito puede verse como un problema de determinar cul es la profundidad mxima del rbol. Para ello, ser necesario recorrer todos los caminos sin ciclos del grafo, almacenando la longitud del ms largo encontrado hasta el momento. El esquema de bsqueda exhaustiva en profundidad nos permite resolver este problema.
Descripcin del esquema e identificacin con el problema.
En la pgina 330 del libro de texto (Brassard, 1997) se presenta el esquema de recorrido en profundidad:
procedimiento rp(nodo) {nodo no ha sido visitado anteriormente} visitado[nodo] := cierto; para cada hijo en adyacentes[nodo] hacer si visitado[nodo] = falso entonces rp(hijo) fsi fpara
As planteado, un nodo no se explorara 2 veces aunque llegramos a l desde una rama distinta. Esto es incorrecto y se debe a que el vector de nodos visitados se plantea de forma global. Veamos un ejemplo:
1 5 2 6 3
La exploracin llega al nodo 1 y lo marca como visitado. Anlogamente sigue marcando como visitados los nodos 2, 3 y 4, hallando un camino de longitud 4. Cundo el control regresa al nodo 1 para explorar ramas alternativas, se explora el nodo 5, el 6, pero cuando llega al nodo 3, se detiene la exploracin porque 3 est marcado como visitado. El nuevo camino encontrado tiene 4 nodos en vez de 5 que sera lo correcto. Este problema lo podemos corregir si el vector de visitados tiene un mbito local en vez de global, y se pasa una copia de padres a hijos (paso de parmetro por valor).
Estructuras de datos Necesitaremos una estructura para grafo. La ms compacta y sencilla de usar es un vector en el que la componente i tiene un puntero a lista de nodos adyacentes al nodo i. Por tanto, tambin necesitaremos implementar una lista de nodos que puede ser, simplemente, una lista de enteros. Adems, necesitaremos un vector de nodos visitados por rama. Algoritmo completo procedimiento longitud(nodo,visitados) dev long {nodo no ha sido visitado anteriormente} visitados[nodo]:=cierto; long_max:=0; para cada hijo en adyacentes[nodo] hacer si visitados[nodo]=falso entonces long:=longitud(hijo,visitados); si long>long_max entonces long_max:=long fsi; fsi fpara devolver long_max+1; La llamada inicial se realiza con el nodo inicial, y los elementos del vector de visitados inicializados a falso. Estudio del coste Sea n el nmero de nodos del grafo. Si suponemos un grafo denso (en el que todos los nodos estn interconectados entre s), tenemos que la longitud del camino mximo ser n. Cada
llamada recursiva, entonces, supondr una reduccin en uno del problema. As mismo, el nmero de llamadas recursivas por nivel tambin ira disminuyendo en uno puesto que en cada nivel hay un nodo adyacente ms que ya ha sido visitado. Por ltimo, dentro del bucle se realizan al menos n comparaciones. Por tanto, podemos establecer la siguiente recurrencia: T(n)=(n-1)T(n-1)+n nmero de llamadas: a=n-1 reduccin por sustraccin: b=1 cnk=n, k=1 Aplicando la recurrencia para el caso cuando a>1: T(n)O(an div b); T(n)O(nn) Al mismo resultado se puede llegar razonando sobre la forma del rbol de exploracin.
RESPUESTAS EXAMEN Programacin III. Septiembre 2004 (Original) Cuestin 1 (2 puntos). Qu significa que el tiempo de ejecucin de un algoritmo est en el orden exacto de f(n)? Demostrar que T(n)= n 3 + 9n 2 log(n) est en el orden exacto de n3 . La definicin formal es (f(n)) = O(f(n)) (f(n)) , y considerando que si
lim
f (n) + , entonces f ( n ) ( g ( n ) ) g (n)
segn la relacin del apartado 3.3 (Ver p. 100 del texto base) y adems aplicamos el teorema de LHopital (p. 38) obtenemos que:
lim
f (n) f ( n) con lo que: = lim g ( n ) n g ( n ) f (n) 3n 2 +18nlog(n) + 9n 6n+18log(n) + 27 6 +18 / n n3 + 9n 2 log(n) = lim = lim = lim = lim = 3 2 n n n 3n 6n 6 g ( n ) n n
lim
= lim
( 6n+18 )
6
= lim
( 6n+18) = 1
6n
con lo que n 3 + 9n 2 log(n) ( n3 ) Tambin ser vlido hallar las constantes c y d segn la definicin de la notacin Theta (p.100)
Cuestin 2 (2 puntos). Implementar una versin recursiva de una funcin que tome un vector y le d estructura de montculo.
Proc crear_monticulo (T [1..n ] ,i ) si i > n devuelve (T ) sino flotar ( i,T ) crear_monticulo (T,i +1) fsi fproc
La llamada inicial ser crear _ monticulo (T , 2 ) . Otra versin pero en este caso sin usar funciones auxiliares es sustituir el cdigo de flotar por su versin iterativa e insertarlo en la funcin anterior.
Cuestin 3 (2 puntos).En qu se diferencian los algoritmos de Prim y de Kruskal? Discute tanto los algoritmos como su complejidad en los casos peores de cada uno. En primer lugar difieren en la forma de crear el camino mnimo. En el caso de Prim la solucin es siempre un ARM y en el otro caso, lo son las componentes conexas pero sin referencia al grafo inicial, salvo al final del mismo. En segundo lugar en trminos de coste, el algoritmo de Kruskal requiere un tiempo que est en (a logn) con a el nmero de aristas, por lo que en el caso peor si el grafo es denso y a se acerca a n 2 , entonces es menos eficiente que el de Prim que es cuadrtico, ocurriendo lo contrario para grafos dispersos.
PROBLEMA (5 puntos). Sean dos vectores de caracteres. El primero se denomina texto y el segundo consulta, siendo ste de igual o menor longitud que el primero. Al vector consulta se le pueden aplicar, cuantas veces sea necesario, los siguientes tres tipos de operaciones, que aaden cada una un coste diferente a la edicin de la consulta: Intercambio de dos caracteres consecutivos: coste de edicin igual a 1 Sustitucin de un carcter por otro cualquiera: coste de edicin igual a 2 Insercin de un carcter cualquiera en una posicin cualquiera: coste de edicin igual a 3 Implementar una funcin que escriba la secuencia de operaciones con menor coste total que hay que realizar sobre el vector consulta para que coincida exactamente con el vector texto. La
funcin devolver el coste total de estas operaciones, es decir, la suma de los costes asociados a cada operacin realizada. 1. Eleccin razonada del esquema algortmico La solucin es resultado de una secuencia de pasos o decisiones pero no se puede establecer un criterio ptimo de seleccin de cada decisin por lo que no puede ser un esquema voraz. Por tanto hay que realizar una exploracin de las posibles soluciones y buscar la ptima. Debido a que hay un criterio de optimalidad, es decir, existe una funcin que decide si un nodo puede llevar a una solucin mejor que la encontrada hasta el momento, el esquema adecuado es Ramificacin y Poda. 2. Descripcin del esquema
Funcin RamificacinPoda (nodo_raz) dev nodo inicializarSolucin(Solucin,valor_sol_actual); Montculo:=montculoVaco(); cota:=acotar(nodo_raz); poner((cota,nodo_raz),Montculo); mientras no vaco(Montculo) hacer (cota,nodo):=quitarPrimero(Montculo); si es_mejor(cota, valor_sol_actual) entonces si vlido(nodo) entonces /*cota es el valor real de la mejor solucin hasta ahora*/ valor_sol_actual:=cota; Solucin:=nodo; fsi; si no para cada hijo en compleciones(nodo) hacer cota:=acotar(hijo); poner((cota,hijo),Montculo); fpara; fsi; sino devolver Solucin fsi; /*termina el bucle, montculo no tiene mejores*/ fmientras devolver Solucin; 3. Estructuras de datos Vector de texto Vector de consulta Montculo de mnimos en el que cada componente almacene una solucin parcial (nodo) con su cota correspondiente. nodo=tupla acciones: lista de Strings; ltimo_coincidente: cardinal; long: cardinal; coste: cardinal;
4. Algoritmo completo inicializarSolucin
La solucin inicial debe tener un coste asociado mayor o igual que la solucin final. De acuerdo con el problema, basta con realizar sustituciones de los caracteres de la consulta (coste=2*long_consulta) y realizar la insercin de los caracteres que faltan (coste=3*(long_texto-long_consulta)). Adems tenemos que construir la solucin inicial: la secuencia de sustituciones e inserciones. Funcin inicializarSolucin(long_consulta, texto, long_texto, Solucin, valor_sol_actual); valor_sol_actual:= 2*long_consulta+3*(long_texto-long_consulta); Solucin:=listaVacia(); para i desde 1 hasta long_consulta hacer aadir(Solucin, sustituir i por texto[i]); fpara; para i desde long_consulta+1 hasta long_texto hacer aadir(Solucin, insertar en i, texto[i]); fpara; vlido(nodo) Un nodo ser vlido (como solucin) si se han hecho coincidir los long_texto caracteres de texto. Para ello, vamos a ir haciendo coincidir la solucin desde el principio del vector hasta el final. por tanto, un nodo ser vlido (aunque no sea la mejor solucin todava) si: nodo.ltimo_coincidente==long_texto es_mejor(cota, valor_sol_actual) Como se trata de encontrar la solucin de menor coste, una cota ser mejor que el valor de la solucin actual si: cota<valor_sol_actual acotar(nodo) Se trata de realizar una estimacin que sea mejor o igual que la mejor solucin que se puede alcanzar desde ese nodo. De esta manera sabremos que si, an as, la estimacin es peor que la solucin actual, por esa rama no encontraremos nada mejor y se puede podar. La mejor estimacin ser sumar al coste ya acumulado, el menor coste que podra tener completar la solucin: que el resto de caracteres de consulta coincidieran (coste=0) y realizar tantas inserciones como caracteres nos falten (coste=2*(long_texto-nodo.long)). Es decir, acotar(nodo) es: nodo.coste+2*(long_texto-nodo.long) compleciones(nodo) Sabiendo que hasta nodo.ltimo_coincidente todos los caracteres coinciden, se trata de considerar las posibilidades para que el siguiente carcter de la consulta coincida con el texto: No hacer nada si ya coinciden de antemano. Intercambiarlo por el siguiente si ste coincide con el texto. Sustituirlo por el correspondiente del texto Insertar el correspondiente del texto y correr el resto del vector, siempre que la consulta no haya alcanzado el tamao del texto. Si se da el primer caso, no es necesario generar el resto de compleciones porque no se puede encontrar una solucin mejor con ninguna de las otras alternativas. An as, no pasara nada si se incluyen. Sin embargo, para el resto de alternativas, no hay garantas
de que una permita encontrar mejor solucin que otra, aunque el coste de la accin puntual sea menor. Por tanto, hay que incluir todas las alternativas. Funcin compleciones(nodo, texto, long_texto, consulta) dev lista_nodos lista:=crearLista(); si consulta[hijo.ltimo_coincidente]==texto[hijo.ltimo_coincidente] entonces hijo:=crearNodo(); hijo.ltimo_coincidente:=nodo.ltimo_coincidente+1; hijo.acciones=nodo.acciones; hijo.coste=nodo.coste; hijo.long=nodo.long; aadir(lista, hijo); si no /* intercambio */ si consulta[hijo.ltimo_coincidente+1]==texto[hijo.ltimo_coincidente] entonces intercambiar(consulta[hijo.ltimo_coincidente], consulta[hijo.ltimo_coincidente+1]); hijo:=crearNodo(); hijo.ltimo_coincidente:=nodo.ltimo_coincidente+1; hijo.acciones=nodo.acciones; aadir(hijo.acciones,intercambiar consulta[hijo.ltimo_coincidente] por consulta[hijo.ltimo_coincidente+1]); hijo.coste=nodo.coste+1; hijo.long=nodo.long; aadir(lista, hijo); fsi; /* sustitucin */ hijo:=crearNodo(); hijo.ltimo_coincidente:=nodo.ltimo_coincidente+1; hijo.acciones=nodo.acciones; insertar(hijo.acciones,sustituir hijo.ltimo_coincidente por texto[hijo.ltimo_coincidente]); hijo.coste=nodo.coste+2; hijo.long=nodo.long; aadir(lista, hijo); /* insercin */ si (nodo.long<long_texto) entonces hijo:=crearNodo(); hijo.ltimo_coincidente:=nodo.ltimo_coincidente+1; hijo.acciones=nodo.acciones; insertar(hijo.acciones,insertar en hijo.ltimo_coincidente, texto[hijo.ltimo_coincidente]); hijo.coste=nodo.coste+3; hijo.long=nodo.long+1; aadir(lista, hijo); fsi; fsi; devolver lista;
La funcin principal quedara entonces como sigue: Funcin ajustar(consulta, long_consulta, texto, long_texto) dev coste inicializarSolucin(long_consulta, texto, long_texto, Solucin, valor_sol_actual); Montculo:=montculoVaco(); nodo.acciones=listaVacia(); nodo.ltimo_coincidente=0; nodo.coste=0; nodo.long=long_consulta; cota:= nodo.coste+2*(long_texto-nodo.long); poner((cota,nodo),Montculo); mientras vaco(Montculo) hacer (cota,nodo):=quitarPrimero(Montculo); si cota<valor_sol_actual entonces si nodo.ltimo_coincidente==long_texto entonces valor_sol_actual:=cota; solucin:=nodo.acciones; si no para cada hijo en compleciones(nodo, texto, long_texto, consulta) hacer cota:= nodo.coste+2*(long_texto-nodo.long); poner((cota,hijo),Montculo); fpara; fsi; sino /* Ya no puede haber una solucin mejor */ escribir(solucin); devolver valor_sol_actual; fsi; fmientras escribir(solucion); devolver valor_sol_actual; 5. Estudio del coste En este caso nicamente podemos hallar una cota superior del coste del algoritmo por descripcin del espacio de bsqueda. En el caso peor se generan 3 hijos por nodo hasta llegar a una profundidad de long_texto. Por tanto, el espacio a recorrer siempre ser menor que 3long_texto.
Programacin III Septiembre 2004 Reserva
Cuestin 1 (2 puntos). Defina qu es un rbol de recubrimiento mnimo, explique alguno de los algoritmos propuestos en la asignatura para hallarlos, aplicndolo paso a paso a un ejemplo.
(Respuesta: Fundamentos de Algoritmia, pags. 215-223).
Cuestin 2 (2 puntos). Sea T [1..12] una matriz tal que T [i ] = i para todo i 12 .Crear un montculo en tiempo lineal, especificando claramente cada paso y mostrando en todo momento el estado de la matriz T.
(Respuesta: Fundamentos de Algoritmia, pag. 189).
Cuestin 3 (2 puntos). Se dispone de n productos diferentes, infraccionables y en cantidades ilimitadas. Cada tipo de producto tiene asociado un peso y un beneficio concreto. Deseamos cargar un camin, que puede transportar un peso mximo PMAX, maximizando el beneficio de los productos transportados por este. Sera posible aplicar un algoritmo voraz a este planteamiento? Responder razonadamente y plantear un ejemplo que justifique la respuesta. (Respuesta: Fundamentos de Algoritmia, Pgs. 227, 343, 353).
PROBLEMA (5 puntos). Sea una red de comparticin de ficheros, similar a las que actualmente se utilizan para intercambiar globalmente archivos por internet. Esta red se encuentra formada por n servidores, siendo todos ellos capaces de distribuir un nmero n de archivos, de tamao Ti Kilobytes, a diferentes velocidades de transmisin. La velocidad de transmisin de datos de cada uno de los servidores viene determinada por una tabla de velocidades de transmisin S, donde, Sij es la velocidad de transmisin del servidor i para el archivo j (en K/seg) .se pide disear un algoritmo capaz de repartir la descarga de los n archivos entre los n servidores disponibles, minimizando el tiempo global de descarga de todos los archivos. La funcin deber indicar el tiempo ptimo de descarga, as como los servidores desde los que sern descargados los n archivos. Suponga que la descargase lleva a cabo de manera secuencial, lo que significa que no es posible descargar ms de un archivo al mismo tiempo. Tome como ejemplo ilustrativo de los datos de entrada una red de comparticin de 3 ficheros (A1, A2, A3) en 3 servidores diferentes (S1, S2, S3). El tamao de los 3 ficheros es T1=100K, T2=200K, T3=300K y la velocidad de transmisin de los 3 servidores viene dado por la matriz:
RESPUESTAS EXAMEN Programacin III. Septiembre 2004 (Reserva) Cuestin 1 (2 puntos). Defina qu es un rbol de recubrimiento mnimo, explique alguno de los algoritmos propuestos en la asignatura para hallarlos, aplicndolo paso a paso a un ejemplo.
(Respuesta: Fundamentos de Algoritmia, pags. 215-223).
Dado un grafo, debemos obtener un nuevo grafo que slo contenga las aristas imprescindibles para que todos los nodos queden conectados y la suma de las longitudes de las aristas de del nuevo grafo debe ser tan pequea como sea posible, se aplica a problemas que tienen que ver con distribuciones geogrficas Hay dos algoritmos que podemos utilizar para resolver este tipo de problemas: Kruskal y Prim. KRUSKAL: Partimos del conjunto de aristas T que inicialmente est vaco, se selecciona en cada paso la arista de menor etiqueta que no provoque ciclo, es decir en orden creciente de longitud de sus aristas. El algoritmo se detiene cuando solo queda una componente conexa. Se ordenan las aristas de menor a mayor coste:
PASO INICIO 1 2 3 4 5 6 7 ARISTA (1,2) (2,3) (4,5) (6,7) (1,4) (2,5) (4,7) EVOLUCION COMPONENTES {1}{2}{3}{4}{5}{6}{7} {1,2}{3}{4}{5}{6}{7} {1,2,3}{4}{5}{6}{7} {1,2,3}{4,5}{6}{7} {1,2,3}{4,5}{6,7} {1,2,3,4,5}{6,7} {1,2,3,4,5,6,7} EVOLUCION SOLUCION
Se rechaza porque los extremos
{(1,2)} {(1,2), (2,3)} {(1,2), (2,3),( 4,5)} {(1,2), (2,3),( 4,5),( 6,7)} {(1,2), (2,3),( 4,5),( 6,7),( 1,4)}
de la arista ya estn en la misma comp. conexa
{(1,2), (2,3),( 4,5),( 6,7),( 1,4),( 4,7)}
PRIM: En este algoritmo el rbol de recubrimiento mnimo crece de forma natural, comenzando por una raz arbitraria, en cada fase se aade una nueva rama al rbol construido con el valor ms pequeo posible, el rbol se detiene cuando se han alcanzado todos los nodos.
EVOLUCION COMPONENTES {1} {1,2} {1,2,3} {1,2,3,4} {1,2,3,4,5} {1,2,3,4,5,7} {1,2,3,4,5,6,7}
PASO INICIO 1 2 3 4 5 6
ARISTA (1,2) (2,3) (1,4) (4,5) (4,7) (7,6)
EVOLUCION SOLUCION
{(1,2)} {(1,2), (2,3)} {(1,2), (2,3),(1,4)} {(1,2), (2,3),(1,4),(4,5)} {(1,2), (2,3),(1,4),(4,5),(4,7)} {(1,2), (2,3),(1,4),(4,5),(4,7),(7,6)}
Estos algoritmos difieren en la forma de crear el camino mnimo. En el caso de Prim la solucin es siempre un AEM y en el otro caso, lo son las componentes conexas pero sin referencia al grafo inicial, salvo al final del mismo. En segundo lugar en trminos de coste, el algoritmo de Kruskal requiere un tiempo que est en (a logn) con a el nmero de aristas, por lo que en el caso peor si el grafo es denso y a se tiende a
n ( n - 1) 2 , con un tiempo que est en ( n 2logn ) entonces es menos eficiente que el de Prim que es
cuadrtico, para un grafo disperso a tiende a n por lo que Kruskal requiere un tiempo que est en ( nlogn ) y el algoritmo de Prim es menos eficiente en este caso. Los dos algoritmos se pueden implementar con montculos, en este caso los dos algoritmos estn en ( a logn )
Cuestin 2 (2 puntos). Sea T [1..12] una matriz tal que T [i ] = i para todo i 12 .Crear un montculo en
(Respuesta: Fundamentos de Algoritmia, pag. 189).
tiempo lineal, especificando claramente cada paso y mostrando en todo momento el estado de la matriz T.
Para Crear un montculo Se inserta un nuevo elemento al final del montculo (primera posicin libre) Si se mantiene la propiedad del montculo no hay que hacer ninguna operacin Si no se mantiene la propiedad del montculo hay que restaurarla Se restaura la propiedad del montculo intercambiando el nuevo elemento con su padre cuantas veces sea necesario, a esta operacin de subir en el montculo se la denomina flotar un elemento El nuevo elemento sube en el montculo (flota) y sus padres bajan en el montculo (se hunden) A la operacin de bajar en un montculo se la denomina hundir Por ejemplo con el vector T [15,11,12,20,5,16,8,32,18,31,25,14] Proc aadir - nodo (T[1...12],v)
Proc Flotar(T[1...n],i) k i Repetir jk Si j > 1 y T[j 2] > T[k] entonces k j 2 Intercambiar T[j] y T[k] Hasta j = k Fproc
{ Aade un elemento cuyo vlor es v al del montculo T[1...n]}

T[n+1] v Flotar(T[1...n+1],n+1) Fproc
final
Detallo paso por paso: 12345Inserto el elemento 15. Estado de la matriz T [15]. Inserto el elemento 11 y llamo al procedimiento flotar. Estado de la matriz T [11, 15]. Inserto el elemento 12. Estado de la matriz T [11, 15,12]. Inserto el elemento 20. Estado de la matriz T [11, 15,12,20]. Inserto el elemento 5 y llamo al procedimiento flotar dos veces. Estado de la matriz T [5,11, 12,20,15]. 6- Inserto el elemento 16. Estado de la matriz T [5,11, 12,20,15,16]. 7- Inserto el elemento 8 y llamo al procedimiento flotar. Estado de la matriz T [5,11, 12,20,15,16,8]. 8- Inserto el elemento 32. Estado de la matriz T [5,11, 12,20,15,16,8,32]. 9- Inserto el elemento 18 y llamo al procedimiento flotar. Estado de la matriz T [5,11, 12,18,15,16,8,32,20]. 10- Inserto el elemento 31. Estado de la matriz T [5,11, 12,18,15,16,8,32,20,31]. 11- Inserto el elemento 25. Estado de la matriz T [5,11, 12,18,15,16,8,32,20,31,25]. 12- Inserto el elemento 14 y llamo al procedimiento flotar. Estado de la matriz T [5,11, 12,18,15,14,8,32,20,31,25,16].
Despus de realizar estas operaciones se puede observar que el vector tiene estructura de montculo de mnimos.
Cuestin 3 (2 puntos). Se dispone de n productos diferentes, infraccionables y en cantidades ilimitadas. Cada tipo de producto tiene asociado un peso y un beneficio concreto. Deseamos cargar un camin, que puede transportar un peso mximo PMAX, maximizando el beneficio de los productos transportados por este. Sera posible aplicar un algoritmo voraz a este planteamiento? Responder razonadamente y plantear un ejemplo que justifique la respuesta. (Respuesta: Fundamentos de Algoritmia, Pgs. 227, 343, 353).
NO. La variante del problema de la mochila que admite solucin voraz es la variante continua, donde podemos fragmentar los objetos. Esta variante admite solucin voraz porque encontramos una funcin de seleccin que nos permite escoger del candidato a cada paso de forma que obtengamos una solucin ptima. Dicha funcin consiste en escoger los objetos por orden decreciente (de mayor a menor) segn su relacin valor/peso, lo que nos lleva a una solucin ptima. La variante que no admite solucin ptima es la que no nos permite fragmentar los objetos, veamos esto con un ejemplo. Dada la siguiente relacin de objetos valor-peso para una mochila de capacidad 10 (W=10, peso mximo de la mochila) . a 6 8 b 5 5 c 5 5
wi vi
Segn el algoritmo voraz de la variante continua tomaramos los objetos segn su orden decreciente en funcin de la relacin valor/peso. De este modo tendramos: a (vi/wi = 1,333) , b (vi/wi= 1) y c(vi/wi=1) . La sucesin a, b y c. Sin embargo como en esta ocasin NO podemos fragmentar los objetos al introducir en la mochila el objeto a de peso 6 ya no podemos introducir ninguno ms, el valor conseguido ser entonces de 8; mientras que si introducimos primero el objeto b, queda an espacio para el objeto c, con lo que en esta ocasin hemos utilizado el peso total mximo de la mochila y el valor conseguido es de 10. Siendo esta la solucin ptima. Vemos con este ejemplo como el criterio seguido en la variante continua del problema no puede aplicarse en el caso en el que los objetos no puedan fragmentarse.
PROBLEMA (5 puntos). Sea una red de comparticin de ficheros, similar a las que actualmente se utilizan para intercambiar globalmente archivos por internet. Esta red se encuentra formada por n servidores, siendo todos ellos capaces de distribuir un nmero n de archivos, de tamao Ti Kilobytes, a diferentes velocidades de transmisin. La velocidad de transmisin de datos de cada uno de los servidores viene determinada por una tabla de velocidades de transmisin S, donde, Sij es la velocidad de transmisin del servidor i para el archivo j (en K/seg) .se pide disear un algoritmo capaz de repartir la descarga de los n archivos entre los n servidores disponibles, minimizando el tiempo global de descarga de todos los archivos. La funcin deber indicar el tiempo ptimo de descarga, as como los servidores desde los que sern descargados los n archivos. Suponga que la descargase lleva a cabo de manera secuencial, lo que significa que no es posible descargar ms de un archivo al mismo tiempo. Tome como ejemplo ilustrativo de los datos de entrada una red de comparticin de 3 ficheros (A1, A2, A3) en 3 servidores diferentes (S1, S2, S3). El tamao de los 3 ficheros es T1=100K, T2=200K, T3=300K y la velocidad de transmisin de los 3 servidores viene dado por la matriz:
Programacin III
Primera Semana Febrero 2005 Duracin: 2 horas Material permitido: NINGUNO

DNI: _______________________
Prueba Presencial
Apellidos: ___________________________________________________________________________________ Nombre: _____________________________________
Centro Asociado en el que entreg la prctica: _______________________
Cuestin 1 (2 puntos).
Se dispone de un conjunto de ficheros f1, f2, ..., fn con tamaos I1, I2, ..., In y de un disquete con una capacidad total de almacenamiento de d<I1+I2+...+In. a) Suponiendo que se desea maximizar el nmero de ficheros almacenados y que se hace uso de un planteamiento voraz basado en la seleccin de ficheros de menor a mayor tamao, el algoritmo propuesto siempre obtendra la solucin ptima?. En caso afirmativo demostrar la optimalidad y en caso negativo ponga un contraejemplo; b) En caso de que quisiramos ocupar la mayor cantidad de espacio en el disquete independientemente del nmero de ficheros almacenados, una estrategia voraz basada en la seleccin de ficheros de mayor a menor tamao obtendra en todos los casos la solucin ptima?. En caso afirmativo demuestre la optimalidad, en caso negativo ponga un contraejemplo.
Solucin: Apartado A
El algoritmo voraz obtendra la solucin ptima, es decir, un disquete con el mayor nmero posible de ficheros. Demostracin: Suponiendo que los programas se encuentran inicialmente ordenados de menor a mayor tamao, vamos a demostrar la optimalidad de la solucin comparando una solucin ptima con una solucin obtenida por el algoritmo voraz. Si ambas soluciones no fueran iguales, iremos transformando la solucin ptima de partida, de forma que contine siendo ptima, pero asemejndola cada vez ms con la obtenida por el algoritmo voraz. Si consiguiramos igualar ambas soluciones en un nmero finito de pasos, entonces podremos afirmar que la solucin obtenida por el algoritmo es ptima. Notacin: Una solucin cualquiera viene representada por Z=(z1, z2, ..., zn) donde zi=0 implica que el fichero fi no ha sido seleccionado como parte de la solucin. De este modo,
z
i =1
indicar el nmero de ficheros seleccionados
como solucin al problema. Siendo X la solucin devuelta por la estrategia voraz e Y la solucin ptima al problema. Supongamos que la estrategia voraz propuesta selecciona los k primeros ficheros (con 1 = k = n), recordamos que los ficheros se encuentran inicialmente ordenados de menor a mayor tamao. El fichero k+1 es rechazado puesto que ya no es posible incluir un solo fichero ms. De este modo, la solucin X ser (x1, x2, ..., xk,..., xn), donde . i . { ..k }.x i = 1 y 1 . i . {k + 1..n}.x i = 0 . Comenzando a comparar X con Y de izquierda a derecha, supongamos que j = 1 sea la primera posicin donde xj . yj . En este caso, obligatoriamente j = k ya que en caso contrario la solucin ptima incluira todos los ficheros escogidos por la estrategia voraz y alguno ms, lo que se contradice con el hecho de que los ficheros del k+1 al n se rechazan por la estrategia voraz porque no caben. Este modo, xj . yj implica que yi=0, por lo que
y
i =1
= j 1 , que es menor que el nmero de ficheros seleccionados
por nuestra estrategia voraz como solucin al problema
x
i =1
= j . Como suponemos que Y es una solucin ptima,

i =1
yi =
x
i =1
= k , esto significa que existe un l > k = j tal que yl = 1, es decir, existe un fichero posterior para
compensar el que no se ha cogido antes. Por la ordenacin impuesta a los ficheros, sabemos que lj = ll, es decir, que si fl cabe en el disco, podemos poner en su lugar fj sin sobrepasar la capacidad total. Realizando este cambio en la solucin ptima Y, obtenemos otra solucin Y en la cual yj= 1 = xj, yl=0 y para el resto yi = yi. Esta nueva solucin es ms parecida a X, y tiene el mismo nmero de ficheros que Y, por lo que sigue siendo ptima. Repitiendo este proceso, podemos ir igualando los ficheros en la solucin ptima a los de la solucin voraz X, hasta alcanzar la posicin k.
Apartado B
El algoritmo voraz no obtendra la solucin ptima en todos los casos. Contraejemplo: Supongamos la siguiente lista de ficheros con tamaos asociados: Fichero F1 Tamao 40 Supongamos que la capacidad mxima del disquete es 45. Aplicando la estrategia voraz propuesta, nicamente podramos almacenar el fichero F1, ocupando 40 de los 45 de capacidad que tiene el disquete. Sin embargo, si hubiramos seleccionado los ficheros F2 y F3 hubiera sido posible maximizar el espacio ocupado en el disco. F2 30 F3 15
Cuestin 2 (2 punto).
Exponga y explique el algoritmo ms eficiente que conozca para realizar una planificacin de tareas con plazo fijo maximizando el beneficio. Dada la tabla adjunta de tareas con sus beneficios (gi) y caducidades (di) asociados. Aplique paso a paso el algoritmo propuesto, suponiendo que se desea realizar una planificacin en un tiempo t=5. i gi di 1 30 5 2 10 3 3 2 2 4 11 2 5 10 1 6 9 2 7 2 7 8 56 5 9 33 4
Solucin: Apartado A
El algoritmo ms apropiado es el algoritmo secuencia2 explicado y desarrollado en pg 240-241 del texto base y que ha sido utilizado en la prctica (Bloque 1). El alumno debe haberlo expuesto y explicado.
Apartado B
1. Inicialmente ordenamos la tabla propuesta por orden decreciente de beneficios. 2. Creamos el nmero apropiado de estructuras de particin. p=min(9,max(di))=min(9,7)=7. Como en este caso concreto queremos nicamente planificar las 5 primeras tareas p puede reducirse a 5. 3. Vamos extrayendo cada una de las tareas por orden decreciente de beneficios e incluyndolas en su correspondiente estructura de particin. Esta operacin implica fusionar la estructura en la cual se ha incluido la tarea con la estructura de particin inmediatamente anterior. 4. El algoritmo termina cuando ya no queda ninguna estructura de particin libre para asignar tarea. i gi di 8 9 1 4 5 2 6 3 7 56 33 30 11 10 10 9 2 2 5 4 5 2 1 3 2 2 7 Tabla de costes y caducidades ordenada
El proceso puede esquematizarse del siguiente modo:
0 0
1 1
2 2
3 3
4 4
5 5
0 Res[]
0 0
1 1
2 2
3 3
4 4
Selecciono tarea 8 0 Res[] 5 1 2 3 4 8
0 0
1 1
2 2
3 3
Selecciono tarea 9 0 Res[] 4 5 1 2 3 9 4 8
0 0
1 1
2 2
Selecciono tarea 1 0 Res[] 3 4 5 1 2 1 3 9 4 8
0 0
1 1
Selecciono tarea 4 0 Res[] 2 3 4 5 1 4 2 1 3 9 4 8
Selecciono tarea 5 0 Res[] 1 2 3 4 5 5 1 4 2 1 3 9 4 8
Cuestin 3 (1 punto).
Explique las diferencias entre un recorrido en anchura y un recorrido en profundidad. Exponga un algoritmo iterativo para cada uno de los recorridos explicando las estructuras de datos asociadas, as como su coste.
Solucin:
En las pginas 338 y 339 del texto base puede encontrarse una explicacin tanto de las diferencias entre ambos tipos de recorrido, como un algoritmo iterativo para cada uno de ellos basado en el uso de PILAS y COLAS como estructuras de datos asociadas.
Problema (5 puntos).
Partiendo de un conjunto N={n1, n2, ..., nm} compuesto por m nmero positivos y de un conjunto O={+,-,*,/} con las operaciones aritmticas bsicas, se pide obtener una secuencia de operaciones factible para conseguir un nmero objetivo P. Como restricciones al problema, debe tenerse en cuenta que: a) los nmeros del conjunto N pueden utilizarse en la secuencia de operaciones 0 o 1 vez, b) los resultados parciales de las operaciones pueden utilizarse como candidatos en operaciones siguientes, c) las operaciones que den como resultado valores negativos o nmeros no enteros NO debern tenerse en cuenta como secuencia vlida para obtener una solucin. Disee un algoritmo que obtenga una solucin al problema propuesto, mostrando la secuencia de operaciones para obtener el nmero objetivo P. En caso de no existir solucin alguna, el algoritmo deber mostrar la secuencia de operaciones que d como resultado el valor ms prximo, por debajo, del nmero objetivo P. Por ejemplo, siendo P=960 y N={1,2,3,4,5,6}, la secuencia de operaciones que obtiene la solucin exacta es: ((((6*5)*4)*2)*(3+1))=960. Si P=970, el algoritmo no encontrara la solucin exacta con el conjunto de nmeros inicial y la secuencia ms prxima por debajo de P sera ((((6*5)*4)*2)*(3+1))=960.
Solucin: Eleccin Razonada del Esquema Algortmico.

Obviamente no se trata de un problema que pueda ser resuelto por divide y vencers, puesto que no es posible descomponer el problema en subproblemas iguales, pero de menor tamao, que con algn tipo de combinacin nos permita encontrar la solucin del problema. Tampoco se trata de un algoritmo voraz, puesto que no existe ninguna manera de atacar el problema de manera directa que nos lleve a la solucin sin necesidad de, en algn momento, deshacer alguna de las decisiones tomadas. Por tanto, se trata de un problema de exploracin de grafos donde deberemos construir el grafo implcito al conjunto de operaciones posibles con el fin de encontrar una solucin al problema. Descartamos una exploracin ciega en profundidad o en anchura puesto que, como en la mayor parte de los casos va a existir por lo menos una solucin y adems el enunciado del problema solicita una solucin al problema y no todas, es deseable que la exploracin se detenga en el momento en el que encuentre alguna de ellas. Slo en el caso de que no exista solucin al problema, a partir del conjunto N inicial, el recorrido deber ser completo. De acuerdo a este razonamiento, la estrategia ms apropiada parece la de aplicar un esquema del tipo backtracking o vuelta atrs. Como el alumno ya conoce, este tipo de algoritmos se basan en un recorrido en profundidad o en anchura que no construye el grafo implcito de manera exhaustiva, puesto que dispone de condiciones de corte que lo detienen en cuanto se encuentra una solucin. En nuestro caso, adems, basaremos el algoritmo en un recorrido en profundidad y no en anchura puesto que en la mayor parte de las ocasiones es necesario combinar prcticamente la totalidad de los elementos de N para obtener la solucin. La alternativa de aplicar un algoritmo de ramificacin y poda no es vlida en este caso pues este tipo de algoritmos se caracteriza por obtener la solucin ptima a un problema concreto. En este caso no es necesario optimizar absolutamente nada, pues la solucin es el nmero objetivo que nos solicitan y no van a existir, por tanto, soluciones mejores o peores. Slo en el caso de que no exista solucin, el problema nos pide la ms aproximada por debajo, lo cual implica una exploracin exhaustiva del grafo implcito y, por tanto, el conocimiento por parte del algoritmo de cual ha sido la operacin ms aproximada realizada hasta el momento.
Descripcin del Esquema Algortmico de Vuelta Atrs.

fun vuelta-atrs(e: ensayo) si valido(e) entonces dev e sino listaensayos .
complecciones(e)
mientras vacia(listaensayos) . resultado hacer hijo . primero(listaensayos) listaensayos . resto(listaensayos) si condicionesdepoda(hijo) entonces resultado . vuelta-atrs(hijo) fsi fmientras dev resultado fsi ffun
Estructuras de Datos Necesarias

La estructura de datos principal para llevar a cabo nuestro algoritmo va a ser aquella encargada de almacenar la informacin relativa a cada uno de los ensayos generados:
Tipo Tensayo= candidatos: vector de int operaciones: vector de TpilaOperaciones solucion: boolean vacio: boolean Operaciones Asociadas --------------------getCandidatos():vector Devuelve el vector de candidatos para operar con l. getOperaciones():vector Devuelve el vector de operaciones(pilas) para operar con l. getCandidato(indexCand int):int Devuelve el candidato que se encuentra en la posicin indexCand. removeCandidato(indexCand int):void Elimina el candidato que se encuentra en la posicin indexCand. setCandidato(candidato int,indexCand int):void Inserta el candidato candidato en la posicin indexCand del vector de candidatos. getOperacion(indexOp int):TPilaOperaciones Devuelve la operacin(pila) que se encuentra en la posicin indexOp. removeOperacion(indexOp int):void Elimina la pila de operaciones que se encuentra en indexOp. setOperacion(operacion TpilaOperaciones, indexOp int):void Inserta la pila de operaciones operacin en la posicin indexOp del vector de operaciones. setSolucion(solucion boolean):void Marca el ensayo como solucin vlida. isSolucion():boolean Devuelve un boolean que indica si el ensayo es o no solucin. isVacio():bolean Devuelve un bolean que indica si el ensayo es o no vacio. setVacio(vacio boolean)void Marca el ensayo como vacio.
Tipo TpilaOperaciones= pila: pila de String Operaciones Asociadas --------------------pushNumber(value int):void Aade un nmero a la pila. La lgica de la operacin transforma el entero de entrada en una cadena de caracteres para poder insertarlo en la pila. pushOperator(oper char):void Aade un operador a la pila. La lgica de la operacin transforma el entero de entrada en una cadena de caracteres para poder insertarlo en la pila.
El principal problema del ejercicio se encuentra en determinar cmo vamos a ir construyendo el grafo implcito y cmo vamos a representar las operaciones que ya han sido llevadas a cabo. Para ello vamos a tener en cuenta lo siguiente: 1. Nuestro algoritmo siempre va a trabajar sobre un conjunto de candidatos que recoger inicialmente los valores asociados y, posteriormente, los valores obtenidos al ir realizando cada una de las operaciones. Esta es la funcin del elemento candidatos de Tensayo. 2. Para poder recordar qu operaciones se han llevado a cabo y mostrrselas al usuario al fin del algoritmo, es necesario desplegar un almacn de informacin paralelo a candidatos que, para cada uno de los candidatos recoja las operaciones que ste ha soportado hasta el momento. Con este fin se crea el elemento operaciones, que no es ms que un vector donde cada elemento representa una pila de operaciones y operandos que, en notacin postfija, representan el historial de operaciones de dicho elemento. 3. Finalmente, el elemento solucin marca el ensayo como solucin o no, dependiendo si alberga la solucin al problema. Veamos con un ejemplo el funcionamiento de esta estructura de datos. Supongamos que nuestro conjunto inicial es N={1, 2, 3, 4}. El ensayo correspondiente a esta situacin inicial vendra descrito por:
Tipo Tensayo= candidatos: vector de int operaciones: vector de TpilaOperaciones solucion: bolean ENSAYO -----candidatos:<1,2,3,4> operaciones < 1 2 3 4 >
solucion: false
Supongamos ahora que operamos el candidato 2 y el candidato 4 con el operador +. El nuevo formato del ensayo sera el siguiente:
ENSAYO -----candidatos:<1,6,3> 2 4 operaciones < 1 + 3 >
solucion: false vacio: false
Ntese que: 1. Desaparece el elemento que ocupa la posicin 3 del vector y su pila asociada. 2. El vector de candidatos ahora almacena el valor 6 all donde se ha realizado la operacin. 3. El vector de operaciones ha actualizado la pila de operaciones, reflejando la nueva situacin en notacin postfija (2,4,+)
Supongamos que ahora operamos el candidato 6 con el candidato 3 utilizando el operador -. El nuevo ensayo quedara:
ENSAYO -----candidatos:<1,3>
2 4 + 3 operaciones < 1 >
Finalmente si operamos el candidato 1 con el candidato 3 utilizando el operador *. El ensayo obtenido sera:
ENSAYO -----candidatos:<3>
2 4 + 3 1
operaciones
<
>
Como podemos observar, el valor final obtenido combinando todos los valores iniciales, y de acuerdo a las operaciones descritas, sera 3 y el historial completo de todas las operaciones realizadas podra mostrarse deshaciendo la pila en formato postfijo generada (2,4,+,3,-,1,*).
Algoritmo Completo.
fun vuelta-atrs(e: Tensayo):Tensayo si valido(e) entonces solucion . e solucion.setSolucion(true); dev solucion sino listaensayos . complecciones(e) mientras vacia(listaensayos) . solucion.isSolucion() hacer hijo . primero(listaensayos) listaensayos . resto(listaensayos) si podar(hijo) entonces solucion . vuelta-atrs(hijo) sino solucion . mejor(e) fsi fmientras dev solucion fsi ffun
Ntese que solucin es un ensayo, que inicialmente es vaco, y que contendr la solucin en caso de existir o la serie de operaciones que ms se aproximen en caso de que esto no ocurra. Solucin se define externamente a la funcin vuelta-atrs y, por eso, puede manipularse desde cualquiera de las funciones sin ser necesario enviarla a stas como parmetro. Igualmente, la el valor objetivo P, tambin es utilizado globalmente por la funcin vuelta atrs. Las funciones asociadas al algoritmo son las siguientes:
valido(e Tensayo):boolean Funcin que devuelve true si el ensayo que recibe como parmetro es solucin al problema, es decir, si contiene algn candidato cuyo valor sea P. Devuelve false en caso contrario. complecciones(e Tensayo):lista Funcin que devuelve la lista de hijos correspondientes a un ensayo concreto. La poltica de generacin de hijos que seguiremos ser la siguiente: Para cada candidato, complecciones genera todas las combinaciones posibles de ste con cada uno de los dems, haciendo uso del conjunto de operaciones posibles. podar(e Tensayo):bolean Funcin que devuelve un boolean dependiendo si es posible continuar explorando por el ensayo e que recibe como parmetro o no. La nica condicin de poda que impondremos ser que alguno de los candidatos calculados hasta el momento sobrepase el valor de P. mejor(e Tensayo):Tensayo Funcin que compara el ensayo e, que recibe como parmetro, con la solucin calculada hasta el momento. Devuelve a la salida aquel ensayo que contenga el candidato ms prximo a la solucin solicitada. fun valido(e: Tensayo):boolean para c desde 0 hasta numCandidatos hacer candidato . e.getCandidato(c) si candidato = P entonces dev true fsi fpara dev false ffun fun podar(e: Tensayo):boolean para c desde 0 hasta numCandidatos hacer candidato . e.getCandidato(c) si candidato > P entonces dev true fsi fpara dev false ffun
fun mejor(e: Tensayo):Tensayo v1 . valorMax(e) v2 . valorMax(solucion) si v1<v2 entonces dev solucion sino dev e fsi ffun fun valorMax(e: Tensayo):int value . e.getCandidato(0) para cada c desde 1 hasta numCandidatos hacer valAux . e.getCandidato(c) si (valAux>value) . (valAux<=P) entonces value=valAux fsi fpara dev value ffun fun complecciones(e: Tensayo):vector para c1 desde 0 hasta numCandidatos hacer para c2 desde c1+1 hasta numCandidatos hacer hijo=obtieneHijo(e,+,c1,c2) si ( hijo.isVacio()) entonces vHijos.addElement(hijo) fsi hijo=obtieneHijo(e,-,c1,c2) si ( hijo.isVacio()) entonces vHijos.addElement(hijo) fsi hijo=obtieneHijo(e,*,c1,c2) si ( hijo.isVacio()) entonces vHijos.addElement(hijo) fsi hijo=obtieneHijo(e,/,c1,c2) si ( hijo.isVacio()) entonces vHijos.addElement(hijo) fsi fpara fpara dev vHijos ffun
fun obtieneHijo(e: Tensayo, char operator, int c1Index, int c2Index):Tensayo c1 . c2 . e.getCandidato(c1Index) e.getCandidato(c2Index) e
nuevoEnsayo .
si (operator=+) entonces res . c1+c2 sino si (operator=-) entonces res . c1-c2 sino si (operator=*) entonces res . c1*c2 sino si (operator=/) entonces si (c2!=0) . (c1%c2=0) entonces res . c1/c2 sino res . -1 fsi fsi fsi fsi fsi si (res >=0) entonces nuevoEnsayo . e
pila1=e.getOperacion(c1) pila2=e.getOperacion(c2) pila=generaNuevaPila(pila1,pila2,operator) nuevoEnsayo.removeCandidato(c2) nuevoEnsayo.setCandidato(res,c1) nuevoEnsayo.removeOperacion(c2) nuevoEnsayo.setOperacion(pila,c1) dev nuevoEnsayo sino dev ensayoVacio fsi ffun
Ntese como la funcion generaNuevaPila recibe como parmetros las dos pilas ya existentes (pertenecientes a cada uno de los candidatos), as como el operador que va a ser utilizado para combinar ambos candidatos y genera como resultado la nueva pila correspondiente al candidato generado.
Programacin III
Solucin
Prueba Presencial Segunda Semana Enero - Febrero de 2005
UNIVERSIDAD NACIONAL DE EDUCACIN A DISTANCIA
Cuestin 1 (2 puntos). Demuestra cul es el orden exacto de complejidad en funcin de la variable n, del siguiente programa: 1 2 3 4 5 6 7 8 9 procedimiento lona (n: entero, j: entero) para i desde 1 hasta n div 4 hacer j:=j+i; fpara si n>1 entonces lona(n-2,j); escribir j; lona(n-2,n-j); fsi
Planteamos una recurrencia con reduccin del problema mediante sustraccin n: tamao del problemas a: nmero de llamadas recursivas b: reduccin del problema en cada llamada recursiva n-b: tamao del subproblema nk: coste de las instrucciones que no son llamadas recursivas Recurrencia: T(n)= cnk aT(n-b)+cnk (nk) (nk+1) (an div b) si a<1 si a=1 si a>1 si 0n<b si nb
T(n) a=2; b=2; nk=n; k=1
Por tanto, T(n) (2n div 2) Nota: (2n div 2) no es equivalente a (2n), puesto que se le est aplicando la raz cuadrada y no el producto de una constante.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico 2. Descripcin del esquema usado e identificacin con el problema 3. Estructuras de datos 4. Algoritmo completo a partir del refinamiento del esquema general 5. Estudio del coste
Cuestin 2 (1 punto). En qu se diferencia una bsqueda ciega en profundidad y un esquema de vuelta atrs? Pon un ejemplo. El esquema de vuelta atrs es una bsqueda en profundidad pero en la que se articula un mecanismo para detener la bsqueda en una determinada rama (poda). Para alcanzar una solucin final es necesario que los pasos intermedios sean soluciones parciales al problema. Si un determinado nodo no es una solucin parcial, entonces la solucin final no se puede alcanzar a partir de dicho nodo y la rama se poda. Esto se implementa en el esquema de vuelta atrs mediante la funcin condiciones_de_poda o funcin de factibilidad. El problema de colocar N reinas en un tablero de NxN sin que se amenacen entre s es un problema que se puede resolver mediante vuelta atrs, puesto que en cada nivel de la bsqueda se establece un problema parcial: en el nivel i se trata de colocar i reinas en un tablero de NxN sin que se amenacen entre s. Si un nodo no cumple esta condicin, por muchas ms reinas que se coloquen a continuacin nunca se va a encontrar una solucin final. Cuestin 3 (2 puntos). Demuestra por induccin que el algoritmo de Dijkstra halla los caminos mnimos desde un nico origen hasta todos los dems nodos del grafo. (Solucin en el libro de texto, Brassard, pg. 225). Problema (5 puntos). Utiliza el esquema de divide y vencers para implementar una funcin que tome un vector de enteros y le d estructura de montculo con el menor coste posible. 1. Eleccin del esquema (0 puntos) No es necesario razonar la eleccin del esquema puesto que viene impuesto en el problema. 2. Esquema general (0.5 puntos) 1. Descomponer el ejemplar en subejemplares del mismo tipo que el ejemplar original 2. Resolver independientemente cada subejemplar (subproblema) 3. Combinar los resultados para construir la solucin del ejemplar original Funcin DivideVencers(X) si suficiente_pequeo(X) entonces dev subalgoritmo_bsico(X) si no Descomponer(X, X1..Xn) para i=1 hasta n hacer Yi:=DivideVencers(Xi); fpara Recombinar(Y1..Yn, Y) dev Y fsi
3. Estructuras de datos (0 puntos) No se necesita ninguna estructura adicional a parte del vector de entrada. 4. Algoritmo completo (3 puntos) Como se trata de un rbol binario, descomponemos el problema en los dos subrboles bajo el nodo i, es decir, el que tiene por raz 2i y el que tiene por raiz 2i+1. Cada subrbol a su vez debe tener estructura de montculo lo que resulta un problema del mismo tipo que el original y, por tanto, corresponde a sendas llamadas recursivas, una para 2i y otra para 2i+1. Por ltimo, hay que colocar la raz i en su lugar. Para ello, hay que hundirla. Procedimiento crear_montculo(i, M[1..m]) si 2i<m entonces crear_montculo(2i, M) fsi si (2i+1)<m entonces crear_montculo(2i+1, M) fsi si (2im) entonces hundir(M, i) fsi M[8] 2 M[4] 4 M[5] M[9] 1 6 M[10] 7 5 M[6] M[7] 2 M[2] 7 M[3] 9 M[1]
La llamada inicial ser: crear_montculo(1,M). Como puede observarse, dividir el vector en dos mitades M[1..m/2], M[(m/2)+1..m] y tratar de resolver cada una de ellas supone un error. Una solucin que recorra completamente el vector y proceda a hundir o flotar cada elemento siempre tendr mayor coste. Ya que estamos en un esquema divide y vencers, podemos plantear el procedimiento hundir como un problema de reduccin. nicamente se tiene que decidir si el nodo debe intercambiarse por alguno de sus hijos, y en caso afirmativo intercambiarse con el mayor de ellos y realizar la correspondiente llamada recursiva para seguir hundindose. Procedimiento hundir(T[1..n], i) hmayor:=i si (2i n) y (T[2i] > T[hmayor]) entonces hmayor=2i
fsi si (2i < n) y (T[2i+1] > T[hmayor]) entonces hmayor=2i+1 fsi si (hmayor > i) entonces intercambiar(T[i], T[hmayor]) hundir(T[1..n], hmayor) fsi 5. Estudio del coste (1.5 puntos) El coste del procedimiento hundir se puede plantear mediante una recurrencia con reduccin del problema por divisin, ya que hundir prosigue por uno de los dos subrboles y, por tanto, el problema se ha reducido a la mitad. T(n)= cnk aT(n/b)+cnk (nk) (nk log n) (nlogb a) si 0nbk
T(n)
a=1; b=2; cnk=c, k=0; a=bk luego T(n)(log n) El coste de crear_montculo puede expresarse, entonces mediante la siguiente recurrencia: T(n)=2T(n/2)+log n Sin embargo, esta recurrencia no se puede resolver con la frmula anterior puesto que la parte no recursiva no tiene una complejidad polinomial. Para resolverlo, vamos a utilizar un cambio de variable: Sea h la altura del montculo de n nodos: h=log2 n. En cada llamada recursiva bajamos un nivel por lo que el problema se puede expresar mediante una recurrencia con reduccin del problema por sustraccin. Es decir, si en cada paso se baja un nivel, el problema se reduce en uno. T(n)= cnk aT(n-b)+cnk (nk) (nk+1) (an div b) si a<1 si a=1 si a>1 si 0n<b si nb
T(n)
En el caso de hundir T(h)=T(h-1)+c, con a=1 y b=1, luego T(h)(h), que deshaciendo el cambio de variable lleva a un tiempo en funcin de n: T(n)(log n) como habamos demostrado antes. Sin embargo, ahora ya podemos plantear la recurrencia para crear_montculo: T(h)=2T(h-1)+h, donde a=2 y b=1 y, por tanto, T(h)(2h). Deshaciendo el cambio de variable: 2h=2log2 n=n, y T(n)(n), que es el menor coste posible para dar estructura de montculo a un vector. NOTA: cualquier solucin que tenga mayor coste no ser puntuada.
Programacin III Septiembre 2005 Original
Cuestin 1 (2 puntos). Suponga que N personas numeradas de 1 a N deben elegir por votacin a una entre ellas. Sea V un vector en el que la componente V[i] contiene el nmero del candidato que ha elegido el votante i. Qu algoritmo utilizaras para determinar con un coste lineal si una persona ha obtenido ms de la mitad de los votos?
Cuestin 2 (1 punto). En el contexto de elegir un esquema algortmico para resolver un problema de optimizacin con restricciones, cundo se puede resolver mediante un esquema voraz y en qu casos sera necesario utilizar un esquema de ramificacin y poda? Cuestin 3 (2 puntos). Sea T(n)=4n2-3n+2 el tiempo de ejecucin de un algoritmo. Demuestra si es cierta o falsa cada una de las siguientes afirmaciones (0.5 puntos cada una):
T (n) O(n 2 log n) T ( n) O ( n 3 ) T (n) (n log n) T ( n) O ( n 2 )
PROBLEMA (5 puntos). Sea V[1..N] un vector con la votacin de unas elecciones. La componente V[i] contiene el nombre del candidato que ha elegido el votante i. Implementa un programa cuya funcin principal siga el esquema divide y vencers, que decida si algn candidato aparece en ms de la mitad de las componentes (tiene mayora absoluta) y que devuelva su nombre. Sirva como ayuda que para que un candidato tenga mayora absoluta considerando todo el vector (al menos N/2+1 de los N votos), es condicin necesaria pero no suficiente que tenga mayora absoluta en alguna de las mitades del vector. La resolucin del problema debe incluir, por este orden:
1. Descripcin del esquema divide y vencers y su aplicacin al problema (0.5 puntos). 2. Algoritmo completo a partir del refinamiento del esquema general (3 puntos) 3. Estudio del coste del algoritmo desarrollado (1.5 puntos)
Programacin III
Solucin
Prueba Presencial Original Septiembre de 2005
Prueba Presencial
Cuestin 1 (2 puntos). Suponga que N personas numeradas de 1 a N deben elegir por votacin a una entre ellas. Sea V un vector en el que la componente V[i] contiene el nmero del candidato que ha elegido el votante i. Qu algoritmo utilizaras para determinar con un coste lineal si una persona ha obtenido ms de la mitad de los votos? Podra utilizarse una estrategia similar a la que emplea para ordenacin el algoritmo de la casilla (pgina 80 del libro), pero trasladado al conteo de elementos. La siguiente funcin almacena en el vector votos el nmero de votos que va sumando cada candidato votado. Devuelve un valor TRUE si hay alguno con mayora indicando de qu candidato se trata: funcin contar_votos(V[1..N) dev (booleano, elegido) votos[1..N]=0; para i=1 hasta N hacer votos[V[i]]=votos[V[i]]+1; si votos[V[i]]>N/2 entonces devolver (TRUE,V[i]) fsi; fpara devolver (FALSE,0); Cuestin 2 (1 punto). En el contexto de elegir un esquema algortmico para resolver un problema de optimizacin con restricciones, cundo se puede resolver mediante un esquema voraz y en qu casos sera necesario utilizar un esquema de ramificacin y poda? Para resolverlo con un esquema voraz es necesario que exista una funcin de seleccin de candidatos y una funcin de factibilidad que decida si se acepta o rechaza el candidato, de manera que la decisin es irreversible. Si no es posible encontrar las funciones de seleccin y de factibilidad de manera que se garantice que la eleccin de un candidato lleva a la solucin ptima, entonces optaramos por otro esquema como el de ramificacin y poda. Cuestin 3 (2 puntos). Sea T(n)=4n2-3n+2 el tiempo de ejecucin de un algoritmo. Demuestra si es cierta o falsa cada una de las siguientes afirmaciones (0.5 puntos cada una): Recordamos la regla del lmite:
c entonces f (n) lm = 0 entonces n g ( n ) + entonces

a) T(n) O(n2 ln n)
f ( n ) ( g ( n )) f ( n ) O ( g ( n )), f ( n ) ( g ( n )) f ( n ) ( g ( n )), f ( n ) ( g ( n ))
4n 2 3n + 2 8n 3 8 = lm = =0 2 n n 2n ln n + n 2 ln n + 3 n ln n lm
Luego pertenece al orden indicado y la cuestin a) es FALSA b) T(n) O(n3)
lm
4n 2 3n + 2 8n 3 8 = lm = =0 3 n n 3n 2 6n n
Por lo que T(n) pertenece a O(n3 ) y la cuestin b) es FALSA c) T(n) (n log n)
con lo que c) es CIERTO
4n 2 3n + 2 8n 3 8 lm = lm = = + n n ln n + 1 1 n ln n n
d) T(n) O(n2)
4n 2 3n + 2 8n 3 8 = lm = = 4 + 2 n n 2n 2 n lm
En este caso, al ser T(n) (n2) se cumple tambin que T(n) O (n2) luego d) es CIERTO Problema (5 puntos). Sea V[1..N] un vector con la votacin de unas elecciones. La componente V[i] contiene el nombre del candidato que ha elegido el votante i. Implementa un programa cuya funcin principal siga el esquema divide y vencers, que decida si algn candidato aparece en ms de la mitad de las componentes (tiene mayora absoluta) y que devuelva su nombre. Sirva como ayuda que para que un candidato tenga mayora absoluta considerando todo el vector (al menos N/2+1 de los N votos), es condicin necesaria pero no suficiente que tenga mayora absoluta en alguna de las mitades del vector. La resolucin del problema debe incluir, por este orden: 1. Descripcin del esquema divide y vencers y su aplicacin al problema (0.5 puntos). El esquema general Divide y Vencers consiste en: 1. Descomponer el ejemplar en subejemplares del mismo tipo que el original 2. Resolver independientemente cada subejemplar 3. Combinar los resultados para construir la solucin del ejemplar original Ms formalmente: Funcin DivideVencers(X) dev Y si suficiente_pequeo(X) entonces dev subalgoritmo_bsico(X) si no (X1..Xn)=Descomponer(X); para i=1 hasta n hacer Yi:=DivideVencers(Xi); fpara Y=Recombinar(Y1..Yn); dev Y; fsi
2. Algoritmo completo a partir del refinamiento del esquema general (3 puntos) funcin contar(V[1..N], i, j) dev (tiene_mayora, candidato, num_votos) si (i==j) entonces dev (TRUE, V[i], 1) si no /* Descomponer */ (tiene_mayora1, candidato1, num_votos1)=contar(V, i, (i+j)2); (tiene_mayora2, candidato2, num_votos2)=contar(V, (i+j)2+1, j); /* Recombinar */ si tiene_mayora1 entonces para k desde (i+j)2+1 hasta j hacer si es_igual(V[k], candidato1) entonces num_votos1=num_votos1+1; fsi fpara si (num_votos1>(j-i+1)/2) entonces devolver (cierto, candidato1, num_votos1); fsi fsi si tiene_mayora2 entonces para k desde i hasta (i+j)2 hacer si es_igual(V[k], candidato2) entonces num_votos2=num_votos2+1; fsi fpara si (num_votos2>(j-i+1)/2) entonces devolver (cierto, candidato2, num_votos2); fsi fsi devolver (falso,,0); fsi Llamada inicial contar(V,1,N);
3. Estudio del coste del algoritmo desarrollado (1.5 puntos) Planteamos la ecuacin de recurrencia T(n) = 2T(n2) + n2 + n2 = 2T(n2) + n La reduccin del problema se realiza mediante divisin, cuyos casos son los siguientes: (nk) T(n) = (nk log n) (nlogba) si a<bk si a=bk si a>bk
donde:
n: tamao del problema a: nmero de llamadas recursivas n/b: tamao del subproblema nk: coste de las instrucciones que no son llamadas recursivas
Aplicado a nuestro problema: cnk=n; k=1; b=2; a=2; bk=21=2 a=bk luego T(n) (n log n)
Programacin III Septiembre 2005 Reserva Cuestin 1 (1 punto). Dado m = [ 2, 6, 4,12, 7, 4, 4] . Comprobar si es o no montculo de mnimos. Si no lo es, programar una funcin para convertirlo en montculo y aplicarla a m. Sino, programar una funcin de aadir elemento mediante la funcin flotar y aplicarlo al valor 3. En ambos casos escribir el montculo resultante y detallar todos los pasos. Cuestin 2 (2 puntos). Demostrar formalmente si existe relacin de pertenencia entre f(n) y O ( g ( n ) )
Y tambin entre g(n) y O ( f ( n ) ) considerando f ( n ) = 2n y g ( n ) = 22 n .
Cuestin 3 (2 puntos). Analizar y hallar el coste de los algoritmos siguientes (Considerar de orden ( n 2 ) la funcin h ( n, r , i ) )
PROCEDIMIENTO a (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 3 ENTONCES DEVOLVER(1); SINO COMIENZO r a (n DIV 2, k-1); r r + a (n DIV 2, k+1);
PARA i 1 HASTA n^2 HACER r r + k; PROCEDIMIENTO b (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 4 ENTONCES DEVOLVER(1); SINO COMIENZO r r + b (n DIV 2, k+1); PARA i 1 HASTA n HACER COMIENZO r h (n,r,i); r r + h (n,r-1,i); FIN r r + b (n DIV 2, k+2); DEVOLVER (r); FIN FIN
DEVOLVER (r); FIN FIN
Problema (5 puntos). El Sudoku es un pasatiempo consistente en rellenar con cifras del 1 al 9 una cuadrcula de 81 (9x9) casillas distribuidas a su vez en 9 cajas de 3x3. El juego consiste en rellenar cada caja de 9 casillas con cifras del 1 al 9 sin repetirlas. No se pueden repetir tampoco cifras en lneas o columnas de la cuadrcula. Se pide disear un algoritmo que complete por nosotros este pasatiempo. La tabla adjunta muestra un ejemplo resuelto.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. (0,25) 2. Refinamiento e identificacin con el problema. (0,5) 3. Estructuras de datos. (0,25) 4. Algoritmo completo a partir del refinamiento del esquema general. (3,5) 5. Estudio del coste. (0,5)
RESPUESTAS EXAMEN Programacin III. Septiembre 2005 (Reserva) Cuestin 1 (1 punto). Dado m = [ 2, 6, 4,12, 7, 4, 4] . Comprobar si es o no montculo de mnimos. Si no lo es, programar una funcin para convertirlo en montculo y aplicarla a m. Sino, programar una funcin de aadir elemento mediante la funcin flotar y aplicarlo al valor 3. En ambos casos escribir el montculo resultante y detallar todos los pasos.
12
Como es un montculo de mnimos inserto el valor 3 al montculo m = [ 2, 6, 4,12, 7, 4, 4] , quedando de la siguiente manera m = [ 2, 6, 4,12, 7, 4, 4,3] . Para que el vector siga manteniendo la estructura de montculo utilizo el procedimiento flotar, comparo T [ 4] > T [8] como es mayor entonces k=4 y hago intercambio de j y k. m = [ 2, 6, 4,3, 7, 4, 4,12] Con la variable actualizada k=4 vuelvo a comparar T [ 2] > T [ 4] como es mayor entonces k=2 y hago intercambio de j y k.
m = [ 2,3, 4, 6, 7, 4, 4,12]
Con la variable actualizada k=2 vuelvo a comparar T [1] > T [ 2] , en este caso no es mayor y por lo tanto la variable j=k terminando el procedimiento. El montculo queda as: m = [ 2,3, 4, 6, 7, 4, 4,12]
Proc Flotar(V[1...n],i) k i Repetir jk Si j > 1 y V[j 2] < V[k] entonces k j 2 Intercambiar V[j] y [k] Hasta j = k Fproc
Y tambin entre g(n) y O ( f ( n ) ) considerando f ( n ) = 2n y g ( n ) = 22 n . Primer compruebo que f(n) est en O ( g ( n ) )
Cuestin 2 (2 puntos). Demostrar formalmente si existe relacin de pertenencia entre f(n) y O ( g ( n ) )
lim
f (n) 2n 2n 1 1 = lim 2 n = lim n n = lim n = lim = 0 n 2 n 2 2 n 2 n 2 g ( n)
Y por la regla de los lmites deducimos que f ( n ) O ( g ( n ) ) pero g ( n ) O ( f ( n ) ) En la segunda cuestin compruebo que g(n) est en O ( f ( n ) )
lim
g ( n) 22 n 2n 2n 2n 2 = lim n = lim n = lim = lim = n n 1 n 1 2 f ( n ) n 2
Y por la regla de los lmites deducimos que g ( n ) O ( f ( n ) ) pero f ( n ) O ( g ( n ) ) Regla del lmite:
1. Si lim 2. Si lim 3. Si lim
f (n) 0 , entonces f ( n ) O ( g ( n ) ) pero g ( n ) O ( f ( n ) ) g ( n) f ( n) + , entonces f ( n ) O ( g ( n ) ) pero g ( n ) O ( f ( n ) ) g ( n)
f ( n) + , entonces f ( n ) O ( g ( n ) ) y g ( n)
g ( n) O ( f ( n ))
Cuestin 3 (2 puntos). Analizar y hallar el coste de los algoritmos siguientes (Considerar de orden ( n 2 ) la funcin h ( n, r , i ) )
PROCEDIMIENTO a (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 3 ENTONCES DEVOLVER(1); SINO COMIENZO r a (n DIV 2, k-1); r r + a (n DIV 2, k+1);
PARA i 1 HASTA n^2 HACER r r + k;
DEVOLVER (r); FIN FIN
PROCEDIMIENTO b (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 4 ENTONCES DEVOLVER(1); SINO COMIENZO r r + b (n DIV 2, k+1); PARA i 1 HASTA n HACER COMIENZO r h (n,r,i); r r + h (n,r-1,i); FIN r r + b (n DIV 2, k+2); DEVOLVER (r); FIN FIN
El procedimiento uno tiene una instruccin condicional de coste constante. Dentro de la condicin tiene: o bien una instruccin constante, que no tenemos en cuenta para el clculo, o bien dos llamadas recursivas, ambas invocan la funcin con un tamao n/2. //En el segundo caso de la llamada recursiva hay otra instruccin simple aadida. Un bucle en el que se repite n2 veces un clculo consistente en una instruccin constante La expresin queda T(n) = T(n/2) + T(n/2) + n2 (1) lo que equivale a: T(n) = 2T(n/2) + n2. Aplicando la resolucin genrica de las expresiones del tipo T(n) = aT(n/b)+cnk lo que equivale a T(n) = 2T(n/2) + n2 y siendo 2 < 2 2 el coste es O(n2). a = 2, b = 2, k = 2 el segundo algoritmo: est formado por una instruccin condicional de coste constante cuyo cuerpo incluye secuencialmente: (i) una llamada recursiva de tamao n/2, (ii) un bucle en el que se repite n veces un clculo consistente en llamar dos veces a una funcin h(n; r; i) de coste cuadrtico, /*ms una instruccin simple*/, y por ltimo (v) una instruccin simple, que no tenemos en cuenta para el clculo, y otra llamada recursiva de tamao n/2. Sumando los trminos nos sale T(n) = T(n/2)+ n (2n2)+T(n/2), lo que equivale a T(n) = 2T(n/2) + 2n3 , Aplicando la resolucin genrica de las expresiones del tipo T(n) = aT(n/b) + cnk y siendo 2 < 2 3 el coste es O(n3). a = 2, b = 2, k = 3
Problema (5 puntos). El Sudoku es un pasatiempo consistente en rellenar con cifras del 1 al 9 una cuadrcula de 81 (9x9) casillas distribuidas a su vez en 9 cajas de 3x3. El juego consiste en rellenar cada caja de 9 casillas con cifras del 1 al 9 sin repetirlas. No se pueden repetir tampoco cifras en lneas o columnas de la cuadrcula. Se pide disear un algoritmo que complete por nosotros este pasatiempo. La tabla adjunta muestra un ejemplo resuelto.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. (0,25) 2. Refinamiento e identificacin con el problema. (0,5) 3. Estructuras de datos. (0,25) 4. Algoritmo completo a partir del refinamiento del esquema general. (3,5) 5. Estudio del coste. (0,5)
Cuestin 1 (2,5 puntos). En qu se diferencia una bsqueda ciega en profundidad y un esquema de vuelta atrs? (0.5 puntos)
Cuestin 2 (1,5 puntos). Declara en Java o en Mdula-2 las clases y/o estructuras de datos que utilizaras en el problema del Sudoku (prctica de este ao) para comprobar en un tiempo de ejecucin constante respecto a la dimensin n del tablero (nxn) que una casilla contiene un valor factible. Cuestin 3 (2 puntos). Dado el siguiente grafo, rellena la tabla adjunta indicando paso a paso cmo el algoritmo de Dijkstra encuentra todos los caminos de menor coste desde el nodo 1.
Distancias desde 1
Nodo Precedente
Problema (4 puntos). Una empresa de montajes tiene n montadores con distintos rendimientos segn el tipo de trabajo. Se trata de asignar los prximos n encargos, uno a cada montador, minimizando el coste total de todos los montajes. Para ello se conoce de antemano la tabla de costes C[1..n,1..n] en la que el valor cij corresponde al coste de que el montador i realice el montaje j. Se pide:
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. (0,5) 2. Escribir el esquema general. (0,5) 3. Estructuras de datos. (0,5) 4. Algoritmo completo a partir del refinamiento del esquema general. (2,5)
RESPUESTAS EXAMEN Programacin III. Febrero 2006 (Primera Semana) Cuestin 1 (2,5 puntos). En qu se diferencia una bsqueda ciega en profundidad y un esquema de vuelta atrs? (0.5 puntos) La bsqueda ciega explora todas las ramas alternativas mientras que en un esquema de vuelta atrs se establecen condiciones de poda que determinan si una rama puede alcanzar o no una solucin final. Si se determina que no es posible, entonces no se prosigue la bsqueda por dicha rama (se poda). Los problemas aptos para un esquema de vuelta atrs permiten expresar los nodos intermedios como soluciones parciales al problema. Aquellos nodos que no sean soluciones parciales no permiten alcanzar una solucin final y, por tanto, su rama se poda. Por ejemplo, el problema de poner N reinas en un tablero de NxN sin que se amenacen entre s, requiere ir solucionando la siguiente secuencia de soluciones parciales: poner 1 reina en un tablero de NxN sin que est amenazada (trivial) poner 2 reinas en un tablero de NxN sin que se amenacen entre s ... poner k reinas en un tablero de NxN sin que se amenacen entre s ... poner N reinas en un tablero de NxN sin que se amenacen entre s (solucin final) Si por una rama no se puede resolver el problema para k, entonces evidentemente no se podr resolver para N, por muchos intentos de aadir reinas hagamos. En el espacio de bsqueda, qu significa que un nodo sea k-prometedor? (1 punto) Significa que es solucin parcial para las k primeras componentes de la solucin y, por tanto, todava es posible encontrar una solucin final (incluyendo las N componentes). En el problema de las N reinas habramos colocado k reinas sin que se coman entre s. Que hay que hacer para decidir si un vector es k-prometedor sabiendo que es una extensin de un vector (k-1)-prometedor? (1 punto) Si es (k-1)-prometedor quiere decir que es solucin parcial para las primeras k-1 componentes y que, por tanto, estas cumplen las restricciones necesarias entre s y no hay que volver a verificarlas. Entonces, para decidir si una extensin considerando la siguiente componente k conforma un nodo k-prometedor, lo nico que hay que hacer es verificar si esta nueva componente k cumple las restricciones respecto a las otras k-1.
Cuestin 2 (1,5 puntos). Declara en Java o en Mdula-2 las clases y/o estructuras de datos que utilizaras en el problema del Sudoku (prctica de este ao) para comprobar en un tiempo de ejecucin constante respecto a la dimensin n del tablero (nxn) que una casilla contiene un valor factible. Existen varias alternativas, pero de nada sirve que verificar una casilla se realice en tiempo constante si luego actualizar su valor se realiza en tiempo lineal. En la siguiente solucin se declaran tres tablas de booleanos que indican si ya hay o no un determinado valor en una determinada fila, columna o regin, respectivamente. Si no es as, entonces es factible poner el valor en la casilla. Tanto la funcin de verificacin como las de actualizacin tienen un coste computacional constante.
public class Tablero { int N=9; int subN=(int)Math.sqrt(N); boolean val_en_fil[][] = new boolean[N][N]; boolean val_en_col[][] = new boolean[N][N]; boolean val_en_reg[][] = new boolean[N][N]; boolean valorFactible(int fil, int col, int val){ int g=region(fil,col); re return (!val_en_fil[fil][val] && !val_en_col[col][val] && !val_en_reg[reg][val]); } void poner(int fil, int col, int val) { int reg=region(fil,col); val_en_fil[fil][val]=true; val_en_col[col][val]=true; val_en_reg[reg][val]=true; } void quitar(int fil, int col, int val) { int reg=region(fil,col); val_en_fil[fil][val]=false; val_en_col[col][val]=false; val_en_reg[reg][val]=false; } int region(int fil, int col) { return (col/subN)*subN+fil/subN; // divisin entera } }
Cuestin 3 (2 puntos). Dado el siguiente grafo, rellena la tabla adjunta indicando paso a paso cmo el algoritmo de Dijkstra encuentra todos los caminos de menor coste desde el nodo 1.
Distancias desde 1
Nodo Precedente
0 1 2 3
{1} {1,2} {1,2,4} {1,2,3,4}
{2,3,4,5} {3,4,5} {3,5} {5}
2 3 3 3 3
3 9 6 6
4 5 4 4 4
5 14 14 7
2 1 1 1 1
3 1 2 4 4
4 1 2 2 2
5 1 2 2 3
Problema (4 puntos). Una empresa de montajes tiene n montadores con distintos rendimientos segn el tipo de trabajo. Se trata de asignar los prximos n encargos, uno a cada montador, minimizando el coste total de todos los montajes. Para ello se conoce de antemano la tabla de costes C[1..n,1..n] en la que el valor cij corresponde al coste de que el montador i realice el montaje j. Se pide: 1. Determinar qu esquema algortmico es el ms apropiado para resolver el problema. Razonar la respuesta. (0.5 puntos) Se trata de un problema de optimizacin con restricciones. Por tanto, podra ser un esquema voraz o un esquema de ramificacin y poda. Sin embargo descartamos el esquema voraz porque no es posible encontrar una funcin de seleccin y de factibilidad tales que una vez aceptado un candidato se garantice que se va alcanzar la solucin ptima. Se trata, por tanto, de un algoritmo de ramificacin y poda. Escribir el esquema general. (0,5 puntos)
Funcin RamificacinPoda (nodo_raz) dev nodo Montculo:=montculoVaco(); cota:=acotar(nodo_raz); poner((cota,nodo_raz), Montculo); mientras no vaco(Montculo) hacer (cota, nodo):=quitarPrimero(Montculo); si solucin(nodo) entonces devolver nodo; si no para cada hijo en compleciones(nodo) hacer cota:=acotar(hijo); poner((cota,hijo),Montculo); fpara; fsi; fmientras devolver
Indicar que estructuras de datos son necesarias. (0,5 puntos)

nodo=tupla asignaciones: vector[1..N]; ltimo_asignado: cardinal; filas_no_asignadas: lista de cardinal; coste: cardinal; Montculo de mnimos (cota mejor la de menor coste)
Desarrollar el algoritmo completo. (2,5 puntos) Las funciones generales del esquema general que hay que instanciar son: 1. a. solucin(nodo): si se han realizado N asignaciones (ltimo_asignado==N) 2. b. acotar(nodo,costes): nodo.coste + mnimo coste de las columnas no asignadas 3. c. compleciones(nodo,costes): posibilidades para la siguiente asignacin (valores posibles para asignaciones[ltimo_asignado+1])
4.
Funcin asignacin(costes[1..N,1..N]) dev solucin[1..N] Montculo:=montculoVaco(); nodo.ltimo_asignado=0; nodo.coste=0; cota:=acotar(nodo,costes); poner((cota,nodo),Montculo); mientras no vaco(Montculo) hacer (cota,nodo):=quitarPrimero(Montculo); si nodo.ltimo_asignado==N entonces devolver nodo.asignaciones; si no para cada hijo en compleciones(nodo,costes) hacer cota:=acotar(hijo,costes); poner((cota,hijo),Montculo); fsi; fmientras devolver ; Funcin acotar(nodo,costes[1..N,1..N]) dev cota cota:=nodo.coste; para columna desde nodo.ltimo_asignado+1 hasta N hacer minimo=; para cada fila en nodo.filas_no_asignadas hacer si costes[columna,fila]<mnimo entonces mnimo:=costes[columna,fila]; fsi fpara cota:=cota+mnimo; fpara devolver cota; Funcin compleciones(nodo,costes[1..N,1..N]) dev lista_nodos lista:=crearLista(); para cada fila en nodo.filas_no_asignadas hacer hijo:=crearNodo(); hijo.ltimo_asignado:=nodo.ltimo_asignado+1; hijo.asignaciones=nodo.asignaciones; hijo.asignaciones[hijo.ltimo_asignado]:=fila; hijo.coste:=nodo.coste+costes[hijo.ltimo_asignado,fila]; hijo.filas_no_asignadas:=nodo.filas_no_asignadas; eliminar(fila,hijo.filas_no_asignadas); aadir(hijo,lista); fpara; devolver lista;
Coste: En este caso nicamente podemos hallar una cota superior del coste del algoritmo por descripcin del espacio de bsqueda. En el caso peor se generan (k-1) hijos por cada nodo del nivel k, habiendo n. Por tanto, el espacio a recorrer siempre ser menor que n!.
4. Desarrollar el algoritmo completo (2.5 puntos) Las funciones generales del esquema general que hay que instanciar son: a. solucin(nodo): si se han realizado N asignaciones (ltimo_asignado==N) b. acotar(nodo,costes): nodo.coste + mnimo coste de las columnas no asignadas c. compleciones(nodo,costes): posibilidades para la siguiente asignacin (valores posibles para asignaciones[ltimo_asignado+1])
Funcin asignacin(costes[1..N,1..N]) dev solucin[1..N] Montculo:=montculoVaco(); nodo.ltimo_asignado=0; nodo.coste=0; cota:=acotar(nodo,costes); poner((cota,nodo),Montculo); mientras no vaco(Montculo) hacer (cota,nodo):=quitarPrimero(Montculo); si nodo.ltimo_asignado==N entonces devolver nodo.asignaciones; si no para cada hijo en compleciones(nodo,costes) hacer cota:=acotar(hijo,costes); poner((cota,hijo),Montculo); fsi; fmientras devolver ; Funcin acotar(nodo,costes[1..N,1..N]) dev cota cota:=nodo.coste; para columna desde nodo.ltimo_asignado+1 hasta N hacer mnimo=; para cada fila en nodo.filas_no_asignadas hacer si costes[columna,fila]<mnimo entonces mnimo:=costes[columna,fila]; fsi fpara cota:=cota+mnimo; fpara devolver cota; Funcin compleciones(nodo,costes[1..N,1..N]) dev lista_nodos lista:=crearLista(); para cada fila en nodo.filas_no_asignadas hacer hijo:=crearNodo(); hijo.ltimo_asignado:=nodo.ltimo_asignado+1; hijo.asignaciones=nodo.asignaciones; hijo.asignaciones[hijo.ltimo_asignado]:=fila; hijo.coste:=nodo.coste+costes[hijo.ltimo_asignado,fila]; hijo.filas_no_asignadas:=nodo.filas_no_asignadas; eliminar(fila,hijo.filas_no_asignadas); aadir(hijo,lista); fpara; devolver lista;
Programacin III Febrero 2006 Segunda semana Cuestin 1 (1 punto). En la prctica obligatoria del presente curso 2005/2006 se ha tenido que disear y desarrollar un algoritmo para resolver el juego del Su-doku. Codifique en java o en modula-2 un algoritmo iterativo que recorra el cuadrado de 3x3 casillas que corresponda a una casilla que ocupa las posiciones i,j del tablero. Cuestin 2 (2 puntos). Sea el famoso problema de la mochila. Se dispone de n objetos y una mochila. Para i= 1,2,,n, el objeto i tiene un peso positivo wi y un valor positivo vi. La mochila puede llevar un peso que no sobrepase W. El objetivo es llenar la mochila de tal manera que se maximice el valor de los objetos almacenados, respetando la limitacin de peso impuesta. Indique qu esquema o esquemas considera ms adecuados para resolver este problema en los siguientes casos: 1. Los objetos se pueden fraccionar, luego se puede decidir llevar una fraccin xi del objeto i, tal que 0 xi 1 para 1 i n. 2. Los objetos no se pueden fraccionar, por lo que un objeto puede o no ser aadido, pero en ste ltimo caso, slo se aade 1. Adems de nombrar el esquema o esquemas, explica el porqu de su eleccin, los aspectos destacados de cmo resolveras el problema y el coste asociado. No se piden los algoritmos. Cuestin 3 (3 puntos). Un dentista pretende dar servicio a n pacientes y conoce el tiempo requerido por cada uno de ellos, siendo ti , i= 1,2,,n el tiempo requerido por el paciente i. El objetivo es minimizar el tiempo total que todos los clientes estn en el sistema, y como el n de pacientes es fijo, minimizar la espera total equivale a minimizar la espera media. Se pide: 1. Identificar una funcin de seleccin que garantice que un algoritmo voraz puede construir una planificacin ptima. (0.5 puntos) 2. Hacer una demostracin de la optimalidad de dicha funcin de seleccin. (2.5 puntos) Solucin: estn solucionados en el libro base de la asignatura, apartado 6.6.1, pg 231.
Problema (4 puntos). Dos socios que conforman una sociedad comercial deciden disolverla. Cada uno de los n activos que hay que repartir tiene un valor entero positivo. Los socios quieren repartir dichos activos a medias y, para ello, primero quieren comprobar si el conjunto de activos se puede dividir en dos subconjuntos disjuntos, de forma que cada uno de ellos tenga el mismo valor. La resolucin de este problema debe incluir, por este orden:
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. (1 punto) 2. Estructuras de datos. (0,5 puntos) 3. Algoritmo completo a partir del refinamiento del esquema general. (2 puntos) 4. Estudio del coste ( 0,5 puntos)
RESPUESTAS EXAMEN Programacin III. Febrero 2006 (Segunda Semana) Cuestin 1 (1 punto). En la prctica obligatoria del presente curso 2005/2006 se ha tenido que disear y desarrollar un algoritmo para resolver el juego del Su-doku. Codifique en java o en modula-2 un algoritmo iterativo que recorra el cuadrado de 3x3 casillas que corresponda a una casilla que ocupa las posiciones i,j del tablero. Solucin: Se trataba de encontrar la relacin entre las posiciones i,j del tablero y las posiciones de comienzo del cuadrado de 3x3 que les corresponde en el tablero del Su-doku 9x9. Supongamos que el tablero tiene como ndices 0..8, 0..8 y que i y j son de tipo entero, la relacin se puede establecer de la siguiente manera:
int coordFilaInicioCuadrado = (i / 3) * 3; // divisin entera int coordColumnaInicioCuadrado = (j / 3) * 3; // divisin entera
ahora slo queda hacer el recorrido:

for (int k= coordFilaInicioCuadrado; k < coordFilaInicioCuadrado+3; k++){ for (int l= coordColumnaInicioCuadrado; l < coordColumnaInicioCuadrado+3; l++){ procesar(tab[k][l]); } }
Cuestin 2 (2 puntos). Sea el famoso problema de la mochila. Se dispone de n objetos y una mochila. Para i= 1,2,,n, el objeto i tiene un peso positivo wi y un valor positivo vi. La mochila puede llevar un peso que no sobrepase W. El objetivo es llenar la mochila de tal manera que se maximice el valor de los objetos almacenados, respetando la limitacin de peso impuesta. Indique qu esquema o esquemas considera ms adecuados para resolver este problema en los siguientes casos: 1. Los objetos se pueden fraccionar, luego se puede decidir llevar una fraccin xi del objeto i, tal que 0 xi 1 para 1 i n. 2. Los objetos no se pueden fraccionar, por lo que un objeto puede o no ser aadido, pero en ste ltimo caso, slo se aade 1. Adems de nombrar el esquema o esquemas, explica el porqu de su eleccin, los aspectos destacados de cmo resolveras el problema y el coste asociado. No se piden los algoritmos. Solucin: En el caso a) se puede utilizar el esquema voraz ya que existe una funcin de seleccin que garantiza obtener una solucin ptima. La funcin de seleccin consiste en considerar los objetos en orden decreciente de vi/wi. El coste est en O(n log n), incluyendo la ordenacin de los objetos. Ver pgina 227 del libro base de la asignatura. En el caso b) no se puede utilizar el esquema voraz ya que no existe una funcin de seleccin que garantice obtener una solucin ptima. Al ser un problema de optimizacin se puede utilizar el esquema de ramificacin y poda. Se podran seleccionar los elementos en orden decreciente de vi/wi. As, dado un determinado nodo, una cota superior del valor que se puede alcanzar siguiendo por esa rama se puede calcular suponiendo que la mochila la rellenamos con el siguiente elemento siguiendo el orden decreciente de vi/wi. El coste en el caso peor sera de orden exponencial, ya que en el rbol asociado al espacio de bsqueda, cada nodo tendr dos sucesores que representarn si el objeto se aade o no a la mochila, es decir, O(2n). Sin embargo, sera de esperar que, en la prctica, el uso de la cota para podar reduzca el nmero de nodos que se exploran.
Cuestin 3 (3 puntos). Un dentista pretende dar servicio a n pacientes y conoce el tiempo requerido por cada uno de ellos, siendo ti , i= 1,2,,n el tiempo requerido por el paciente i. El objetivo es minimizar el tiempo total que todos los clientes estn en el sistema, y como el n de pacientes es fijo, minimizar la espera total equivale a minimizar la espera media. Se pide: 1. Identificar una funcin de seleccin que garantice que un algoritmo voraz puede construir una planificacin ptima. (0.5 puntos) 2. Hacer una demostracin de la optimalidad de dicha funcin de seleccin. (2.5 puntos) Solucin: estn solucionados en el libro base de la asignatura, apartado 6.6.1, pg 231. 1. Cuando se sirve a los clientes por orden creciente de tiempos de servicio. 2. Sea P = p1 , p2 ,... pn cualquier permutacin de enteros del 1 al n y sea si = t pi . Si se sirven clientes en el orden P, entonces el tiempo de servicio requerido por el i-simo cliente que haya que servir ser si, y el tiempo total transcurrido en el sistema por todos los clientes es:
T ( P ) = s1 + ( s1 + s2 ) + ( s1 + s2 + s3 ) + ... = ns1 + ( n 1) s2 + ( n 2 ) s3 + ... = ( n k + 1) sk

Supongamos ahora que P no organiza a los clientes por orden de tiempos creciente de servicio. Entonces se puede encontrar dos enteros a y b con a sb , si intercambiamos la posicin de estos dos clientes, obtendremos un nuevo orden de servicio P que es simplemente el orden de P despus de intercambiar los enteros pa y pb . El tiempo total transcurrido pasado en el sistema por todos los clientes si se emplea la planificacin P es:
k =1 n
T ( P ) = ( n - a +1) sb + ( n - b+1) sa + ( n - k +1) sk

k=1 k a,b
La planificacin nueva es preferible a la vieja, porque:

T ( P ) T ( P ) = ( n - a +1)( sa sb ) + ( n - b+1)( sb sa ) =
( b a )( sa sb ) > 0
Problema (4 puntos). Dos socios que conforman una sociedad comercial deciden disolverla. Cada uno de los n activos que hay que repartir tiene un valor entero positivo. Los socios quieren repartir dichos activos a medias y, para ello, primero quieren comprobar si el conjunto de activos se puede dividir en dos subconjuntos disjuntos, de forma que cada uno de ellos tenga el mismo valor. La resolucin de este problema debe incluir, por este orden: (PROBLEMA 6.16 U.M., EDMA 470)
Solucin: 1. No se puede encontrar una funcin de seleccin que garantice, sin tener que reconsiderar decisiones, una eleccin de los activos que cumpla con la restriccin del enunciado, por ello no se puede aplicar el esquema voraz. Tampoco se puede dividir el problema en subproblemas que al combinarlos nos lleven a una solucin. Al no ser un problema de optimizacin, el esquema de exploracin de grafos ms adecuado es el esquema vuelta-atrs. Vuelta atrs es un recorrido en profundidad de un grafo dirigido implcito. En l una solucin puede expresarse como una n-tupla [x1, x2, x3, xn], donde cada xi, representa una decisin tomada en la etapa i-sima, de entre un conjunto finito de alternativas.
Descripcin algortmica del esquema:

funcin vuelta-atrs(e: ensayo) si valido(e) entonces dev e sino listaEnsayos complecciones(e) mientras vacia(listaEnsayos) resultado hacer hijo primero(listaEnsayos) listaEnsayos resto(listaEnsayos) si condicionesDePoda(hijo) entonces resultado vuelta-atrs(hijo) fsi fmientras dev resultado fsi ffuncin
Otra posible descripcin:

funcin vuelta-atrs(v[1..k]: nTupla) si solucion(v) entonces dev v sino Para cada vector w k+1-prometedor hacer si condicionesDePoda(w) entonces vuelta-atrs(w[1..k+1]) fsi fpara fsi ffuncin
En este caso, el espacio de bsqueda es un rbol de grado 2 y altura n+1. Cada nodo del i-simo nivel tiene dos hijos correspondientes a si el i-simo activo va a un socio o al otro. Para poder dividir el conjunto de activos en dos subconjuntos disjuntos, de forma que cada uno de ellos tenga el mismo valor, su valor debe ser par. As, si el conjunto inicial de activos no tiene un valor par el problema no tiene solucin.
2. Descripcin de las estructuras de datos necesarias. El conjunto de activos y sus valores se representa en un array de enteros v= [v1, v2, v3, vn], donde cada vi representa el valor del activo i-simo. La solucin se representa mediante una array de valores x= [x1, x2, x3, xn], donde cada xi, podr tomar el valor 1 o 2 en funcin de que el activo i-simo se asigne al subconjunto del un socio o del otro. Un array de dos elementos, suma, que acumule la suma de los activos de cada subconjunto.
3. Algoritmo completo a partir del refinamiento del esquema general. En esta solucin se sigue el segundo de los esquemas planteados en el apartado 2. Una posible condicin de poda consistir en que se dejarn de explorar aquellos nodos que verifiquen que alguno de los dos subconjuntos que se van construyendo tiene un valor mayor que la mitad del valor total.
funcin Solucion (k: entero; suma: array[1..2]) dev booleano
si (k = n) AND (suma[1] = suma [2]) entonces dev Verdadero sino dev Falso fsi ffuncion
funcin SeparacionSociosMitad (v: array[1..n], k: entero, suma: array[1..2], sumaTotal: entero) dev x: array[1..n]; separacion: boolean si Solucion (k, suma) entonces dev x, Verdadero sino para i desde 1 hasta 2 hacer x[k] i suma[i] suma[i] + v[k] si suma[i] <= (sumaTotal DIV 2) entonces si k < n entonces x SeparacionSociosMitad(v, k+1, suma, sumaTotal) fsi sino suma[i] suma[i] - v[k] fsi fpara fsi ffuncin funcin ProblemaSeparacionSociosMitad (v: n-tupla) dev x: n-tupla; separacion: boolean para i desde 1 hasta n hacer sumaTotal sumaTotal + v[i] fpara si par(sumTotal) entonces dev SeparacionSociosMitad (v, 1, suma[0,0], sumaTotal) sino dev 0 fsi ffuncion
Llamada inicial ProblemaSeparacionSociosMitad (v); 4. Estudio del coste del algoritmo desarrollado. En este caso, el coste viene dado por el nmero mximo de nodos del espacio de bsqueda, esto es: T(n) O(2n)
Programacin III Septiembre 2006 Original
Cuestin 1 (2 puntos). Demuestra que el tiempo de ejecucin en funcin de n del siguiente fragmento de cdigo est acotado superiormente por ( n 2 ) e inferiormente por ( n ) (1,5 puntos). Demuestra tambin su orden exacto de complejidad (0,5 puntos).
para i desde 1 hasta n hacer para j desde 1 hasta n div i hacer escribir i,j,k; fpara fpara
Cuestin 2 (2 puntos). (1,5 puntos):
Escribe la salida al realizar la llamada pinta(5), dado el siguiente cdigo
funcion pinta (int n) si n>0 entonces escribir n; pinta (n-1); escribir n-1; fsi
Cuestin 3 (2 puntos). Dibuja cmo evolucionara el siguiente vector al ordenarlo mediante el algoritmo de ordenacin rpida (Quicksort). Indica nicamente cada una de las modificaciones que sufrira el vector.
6 5 1 2 3 4 7 8 9
Problema (4 puntos). Desarrollar un programa que compruebe si es posible que un caballo de ajedrez mediante una secuencia de sus movimientos permitidos recorra todas las casillas de un tablero NxN a partir de una determinada casilla dada como entrada y sin repetir ninguna casilla. Se pide:
1. 2. 3. 4. Determinar qu esquema algortmico es el ms apropiado para resolver el problema. Razonar la respuesta y escribir el esquema general (0.5 puntos) Indicar que estructuras de datos son necesarias (0.5 puntos) Desarrollar el algoritmo completo en el lenguaje de programacin que utilizaste para la prctica (2.5 puntos) Hallar el orden de complejidad del algoritmo desarrollado (0.5 puntos)
Programacin III
Cdigo de asignatura (marcar con una X): Sistemas: __ 402048 (plan viejo) __ 532044 (plan nuevo) Gestin: __ 41204- (plan viejo) __ 542046 (plan nuevo)
Prueba Presencial Ordinario Septiembre de 2006

DNI: _______________________
Apellidos: ___________________________________________________________________________________
Nombre: ______________________________ Centro donde entreg la prctica: ____________________ e-mail: ___________________
Cuestin 1 (2 puntos). Demuestra que el tiempo de ejecucin en funcin de n del siguiente fragmento de cdigo est acotado superiormente por O(n2) e inferiormente por (n) (1.5 puntos). Demuestra tambin su orden exacto de complejidad (0.5 puntos). para i desde 1 hasta n hacer para j desde 1 hasta n div i hacer escribir i,j,k; fpara fpara Supn que el coste de escribir es constante. Solucin: En primer lugar debemos plantear el tiempo de ejecucin T(n) en funcin de n. Para ello, vamos a fijarnos en la instruccin barmetro (la instruccin que se ejecuta ms veces) y vamos a contar cuntas veces se ejecuta. Puesto que todas las instrucciones tienen un coste constante, la complejidad del programa estar en el orden del nmero de veces que se ejecute la instruccin barmetro.
T ( n ) = 1 =
i =1 j =1 i =1
n
n /i
n n 1 = n i i =1 i
menor que n. Por tanto, T(n) nn, o en otras palabras, T(n) est acotado superiormente por n2: T(n)O(n2) como queramos demostrar. Por otra parte,
1 i es un sumatorio de n elementos menores o iguales que 1, por lo que su suma total ser i =1
i
i =1
es mayor que 1 y, por tanto T(n) n1, o en otras palabras, T(n) est
acotado inferiormente por n: T(n)(n) como queramos demostrar.
Para demostrar el orden exacto es necesario saber cmo crece la serie podemos aproximar la serie con la integral:
n
i
i =1
. Para ello,
como el ln(n). As pues, se pueden encontrar dos constantes c y d tal que T(n) est acotado superiormente por cnlog(n) e inferiormente por dnlog(n). En conclusin, el orden exacto de T(n) es nlog(n): T(n)(n log n) Cuestin 2 (2 puntos). Escribe la salida al realizar la llamada pinta(5), dado el siguiente cdigo (1.5 puntos): funcin pinta(int n) si n>0 entonces escribir n; pinta(n-1); escribir n-1; fsi Demuestra el coste computacional de la funcin pinta suponiendo que escribir tiene coste constante (0.5 puntos). Solucin: La salida sera: 5 4 3 2 1 0 1 2 3 4 Para calcular el coste planteamos una recurrencia con reduccin del problema mediante sustraccin: n: tamao del problemas a: nmero de llamadas recursivas b: reduccin del problema en cada llamada recursiva n-b: tamao del subproblema nk: coste de las instrucciones que no son llamadas recursivas Recurrencia: T(n)= cnk aT(n-b)+cnk (nk) (nk+1) (an div b) si a<1 si a=1 si a>1 si 0n<b si nb
1 x dx que corresponde al logaritmo natural de n. Por tanto, la serie crece tan rpidamente 1
T(n)
a=1; b=1; nk=1; k=0 Por tanto, T(n) (n)
Cuestin 3 (2 puntos). Dibuja cmo evolucionara el siguiente vector al ordenarlo mediante el algoritmo de ordenacin rpida (Quicksort). Indica nicamente cada una de las modificaciones que sufrira el vector. 6 5 1 2 3 4 7 8 9 Solucin: Si se toma como pivote el primer elemento: 6 4 4 2 2 1 5 5 3 3 1 2 1 1 1 1 3 3 2 2 2 4 4 4 3 3 5 5 5 5 4 6 6 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9
Si se toma como pivote el elemento que ocupa la posicin central, en este caso el primer pivote es el elemento que ocupa la posicin quinta, que es el 3: 6 2 2 2 1 1 5 5 1 1 2 2 1 1 5 3 3 3 2 6 6 6 6 4 3 3 3 5 5 5 4 4 4 4 4 6 7 7 7 7 7 7 8 8 8 8 8 8 9 9 9 9 9 9
Problema (4 puntos). Desarrollar un programa que compruebe si es posible que un caballo de ajedrez mediante una secuencia de sus movimientos permitidos recorra todas las casillas de un tablero NxN a partir de una determinada casilla dada como entrada y sin repetir ninguna casilla. Se pide: 1. Determinar qu esquema algortmico es el ms apropiado para resolver el problema. Razonar la respuesta y escribir el esquema general (0.5 puntos) 2. Indicar que estructuras de datos son necesarias (0.5 puntos) 3. Desarrollar el algoritmo completo en el lenguaje de programacin que utilizaste para la prctica (2.5 puntos) 4. Hallar el orden de complejidad del algoritmo desarrollado (0.5 puntos) Solucin:
Una solucin en pseudocdigo se puede encontrar en la pgina 86 del libro de problemas de la asignatura: Esquemas Algortmicos: Enfoque Metodolgico y Problemas Resueltos. Julio Gonzalo Arroyo y Miguel Rodrguez Artacho. Cuadernos de la UNED.
Programacin III Septiembre 2006 Reserva Cuestin 1 (3 puntos). Hallar el coste de los siguientes algoritmos, siendo h(n,r,k) O(n2).
PROCEDIMIENTO uno (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 6 ENTONCES DEVOLVER(1); SINO COMIENZO r uno (n DIV 6, k-1); r r + uno (n DIV 6, k+1); r r + uno (n DIV 6, k+2); PARA i 1 HASTA 2*n HACER COMIENZO r h(n,r,i)+h(n,r-1,i); FIN DEVOLVER (r); FIN FIN PROCEDIMIENTO dos (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 8 ENTONCES DEVOLVER(1); SINO COMIENZO r dos (n DIV 8, k-1); r r + dos (n DIV 8, k+1); PARA i 1 HASTA n/2 HACER COMIENZO r h (n,r,i); r r + h (n,r-1,i); FIN r r + dos (n DIV 8, k+2); DEVOLVER (r); FIN FIN
Cuestin 2 (1 punto). Explica cmo pueden ordenarse n valores enteros positivos en tiempo lineal, sabiendo que el rango de dichos valores es limitado. Explica las ventajas e inconvenientes de ese mtodo. Cuestin 3 (1 punto). Puede un grafo tener dos rboles de recubrimiento mnimo diferentes? En caso afirmativo poner un ejemplo. En caso negativo demostrarlo formalmente.
Problema (5 puntos). Un repartidor de pizzas tiene que entregar K pedidos de diferente valor de recaudacin como mucho hasta la ranura de tiempo concreta que tiene asignada en la tabla adjunta.
Pedido Ranura Recaudacin
1 2 3 4 5 6 7 8 9 1 5 5 6 6 4 4 2 2 60 70 80 20 20 30 50 50 90
Si un pedido se entrega tarde la recaudacin es 0. Construir un algoritmo que devuelva un plan de trabajo para el repartidor que maximice el beneficio. Aplquelo al ejemplo detallando TODOS los pasos.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico. (0,5 puntos) 2. Algoritmo completo a partir del refinamiento del esquema general. (3,5 puntos) 3. Estudio del coste. (1 punto)
RESPUESTAS EXAMEN Programacin III. Septiembre 2006 (Reserva) Cuestin 1 (3 puntos). Hallar el coste de los siguientes algoritmos, siendo h(n,r,k) O(n2).
PROCEDIMIENTO uno (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 6 ENTONCES DEVOLVER(1); SINO COMIENZO r uno (n DIV 6, k-1); r r + uno (n DIV 6, k+1); r r + uno (n DIV 6, k+2); PARA i 1 HASTA 2*n HACER COMIENZO r h(n,r,i)+h(n,r-1,i); FIN DEVOLVER (r); FIN FIN PROCEDIMIENTO dos (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 8 ENTONCES DEVOLVER(1); SINO COMIENZO r dos (n DIV 8, k-1); r r + dos (n DIV 8, k+1); PARA i 1 HASTA n/2 HACER COMIENZO r h (n,r,i); r r + h (n,r-1,i); FIN r r + dos (n DIV 8, k+2); DEVOLVER (r); FIN FIN
El procedimiento uno tiene una instruccin condicional de coste constante. Dentro de la condicin tiene: o bien una instruccin constante, que no tenemos en cuenta para el clculo, o bien tres llamadas recursivas, ambas invocan la funcin con un tamao n/6. //En el segundo y tercer caso de la llamada recursiva hay otra instruccin simple aadida. Un bucle en el que se repite 2n veces un clculo consistente en llamar dos veces a una funcin h(n; r; i) de coste cuadrtico. La expresin queda T(n) = T(n/6) + T(n/6) + T(n/6) + 2n(n2 + n2 )lo que equivale a que T(n) = 3T(n/6) + 4n3. Aplicando la resolucin genrica de las expresiones del tipo T(n) = aT(n/b) + cnk. lo que equivale a T(n) = 3T(n/6) + 4n3 y siendo 3 < 63 el coste es O(n3). a = 3, b = 6, k = 3 el segundo algoritmo: est formado por una instruccin condicional de coste constante cuyo cuerpo incluye secuencialmente: (i) una llamada recursiva de tamao n/8, (ii) una instruccin simple, que no tenemos en cuenta para el clculo, (iii) otra llama recursiva de tamao n/8, (iv) un bucle en el que se repite n/2 veces un clculo consistente en llamar dos veces a una funcin h(n; r; i) de coste cuadrtico, /*ms una instruccin simple*/, y por ltimo (v) una instruccin simple que no tenemos en cuenta para el clculo, y otra llamada recursiva de tamao n/8. Sumando los trminos nos sale T(n) = T(n/8)+T(n/8)+n/2* (2n2)+T(n/8), lo que equivale a T(n) = 3T(n/8) + 2n3 / 2 y siendo 3 < 8 3 el coste es O(n3). a = 3, b = 8, k = 3
( n k ) T ( n ) ( n k log n ) log a n b
Cuestin 2 (1 punto). Explica cmo pueden ordenarse n valores enteros positivos en tiempo lineal, sabiendo que el rango de dichos valores es limitado. Explica las ventajas e inconvenientes de ese mtodo.
Suponiendo que el rango de los valores a ordenar es limitado, es decir, sabemos que por ejemplo el rango de nmeros a ordenar va de 0 a 2000, podemos generar un vector de 2000 elementos de tipo entero que almacenar el nmero de ocurrencias de cada valor de la lista a ordenar en la posicin del vector correspondiente. 1- El vector esta inicializado a 0 (O(n)). 2- Recorremos la lista de valores a ordenar (O(n)). Por cada valor i extrado de la lista, incrementamos el valor de la posicin i del vector. 3- Recorremos el vector generado mostrando los valores generados en el paso anterior (2) y omitiendo aquellas posiciones del vector que contengan un 0.
Las ventajas de esta ordenacin es que el coste en tiempo de bsqueda es constante, sin embargo se requiere un determinado espacio de memoria que estar vaco. Ejemplo: n={1,5,12,15}
V : vector[1..max(n(i))] For (i = 1; i <= n.length; i ++){ V[n(i)] = n; }
Indice 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 valor 1 5 12 15
Cuestin 3 (1 punto). Puede un grafo tener dos rboles de recubrimiento mnimo diferentes? En caso afirmativo poner un ejemplo. En caso negativo demostrarlo formalmente.
Si. Siendo G=(N,A) un grafo conexo no dirigido en donde N es el conjunto de nodos y A es el conjunto de aristas. Suponiendo que cada arista posee una longitud no negativa. Encontrar un rbol de recubrimiento mnimo consiste en hallar un subconjunto T de las aristas de G tal que utilizando solamente las aristas de T, todos los nodos deben quedar conectados, y adems la suma de las longitudes de las aristas de T debe ser tan pequea como sea posible.
Problema (5 puntos). Un repartidor de pizzas tiene que entregar K pedidos de diferente valor de recaudacin como mucho hasta la ranura de tiempo concreta que tiene asignada en la tabla adjunta.
Pedido Ranura Recaudacin
1 2 3 4 5 6 7 8 9 1 5 5 6 6 4 4 2 2 60 70 80 20 20 30 50 50 90
Si un pedido se entrega tarde la recaudacin es 0. Construir un algoritmo que devuelva un plan de trabajo para el repartidor que maximice el beneficio. Aplquelo al ejemplo detallando TODOS los pasos. La resolucin del problema debe incluir, por este orden: eleccin razonada del esquema algortmico y esquema (0,5 puntos), algoritmo completo a partir del refinamiento del esquema general (3,5 puntos) y estudio del coste desarrollado (1 punto).
Eleccin razonada del esquema algortmico y esquema: El divide y vencers queda descartado, ya que no parece posible dividir el problema en subproblemas iguales que puedan resolverse individualmente y posteriormente combinar las soluciones parciales para obtener la solucin final.
Se trata de un problema de optimizacin, por lo que podremos aplicar un voraz o un ramificacin y poda. Cuenta con un conjunto de candidatos que sern los pedidos. Los pedidos debern ser seleccionados de forma que puedan optimizar el beneficio que genera dicha ordenacin y que se realicen dentro de la ranura de tiempo asignada. Se trata de un problema de planificacin con optimizacin del beneficio, por lo que podemos utilizar el esquema voraz que aparece en el libro llamado Secuencia2.
El esquema general de un algoritmo voraz es: Fun voraz (C: conjunto) dev conjunto S solucin vaca mientras vacio(C) y Solucion(S) hacer x seleccionar(C); C=C-{x} Si completable(S U {x}) entonces S S U {x} Fin SI Fin mientras Fin funcin
Donde el conjunto de candidatos C se ordena previamente por orden decreciente de beneficio aportado. La funcin Solucin(S) ser tener tantos elementos en el conjunto S como el mximo valor de las ranuras de tiempo. Seleccionar(C) ser la funcin que elige el elemento de menor valor en la ranura de tiempo que no haya sido incorporado a la solucin. Completable es trivial, puesto que siempre se encontrar una solucin.
Algoritmo completo: Funcin Secuencia (ranura[1..n]: matriz) dev k, F[1..k] P=min(n, max(ranura(i));
J, F : matriz [0..P] Para i 0 hasta P hacer J[i]=0; F[i]=i; Fin para Para i 1 hasta n hacer K=buscar(min(p, ranura(i)); M=F(K); Si M#0 entonces J[M]=i; L=buscar(M-1); F(K)=F(L); Fusionar(K, L); Fin SI Para i 1 hasta P hacer Si J[i]>0 entonces k=k+1 F[k]=J[i] Fin Si Fin Para Para que este algoritmo funcione de forma idnea, primero es necesario ordenar la tabla por orden decreciente de recaudacin. Pedido 1 2 3 4 5 6 7 8 9 Ranura 2 5 5 1 4 2 4 6 6 Recaudaci 90 80 70 60 50 50 30 20 20 n Funcin Secuencia (ranura[1..9]: matriz) dev k, F[1..k] P=min(9, 6); J, F : matriz [0..6] J={0, 0, 0, 0, 0, 0, 0}; F={0, 1, 2, 3, 4, 5, 6} Para i 1 hasta 9 hacer I=1: K=buscar(min(6,2)=buscar(2)=2; M=F(2)=2; Si M#0 entonces J[2]=1; L=buscar(1)=1; F(2)=F(1); Fusionar(K, L); Indice 0 1 2 3 4 5 6 J 0 0 1 0 0 0 0 F 0 1 3 4 5 6 2 I=2: K=buscar(min(6,5)=buscar(5)=4; M=F(4)=5; Si M#0 entonces J[5]=2; L=buscar(4)=3;
F(4)=F(3); Fusionar(K, L); Indice 0 1 2 J 0 0 1 F 0 1 3 2
3 4 5 6 0 0 2 0 4 6 5
I=3: K=buscar(min(6,5)=buscar(5)=3; M=F(3)=4; Si M#0 entonces J[4]=3; L=buscar(3)=2; F(3)=F(2); Fusionar(3, 2); Indice 0 1 2 3 4 5 6 J 0 0 1 0 3 2 0 F 0 1 3 6 2 4 5 I=4: K=buscar(min(6,1)=buscar(1)=1; M=F(1)=1; Si M#0 entonces J[1]=4; L=buscar(0)=0; F(1)=F(0); Fusionar(1, 0); Indice 0 1 2 3 4 5 6 J 0 4 1 0 3 2 0 F 0 3 6 1 4 2 5 I=5: K=buscar(min(6,4)=buscar(4)=1; M=F(1)=3; Si M#0 entonces J[3]=5; L=buscar(2)=0; F(1)=F(0); Fusionar(1, 0); Indice 0 1 2 3 4 5 6 J 0 4 1 5 3 2 0 F 0 6 1 2 3 4 5 I=6: K=buscar(min(6,2)=buscar(2)=0; Rechazamos el candidato
I=7 K=buscar(min(6,4)=buscar(4)=0; Rechazamos el candidato I=8 K=buscar(min(6,6)=buscar(6)=1; M=F(1)=6; Si M#0 entonces J[6]=8; L=buscar(5)=0 F(1)=F(0) Fusionar (1, 0); Indice 0 1 2 3 4 5 6 J 0 4 1 5 3 2 8 F 0 1 2 3 4 5 6 I=9 K=buscar(min(6,6)=buscar(6)=0; Rechazamos el candidato Produce como salida K=6, F={4, 1, 5, 3, 2, 8} donde F contiene el nmero de pedido que debera atenderse para maximizar el beneficio. El beneficio obtenido sera 60+90+50+70+80+20=370
Coste del algoritmo: El coste de ordenar la tabla por orden decreciente de beneficio en el mejor tiempo posible es del orden de O(n log n). El bucle para se recorre n veces, las funciones buscar y fusionar se ejecutarn como mximo 2n y n veces respectivamente, por tanto el coste total del algoritmo es (n log n)+O(n(2n + n)) = (n log n)+O(n2) = O(n2).
ESCUELA TECNICA DE INGENIERIA INFORMATICA DE LA UNED (SISTEMAS Y GESTION) Programacin III Diciembre 2.006 Convocatoria Extraordinaria Tiempo: 2 horas. Ningn Material.
Cuestin 1 (2 puntos). Cuenta el nmero de operaciones elementales que efecta el siguiente fragmento de cdigo f en los casos mejor y peor, y a partir de estos resultados da su orden de ( ) , y su orden exacto ( ) . complejidad, (1) (2) (3) (4) (5) (6) (7) (8) (9) para i desde 1 hasta n hacer para j desde n hasta + 1 dec -1 hacer si [ 1] > [ ] entonces = [ 1]; [ 1] = [ ]; [ ]= fsi fpara fpara
Cuestin 2 (2 puntos). Explica cmo pueden ordenarse n valores positivos en tiempo lineal, sabiendo que el rango de dichos valores es limitado.
Cuestin 3 (2 puntos). Dado el grado de la figura, aplica el algoritmo de Dijkstra para hallar los caminos ms cortos desde el nodo 1 hasta uno de los otros nodos, indicando en cada paso: nodos seleccionados, nodos no seleccionados, vector de distancias y vector de nodos precedentes.
10 13
2
26
3
7
1
5
Problema (4 puntos). Se desea grabar un CD de audio, de capacidad T, con canciones de una coleccin de n elementos, cuyas duraciones , , cumplen: > . Disea un algoritmo que permita almacenar el mximo nmero de canciones en el espacio disponible. Puede suponerse que la coleccin de canciones est ordenada por longitud de menor a mayor. La resolucin de este problema debe incluir, por este orden: 1. Eleccin del esquema ms apropiado, el esquema general y explicacin de su aplicacin al problema (1 punto). 2. Descripcin de las estructuras de datos necesarias (0.5 puntos). 3. Algoritmo completo a partir del refinamiento del esquema general (2 puntos). 4. Estudio del coste del algoritmo desarrollado (0.5 puntos).
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2007 Primera semana
Cuestin 1 (2 puntos). Implementa en Java o Mdula-2 la funcin de estimacin de la cota en el problema del n-puzzle (prctica de este curso). Cuestin 2 (2 puntos). Escribir en pseudocdigo una funcin recursiva de bsqueda binaria en un vector, suponiendo que en algunos casos el elemento no est en el vector (1 punto). Demuestra el coste que tiene la funcin implementada (1 punto).
Cuestin 3 (2 puntos). Dado un vector C [1..n ] de nmeros enteros distintos, y un nmero entero S, se pide plantear un programa de complejidad en ( nlogn ) que determine si existen o no dos elementos de C tales que su suma sea exactamente S. En caso de utilizar algoritmos conocidos no es necesario codificarlos. (Resuelto en Estructuras de datos y mtodos algortmicos pag 338) Problema (4 puntos). Hoy es un da duro para el taller Sleepy. Llegan las vacaciones y a las 8:00 de la maana n clientes han pedido una revisin de su coche. Como siempre, todos necesitan que les devuelvan el coche en el menor tiempo posible. Cada coche necesita un tiempo de revisin ri y al mecnico le da lo mismo por cul empezar: sabe que en revisar todos los coches tardar lo mismo independientemente del orden que elija. Pero al jefe de taller no le da lo mismo, la satisfaccin de sus clientes es lo que importa: es mejor tener satisfechos al mayor nmero de ellos. Al fin y al cabo, la planificacin la hace l y, evidentemente, un cliente estar ms satisfecho cuanto menos tarden en devolverle el coche. Implementar un programa que decida el orden en el que revisar uno a uno los coches para maximizar la satisfaccin de los clientes de Sleepy.
RESPUESTAS EXAMEN Programacin III. Febrero 2007 (Primera Semana) Cuestin 1 (2 puntos). Implementa en Java o Mdula-2 la funcin de estimacin de la cota en el problema del n-puzzle (prctica de este curso).
Cuestin 2 (2 puntos). Escribir en pseudocdigo una funcin recursiva de bsqueda binaria en un vector, suponiendo que en algunos casos el elemento no est en el vector (1 punto). Demuestra el coste que tiene la funcin implementada (1 punto).
fun busquedabin (T [1..n ] ,x ) si n = 0 x > T [ n ] entonces devolver n+1 sino devolver binrec (T [1..n ] ,x )
fun binrec (T [i..j ] ,x )
{Bsqueda binaria de x en la submatriz T [i..j ] con la seguridad de que T [i - 1] < x T [ j ]}

si i = j entonces devolver i k (i + j ) 2 si x T [ k ] entonces devolver binrec (T [i..k ] ,x ) sino devolver binrec (T [ k + 1..j ] ,x ) fsi ffun
Para demostrar el coste utilizo la ecuacin de recurrencia:

Donde a = 1, b = 2, k = 0 ( log n )
Cuestin 3 (2 puntos). Dado un vector C [1..n ] de nmeros enteros distintos, y un nmero entero S,
se pide plantear un programa de complejidad en ( nlogn ) que determine si existen o no dos elementos de C tales que su suma sea exactamente S. En caso de utilizar algoritmos conocidos no es necesario codificarlos. (Resuelto en Estructuras de datos y mtodos algortmicos pag 338)
Resuelvo el problema de la siguiente manera, primero ordeno el vector C y segundo para cada elemento x de C buscar, utilizando bsqueda binaria el entero S - x . Si alguna de las bsquedas tiene xito habremos encontrado dos elementos de C que suman S. Utilizando la ordenacin por fusin el coste del primer paso est en ( nlogn ) , y el coste del segundo paso est en ( nlogn ) . En el peor caso se hacen n bsquedas binarias de coste ( logn ) cada una de ellas, por lo tanto el coste total es ( nlogn ) .
funcion buscar dos ( C [1..n ] de ent , S : ent ) dev existe : bool , x1 , x2 : ent var V [1..n ] de ent V := C ; ordenar (V ) j := 1; existe := falso; mientras j n existe hacer x1 := V [ j ] ; x2 := S x1 ; existe, p := busqueda binaria (V , x2 ,1, n ) existe := existe p j {no puede usarse el mismo numero dos veces} j := j + 1; fmientras ffuncion
Problema (4 puntos). Hoy es un da duro para el taller Sleepy. Llegan las vacaciones y a las 8:00 de la maana n clientes han pedido una revisin de su coche. Como siempre, todos necesitan que les devuelvan el coche en el menor tiempo posible. Cada coche necesita un tiempo de revisin ri y al mecnico le da lo mismo por cul empezar: sabe que en revisar todos los coches tardar lo mismo independientemente del orden que elija. Pero al jefe de taller no le da lo mismo, la satisfaccin de sus clientes es lo que importa: es mejor tener satisfechos al mayor nmero de ellos. Al fin y al cabo, la planificacin la hace l y, evidentemente, un cliente estar ms satisfecho cuanto menos tarden en devolverle el coche. Implementar un programa que decida el orden en el que revisar uno a uno los coches para maximizar la satisfaccin de los clientes de Sleepy. Eleccin razonada del esquema algortmico ms eficiente para resolver el problema.
Se trata de un problema de optimizacin, por lo tanto descarto el esquema de divide y vencers, para este problema se puede encontrar una funcin de seleccin que lo resuelva, de esta manera descarto el esquema de ramificacin y poda, debemos elegir a los clientes por orden creciente de tiempo de finalizacin, este problema se corresponde con el problema de minimizacin del tiempo en el sistema.
Esquema general:
Estructuras de datos: Tres vectores de enteros, un vector booleano y la funcin auxiliar ordenar ndices. Algoritmo completo a partir del refinamiento del esquema general
fun taller (C[1..n]nat, D[1..n]nat) dev sol[1..n] bool var F[1..n]nat ; I[1..n]1..n ; para i=1 hasta n hacer F[i]:= C[i]+D[i]; sol[i]:= falso; fpara I:= ordenar-indices(F) sol[I[1]]:= cierto; final := F[I[1]]; para i=2 hasta n hacer si C[I[i]] final entonces sol[I[i]]:= cierto; final := F[I[i]]; fsi fpara ffun fun ordenar-indices(V[1..n])dev indice [1..n]1..n merge-indice(V,indice,1,n) ffun
Estudio del coste El bucle voraz es de complejidad lineal respecto al nmero de clientes y el orden de complejidad del algoritmo completo corresponde al de la ordenacin del vector de tiempos finales ( nlogn ) .
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2007 Segunda semana Cuestin 1 (2 puntos). Cual es el tamao del problema, n, que determina el orden de complejidad del siguiente procedimiento? (0.5 puntos). Calcula el orden de complejidad del algoritmo en funcin de dicho tamao (1.5 puntos).
tipo vector = array de enteros; procedimiento examen(var a:vector; prim,ult, x: entero): boolean; var mitad: entero; si (prim >= ult) entonces devolver a[ult] = x si no mitad = (prim + ult) div 2; si (x = a[mitad]) entonces devolver cierto si no si (x < a[mitad]) entonces devolver examen(a, prim, mitad-1, x) si no devolver examen(a, mitad+1, ult, x) fsi fsi
Cuestin 2 (2 puntos). Escribe en Java el algoritmo principal del esquema de ramificacin y poda utilizado en la prctica del presente curso (no es necesario implementar las funciones auxiliares). Cuestin 3 (2 puntos). Aplica el algoritmo de Kruskal al siguiente grafo indicando claramente en cada paso qu arista se selecciona, la evolucin de las componentes conexas y la evolucin de la solucin.
Problema (4 puntos). Disponemos de un conjunto A de n nmeros enteros (tanto positivos como negativos) sin repeticiones almacenados en una lista. Dados dos valores enteros m y C, siendo m < n se desea resolver el problema de encontrar un subconjunto de A compuesto por exactamente m elementos y tal que la suma de los valores de esos m elementos sea C.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico mas eficiente para resolver el problema (0,5 puntos). 2. Estructuras de datos (0,5 puntos). 3. Algoritmo completo a partir del refinamiento del esquema general (2,5 puntos). 4. Estudio del coste (1 punto).
Programacin III o
Febrero de 2007 NOMBRE: APELLIDOS: DNI: Cuestin 1 (2 puntos) o Cual es el tama o del problema, n, que determina el orden de complejidad del n siguiente procedimiento? (0.5 puntos). Calcula el orden de complejidad del algoritmo en funcin de dicho tama o (1.5 puntos). o n
tipo vector = array de enteros; procedimiento examen(var a:vector; prim,ult, x: entero): boolean; var mitad: entero; (1) si (prim >= ult) entonces (2) devolver a[ult] = x (3) si no (4) mitad = (prim + ult) div 2; (5) si (x = a[mitad]) entonces (6) devolver cierto (7) si no si (x < a[mitad]) entonces (8) devolver examen(a, prim, mitad-1, x) (9) si no (10) devolver examen(a, mitad+1, ult, x) (11) fsi (12) fsi
Solucin o a) n = (ult - prim)+1 b) Contando las instrucciones tenemos que si se cumple la condicin de la l o nea (1) el coste es cte.. Si se va por la l nea (3), puede irse por la la linea (6) (coste cte), por la l nea (8) (coste t(n/2) + cte) o por la l nea (10) (coste t(n/2) + cte). Por tanto, T(n) = T(n/2) + cte. Planteamos la recurrencia con reduccin del problema mediante divisin: o o n: tama o del problema a: n mero de llamadas recursivas n/b: tama o del subpron u n k blema cn : coste de las instrucciones que no son llamadas recursivas T (n) = entonces cnk aT (n/b) + cnk

si 0 n bk
En nuestro caso, tenemos que los valores son a = 1, b = 2, cnk = cte, k = 0. d De donde T(n) (logn).
(nk ) (nk logn) T (n) (nnlogb a )
Cuestin 2 (2 puntos) o Escribe en Java el algoritmo principal del esquema de ramicacin y poda utilio zado en la prctica del presente curso (no es necesario implementar las funciones a auxiliares). Solucin: o La implementacin ms sencilla es dejar los nodos solucin dentro de la cola de o a o prioridad. Cuando el primero de la cola sea solucin entonces hemos encontrado la o solucin ptima porque el resto de nodos proporcionan una estimacin que a n en o o o u el mejor de los casos ser peor: a
public class MejorPrimero implements SearchAlgorithm { public Solution SearchSolution(Node nodoInicial) { Solution solucion; Queue<Node> cola = new PriorityQueue<Node>(); cola.add(nodoInicial); while(!cola.isEmpty() ) { Node nodo = cola.poll(); if( nodo.isSolution() ) { return nodo.getSolution(); } else { for(Node nodoHijo:nodo.generatePossibleChildren()) { cola.offer( nodoHijo ); } } } return null; } }
Sin embargo, la solucin anterior tiene el problema de que todos los nodos (incluidas o algunas soluciones) se guardan en memoria (en la cola de prioridad) a n sabiendo u que muchos no pueden proporcionar la solucin ptima. Por tanto, es posible renar o o el algoritmo anterior para ir eliminando de la cola de prioridad todos los nodos que podamos ir descartando. Para descartar nodos, primero tenemos que encontrar una solucin que se convierte en la solucin de referencia. Todos los nodos ya existentes o o con una estimacin peor se eliminan de la cola (mtodo depurar) y todos los nuevos o e nodos con una estimacin peor ya no se meten en la cola. Esta versin necesita menos o o memoria, pero puede tener mayor coste computacional puesto que hay que recorrer la cola cada vez que encontramos una nueva solucin. Por otro lado, mantener la o cola tiene menos coste porque en general contendr menor n mero de nodos. a u
public class RamificacionYPoda implements SearchAlgorithm { public Solution searchSolution(Node nodoInicial) { Queue<Node> cola = new PriorityQueue<Node>(); cola.add(nodoInicial); // Solucion inicial int costeMejor = Integer.MAX_VALUE; while(!cola.isEmpty() ) { Node nodo = cola.poll(); if( nodo.isSolution() ) { int costeReal = nodo.getCost(); if( costeReal < costeMejor ) { costeMejor = costeReal; solucion = nodo.getSolution(); depurar(cola, costeMejor); } } else { for(Node nodoHijo:nodo.generatePossibleChildren()) { int cota=nodoHijo.calculateEstimatedCost(); if(cota < costeMejor) { cola.offer( nodoHijo ); } } } } return solucion; } private void depurar(Queue<Node> cola, int costeMejor) { Iterator it = cola.iterator(); List<Node> depurationList = new ArrayList<Node>(); while(it.hasNext()) { Node node = (Node) it.next(); if(node.calculateEstimatedCost()>costeMejor) { depurationList.add(node); } } cola.removeAll(depurationList); } }
Cuestin 3 (2 puntos) o Aplica el algoritmo de Kruskal al siguiente grafo indicando claramente en cada paso qu arista se selecciona, la evolucin de las componentes conexas y la evolucin de e o o la solucin. o
1 3 4 3 1 5 5 2 2 7 9 6 10 6 4 8
Se ordenan las aristas de menor a mayor coste: Arista seleccionada (3,5) (2,5) (1,3) (1,2) (2,3) (2,4) (5,6) Evolucin de las o componentes conexas {1},{2},{3},{4},{5},{6} {1},{2},{3,5},{4},{6} {1},{2,3,5},{4},{6} {1,2,3,5},{4},{6} Rechazada Rechazada {1,2,3,5,4},{6} {1,2,3,5,4,6} Evolucin o de la solucin o {(3,5)} {(3,5), (2,5)} {(3,5), (2,5), (1,3)} {(3,5), (2,5), (1,3)} {(3,5), (2,5), (1,3)} {(3,5), (2,5), (1,3), (2,4)} {(3,5), (2,5), (1,3), (2,4), (5,6)}
(*: ambos nodos en una misma particin) o Problema (4 puntos) Disponemos de un conjunto A de n n meros enteros (tanto positivos como negativos) u sin repeticiones almacenados en una lista. Dados dos valores enteros m y C, siendo m < n se desea resolver el problema de encontrar un subconjunto de A compuesto por exactamente m elementos y tal que la suma de los valores de esos m elementos sea C. La resolucin de este problema debe incluir, por este orden: o 1. Eleccin del esquema ms apropiado, el esquema general y explicacin de su o a o aplicacin al problema (0.5 puntos). o 2. Descripcin de las estructuras de datos necesarias (0.5 puntos). o 3. Algoritmo completo a partir del renamiento del esquema general (2.5 puntos). 4. Estudio del coste del algoritmo desarrollado (1 punto). Seleccin del esquema algor o tmico Se trata de una b squeda, no de una opu timizacin, por lo que no son aplicables el esquema voraz ni el de ramicacin y o o poda. Tampoco se puede dividir el problema en subproblemas que se resuelvan con exactamente con el mismo procedimiento. Tenemos que recorrer un rbol de soluciones candidatas, pero siguiendo aquellas a ramas que tengan opcin de convertirse en una solucin (k-prometedoras) por lo o o que el esquema de vuelta atrs es adecuado. Tambin es vlido un recorrido del a e a a rbol de soluciones en profundidad, siempre que el recorrido se detenga en el nivel correspondiente a m.
Dependiendo de la representacin del ensayo y de la estrategia de ramicacin (geo o neracin de hijos) tenemos al menos dos aproximaciones para el esquema de vuelta o atrs. a En una primera aproximacin (que llamaremos A) podr representarse el ensayo o a como un vector de m enteros y los descendientes de un nodo de nivel k ser todas an los valores no tomados anteriormente. As del nodo ra tendr z amos n opciones para el nivel 1 del rbol, en el nivel 2 tendr a amos n(n 1) hijos, etc. hasta el nivel m. Como se ver ms adelante, en el caso peor que es cuando m tiende a n, el n mero a a u de nodos del rbol es n!. a La segunda aproximacin (que llamaremos B) es ms correcta y consistir en reo a a presentar el ensayo como un vector de n booleanos. De este modo los descendientes de un nodo de nivel k ser las opciones de tomar o no el valor k + 1 del vector an de entrada. Es decir siempre se tendr dos opciones. Cuando m tiende a n, el an n mero de nodos ser 2n que es mejor que n! Lo que est ocurriendo bsicamente, u a a a es que la segunda alternativa evita considerar permutaciones, es decir, tomar los mismos n meros pero en orden diferente. Adems esta segunda opcin es ms fcil u a o a a de implementar. A continuacin mostraremos la implementacin de las dos alternativas. Considerao o mos los siguientes apartados para cada una de las alternativas: Alternativa A 1. Esquema general
fun vuelta-atras(e: ensayo) dev (booleano, ensayo) si valido(e) entonces dev (cierto,e) sino listaensayos <-- compleciones(e) mientras no vacia(listaensayos) y no es_solucion hacer hijo <-- primero(listaensayos) listaensayos <-- resto(listaensayos) si esprometedora(hijo) entonces (es_solucion,solucion) <-- vuelta-atras(hijo) fsi fmientras dev (es_solucion, solucion) fsi ffun
esprometedora comprueba si se cumplen las condiciones de poda, es decir ser una funcin que compruebe que el n mero de sumandos ya seleccionaa o u dos es menor que m. compleciones es una funcin que considera todos los numero que a n no han o u sido probados como siguiente elemento. valido comprueba que se haya alcanzado una solucin. o 2. estructuras de datos
Tipo ensayo= candidatos: vector de enteros //numeros que aun no se han probado
solucion: vector de enteros suma: entero num_sumados: entero
//numeros de la posible solucion // valor alcanzado hasta ese momento // cantidad de numeros que ya se han sumado
3. algoritmo completo
funcion compleciones(e: ensayo) dev lista_compleciones lista_compleciones <-- lista_vacia para cada i en e.candidatos hacer nuevo_ensayo <-- e eliminar(nuevo_ensayo.candidatos, i) anadir(nuevo_ensayo.solucion, i) nuevo_ensayo.suma <-- e.suma + i nuevo_ensayo.num_sumados <-- e.num_sumados + 1 lista_compleciones <-- anadir(lista_compleciones, nuevo_ensayo) fpara dev lista_compleciones funcion esprometedora(e:ensayo) dev booleano si (e.num_sumados < m) entonces dev cierto si no dev falso funcion valido(e:ensayo) dev booleano si (e.suma = C) y (e.num_sumados = m) entonces dev cierto si no dev falso
4. Complejidad del algoritmo Una cota superior al tiempo de ejecucin ser el o a n mero de nodos del rbol, es decir las combinaciones de n elementos tomados u a de m en m, multiplicado por el n mero de posibles permutaciones, ya que estas u no se excluyen: T (n, m) = n m m! = n! n! m! = = n(n 1) (n m + 1) (m n)!m! (n m)!
Llegamos al mismo resultado calculando el n mero de hijos de cada nivel del u a rbol: el n mero de hijos de primer nivel es n, el numero de hijos del segundo u nivel es n(n 1), hasta llegar al nivel (n m + 1), cuyo n mero de hijos es u n(n 1) (n m + 1). Podemos observar que si m n = T (n) O(n!) si m 1 = T (n) O(n) Alternativa B 1. Esquema general
fun vuelta-atras(e: ensayo, k ) dev (booleano, ensayo) // e es k-prometedor si K=limite entonces dev (cierto,e)
sino listaensayos <-- compleciones(e,k+1) mientras no vacia(listaensayos) y no es_solucion hacer hijo <-- primero(listaensayos) listaensayos <-- resto(listaensayos) si esprometedora(hijo,k+1) entonces (es_solucion,solucion) <-- vuelta-atras(hijo,k+1) fsi fmientras dev (es_solucion, solucion) fsi ffun
En la llamada inicial a vuelta-atras, todas las posiciones de e.candidatos se inicializan a true y k toma el valor 0. 2. Estructuras de datos
datos: vector de enteros //lista de numeros de entrada Tipo ensayo= candidatos: vector de booleanos //indica si el numero de cada posicion // se incluye en la solucion suma: entero // valor alcanzado hasta ese momento num_sumados: entero // cantidad de valores true de los candidatos
3. algoritmo completo
funcion compleciones(e: ensayo, k:entero) dev lista_compleciones lista_compleciones <-- lista_vacia nuevo_ensayo <-- e // el valor asignado a la posicion K es true nuevo_ensayo.suma <-- e.suma + datos[k] nuevo_ensayo.num_sumados <-- e.num_sumados + 1 lista_compleciones <-- anadir(lista_compleciones, nuevo_ensayo) nuevo_ensayo <-- e // el valor asignado a la posicion K es false nuevo_ensayo.candidatos[k] <-- false lista_compleciones <-- anadir(lista_compleciones, nuevo_ensayo) dev lista_compleciones funcion esprometedora(e:ensayo) dev booleano si (e.num_sumados < m) entonces dev cierto si no dev falso funcion valido(e:ensayo) dev booleano si (e.suma = C) y (e.num_sumados = m) entonces dev cierto si no dev falso
4. Complejidad del algoritmo En cada nivel el rbol se divide como mximo a a en dos ramas (si no se ha llegado a tener m posicione a true). Luego una cota superior es 2n .
Podemos observar que si m n = T (n) O(2n ) si m 1 = T (n) O(n) Este algoritmo ser ms eciente que el anterior cuando m n. a a
Programacin III Septiembre 2007 Original Cuestin 1 (1 punto). Describe el grafo asociado al espacio de soluciones del problema del n-puzzle (Prctica de este curso). Cuestin 2 (2,5 puntos). Supongamos que un polinomio se representa por un vector v[0..n] de longitud n+1 donde el valor v[i] es el coeficiente de grado i. Describir claramente los clculos y la descomposicin algortmica necesaria para plantear un algoritmo, de orden mejor que cuadrtico, que multiplique dos polinomios P(x) y Q(x) mediante divide y vencers. NOTA: La solucin tpica trivial de orden cuadrtico punta 0 puntos. Cuestin 3 (2,5 puntos). Con respecto al algoritmo de ordenacin por fusin (Mergesort). 1. Escribe el algoritmo. 2. Dibuja la secuencia de llamadas del algoritmo y la evolucin del siguiente vector al ordenarlo. Para ello ten en cuenta que hay que considerar que el problema es suficientemente pequeo cuando el subarray es de tamao 2. (2,0,2,1,9,6,2,3,5,8)
Problema (4 puntos). Tenemos n objetos de volmenes v1... vn, y un nmero ilimitado de recipientes iguales con capacidad R (con vi R, i ). Los objetos se deben meter en los recipientes sin partirlos, y sin superar su capacidad mxima. Se busca el mnimo nmero de recipientes necesarios para colocar todos los objetos.
La resolucin de este problema debe incluir, por este orden:

1. Eleccin razonada del esquema algortmico ms apropiado para resolver el problema. Escriba dicho esquema general.(0,5 puntos). 2. Descripcin de las estructuras de datos necesarias (0,5 puntos). 3. Algoritmo completo a partir del refinamiento del esquema general (2 puntos). 4. Estudio del coste del algoritmo desarrollado (1 punto).
RESPUESTAS EXAMEN Programacin III. Septiembre 2007 (Original) Cuestin 1 (1 punto). Describe el grafo asociado al espacio de soluciones del problema del n-puzzle (Prctica de este curso). Solucin: Cada nodo se bifurca como mximo en los cuatro movimientos posibles del hueco (arriba, abajo, Izquierda, y derecha), siempre que sea posible. La profundidad del rbol est limitada por el nmero de distintos tableros posibles ((nxn)!, siendo n el tamao del lado del tablero), ya que no se deben repetir. Cuestin 2 (2,5 puntos). Supongamos que un polinomio se representa por un vector v[0..n] de longitud n+1 donde el valor v[i] es el coeficiente de grado i. Describir claramente los clculos y la descomposicin algortmica necesaria para plantear un algoritmo, de orden mejor que cuadrtico, que multiplique dos polinomios P(x) y Q(x) mediante divide y vencers. NOTA: La solucin tpica trivial de orden cuadrtico punta 0 puntos. Solucin: Es relativamente simple dar con la solucin de orden cuadrtico. En este caso, se descompone en mitades P(x) = Axn/2+B y Q(x) = Cxn/2 +D con A,B,C,D polinomios de grado n/2 sacando factor comn xn/2 como se detalla en las expresiones. De esta forma se ve claramente que PQ es (Axn/2 +B)( Cxn/2+D) = AC xn + (AD+BC)xn/2 + BD lo que la solucin conlleva 4 multiplicaciones de grado n/2. El coste sera en este caso cuadrtico. Sin embargo hay una manera de organizar las operaciones mediante la cual, no es necesario calcular AD+CD mediante 2 productos, sino slo con uno, aprovechando que ya tenemos realizados los productos BD y AC. En este ltimo caso basta con observar que (A+B)( C+D) = AC+BC+AD+BD y que BC+AD = (A+B)( C+D) AC BD con lo que es posible realizar el clculo con 3 productos en lugar de 4, ya que el coste de las sumas, si consideramos las multiplicaciones como lineales, sera constante. De manera que (A+B)( C+D) sera uno de los productos, y AC y BD los otros dos. Este problema es similar al problema de la multiplicacin de nmeros enteros muy grandes del texto base, captulo 7. Cuestin 3 (2,5 puntos). Con respecto al algoritmo de ordenacin por fusin (Mergesort). a) Escribe el algoritmo. (a) El algoritmo se puede encontrar en Brassard & Bratley, pag. 258 b) Dibuja la secuencia de llamadas del algoritmo y la evolucin del siguiente vector al ordenarlo. Para ello ten en cuenta que hay que considerar que el problema es suficientemente pequeo cuando el subarray es de tamao 2. (2,0,2,1,9,6,2,3,5,8)
procedimiento fusionar(U[1..m+1],V[1..n+1], T[1..m+ n]) {Fusionar las matrices ordenadas U[1..m] y V[1..n] almacenndolas en T[1..m+ n],U[m+1] y V[n+1] se utilizan como centinelas} i, j 1 U[m+1],V[n+1] para k 1 hasta m+ n hacer si U[i] < V[j] entonces T[k] U[i];i i + 1 sino T[k] V[j]; j j + 1 fsi fpara fprocedimiento
procedimiento ordenarporfusin (T[1..n]) si n es suficientemente pequeo entonces insertar(T) sino matriz U[1..1 + n/2 ],V[1..1 + n/2 ], U[1.. n/2 ] T[1.. n/2 ] V[1.. n/2 ] T[1 + n/2 ..n] ordenarporfusin(U[1.. n/2 ] ) ordenarporfusin(V[1.. n/2 ] ) fusionar(U,V,T) fsi fprocedimiento
(b) OrdFusion(2,0,2,1,9,6,2,3,5,8) OrdFusion(2,0,2,1,9) OrdFusion(2,0) Insertar(2,0) -> (0,2) OrdFusion(2,1,9) OrdFusion(2) Insertar(2) -> (2) OrdFusion(1,9) Insertar(1,9) -> (1,9) Fusionar((2),(1,9)) -> (1,2,9) Fusionar((0,2),(1,2,9)) -> (0,1,2,2,9) OrdFusion(6,2,3,5,8) OrdFusion(6,2) Insertar(6,2) -> (2,6) OrdFusion(3,5,8) OrdFusion(3) Insertar(3) -> (3) OrdFusion(5,8) Insertar(5,8) -> (5,8) Fusionar((3),(5,8)) -> (3,5,8) Fusionar((2,6),(3,5,8)) -> (2,3,5,6,8) Fusionar((0,1,2,2,9), (2,3,5,6,8)) -> (0,1,2,2,2,3,5,6,8,9)
Problema (4 puntos). Tenemos n objetos de volmenes v1... vn, y un nmero ilimitado de recipientes iguales con capacidad R (con vi R, i ). Los objetos se deben meter en los recipientes sin partirlos, y sin superar su capacidad mxima. Se busca el mnimo nmero de recipientes necesarios para colocar todos los objetos. La resolucin de este problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico ms apropiado para resolver el problema. Escriba dicho esquema general.(0,5 puntos). 2. Descripcin de las estructuras de datos necesarias (0,5 puntos). 3. Algoritmo completo a partir del refinamiento del esquema general (2 puntos). 4. Estudio del coste del algoritmo desarrollado (1 punto).
Solucin: Resuelto en Estructuras de datos y mtodos algortmicos. N.Mart, Y. Ortega, J.A Verdejo. Pearson education, 2004. Ejercicio 15.9.
Indicaciones: 1. Ramificacin y poda. Se trata de un problema de optimizacin, para el que no existe una funcin de seleccin que permita ir seleccionando a cada paso el objeto que de lugar a la construccin parcial de la solucin ptima. Por tanto no es posible aplicar un algoritmo voraz. Tampoco existe una forma de dividir el problema en subproblemas que se puedan resolver independientemente, por lo que tampoco es posible un esquema divide y vencers. 2. vector de objetos: Podemos representar el reparto de objetos entre recipientes mediante un vector en el que cada posicin indique a qu recipiente se ha asignado el objeto correspondiente.
objetos = vector[1..n] of entero La solucin es la cantidad entera S de recipientes empleados. Montculo de mnimos en el que cada componente almacene una solucin parcial (nodo) con su cota correspondiente. 4. El nmero de recipientes est limitado a n, es decir al nmero de objetos. Una estimacin del coste es el tamao del rbol, que en el peor caso crece como ( n !) , ya que cada nodo del nivel k puede expandirse con los n-k objetos que quedan por asignar a recipientes.
Solucin:
En la solucin del ejercicio 14.22, pgina 499 de Estructura de datos y mtodos algortmicos, se supone que todo objeto cabe en un envase vaco y, por tanto, se necesitan un mximo de n envases. Las soluciones se representan en tuplas de la forma (x1,,xn) donde xi es el envase donde hemos colocado el objeto i. Como los envases son indistinguibles, el primer objeto siempre se coloca en el primer envase (x1 = 1) y para cada objeto de los restantes se puede usar uno de los envases ya ocupados, si cabe en alguno, o coger uno vaco. En cuanto a las estimaciones a utilizar para el esquema optimista-pesimista, tenemos:
Optimista: una cota inferior adecuada es el nmero de envases ya utilizados en la solucin parcial. Pesimista: una cota superior muy sencilla es considerar un envase extra por cada objeto que nos queda por empaquetar, pero resulta demasiado grosera. Podemos en cambio ir considerando cada objeto restante, en el orden que se haya dado, e intentar meterlo en el primer envase utilizand y, en el caso en que no quepa, intentarlo con el segundo envase, y as hasta agotar todas las posibilidades, en cuyo caso, se aadir un nuevo envase a la solucin parcial.
En cada nodo, adems de la informacin usual (solucin parcial, etapa y prioridad), guardamos el nmero de envases utilizados y las capacidades disponibles de cada envase utilizado.
tipos nodo = reg sol[1..n]de 1..n k:1..n envases:1..n {prioridad} capacidad[1..n]de real freg ftipos
Adems, como en la solucin mediante la tcnica de vuelta atrs (vase el ejercicio 14.22), la bsqueda podr acabarse si encontramos una solucin con el valor
n vi optimo = i =1 E
El algoritmo es el siguiente:
fun empaquetar-rp(E:real,V[1..n]de real)dev (sol-mejor[1..n]de 1..n, envase-mejor:1..n) var X,Y: nodo,C:colapr[nodo] total:=0 para i = 1 hasta n hacer total := total +V[i] fpara optimo:= total / E
encontrada:=falso {generamos raz: el primer objeto en el primer envase} X.k:=1; Y.sol[1]:=1; Y.envases:=1 Y.capacidad[1]:= E - V[1]; Y.capacidad[2..n]:= V[E] C:= cp-vacia(); aadir(C,Y) envases-mejor:=calculo-pesimista(E,V,Y) mientras encontrada ^ es-cp-vacia?(C)^(minimo(C).envases envases-mejor) hacer Y:=minimo(C); eliminar-min(C) {generamos los hijos de Y} X.k:=Y.k+1; X.sol:=Y.sol X.envases:= Y.envases; X.capacidad:= Y.capacidad; {probamos con cada envase ya utilizado} i:=1 mientras i Y.envases ^ encontrada hacer si X.capacidad[i] V[X.k] entonces X.sol[X.k]:=i; X.capacidad[i]:= X.capacidad[i]- V[X.k] si X.k = n entonces sol-mejor:=X.sol; envase-mejor:= X.envases encontrada:= (envases-mejor = optimo) {terminar} sino aadir(C,X) pes:=calculo-pesimista(E,V,X) envases-mejor:=min(envases-mejor, pes) fsi X.capacidad[i]:= Y.capacidad[i] fsi fpara si encontrada entonces {probamos con un nuevo envase} nuevo:= Y.envases + 1 X.sol[X.k]:=nuevo; X.envases:= nuevo X.capacidad[nuevo]:= E - V[X.k] si X.envases envases-mejor entonces si X.k = n entonces sol-mejor:=X.sol; envases-mejor:= nuevo encontrada:= (envases-mejor = optimo) {terminar} sino aadir(C,X) pes:= calculo-pesimista(E,V,X) envases-mejor:= min(envases-mejor,pes) fsi fsi fmientras ffun
Para calcular las estimaciones

fun calculo-pesimista (E:real,V[1..n]de real,X:nodo)dev pes:1..n var capacidad-aux[1..n]de real pes:=X.envases; capacidad-aux:= X.capacidad para i = X.k+1 hasta n hacer j:= 1 mientras V[i] > capacidad-aux [j] hacer j:= j+1 fmientras capacidad-aux [j] - V[i] entonces pes := pes(pes,j) fpara ffun
Programacin III Septiembre 2007 Reserva Cuestin 1 (2 puntos). Hallar formalmente el coste de los siguientes algoritmos, siendo h ( n, r , k ) ( n ) NOTA: Acertar a ojo se evala con cero puntos.
PROCEDIMIENTO uno (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 2 ENTONCES DEVOLVER(1); SINO COMIENZO r uno (n DIV 2, k-1); r r + uno (n DIV 2, k+1); r r + uno (n DIV 2, k+2); DEVOLVER (1); FIN FIN
PROCEDIMIENTO dos (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 2 ENTONCES DEVOLVER(1); SINO COMIENZO r dos (n DIV 2, k-1); r r + dos (n DIV 2, k+1); PARA i 1 HASTA n HACER COMIENZO r h (n,r,i); r r + h (n,r-1,i); FIN r r + dos (n DIV 2, k+2); DEVOLVER (r); FIN FIN
Cuestin 2 (2 puntos). Dos amigos juegan a un sencillo juego de adivinacin: uno de ellos piensa un nmero natural positivo y el otro debe adivinarlo preguntando solamente si es menor o igual que otros nmeros. Qu esquema algortmico utilizara para adivinar el nmero en tiempo logartmico? Disee el algoritmo y escrbalo en pseudocdigo. (Resuelto en Estructuras de datos y mtodos algortmicos pag 312) Cuestin 3 (2 puntos). Declarar en Java las clases y/o estructuras de datos que utilizara en el problema de puzzle (prctica de este ao). Problema (4 puntos). La agencia matrimonial Celestina & Co. Quiere informatizar parte de la organizacin de parejas entre sus clientes. Cuando un cliente llega a la agencia se describe a s mismo y cmo le gustara que fuera su pareja. Con la informacin de los clientes la agencia construye dos matrices
M y H que contienen las preferencias de los unos por los otros, tales que la fila M[i,] es una ordenacin de mayor a menor de las mujeres segn las preferencias del i-simo hombre y la fila H[i,] es una ordenacin de mayor a menor de los hombres segn las preferencias de la i-sima mujer. Por ejemplo, M[i,1] almacenara a la mujer preferida por el hombre i y M[i,2] a su segunda preferida. Dado el alto ndice de divorcios, la empresa se ha planteado como objetivo que los emparejamientos sean lo ms estables posible evitando las siguientes situaciones: 1) Que dada una pareja (h,m) se de el caso de m prefiera un h sobre h y adems h prefiera a un m sobre m. 2) Que dada una pareja (h,m) se de el caso de h prefiera un m sobre m y adems m prefiera a h sobre h. La agencia quiere que dadas las matrices de preferencia, un programa establezca parejas evitando las dos situaciones descritas con anterioridad. La resolucin de este problema debe incluir, por este orden:
1. Eleccin del esquema ms apropiado, el esquema general y explicacin de aplicacin al problema. (1 punto). 2. Descripcin de las Estructuras de datos necesarias. (0,5 puntos) 3. Algoritmo completo a partir del refinamiento del esquema general. (2 puntos) 4. Estudio del coste del algoritmo desarrollado. (0,5 puntos)
RESPUESTAS EXAMEN Programacin III. Septiembre 2007 (Reserva) Cuestin 1 (2 puntos). Hallar formalmente el coste de los siguientes algoritmos, siendo h ( n, r , k ) ( n ) NOTA: Acertar a ojo se evala con cero puntos.
PROCEDIMIENTO uno (n,k:entero):entero; VAR i,r:entero; COMIENZO SI n < 2 ENTONCES DEVOLVER(1); SINO COMIENZO r uno (n DIV 2, k-1); r r + uno (n DIV 2, k+1); r r + uno (n DIV 2, k+2); DEVOLVER (1); FIN FIN
El procedimiento uno tiene: Una instruccin constante, que no tenemos en cuenta para el clculo, o bien tres llamadas recursivas, ambas invocan la funcin con un tamao n/2. //En el segundo y tercer caso de la llamada recursiva hay otra instruccin simple aadida. La expresin queda T(n) = T(n/2) + T(n/2) + T(n/2) lo que equivale a T(n) = 3T(n/2) + c. Aplicando la resolucin genrica de las expresiones del tipo: T(n) = aT(n/b)+cnk con k = 0, a=3 y b=2 queda que 3 > 20 y por tanto la funcin T(n) tiene un coste El procedimiento dos tiene:
n log 2 3
Una llamada recursiva de tamao n/2, Otra llama recursiva de tamao n/2, Un bucle en el que se repite n veces un clculo consistente en llamar dos veces a una funcin h(n;r;k) de coste lineal, /*ms una instruccin simple*/, y por ltimo Una instruccin simple /* que no tenemos en cuenta para el calculo*/ y otra llamada recursiva de tamao n/2. Sumando los trminos nos sale T(n) = T(n/2) +T(n/2)+n (2n) +T(n/2), lo que equivale a T(n) = 3T(n/2) + 2n2 Aplicando la resolucin genrica de las expresiones del tipo T(n) = aT(n/b) + cnk y siendo 3 < 2 2 el coste es O(n2). a = 3, b = 2, k = 2
Cuestin 2 (2 puntos). Dos amigos juegan a un sencillo juego de adivinacin: uno de ellos piensa un nmero natural positivo y el otro debe adivinarlo preguntando solamente si es menor o igual que otros nmeros. Qu esquema algortmico utilizara para adivinar el nmero en tiempo logartmico? Disee el algoritmo y escrbalo en pseudocdigo. (Resuelto en Estructuras de datos y mtodos algortmicos pag 312)
Utilizara la bsqueda binaria ya que como pide el enunciado se obtiene un coste logartmico.
fun busquedabin (T [1..n ] ,x ) si n = 0 x > T [ n ] entonces devolver n+1 sino devolver binrec (T [1..n ] ,x )
fun binrec (T [i..j ] ,x )
{Bsqueda binaria de x en la submatriz T [i..j ] con la seguridad de que T [i - 1] < x T [ j ]}

si i = j entonces devolver i k (i + j ) 2 si x T [ k ] entonces devolver binrec (T [i..k ] ,x ) sino devolver binrec (T [ k + 1..j ] ,x ) fsi ffun
Para adivinar el nmero utilizar una variacin de bsqueda binaria:

fun bus - bin2 ( c, f ) dev n si c = f entonces n := c sino m := ( c + f ) div2 si menor - igual ( m ) entonces n := bus - bin2 ( c,m ) sino n := bus - bin2 ( m+1, f ) fsi fsi ffun
fun adivinar (
) dev n
{encontrar cotas superior e inferior}

cinf := 1; csup := 1; mientras menor - igual ( csup ) hacer cinf := csup +1;csup := 2 csup; fmientras n := bus - bin2 ( cinf,csup ) csup
Cuestin 3 (2 puntos). Declarar en Java las clases y/o estructuras de datos que utilizara en el problema de puzzle (prctica de este ao).
Problema (4 puntos). La agencia matrimonial Celestina & Co. Quiere informatizar parte de la organizacin de parejas entre sus clientes. Cuando un cliente llega a la agencia se describe a s mismo y cmo le gustara que fuera su pareja. Con la informacin de los clientes la agencia construye dos matrices
M y H que contienen las preferencias de los unos por los otros, tales que la fila M[i,] es una ordenacin de mayor a menor de las mujeres segn las preferencias del i-simo hombre y la fila H[i,] es una ordenacin de mayor a menor de los hombres segn las preferencias de la i-sima mujer. Por ejemplo, M[i,1] almacenara a la mujer preferida por el hombre i y M[i,2] a su segunda preferida. Dado el alto ndice de divorcios, la empresa se ha planteado como objetivo que los emparejamientos sean lo ms estables posible evitando las siguientes situaciones: 1) Que dada una pareja (h,m) se de el caso de m prefiera un h sobre h y adems h prefiera a un m sobre m. 2) Que dada una pareja (h,m) se de el caso de h prefiera un m sobre m y adems m prefiera a h sobre h. La agencia quiere que dadas las matrices de preferencia, un programa establezca parejas evitando las dos situaciones descritas con anterioridad. La resolucin de este problema debe incluir, por este orden:
1. Eleccin del esquema ms apropiado, el esquema general y explicacin de aplicacin al problema. (1 punto). 2. Descripcin de las Estructuras de datos necesarias. (0,5 puntos) 3. Algoritmo completo a partir del refinamiento del esquema general. (2 puntos) 4. Estudio del coste del algoritmo desarrollado. (0,5 puntos)
1. Eleccin del esquema:
fun vuelta - atrs(ensayo) si valido (ensayo) {es una solucin} entonces dev ensayo si no para cada hijo compleciones (ensayo) hacer si condiciones de poda (hijo) hacer vuelta - atrs(hijo) fsi fpara fsi ffun
2. Descripcin de las Estructuras de datos necesarias
Dos matrices m[1..n, 1..n ] y h[1..n, 1..n ] que contienen las preferencias de unos por los otros. m [i,j] : mujer a la que prefiere el hombre i-simo en el lugar de preferencia j-simo. h [i,j] : hombre al que prefiere la mujer i-sima en el lugar de preferencia j-simo. Un array asignado[1..n] que indicar si una mujer est o no asignada libre [i] : valor booleano que indica si la mujer i-sima ha sido asignada.
Comportamiento del algoritmo: El algoritmo trabajar por etapas y en cada etapa k decide la mujer que ha de emparejarse con el hombre k-simo En una etapa cualquiera k, el k-simo hombre escoger la mujer que prefiere en primer lugar siempre que sta est libre y la pareja resulte estable
3. Algoritmo completo a partir del refinamiento del esquema general.o

proc parejasVA (H[1..n,1..n],M[1..n,1..n],sol[1..n]1..n,k:1..n,asignado[1..n]bool) para hombre = 1 hasta n hacer si asignado[hombre] entonces sol[k] = hombre asignado[hombre] = cierto si estable?(H,M,sol,k) entonces si k = n entonces imprimir (sol) sino parejasVA(H,M,sol,k+1,asignado) fsi fsi asignado[hombre] = falso fsi fpara fproc
fun estable?(H[1..n,1..n],M[1..n,1..n],sol[1..n]1..n,k:1..n) dev respuesta bool respuesta = cierto; i=1; mientras i<k respuesta hacer respuesta = (M[k, sol[i]] M[k, sol[k]] H[sol[i], k] H[sol[i], i]) (M[i, sol[k]] M[i, sol[i]] H[sol[k], i] H[sol[k], k]) i= i+1; fmientras ffun
proc parejas (H[1..n,1..n],M[1..n,1..n]) var sol[1..n], asignado[1..n]bool asignado[1..n] = [falso]; parejasVA (H, M, sol, 1, asignado) fproc
4. Estudio del coste del algoritmo desarrollado.
Sea T(n) el tiempo de ejecucin del algoritmo. El algoritmo principal posee un bucle para que se ejecuta n veces y llamada recursiva que se ejecuta tambin n veces. El coste adicional sale de que esta funcin llama a la funcin estable, esta funcin posee una complejidad O(n4). Si sumamos ambas complejidades obtenemos: O(n!) + O(n4 ) = O(n!) Se deduce que la complejidad temporal es: O(T(n))= O(n!)
Programacin III Febrero 2008 Primera semana Cuestin 1 (1,5 puntos). Escribe el grafo asociado al espacio de soluciones del problema del nonograma, a partir del nodo que se presenta a continuacin. Se supone que a partir de dicho nodo se 2 van a comenzar a explotar la fila 3. (No punta la exploracin por fuerza bruta de coste 2n ).
Cuestin 2 (2 puntos). Cules de las siguientes afirmaciones son verdaderas y cuales falsas? Demuestra tus respuestas. a) n 2 O(n 3 ) ; b) n 2 (n3 ) ; c) 4n 2 3n + 2 (n log n) ; d) n ! (2n + 1)
Cuestin 3 (2,5 puntos). En una fontanera se necesitan hacer n reparaciones urgentes, y sabe de antemano el tiempo que le va a llevar cada una de ellas: en la tarea i-sima tardar ti minutos. Como en su empresa le pagan dependiendo de la satisfaccin del cliente, necesita decidir el orden en el que atender los avisos para minimizar el tiempo medio de espera de los clientes. Si llamamos Ei a lo que espera el cliente i-simo hasta ver reparada su avera por completo, necesita minimizar la expresin:
E (n) = Ei
i =1
Indica qu esquema o esquemas consideras ms adecuados para resolver este problema en los siguientes casos: La empresa slo dispone de un fontanero para realizar las reparaciones y quiere minimizar el tiempo medio de espera de los clientes. La empresa dispone de F fontanero para realizar las reparaciones y quiere minimizar el tiempo medio de espera de los clientes.
Adems de nombrar el esquema o esquemas, explica el porque de su eleccin, los aspectos destacados de cmo resolveras el problema (funcin de seleccin, restricciones, cotas en funcin del esquema propuesto) y el coste asociado. No se piden los algoritmos. Problema (4 puntos). El to Facundo posee n huertas, cada una con un tipo diferente de rboles frutales. Las frutas ya han madurado y es hora de recolectarlas. El to Facundo conoce, para cada una de las huertas, el beneficio bi que obtendra por la venta de lo recolectado. El tiempo que se tarda en recolectar los frutos de cada finca es as mismo variable (no unitario) y viene dado por ti. Tambin sabe los das di que tardan en pudrirse los frutos de cada huerta. Se pide ayudar a decidir al to Facundo que debe recolectar para maximizar el beneficio total obtenido.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico mas eficiente para resolver el problema (0,5 puntos). 2. Estructuras de datos (0,5 puntos). 3. Algoritmo completo a partir del refinamiento del esquema general (2 puntos). 4. Estudio del coste (1 punto).
RESPUESTAS EXAMEN Programacin III. Febrero 2008 (Primera Semana) Cuestin 1 (1,5 puntos). Escribe el grafo asociado al espacio de soluciones del problema del nonograma, a partir del nodo que se presenta a continuacin. Se supone que a partir de dicho nodo se 2 van a comenzar a explotar la fila 3. (No punta la exploracin por fuerza bruta de coste 2n ).
X X
X O
O X
O O
X X X
X X O
O X X
O X O
O X X X
O X X O
Cuestin 2 (2 puntos). Cules de las siguientes afirmaciones son verdaderas y cuales falsas? Demuestra tus respuestas. a) n 2 O(n 3 ) ; b) n 2 (n3 ) ; c) 4n 2 3n + 2 (n log n) ; d) n ! (2n + 1!)
REGLA DEL LMITE: f ( n) 1. Si lim + , entonces f ( n ) ( g ( n ) ) n g ( n ) 2. Si lim 3. Si lim

n
f (n) 0 , entonces f ( n ) O ( g ( n ) ) pero f ( n ) ( g ( n ) ) g ( n)
f ( n) + , entonces f ( n ) ( g ( n ) ) pero f ( n ) ( g ( n ) ) g ( n)
a) n 2 O(n 3 ) lim n2 2n 2 0 = lim 2 = lim = =0 3 n n n 3n n 6n 6
Por lo tanto a es cierto.
b) n 2 (n3 ) lim n2 2n 2 0 = lim 2 = lim = =0 n n 3 n 3n n 6n 6
Por lo tanto b es falso. c) 4n 2 3n + 2 (n log n) 4n 2 3n + 2 8n 3 8 lim = lim = 1 = + n n ln n + 1 n log n n Por lo tanto c es cierto. d) n ! (2n + 1!) lim
[ n (n 1)!] / n = lim (n 1)! = + n! n (n 1)! = lim = lim n 2n + 1! n n 2n / n + 1/ n n 2n + 1 2
Por lo tanto d es falso.

Cuestin 3 (2,5 puntos). En una fontanera se necesitan hacer n reparaciones urgentes, y sabe de antemano el tiempo que le va a llevar cada una de ellas: en la tarea i-sima tardar ti minutos. Como en su empresa le pagan dependiendo de la satisfaccin del cliente, necesita decidir el orden en el que atender los avisos para minimizar el tiempo medio de espera de los clientes. Si llamamos Ei a lo que espera el cliente i-simo hasta ver reparada su avera por completo, necesita minimizar la expresin:
E (n) = Ei
i =1
Indica qu esquema o esquemas consideras ms adecuados para resolver este problema en los siguientes casos: La empresa slo dispone de un fontanero para realizar las reparaciones y quiere minimizar el tiempo medio de espera de los clientes. La empresa dispone de F fontaneros para realizar las reparaciones y quiere minimizar el tiempo medio de espera de los clientes.
Adems de nombrar el esquema o esquemas, explica el porque de su eleccin, los aspectos destacados de cmo resolveras el problema (funcin de seleccin, restricciones, cotas en funcin del esquema propuesto) y el coste asociado. No se piden los algoritmos.
Solucin:
En primer lugar hemos de observar que el fontanero siempre tardar el mismo tiempo global T = t1 + t2 + ... + tn en realizar todas las reparaciones, independientemente de la forma en que las ordene. Sin embargo, los tiempos de espera de los clientes s dependen de esta ordenacin. En efecto, si mantiene la ordenacin original de las tareas (1, 2, ..., n), la expresin de los tiempos de espera de los clientes viene dada por: E 1 = t1 E 2 = t1 + t2 ..... En = t1 + t2 + ... + tn . Lo que queremos encontrar es una permutacin de las tareas en donde se minimice la expresin de E(n) que, basndonos en las ecuaciones anteriores, viene dada por: Vamos a demostrar que la permutacin ptima es aquella en la que los avisos se atienden en orden creciente de sus tiempos de reparacin. Para ello, denominemos X = (x1,x2,...,xn) a una permutacin de los elementos (1,2,...,n), y sean (s1,s2,...,sn) sus respectivos tiempos de ejecucin, es decir, (s1,s2,...,sn) va a ser una permutacin
de los tiempos orginales (t1,t2,...,tn). Supongamos que no est ordenada en orden creciente de tiempo de reparacin, es decir, que existen dos nmeros xi < xj tales que si > sj. Sea Y = (y1,y2,...,yn) la permutacin obtenida a partir de X intercambiando xi con xj, es decir, yk = xk si k i y k j, yi = xj, yj = xi. Si probamos que E(Y) < E(X) habremos demostrado lo que buscamos, pues mientras ms ordenada (segn el criterio dado) est la permutacin, menor tiempo de espera supone. Pero para ello, basta darse cuenta que
E (Y ) = ( n - xi +1) s j + ( n - x j +1) si +
y que, por tanto:
k=1, k i,k j
( n - k +1) s
E ( X ) E (Y ) = ( n - xi +1) ( si s j ) + ( n - x j +1)( s j si ) = ( x j xi )( si s j ) > 0

En consecuencia, el algoritmo pedido consiste en atender a las llamadas en orden inverso a su tiempo de reparacin. Con esto conseguir minimizar el tiempo medio de espera de los clientes, tal y como hemos probado.
En el segundo caso tambin tenemos que minimizar el tiempo medio de espera de los clientes, pero lo que ocurre es que ahora existen F fontaneros dando servicio simultmeamente. Basndonos en el mtodo utilizado anteriormente, la forma ptima de atender los avisos va a ser la siguiente:
En primer lugar, se ordenan los avisos por orden creciente de tiempo de reparacin. Un vez hecho esto, se van asignando los avisos por este orden, siempre al fontanero menos ocupado. En caso de haber varios con el mismo grado de ocupacin, se escoge el de nmero menor.
En otras palabras, si los avisos estn ordenados de forma que ti tj si i < j, asignaremos al fontanero k los avisos k, k+F, k+2F, ... Problema (4 puntos). El to Facundo posee n huertas, cada una con un tipo diferente de rboles frutales. Las frutas ya han madurado y es hora de recolectarlas. El to Facundo conoce, para cada una de las huertas, el beneficio bi que obtendra por la venta de lo recolectado. El tiempo que se tarda en recolectar los frutos de cada finca es as mismo variable (no unitario) y viene dado por ti. Tambin sabe los das di que tardan en pudrirse los frutos de cada huerta. Se pide ayudar a decidir al to Facundo que debe recolectar para maximizar el beneficio total obtenido. (Solucionado en el ejercicio 15.4 pg 516 de Estructura de datos y mtodos algortmicos)
Solucin: En el ejercicio 14.6, pgina 463 de Estructura de datos y mtodos algortmicos, vimos la solucin a este problema mediante la tcnica de vuelta atrs. Representamos las soluciones mediante tuplas (x1,,xn) donde xi = 1 indica que los frutos de la huerta i se recolectan mientras que xi = 0 indica que los frutos de la huerta no se recolectan. Tambin vimos como comprobar que un subconjunto de huertas es factible, es decir, que todas pueden recolectarse sin superar su plazo, manteniendo las huertas ordenadas por tiempo de caducidad creciente. En cuanto a las estimaciones a utilizar para el esquema optimista-pesimista, tenemos: Optimista: Como ya vimos en el ejercicio 14.6, podemos aproximar superiormente el beneficio obtenible sumando el beneficio de todas las huertas que pueden recolectarse sin llegar a su fecha de caducidad despus de las ya elegidas (es decir, empezando a recolectar cada una justo despus de terminar con la ltima finca ya elegida). Pesimista: igual que en el ejercicio 15.2, podemos obtener una cota pesimista calculando una posible solucin extensin de la que tengamos: las huertas no consideradas se van recolectando en orden (acumulando el tiempo), siempre que no se supere su fecha de caducidad.
En cada nodo, adems de la informacin usual (solucin parcial, etapa y prioridad), mantendremos el tiempo y beneficio acumulados.
tipos nodo = reg sol[1..n]de 0..1 k:0..n tiempo.beneficio:real beneficio-opt:real {prioridad} freg ftipos
fun huertas-rp(T[1..n],D[1..n],B[1..n]de real)dev (sol-mejor[1..n]de 0..1, beneficio-mejor:real) var X,Y: nodo,C:colapr[nodo] {generamos raz} X.k:=0; Y.tiempo:=0; Y.beneficio:=0 Y.beneficio-opt:=calculo-optimista(T,D,B,Y.k,Y.tiempo,Y.beneficio) C:= cp-vacia(); aadir(C,Y) beneficio-mejor:=calculo-pesimista(T,D,B,Y.k,Y.tiempo,Y.beneficio) mientras es-cp-vacia?(C)^(maximo(C).beneficio-opt beneficio-mejor) hacer Y:=maximo(C); eliminar-max(C) X.k:=Y.k+1; X.sol:=Y.sol {hijo izquierdo - recolectar} si Y.tiempo+T[X.k] D[X.k] entonces {es factible} X.sol[X.k]:=1; X.tiempo:= Y.tiempo+T[X.k] X.beneficio:= Y.beneficio + B[X.k] X.beneficio-opt:= calculo-optimista(T,D,B,Y.k,Y.tiempo,X.beneficio) si X.beneficio-opt beneficio-mejor entonces si X.k = n entonces sol-mejor:=X.sol; beneficio-mejor:= X.beneficio sino aadir(C,X) {la estimacin pesimista coincide con la de Y} {beneficio-mejor no cambia} fsi fsi fsi {hijo deerecho no recolectar} X.sol[X.k]:=0; X.tiempo:= Y.tiempo X.beneficio:= Y.beneficio X.beneficio-opt:= calculo-optimista(T,D,B,Y.k,Y.tiempo,X.beneficio) si X.beneficio-opt beneficio-mejor entonces si X.k = n entonces sol-mejor:=X.sol; beneficio-mejor:= X.beneficio sino aadir(C,X) pes:= calculo-pesimista(T,D,B,Y.k,X.tiempo,X.beneficio) beneficio-mejor:= max(beneficio-mejor,pes) fsi fsi fmientras ffun
Las funciones que calculan las estimaciones son las siguientes:
fun calculo-optimista (T[1..n],B[1..n],B[1..n]de real,k:0..n,tiempo,beneficio:real)dev opt:real opt:=beneficio para i = k+1 hasta n hacer si tiempo+T[i] D [i] entonces opt := opt+ B[i] fsi fpara ffun
fun calculo-pesimista (T[1..n],B[1..n],B[1..n]de real,k:0..n,tiempo,beneficio:real)dev pes:real pes:=beneficio; tiempo-pes:= tiempo para i = k+1 hasta n hacer si tiempo-pes+T[i] D [i] entonces pes := pes+ B[i]; tiempo-pes:= tiempo-pes+T[i] fsi fpara ffun
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Febrero 2008 Segunda semana Cuestin 1 (2 puntos). En la prctica obligatoria del presente curso 2007/2008 se ha tenido que disear y desarrollar un algoritmo para resolver el problema del nonograma. Dado el cuadrado de 4x4 de la figura, trazar el algoritmo que lo resuelve tal como lo hace el desarrollado para la prctica y explicar cada paso. Hacer al menos 3 niveles y al menos 2 backtrakings. Restricciones del nonograma:
Cuestin 2 (2 puntos). Sea T[1..n] con k elementos (k<n) un montculo de mnimos. Se pide programar una funcin flotar recursiva que dado un nuevo elemento T[k+1] restaure la propiedad de montculo en T. Una funcin iterativa que lo resuelva puntuar cero puntos. Cuestin 3 (2 puntos). Dado n potencia de 2, escribe un algoritmo recursivo que calcule en tiempo logartmico el valor de an suponiendo que solo se pueden realizar multiplicaciones y que stas tienen coste unitario. Demuestre el coste mediante la ecuacin de recurrencia. No justifique el esquema usado, aplquelo. Problema (4 puntos). Una flota de 4 camiones (T1..T4) debe transportar cargamento variado a otras tantas ciudades (C1..C4). El coste de adjudicar el transporte vara en funcin de la distancia y de la peligrosidad del trayecto y se resume en la tabla adjunta. Exponer un algoritmo que calcule de manera ptima a quin encargarle qu destino de manera que en total el coste sea mnimo.
La resolucin del problema debe incluir, por este orden: 1. Eleccin razonada del esquema algortmico mas eficiente para resolver el problema (0,5 puntos). 2. Estructuras de datos (0,5 puntos). 3. Algoritmo completo a partir del refinamiento del esquema general (2,5 puntos). 4. Estudio del coste (0,5 punto).
RESPUESTAS EXAMEN Programacin III. Febrero 2008 (Segunda Semana) Cuestin 1 (2 puntos). En la prctica obligatoria del presente curso 2007/2008 se ha tenido que disear y desarrollar un algoritmo para resolver el problema del nonograma. Dado el cuadrado de 4x4 de la figura, trazar el algoritmo que lo resuelve tal como lo hace el desarrollado para la prctica y explicar cada paso. Hacer al menos 3 niveles y al menos 2 backtrakings. Restricciones del nonograma:
Solucin: En funcin del algoritmo desarrollado por el alumno en la prctica.
Cuestin 2 (2 puntos). Sea T[1..n] con k elementos (k<n) un montculo de mnimos. Se pide programar una funcin flotar recursiva que dado un nuevo elemento T[k+1] restaure la propiedad de montculo en T. Una funcin iterativa que lo resuelva puntuar cero puntos.
Proc Flotar ( i, T [1...n ]) ; i_padre := i div 2; Si ( i > 1) y T [i ] < T [i_padre ] entonces Intercambiar (T [i ] , T [i_padre]) ; Flotar ( i_padre,T ) ; fFlotar;
Cuestin 3 (2 puntos). Dado n potencia de 2, escribe un algoritmo recursivo que calcule en tiempo logartmico el valor de an suponiendo que solo se pueden realizar multiplicaciones y que stas tienen coste unitario. Demuestre el coste mediante la ecuacin de recurrencia. No justifique el esquema usado, aplquelo.
fun exp (a:entero,n:natural) dev entero si n=1 entonces dev a sino si n=0 entonces dev 1 sino t exp(a,n DIV 2) dev t t fsi ffun
En este problema: a=1, b=2, k=0, luego el caso es T ( n ) n k logn por lo que el coste es T ( n ) ( logn )
cn k T (n) = k aT ( n / b ) + cn ( n k ) T ( n ) ( n k logn ) log a n b
, si 1 n b k
Problema (4 puntos). Una flota de 4 camiones (T1..T4) debe transportar cargamento variado a otras tantas ciudades (C1..C4). El coste de adjudicar el transporte vara en funcin de la distancia y de la peligrosidad del trayecto y se resume en la tabla adjunta. Exponer un algoritmo que calcule de manera ptima a quin encargarle qu destino de manera que en total el coste sea mnimo.
Solucin: El problema de las asignaciones Seccion 9.7 Brassad&Bradley. Similar al problema 4.6 del libro Esquemas Algortmicos: Enfoque metodolgico y problemas resueltos. Gonzalo, J. Rodrguez, M. ejercicio 15.1, pgina 508 de Estructura de datos y mtodos algortmicos. Escribir el esquema general.
Indicar que estructuras de datos son necesarias.

Montculo de mnimos (cota mejor la de menor coste)
tipos nodo = reg sol[1..n]de 1..n k:0..n tiempo:real tiempo-opt:real {prioridad} asignado[1..n]de bool freg ftipos
fun camiones-rp(T[1..n,1..n]de real)dev (sol-mejor[1..n]de 1..n, tiempo-mejor:real) var X,Y: nodo,C:colapr[nodo],opt[0..n],pes[0..n]de real (opt,pes):= pre-calculo-estimaciones(T) {generamos los hijos de Y} X.k:=0; Y.asignado[1..n]; Y.tiempo:=0; Y. tiempo-opt:=opt[0] C:= cp-vacia(); aadir(C,Y) tiempo-mejor:= pes[0] mientras es-cp-vacia?(C)^(minimo(C).tiempo-opt tiempo-mejor) hacer Y:= minimo C); eliminar-min(C) {generamos los hijos de Y} X.k:=Y.k+1; X.sol:=Y.sol; X.asignado:=Y.asignado para t=1 hasta n hacer si X.asignado[t] entonces X.sol[X.k]:=t; X.asignado[t]:= cierto X.tiempo:= Y.tiempo + T[X.k,t] X.tiempo-opt:= Y.tiempo + opt[X.k] si X.tiempo-opt tiempo-mejor entonces si X.k = n entonces sol-mejor:=X.sol; tiempo-mejor:= X.tiempo sino aadir(C,X) tiempo-mejor:= min(tiempo-mejor, X.tiempo + pes[X.k]) fsi fsi X.asigando[t]:= falso fsi fpara fmientras ffun
fun pre-calculo-estimaciones (T[1..n, 1..n] de real) dev (opt[0..n], pes[0..n] de real) var rapido[1..n], lento[1..n] de real {calculo de los minimos y maximos por filas} para i = 1 hasta n hacer rapido[i]:= T[i,1] lento[i]:= T[i,1] para j = 2 hasta n hacer rapido[i]:= min(rapido[i],T[i,j]) lento[i]:= max(lento[i],T[i,j]) fpara fpara {calculo de las estimaciones} opt[n]:= 0; pes[n]:= 0; para i = n-1 hasta 0 paso -1 hacer opt[i]:= opt[i+1]+ rapido[i+1] pes[i]:= pes[i+1]+ lento[i+1] fpara ffun
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Septiembre 2008 Cuestin 1 (1 punto). Escribe el grafo asociado al espacio de soluciones del problema del nonograma, a partir del nodo que se presenta a continuacin. Se supone que a partir de dicho nodo se 2 van a comenzar a explotar la fila 3. (No punta la exploracin por fuerza bruta de coste 2n ).
Cuestin 2 (2 puntos). El algoritmo mergesort posee una complejidad T(n) (n log n), describa y demuestre un caso en el que mergesort tiene una complejidad T(n) (n2).
Cuestin 3 (3 puntos). Considere un array A[1..n] ordenado y formado por enteros diferentes, algunos de los cuales pueden ser negativos. Escriba un algoritmo recursivo que calcule en tiempo logartmico un ndice i tal que 1 i n y T[i] = i , siempre que este ndice exista, devolviendo -1 si no existe. Se supone que las operaciones elementales tienen coste unitario. Demuestre el coste mediante la ecuacin de recurrencia. No justifique el esquema usado, aplquelo. Problema (4 puntos). Una empresa de mensajera tiene n repartidores con distintas velocidades segn el tipo de envo. Se trata de asignar los prximos n envos, uno a cada repartidor, minimizando el tiempo total de todos los envos. Para ello se conoce de antemano la tabla de tiempos T[1..n,1..n] en la que el valor t[i,j] corresponde al tiempo que emplea el repartidor i en realizar el envo j. Se pide:
RESPUESTAS EXAMEN Programacin III. Septiembre 2008 (Original) Cuestin 1 (1 punto). Escribe el grafo asociado al espacio de soluciones del problema del nonograma, a partir del nodo que se presenta a continuacin. Se supone que a partir de dicho nodo se 2 van a comenzar a explotar la fila 3. (No punta la exploracin por fuerza bruta de coste 2n ).
Fila 3:
O X
O O
O X X
O X O
O X O X
O X O O
Fila 4:
X X
X O
Cuestin 2 (2 puntos). El algoritmo mergesort posee una complejidad T(n) (n log n), describa y demuestre un caso en el que mergesort tiene una complejidad T(n) (n2). Solucin: Si utilizamos como posicin de corte el penltimo o (segundo) elemento del vector de forma consecutiva, el coste ser equivalente a: t (n) = t(n1) + t(1) + g(n) , donde g(n) (n) de forma que t (n) (n2)
Cuestin 3 (3 puntos). Considere un array A[1..n] ordenado y formado por enteros diferentes, algunos de los cuales pueden ser negativos. Escriba un algoritmo recursivo que calcule en tiempo logartmico un ndice i tal que 1 i n y T[i] = i , siempre que este ndice exista, devolviendo -1 si no existe. Se supone que las operaciones elementales tienen coste unitario. Demuestre el coste mediante la ecuacin de recurrencia. No justifique el esquema usado, aplquelo.
fun coincide (A: array[1..n], ini, fin:natural) dev entero lon = fin ini + 1 si lon < 1 entonces dev -1 sino si lon = 1 entonces si A[ini] = ini entonces dev ini sino dev -1 sino pos = (fin ini+1) div 2 si A[pos] = pos entonces dev pos sino si A[pos] < pos entonces dev coincide(A, pos+1, fin) sino dev coincide(A, ini, pos-1]) fsi fsi fsi fun
Ecuacin de recurrencia: cn k , si 1 n < b T (n) = k aT ( n / b ) + cn , si n b
( n k ) T ( n ) ( n k logn ) log a n b
En este problema: a=1, b=2, k=0, luego el caso es T ( n ) n k logn por lo que el coste es T ( n ) ( logn )
Problema (4 puntos). Una empresa de mensajera tiene n repartidores con distintas velocidades segn el tipo de envo. Se trata de asignar los prximos n envos, uno a cada repartidor, minimizando el tiempo total de todos los envos. Para ello se conoce de antemano la tabla de tiempos T[1..n,1..n] en la que el valor t[i,j] corresponde al tiempo que emplea el repartidor i en realizar el envo j. Se pide: Determinar qu esquema algortmico es el ms apropiado para resolver el problema.
Se trata de un problema de optimizacin con restricciones. Por tanto, podra ser un esquema voraz o un esquema de ramificacin y poda. Sin embargo descartamos el esquema voraz porque no es posible encontrar una funcin de seleccin y de factibilidad tales que una vez aceptado un candidato se garantice que se va alcanzar la solucin ptima. Se trata, por tanto, de un algoritmo de ramificacin y poda.
Escribir el esquema general.
Indicar que estructuras de datos son necesarias.

nodo=tupla asignaciones: vector[1..N]; ltimo_asignado: cardinal; filas_no_asignadas: lista de cardinal; coste: cardinal; Montculo de mnimos (cota mejor la de menor coste)
Desarrollar el algoritmo completo.
Las funciones generales del esquema general que hay que instanciar son: 1. a. solucin(nodo): si se han realizado N asignaciones (ltimo_asignado==N) 2. b. acotar(nodo,costes): nodo.coste + mnimo coste de las columnas no asignadas 3. c. compleciones(nodo,costes): posibilidades para la siguiente asignacin (valores posibles para asignaciones[ltimo_asignado+1])
4.
Funcin asignacin(costes[1..N,1..N]) dev solucin[1..N] Montculo:=montculoVaco(); nodo.ltimo_asignado=0; nodo.coste=0; cota:=acotar(nodo,costes); poner((cota,nodo),Montculo); mientras no vaco(Montculo) hacer (cota,nodo):=quitarPrimero(Montculo); si nodo.ltimo_asignado==N entonces devolver nodo.asignaciones; si no para cada hijo en compleciones(nodo,costes) hacer cota:=acotar(hijo,costes); poner((cota,hijo),Montculo); fsi; fmientras devolver ; Funcin acotar(nodo,costes[1..N,1..N]) dev cota cota:=nodo.coste; para columna desde nodo.ltimo_asignado+1 hasta N hacer minimo=; para cada fila en nodo.filas_no_asignadas hacer si costes[columna,fila]<mnimo entonces mnimo:=costes[columna,fila]; fsi fpara cota:=cota+mnimo; fpara devolver cota; Funcin compleciones(nodo,costes[1..N,1..N]) dev lista_nodos lista:=crearLista(); para cada fila en nodo.filas_no_asignadas hacer hijo:=crearNodo(); hijo.ltimo_asignado:=nodo.ltimo_asignado+1; hijo.asignaciones=nodo.asignaciones; hijo.asignaciones[hijo.ltimo_asignado]:=fila; hijo.coste:=nodo.coste+costes[hijo.ltimo_asignado,fila]; hijo.filas_no_asignadas:=nodo.filas_no_asignadas; eliminar(fila,hijo.filas_no_asignadas); aadir(hijo,lista); fpara; devolver lista;
UNED ESCUELA TCNICA SUPERIOR DE INGENIERA INFORMTICA INGENIERA TCNICA DE SISTEMAS E INGENIERIA TCNICA DE GESTION Programacin III Septiembre 2008 Reserva Cuestin 1 (1 punto). Escribe el grafo asociado al espacio de soluciones del problema del nonograma, a partir del nodo que se presenta a continuacin. Se supone que a partir de dicho nodo se 2 van a comenzar a explotar la fila 3. (No punta la exploracin por fuerza bruta de coste 2n ).
Cuestin 2 (3 puntos). Hallar formalmente el coste de los siguientes algoritmos, siendo h ( n, r , k ) ( n ) NOTA: Acertar a ojo se evala con cero puntos.
Cuestin 3 (2 puntos). Aplique el algoritmo de Prim al siguiente grafo empezando por el nodo 1. Indique claramente en cada paso qu arista se selecciona, y la evolucin de la solucin.
Problema (4 puntos). Un cajero automtico dispone de n tipos de billetes distintos teniendo cada uno de los n tipos un valor distinto. Se trata de calcular si es posible suministrar al cliente el valor exacto solicitado, y si este fuera el caso el sistema deber suministrar el conjunto de billetes que forman una solucin, adems se desea que el sistema utilice el menor nmero de billetes posible. Se puede suponer que el nmero de billetes de cada tipo disponibles es finito.
RESPUESTAS EXAMEN Programacin III. Septiembre 2008 (Reserva) Cuestin 1 (1 punto). Escribe el grafo asociado al espacio de soluciones del problema del nonograma, a partir del nodo que se presenta a continuacin. Se supone que a partir de dicho nodo se 2 van a comenzar a explotar la fila 3. (No punta la exploracin por fuerza bruta de coste 2n ).
X X
X O
O X
O O
X X X
X X O
O X X
O X O
O X X X
O X X O
Cuestin 2 (3 puntos). Hallar formalmente el coste de los siguientes algoritmos, siendo h ( n, r , k ) ( n ) NOTA: Acertar a ojo se evala con cero puntos.
El procedimiento uno tiene: Una instruccin constante, que no tenemos en cuenta para el clculo, o bien dos llamadas recursivas, ambas invocan la funcin con un tamao n/3. La expresin queda T(n) = T(n/2) + T(n/2) lo que equivale a T(n) = 2T(n/3) + c. Aplicando la resolucin genrica de las expresiones del tipo: T(n) = aT(n/b) + cnk con k = 0, a=2 y b=3 queda que 2 > 30 y por tanto la funcin T(n) tiene un coste
n log 3 2
El procedimiento dos tiene: Una llamada recursiva de tamao n/4, Otra llama recursiva de tamao n/4, Un bucle en el que se repite n veces un clculo consistente en llamar dos veces a una funcin h(n;r; k) de coste lineal, /*ms una instruccin simple*/, y por ltimo Una instruccin simple /* que no tenemos en cuenta para el calculo*/ y otra llamada recursiva de tamao n/4. Sumando los trminos nos sale T(n) = T(n/4) +T(n/4)+n (2n) +T(n/4), lo que equivale a T(n) = 3T(n/2) + 2n2 Aplicando la resolucin genrica de las expresiones del tipo T(n) = aT(n/b) + cnk y siendo 3 < 4 2 el coste es O(n2). a = 3, b = 4, k = 2
( n k ) T ( n ) ( n k log n ) log a n b
Cuestin 3 (2 puntos). Aplique el algoritmo de Prim al siguiente grafo empezando por el nodo 1. Indique claramente en cada paso qu arista se selecciona, y la evolucin de la solucin.
2 1 7 2 4 1 6 3 6 3 10
5 4 8 5 1 7
2 3 6 2 4 1 6 3 10
5 4 8 5
EVOLUCION EVOLUCION COMPONENTES SOLUCION {1}{2}{3}{4}{5}{6} INICIO {1,3}{2}{4}{5}{6} (1,3) 1 {(1,3)} {1,3,4}{2}{5}{6} (3,4) 2 {(1,3), (3,4)} {1,2,3,4}{5}{6} (2,3) 3 {(1,3), (3,4),(2,3)} {1,2,3,4,6}{5} (2,6) 4 {(1,3), (3,4),(2,3),( 2,6)} {1,2,3,4,5,6} (5,6) 5 {(1,3), (3,4),(2,3),( 2,6),(5,6)} Proceso terminado porque slo queda una nica componente conexa PASO ARISTA
Problema (4 puntos). Un cajero automtico dispone de n tipos de billetes distintos teniendo cada uno de los n tipos un valor distinto. Se trata de calcular si es posible suministrar al cliente el valor exacto solicitado, y si este fuera el caso el sistema deber suministrar el conjunto de billetes que forman una solucin, adems se desea que el sistema utilice el menor nmero de billetes posible. Se puede suponer que el nmero de billetes de cada tipo disponibles es finito. Solucin:
Se trata de un problema de optimizacin, por lo tanto descarto el esquema de vuelta atrs, descarto tambin el esquema de divide y vencers ya que no se puede dividir el problema en subproblemas iguales. Puede resolverse por un esquema voraz o ramificacin y poda, voy a descartar el voraz ya que auque es posible encontrar una funcin de seleccin y de factibilidad para resolver el problema no lo hara de una forma optima, por lo tanto utilizar ramificacin y poda. El problema es similar al Ejercicio 15.2, pgina 511 de Estructura de datos y mtodos algortmicos.
tipos nodo = reg sol[1..n]de 0..1 k:0..n peso, beneficio:real beneficio-opt:real {prioridad} freg ftipos
fun cajero-rp(P[1..n], V[1..n]de real, M: real)dev (sol-mejor[1..n]de 0..1, beneficio-mejor:real) var X,Y: nodo,C:colapr[nodo] {generamos raz} X.k:=0; Y.peso :=0; Y.beneficio:=0; (Y.beneficio.opt,beneficio-mejor):= calculo-estimaciones(P, V, M, Y.k, Y.peso, Y.beneficio) C:= cp-vacia(); aadir(C,Y) mientras es-cp-vacia?(C)^(minimo(C).beneficio-opt beneficio-mejor) hacer Y:= maximo C); eliminar-max(C) X.k:=Y.k+1; X.sol:=Y.sol; {probamos a meter el objeto en la mochila} si Y.peso + [X.k] M entonces {es factible y, por tanto, las estimaciones coinciden con las de Y} {beneficio-opt(X) = beneficio-opt(Y) beneficio-mejor } X.sol[X.k]:=1; X.peso:= Y.peso + P[X.k] X.beneficio:= Y.beneficio + V[X.k]; X.beneficio-opt := Y.beneficio-opt si X.k = n entonces { beneficio(X) = beneficio-opt(X) beneficio-mejor } sol-mejor:=X.sol; beneficio-mejor:= X.beneficio sino aadir(C,X) {no se puede mejorar beneficio mejor} fsi fsi {probamos a no meter el objeto (siempre es factible)} (X.beneficio-opt, pes) := calculo-estimaciones (P, V, M, Y.k, Y.peso, Y.beneficio) si X.beneficio-opt beneficio-mejor entonces X.sol[X.k] := 0; X.peso := Y.peso X.beneficio := Y.beneficio si X.k = n enteonces sol-mejor := X.sol; beneficio-mejor := X.beneficio sino aadir(C,X) beneficio-mejor := max(beneficio-mejor, pes) fsi fsi fmientras ffun
fun calculo-estimaciones (P[1..n], V[1..n] de real, M: real, k: 0..n, peso, beneficio:real) dev (opt, pes: real) hueco := M-peso; pes := beneficio; opt := beneficio; j := k+1 mientras j n ^ P[j] hueco hacer {podemos coger el objeto j entero} hueco := hueco-P[j] opt := opt + V[j]; pes:= pes + V[j] j := j+1 ; fmientras si j n entonces {quedan objetos por probar} {fraccionamos el objeto j (solucion voraz)} opt := opt + (hueco/P[j]*V[j] {extendemos a una solucin en la versin 0/1} j := j+1 mientras j n ^ hueco > 0 hacer si P[j] hueco entonces hueco := hueco P[j] pes := pes + V[j] fsi j := j+1 fmientras fsi ffun

Programacion III

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Programacion III

Caricato da

Copyright:

Formati disponibili

EXMENES RESUELTOS PROGRAMACIN III

Recopilacin de Exmenes de Programacin III

Problemas de Programacin III

Programacion III - Convocatoria de Febrero

Eleccin razonada del esquema

Esquema general e identificacin con el problema

Algoritmo completo a partir del refinamiento del esquema

Anlisis del coste

Programacion III - Convocatoria de Febrero

Sugerencia: Utilizad la siguiente relacion:

Programacion III - Convocatoria de Septiembre 96

Soluciones a los examenes de Septiembre 1996

Eleccion razonada del esquema algor tmico.

Descripcion del esquema usado e identi cacion con el problema.

Algoritmo completo a partir del re namiento del esquema general.

fun mapa (g:grafo) dev vector 1. . . N,1. . . N] de entero

fpara dev m fun

Estudio del coste.

Eleccion razonada del esquema algor tmico.

Descripcion del esquema usado e identi cacion con el problema.

: : : pk g descomposicion(problema) para cada si hacer si divide y venceras(pi) fpara dev combinacion(s1 : : : sk )

Algoritmo completo a partir del re namiento del esquema general.

proc fusion (v: vector 1. . . n] inicio, nal,factor: entero ) dev vector 1. . . n]

para h=inicio hasta nal hacer

si no hacer fsi fpara

proc b (v: vector 1. . . c*f], entero: c) dev vector 1. . . c*f]

Estudio del coste.

T (n) = 2T (n=2) + cte n

Eleccion razonada del esquema algor tmico.

Descripcion del esquema usado e identi cacion con el problema.

Programacion III - Convocatoria de Septiembre 96

Divide y venceras: Vuelta atras:

Programacion III - Convocatoria de Febrero de 1997

Problema 1 (5 puntos). Dado un conjunto de n cintas con n registros ori

Eleccin razonada del esquema

Esquema general e identificacin con el problema

Algoritmo completo a partir del refinamiento del esquema

Anlisis del coste

Programacion III - Convocatoria de Febrero de 1997

en una cinta de audio de

Problema 1(5 puntos). Dise~ar un algoritmo que permita almacenar el maximo n

Programacion III - Convocatoria de Septiembre de 1997

Programacion III - Convocatoria de Febrero de 1998

proc hacerMovimiento(D,mov) D[mov.origen.x,mov.origen.y] 0 D[mov.destino.x,mov.destino.y] 1 D[mov.comido.x,mov.comido.y] 0 fin proa

proc deshacerMovimiento(D,sol[etapa]) D[mov.origen.x,mov.origen.y] 1 D[mov.destino.x,mov.destino.y] 0 D[mov.comido.x,mov.comido.y] 1 fin proa

Programacion III - Convocatoria de Febrero de 1998

Programacion III - Convocatoria de Septiembre de 1998

Problema 1 (5 puntos). Dado un conjunto de n rectangulos cuyos lados son paralelos

Problema 2 (5 puntos). Una cadena euleriana en un grafo no orientado es una cadena

RESPUESTAS EXAMEN Programacin III. Febrero 2000 (Segunda Semana)

Programacion III - Septiembre 2.000 - Original

Cuestion 3 (2 puntos). >Cual es la relacion entre la ordenacion por

Fun Fibiter(n) i 1; j 0; para k 1 hasta n hacer j j + i; i j i; Fpara devolver j; Ffun

Tiempo: Tiempo: Tiempo: Tiempo: Tiempo:

0.266 0.266 0.266 0.266 0.266

Tiempo: Tiempo: Tiempo: Tiempo: Tiempo:

11211.5 s. 18116.5 s. 29307.125 s. 47427.625 s. 76710.469 s.

Para calcular el coste podemos utilizar la siguiente recurrencia:

Tenemos a=2, b=2, k=1;

Proc aadir - nodo (T[1...n],v) T[n+1] v Flotar(T[1...n+1],n+1) Fproc

{1} {1,2} {1,2,4} {1,2,4,3} {1,2,4,3,5}

{2,3,4,5,6} {3,4,5,6} {3,5,6} {5,6} {6}

Programacion III - Convocatoria de Septiembre de 2001

proc b (v: vector 1. . . cf], entero: c) dev vector 1. . . cf]

Apellidos: _______________________________________________ Nombre: _

Nombre: __________________ Centro donde entreg la prctica: Especialidad:

Apellidos: _______________________________________________ Nombre: _