Академический Документы
Профессиональный Документы
Культура Документы
Fuentealba Vivallo
___________________________________________________________________
Guía de ecuaciones de recurrencia
___________________________________________________________________
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
#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) – 2*t(n-1) = 0
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.
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
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.
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.
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
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.
}
solucion
esto es equivalente a recorrer el árbol en inorden.
ordenar
S = { 12,13,14,15,16,17,83,84,85,87,23,24,25,26,27,28,29,30,7,8,45}
1 si n < 1
T(n) =
3*n + T ( n /2 + 3 )
1 si n < 1
T(n) =
3 + T ( n /2 ) + T(n/ 3 )
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)
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 )