You are on page 1of 9

Julio A.

Fuentealba Vivallo
___________________________________________________________________
Guía de ecuaciones de recurrencia
___________________________________________________________________

1.- El siguiente algoritmo ordena un conjunto de elementos. Calcule su eficiencia en


función de sus comparaciones

void CH(arreglo a, int izq, int der )


{
int i,j,v ;
if (der > izq )
{ v = a[der] ; i = izq-1 ; j = der ;
for (;;)
{
while (a[++i] <= v ) ;
while (a[--j] > v ) ;
if ( i >= j ) break ;
intercambia(a,i,j);
}
intercambia(a,i,der);
CH(a,izq,i-1);
CH(a,i+1,der);
}
}
solucion
este algoritmo es QuickSort

2.- El ordenamiento de selección cuadrática, divide los n elementos de un conjunto S en


k grupos donde
k = raíz(n), encuentra el elemento más grande de cada grupo y lo lleva a un arreglo A,
encuentre al mayor elemento del arreglo auxiliar y llévelo a la ultima casilla disponible de
un arreglo O, luego reemplace en A el elemento extraído por el mayor del grupo del cual
proviene, repita el proceso hasta que O contenga a S ordenado.

 ¿ cual es la eficiencia de este algoritmo ?


 ¿ que pasa con los datos repetidos ?

solucion
se contaran comparaciones entre elementos del conjunto
a- subdividir en raiz(n) elementos ------------------ costo 0
b- sacar el mayor de un grupo ------------------- raiz(n) – 1
c- sacar el mayor de todos los grupos ------------- raiz(n) *( raiz(n) – 1)
d- sacar el mayor de A y llevarlo a O ------------------- raiz(n) – 1

e- reemplazar el elemento extraido de A------------------- raiz(n) – 1


f- repetir los pasos c,d y e n veces------------------- n * (2*( raiz(n) – 1))
g- costo total se obtiene de sumar 3 y 6 ---- raiz(n) *( raiz(n) – 1) + n * (2*( raiz(n) – 1))

3.- Considere el algoritmo siguiente


 dado el Conjunto S, todos sus elementos son insertados en un ABB
 el ABB es recorrido en inorden, guardando la secuencia obtenida
 se retorna el conjunto ordenado.
solucion
insertar 1 dato en un ABB  de orden(log(n))
insertar n elementos en un ABB  de orden(n*log(n))
recorrer en inorden  de orden(n)

orden del algoritmo  de orden(n *log(n))

4.- Para el siguiente programa calcule el costo y el orden de la función “costo” .

#include <stdio.h>
int contador ;
int costo (int i )
{
int k, respuesta = 0 ; printf ( “ … %d “,contador ++ );
if ( i < 2 )
return 1 ;
else
for ( k = 1 ; k < i ; k++ )
respuesta = respuesta + costo ( i - k );
return respuesta ;
}
main ()
{ int j ;
for ( j = 0 ; j < 15 ; j++ )
{ contador =0 ;
costo (j);
getch(); printf(“\n-------------------------------\n”);
}
}

solucion
se contaran sumas de la expresión respuesta = respuesta + costo ( i - k );
como es un alg recursivo se usara una ecuación de recurrencia
0 si n < 1

T(n) =
1 +T(1) + T(2) + T(3) + … + T(n-k)

t(n) = 1 + sumatoria(t(i)) para i desde 1 hasta n-k, (1)


hacemos la expresión para n-1
t(n-1) = 1 + sumatoria(t(i)) para i desde 1 hasta n-1-k, (2)

restamos (1) menos (2) y nos da


t(n) – t(n-1) = 0 + t(n-1)
lo que da

t(n) – 2*t(n-1) = 0

como esta es una ecuación homogénea, lineal y de coeficientes constantes

se usara el método de la ecuación característica.

xn – 2xn-1= 0
ecuación característica es x – 2= 0 lo que resulta en x = 2
luego t(n) = cte * 2n

5.- Se desean colocar 8 reinas en un tablero de ajedrez de manera que ninguna en una sola
movida, pueda comerse a otra. La estrategia más común es que usted, ponga una reina en
un casillero (una reina en cada fila y en cada columna), verifique que no provoca conflicto
e intente la siguiente, si provoca conflicto entonces, cambia la posición actual, si luego de
intentar las 8 posibilidades no encuentra solución, supone que la reina anterior esta mal
puesta y retrocede, para reubicar en una nueva posición la reina anterior. Con esta lógica
debiera encontrar todas las soluciones.
¿Cual es el orden de esta solución al problema?

El orden es nn pues n filas implican n reinas, cada fila tiene n posibilidades de poner a su
reina, al devolverse recursivamente y reintentarlo se parte de nuevo desde la primera
casilla.

6.- calcule el costo y el orden del siguiente algoritmo.

RecorreABBInorden( arbol t)
{
if ( t <> NULL )
{
RecorreABBInorden( t->izq);
Printf(“%d”,t->dato);
RecorreABBInorden( t->der);
}
}

solucion
se contaran llamadas recursivas

0 si n = 0

T(n) =
2 * T(n/2 ) si suponemos que para cada lado tenemos la mitad de los datos

T(n) – 2*T(n/2) = 0
hacemos un cambio de variable n = 2i
T(n) -2*T(n/2) = t(2i ) – 2 * t(2i-1) = f(i) – 2*f(i-1)=0
luego resolvemos f(i) – 2*f(i-1)=0
xi – 2xi-1= 0 da como resultado f(i) = cte * 2i
como f(i) = t( 2i) = T(n) = cte * n

7.- Dado un arreglo A con números, creamos B inicialmente lleno con ceros, luego por
cada casilla i de B contamos el número de casillas de A, menores a la casilla A(i). Al
terminar en B se tiene el orden que debiera tener A.

A
73 23 43 51 15 16 30 29 46

B
8 2 5 7 0 1 4 3 6

Luego podemos ver que el 15 es el menor pues en su correspondiente casilla de B se tiene


un 0, le sigue el 16, pues le corresponde un 1 ….

¿Cuál es el costo de este ordenador? ( con toda precisión)

solucion
se contaran comparaciones entre elementos del conjunto
casa casilla requiere n-1 comparaciones, pues se tienen n datos y no se compara consigo
misma.
Esto se hace para las n casillas de A, lo que da n * (n-1) comparaciones.

8.- Cual es el costo y el orden del siguiente algoritmo eliminaABB


ABB *HijoMayor(ABB *t)
{
while ( t->der != NULL ) t = t->der;
return t;
}
ABB *eliminaABB( ABB *p , int i)
{
ABB *q;
if ( !vacia(p))
if ( p->dato == i) // el dato a eliminar esta en la raiz.
if ((p->izq == NULL ) && ( p->der == NULL))
{
delete p;
return NULL;
}
else
{
q = NULL ;
if (p->izq != NULL )
q = HijoMayor(p->izq);
if ( q == NULL ) // no existe rama izquierda
{
q=p;
p = p->der;
delete q;
return p;
}
else
{
p->dato = q->dato;
i = q->dato;
p->izq = eliminaABB(p->izq, i);
}
}
else // no esta en la raiz debo buscarlo
if ( i < p->dato ) p->izq = eliminaABB(p->izq,i);
else p->der = eliminaABB(p->der,i);
return p;
}

9.- Calcule el costo y el orden para la siguiente función


int davenport(int a)
{
int s=0;
if ( a < 2) return 5;

else
for ( int i = 0 ; i < a ; i++ )
s += davenport(a/2);

return s ;
}

solucion

10.- A veces se afirma que en la actualidad el Hardware es tan barato y la mano de obra es
tan cara que nunca merece la pena desperdiciar el tiempo de un programador para quitarle
unos pocos segundos a la ejecución de un programa. ¿Significa esto que el estudio de la
complejidad de un algoritmo está destinado a ser un estudio teórico de interés solamente
formal, sin aplicaciones prácticas? Justifique su respuesta.
solucion
no falta el huevon que cree que en esta asignatura solo esta perdiendo el tiempo.
Mas seriamente …
Las mejorías obtenidas por un algoritmo mas eficiente pueden ser enormes, y pueden llegar
a cambiar de orden, las mejorías obtenidas por un hardware nuevo nunca cambian al
problema de orden, pueden ser el doble mas rápido, el triple
Por ejemplo un algoritmo de orden(n) con un hardware mas rápido puede demorar n/2 … o
n/3, pero si un algoritmo mejor de orden log(n) superara ampliamente al hardware.

11.- Un algoritmo de ordenación de orden nlog(n) requiere de 10 segundos para ordenar


1.000 registros en su computadora, ¿cuantos segundos demorara en ordenar 22.000
registros?
solucion

Para 1000 datos hace 9966 comparaciones y demora 10 segundos


Para 22000 datos hace 317355 comparaciones y demora 318 segundos

12.- Se quiere calcular el producto de dos números usando el algoritmo “a la russa”


ejemplo: 40 * 80 = 3200
a la russa se calcula usando la tabla siguiente
40 80
20 160
10 320
5 640
2 1280
1 2560
La columna encabezada por 40 se divide por 2 hasta llegar a uno, la columna del 80 se
duplica, luego sumamos los números de la columna del 80 en donde la columna del 40
tiene un impar, es decir 640 + 2560 = 3200
Calcule el orden de multiplicar “a la russa” para dos números grandes.
solucion
13.- Dada la siguiente definición
 m  m
0 =1 ; m =1 ;

   
 m m-1 m-1
n = n + n-1

Confeccione una función recursiva que calcule “ m sobre n”, usando esta definición y
evalúe su costo

14.- Se necesita calcular la profundidad de un árbol binario, considerando que un árbol


vacío tiene profundidad cero y que un árbol cualquiera tiene 1 + la profundidad del hijo
más profundo, ( el camino más largo, desde la raíz hasta una hoja), usando esta forma de
contar, ¿cual es el costo del algoritmo?
solucion
esto es equivalente a recorrer el árbol en inorden. Pues no se cual es la rama mas
profunda, por lo que debo recorrer todo el arbol.

15.-Calcule el costo y el orden del siguiente algoritmo, que cuenta el número de nodos
presentes en un árbol de búsqueda binaria.

Int cuentaNodosDeUnABB( arbol t)


{
if ( t == NULL )
return 0 ;
else
1 + cuentaNodosDeUnABB(t->izq) + cuentaNodosDeUnABB(t->der);

}
solucion
esto es equivalente a recorrer el árbol en inorden.

16.- Cual es el orden del ordenador siguiente


ordena(s)
{
mientras (S no este ordenado)
intercambia aleatoriamente dos casillas de S
}
para el intercambio de elementos de S considere que nunca se pasa dos veces por el
mismo estado de S.
solucion
para saber si S esta o no ordenado se hacen n-1 comparaciones, el intercambio aleatorio me
da n! , combinaciones en el peor caso, luego el orden es (n-1) * n!
17.- Sea S un conjunto de datos, parcialmente ordenado en grupos, (ver ejemplo)
confeccione un algoritmo eficiente que ordene dicho conjunto. (aprovechando el orden
parcial)

ordenar
S = { 12,13,14,15,16,17,83,84,85,87,23,24,25,26,27,28,29,30,7,8,45}

Calcule el orden de su algoritmo y explique su resultado.


solucion
ordenar un arreglo es de orden n*log(n), aca basta con tomar a un representante de cada
grupo ( por ejemplo el primero) , con m grupos y ordenarlos, luego el orden es m*log(m)

18.- calcule el T(n) siguiente

1 si n < 1

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

19.- Calcule el T(n) .

T(n) = (1/2)n + 4 T ( (n/2) + 3 ).

20.- calcule el T(n) siguiente

1 si n < 1

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

21.- Calcule el T(n) siguiente


T(n) = 1 si n<2 y T(n) = n*lg(n) + 5 T(n/2)

22.- calcule el T(n) siguiente

1 si n < 1

T(n) =
5 + T ( n /2 ) + T(n/ 3 ) + T(n/6)

23.- para las siguientes ecuaciones determine el costo y el orden. (debe suponer un borde
adecuado)
T(n) = n3 + 4T(n/2)
T(n) = n + T(9n/10)
T(n) = n2 + 3T(n/4)
T(n) = 2*n + T(n/10)
T(n) = n3/2 + 4T(n/2)
T(n) = 5*T(n/2)
T(n) = n1/2 + 4T(n/2)
T(n) = 2 + T(n/3 + 5)
T(n) = n + n3 + 3T(n/2 + 11)

24.- usando el método del árbol resuelva

T(n) = n + T(n/3) + T(n/4)

25.- usando recurrencias homogéneas, resuelva

0 si n = 1
6 si n = 2
T(n) =
T ( n - 1 ) + 12T(n-2 )

1 si n = 1
5 si n = 2
T(n) =
10T ( n - 2 ) - 7T(n-1 )

n si n < 3

T(n) =
T ( n - 1 ) - 2T(n-2 ) – 4T(n-3)

n si n < 3

T(n) =
48T(n-3) - T ( n - 1 ) - 4T(n-2 )