Algoritmos y Estructuras de Datos UNLP

Apuntes de Algoritmos y Estructuras de Datos Programaci´ on o n III Facultad de Informática atica - UNLP Alejandro Santos [email protected]

Curso 2013 (actualizado 29 de julio de 2013)

Prog. III

2

´ Indice general 1. Tiempo Tiempo de Ejecuci Ejecuci´ ´ on on

7

1.1. 1.1. Tiempo Tiempo de de Ejecuci Ejecuci´ on oń . . . . . . . . . . . . . . . . . 1.2. 1.2. An Análisis álisis Asintótico otico BigOh . . . . . . . . . . . . . . 1.2.1. 1.2.1. Po Porr definici definici´ on oń . . . . . . . . . . . . . . . . . 1.2.2. 1.2.2. Ejemplo Ejemplo 1, por por definic definici´ i´ on on Big-Oh . . . . . . 1.2.3. 1.2.3. Po Porr regla regla de los polinomi polinomios os . . . . . . . . . . 1.2. 1.2.4. 4. Po Porr regla regla de la la suma suma . . . . . . . . . . . . . 1.2.5. 1.2.5. Otras Otras reglas reglas . . . . . . . . . . . . . . . . . . 1.2.6. 1.2.6. Ejemplo Ejemplo 2, por por definic definici´ i´ on on Big-Oh . . . . . . 1.2.7. 1.2.7. Ejemplo Ejemplo 3, por por definic definici´ i´ on on Big-Oh en partes . 1.2.8. 1.2.8. Ejemplo Ejemplo 4, por por definic definici´ i´ on. on. . . . . . . . . . . 1.3. 1.3. An An´álisis alisis de Algoritmos y Recurrencias . . . . . . . . 1.3.1. 1.3.1. Expresi Expresión oń constante . . . . . . . . . . . . . 1.3.2. 1.3.2. Grupo de const constan antes tes . . . . . . . . . . . . . 1.3.3. 1.3.3. Secuenci Secuencias as . . . . . . . . . . . . . . . . . . . 1.3.4. 1.3.4. Cond Condici icional onales es . . . . . . . . . . . . . . . . . 1.3. 1.3.5. 5. for y whi while le . . . . . . . . . . . . . . . . . . . 1.3.6. 1.3.6. for y while, while, ejemplo ejemplo . . . . . . . . . . . . . . 1.3.7. Llamadas recursivas recursivas . . . . . . . . . . . . . 1.3.8. 1.3.8. Ejemplo Ejemplo 5, itera iterativ tivoo . . . . . . . . . . . . . . 1.3.9. 1.3.9. Ejemplo Ejemplo 6, recur recursiv sivoo . . . . . . . . . . . . . 1.3.10. Ejemplo 7, recursivo . . . . . . . . . . . . . 1.3.11. Ejemplo 8, Ejercicio 12.4 . . . . . . . . . . . 1.4. 1.4. Otros Otros ejemplo ejemploss . . . . . . . . . . . . . . . . . . . . 1.4. 1.4.1. 1. Ejemp Ejemplo lo 9 . . . . . . . . . . . . . . . . . . . Planteo de la recurrencia recurrencia . . . . . . . . . . . Demostración on del orden (f ( f (n)) . . . . . . 1.4. 1.4.2. 2. Ejemp Ejemplo lo 10 . . . . . . . . . . . . . . . . . . Antes de empezar empezar . . . . . . . . . . . . . . . Ejercicio . . . . . . . . . . . . . . . . . . . .

O

3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8 8 9 9 10 10 11 11 12 13 15 15 15 15 15 15 15 17 17 18 19 21 23 23 23 25 26 26 27

´ INDICE GENERAL

Prog. Prog. III

Demostración on del orden (f ( f (n)) . . . . . . . . . . . . 29 1.5. Identidades Identidades de sumatorias sumatorias y logaritmos logaritmos . . . . . . . . . . . . . 30

O

2. Lista Listass

31

2.1. 2.1. Los Pares Pares del del Fara´ Fara´ on on . . . . . . . . . . . . . . . . . . . . . 2.1.1. 2.1.1. Explicac Explicaci´ i´ on on del problema . . . . . . . . . . . . . . . 2.1.2. 2.1.2. Implem Implement entaci´ aci´ on on Java . . . . . . . . . . . . . . . . . 2.2. 2.2. PilaMi PilaMin n . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.1. 2.2.1. Explicac Explicaci´ i´ on on del problema . . . . . . . . . . . . . . . 2.2.2. 2.2.2. Implem Implement entaci´ aci´ on on Java - Versión on con Lista Enlazada . 2.2.3. 2.2.3. PilaMi PilaMin, n, menor menor elemen elemento to en tiempo tiempo (1) . . . . . .

O

. . . . . . .

. . . . . . .

´ 3. Arboles binarios y Generales

32 32 33 34 34 35 35 39

3.1. 3.1. Evalu Evaluar ar arbol a´rbol de expresión on . . . . . . . . . . . . . . . . 3.1.1. 3.1.1. Explicac Explicaci´ i´ on on del problema . . . . . . . . . . . . . 3.1.2. 3.1.2. Implem Implement entaci´ aci´ on on Java . . . . . . . . . . . . . . . 3.2. M´ınimo del Nivel . . . . . . . . . . . . . . . . . . . . . 3.2.1. 3.2.1. Explicac Explicaci´ i´ on on del problema . . . . . . . . . . . . . 3.2.2. 3.2.2. Implem Implement entaci´ aci´ on on Java - Recursivo con Integer . 3.2.3. 3.2.3. Implem Implement entaci´ aci´ on on Java - Recursivo con int . . . . 3.2.4. 3.2.4. Implem Implement entaci´ aci´ on on Java - Iterativo . . . . . . . . . 3.3. Trayectoria rayectoria Pesada Pesada . . . . . . . . . . . . . . . . . . . . 3.3.1. 3.3.1. Forma de encara encararr el ejercici ejercicioo . . . . . . . . . . . 3.3.2. 3.3.2. Recorri Recorrido do del arbol a´rbol . . . . . . . . . . . . . . . . 3.3.3. 3.3.3. Procesami Procesamien ento to de los los nodos nodos . . . . . . . . . . . 3.3.4. Almacenamien Almacenamiento to del resultado resultado . . . . . . . . . . 3.3.5. Detalles Detalles de implementac implementaci´ i´ on on . . . . . . . . . . . Modularización on . . . . . . . . . . . . . . . . . . esHoja() . . . . . . . . . . . . . . . . . . . . . public y private . . . . . . . . . . . . . . . . Clases abstractas abstractas . . . . . . . . . . . . . . . . . 3.3.6. 3.3.6. Errores Errores comunes comunes en las las entreg entregas as . . . . . . . . . 3.4. 3.4. Arboles Arboles Generales Generales:: Ancestro Ancestro Com´ un un más as Cercano . . . 3.4.1. 3.4.1. Explicac Explicaci´ i´ on on General . . . . . . . . . . . . . . . 3.4.2. 3.4.2. Versi´ ersion ón Recursiva . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

´ 4. Arboles AVL

40 40 40 41 41 42 42 43 44 44 44 44 45 46 46 47 48 48 49 53 53 53 57

4.1. 4.1. Perros Perros y Perro Perross y Gatos Gatos . . . . 4.1.1. 4.1.1. Explicac Explicaci´ i´ on on del problema 4.1.2. 4.1.2. Implem Implement entaci´ aci´ on on Java . . 4.2. 4.2. Pepe Pepe y Alicia Alicia . . . . . . . . . . 4

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

58 58 58 59

´ INDICE GENERAL

Prog. Prog. III

4.2.1. 4.2.1. Explicac Explicaci´ i´ on on del problema . . . . . . . . . . . . . . . . . 59 4.2.2. 4.2.2. Implem Implement entaci´ aci´ on on Java . . . . . . . . . . . . . . . . . . . 60 5. Grafo Grafoss

63

5.1. 5.1. Recorrid Recorridos os sobre sobre grafos grafos . . . . . . . . 5.2. 5.2. El n´ umero umero Bacon . . . . . . . . . . . 5.2. 5.2.1. 1. Calcul Calcular ar el el N´ umero umero de Bacon 5.2.2. 5.2.2. Explicac Explicaci´ i´ on on del problema . . . 5.2.3. 5.2.3. Implem Implement entaci´ aci´ on on Java - BFS . 5.2.4. 5.2.4. Implem Implement entaci´ aci´ on on Java - DFS . 5.3. Juan Carlos Verticio . . . . . . . . . 5.3.1. 5.3.1. Explicac Explicaci´ i´ on on del problema . . . 5.3.2. 5.3.2. Implem Implement entaci´ aci´ on on Java - DFS . 5.4. 5.4. Virus Virus de Compu Computado tadora ra . . . . . . . . 5.4. 5.4.1. 1. Dibu Dibujo jo . . . . . . . . . . . . . 5.4.2. Caracter´ Caracter´ısticas del grafo . . . 5.4.3. 5.4.3. Explicac Explicaci´ i´ on on del problema . . . 5.4.4. 5.4.4. Implem Implement entaci´ aci´ on on Java - BFS . 5.5. 5.5. Circui Circuitos tos Electr´ Electr´ onicos onicos . . . . . . . . . 5.5. 5.5.1. 1. Dibu Dibujo jo . . . . . . . . . . . . . 5.5.2. Caracter´ Caracter´ısticas del grafo . . . 5.5.3. 5.5.3. Explicac Explicaci´ i´ on on del problema . . . 5.5.4. 5.5.4. Implem Implement entaci´ aci´ on on Java - BFS . 5.5.5. 5.5.5. Implem Implement entaci´ aci´ on on Java - DFS . 5.6. 5.6. Viajante Viajante de Encues Encuestas tas . . . . . . . . 5.6.1. 5.6.1. Explicac Explicaci´ i´ on on del problema . . . 5.6.2. 5.6.2. Implem Implement entaci´ aci´ on on Java . . . . .

5

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

64 67 68 68 68 70 72 72 73 75 75 75 75 76 78 78 78 79 79 80 83 83 83

´ INDICE GENERAL

Prog. Prog. III

6

Introducci´ on on El presente apunte es una recopilaci´ on on de explicaciones y exámenes amenes parciales dados como parte de los cursos 2012-2013 de Programaci´ on o n III de 1 Ingenier Inge nier´´ıa en Computaci´ Compu tación, on, UNLP . Actualmente se encuentra en estado de borrador, y puede contener rro re s u omisiones, por lo que se recomienda consultar a los docentes ante cualquier duda o ambiguedad. Puede contactarse con el autor por e-mail a: [email protected] .

1

http://www.info.unlp.edu.ar/

7

´ INDICE GENERAL

Prog. Prog. III

8

Cap´ıtulo 1 Tiem Tiemp po de Ejec Ejecuc uci´ i´ on on

9

´ 1.1. TIEMPO TIEMPO DE DE EJECUC EJECUCI I ON

1.1. 1.1.

Prog. Prog. III

Tiem Tiempo po de Ejec Ejecuc uci´ i´ on on

Nos interesa analizar y comparar diferentes algoritmos para saber cu´ al es más as eficiente. Una forma de hacerlo hacer lo es escribir el código odigo de cada algoritmo, algor itmo, ejecutarlos ejecuta rlos con diferentes entradas y medir el tiempo de reloj que demora cada uno. Por ejemplo, para ordenar una secuencia de n´ umeros existen diferentes algoritmos: inserción, on, mergesort, etc. Se puede tomar cada uno de estos algoritmos y ejecutarlos con una secuencia de n´ umeros, midiendo el tiempo que umeros, tarda cada uno. Sin embargo, existe otra forma de comparar algoritmos, que se conoce como an´ alisis alisis asintótico. otico. Consiste en analizar el código odigo y convertirlo en una expresión on matemática atica que nos diga el tiempo que demora cada uno en funci´ on de la cantidad de elementos que se est´ a procesando. De esta forma, ya no es necesario ejecutarlos, y nos permite comparar algoritmos en forma independiente de una plataforma en particular. En el caso de los algoritmos de ordenaci´ on, on, la función on nos dar´ a un valor en base a la cantidad de elementos que se est´ an an ordenando.

1.2.

An´ alisis alisis Asint´ otico otico BigOh

f ( f (n) es de

O(g(n)) si y solo si ∃c tal que f ( f (n) ≤ cg( cg (n), ∀n ≥ n . 0

La definición on de BigOh dice que una funci´ on f on f ((n) es de orden g orden g((n) si existe una constante c constante c tal tal que la función g on g((n) multiplicada por dicha constante acota por arriba a la función on f ( f (n). Cuando decimos acota queremos decir que todos los valores para los que la funci´ on on está definida son mayores. Esto es, la funci´ on on g (n) acota a f ( f (n) si cada valor de g (n) es mayor o igual que f ( f (n). Por ejemplo, la función on g (n) = n + 1 acota por arriba a la funci´ on on f ( f (n) = n ya que para todo n 0, f ( f (n) g (n).

≥

≤

Nuestro objetivo es encontrar un c un c que que multiplicado por g por g((n) haga que se cumpla la definición. on. Si ese c ese c existe, existe, f f ((n) será de orden g orden g((n). Caso contrario, si no es posible encontrar c, f ( f (n) no es de orden g (n). El problema entonces se reduce a encontrar el c, que algunas veces es trivial y directo, y otras no lo es. Además, as, el hecho de no poder encontrarlo no quiere decir que no exista. 10

´ CAP ´ ITULO ITULO 1. TIEMPO TIEMPO DE EJECU EJECUCI CI ON

1.2. 1.2.1. 1.

Prog. Prog. III

Por defin definic ici´ i´ on on

Usando la definición o n de BigOh, una forma de descubrir si una funci´ on on f ( f (n) es de orden g (n) se traduce en realizar operaciones para despejar el valor de c, y descubrirlo en caso que exista, o llegar a un absurdo en caso que no exista.

1.2.2 1.2.2..

Ejemp Ejemplo lo 1, por defin definic ici´ i´ on on Big-Oh

Ejemplo: ¿3n es de

n

O(2 )? Primero escribimos la definición on de BigOh: f (n) ≤ cg( cg (n), ∀n ≥ n ∃c, f (

0

(1.2.1)

Luego identificamos y reemplazamos las partes: f ( f (n) = 3n g(n) = 2n

(1.2.2) (1.2.3)

Una vez identificadas las partes podemos expresar la pregunta en forma de BigOh, donde tenemos que encontrar un c que cumpla lo siguiente: 3n

n

≤ c2 , ∀n ≥ n

0

(1.2.4)

La segunda parte de la definici´ on, on, que dice para todo n mayor o igual a n0 , es tan importante como la primera, y no hay que olvidarse de escribirlo. El valor de n0 puede ser cualquier que nos ayude a hacer verdadera la desigualdad. Por ejemplo, en este caso se puede tomar n0 = 1. n0 no puede ser negativo. Elegir un n0 negativo significa que estamos calculando el tiempo de ejecuci´ on con una cantidad negativa de elementos, on algo que no tiene sentido. Eso tambi´ también en significa significa que las funciones siempre deben dar un valor positivo, dado que el valor de la funci´ on de la que se quiere calcular el orden on representa tiempo de ejecuci´ o n de un algoritmo. El tiempo debe ser siemon pre positivo, y por ejemplo decir que una funci´ on on demora 3 segundos en procesar 10 elementos tampoco tiene sentido. Se asume que 3n es de (2n), y se pasa el 2n dividiendo a la izquierda:

−

O

3n 2n

 3 2

≤ c, ∀n ≥ n ≤ c, ∀n ≥ n

0

(1.2.5)

0

(1.2.6)

n

11

´ ´ 1.2. 1.2. AN ALISIS ASINT OTICO BIGOH

Prog. Prog. III

Se llega a un absurdo, ya que no es posible encontrar un n´ umero umero c para que se cumpla la desigualdad para todo n mayor que alg´ un n0 fijo. Por lo un tanto es falso, 3n no es de (2n). Un análisis a lisis un poco más a s cercano nos muestra que la funcion ( 32 )n es siempre creciente hasta el infinito, donde el l´ımite:

O

l´ım

n→∞

 3 2

n

(1.2.7)

toma el valor infinito. Por ejemplo: para cualquier constante c fija, para algunos valores de n se cumple, pero para otros no. Con c = 100, n

≤ 3 2

100, 100, n

∀ ≥n

0

(1.2.8)

Despejando el valor de n, log log

3 2

n

≤  3 2

3 2

3 2

log 100, 100, n

∀ ≥n

3 2

0

(1.2.9)

n

= n;log n;log 100

≈ 11, 11,35 n ≤ 11, 11,35, 35, ∀n ≥ n

(1.2.10)

3 2

0

(1.2.11)

No es posible que n que n sea menor a 11, 11,35 y a la vez n vez n sea sea mayor a alg´ un n 0 , un n ya que n debe ser mayor que n0 siempre.

1.2.3 1.2.3..

Por reg regla la de los los poli polino nomi mios os

En las teor´ teor´ıas se vieron algunas reglas para simplificar simplificar el trabajo: Dado un polinomio P polinomio P ((n) de grado k grado k,, sabemos que el orden del polinomio k 2 es (n ). Ejemplo: P Ejemplo: P ((n) = 2n + 3n 3n + 5. Como el grado del polinomio es 2, 2 el orden de P ( P (n) es (n ). Esta regla solo se aplica a polinomios. Cualquier función o n que no lo sea habr´ a que desarrollarla por alg´ un otro método. un eto do. Ejemplo: Ejemp lo: T ( T (n) = n = n no es un polinomio, y no puede aplicarse esta regla.

O

O

1 2

1.2. 1.2.4. 4.

√

Por regl regla a de de la la sum suma a

Si T 1 (n) =

O(f ( f (n)) y T (n) = O(g (n)) entonces: 2

T 1 (n) + T + T 2 (n) = max( max ( (f ( f (n)), )), (g (n)))

O

12

O

(1.2.12)


1.2. 1.2.5. 5.

Prog. Prog. III

Otra Otrass regl reglas as

T ( T (n) = logk n es (n). T ( T (n) = cte, cte, donde cte es una expresi´ on constante que no depende del on valor de n es (1). T ( T (n) = cte f ( f (n) es (f ( f (n)).

→ O → O × → O

1.2.6 1.2.6..

Ejemp Ejemplo lo 2, por defin definic ici´ i´ on on Big-Oh

Calcular y demostrar el orden de T ( on: T (n) por definición: T ( T (n) = 2n3 + 3n 3n3 log(n log(n) Teniendo el T ( T (n), para demostrar por definici´ on o n el BigOh se empieza planteando cu´ a l puede ser, ya sea de forma intuitiva o por alguna de las al reglas conocidas. En este e ste caso, ca so, el orden parecer´ parecer´ıa ser: ser : (n3 log(n log(n)). Una vez planteado el Big-Oh posible, se aplica la definición on para verificar si realmente el orden elegido corresponde con la funci´ on: on:

O

∃k ∈ R, T ( T (n) ≤ kF ( kF (n), ∀n ≥ n

0

(1.2.13)

Se reemplazan T ( T (n) y F ( F (n) por sus correspondientes valores. La funci´ on on 3 F ( F (n) es el orden elegido, F ( F (n) = n log(n log(n): 2n3 + 3n 3n3 log(n log(n)

≤ kn

3

log(n log(n), n

∀ ≥n

0

(1.2.14)

Se pasa dividiendo n3 log(n log(n) hacia la izquierda: 2n3 + 3n 3n3 log(n log(n) n3 log(n log(n) 2 + 3 k, n log(n log(n)

≤ k, ∀n ≥ n ≤ ∀ ≥ n ,n = 2 0

0

0

(1.2.15) (1.2.16)

Se puede ver que es posible encontrar un k fijo que, sin importar el valor tomado por n, la desigualdad sea siempre cierta. Esto ocurre porque mientras n es más as grande, 2/ 2/ log(n log(n) es cada vez más as chico. Por lo tanto, la función on nunca va a tomar un valor mayor que alg´ un un k . En este ejemplo, k = 5 para que la desigualdad sea verdadera para todo n n0 , con n0 = 2. El valor de n de n 0 no puede ser menor que 2 ya que con n = 1 se tendrá una división on por cero.

≥

13


Prog. Prog. III

El objetivo de la demostración on es encontrar un k fijo de forma que se cumpla la desigualdad, para todo n n0 , y lo encontramos. Por lo tanto, T ( T (n) es de orden (n3 log(n log(n)).

≥

O

1.2.7 1.2.7..

Ejemp Ejemplo lo 3, por defin definic ici´ i´ on Big-Oh en partes on

Calcular y demostrar el orden de T ( T (n) por definición: on: 2n2 + n log(n log(n) T ( T (n) = 5n3 + 2n

(1.2.17)

Una segunda manera de demostrar el orden a partir de un T ( T (n) es en partes. Se toma cada término ermino por separado, y se demuestra demuestra el orden de cada uno. Si en todas las partes se cumple la desigualdad, quiere decir que se cumple en la función on original. De la misma forma que siempre, hay que elegir un orden para luego verificar si realmente se cumple. En este caso se elige: 3

O(n ) Es importante imp ortante que todos los términos erminos se comparen con el mismo orden , de otra forma la demostraci´ on on no será correcta. Planteando los tres términos erminos por separado se tiene: T 1 (n) = 5n3 T 2 (n) = 2n2 T 3 (n) = n log(n log(n)

(1.2.18) (1.2.19) (1.2.20)

Demostrando cada uno por separado: F (n), ∀n ≥ n ∃k , T (n) ≤ k F ( F (n), ∀n ≥ n ∃k , T (n) ≤ k F ( F (n), ∀n ≥ n ∃k , T (n) ≤ k F ( 1

1

1

1,0

2

2

2

2,0

3

3

3

3,0

(1.2.21) (1.2.22) (1.2.23)

Reemplazando las tres desigualdades se tiene: 3

3

∃k , 5n ≤ k n , ∀n ≥ n 5n ≤ k − −→ →5≤k n 1

1

1

(1.2.24)

1

(1.2.25)

3

3

1

14


2

3

Prog. Prog. III

∃k , 2n ≤ k n , ∀n ≥ n 2n 2 k − ≤ −→ → ≤ k n n 2

2

2

(1.2.26)

2

(1.2.27)

2

2

3

3

∃k , n log(n log(n) ≤ k n , ∀n ≥ n n log(n log(n) log(n log(n) ≤ −→ → ≤k k − n n 3

3

3

3

2

3

(1.2.28)

3

(1.2.29)

En los tres casos se llega a que la desigualdad se cumple, siendo posible encontrar un ki R fijo para cualquier valor positivo de n, mayor que algun ni . Por lo tanto, T ( T (n) es de orden (n3 ).

∈

1.2.8 1.2.8..

O

Ejemp Ejemplo lo 4, por defin definic ici´ i´ on. on.

¿Cuál al es el orden

O() de la siguiente función? on? F ( F (n) = n 1/2 + n1/2 log4 (n)

a) ¿Es de orden (n1/2 )? Para que F que F ((n) sea (n1/2) hace falta encontrar un k constante tal que se cumpla la siguiente desigualdad para todo n alg´ un n0 . un

O

O

≥

n1/2 + n1/2 log4 (n)

≤ kn

1/2

(1.2.30)

Pasando dividiendo el n1/2 hacia la izquierda queda:

n1/2 n1/2 log4 (n) + n1/2 n1/2 1 + log4 (n)

≤k ≤k

(1.2.31)

(1.2.32)

Se concluye que es falso, porque a medida que n aumenta, la parte de la izquierd izquierdaa de la desigua desigualdad ldad 1 + log4 (n) también en aumenta, aumenta , para p ara todo to do n cualquier n0 , y no es posible encontrar un k constante. No es de orden (n1/2 ).

≥

O

15


Prog. Prog. III

b) ¿Es de orden (log4 (n))? Para que F ( F (n) sea (log4 (n)) hace falta encontrar un k constante tal que se cumpla la siguiente desigualdad para todo n alg´ un n0 . un

O

O

≥

n1/2 + n1/2 log4(n)

≤ k log (n)

(1.2.33)

4

Pasando dividiendo el log4(n) hacia la izquierda queda: n1/2 n 1/2 log4 (n) + log4 (n) log4 (n) n1/2 + n1/2 log4 (n)

≤k

(1.2.34)

≤k

(1.2.35)

Se concluye que es falso, porque a medida que n aumenta, la parte de / la izquierda de la desigualdad logn (n) + n1/2 también en aumenta, aument a, para todo to do n cualquier n0 , y no es posible encontrar un k constante. No es de orden (log4 (n)). 1 2 4

≥

O

c) ¿Es de orden (n1/2 log4(n))? Para que F ( F (n) sea (n1/2 log4 (n)) hace falta encontrar un k constante tal que se cumpla la siguiente desigualdad para todo n alg´ un n0. un

O

O

≥

n1/2 + n1/2 log4 (n)

≤ kn

1/2

log4 (n)

(1.2.36)

Pasando dividiendo el n1/2 log4(n) hacia la izquierda queda: n1/2 n 1/2 log4 (n) + n1/2 log4 (n) n1/2 log4 (n) 1 + 1 log4 (n)

≤ k ≤k

(1.2.37)

(1.2.38)

Se concluye que es verdadero, porque a medida que n aumenta, la parte de la izquierda de la desigualdad log1(n) + 1 va tomando tomando cada vez vez valores más as peque˜ nos nos para todo n 2, n0 = 2. Por lo tanto, es posible encontrar el k constante y fijo que haga que se cumpla la desigualdad y F ( F (n) es de orden (n1/2 log4 (n)).

≥

O

16

4


1.3.

Prog. Prog. III

An´ alisis alisis de Algoritmo Algoritmoss y Recurrenc Recurrencias ias

El análisis a lisis de algoritmos consiste en convertir un bloque de código o digo o función on escrita en alg´ un lenguaje de programaci´ un on a su equivalente versi´ on on on que nos permita calcular su función on de tiempo de ejecuci´ on on T ( T (n). Eso es, el objetivo es encontrar cual es el tiempo de ejecuci´ on on a partir de la cantidad de elementos. El objetivo de resolver una recurrencia es convertir la funci´ on on en su forma expl´ expl´ıcita equivalente equivalente sin contener sumatorias ni llamadas recursivas. Para ello hace falta aplicar las definiciones previas de sumatorias, y el mecanismo de resolución on de recurrencias.

1.3. 1.3.1. 1.

Expr Expres esi´ i´ on on constante

Cualquier Cualquier expresi´ expresion oń que no dependa de la cantidad de elementos a procesar se marcar´ a como constante, c1 ,...,ck .

1.3.2 1.3.2..

Grupo Grupo de cons consta tan ntes tes

Cualquier grupo de constantes c1 ,...,ck se pueden agrupar en una unica uńica constante c, c = (c1 + ... + ... + + c ck ).

1.3.3 1.3.3..

Secu Secuen enci cias as

Dadas dos o más as sentencias una d despu´ espués es de la otra otr a sus tiempos se suman. suman .

1.3.4 1.3.4..

Cond Condic icio iona nale less

Dado un condicional if , el tiempo es el peor caso entre todos los caminos posibles de ejecuci´ on. on.

1.3. 1.3.5. 5.

for for y while hile

Los bloques for y while while se marcan como la cantidad de veces que se ejecutan, expresado como una sumatoria desde 1 a esa cantidad. En el caso del for del for se se usará como variable de la sumatoria el mismo indice del for. En el caso del while del while se se usará una variable que no haya sido usada.

1.3. 1.3.6. 6.

for for y whi while le,, eje ejemp mplo lo

Se tiene el siguiente c´ odigo: odigo: 17

´ 1.3. 1.3. AN ALISIS DE ALGORITMOS Y RECURRENCIAS

1 v oi o i d i n t f ( i n t N) 2 int x = 1 ; 3 while ( x < N) 4 / A l g o d e O ( 1 ) . . . 5 x = x 2; 6 7 return x ; 8

Prog. Prog. III

{

{

/

}

}

Tal como se describió, o, hace falta escribir el tiempo T tiempo T ((n) como una sumatoria de 1 hasta la cantidad de veces que se ejecuta el while el while . La cantidad de veces vece s que éste est e while se se ejecuta se puede plantear de la siguiente forma: 1. El while El while se se ejecuta mientras se cumple la condición on x < N . N . 2. La variable variable x x comienza en 1, en cada paso se multiplica su valor por 2, y la ejecución on termina cuando x llega a N a N .. 3. La cantidad cantidad de veces que que se ejecuta el while el while corresponde corresponde con la cantidad de veces que la variable x se multiplica por 2. Si decimos que la variable k representa la cantidad de veces que se multiplica la variable x por dos, la variable x entonces vale: x = 1

k

× 2 × 2 × ... × 2 = 2

(1.3.1)

Además as pedimos que x que x sea igual a N a N para para que el while finalice: x = N = N

(1.3.2)

Nos interesa entonces hallar el valor de k, a fin de hallar la cantida de veces que se ejecuta el while el while . Eso se logra facilmente aplicando propiedades de logaritmos: x = 2k x = N = N 2k = N log2(2k ) = log2 N k = log2 N 18

(1.3.3) (1.3.4) (1.3.5) (1.3.6) (1.3.7)


Prog. Prog. III

Por lo tanto, el T ( T (n) del ejemplo anterior es: log2 N

T ( T (n) = c1 +



(c2)

(1.3.8)

x=1

1.3.7. 1.3.7.

Llamad Llamadas as recurs recursiv ivas as

Las llamadas recursivas se reemplazan por la definicion de tiempo recursiva. Las definiciones recursivas son funciones definidas por partes, teniendo por un lado el caso base y por el otro el caso recursivo.

1.3.8 1.3.8..

Ejemp Ejemplo lo 5, iter iterat ativ ivo o

1 v oi o i d i n t sumar( i n t [ ] d a t o s ) 2 i n t acumulado = 0; 3 =0; i
{

{

}

}

Linea 2: c1 . Linea 3:



n i=1 .

Linea 4: c2 . Linea 6: c3 .

Todo junto, el T ( T (n) de la función on sumar es: n

T ( T (n) = c 1 + (



+ c3 c2 ) + c

(1.3.9)

i=1

El siguiente paso es convertir el T el T ((n) a su versión on expl´ expl´ıcita sin sumatorias sumat orias.. Aplicando las identidades de la sección on anterior: T ( T (n) = c 1 + nc + nc2 + c + c3 = c 4 + nc + nc2 , c4 = c 1 + c + c3

(1.3.10)

Por lo tanto, el T ( T (n) de la función on sumar es: T ( T (n) = c 4 + nc + nc2

¿Cuál al es su orden de ejecuci´ on on BigOh? T ( T (n) es

O(n).

19

(1.3.11)


1.3.9 1.3.9..

Prog. Prog. III

Ejemp Ejemplo lo 6, recu recurs rsiv ivo o

1 i n t rec 1 ( i n t n ) 2 i f ( n <= 1 ) 3 return 3 ; 4 else 5 return 1 + r e c 1 ( n 1) 6

{

rec1 (n 1);

−

}

−

Las funciones recursivas se definen por partes, donde cada parte se resuelve de forma similar a un codigo iterativo: T ( T (n) =



c1 2T ( T (n

− 1) + c + c

n 1 n > 1

≤

2

El objetivo es encontrar una versión on expl´ expl´ıcita de la recurrencias. Se comienza por escribir las primeras definiciones parciales:

T ( T (n T ( T (n

− −

T ( T (n) = 2T ( T (n 1) + c + c2 , n > 1 1) = 2T 2T ((n 2) + c + c2 , n 1 > 1 2) = 2T 2T ((n 3) + c + c2 , n 2 > 1

− −

−

(1.3.12) (1.3.13) (1.3.14)

− −

Segundo, Segun do, se expande expan de cada ca da término ermin o tres tre s o´ cuatro veces, las que sean necesarias para par a descubrir la forma en la que los diferentes términos erminos van cambiando: T ( T (n) = 2T ( T (n 1) + c + c2 T ( T (n) = 2(2T 2(2T ((n 2) + c + c2 ) + c + c2 T ( T (n) = 2(2(2T 2(2(2T ((n 3) + c + c2 ) + c + c2 ) + c + c2 T ( T (n) = 2(22 T ( T (n 3) + 2c 2c2 + c + c2 ) + c + c2 T ( T (n) = 23T ( T (n 3) + 22 c2 + 2c 2 c2 + c + c2 , n 3 1

− −

−

−

−

∀ − ≥

(1.3.15) (1.3.16) (1.3.17) (1.3.18) (1.3.19)

La definici´ on on recursiva contin´ ua ua mientras el n > 1, por lo que en k en k pasos tenemos la expresi´ on on general del paso k paso k:: k−1 k

T ( T (n) = 2 T ( T (n

− k) +

La llamada recursiva finaliza cuando n cuando n 20



2i c2

i=0

− k = 1, por lo tanto:

(1.3.20)


Prog. Prog. III

n k=1 k = n = n 1

−

n−1−1

T ( T (n) = 2

n−1

T (1) T (1) +

(1.3.21) (1.3.22)

−

  

2i c2

(1.3.23)

2i c2

(1.3.24)

i=0 n−2

T ( T (n) = 2n 1 c1 + −

i=0 n−2

T ( T (n) = 2n 1 c1 + c + c2 −

2i

(1.3.25)

− 1) −c −c

(1.3.26) (1.3.27) (1.3.28)

i=0 n−2+1

n−1

T ( T (n) = 2 c1 + c + c2 (2 T ( T (n) = 2n 1 c1 + 2 n 1 c2 T ( T (n) = 2n 1 (c1 + c + c2 ) −

−

−

2 2

¿Cuál al es su orden de ejecuci´ on on BigOh? T ( T (n) es

n

O(2 ).

1.3.1 1.3.10. 0.

Ejemp Ejemplo lo 7, recu recurs rsiv ivo o

T ( T (n) =



c 2n + T + T ((n/2) n/2)

n = 1 n 2

≥

Se asume que n es potencia entera de 2. n

 k=0

1 =2 2k

− 21

n

Definiciones parciales: 2n n n T ( T ( 2 ) = 2 + T 3 2 2 2

T ( T (n) = 2n + T + T ((n/2) n/2) n 2n n T ( T ( ) = + T 2 2 2 2



T ( T (

Desarrollo: 21

 

n 2n n ) = + T 23 23 24


Prog. Prog. III

T ( T (n) = 2n + T + T ((n/2 n/2) 2n n T ( T (n) = 2n + + T 2 2 2 2n 2 n 2n n T ( T (n) = 2n + + + T 2 22 23 2n 2n 2 n 2n n T ( T (n) = 2n + + 2 + + T 2 2 23 24 3

T ( T (n) =

(1.3.29)

             i=0 3

(1.3.30)

(1.3.31)

(1.3.32)

2n n + T 2i 24

(1.3.33)

1 n + T 2i 24

(1.3.34)

T ( T (n) = 2n

i=0

Paso general k:

k−1

T ( T (n) = 2n

 i=0

1 n + T 2i 2k



(1.3.35)

Caso base: n =1 2k

k

= k → n = 2 → log n = k

log n−1

T ( T (n) = 2n

1 n + T 2i 2log n

   − 

(1.3.36)

1 + c 2i

(1.3.37)

+ c

(1.3.38)

+ c

(1.3.39)

 i=0

log n−1

T ( T (n) = 2n

i=0

1

T ( T (n) = 2n 2

2log n 1 2n T ( T (n) = 4n 2log n −

−

1

−

(1.3.40) 22


Prog. Prog. III

+ c − (2 2n)/2 + c 2n T ( T (n) = 4n − + c + c (n)/2 4n T ( T (n) = 4n − + c n T ( T (n) = 4n − 4 + c + c

T ( T (n) = 4n

1.3.1 1.3.11. 1.

log n

(1.3.41)

(1.3.42)

(1.3.43)

(1.3.44)

Ejemp Ejemplo lo 8, 8, Ejer Ejerci cici cio o 12 12.4 .4 T ( T (n) =



1 n 8T ( + n3 T ( ) + n 2

n = 1 n 2

≥

Soluciones parciales: n T ( T (n) = 8T ( T ( ) + n + n3 2 n n n T ( T ( ) = 8T ( T ( ) + ( )3 2 4 2 n n n T ( T ( ) = 8T ( T ( ) + ( )3 4 8 4 n n n T ( T ( ) = 8T ( T ( ) + ( )3 8 16 8

(1.3.45) (1.3.46) (1.3.47) (1.3.48)

Desarrollo: n T ( T (n) = 8T ( T ( ) + n + n3 2 n n T ( T (n) = 8(8T 8(8T (( ) + ( )3 ) + n + n3 4 2 n n n T ( T (n) = 8(8(8T 8(8(8T (( ) + ( )3 ) + ( )3) + n + n3 8 4 2 n n n n T ( T (n) = 8(8(8(8T 8(8(8(8T (( ) + ( )3) + ( )3 ) + ( )3 ) + n + n3 16 8 4 2 n n n n T ( T (n) = 8(8(82 T ( T ( ) + 8( )3 + ( )3) + ( )3 ) + n + n3 16 8 4 2 n n n n T ( T (n) = 8(83 T ( T ( ) + 8 2 ( )3 + 8( )3 + ( )3 ) + n + n3 16 8 4 2 n n n n T ( T (n) = 84 T ( T ( ) + 8 3 ( )3 + 82 ( )3 + 8( )3 + n3 16 8 4 2 n n3 = 80 ( 0 )3 2 23

(1.3.49) (1.3.50) (1.3.51) (1.3.52) (1.3.53) (1.3.54) (1.3.55) (1.3.56)


T ( T (n) = 84T ( T (

Prog. Prog. III

n 3 n 3 2 n 3 1 n 3 0 n 3 ) + 8 ( ) + 8 ( ) + 8 ( ) + 8 ( 0) 24 23 22 21 2 3

n T ( T (n) = 8 T ( T ( 4 ) + 2



n T ( T (n) = 8 T ( T ( k ) + 2



4

Caso k: k

Caso base: n =1 2k

i=0

k−1

i=0

n 8i ( i )3 2

(1.3.58)

n 8i ( i )3 2

(1.3.59)

k

log 2 → n = 2 → log n = log

k

= k

k = log n log n

T ( T (n) = 8

T ( T (

log n

T ( T (n) = 8

2

(1.3.60)

n 8i ( i )3 2

(1.3.61)

n3 8 ( i 3) (2 )

(1.3.62)

(23 )i n3 ( 3i ) 2

(1.3.63)

log n−1

n

    

)+ log n

i=0

n T ( T ( ) + n

(1.3.57)

log n−1

i=0

i

log n−1 log n

T ( T (n) = 8

T (1) T (1) +

i=0

log n−1 log n

T ( T (n) = 8

T (1) T (1) +

i=0

23i n3 ( 3i ) 2

(1.3.64)

log n−1

log n

T ( T (n) = 8

T (1) T (1) +

(n3)

(1.3.65)

i=0

T ( T (n) = 8log n + n3 log n

(1.3.66)

T ( T (n) = (23 )log n + n3 log n

(1.3.67)

T ( T (n) = 23

(1.3.68)

log n

×

+ n3 log n

T ( T (n) = (2(log n) )3 + n3 log n T ( T (n) = n 3 + n3 log n

24

(1.3.69) (1.3.70)


1.4. 1.4.

Prog. Prog. III

Otro Otross ejem ejempl plos os

1.4. 1.4.1. 1.

Eje Ejemplo mplo 9

Sea el siguiente programa, a. Calcula Calcularr su T su T ((n), detallando los pasos seguidos para llegar al resultado. resultado.

O(f ( f (n)) justificando usando la definici´ on on de BigOh.

b. Calcula Calcularr su

1 i n t uno( i n t n ) 2 ++) f o r ( i n t i = 1 ; i <= n ; i ++ 3 1 ; j <= i ; j ++ ++) f o r ( i n t j = 1; 4 algo de O ( 1 ) ; 5 6 7 i f ( n > 1 ) 8 ++) f o r ( i n t i = 1 ; i <= 4 ; i ++ 9 uno ( n / 2 ) ; 10

{

}

{

{

}

}

Planteo de la recurrencia



c1

n T ( T (n) = n i c + 4T 4 T ( ( ) 2 i=1 j=1 j =1 2 Eliminando las sumatorias tenemos: n

i

n

  c2 =

i=1 j=1 j =1

  n

ic2 = c 2

i=1



i =

i=1



T ( T (n) =

c2 2 n (n ( n + n) 4 T (( ) n) + 4T 2 2 25

≥

c2 n(n + 1) c2 2 = (n ( n + n) n) 2 2

c1 c2 2 n (n ( n + n) n) + 4T 4 T (( ) 2 2 Desarrollo de la recurrencia: T ( T (n) =

n = 1 n 2

(1.4.1)

n = 1 n 2

≥

(1.4.2)

Prog. Prog. III

1.4. OTROS OTROS EJEMPL EJEMPLOS OS

                                                                                                  

c2 2 = (n ( n + n) n) + 4 2

c2 2

n 2

2

c2 2 c2 = (n (n + n) n) + 4 2 2

n 2

+

n 2

2

+

n 22

+ 4T 4T

n 2

+ 42 T

n 22

c2 2 c2 n 2 n = (n (n + n) n) + 4 + + 2 2 2 2 c2 n 2 n n 42 + + 4T 4 T 2 22 22 23

(1.4.3)

(1.4.4)

(1.4.5)

c2 2 c2 n 2 n (n (n + n) n) + 4 + + 2 2 2 2 c2 n 2 n n 3 42 + + 4 T 2 22 22 23

(1.4.6)

c2 2 c2 n 2 n (n (n + n) n) + 4 + + 2 2 2 2 n 2 n 2 c2 4 + + 2 22 22 c2 n 2 n n 43 + + 4T 4 T 2 23 23 24

(1.4.7)

c2 2 c2 n 2 n (n (n + n) n) + 4 + + 2 2 2 2 c2 n 2 n 42 + + 2 22 22 n 2 n n 3 c2 4 4 + + 4 T 2 23 23 24

(1.4.8)

=

=

=

c2 = 2 c2 = 2 c2 = 2

3

w

4

w=0

3

w

4

w=0 3

2

2w

w=0

c2 = 2

n 2w

2

+

n 2w

+ 44 T

n 24

(1.4.9)

n2 (2w )2

+ 4w

n 2w

+ 44 T

n 24

(1.4.10)

n 2 22w

+ 22w

n 2w

+ 44 T

n 24

(1.4.11)

3

n2 + 2 w (n) + 44 T

w=0

26

n 24

(1.4.12)


c2 T ( T (n) = 2 Paso general k: c2 T ( T (n) = 2

3

c2 n + 2 w=0



2

k−1

c2 n + 2 w=0



2

Prog. Prog. III

3



w

4

2 n + 4 T

w=0

k−1



w

k

2 n + 4 T

w=0

n 24



n 2k



(1.4.13)

(1.4.14)

Paso base: n =1 2k n = 2k log2 n = n = log 2 (2k ) log2 n = n = k k

log2 (n)−1

log2 (n)−1





(1.4.15) (1.4.16) (1.4.17) (1.4.18)

c2 c 2 n 2w n + 4 log n T log n (1.4.19) T ( T (n) = n2 + 2 w=0 2 w=0 2 c2 c 2 n = n 2 log2 (n) + (log2(n) + 1)n 1)n + 4 log n T log n (1.4.20) 2 2 2 log n 2 log n log n 2 4 = (2 ) = (2 ) = n 2 (1.4.21) c2 c2 = n 2 log2 (n) + (log2 (n) + 1)n 1)n + n + n2 T ( T (1) (1.4.22) 2 2 c2 c2 c 2 T ( T (n) = n 2 log2 (n) + n log2 (n) + n + n + c c1 n2 (1.4.23) 2 2 2 2

    2

2

2

2

Demostraci´ on on del orden

2

2

f (n)) O(f (

Se elige el término ermino de mayor orden: c2 n 2 log2 (n) f ( f (n) es de (g(n)) si y solo si w tal que f ( f (n) wg( wg (n), n ¿T ( T (n) es de (n2 log2 (n))? 2

O O

∃

≤

∀ ≥n . 0

c2 2 c 2 c2 n log2 (n) + n log2 (n) + n + n + c c1n2 wn2 log2 (n) (1.4.24) 2 2 2 2 c2 n log2 (n) c2n log2 (n) c2 n c1 n2 + 2 + + w (1.4.25) 2n2 log2 (n) 2n log2 (n) 2n2 log2 (n) n2 log2(n) c2 c2 c2 c1 + + + w (1.4.26) 2 2n 2n log2 (n) log2(n)

≤

≤ ≤

27

Prog. Prog. III


Dado que la parte izquierda de la desigualdad es una función on decreciente, con n0 = 2 se tiene que se cumple la definici´ on on de BigOh, donde T ( T (n) wn2 log2 (n), n 2.

≤

∀ ≥

c2 c2 c2 c1 c2 c2 c2 c 1 + + + = + + + = c 2 + c + c1 = w = w(1.4.27) (1.4.27) 2 4 4log2 (2) log2(2) 2 4 4 1 Por lo tanto se demuestra que el T ( T (n) es efectivamente

2

O(n

1.4. 1.4.2. 2.

log2 (n)).

Eje Ejemplo mplo 10

Sea el siguiente programa, a. Calcula Calcularr su T su T ((n), detallando los pasos seguidos para llegar al resultado. resultado. f (n)) justificando usando la definici´ on on de BigOh. O(f (

b. Calcula Calcularr su

1 p u bl b l ic i c s t a t i c v oi oi d f ( i n t n ) 2 sum=0, sum1=0, sum1=0, sum2=0; sum2=0; i n t sum=0, 3 =1; i <= n ; i += += 0 . 5 ) f o r ( double i =1; 4 ++sum1 ; 5 =1; j <= sum sum11 ; j++ j++) f o r ( double j =1; 6 sum2++; 7 k=j ; k <= sum1 sum1 ; k++) f o r ( double k=j 8 sum += sum1 + su m2 ; 9 10 11 12 return sum; 13

{

{

{

}

}

{

}

}

Antes de empezar

Para plantear inicialmente este ejercicio hace falta analizar el programa. Una estrategia interesante para resolver este tipo de ejercicios consiste en reescri reescribir bir los l´ımites ımites de los bucles, bucles, a fin de consegui conseguirr un program programaa que se ejecute la misma cantidad de veces que el original y calcule los mismos valores con el mismo resultado, pero que sea más as fácil acil para analizar. Por ejemplo, los programas F1 y F2 son equivalentes en cuanto al valor calculado calculado y cantidad cantidad de veces que se ejecuta cada bucle, solo var´ ar´ıan en sus constantes: 28


1 p u bl b l ic i c s t a t i c v o iid d F1 ( i n t n ) 2 int x = 0 ; 3 0 ; i <= 1 0 n ; i += 1 0) 0) f o r ( i n t i = 1 0; 4 x += a l g o d e O 1 ( i ) ; 5 6 return x ; 7

Prog. Prog. III

{

{

}

}

1 p u bl b l ic i c s t a t i c v o iid d F2 ( i n t n ) 2 int x = 0 ; 3 ++) f o r ( i n t i = 1 ; i <= n ; i ++ 4 x += a l g o d e O 1 ( i 1 0 ) ; 5 6 return x ; 7

{

{

}

}

Al momento de escribir el tiempo de ejecuci´ on de los programas, se pueden on tener: 1. Sumatorias Sumatorias que sus variables variables tomen los mismos valores valores que los bucles del programa. 2. Sumatorias que tengan la misma cantidad de términos erminos que la cantidad de veces que se ejecuta cada bucle del programa. Estas dos estrategias estrategias son equivalen equivalentes tes entre s´ s´ı. Por esto, el tiempo de ejecución on de ambas funciones F1 y F2 anteriores es: F ( F (n) = C 1 + C + C 2 n + C + C 3

(1.4.28)

Donde C 1 , C 2 , C 3 son constantes constantes que su valor depende de la versi´ versión on del programa se est´ a analizando, ya sea F1 o F2. Ejercicio

A partir de esto podemos decir: El for con con ´ındi ın dice ce i se ejecuta 2 * n - 1 veces. La variable sum1 cuenta la cantidad de veces que se ejecuta el primer for. Su valor comienza en 1 y termina en 2 * n - 1 . 29

Prog. Prog. III


El for con co n ´ındi ın dice ce j j se ejecuta tantas veces como vale la variable sum1. Dado que el valor de la variable sum1 va cambiando a medida que se ejecuta el programa, programa, no es correcto decir que éste este for se ejecuta 2 * n veces, porque n siempre vale lo mismo pero sum1 no. El for con con ´ındi ın dice ce k se ejecuta sum1 - j + 1 veces. Dado que el ´ındice ındic e i del primer for no se utiliza sino solo para contar (y no aparece en ning´ un otro lugar del programa) podemos cambiar el un primer for (co ( con n ´ındi ın dice ce i) por esto otro: 1; i <= ( 2 f o r ( i n t i = 1;

n

− 1);

i ++ ++)

.. .

{

Con este cambio conseguimos que la variable i tome el mismo valor que la variable sum1, manteniendo manteni endo que éste este for se ejecute la misma cantidad de veces que el for original. A partir de este an´ alisis, podemos definir la función alisis, on de tiempo: 2n−1

i

i

   −   −      −  − −      

T ( T (n) =

c1

(1.4.29)

i=1 j=1 j =1 k= j

2n−1

i

T ( T (n) = c 1

(i

j + 1)

(1.4.30)

i=1 j=1 j =1

2n−1

T ( T (n) = c 1

i

i

i

i=1

j=1 j =1

2n−1

i2

T ( T (n) = c 1

i=1

2n−1

i2

T ( T (n) = c 1

i=1

2n−1

T ( T (n) = c 1

i=1

1 T ( T (n) = c 1 2 n

 i=0

i

i2 =

j + j +

j=1 j =1

1 2 i 2

(1.4.31)

j=1 j =1

1 + i i + i 2

1 2 1 i + i 2 2

(1.4.32)

(1.4.33)

(1.4.34)

2n−1

2

i +

i

i=1

n(n + 1)(2n 1)(2n + 1) 6 30

i(i + 1) + i 2

2n−1

i=1

1

(1.4.35)


2n−1

2n

   − 2

i2

i =

i=1

1 T ( T (n) = c 1 2



1 2

(4n (4n2 + 2n 2n)(4n )(4n + 1) 6

2

− (2n (2n) 2

− 4n

+

16n 16n3 + 4n 4n2 + 8n 8n2 + 2n 2n 6

− 4n

16 3 4 2 8 2 2 n + n + n + n 6 6 6 6

− 4n

 

1 T ( T (n) = c1 2



(2n (2n)2

1 T ( T (n) = c 1 2



2

+

−

(2 ( 2n

− 1)(2n 1)(2n) 2

4n 4 n2

− 2n

2

4n 4 n2

+

2





 

(1.4.39)

(1.4.40)

(1.4.41)

1

(1.4.37) (1.4.38)

− 22 n

2 n 3

− c 23 n



− 2n

4 + n2 2

2

16 3 n 6

4 T ( T (n) = c 1 n3 3 Demostraci´ on on del orden

(1.4.36)

i=1

(2n (2n)((2n )((2n) + 1)(2(2n 1)(2(2n) + 1) 6

1 T ( T (n) = c 1 2

T ( T (n) = c 1

Prog. Prog. III

(1.4.42)

f (n)) O(f (

Se elige el término ermino de mayor orden: g (n) = n 3 f ( f (n) es de (g(n)) si y solo si w tal que f ( f (n) ¿T ( T (n) es de (n3 )?

O O

∃

4 c1 n3 3

wg (n), ∀ n ≥ n . ≤ wg( 0

− c 23 n ≤ wn ∀n ≥ n 3

1

0

(1.4.43)

4n3 2n c1 3 c1 3 w (1.4.44) 3n 3n 4 2 c1 c1 2 w (1.4.45) 3 3n Dado que la parte izquierda de la desigualdad es una función on decreciente, con n0 = 1 se tiene que se cumple la definici´ on on de BigOh, donde T ( T (n) wn3 , n 1.

−

≤

−

≤

≤

∀ ≥

4 2 2 c1 = c1 3 3 3 Por lo tanto se demuestra que el T ( T (n) es efectivamente w = c = c1

(1.4.46)

−

3

O(n ).

31

Prog. Prog. III

1.5. IDENTIDA IDENTIDADES DES DE SUMATORIA SUMATORIAS S Y LOGARITMOS LOGARITMOS

1.5. 1.5.

Iden Identi tida dade dess de sumat sumator oria iass y loga logari ritm tmos os n



c = nc = nc

(1.5.1)

1) c − k + 1)c

(1.5.2)

i=1

n



c = (n

i=k

n



i =

i=1

n



n(n + 1)(2n 1)(2n + 1) 6

i2 =

i=0

n

  3

i =

i=0

n

n(n + 1) 2

n(n + 1) 2

1)(2n + 1)(3n 1)(3n2 + 3n 3n n(n + 1)(2n i = 30 i=0



4

n

 i=k

n

f ( f (i) =



(1.5.3)

(1.5.4)

2

(1.5.5)

− 1)

(1.5.6)

k−1

 −  −  − f ( f (i)

i=1 n

f ( f (i)

(1.5.7)

1

(1.5.8)

i=1

2i = 2n+1

i=0 n

ai =

i=0

1

an+1 1 a

(1.5.9)

logc a logc b

(1.5.10)

(1.5.11)

(1.5.12) (1.5.13) (1.5.14)

−

logb a = a =

a log = log a log b b log(a log(a b) = log a + log b logb (ba ) = b logb a = a c ab = a bc = (ac )b

−

×



32

Cap´ıtulo 2 Listas

33

´ 2.1. LOS PARE PARES S DEL FARA FARAON

2.1. 2.1.

Prog. Prog. III

Loss Par Lo Pares es del del Far Fara´ a´ on on

Entre todas sus fascinaciones, al Fara´ on on le atrae a trae la idea de ver qué grupos de objetos a su alrededor se pueden dividir en dos grupos de igual tama˜ no. no. Como Ingeniero/a del Fara´ on, es tu tarea escribir un programa en Java on, que, a partir de una lista que representa la cantidad de elementos de cada grupo, le permita al Fara´ on on descubrir cu´ antos grupos se pueden dividir en antos dos sin tener un elemento sobrante (ni tener que dividir el elemento sobrante por la mitad). int contar ( ListaDeEnteros L)

2.1.1 2.1.1..

{

.. .

}

Expl Explic icac aci´ i´ on on del problema

Se tiene una lista de n´ umeros enteros, y hay que devolver la cantidad de umeros números umeros pares que aparecen en la lista. El objetivo de este ejercicio es poner en pr´ actica los conceptos de abstraactica ción, on, teniendo un tipo abstracto que representa una secuencia de elementos sin importar imp ortar de qué forma fo rma se representa internamente la estructura. Es importante importante tener en cuenta que las listas se recorren con los métodos etodos presentes en la pr´ actica, sin acceder directamente al arreglo o nodos interioactica, res.

34

CAP ´ ITULO ITULO 2. LISTAS LISTAS

2.1.2 2.1.2..

Prog. Prog. III

Impl Implem emen enta taci ci´ ´ on on Java

1 int contar ( ListaDeEnteros L) 2 int c a n t i d a d = 0 ; 3 4 L . c o m e n z ar ar ( ) ; 5 while ( ! L . f i n ( ) ) 6 t o ( ) % 2 ) == 0 ) i f ( ( L . e l e m e n to 7 c a n t i d a d ++; 8 L . proximo ( ) ; 9 10 11 return c a n t i d a d ; 12

{

{

}

}

35

Prog. Prog. III

2.2. PILAMI PILAMIN N

2.2.

PilaMin

(a) Implementar Implementar una clase clase PilaDeEnteros donde donde todas to das las operaciones sean de tiempo constante (1).

O

(b) Implementar Implementar una una subclase PilaMin subclase PilaMin que que permita pe rmita obtener obte ner el m´ınimo ınimo elemento presente pr esente en la estructura, e structura, tambi´ en en en tiempo constante (1).

O

1 class PilaDeEnteros 2 ... public public vo void id p o n e r ( i n t e ) 3 ... p u bl bl ic ic i n t s a c a r ( ) 4 ... p u bl bl ic i c i n t tope () 5 ... public boolea boolean n esVacia () 6 7 8 c l a s s PilaMin extends P i l a D e E n t e r o s 9 ... p u bl bl ic i c i n t min() 10

{

{ } { }

} }

2.2.1 2.2.1..

{ } { }

{ }

{


La implementaci implementaci´ on o´ n de PilaDeEnteros PilaDeEnteros utiliza internamen internamente te una una ListaDeEnteros para DeEnteros para almacenar los elementos de la estructura. De esta forma, la lista se utiliza agregando y eliminando eliminando de la pila siempre en el mismo extremo, ya sea siempre al comienzo de la estructura, o siempre al final. Sim embargo, dependiendo de la implementaci´ implementaci´ on on concreta de ListaDeEnde ListaDeEnteros elegida, teros elegida, la eficiencia será diferente. Utilizando una ListaDeEnterosCouna ListaDeEnterosConArreglos , para insertar al comienzo del arreglo es necesario hacer el corrimiento de todos los elementos de la estructura, teniendo orden lineal (n), con n en tama˜ no no de la estructua. Algo similar ocurre en una ListaDeEnterosEnlazada una ListaDeEnterosEnlazada , donde para insertar al final de la estructura es necesario recorrerla desde el comienzo para hacer los enganches de los nodos al final. Insertar un elemento a final de una lista enlazada simple es e s tambi´ t ambi´ en en una operacion de orden (n). De todas formas, es posible conseguir acceso de tiempo constante en una lista. En un arreglo, insertar y eliminar un elemento al final es una operación on de tiempo constante, ya que sin importar la cantidad de elementos ni la posici´ on a la que se accede, se puede acceder directamente y no hace falta on hacer ning´ un corrimiento de elementos. un

O

O

36


Prog. Prog. III

En una lista enlazada simple, insertar y eliminar en el comienzo es tambi´ bién en de tiempo tiempo constan constante, te, ya que solo solo hace falta falta hacer hacer los enganch enganches es del primer nodo de la estructura junto con la referencia al primer elemento, sin importar cu´ antos elementos contiene la estructura. antos

2.2.2 2.2.2..

Impl Implem emen enta taci ci´ ´ on on Jav Java - Versi´ ersi´ on on con Lista Enlazada

class PilaDeEnteros private L i s t a D e E n t e r o s E n l a z a d a L = new new

{

ListaDeEn terosEnla zada () ; public public vo void id p o n e r ( i n t e )

L . comenzar ( ) ; L . a g r e g a r ( e ) ; /

{

Tiemp iempoo ct e .

/

} p u bl bl ic ic i n t s a c a r ( ) int x ;

{

L . comenzar ( ) ; x = L. elemento () ; L . e l i m i n a r ( ) ; / Tiemp iempoo ct e .

/

} p u bl bl ic i c i n t tope ()

{

L . comenzar ( ) ; return L. eleme nto () ; /

Tiem Tiempo po ct e .

/

} public boolea boolean n esVacia () return (L . tamanio () == 0) ; /

{

}

Tiem Tiempo po ct e .

/

}

2.2.3 2.2.3..

O(1)

Pila PilaMi Min, n, meno menor r eleme elemen nto en tie tiempo mpo

La operaci´ on on para obtener el m´ınimo elemento de la estructura también en debe ser de tiempo constante, por lo que recorrer la lista cada vez que se consulta el m´ınimo no es correcto. Tampoco ampo co es correcto c orrecto agregar una variable que acumule el m´ınimo entero e ntero agregado, porque si bien funciona mientras se le agregan elementos a la pila, 37

Prog. Prog. III


cuando se elimina un elemento de la pila ya pierde su valor. Por ejemplo: c l a s s PilaMin extends P i l a D e E n t e r o s .MAX VALUE; i n t minelem = I n t e g e r .MA public public vo void id p o n e r ( i n t e )

{

{

/ VERSION INCORREC INCORRECTA TA / minelem m ) minel minelem em = e ; i f ( e < minele er ( e ) ; super . p o n er

} p u bl bl ic i c i n t min()

{

/ VERSION INCORREC INCORRECTA TA return minelem ;

}

/

}

Es posible posible obtener obtener el m´ınimo ınimo elemen elemento to en tiempo tiempo constan constante te sin tener tener que recorrer la lista. A medida que se van agregando elementos, el nuevo menor es el menor elemento entre el menor actual y el nuevo elemento que se está agregando. Pero cuando se eliminan elementos, el menor debe pasar a ser el que estaba antes de agregarlo a la pila. Por lo tanto, se puede crear una segunda pila que contenga la misma cantidad de elementos y en la que se vaya apilando el menor en cada paso. Entonces, el menor será el que esté en el tope t ope de la segunda pila. Cuando se elimina un elemento de la estructura tambien es necesario eliminarlo de la pila de minimos.

38


Prog. Prog. III

/

V er e r si s i on o n f i n a l c o r r e c ta t a . / c l a s s PilaMin extends P i l a D e E n t e r o s p ri ri va v a te te s t a t i c i nt n t MIN( i n t a , i n t b ) return ( a < b ) ? a : b ;

{

{

} P i l a D e E n t e r o s m in in im im os os = new new PilaDeEnt eros () ; public public vo void id p o n e r ( i n t e ) i f ( esV acia () )

{

minimo minimoss . poner ( e ) ; else

minimos . pon er (MI (MIN( e , minimos . to pe () ) ) ; er ( e ) ; super . p o n er

} p u bl bl ic ic i n t s a c a r ( )

{

minimos minimos . sa ca r () ; return return super super . saca r () ;

} p u bl bl ic i c i n t min() return minimos . to pe ( ) ;

{

}

}

39

Prog. Prog. III


40

Cap´ıtulo 3 ´ Arboles binarios y Generales

41

´ ´ 3.1. EVALUA EVALUAR R ARBOL DE EXPRESI ON

3.1.

Prog. Prog. III

Evalua Evaluar r´ arbol arbol de expresi´ expresi´ on on

Dado un arbol a´rbol de expresión, on, implementar en Java una función on que calcule el valor de la expresión. on. El árbol arbol ya se encuentra construido, es de String y la función on será: a: f l o a t eva lua r ( ArbolBina rio < S t r i n g > a )

{

.. .

}

a´rbol 2 + 3 * 4, la funci´ on on deber´ a devolver el valor 14. Ejemplo: Dado el arbol

3.1.1 3.1.1..


El arbol árbol es de Strings porque hay diferentes tipos de nodos: operadores, y valores. Los operadores pueden ser +, +, , , /, y los valores son n´ umeros. umeros. Dado que cualquier cualquier subarbol de un arbol a´rbol de expresi´ expresion oń es tambi´ ta mbién en un arbol a´rbol de expresi´ on, on, la forma más as fácil acil y directa de resolverlo es de forma recursiva. Si el árbol arbol está vac´ vac´ıo se dispara dispar a un NullPointerException NullPointerException en la primer llamada, pero dado que el arbol a´rbol ya viene correctamente construido como un arbol árbol de expresi´ on, todos los nodos operadores tendr´ on, an an dos hijos, y los nodos de valores serán an hojas.

−×

3.1.2 3.1.2..


1 f l o a t eva lua r ( ArbolBina rio A) 2 S t r i n g d = A . g et e t Da D a to t o Ra R a iz iz ( ) ; 3 A r b o l B i n a r io i o I = A . g e t H i j o I z q u i e r d o ( ) ; 4 A r b o l B i n a r io i o D = A. getHij oDere cho () ; 5 6 i f (d . eq ua ls ( ”+” ) ) 7 return eva lua r ( I ) + eva lua r ( D) ; 8 i f ( d . e q u a l s ( ” ” ) ) 9 ev al ua r (D) (D) ; return ev al ua r ( I ) 10 i f ( d . e q u a l s ( ” ” ) ) 11 ev al ua r (D) (D) ; return ev al ua r ( I ) 12 i f ( d . e q u a l s ( ” / ” ) ) 13 return eva lua r ( I ) / eva lua r ( D) ; 14 15 return Float . par seF loa t (d ) ; 16

{

−

−

}

42

´ CAP ´ ITULO 3. ARBOLES BINARIOS Y GENERALES

3.2.

Prog. Prog. III

M´ınimo del Nivel Nivel

Implementar en e n Java Java una función on que dado un arbol a´rbol binario de enteros y un n´ umero umero de nivel, nivel, permita calcular calcular el m´ınimo valor del nivel nivel indicado. indicado. Considere la ra´ ra´ız como nivel cero. c ero. i n t calcula rMinimo ( ArbolBina rio a , i n t

numeroNivel)

3.2.1 3.2.1..

{

.. .

}


Hay dos formas diferentes de encarar este problema: de forma recursiva, y de forma iterativa. Ambas son simples de entender y correctas, dando el resultado esperado. En la forma recursiva hace falta pasar por par´ ametro ametro el arbol a´rbol y el numero de nivel actual. Cuando se llega al nivel esperado hay que devolver el valor actual, y cuando se regresa de la recursi´ on hay que comparar los minimos on entre los hijos izquierdo y derecho del nodo actual. En la forma iterativa hace falta recorrer por niveles el arbol, contando el nivel actual con la marca de null. Cuando se llega al nivel esperado hay que buscar entre todos los valores desencolados el m´ınimo de ellos. Una vez que se terminaron los elementos o se lleg´ o a un nivel más as que el buscado hay que cortar la b´ usqueda. usqueda. En ambos casos, hace falta verificar que el nivel realmente exista. Una forma de transmitirlo es devolviendo null cuando no se encontr´ o el valor. Esto solo se puede cuando se usa Integer como tipo de datos; usando int como tipo de datos de retorno no es posible devolver null. En el caso de usar int se puede usar la constante Integer.MAX VALUE para indicar que el valor no se encontr´ o. o. En Java, el operador ternario signo de pregunta ”?:” es un if reducido. La parte de la izquierda es la condici´ on, on, cuando es true se devuelve el valor del medio, y cuando es false se devuelve lo que hay a la derecha del dos puntos. Por ejemplo, la siguiente funci´ on on devuelve el máximo aximo entre los valores recibidos por par´ ametro: ametro: 1 2 3

i n t obtenerMaximo( i n t A, i n t B) return (A > B ) ? A : B ;

}

43

{

3.2. 3.2. M ´ INIMO DEL NIVEL

3.2.2 3.2.2..

Prog. Prog. III

Impl Implem emen enta taci ci´ ´ on Java - Recursivo con Integer on

1 I n t e g e r c a l c u la l a r M i n im i m o ( A r b o lB l B i n a ri r i o< o A, i n t numeroNivel) 2 (A) ) i f ( es Va ci o (A) 3 retu return rn null ; 4 == 0) i f ( numeroNivel == 5 return A. getDato Raiz () ; 6 7 I n t e g e r m i n I = c al a l cu c u la l a r Mi M i ni n i mo m o ( A . g e t H i j o I z q u ie ie r d o ( ) , numeroNivel 1) ; 8 I n t e g e r minD = c a l c u l ar a r M i n im i m o ( A . g e t H i jo jo D e r e c h o ( ) , numeroNivel 1) ; 9 10 / m in in I y mi minD p u uee de d e n s e r n u l l / 11 in I ! = null && && minD minD != null ) i f ( m in 12 minI : minD; return (minI < minD) ? minI 13 e l s e 14 in I ; return (minI == null ) ? minD : m in 15

{

− −

}

3.2.3 3.2.3..

Impl Implem emen enta taci ci´ ´ on Java - Recursivo con int on

1 / Devuelve In te ge r .MA .MAX VALUE cuando cuando no se encuentra 2 i n t calcula rMinimo ( ArbolBina rio A, i n t numeroNivel) 3 (A) ) i f ( es Va ci o (A) 4 return Integer .MAXVALUE; 5 == 0) i f ( numeroNivel == 6 return A. getDato Raiz () ; 7 8 in I = c a l c u l a r M i n i m o (A . g e t H i j o I z q u i e r d o ( ) , i n t m in numeroNivel 1) ; 9 i n t minD = calcula rMinimo ( A. getHij oDere cho () , numeroNivel 1) ; 10 11 return (minI < minD) ? minI minI : minD; 12

{

− −

}

44

/


3.2.4 3.2.4..

Prog. Prog. III

Impl Implem emen enta taci ci´ on ´ on Java - Iterativo

1 / Devuelve In te ge r .MA .MAX VALUE cuando cuando no se encuentra / 2 i n t calcula rMinimo ( ArbolBina rio A, i n t numeroNivel) 3 (A) ) i f ( es Va ci o (A) 4 return Integer .MAXVALUE; 5 6 C o l a G e n e r ic i c a > c o l a = new new ColaGenerica< ColaGenerica > r >>() () ; 7 minActual = In te ge r .MA .MAX VALUE; i n t ni ve lA ct ua l = 0 , minActual 8 boolean s a l i r = f a l s e ; 9 10 / R ec e c or o r ri r i do d o p o r n i v e l e s e n e l a r b o l / 11 c o l a . p on o n er e r ( A) A) ; 12 c o la l a . p o n e r ( null ) ; 13 14 while ( ! c o l a . e s V a c i a ( ) && ! s a l i r ) 15 A r b o l B i n a r i o E = c o l a . s a c a r ( ) ; 16 i f (E == null ) 17 m e r o Ni Ni v el el ) i f ( n i v e l A c t u a l == n u me 18 s a l i r = true ; 19 else 20 n i v e l A c t u a l ++; 21 22 i f ( ! co la . esVacia () ) 23 c o l a . p o n e r ( null ) ; 24 else 25 numeroNivell && e . getDatoRaiz () i f ( ni ve lAc tu al == numeroNive < minActual) 26 m in Act u al = e . g e t D a t o R a i z ( ) ; 27 i f ( t i e n e H i j o I z q u i e r d o ( A) ) 28 c ol o l a . p o n e r (A ( A . g et e t Hi H i jo j o Iz I z q u ie ie r d o ( ) ) ; 29 (A) ) i f ( tie neH ijo Der ech o (A) 30 c o l a . p o n e r (A ( A . g e tH t H i j o De D e r e ch ch o ( ) ) ; 31 32 33 34 return minActual ; 35

{

{

{

} }

}

}

{

{

{

}

}

45

Prog. Prog. III

3.3. TRAYECTOR TRAYECTORIA IA PESADA PESADA

3.3. 3.3.

Tray rayectori ectoria a Pesada esada

Se define el valor de trayectoria pesada de una hoja de un arbol a´rbol binario como la suma suma del contenido contenido de todos los nodos desde la ra´ ra´ız hasta hasta la hoja multiplicado por po r el nivel en el que se encuentra. encue ntra. Implemente un método etodo que, dado un arbol a´rbol binario, devuelva el valor de la trayectoria pesada de cada una de sus hojas. Considere Considere que el nivel nivel de la ra´ ra´ız es 1. Para el ejemplo de la figura: trayectoria pesada de la hoja 4 es: (4 3) + (1 2) + (7 1) = 21.

∗

∗

∗

Figura 3.1: Ejercicio 5

3.3.1 3.3.1..

Forma orma de enc encar arar ar el eje ejerc rcic icio io

El ejercicio se puede dividir en tres partes: 1. Recorri Recorrido do del arbol. a´rbol. 2. Procesami Procesamien ento to de los nodos. 3. Almacenamien Almacenamiento to del resultado.

3.3.2.

Recorrido Recorrido del ´ arbol arbol

Existen Existen diferentes maneras de recorrer arboles, ´ cada cual con sus ventajas y desventajas. Un recorrido recursivo puede ser interesante, en especial el preorden o inorden. Cualquiera Cualquiera de éstos estos se puede aplicar aplicar al ejercicio. ejercicio. Por ejemplo, a continuaci continuaci´ on1 oń1 se puede ver el recorrido preorden.

3.3.3 3.3.3..

Proce Procesa sami mien ento to de de los los nodos nodos

El el dibujo de ejemplo se pueden ver tres hojas. El valor de la trayectoria de cada hoja es: - Hoja 4: 7

× 1 + 1 × 2 + 4 × 3. 46


Prog. Prog. III

on on en pseudoc´ odigo de un recorrido preorden. odigo Algorithm 1 versi´ function R(A) vac´ıo then if A no es vac´ Procesar(A.dato) if A tiene hijo izquierdo then R(A.Izq) end if if A tiene hijo derecho then R(A.Der)

end if end if end function

- Hoja 9: 7

× 1 + 1 × 2 + 9 × 3. - Hoja 3: 7 × 1 + 3 × 2. En todas las hojas, como parte del valor de la trayectoria se encuentra la suma parcial de 7 1, y en todos los nodos hijos del nodo 1 se encuentra la suma parcial de 1 2. En general, para un nodo cualquiera cualquiera del árbol arbol todos sus hijos van a tener como parte de su trayectoria la suma parcial del camino que existe desde la ra r a´ız hasta ese nodo. Esto significa que, recursivamente, podemos acumular el valor del nodo actual multiplicado por el n´ u mero de nivel y pasarlo por parámetro umero a metro en el llamado recursivo de ambos hijos. Actualizando el pseudoc´ odigo2 odigo2 tenemos el recorrido preorden R con tres par´ ametros: ametros: el arbol a´rbol (A (A), el n´ umero umero de nivel actual (N (N ), ), y la suma acumulada desde la ra´ ra´ız hasta h asta el nodo actual (V ): ):

× ×

3.3.4. 3.3.4.

Almace Almacenam namien iento to del result resultado ado

En ambas versiones de pseudoc´ odigo anteriores se encuentra el llamaodigo do a la función on “Procesar”. El enunciado pide devolver el valor de cada una de las hojas del arbol, a´ rbol, por lo que hace falta utilizar una estructura que permite almacenar y devolver m´ ultiples elementos. En nuestra mateultiples ria, la estructura estructura más as adecuada que tenemos se llama ListaGenerica , que nos permite almacenar objetos de cualquier tipo que corresponda con el par´ ametro ametro de comod´ comod´ın de tipo. Otras opciones pueden ser ListaDeEnteros o ColaDeEnteros . Hace Hace falt faltaa hacer hacer un peque˜ peque˜ no análisis alisis acerca acerca de qu´ qué debe hacerse hacerse en “Procesar”. El ejercicio pide almacenar el valor de la trayectoria, donde 47

Prog. Prog. III


on on en pseudoc´ odigo del procesamiento de nodos. odigo Algorithm 2 versi´ ) function R(A,N,V ) vac´ıo then if A no es vac´ Procesar(A. Procesar(A.dato, dato, N , V ) ) if A tiene hijo izquierdo then R(A.Izq, N + 1, V + N A.dato) A.dato)

× ×

end if if A tiene hijo derecho then R(A.Der,

N + 1, V 1, V + N

× A.dato) × A.dato)

end if end if end function

éste este es un valor que se calcula a partir del dato propio de cada nodo y del nivel, teniendo en cuenta que el dato de la ho ja tambi´ también en debe ser almacenado. Esto significa dos cosas, por un lado, al hacer el recorrido recursivo el dato no puede almacenarse hasta no visitar una hoja, y por el otro el valor de la hoja debe ser parte del resultado final. En Java, “Procesar” puede puede ser una llamada llamada a un m´ etodo etodo separado separado,, o puede ser simplemente el código odigo mismo. Por ejemplo: 1 private private vo void id Proc esar ( ArbolBina rio A, i n t N, i n t V, L i s t a G e n e r i c a< a l i s t a ) 2 i f (A. esH oja ( ) ) 3 4 l i s t a . a g r eg e g a r ( V + ( I n t e g e r ) A . g et e t Da D a to t o Ra R a iz iz ( ) N) ; 5 6

{

{

}

}

3.3.5. 3.3.5.

Detall Detalles es de implem implemen entac taci´ i´ on on

Modularizaci´ on on

Modularizar y separar el c´ odigo odigo en diferentes funciones o métodos etodos suele ser una buena idea. Hasta ahora vimos que el ejercicio se puede separar en dos métodos. etodos. Sin embargo, embargo, se pide devolver devolver los valores de todas las hojas, por lo que hace falta que el e l método etodo principal del ejercicio tenga como tipo tip o de retorno ListaGenerica ListaGenerica (o la estructura elegida). Esto puede complicar la implementaci´ on del recorrido preorden, por lo que puede ser de mucha ayuda on tener otro o tro método etodo aparte que se encargue encargu e del recorrido recursivo. Una buena bue na forma de modularizar este ejercicio puede ser como el siguiente ejemplo: 48


Prog. Prog. III

1 class E j e r c i c i o C i n c o 2 p ub u b li li c s t a t i c L i s t a G e n e r i c a < I n t e g e r > C a l c u l a r T r a y e c t o r i a ( A r b o l B i n a r i o< o A) 3 L i s t a G e n e r i c a l i s t a = new new L i s t a E n l a z a d a G e n e r i c a r > ( ) ; 4 5 R e c o r r i d o (A, 1 , 0 , l i s t a ) ; 6 7 return l i s t a ; 8 9 10 p ri r i va v a te t e s t a t i c vo vo iid d Reco rrid o ( ArbolBina rio A, V , L i s t aG a G e n er e r i c a< a l i s t a ) i n t N, i n t V, 11 / / Me Me t o d o d e l r e c o r r i d o ”R ” R” p r eo e o r de de n r e c u r s i v o . 12 i f ( !A. esVacio () ) 13 // . . . 14 15 16 17 p ri r i va v a te t e s t a t i c vo vo iid d Proc esar ( ArbolBina rio A, V , L i s t aG a G e n er e r i c a< a l i s t a ) i n t N, i n t V, 18 // . . . 19 20

{

{

}

{

{

}

}

{

}

}

esHoja()

La definición on del método eto do esHoja() de la clase ArbolBinario puede ser: 49

Prog. Prog. III


1 c l a s s A r b o l B i n a r i o 2 public boolea boolean n esHoja () 3 return ! t i e n e H i j o I z q u i e r d o ( ) && ! tieneHijoDerecho () ; 4 5 6 public boolea boolean n tieneHijoIzquierdo () 7 return g e t R a i z ( ) . g e t H i j o I z q u i e r d o ( ) ! = null ; 8 9 10 public boolea boolean n tieneHijoDerecho () 11 return g e t R a i z ( ) . g e t H i j o D e r e c h o ( ) ! = null ; 12 13

{

{

}

{

}

{

}

}

public y private

En Java, la forma que se tiene de abstraer y encapsular c´ odigo odigo y datos es mediante los especifi especificador cadores es de acceso acceso. Dos de ellos son public y odigo odigo se puede invocar private, que permiten definir desde qué parte del c´ un método etodo o acceder a una variable. En el caso de este ejercici ejercicio, o, es importan importante te que el m´ etodo etodo princip principal al del recorrido sea public a fin de que los usuarios del ArbolBinario lo puedan utilizar. utilizar. Por otro lado, tener los métodos etodos auxiliares auxiliares como private permite que los detalles detalles de implementac implementaci´ i´ on permanezcan ocultos, dejando la libertad on que en un futuro sea posible modificar el código odigo y los detalles de implementación on teniendo el menor impacto en el mantenimiento del resto del c´ odigo odigo donde se utilizan estas llamadas. Clases abstractas

El operador “new” solo puede ser usado para instanciar clases que no sean abstract . Por ejemplo, el siguiente programa no es correcto, ya que el operador new se está usando para instanciar una clase abstract . 1 p u bl b l i c a b s t ra ra c t c l a s s X 2 public X( ) 3 // . . . 4 5 6 in ( S t r i n g [ ] a r g s ) p ub u b li li c s t a t i c vo v o iid d m a in

{

{

}

50

{


7 8 9

Prog. Prog. III

X y = new new X( ) ; // Error !

}

}

En particular, no es posible crear una instancia de ListaGenerica , ya que esta es una clase abstract . Es necesario instanciar una subclase que no sea abstract. Por ejemplo, ListaEnlazadaGenerica ListaEnlazadaGenerica . 1 public public vo void id f ( ) 2 L i s t a G e n e r i c a L = new new L i s t a E n l a z a d a G e n e r i c a r > ( ) ; 3

{

}

3.3.6 3.3.6..

Erro Errore ress comun comunes es en las las entr entreg egas as

1. No devolver los valores. El enunciado pide devolver los valores, por lo que imprimirlos mediante System.out.print(); no ser´ ser´ıa correcto corr ecto.. Hace falta utilizar una estructura que permita almacenar una cantidad variable de elementos para luego devolver la estructura completa. 2. No sumar el valor valor de la ho ja como parte de la trayectoria. trayectoria. Al momento de agregar el valor de la trayectoria hace falta incluir el valor de la hoja multiplicado por su nivel. Manteniendo la idea explicada hasta ahora, el siguiente resultado es incorrecto: 1 p r i va va te t e s t a t i c v oi oi d Proc esar ( ArbolBina rio A, i n t N, i n t V, V, L i s ta t a G e n er e r i c a< a l i s t a ) 2 i f (A. esH oja ( ) ) 3 l i s t a . a g r e g a r ( V ) ; / / I nc n c or o r re r e ct ct o , f a l t a c a l c u l a r hoja 4 5

{

{

}

}

3. No preguntar preguntar inicialmen inicialmente te si el arbol a´rb ol es vac´ vac´ıo. No solo hace falta pregunpregu ntar si el arbol arb ol tiene hijo izquierdo o hijo derecho, sino tambi´ ta mbi´ en en si el arbol arb ol original inicial tiene alg´ un dato. Eso se logra preguntando si la ra´ız un ız de e l uso del método etodo esVacio(). ArbolBinario es null, o mediante el 51

Prog. Prog. III


1 p r i va va te t e s t a t i c v oi oi d R( ArbolBin ario A) 2 i f ( !A. esVacio () ) 3 // . . . 4 5

{

}

{

}

Don de el método Donde eto do esVacio() se define dentro de la clase ArbolBinario como: 1 c l a s s A r b o l B i n a r i o 2 public bool boolea ean n esVacio () 3 return getRa iz () == null ; 4 5

{

}

{

}

4. Uso del del operado operadorr “++” a derecha derecha para incrementar incrementar de nivel. nivel. El operador “++” a derecha, por ejemplo en el caso de “n++”, hace que el valor de la variable n se modifique, pero este incremento incremento se realiza después es de devolver el valor original. Si se usa n++ como incremento de nivel, y esta expresión on está directamente en el llamado recursivo, el efecto deseado no se cumplirá. a. En cada llamada recursiva, el par´ ametro ametro n siempre tomará el mismo valor, y no se estará incrementando el nivel. 1 p u bl b l ic ic s t a t i c v o iid d R( ArbolBina rio A, i n t N) 2 i f (A. esH oja ( ) ) 3 / / E l p ar a r a´ me m e tr tr o N nu nu n c a l l e g a a l l lla a ma ma d o r e c u r s i v o c o n e l v a l o r i nc n c re r e me m e nt n t ad ad o . 4 else 5 i f ( A . t i e n e H i j o I z q u i e r d o ( ) ) R ( A . g e t H i j o I z q u i e r d o ( ) , N++) ; 6 i f ( A. tie neH ijo Der ech o () ) R ( A. getHi joDer echo () , N++); ++) ; 7 8

{

{

}

}

{

}

5. Pasar por par´ ametro ametro el árbol arbol en un método etodo no static de la clase a´rboles a la vez. ArbolBinario genera que se esten recorriendo dos arboles Por un lado, el árbol arbol que llega por par´ ametro, y por el otro el arbol de ametro, “this”. 52


Prog. Prog. III

1 c l a s s A r b o l B i n a r i o 2 public L i s t a G e n e r i c a T r a y e c t o r i a ( A r b o l B i n a r i o< o A) 3 // Ac´ a h a y d o s a´ r b o l e s . ” t h i s ” y ”A ” . 4 5

{

{

}

}

La solución on a esto puede ser: a ) Indicar los métodos etodos de recorrido recor rido como static, b ) Quitar el parámetro ametro y hacer el recorrido del arbol con “this”. c ) Implementar los métodos etodos en una clase diferente a ArbolBinario , por ejemplo dentro de la clase “EjercicioCinco”. 6. Preguntar por la existencia del hijo izquierdo o derecho a partir del valor devuelto por getHijoIzquierdo() getHijoIzquierdo() de ArbolBinario . 1 c l a s s A r b o l B i n a r i o 2 public A r b o l B i n a r i o g e t H i j o I z q u i e r d o ( ) 3 return new A r b o l B i n a r i o (ge tRaiz () . get HijoI zquie rdo () ) ; 4 5

{

}

{

}

De acuerdo a la definición on vista en clase de ArbolBinario , los lo s métoet odos getHijoIzquierdo y getHijoDerecho de ArbolBinario nunca devuelven null, y por lo tanto la siguiente pregunta nunca va a ser True, porque el operador “new” nunca devuelve null. 1 2 3

==null ) i f ( a r b o l . g e t H i j o I z q u i e r d o ( ) == / / N un ca p ue u e d e s e r T ru ru e .

{

} Lo ideal en este caso es utilizar utilizar los métodos etodos tieneHijoIzquierdo y tieneHijoDerecho, implementados dentro de la clase ArbolBinario tal como se muestra en la sección Detalles on Detalles de implementaci´ on .

7. Variable ariabless en null. El siguiente código o digo dispara siempre un error de on on del if da True entonces “lista” NullPointerException. Si la condici´ es null, y de ninguna forma es posible utilizar la variable “lista” porque justamente su valor es null. 53

Prog. Prog. III


1 2 3 4

( l i s t a == ==null ) i f (

{ }

l i s t a . a gr g r e ga g a r ( su sum ) ;

8. Preguntar si this es null. El lenguaje Java garantiza que “this” jamás as pueda ser null, ya que al momento momento de invocar invocar un método etodo de instancia en una variable con referencia null, se dispara un error de NullPointerException.

54


3.4. 3.4.

Prog. Prog. III

Arboles Arboles Genera Generales les:: Ancest Ancestro ro Com´ un m´ as Cercano

Sea un arbol a´rbol general que representa un arbol a´rbol genealógico ogico de una familia, dondee la ra dond r a´ız es el e l pariente pari ente inmigrante inm igrante que lleg´ ll eg´ o en e n ba barco rco desde un pa p a´ıs lejano le jano,, y la relación on de hijos son los hijos de cada persona. Escribir Escribir en Java Java un método etodo que, dado un arbol a´rbol general de Strings y dos nombres de personas, devuelva el nombre del ancestro en com´ un u n más as cercano a ambas personas. Esto es, la ra´ ra´ız siempre ser´ a ancestro en com´ un un de cualquier par de nodos del arbol, a´rbol, pero no necesariament necesariamentee es el m´ as as cercano. Asuma que no hay dos personas que se llamen igual en la familia (tradición on familiar), y en caso que no exista relación o n en com´ un entre ambas personas, un por ejemplo que una de las personas no figure en el arbol, a´rbol, devolver null. 1 S t r i n g a nc n c es e s tr t r oC o C om o m un u n ( A r b o lG l G e n er e r a l< l A , S t r in in g Nombr ombre1 e1 , St ri ng Nomb ombre2) re2) .. .

{

3.4.1 3.4.1..

}

Expl Explic icac aci´ i´ on on General

El problema se reduce a encontrar el nodo con mayor n´ umero de nivel que los elementos indicados formen parte de los nodos de sus sub´ arboles, arboles, sin importar en qué parte del sub´ arbol arbol se encuentren. Si alguno de los dos elementos elementos indicados indicados es la ra´ ra´ız misma, dado que la ra´ ra´ız no n o tiene tie ne ancest a ncestro ro debe d eber´ r´ a devolverse null. Además, as, pueden existir varios nodos que posean ambos elementos en sus sub´ arboles, arboles, por ejemplo la ra´ ra´ız es ancestro com´ un de cualquier par de nodos del arbol, un a´rbol, es por eso que se busca el de mayor nivel.

3.4. 3.4.2. 2.

Versi ersi´ on o ń Recursiva

1 class X 2 ancestroC roComu omun n ( ArbolGeneral< ArbolGeneral< p ub u b li li c s t a t i c St ri ng ancest S t r i n g > A , S t r i n g Nom1 , S t r i n g Nom2 ) 3 i f (A. esV aci o () ) 4 retu return rn null ; 5 6 i e ne n e N2 N 2 = f a l s e ; boolean t i e n e N 1 = f a l s e , t ie 7 L i s t a G e n e r i c a > L = A . g e t H i j o s () ; 8 S t r i n g a n c e s t r o = null ;

{

{

55

´ M AS ´ CERCANO 3.4. ARBOLES ARBOLES GENERALES: GENERALES: ANCESTRO ANCESTRO COM COM UN Prog. III

9 10 11 12 13 14 15 16 17 18 19 20 21

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

/ / P r i m e r o me f i j o s i a l g un u n su s u b a´ r b o l t i e n e u n n o d o ances tro . L . comenzar ( ) ; while ( ! L . f i n ( ) && a n c e s t r o == null ) a n c e s t r o = a n ce ce st st ro ro Co Co mu mu n ( L . e le l e m en e n t o ( ) , Nom1 , No Nom2 ); L . pro ximo ( ) ;

{

} / / En En ca c a so s o d e t e n er e r l o , d e vu v u e lv l v o e s te t e , y a q ue u e h ay ay q u e d e v o l v e r e l d e may or n i v e l . i f ( a n c e s t r o ! = null ) return a n c e s t r o ; / / S i no n o ha h a y h i j o q u e s ea e a a nc n c es e s tr t r o me f i j o s i e l n o do do a c t u a l e s a n c e s t r o ; d on o n de de N1 y N2 a mb mb o s e s t en e n e n a llgg un u n o d e m i s s ub u b a´ r b o l e s . L . comenzar ( ) ; while ( ! L . f i n ( ) ) tieneN1 = tieneN1 es Hi jo (L . eleme nto () , Nom1) ; tieneN2 = tieneN2 es Hi jo (L . eleme nto () , Nom2) ; i f ( tien eN1 && tien eN2 ) break ; L . pro ximo ( ) ;

{

|| ||

}

i f ( tien eN1 && tien eN2 ) return A. getDato Raiz () ; retu return rn null ;

} ArbolGeneral A, p r iv iv a te te s t a t i c bo bo ol ol ea ea n es Hij o ( ArbolGeneral< S t r i n g d at at o ) / / De D e vu v u el e l ve v e Tr Tr u e s i a llgg un u n no n o d o d e l s u ba b a r b ol ol t o t a l p o s e e como d a t o e l p a ra r a me m e tr t r o ” Da Dato ” i f (A. esV aci o () ) r et et ur ur n f a l s e ; i f (A. getDato Raiz () . eq ua ls ( dato ) ) return return true ;

{

56


42 43 44 45 46 47 48 49 50 51 52

L i s t a G e n e r i c a > L = A . g e t H i j o s () ; L . comenzar ( ) ; while ( ! L . f i n ( ) ) i f ( es Hij o (L. elemento () , dato ) ) return return true ;

{

{

}

L . pro ximo ( ) ;

}

r e tu tu rn rn f a l s e ;

}

Prog. Prog. III

}

57

´ M AS ´ CERCANO 3.4. ARBOLES ARBOLES GENERALES: GENERALES: ANCESTRO ANCESTRO COM COM UN Prog. III

58

Cap´ıtulo 4 ´ Arboles AVL

59

Prog. Prog. III

4.1. PERROS PERROS Y PERROS PERROS Y GATOS GATOS

4.1. 4.1.

Perro erross y Per Perro ross y Gat Gatos os

A partir de una lista de palabras, implemente en Java una funci´ on on que, de forma eficiente eficiente y usando un AVL, determine la cantidad de palabras diferentes en la secuencia. Ejemplo: si la secuencia es: [”Perro”, ”Gato”, ”Perro”, ”Perro”, ”Gato’], la función on deber´ a devolver 2 porque si bien hay 5 elementos, solo ”Perro” y ”Gato” son las dos palabras diferentes que aparecen.

4.1.1 4.1.1..


Hay que descartar las palabras repetidas y contar las diferentes. Eso se logra recorriendo la lista de entrada; por cada palabra agregarla al arbol a´rbol solo si no se encuentra, contando contando la cantidad de palabras agregadas o devolviendo devolviendo el tama˜ no no final del arbol. a´rbol.

4.1.2 4.1.2..


1 i n t c o n t a r ( L i s t a G e n e r i c a L ) 2 Arbo lAVL A = new ArbolAVL g >(( ) ; new ArbolAVL< 3 int c a n t i d a d = 0 ; 4 5 L . c o m e n z ar ar ( ) ; 6 while ( ! L . f i n ( ) ) 7 i f ( !A. in cl uy e (L. elemento () ) 8 A. i n s er t a r (L . elemen to ( ) ) ; 9 c a n t i d a d ++; 10 11 L . proximo ( ) ; 12 13 14 return c a n t i d a d ; 15

{

{

{

}

}

}

60

´ CAP ´ ITULO 4. ARBOLES AVL

4.2.

Prog. Prog. III

Pepe y Alicia

Pepe y Alicia quieren saber cu´ ales son sus intereses en com´ ales un. un. Para ello, cada uno arm´ o una lista de intereses, pero llegaron a tener miles cada uno. Implemente en Java un programa que dadas dos listas de String devuelva de forma eficiente forma eficiente una una lista con los intereses en com´ un, sin elementos repetiun, dos. Los intereses de cada uno pueden estar repetidos, pero el resultado debe tener uno solo de cada tipo. No hace falta implementar las estructuras. [A,B,C,A,B]] y a Alicia [A,D,A [A,D,A]. ]. Sus intereEjemplo: A Pepe le gusta [A,B,C,A,B ses en com´ un un son: [A [A]. L i s t a G e n e r i c a< a interesesComun ( List aGen eric a < S t r i n g > P , L i s t aG a G e n er e r i c a< a A) .. .

{

4.2.1 4.2.1..

}


Es una intersección on entre dos conjuntos, devolviendo los elementos que pertenecen a ambas listas. Hace falta tener en cuenta que el enunciado pide que sea de forma eficiente forma eficiente . Es por ello que hace falta utilizar alguna estructura que permita mejorar el tiempo de ejecuci´ on. on. Una primer solución on puede ser recorrer la primer lista, y por cada elemento recorrer la segunda lista verificando si se encuentra en esta. Por ejemplo: L i s t a G e n e r i c a< a interesesEn inter esesEnComun( Comun( List aGen eric a < S t r i n g > P , L i s t aG a G e n er e r i c a< a A) / S ol o l uc u c io i o n i n e f i c i e n t e / L i s t a G e n e r i c a< a r e s u l t a d o = new new L i s t a G e n e r i c a < S t r i n g > g > ( ) ; o m en e n z ar ar ( ) ; ! P . f i n ( ) ; P . s i g u i e n t e ( ) ) f o r ( P . c om Str ing E = P. elemento () ; (A. in cl uy e (E) && ! re su lt ad o . in cl uy e (E) (E ) ) i f (A. re su lt ad o . agr ega r (P. elemento () ) ;

{

{

}

return r e s u l t a d o ;

} Sin embargo, esta solución on no es eficiente ya que por cada elemento de la primer lista se recorre la segunda lista, dando un orden de ejecuci´ on O(n2 ), ya que la función on incluye() de la clase ListaGenerica debe recorrer toda la estructura preguntando por cada elemento. Para mejorar el tiempo de ejecuci´ on, una mejor soluci´ on on puede ser utilizar utilizar una estructura de datos intermedia, por ejemplo un arbol a´rbol AVL. 61

Prog. Prog. III

4.2. 4.2. PEPE PEPE Y ALIC ALICIA IA

Hace falta utilizar dos árboles arboles AVL. El primer árbol arbol contendr´ a los elementos de la primer lista, permitiendo conocer de forma eficiente eficiente qu´ e elemento elemento se encuentran encuentran en ésta esta lista. Primero, hace falta guardar los elementos de la primer lista en el primer arbol a´rbol AVL sin repetición. on. Luego, recorriendo la segunda lista se pregunta si cada elemento de esta se encuentra en el primer arbol pero no en el segundo. En caso de que se cumpla la condici´ on, on, se inserta en el segundo arbol a´rbol AVL y además as en una lista temporal. La lista temporal contendr´ a los elementos que se encuentran en ambas listas iniciales, sin repetición, o n, y será construida en tiempo O(n log n), con n siendo la suma de la cantidad de elementos de ambas listas iniciales. El segundo arbol a´rbol contendr´ a los elementos elementos que se encuentran encuentran en la lista temporal, permitiendo una b´ usqueda eficiente para verificar si ya fueron agregados a la usqueda lista resultante.

4.2.2 4.2.2..


1 class I n t e r e s e s 2 L i s t a G e n e r i c a interesesComun ( List aGen eric a < S t r i n g > P , L i s ta t a G e n er e r i c a< a A) 3 L i s t a G e n e r i c a r e s u l t a d o = new new L i s t a E n l a z a d a G e n e r i c a g >(( ) ; 4 Ar bolAVL lasDePepe = new ArbolAVL g >(( ) new ArbolAVL< ; 5 Ar bolAVL enComun = new ArbolAVL g > ( ) ; new ArbolAVL< 6 7 P . comenzar ( ) ; 8 while ( ! P . f i n ( ) ) 9 i f ( ! lasDePepe . in cl uy e (P. eleme nto () ) ) 10 l a s D e P e p e . a gr g r eg e g ar a r ( P . e le l e me me n t o ( ) ) ; 11 12 P. sig uien te () ; 13 14 15 A. comenzar ( ) ; 16 while ( ! A . f i n ( ) ) 17 (A. eleme nto () ) && ! enComun . i f ( lasDePepe . in cl uy e (A. in cl uy e (A. (A. eleme nto () ) ) 18 enComun . a gr g r e ga g a r ( A . e le l e me m e nt nt o ( ) ) ; 19 r e s u l t a do d o . a gr g r eg e g ar a r (A . e l e m e n t o ( ) ) ; 20

{

{

{

{

}

}

{

{

}

62

´ CAP ´ ITULO 4. ARBOLES AVL

21 22 23 24 25 26

Prog. Prog. III

A. s i g u i e n t e ( ) ;

} return r e s u l t a d o ;

}

}

63

Prog. Prog. III

4.2. 4.2. PEPE PEPE Y ALIC ALICIA IA

64

Cap´ıtulo 5 Grafos

65

Prog. Prog. III

5.1. RECORRI RECORRIDOS DOS SOBRE SOBRE GRAFOS GRAFOS

5.1. 5.1.

Reco Recorr rrid idos os so sobr bre e graf grafos os

Existen dos tipos de recorridos sobre grafos: recorrido en profundidad (DFS), y recorrido en amplitud (BFS). El recorrido tipo DFS se ejecuta de forma recursiva sobre cada nodo del grafo haciendo una b´ usqueda exhaustiva por cada posible camino que se usqueda puede tomar entre un nodo inicial y el resto de los nodos del grafo. La forma general de un recorrido DFS es: 1 void DF DFS( Ve rt ic e V, i n t pes o ) 2 v i s i t a d o s [ V . p o s i c io i o n ( ) ] = true ; 3 4 L i s t a G e n e r i c a ADY = V . o b t e ne n e r A d ya y a c e n te te s ( ) ; 5 (ADY. com enz ar ( ) ; !AD !ADY. f i n ( ) ; ADY. pro ximo () ) f o r (AD 6 A r i st s t a E = ADY . e le l e me m e nt nt o ( ) ; 7 i f ( ! v i s i t a d o s [ E . v e r t i c e D e s t i n o ( ) . p o s i c i o n ( ) ] ) 8 DFS ( E . v e r t ic i c e D e s ti t i n o ( ) , p es e s o + E . p es es o ( ) ) ; 9 10 11 v i s i t a d o s [ V . p o s i c io i o n ( ) ] = f a l s e ; 12

{

{

}

}

Es importante tener en cuenta que para poder hacer la b´ usqueda de forma exhaustiva, por cada adyacente de cada nodo hace falta iniciar de forma recursiva el recorrido. De esta forma, se eval´ uan todas las posibles combiuan naciones de nodos y aristas posibles del grafo, partiendo desde un v´ ertice ertice inicial. Tambi´ ambién en es importante importante marcar los nodos como visitados visitados al iniciar iniciar la recursión, o n, preguntar si el nodo no se encuentra actualmente visitado en el recorrido de adyacentes, y por ultimo u ´ ltimo desmarcar el visitado al terminar la recursión. on. A diferencia del DFS , en un recorrido BFS no se eval´ uan uan todas las posibles combinaciones de caminos. En un DFS, cada vértice ertice puede ser visitado m´ as as de una vez, mientras que en un BFS cada vértice ertice puede ser visitado a lo sumo una unica u ´ nica vez. Por un lado, esto permite que en general los recorridos BFS sean más as eficientes que un recorrido DFS . Por otro lado, no siempre es posible resolver cualquier cualquier recorrido con un BFS, no dejando otra opci´ on on que hacerlo aplicando aplicando un recorrido DFS. La forma general de un recorrido BFS es: 1 void BF BFS( Ve rt ic e V)

{ 66

CAP ´ ITULO ITULO 5. 5. GRAFO GRAFOS S

2

Prog. Prog. III

C o l a G e n e r ic i c a C = new ColaGenerica e >(( ) new ColaGenerica< ; C . p o ne n e r (V (V) ;

3 4 5 while ( !C. esVacia () ) 6 V e rt r t ic i c e W = C . s a ca ca r ( ) ; 7 L i s t a G e n er e r i c a AD ADY = W. o b te t e n er e r A dy d y a ce c e n te te s ( ) ; 8 !ADY. f i n () ; ADY. pro ximo ( ) ) f o r (ADY. com enz ar ( ) ; !AD 9 A ri r i st s t a E = ADY . e l e m e n t o ( ) ; 10 [E . v e r t i c e D e s t i n o ( ) . p o s i c i o n ( ) ] ) i f ( ! v i s i t a d o s [E 11 v i s i t a d o s [ E . v er e r t i ce c e De D e s t i n o ( ) . p os o s ic i c io i o n ( ) ] = true ; 12 C . p o n e r (E ( E . v er e r ti t i ce c e De D e st s t in in o ( ) ) ; 13 14 15 16

{

{

{

}

}

}

}

Para calcular el camino m´ m´ınimo en un grafo no pesado es posible utilizar un recorrido BFS, modificando el anterior ejemplo general de forma que además as de marcar como c omo true el adyacente en visitado, también en actualizar act ualizar la distancia. Hacer un recorrido BFS en un grafo no pesado garantiza que al finalizar el recorrido la tabla de distancias tendr´ a el camino m´ınimo siempre. siemp re. Tambi´ en en es posible realizar un recorrido DFS para hacer el c´ alculo alculo del camino m´ m´ınimo en un grafo no pesado, teniendo en cuenta cuenta la desventaja desventaja de que el tiempo de ejecuci´ on on será mayor con respecto a un recorrido BFS. Sin embargo, en un grafo pesado, ya sea con aristas positivas o negativas, en general no es posible calcular el camino m´ m´ınimo mediante el algoritmo algoritmo general de BFS. En un grafo pesado con aristas todas no negativas, hace falta utilizar el Algoritmo de Camino M´ınimo de Dijkstra, reemplazando la ColaGenerica por una cola de prioridad, prioridad, y teniendo el peso del vértice ertice calculado hasta el momento como valor de prioridad del nodo. Utilizar una Heap como estructura de cola de prioridad permite implementar el algoritmo de Dijkstra de la forma más as eficiente, O(n log n). De otro modo, si el grafo es pesado con aristas negativas, es necesario utilizar un recorrido DFS que verifique exhaustivamente todas las posibles combinaciones de caminos del grafo. Por ejemplo, para calcular c alcular el camino m´ınimo ınimo en un grafo pesado mediante un DFS: 1 void DF DFS( Ve rt ic e V, i n t pes o ) 67

{

Prog. Prog. III

5.1. RECORRI RECORRIDOS DOS SOBRE SOBRE GRAFOS GRAFOS

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

v i s i t a d o s [ V . p o s i c io i o n ( ) ] = true ; [ V . p o s i c i o n ( ) ] > pes o ) i f ( d i s t a n c i a s [V d i s t a n c i a s [ V . p o s ic i c i o n ( ) ] = pe pe s o ;

{

} L i s t a G e n e r i c a ADY = V . o b t e ne n e r A d ya y a c e n te te s ( ) ; (ADY. com enz ar ( ) ; !AD !ADY. f i n ( ) ; ADY. pro ximo () ) f o r (AD A r i st s t a E = ADY . e le l e me m e nt nt o ( ) ; i f ( ! v i s i t a d o s [ E . v e r t i c e D e s t i n o ( ) . p o s i c i o n ( ) ] ) DFS ( E . v e r t ic i c e D e s ti t i n o ( ) , p es e s o + E . p es es o ( ) ) ;

} v i s i t a d o s [ V . p o s i c io i o n ( ) ] = f a l s e ;

}

68

{


5.2.

Prog. Prog. III

El numero u ´ mero Bacon

Kevin Norwood Norwood Bacon (n. el 8 de julio de 1958) es un actor de cine y teatro estadounidense notable por sus papeles en National Lampoon’s Animal House, Diner, The Woodsman, Friday the 13th, Hollow Man, Tremors y Frost/Nixon. Bacon ha ganado un Premios Globo de Oro y Premios del Sindicato de Actores, estuvo nominado para un Premio Emmy, y fue nombrado por The Guardian, como uno de los mejores actores 1 ´ que no ha recibido una nominaci´ on on al Premio Oscar. Hace algunos a˜ nos en una entrevista, Kevin Bacon coment´ nos o que él hab´ıa actuado actuado con la mayo mayorr´ıa de los actores actores de Hollyw Hollywod, od, ya sea en la misma misma pel´ pel´ıcula o indirectamente con otro actor. Ah´ı naci na ció´ el ”N´ umero de Bacon”, con la idea de establecer cual era la umero distancia entre Bacon y el resto de los actores de Hollywood2 . Los actores que hab hab´´ıan actuado en alguna pel´ pel´ıcula junto a Bacon tienen el n´ umero 1, los que actuaron ac tuaron en alguna pel´ pel´ıcula junto a alguien que actu´ actuo´ con Bacon tienen el n´ umero umero 2, y as´ as´ı sucesivamente. suces ivamente. Por ejemplo, el actor Sean Penn tiene como N´ umero u mero de Bacon el 1 ya que actuaron actu aron juntos en la pel´ıcula ıcula R´ıo M´ıstico, ıstico , mientras mientra s que Sean Connery Conne ry tiene como N´ u mero de Bacon el 2, ya que si bien no actuaron juntos en umero ninguna pel p el´´ıcula, ambos actuaron junto al actor John Lithgow en al menos pel´ pel´ıcula (Sean Connery actu´ o en ”A Good Man in Africa”, y Kevin Bacon en ”Footloose”. John Lithgow actu´ o en ambas pel´ıculas.) ıculas .) 1 2

http://es.wikipedia.org/wiki/Kevin_Bacon vin_Bacon Imagen y texto de Wikipedia, http://es.wikipedia.org/wiki/Ke www.sixdegrees.org Bacon tom´ o esta idea y fundó una organización on de caridad, www.sixdegrees.org

69

´ 5.2. 5.2. EL N UMERO BACON

5.2. 5.2.1. 1.

Prog. Prog. III

Calc Calcul ular ar el N´ umero umero de Bacon

The Oracle Of Bacon3 es una p´ a gina web que permite ver cu´ agina al a l es la relación on entre dos actores actor es a partir de las pel p el´´ıculas que ambos actuaron. actua ron. ¿C´ omo omo funciona?

5.2.2 5.2.2..


Dado el nombre de un actor, indicar cual es su N´ umero umero de Bacon. Eso es, cuál al es la m´ınima distancia que se puede establecer entre Kevin Bacon y el segundo actor, relacionados r elacionados por p or las pel´ pel´ıculas en las que actuaron. El problema se puede modelar como un grafo, teniendo a cada actor de Hollywood como c omo un nodo del grafo, y cada pel´ pel´ıcula en la que actuaron ac tuaron juntos como una arista del grafo. Entonces el N´ umero de Bacon se puede calcular con un recorrido sobre umero el grafo, calculando la m´ınima distancia entre los dos actores. Eso se logra facilmente facilmente con un algoritmo algoritmo de camino m´ m´ınimo en un grafo no pesado, ya sea BFS o DFS.

5.2.3 5.2.3..

Impl Implem emen enta taci ci´ on ´ on Java - BFS

1 c l a s s BFS 2 / B u s c a r e l v e r t i c e d e l a ct c t or o r / 3 private V e r t i c e buscarAc tor ( Grafo Grafo< G, String actor ) 4 L i s t a G e n e r i c a > v e r t i c e s = G . lista DeVe rtic es () ; 5 v e r t i c e s . comenzar ( ) ; 6 while ( ! v e r t i c e s . f i n ( ) ) 7 V e r t i c e v = v e r t i c e s . e l em e m e n to to ( ) . vertic eDesti no () ; 8 i f (v . dato () . eq ua ls ( ac to r ) ) 9 return v ; 10 v e r t i c e s . proximo ( ) ; 11 12 retu return rn null ; 13 14 15 / Ca mino m i nim nim o en un gra fo n o pesado con co n BF BFS /

{

{

{

}

}

3

http://oracleofbacon.org

70


16 17

numeroDeBacon(Grafo G , S t r i n g a c t o r ) i n t numeroDeBacon(Grafo<

40 41 42 43 44 45 46 47 48 49 50 51 52

{

V e r t i c e i n i c i a l = b u s c a r A c t o r ( G , ” K ev e v in in Bacon” Bacon” ) ; V e r t i c e d e s t i n o = b u s c ar a r A c t or o r ( G, a c t o r ) ;

18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

Prog. Prog. III

m a n io io ( ) ; i n t N = G . l i s t a D e V e r t i c e s ( ) . t a ma C o l a G e n e r i c a > c = new ColaGenerica < new ColaGenerica< V e r t i c e > g >>() () ; boolean v i s i t a d o s [ ] = ne new boolean [N ] ; i n t d i s t a n c i a s [ ] = ne new in t [N ] ;

f o r ( i n t i = 0 ; i < N; ++i ) v i s i t a d o s [ i ] = f a l s e ;

{

d i s t a n c i a s [ i ] = I n t eg e g e r . MAX VA VALUE ;

} d i s t a n c i a s [ i n i c i a l . p o s i c io io n ( ) ] = 0 ; c o l a . p o ne ne r ( i n i c i a l ) ; while ( ! co la . esVacia () )

{

V e r t i c e v = c o l a . s a c a r ( ) ; == d e s t i n o ) / A c to to r e n c o n t r a d o i f ( v == return d i s t a n c i a s [ v . p o s i c i o n ( ) ] ;

/

L i s t a G e n e r i c a > a d y a c e n t e s = v . obtener Adyacente s () ; a d ya y a ce c e nt nt e s . c o m e n z a r ( ) ; while ( ! adyac ente s . f in () ) V e r t i c e w = adyac ente s . elemento () . vertic eDestin o () ; u e va v a Di D i st st = d i s t a n c i a s [ v . p o s i c i o n ( ) ] + 1 ; i n t n ue

{

i f ( ! v i s i t a d o [ w . p o s i c i o n ( ) ] ) v i s i t a d o [ w . p o s i c i o n ( ) ] = true ;

{

d is i s t a nc n c ia i a s [ w . p o s i c io io n ( ) ] = nue va Dist ; c o l a . p o n e r (w) ;

}

a d y a c e n t e s . pr oximo ( ) ;

}

} 71

´ 5.2. 5.2. EL N UMERO BACON

53 54 55 56 57

Prog. Prog. III

/

E l a c to t o r n o e s t a r e l a ci c i o n a do d o p or o r n i ng n g un un a p e l i c u l a c o n K e vi vi n B a c o n / return Integer .MAXVALUE;

}

}

5.2.4 5.2.4..

Impl Implem emen enta taci ci´ ´ on on Java - DFS

1 c l a s s DFS DFS 2 private bool boolea ean n vi si ta do s [ ] ; 3 p r iv iv a te te i n t d i s t a n c i a s [ ] ; 4 5 / B u s c a r e l v e r t i c e d e l a ct c t or o r / 6 private V e r t i c e buscarAc tor ( Grafo Grafo< G, String actor ) 7 L i s t a G e n e r i c a > v e r t i c e s = G . lista DeVe rtic es () ; 8 v e r t i c e s . comenzar ( ) ; 9 while ( ! v e r t i c e s . f i n ( ) ) 10 V e r t i c e v = v e r t i c e s . e l em e m e n to to ( ) . vertic eDesti no () ; 11 i f (v . dato () . eq ua ls ( ac to r ) ) 12 return v ; 13 v e r t i c e s . proximo ( ) ; 14 15 retu return rn null ; 16 17 18 / Ca mino m i nim nim o en un gra fo n o pesado con co n DF DFS / 19 numeroDeBacon(Grafo G , S t r i n g p u bl bl ic i c i n t numeroDeBacon(Grafo< act or ) 20 V e r t i c e i n i c i a l = b u s c a r A c t o r ( G , ” K ev e v in in Bacon” Bacon” ) ; 21 V e r t i c e d e s t i n o = b u s c ar a r A c t or o r ( G, a c t o r ) ; 22 23 ma n io io ( ) ; i n t N = G . l i s t a D e V e r t i c e s ( ) . t a ma 24 C o l a G e n e r i c a > c = new ColaGenerica < new ColaGenerica< V e r t i c e > g >>() () ; 25 v i s i t a d o s [ ] = ne new boolean [N ] ; 26 d i s t a n c i a s [ ] = ne new int [N ] ;

{

{

{

}

}

{

72


27 28 29 30 31 32 33 34 35 36 37 38


{


} nu me ro De Bac o nDFS ( i n i c i o , 0 ) ; return d i s t a n c i a s [ d e s t i n o . p o s i c i o n ( ) ] ;

} private private vo void id numeroDeBaconDFS( Vertice v , i n t

pes o ) v i s i t a d o s [ v . p os o s ic i c io i o n ( ) ] = true ;

{

39 40 41 42 43 44 45

i f ( pes o < d i s t a n c i a s [ v . p o s i c i o n ( ) ] )

d is i s t a n c i a s [ v . p os o s ic i c io io n ( ) ] = p e so ;

{

}

46 47 48 49 50 51 52 53 54 55 56 57 58

Prog. Prog. III

L i s t a G e n e r i c a > a d y a c e n t e s = v . obtener Adyacentes () ; a d ya y a c en e n t es e s . c om om e n z a r ( ) ; while ( ! a d y a c e n t e s . f i n ( ) ) V e r t i c e w = adyac ente s . elemento () . vertic eDesti no () ;

{

i f ( ! v i s i t a d o [ w . p o s i c i o n ( ) ] )

n um er o DeBa c on DFS (w (w . v e r t i c e D e s t i n o ( ) , p pee so so + 1 ) ; a d ya y a ce c e nt nt e s . p r o xi mo ( ) ;

} v i s i t a d o s [ v . p os o s ic i c io i o n ( ) ] = f a l s e ;

}

}

73

Prog. Prog. III

5.3. JUAN CARLOS VER VERTICIO TICIO

5.3. 5.3.

Juan Juan Carl Carlos os Verti ertici cio o

Juan Carlos Verticio es un artista que vive en la ciudad de Grafonia, y entre sus pasiones personales est´ a la de hacer dibujos de grafos4 , y recorrer la ciudad en bicicleta. Verticio desea entrenar para la final de ciclistas 2012, patrocinada por la Divisi´ on de Finanzas y Seguridad (DFS). on Entre sus planes de entrenamiento, Verticio desea armar una serie de recorridos por la ciudad. A fin de optimizar su tiempo en sus ratos libres en la semana, él el quiere poder salir y hacer un recorrido entre dos esquinas esquinas de la ciudad. Para ello necesita conocer cu´ ales ales caminos tienen exactamente tienen exactamente una una determinada longitud entre dos esquinas. El camino no puede terminar a mitad de cuadra. Por ejemplo, todos los caminos de la ciudad que entre dos esquinas miden 21 km. A partir de un grafo dirigido5 que representa la ciudad de Grafonia, realizar una función on en Java que le permita a Verticio obtener una lista de todos los caminos caminos de la ciudad ciudad con una longitu longitud d espec´ espec´ıfica. ıfica. Las aristas aristas del grafo tienen todas valores positivos, siendo la distancia de las diferentes calles de la ciudad, medidas en Km como n´ umeros umeros enteros. Los vértices ertices del grafo contienen un String que representa la esquina de la ciudad.

5.3.1 5.3.1..


Hace falta recorrer el grafo de forma de obtener todos los caminos posibles con una determinada longitud. La forma más as directa de resolverlo es un con un DFS, probando todas las posibles combinaciones de aristas del grafo. 4 5

La imagen es una de sus más recientes obras. Verticio no puede ir por las calles en contramano.

74


Prog. Prog. III

Para ello, por cada nodo del grafo hace falta iniciar un DFS, llevando la lista de esquinas de la ciudad y el costo actual acumulado.

5.3.2 5.3.2..


1 c l a s s DFS DFS 2 boolean v i s i t a d o s [ ] ; 3 int d i s t a n c i a s [ ] ; 4 5 public L i s t a G e n e r i c a > buscarCaminosDeCosto(Grafo< buscarCaminosDeCosto(Grafo G, i n t c o s t o ) 6 m a n io io ( ) ; i n t N = G . l i s t a D e V e r t i c e s ( ) . t a ma 7 v i s i t a d o s [ ] = ne new boolean [N ] ; 8 d i s t a n c i a s [ ] = ne new int [N ] ; 9 L i s t a G e n e r i c a > r e s u l t a d o = a > g >>() () ; new new L i s t a G e n e r i c a caminoActual = new new L i s t a G e n e r i c a< a g > ( ) ; 18 V e r t i c e v = G . l i s t a D e V e r t i c e s ( ) . e l e m e n t o ( i) ; 19 b u s c a r C a m i n o s D e C o s t o D F S ( v , r e s ul u l t a do do , c a mi m i n oA o A ct c t u al al , c o s t o , 0 ) ; 20 21 22 return r e s u l t a d o ; 23 24 25 buscarCaminosD nosDeCost eCostoDFS( oDFS( Ve rt ic e private private vo void id buscarCami v , L i s t a G e n e r i c a< a > r e s u l t a d o , L i s t a G e n e r i c a< a caminoActual , i n t c o s t o , int costo Actual ) 26 v i s i t a d o s [ v . p os o s ic i c io i o n ( ) ] = true ; 27 c a mi m i no n o Ac A c t ua u a l . a g r e g a r ( v . d a to t o ( ) , c a mi m i no n o Ac A c t ua u a l . t am a m an a n io io

{

{

{

}

{

}

}

{

75

Prog. Prog. III

5.3. JUAN CARLOS VER VERTICIO TICIO

() ) ; 28 29 30 31

i f ( c o s t o == c o s t o A c t u a l )

32 33 34

{

}

r e su s u l ta t a d o . a gr g r eg e g ar a r ( n ue u e va v a Li L i s ta ta ) ;

}

41 42 43 44 45 46 47

48 49 50 51 52 53 54 55 56

/ C r e a r un u n a c o ppii a d e l a l i s t a / L i s t a G e n e r i c a n u e v a L i s t a = new new L i s t a G e n e r i c a< a g > ( ) ; c a mi mi n o Ac Ac tu tu a l . c o m e n z a r ( ) ; while ( ! caminoActual . fi n () ) n ue u e va v a Li L i st s t a . a g re r e g ar a r ( c am a m i n o A c t ua u a l . e le l e me m e nt nt o ( ) , nue vaL ist a . tamanio () ) ; c a m i n o A c t u a l . proximo ( ) ;

35 36 37 38 39 40

{

L i s t a G e n e r i c a > a d y a c e n t e s = v . obtener Adyacentes () ; a d ya y a c en e n t es e s . c om om e n z a r ( ) ; while ( ! adyac ente s . f in () ) A r i s t a a = a d y a c e n t e s . e l e m e n t o ( ) ; V e r t i c e w = a . v e r t i c e D e s t i n o ( ) ;

{

w. p o s i c i o n ( ) ] ) i f ( ! v i s i t a d o s [ w.

{

b u s c a r C a m i n o s D e C o s t o D F S (w ( w , r e su s u lt l t a do do , c a mi m i no n o A ct c t u al al , c o s t o , c o s t o A c t u a l + a . p e s o ( ) ) ;

} a d ya y a ce c e nt nt e s . p r o xi mo ( ) ;

} v i s i t a d o s [ v . p os o s ic i c io i o n ( ) ] = f a l s e ; c a mi m i no n o Ac A c t ua u a l . e l i m i n a r ( c a mi m i no n o Ac A c t ua u a l . t am a m an a n io io ( )

}

}

76

−

1) ;


5.4. 5.4.

Prog. Prog. III

Viru Viruss de Comp Comput utad ador ora a

Un poderoso e inteligente virus de computadora infecta cualquier computadora en 1 minuto, logrando infectar toda la red de una empresa con cientos de computadoras. Dado un grafo que representa las conexiones entre las computadoras de la empresa, y una computadora ya infectada, escriba un programa en Java que permita determinar el tiempo que demora el virus en infectar el resto de las computadoras. Asuma que todas las computadoras pueden ser infectadas, no todas las computadoras tienen conexi´ on on directa entre s´ı, y un mismo virus puede infectar un grupo de computadoras al mismo tiempo sin importar la cantidad. Por ejemplo, si la computadora A se conecta con la B, y la B solo con la C y D, el tiempo total desde la A será de dos minutos: la A ya est´ a infectada, infectada, un minuto para la B, y un minuto para la C y D (ambas C y D al mismo tiempo).

5.4. 5.4.1. 1.

Dibu Dibujo jo

5.4.2.

Caracter´ Caracter´ısticas del grafo grafo

Es un grafo no dirigido con aristas sin peso.

5.4.3 5.4.3..


El problema empieza con una primer computadora infectada, y hay que simular la infección on en el resto de la red. Cada vez que el virus ”salta”desde una computadora hacia la siguiente transcurre un minuto, por lo que si hace 77

Prog. Prog. III

5.4. VIRUS VIRUS DE COMPUT COMPUTADORA ADORA

cuatro saltos transcurren cuatro minutos. En este caso, el tiempo total de infección on de la red es de cuatro minutos. Hay que tener en cuenta que una misma computadora se puede infectar por diferentes caminos, y dado que el virus infecta varias computadoras al mismo tiempo, la infección on termina siendo por la que est´ a más as cerca. El problem problemaa se reduce reduce a un camino camino m´ınimo ınimo en un grafo grafo no pesado, pesado, y el tiempo total de infecci´ o n de la red es el mayor costo de los nodos. La on solución o n más as directa es un BFS, que representa la forma en la que el virus se distribuye por la red.

5.4.4 5.4.4..


1 c l a s s BFS 2 a f o G, G, V e r t i c e p u bl bl ic i c i n t c a l c u l a r T i e m p o I n f e c c i o n ( G r af inicial ) 3 ma n io io ( ) ; i n t N = G . l i s t a D e V e r t i c e s ( ) . t a ma 4 C o l a c = new new Cola ( ) ; 5 boolean v i s i t a d o s [ ] = ne new boolean [N ] ; 6 i n t d i s t a n c i a s [ ] = ne new int [N ] ; 7 i n t maxDist = 0; 8 9 f o r ( i n t i = 0 ; i < N; ++i ) 10 v i s i t a d o s [ i ] = f a l s e ; 11 d i s t a n c i a s [ i ] = I n t eg e g e r . MAX VA VALUE ; 12 13 14 d i s t a n c i a s [ i n i c i a l . p o s i c io io n ( ) ] = 0 ; 15 c o l a . p o ne ne r ( i n i c i a l ) ; 16 17 while ( ! co la . esVacia () ) 18 Vertice v = cola . sacar () ; 19 L i s t a G e n e r i c a a d y a c e n t e s ; 20 21 a dy d y a ce c e nt n t es e s = v . o bt b t en e n e rA r A d ya y a ce c e nt n t es es ( ) ; 22 a d ya y a ce c e nt nt e s . c o m e n z a r ( ) ; 23 while ( ! adyac ente s . fi n () ) 24 V e rt r t ic ic e w = a d y a c e n t e s . e l e m e n t o ( ) . vertic eDestin o () ; 25 u e va v a Di D i st st = d i s t a n c i a s [ v . p o s i c i o n ( ) ] + 1 ; i n t n ue 26

{

{

{

}

{

{

78


27 28 29 30 31 32 33 34 35 36 37 38 39 40

Prog. Prog. III

i f ( ! v i s i t a d o [ w . p o s i c i o n ( ) ] ) v i s i t a d o [ w . p o s i c i o n ( ) ] = true ;

{

d is i s t a nc n c ia i a s [ w . p o s i c io io n ( ) ] = nue va Dist ; i f ( nuevaD ist > maxDist) maxDist = n u e v a D i s t ; c o l a . p o n e r (w) ;

}


}

return maxDist ;

}

}

}

79

´ 5.5. CIRCUI CIRCUITOS TOS ELECTR ELECTR ONICOS

5.5. 5.5.

Prog. Prog. III

Circ Circui uito toss Elec Electr tr´ ´ onicos onicos

En un circuito electr´ onico digital la electricidad viaja a la velocidad de onico la luz. Sin embargo, las diferentes compuertas tienen un tiempo de demora entre que la se˜ nal llega por sus entradas y se genera el resultado. nal Si el circuito está mal dise˜ nado, cuando se conectan varias compuertas nado, entre s´ı ocurre o curre lo que se llama una condici´ on de carrera, donde las dos se˜ on nales nales que le llegan a una compuerta NAND lo hacen a diferente tiempo, y la salida de la compuerta tardar´ a en estabilizarse. Asuma que tiempo que demoran las señales nales en viajar por los cables es cero, y el tiempo que demoran las se˜ nales nales en atravezar una compuerta es el mismo para todas. Se tiene un grafo que representa el circuito electr´ onico, o nico, y una unica u ´ nica entrada que generan una se˜ nal. nal.

5.5. 5.5.1. 1.

Dibu Dibujo jo

El siguiente es un dibujo de un grafo que contenga una condicion de carrera.

5.5.2.

Caracter´ Caracter´ısticas del grafo grafo

Es un grafo dirigido no pesado. Hay tres tipos de nodos: el nodo entrada que genera las se˜ n ales, los nodos de salida que reciben las señales, nales, n ales, y los nodos de compuertas, que siempre tienen dos aristas de entrada y una arista de salida. 80


5.5.3 5.5.3..

Prog. Prog. III


Hay una carrera cuando una se˜ nal le llega a una compuerta m´ nal as as rápido apido por una de las entradas que por las otras. Por ejemplo, en el dibujo anterior anterior est´ an las compuertas 1 y 2, una entrada an por donde se disparan las se˜ nales, y una salida, por donde queda el resultado nales, de las compuertas. Las se˜ nales que le llegan a la compuerta 1 son todas al nales mismo momento de tiempo, pero las se˜ nales que le llegan a la compuerta 2 nales lo hacen a diferente tiempo, porque una de las entradas es la salida de la compuerta 1. La idea del ejercicio es hacer el seguimiento de los diferentes caminos que pueden tomar la se˜ nal. No es necesario hacer una lista de todos, sino nal. encontrar el caso de la primer carrea. Una forma de ver la soluci´ on es simular el paso del tiempo en el circuito, on haciendo el mismo recorrido que las se˜ n ales a lo largo del tiempo. Eso se nales puede hacer de dos formas: BFS o DFS. En el caso del DFS, por cada nodo que se visita se va incrementando en 1 un contador a medida que se llama a la recursión, on, este valor se lo almacena en una tabla, y si cuando se vuelve a visitar un nodo por segunda vez el valor es diferente al primero, hay una carrera. En el BFS es similar, pero hace falta diferenciar correctamente los nodos visitados de los que no lo est´ an. Tambien, es necesario mantener una tabla; an. si el nodo no fue visitado actualizr el valor como el valor del padre + 1, y si el nodo ya fue visitado verificar que el valor es el mismo que el del padre + 1. Esto se hace dentro del while que recorre adyacentes. En ambos casos, el contador contador sirve sirve para ver en qu´ e instante instante de tiempo le están an llegando las se˜ nales a la compuerta. Si por un lado le llega un valor nales diferente al que le llega por el otro, quiere decir que le llegan a diferente tiempo y entonces hay una carrera.

5.5.4 5.5.4..


El siguiente programa Java determina si un circuito electr´ onico onico presenta presenta una codici´ on on de carrea. 1 c l a s s BFS 2 a y Ca C a r re r e ra r a ( G r af a f o G, V e r t i c e i n i c i a l ) public boolea boolean n h ay 3 m a n io io ( ) ; i n t N = G . l i s t a D e V e r t i c e s ( ) . t a ma 4 C o l a c = new new Cola ( ) ; 5 boolean v i s i t a d o s [ ] = ne new boolean [N ] ; 6 i n t d i s t a n c i a s [ ] = ne new in t [N ] ; 7

{

81

{


8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23


{


} d i s t a n c i a s [ i n i c i a l . p o s i c io io n ( ) ] = 0 ; c o l a . p o ne ne r ( i n i c i a l ) ; while ( ! co la . esVacia () )

{

Vertice v = cola . sacar () ; L i s t a G e n e r i c a a d y a c e n t e s ; a dy d y a ce c e nt n t es e s = v . o bt b t en e n e rA r A d ya y a ce c e nt n t es es ( ) ; a d ya y a ce c e nt nt e s . c o m e n z a r ( ) ; while ( ! adyac ente s . fi n () ) V e rt r t ic ic e w = a d y a c e n t e s . e l e m e n t o ( ) . vertic eDestin o () ; v a D i st s t a n ci ci a = d i s t a n c i a s [ v . p o s i c i o n ( ) ] + i n t n u e va 1;

{

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

Prog. Prog. III

w. p o s i c i o n ( ) ] ) i f ( ! v i s i t a d o s [ w. v i s i t a d o s [ w . p o s i c i o n ( ) ] = true ;

{

d i s t a n c i a s [ w . p os o s ic i c io io n ( ) ] = nue vaDist an cia ; c o l a . p o n e r (w) ;

} else {

i f ( d i s t a n c i a s [ w . p o s i c i o n ( ) ] ! =

nuevaDistancia ) return return true ; / Hay c a r r e r a

}


}

}

r e tu tu rn rn f a l s e ;

}

}

5.5.5 5.5.5..


1 c l a s s DFS DFS 2 boolean v i s i t a d o s [ ] ;

{

82

/


3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

int d i s t a n c i a s [ ] ;

Grafo G , V e r ti ti c e < public boolea boolean n hayCar rera ( Grafo< Integer > i n i c i a l ) m a n io io ( ) ; i n t N = G . l i s t a D e V e r t i c e s ( ) . t a ma v i s i t a d o s [ ] = ne new boolean [N ] ; d i s t a n c i a s [ ] = ne new int [N ] ;

{


}

35 36 37

ay Ca Ca rr r r er er aD aD FS FS ( i n i c i a l , 0 ) ; return h ay

} hayCarrera reraDFS( DFS( Ver tic e v , i n t private bool boolea ean n hayCar tiempo) v i s i t a d o s [ v . p os o s ic i c io i o n ( ) ] = true ;

{

.MAX VALUE) i f ( di st an ci a s [ v . po si ci on () ] != In te ge r .MA

{

22 23 24 25 26 27 28 29 30

34

{


19 20 21

31 32 33

Prog. Prog. III

i e mp mp o ) i f ( d i s t a n c i a s [ v . p o s i c i o n ( ) ] ! = t ie v i s i t a d o s [ v . p o s i c i o n ( ) ] = f a l s e ; return return true ;

{

}

} else { d i s t a n c i a s [ v . p os o s ic i c io io n ( ) ] }

= tiempo ;

L i s t a G e n e r i c a > a d y a c e n t e s = v . obtener Adyacentes () ; a d ya y a c en e n t es e s . c om om e n z a r ( ) ; while ( ! a d y a c e n t e s . f i n ( ) ) V e r t i c e w = adyac entes . elemento () . vertic eDesti no () ; hayCarre rrera raDF DFS S (w, i f ( ! vi si t ad o s [w. po si ci on () ] && hayCa tiempo tiemp o + 1) ) v i s i t a d o s [ v . p o s i c i o n ( ) ] = f a l s e ; return return true ;

{

} 83


38 39 40 41 42 43 44

a d ya y a ce c e nt nt e s . p r o xi mo ( ) ;

} v i s i t a d o s [ v . p os o s ic i c io i o n ( ) ] = f a l s e ; r e tu tu rn rn f a l s e ;

}

}

84

Prog. Prog. III


5.6. 5.6.

Prog. Prog. III

Viajan Viajante te de Encu Encues esta tass

La facultad de Ciencias Exactas tiene docentes dando clases en diferentes Facultades: Inform´ atica, ati ca, Qu´ Qu´ımica, ımic a, Astron Ast ronom´ om´ıa, ıa, Medici Med icina, na, etc. etc . Mar´ M ar´ıa ıa es concon tratada por Exactas para realizar encuestas a los alumnos de las diferentes comisiones de los diferentes cursos de todas todas las facultad facultades es, y quiere saber cu´ al a l es la ruta óptima optima que menos tiempo le lleve para visitar todos los cursos de los diferentes edificios. Dado un grafo con c on vértices ertices que representan los diferentes cursos de todas to das las facultades, facultade s, y con co n aristas representando cuánto anto cuesta llegar desde un curso a otro, haga un programa en Java Java que le ayude a Mar´ Mar´ıa definir d efinir en qué orden visitar los diferentes cursos para que le cueste lo menos posible. Asuma que el primer curso lo puede elegir sin costo, y los cursos se pueden visitar en cualquier momento. Ayuda: Implemente un recorrido sobre el grafo que pruebe las diferentes variantes ariantes de caminos. caminos.

5.6.1 5.6.1..


Este problema se conoce como Viajante de Comercio, Comercio, TSP en ingl´ inglés. es. Es 6 un problema NPH, una categor´ categor´ıa de problemas de la que no se conoce un algoritmo que funcione eficiente en grafos con cientos de miles (o m´ as) a s) de nodos. De todas formas, es muy fácil acil ver que se puede resolver con un DFS, iniciando un recorrido desde cada nodo del grafo y probando todas las posibles combinacione combinacioness de caminos. caminos. A medida que se va haciendo la recursión on se va creando el camino, y una vez cumplida la condici´ on de visitar todos los nodos se verifica si el camino on actual tiene el menor costo entre los ya procesados. Es importante tener en cuenta que el grafo debe ser conexo. De otra forma nunca se cumplir´ a la condición on de visitar todos los nodos del grafo.

5.6.2 5.6.2..


1 class ViajanteDeEncuestas 2 int N; 3 boolean [ ] v i s i t a d o s ; 4 L i s t a G e n e r i c a mejorCamino ;

{

6

Categorizar problemas como P, NP, NPC, NPH es un tema que se encuentra fuera del alcance de este curso.

85

Prog. Prog. III

5.6. VIAJANTE VIAJANTE DE ENCUEST ENCUESTAS AS

5 6 7 8 9 10 11 12 13 14 15

.MAX VALUE; i n t mejorCamin oCosto = I n t e g e r .MA L i s t a G e n e r i c a c a l c u l a r M e j o r V i a j e ( G r af a f o< o G) N = G. l i s t a D e V e r t i c e s ( ) . ta man io ( ) ; v i s i t a d o s = ne new boolean [N ] ;

{


i++) f o r ( i n t i = 0 ; i < N; i++

{

L i s t a G e n e r i c a caminoActual = new new L i s t a E n l a z a d a G e n e r i c a g > () ; c a l c u l a r C a m i n o M i n i m o D F S (G (G. l i s t a D e V e r t i c e s ( ) . elemento ( i ) , caminoAc cami noActual tual , 1 , 0) ;

16

17 18 return mejorCamino ; 19 20 21 void calcularCaminoMinim calcularCaminoMinimoDFS oDFS ( Ve rt ic e V, L i s t a G e n e r i c a< a caminoActual , i n t c a n t V i s i t , int costoAc tual ) 22 v i s i t a d o s [ V . p o s ic i c i o n ( ) ] = true ; 23 c a m in i n o Ac A c t u al a l . a g r e g a r ( V . d a t o ( ) , c a m in in o Ac A c t u al a l . t a ma ma n io io () ) ; 24 25 i f ( c a n t V i s i t == N && c o s t o A c t u a l < mejorCaminoCosto) 26 27 / C o p i a r l a l i s t a / 28 L i s t a G e n e r i c a n u e v a L i s t a = new new L i s t a E n l a z a d a G e n e r i c a g > () ; 29 c a mi mi n o Ac Ac tu tu a l . c o m e n z a r ( ) ; 30 while ( ! caminoActual . fi n () ) 31 n ue u e va v a Li L i st s t a . a gr g r eg e g ar a r ( n ue u e va v a L i s t a , n ue u e va v a Li L i s ta ta . tama nio () ) ; 32 c a m i n o A c t u a l . proximo ( ) ; 33 34 / A c t u a l i z a r e l c a mi mi no no m in in i m o / 35 m e j o r C a m i n o = n u e v a L is is t a ; 36 m e j o r C a m i n o C o s t o = c os o s to t o Ac A c tu t u al al ;

}

}

{

{

{

}

86


37 38 39 40 41

48 49 50 51 52 53 54 55 56

} else {

42 43 44 45 46 47

Prog. Prog. III

/ S e g u ir i r DF DFS en en l o s a d y a ce c e n te t e s / L i s t a G e n e r i c a a d y a c e n t e s = V . obtener Adyacente s () ; a d ya y a ce c e nt nt e s . c o m e n z a r ( ) ; while ( ! adyac ente s . f in () ) A r i s t a A = adyac entes . elemento () ; V e r t i c e W = A . v e r t i c e D e s t i n o ( ) ; i f ( ! v i s i t a d o s [W. p o s i c i o n ( ) ] ) c a l c u l a r C a m i n o M i n i m o D F S (W (W, c a n t V is i s it it + 1 , cos toA ctu al + A. peso () ) ;

{

{

}


}

}

c a mi m i no n o Ac A c t ua u a l . e l i m i n a r ( c a mi m i no n o Ac A c t ua u a l . t am a m an a n io io ( ) v i s i t a d o s [ V . p o s ic i c io i o n ( ) ] = f a l s e ;

}

}

87

−

1) ;

Algoritmos y Estructuras de Datos UNLP

Recommend Documents