Tarea n1 Anlisis de Algoritmos

Gonzalo Maurelia
Maximiliano Opitz
Abril 13, 2013.

1. Qu realiza la siguiente funcion? Exprese su respuesta como una funcion de n y entregue el peor caso
para el costo en tiempo usando notacion O.
Function Misterio(n)
1 r <- 0
2 for i = 1 to n do
3

for j = i to i do

for k = j to i + j do

r <- r + 1

6
7

endfor
endfor

8 endfor
9 return r

Podemos ver que los tres ciclos no son independientes, ya que todos dependen exclusivamente de la
variable i. Es por ello que el anlisis de este algoritmo tenemos que considerarlo de manera global.
De esta forma, si analizamos la cantidad de veces que se ejecuta el tercer ciclo, correspondera a la
siguiente sumatoria:
( )

*Consideramos i como variable en la sumatoria dado que k depende de j y sta a su vez, de i.

Como podemos observar en la sumatoria, el resultado es de orden cuadrtico. Esto quiere decir que la
complejidad y peor caso para este algoritmo es O(n).
No obstante, con respecto a la funcin del algoritmo, tiene mucho que ver con la complejidad del
mismo. Si vemos la variable r que entrega el algoritmo cuando finaliza, podemos darnos cuenta que el
valor es el mismo que la complejidad. Por lo tanto, el objetivo que tiene este algoritmo es calcular su
propia complejidad.

2. Elabore y analice un algoritmo recursivo que encuentra la moneda falsa entre n monedas cuyos pesos
son almacenados en un arreglo con n = 2k. La moneda falsa es la de menor valor. Se pide un algoritmo
que realice el menor nmero de comparaciones posible.

Function Menor(A, inf, sup)

begin
If sup=inf then
return min(A[inf-1],A[sup-1])
else
min(Menor(A,inf,(inf+sup)/2), Menor(A,((inf+sup)/2)+1,sup))
end

A: Arreglo que contiene n monedas con valores aleatorios

Inf: ndice que muestra la primera posicin del arreglo A.
Sup: ndice final que indica la ltima posicin del arreglo A.
min: es una funcin que me devuelve el mnimo valor entre dos enteros.
Lo que realiza el algoritmo es primero preguntar si el ndice superior es igual al inferior. Esto nos
indicar la detencin final de una subdivisin, y en el ltimo caso, la detencin completa del algoritmo.
Por otro lado, la condicin de que si lo mencionado anteriormente no sucede, es buscar el mnimo de
los valores entre las subdivisiones del arreglo.
Este algoritmo es similar al merge-sort, con respecto a la descomposicin del arreglo, pero la diferencia
est en que no ordena los valores, si no que realiza comparaciones que siempre devuelven el menor
valor. Se puede demostrar esto a travs de la esquematizacin de un rbol binario:

Figura 1.
En la figura 1, al descomponer el arreglo (top-down) hasta la mnima subdivisin, el algoritmo comienza
a recorrer de vuelta el rbol (bottom-up) de modo tal que compara cada hoja y siempre escoge el menor
valor. Por ejemplo, entre la hoja 1 y 8 escoge el 1, luego compara 1 y 4, vuelve a escoger el 1, finalmente
cuando en la raz se renen los dos mnimos valores de las dos ramas, se vuelve a comparar y ese es el
mnimo valor del arreglo de monedas.
Por otro lado, con respecto a la complejidad de este algoritmo, utilizamos el mtodo del rbol recursivo
para obtenerla. Como vemos en la Figura 1, en cada iteracin, el nodo se divide en 2 ramas y cada
problema se va reduciendo a la mitad, es decir n/2, debido a que siempre dividimos el arreglo en dos. Es
por ello que la ecuacin del sistema recurrente nos queda:
T(1)=1
T(n)= 2*T(n/2)+O(1) [0]

Con esta ecuacin podemos demostrar, a travs del teorema maestro, la complejidad de este algoritmo.
Segn la primera condicin del teorema maestro:
Si f (n) e O(n^logb (a)-) para alguna constante > 0, entonces T(n) e O(n ^logb(a)). [1]
Luego, dado que en nuestro caso f(n)=1, y la funcin T(n) anterior est definida sobre enteros no
negativos, se demostrar que la primera condicin del teorema se cumple.
Primero, veremos si la funcin f(n) tiene una cota superior, es por ello que formamos la siguiente
inecuacin:
n^(log2(2)-) 1
es lo mismo que:
n^(1-) 1

Escogiendo un >0, en este caso particular, =1, tenemos que:

n^0 1
11
Como el resultado de la divisin entre esta funcin n y f(n) es polinomial, es aplicable el teorema
maestro, y por ende corresponde al primer caso.
Finalmente, por la regla mostrada en [1], obtenemos que la complejidad de la recursividad [0] y por
ende, la del algoritmo es:
O(n^log2(2))
O(n).