Algoritmos avanzados

Ing. Simón Onofre López

UNIDAD II ANÁLISIS DE ALGORITMOS

2.1. INTRODUCCIÓN

Para cada algoritmo es necesario aclarar cuales son las operaciones elementales y como
están representados los datos de entrada y de salida. Su ejecución requiere unos recursos.

Un algoritmo es mejor cuanto menos recursos consuma.

Otros criterios que se toman en cuenta son: facilidad de programarlo, corto, fácil de entender,
robusto...

Legible y bien documentado

Programa
Ideal
Correcto EFICIENTE

Fácil de mantener y utilizar

2.2 COMPLEJIDAD DE ALGORITMOS

La eficiencia de los algoritmos se cuantifica con las medidas de complejidad:

— Complejidad temporal: tiempo de cómputo de un programa

— Complejidad espacial: memoria que utiliza un programa en su ejecución

También cuando se habla del comportamiento de los algoritmos se hace referencia al

análisis de complejidad.

Dado un algoritmo A, el tiempo de ejecución TA(n) de A es la cantidad de pasos, operaciones

o acciones elementales que debe realizar el algoritmo al ser ejecutado en una instancia de
tamaño n.

El espacio eA(n) de A es la cantidad de datos elementales que el algoritmo necesita al ser

ejecutado en una instancia de tamaño n.
La complejidad de un programa depende de

— el tamaño de los datos de entrada,

— el valor de los datos de entrada, y
— la máquina y el compilador.

Es claro que para cada algoritmo la cantidad de recursos (tiempo, memoria) insumidos
depende fuertemente de los datos de entrada. En general, la cantidad de recursos crece a
medida que crece el tamaño de la entrada.

Ejemplo 1
— para un vector su longitud,
— para un número su valor o su número de dígitos, …

6
Algoritmos avanzados
Ing. Simón Onofre López

2.3 TIPOS DE ANÁLISIS DE EFICIENCIA

Se definen distintos tipos de análisis:

a) Análisis en el peor caso: se considera el máximo entre las cantidades de recursos

insumidas por todas las instancias de tamaño n.
b) Análisis caso promedio: se considera el promedio de las cantidades de recursos
insumidas por todas las instancias de tamaño n.
c) Análisis probabilístico: se considera la cantidad de recursos de cada instancia de
tamaño n pesado por su probabilidad de ser ejecutada.
d) Análisis en el mejor caso: se considera el mínimo entre las cantidades de recursos
insumidas por todas las instancias de tamaño n.

Nos concentraremos en general a analizar el peor caso, debido a que: constituye

una cota superior al total de los recursos insumidos por el algoritmo.
Conocerla nos asegura que no se superar a esa cantidad. Para muchos
algoritmos, el peor caso es el que ocurre más seguido debido al uso de la
notación asintótica, el caso promedio o probabilístico es muchas veces el
mismo que el peor caso.

No se necesita conocer la distribución de probabilidades para todas las

instancias de un mismo tamaño, como será necesario en el análisis
probabilístico. Se considerará entonces que un algoritmo es más
eficiente que otro para resolver el mismo problema si su tiempo de
ejecución (o espacio) en el peor caso tiene un crecimiento menor.

2.4 EFICIENCIA
Relación entre los recursos consumidos y los productos conseguidos.

Ejemplo 2. ¿Cuántos recursos de tiempo y memoria consume el siguiente algoritmo sencillo?

i:= 0 1
a[n+1]:= x 1
repetir
i:= i + 1 1
hasta a[i] = x

Para la estructura repetitiva el Tiempo de Ejecución depende de los valores que toman x y n
Mejor caso. Se encuentra x en la 1ª posición:
Tiempo(N) = 1
Peor caso. No se encuentra x:
Tiempo(N) =·N

Considerando el contenido de los datos de entrada, se analiza.

Mejor caso. El contenido favorece una rápida ejecución.

Peor caso. La ejecución más lenta posible.
Caso promedio. Media de todos los posibles contenidos.

7
Algoritmos avanzados
Ing. Simón Onofre López

Existen dos enfoques para medir la eficiencia:

Enfoque empírico o a posteriori: Consiste en programar todos los algoritmos candidatos e

ir probándolos en distintos casos con ayuda de una computadora.
Enfoque teórico o a priori. Que consiste en determinar matemáticamente la cantidad de
recursos necesarios para cada uno de los algoritmos como función del tamaño de los casos
considerados. Lo recursos que más nos interesan son el tiempo de computación y el espacio
de almacenamiento.

2.5 MODELO
Para analizar algoritmo en un marco formal, se necesita un modelo de computación. Nuestro
modelo es básicamente un computador normal, en el cual las instrucciones se ejecutan de
modo secuencial. El modelo tiene el repertorio estándar de instrucciones sencillas, como
adición, multiplicación, comparación y asignación, pero a diferencia de los computadores
reales, este tarda exactamente una unidad de tiempo en hacer cualquier operación sencilla.
Para ser razonable, se supondrá que, como un computador moderno, este modelo tiene
enteros de tamaño fijo y que no tienen instrucciones refinadas, como la inversión de matrices
o la clasificación, que claramente no se pueden hacer en una unidad de tiempo.

A continuación se definen algunas reglas básicas para la asignación de tiempos:

Operaciones básicas aritméticas y lógicas (+, -, *, :=,...): Una unidad de tiempo,

o alguna constante.
Operaciones de entrada salida: Otra unidad de tiempo, o una constante
diferente.

En ambos casos T(n)=1

Ejemplo 3

a) z=z+1
b) a>b
Tienen un T(n)=1, donde n es el tamaño (no conocido en este ejemplo) de la entrada

2.6 NOTACIONES PARA EXPRESAR LA COMPLEJIDAD EN TIEMPO

Una medida asintótica es un conjunto de funciones que muestran un comportamiento similar
cuando los argumentos toman valores muy grandes. Las medidas asintóticas se definen en
términos de una función de referencia f.

T(n) tiempo de ejecución de un programa con una entrada de tamaño n

Notación () Una función T(n) es (g(n)) sí y solo sí existen unas constantes c y n 0 tales
que cg(n)  T(n) cuando n0n

Notación () Una función T(n) es (h(n)) sí y solo sí se cumple que existen unas constantes
positivas c1, c2 y n0 independientes de n tales que:

8
Algoritmos avanzados
Ing. Simón Onofre López

c1g(n)  T(n)  c2g(n)  n0n

Notación O(): De manera formal se dice que una función f(n) es de orden O(g(n)) sii se
cumple que existen unas constantes positivas c y n0 , ambas independientes tales que:

f(n)  c g(n) ,  n  n0
donde decidir que f(n) es O(g(n)) supone que cg(n) es una cota superior del tiempo de
ejecución del algoritmo

De esta manera definimos la medida asintótica de cota superior f, que notaremos O( f ) como
el conjunto de funciones

{ T | existen c Î Â +, n0 Î À tales que, para todo n ³ n0 , T(n) £ c × f(n) }

Si T Î O( f ) decimos que “T(n) es del orden de f(n)” y que “f es asintóticamente una cota
superior del crecimiento de T”.

Las notaciones se interpretan también de la siguiente forma:

O(T): Orden de complejidad de T.

(T): Orden inferior de T, u omega de T.
(T): Orden exacto de T.

2.6.1 PROPIEDADES DE LA NOTACIÓN O()

Para cualquier par de funciones f(n) y g(n) se verifican las siguientes propiedades:

Pr1: cO(f(n)) es O(f(n)), donde c es una constante

Pr2: Regla de la suma:
O(f(n) + g(n)) es max(O(f(n)), O(g(n))
Pr3: O(f(n)) + O(g(n)) es O(f(n)+g(n))
Pr4: O(f(n))O(g(n)) es O(f(n)g(n))
Pr5: O(O(f(n))) es O(f(n))

Lo que buscamos es determinar matemáticamente la cantidad de recursos

Ejemplo 4 Determine O(g(n))

T(n)=2n es O(n), donde 2 es una constante

T(n)=n3 + n2 + log n es O(n3) puesto que n3 es el mayor
T(n)=nm+n es O(nm), si la entrada depende de n y m
O(O(n3)) es O(n3)
T(n) = 2n2/5 + 3/2; T(n)  O(n2). O T(n) e O(n)

Ejemplo 5
a) Sea el segmento de algoritmo

X=1 . . . . . .1
Z=6 . . . . . . 1

9
Algoritmos avanzados
Ing. Simón Onofre López

El tiempo de ejecución es T(n)= 1+1= 2 aplicando la “regla de la suma” lo cual es O(1) por
la propiedad Pr3

Sea el segmento de algoritmo

For i=1 to 10 do
Begin
x=x+1 ..............1
y=y/i.................1
end

T(n)=T(for)*T(instrucciones internas del for)=10*2=12 por la propiedad de la multiplicación

y
es O(1) por Pr 2

2.6.2 ORDENES DE COMPLEJIDAD

donde:

O(1)  O(log n)  O(n )  Ì O(n)  O(n log n)  O(n2)  O(n3)  ...  O(nk)  ...O(2n )
 O(n!)

2.7 ANALISIS DE ALGORITMOS ITERATIVOS

A continuación se enumeran algunas reglas importantes para el análisis de

programas.

a) Ciclos for

El tiempo de ejecución de un ciclo for, es a lo más el tiempo de ejecución de las

instrucciones que están en el interior del ciclo for (incluyendo las condiciones), por el número
de iteraciones. Generalmente se usa el símbolo de sumatoria

Ejemplo 6

for i:=1 to n do
x:=x+1;

10
Algoritmos avanzados
Ing. Simón Onofre López

n
Ta (n)  T(for_i) * T(instr_internas)  1  n
i 1
Ciclos for anidados

Analizar de adentro hacia fuera. El tiempo de ejecución total de una proposición dentro del
grupo, de ciclos for anidados es el tiempo de ejecución de la proposición multiplicada por el
producto de los tamaños de todos los ciclos for.

T(For/nivel1)*T(For/Nivel2)* . . . *T(For/nivelN)

Ejemplo 7

for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
x:=x+1;
n  n
 n  n  n  n
Ta (n)  T(for_i)* T(for_j)* T(for_k)*1      1      n     n * n   n * n * n  n 3
i 1  j 1  k 11   i 1  j 1  i 1
que es O(n3) orden cúbico

Para If / Else

T(IF_THEN) = T(condición)+T(Then)
T(IF_THEN_ELSE) = T(condición)+max(T(Then),T(Else))

Ejemplo 8

i)
if N mod 2 = 0 then Ta(n)= T(if_then)=T(condición)+T(then)
for i:=1 to n do n

x:=x+1;  1  1  1  n es O(n)orden lineal

i 1

ii) Tb(n)= T(if_then_else)

if N> 0 then = T(condición)+max(T(then),T(else))
x:=x+N;  1  max(1,2)  1  2  3
else es O(1)orden lconstante
begin
N=N+100
Z=z+N
Endélse

11
Algoritmos avanzados
Ing. Simón Onofre López

La noción de esta estructura selectiva se puede extender al uso del CASE (selección
múltiple)

While

Se realiza generalmente un análisis inductivo exhaustivo mediante una variable axiliar t cuya
misión es contar el tiempo del while. Además se realiza el análisi del peor de los casos de
entrada al bucle.

Ejemplo 9

¿Cuántas multiplicaciones realiza el siguiente algoritmo para calcular potencias, en el peor

de los casos?

Funcion potencia1(y : num; z : nat): nat

p := 1 1
mientras z > 0 hacer
p := p * y 1
z := z –1 1 z+1
fmientras
función

Analizando solamente la sentencia mientras se tiene

z t
t=0 4 0 El tiempo del mientras (while) es:
mientras z > 0 hacer 3 1 z +1
z = z -1 2 2 la ctte 1 se adiciona debido a la
t = t +1 1 3 última pregunta de condición del
0 4 while

Finalmente:

Tpotencia1(z) = 1 + (z+1)2 = 1 + 2z + 2 = 3 + 2z que es O(z) orden lineal

2.8 LLAMADAS A PROCEDIMIENTOS Y FUNCIONES

Si se tiene un programa con procedimientos no recursivos es posible calcular el tiempo de
ejecución de los distintos procedimientos, uno a la vez partiendo de aquellos que no llaman a
otros.

Las siguientes formulas serán útiles para la resolución de ejercicios y algunas serán usadas
en esta sección

12
Algoritmos avanzados
Ing. Simón Onofre López

n
a )1  n
i 1
n
b )  1  ( n  a  1).
i a
n
n ( n  1)
c ) i  .
i 1 2

n
n ( n  1)( 2 n  1)
d ) i 2 
i 1 6
n
n r 1
e)  i r 
i 1 ( r  1)  p r ( n )

2.9 EJERCICIOS RESUELTOS

Mediante la notación asintótica, obténganse los tiempos de ejecución del peor caso supuesto
para cada uno de los procedimientos siguientes como una función de n

Ejercicio 1

i:=1;
while I<= n do
begin
x:=x+1;
I:=I+1;
End
Añadiendo una variable t que controlará el número de veces que se ingresa a la estructura
while

i t n
T=0 1 0 4 El tiempo del while es:
i:=1; 2 1
while i<= n do 3 2 n +1
i:=i+1; 4 3
t = t +1 5 4

Finalmente realizamos el análisis del segmento de algoritmo del Ejercicio 1:

T(n) = 1 + T(while)*2 = 1+(n+1)*2 = 1 + 2n + 2 = 3 + 2n es O(n) orden lineal

Ejercicio 2

for i:=1 to n do
for j:=1 to i do
x:=x+1;

13
 Algoritmos avanzados
Ing. Simón Onofre López

n  i  n n(n  1) 1 2 1
T (n)    1  i   n  n es O(n2) orden cuadrático
i 1  j 1  i 1 2 2 2

Ejercicio 3
procedure pord_mat(n: integer);
var
I,j,k:integer;
Begin
For i:=:1 to n do
For j:=1 to n do
begin
C[i,j]:=0; - - - - - - - - - - - - - - 1
For k:=1 to n do
C[i,j]:=C[i,j]+A[i,k] * B[k,j]: - - 1
End;
End;
n n n
Tprod_mat(n) =  ( (1+1)) = n ( n (1+ n )) = n (n+n2) = n2 + n3
I=1 j=1 k=1
3
Que es O(n ) orden cúbico.

La simplificación de las sumatorias se realiza directamente, porque no existen variables

dependientes.

Ejercicio 4
procedure misterio1(n: integer);
var
i,j,k:integer;
begin
for i:=:1 to n-1 do
for j:=i+1 to n do
for k:=1 to j do
{alguna proposición que requiera tiempo O(1) }
end;

n 1 n j n 1 n n1 n i
Tmisterio1 (n)   (  (1))   (  j )   ( j   j )
i 1 j i 1 k 1 i 1 j i 1 i 1 j 1 j 1

n 1
n(n  1) i (i  1) n1 n(n  1) 1 n1 2
Tmisterio1 (n)   (  )  ( )   (i  i )
i 1 2 2 i 1 2 2 i1

( n  1)n( n  1) 1 n 1 2 n 1 (n 2  n )( n  1) 1 ( n  1)n( 2n  1) ( n  1)n

Tmisterio1 ( n )   ( i   i )   (  )
2 2 i 1 i 1 2 2 6 2

es O(n3) orden cúbico

14
Algoritmos avanzados
Ing. Simón Onofre López

Ejercicio 5
procedure misterio2(n: integer);
var
x, cuenta:integer;
begin
cuenta:=0;
x:=2;
while x<n do
begin
x:=2*x;
cuenta:=cuenta+1;
end;
writeln (cuenta)
end;

Primero analizamos la sentencia WHILE

x T n
t=0 2 0 31 El tiempo del mientras (while) es:
x=2 4 1 2t+1 = x  de la condición del while 2t+1 < n
while x<n do 8 2
x=2*x 16 3 despejando t se tiene
t=t+1 32 4 t <log2n –1
para que se de una equivalencia entre ambos términos
t +a  log2n –1  t  log2n –1 –a +1
se adiciona la ctte 1 debido a la última pregunta que se
realiza en la sentencia while

Finalmente:

Es O(log n) orden logarítmico

Tincognita2 ( n )  1  1  (log 2 n  1  a  1)(1  1)  2  (log 2 n  a )2

Tincognita2 ( n )  2  2 log 2 n  2a

Ejercicio 6

Se tiene un fragmento de programa sencillo para calcular  i3 a continuación:

Function suma(n:intertger)
var
i,suma_parcial: integer
begin
(1) suma_parcial=0;
(2) for i:=1 to n do
(3) suma_parcial:= suma_parcial +i*i*i;
end for

15
Algoritmos avanzados
Ing. Simón Onofre López

(4) suma:=suma_parcial
end suma

Calcular el tiempo de ejecución en el peor de los casos

Sol. El tiempo de ejecución para (1), (3) y (4) es 1, en el caso del for es una sumatoria de la
siguiente forma:
n
Tsuma(n) = 1+ 1 + 1
i=1

Tsuma(n) = 1+ n + 1 = 2+n es O(n) orden lineal

2.10 RESOLUCION DE ECUACIONES DE RECURRENCIA

Existen tres enfoques distintos para resolver ecuaciones de recurrencia:

1. Expansión de recurrencias

Utilizar la recurrencia misma para sustituir m<n por cualquier T(m) en la derecha, hasta que
todo, los términos T(m) par m>1 se hayan reemplazado por formulas que impliquen solo T(1)
como T( 1) siempre es constante, so tiene una formula para T(n) en función de n y de
algunas constantes

2.- Suposición de una solución

Suponer una solución f(n) y usar la recurrencia para mostrar que T(n)<=f(n). Algunas veces
solo se supone la forma f(n) dejando algunos parámetros sin especificar. y deduciendo
valores adecuados para los parámetros al intentar demostrar que T(n)<=f(n) para todo n.

3.- Solución general para una clase grande de problemas

Emplear Ia solución general para ciertas ecuaciones de recurrencias de tipos comunes.

Si T(n) es el tiempo para resolver un problema de tamaño n. Se tiene

1 n= 1
( *)T(n) =
aT(n/b)+d(n) n>=2

Donde

a: es el número de llamadas recursivas.

h: es el número de partes en que se divide la entrada.
d(n): función motriz

Para resolver (*) se aplica la técnica de sustituciones repetidas para T en el lado derecho.

16
Algoritmos avanzados
Ing. Simón Onofre López

Una vez que se resuelve por expansion de recurrencias, se obtiene los siguientes tres casos:

CASO I Si ak >d(b)k => O(ak)

CASO II Si ak <d(b)k => O(d(b)k)
CASO Ill: Si ak = d(b)k => O(d(b)k k)

2.11 EJERCICIOS RESUELTOS

Ejercicio 1 Sea el siguiente programa recursivo para calcular factoriales, encontrar el tiempo
de ejecución en el peor de los casos.

int Factorial(int n)
{
if(n<=1) return 1;
else
return Factorial(n-1)*n;
}
So I

Para este ejercicio se tiene la siguiente ecuación característica que representa el tiempo:

Primera forma Segunda forma

c n=1 1 n=1
TFactorial (n) = TFactorial (n) =
T ( n-1) + d n>1 T ( n-1) + 1 n>1

Aplicando la técnica de Expansión de recurrencia:

T(n)=T(n-1) + d = T(n-2) + d + d = T(n-3)+ d + d + d

Generalizando, obtenemos el Patron de Recurrencia:

T(n) = T(n-k) + kd
(*)

Por último, el caso base se presenta cuando el argumento de la función T(n) es 1 es decir
para T(1), entonces:

n-k=1 => k=n –1

luego se reemplaza k en (*)

T(n) = T(n –(n-1)) + (n-1)*d = T(1) + (n-1)*d

T(n) = c + dn – d que es O(n) orden lineal

Ejercicio 2. Obténgase la cota O rnayúscula de la siguiente ecuación:

17
Algoritmos avanzados
Ing. Simón Onofre López

d n= 1

T(n)=
2T(n/2)+ cn n<1

Para aplicar eI método expansión de recurrencia se realizan las siguientes operaciones

auxiliares

n
T(n)  2T   cn
2
n  n  n
T   2T 2   c 
2 2  2
 n   n   n 
T 2   2T 3   c 2 
2  2  2 

Realizando repetidos reemplazos en T(n)

n
T(n)  2T   cn
2
  n   n   n  n  n  n  n 
T(n)  2 2T 2   c    cn  2 2 T 2   2c   cn  2 2 T 2   2c   cn  2 2 T 2   2cn
  2   2  2  2 2  2 2 
  n   n   n  n   n   n 
T(n)  2 2  2T 3   c 2    c   cn  2 3 T 3   2 2 c 2   2cn  2 3 T 3   3cn
  2   2   2  2  2  2 
El patrón de recurrencia será:

 n 
T (n)  2 k T  k   kcn
2 

El caso base se da cuando:

n
k
 1  n  2 k  k  log n n
2

Reemplazando el valor de k en el patron de recurrencia:

T (n)  2 log 2 n T 1  cn log 2 n

T (n)  nT (1)  cn log 2 n  nd  cn log 2 n

es O(nlogn)orden cuasilineal

Ejercicio 3. Obténgase Ia cota 0 mayüscula de la siguiente recurrencia:

2T( n/2 )+2 n> 2

18
Algoritmos avanzados
Ing. Simón Onofre López

T(n)= 1 n= 2
0 n=I

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

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

T(n) = 2[2T(n/4)+2]+2

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

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

El patron de recurrencia será

k
T ( n)  2 k T ( n k )   2 i 2’
2 i 1

Si n=2t

k
)   2i
t
T ( n)  2 k T ( 2 k
2 i 1

Por últirno cuando k=t-1, se obtiene

t 1
2t t 1
)   2i  T ( 2)   2 i
t
T ( n)  2 t 1 T (2 t 1
2 i 1 2 i 1

Debemos resolver la siguiente sumatoria, por inducción:

t 1
S   2i  2t  2
i 1
luego reemplazando S en el Patrón de recurrencia y con n=2t
T(n)=n/2 + 2t-2 0 n/2 +n-2=3/2n-2 es O(n)

Ejercicio 4

C n=1
T(n) =
2T(n/2) + n3 e.o.c.

Respuesta:

Mediante la técnica de "análisis de expansión" o ”Expansión de Recurrencias“,

reemplazamos sobre T(n) de la siguiente forma:

19
 Algoritmos avanzados
Ing. Simón Onofre López

n
T ( n )  2T ( )  n 3
2
  n   n 3   n  n
3

T ( n )  2 2T  2       n 3  2 2 T  2   2   n 3
 2  2  2  2
 

  n   n 3  n
3
n   n 
3
n
3

T ( n )  2 2  2T  3    2    2   n 3  2 3 T  3   2 2  2   2   n 3
 2  2   2 2  2  2
 
Generalizando llegamos al Patrón de Recurrencia

3
 n  k 1  n   n  k 1 n k 1
3
 n  2i
T (n)  2 k T  k    2i  i   2 k T  k    2i i 3  2 k T  k   n 3  i 3
 2  i 0  2   2  i 0 2 2  i 0 2

Primero resolveremos la siguiente sumatoria:

k 1 i i
 2  k 1  1 
  3    2  S
i 0  2  i 0  2 

1 1 1 1
S  1   2  .........  k 2  k 1
4 4 4 4
1 1 1 1 1
S   2  .........  k 1  k
4 4 4 4 4
1 1
S (1  )  1  k
4 4
4 1
S   K 1
3 3.4
La determinación de O se deja como ejercicio

Ejercicio 5 Resuelva la siguiente recurrencia por el método Solución General para una clase
grande de recurrencias
1 n= 2

T(n)=
4T( n/2 )+n3 n> 1

Sc tiene a=4 v b=2

d(n)=n función Motriz. d(2)=8

Abora Comparemos con los tres casos se tiene que

a>d( 2) => 4<8 (Caso II)

20
Algoritmos avanzados
Ing. Simón Onofre López

=> T(n)= O(8logn)

Por propiedades de log se tiene O(n3)

21