Sei sulla pagina 1di 89

ANALISIS DE ALGORITMO Y COMPLEJIDAD COMPUTACIONAL

The Game Chess


Cuantos granos de trigo son? si en cada cuadrado del tablero se dobla la cantidad anterior:

63

2i = 264 20 = 1,8*1019
i=0

Teora de Algoritmos Anlisis y Complejidad


Teora Complejidad Computacional = El estudio de resolver problemas interesantes Medida de la cantidad de recursos necesarios: espacio tiempo

Sobre los algoritmos:

Polinomio es Bueno

--------- Entre ms pequeo mejor

Exponencial es malo --------- Entre ms pequeo mejor

Para que estudiar este Tema:


Eficientes algoritmos llevan a eficientes programas Programas eficientes se venden mejor Programas eficientes hacen un mejor uso del hardware Programadores que escriben mejores programas son ms requeridos

Factores Influyen en la Eficiencia de Programas:


Problema a resolver. Lenguaje de programacin. Compilador Hardware Habilidad del programador Eficacia del programador Algoritmo

Algoritmos Corregidos
Problema a resolver. Lenguaje de programacin. Compilador Hardware Habilidad del programador Eficacia del programador Algoritmo

Resumen
Confianza en los algoritmo desde las pruebas y pruebas corregidas Corregir algoritmos recursivos probar directamente por induccin Corregir algoritmos iterativos usando loop invariantes e induccin

Correcciones
Confianza en los algoritmo desde las pruebas y pruebas corregidas Corregir algoritmos recursivos probar directamente por induccin Corregir algoritmos iterativos usando loop invariantes e induccin

Correcciones
Lgico Mtodo de Corregir Chequeando Testing Pruebas Corregidas

Testing versus Pruebas Corregidas


Testing Prueba Corregida : Trata algoritmo son una entrada de ejemplo.

: Prueba matemticamente Puede no encontrar problemas : : Puede no encontrar problemas Usar test solo puede ser peligroso

Testing

Usar una combinacin de ambas es mejor

Correcciones de Algoritmos Recursivos


Para probar correcciones de algoritmos recursivos:
Probar por induccin el tamao del problema a ser resuelto.
Base recursividad, es la base de la induccin Necesita probar que llamadas recursivas, no son infinitas recursividades Paso inductivo: Asumo que la recursividad llama correctamente, as pruebo que trabaja correctamente.

Nmero Recursivo Fibonacci


Nmero Fibonacci:
F0 = 0 F1 = 1 y para todo 2 n, Fn = Fn-2 + Fn-1 function fib(n) comment return Fn If n 1 then return(n) else return(fib(n-1) + fib(n-2))

Reivindica: Para todo n 0, fib(n) return Fn


Base : Para n = 0, fib(n) retorna 0, est reivindicado Para n = 1, fib(n) retorna 1, est reivindicado Induccin: Supuesto que n 2, y para todo 0 m n, fib(m) retorna Fm Supuesto fin(n) retorna Fn As : fib(n) = fib(n-1) + fib(n-2)

Fibonacci
Int fibonacci(int n) { if ((n==0) II (n==1)) return n; else return fibonacci(n-1) + fibonacci(n-2); }

T(n) = T(n) =

O(1) T(n-1) + T(n-2) + 1

si 1 si n > 1

Anlisis
La operacin bsica que se hace es la suma, se define C(n) como la cantidad de sumas necesarias para calcular fibonacci(n). Si a C(0),C(1),,(Cn) es claro que C0 = 0 y C1 = 0 y para n 2, es Cn = Cn-1 + Cn-2 + 1 Su generatriz es: C(z) = CnZn no

noCnZn = n2(Cn-1 + Cn-2 + 1)Z

noCnZn = n2(Cn-1 + Cn-2 + 1)Z

Transformando generatrices a otras conocidas. Primero se separa en tres sumatorias.

Luego se ajustan los ndices

Se sacan factores

Como C0 = 0, entonces

, sumando y restando 1 + Z

Ahora como

resulta que

Simplificando Las races del polinomio Siendo son comnmente conocido como razn aurea y su conjugado

Por lo que se puede factorizar

Aplicando la propiedad

se llega a

Por lo que llegamos a que

Lo que descomponemos en

igualando coeficientes resulta que

operando sistemas de ecuaciones

Los valores son:

Por lo que la funcin generatriz queda:

Extrayendo coeficientes:

Como el mdulo de

es inferior a uno asintticamente se comporta

As, se concluye que, fibonacci es de orden:

O(

ANALISIS DE ALGORITMO

Implementando Algoritmos

Gran O(h)

Definicin:
f(n) es del orden de g(n), f(n) = O(g(n)), si existe c, no R+ tal que ara todo n no, f(n) cg(n)

Ejemplo:
log(n) es O(n) Reivindica: Para todo n 1, log(n) n.

Se prueba por induccin:


La reivindicacin es trivial para n=1. dado que log(1) = 0 < 1. Ahora se supone cierto para n 1 y log(n) n. Entonces: log(n+1) log(2n) = logn +1 n+1

(por hiptesis de induccin)

Gran (h)

Definicin:
f(n) es del orden de g(n), f(n) = (g(n)), si existe c > 0, tales que son muchos infinitamente n N tal que, f(n) cg(n)

Gran (h)

Definicin:
f(n) es del orden de g(n), f(n) = (g(n)), si existe c,n0 R+> 0, tales que para todo n n0, f(n) cg(n)

Es esta una Diferencia


Si f(n) = (g(n)), f(n) = (g(n)) la inversa no es cierta. Por ejemplo.

Gran (h)

Definicin:
f(n) es (g(n)), s y solo s f(n) es O(g(n)) y f(n) es (g(n))

Sumando O(h)
Si f1(n) es O(g1(n)) y f2(n) es O(g2(n)) f1(n) + f2(n) es O(g1(n) + g2(n))

Multiplicando O(h)
Si f1(n) es O(g1(n)) y f2(n) es O(g2(n)) f1(n) f2(n) es O(g1(n)*g2(n))

Tipo de Anlisis
Peor Caso: El tiempo que toma en el peor caso posible. Es el mximo T(n) sobre una entrada de tamao n. Caso Promedio: Es la expectativa de tiempo corriendo, dada alguna probabilidad o distribucin de tiempo (usualmente uniforme). T(n) es el tiempo que toma sobre toda entrada de tamao n en promedio. Caso Probabilstico: Es la expectativa de tiempo que corre sobre una rango de entradas posibles. Caso Amortizado: El tiempo de corrida pata una serie de ejecuciones, dividida por el nmero de ejecuciones.

Complejidad Tiempo
Analizando los tiempos en el peor caso: asignacin procedimiento entrada procedimiento salida si el test hay dos ramas loop O(1) O(1) O(1) O(mximo de las dos ramas) suma sobre todas las iteraciones del tiempo de cada iteracin.

Multiplicacin
function multiply(y,z) comment Return yz, donde y,z IN 1. x:= 0; 2. while z>0 do 3. if z is odd then x:= x + y; 4. y:=2y; z:=(z/2); 5. return(x) Supuesto y y z tienen n bits. procedimiento de entrada y salida costo O(1) veces lineas 3,4 costo O(1) cada vez el while loop sobre lmeas 2-4 costos O(n) veces (es ejecutada a lo ms n veces) lnea 1 costos O(1) veces

Entonces, la multiplicacin toma O(n) veces

Bubblesort
1. procudere bubblesort(A[1..n]) 2. for i:=1 to n-1 do 3. for j:=0 to n-i do 4. if A[j] > A[j+1] then 5. Swap A[j] with A[j+1] procedimiento de entrada y salida costo O(1) veces lnea 5costo O(1) cada vez el if de la sentencia de lneas 4-5 costosO(1) El for-loop sobre lneas 3-5 costos O(n-i) veces El for-loop sobre lneas 2-5 costos O( ) El bubblesort toma tiempo de O(n2) en el peor caso.

Anlisis de Algoritmos Iterativos (no recursivos)


El Heap: Una implementacin de prioridad de la cola Tiempo de insercin Tiempo de borrado Heapsort Construir un Heap Deshacer un Heap Anlisis peor caso Como construir un Heap en O(nlog(n)) O(nlog(n)) O(nlog(n)) O(n) O(log(n)) O(log(n))

Heap
El Heap: es una popular implementacin. Un heap es un rbol binario con los datos cargados en los nodos, Tiene dos importantes propiedades.
1. Balance. Completar el rbol binario sin prdida de hojas, en los ltimos niveles del lado izquierdo.

2. El valor de las hoja del padre es menor que el valor de las hojas del hijo.

Borrar el Mnimo
Borrarlo de la raz, y devolver el valor.

Pero lo que se tiene ya no es un rbol!!!

Reemplazar la raz por la ltima hoja.

Pero se viola la condicin de la estructura!!!

Reemplazar la raz por la ltima hoja.

Pero se viola la condicin de la estructura!!!

Repetidamente cambiar el elemento hijo ms pequeo.

Como esto Trabaja


Por qu el intercambio del nuevo nodo es el hijo ms pequeo?

Supuesto b c y a no est en el lugar correcto. Esto es a>b o a>c . En este caso b c, nosotros sabemos que a > b.

Lo que lleva a:

respectivamente. Si b es ms pequeo que sus hijos? Si, porque b < c y b c.

Si b es ms pequeo que sus hijos? Si, porque b < c y b c. C es el ms pequeo de estos hijos? Si, porque se verific antes. Es a ms pequeo que stos hijos? No necesariamente, as puede continuar intercambindose y bajando por el rbol. El sub rbol de c, tiene la condicin de estructura? Si, dado que esto no ha cambiado.

Insertar un nuevo Elemento

Preservando balance

Implementando un Heap
Un heap de n nodos usados en un arreglo A[1..n]
* La raz est cargada con A[1] * Los hijos a la izquierda de un nodo en A[i] est cargada en nodo A[2i] * Los hijos a la derecha de un nodo A[i] est cargada en nodo A[2i+1]

Implementando un Heap
Un heap de n nodos usados en un arreglo A[1..n]
* La raz est cargada con A[1] * Los hijos a la izquierda de un nodo en A[i] est cargada en nodo A[2i] * Los hijos a la derecha de un nodo A[i] est cargada en nodo A[2i+1]

Borrar el Mnimo Remover raz Reemplazar raz Swaps O(1) O(1) O(l(n))

Donde l(n) es el nmero de niveles en n-nodo heap.

Insertar
Poner una hoja Swaps O(1) O(l(n))

Anlisis de l(n) Un rbol binario completo con k niveles, tiene exactamente 2k-1 nodos. Entonces con k niveles tiene no menos 2k-1 y no ms que 2k-1 .

Entonces en un heap con k niveles y n nodos:

Resumen
Anlisis de algoritmos recursivos: * relacin de recurrencia * como deriva * como se soluciona

Derivando la Relacin de Recurrencia


Para encontrar la relacin de recurrencia corriendo veces a un algoritmo: * n es el tamao del problema * ver que valor de n es usado sobre la base recursividad * Ver el valor de T(no), usualmente una constante * Usualmente en la recursividad un problema de tamao f)n) da un trmino a*T(f(n)) en la relacin de recursividad.

Derivando la Relacin de Recurrencia


Para encontrar la relacin de recurrencia corriendo veces a un algoritmo: * n es el tamao del problema * ver que valor de n es usado sobre la base recursividad * Ver el valor de T(no), usualmente una constante * Usualmente en la recursividad un problema de tamao f)n) da un trmino a*T(f(n)) en la relacin de recursividad.

Derivando la Relacin de Recurrencia

Derivando la Relacin de Recurrencia

Ejemplos:

As, T(n) el tiempo para multiply(y,z), donde z es un n-bits nmero natural. Entonces para algn c,d IR T(n) = c T(n-1) + d si n=1 en otro caso

Resolviendo la relacin de recurrencia:


Se sabe que: T(n) = T(n-1) + d para todo n> 1

Entonces, para una gran cantidad de n T(n) T(n-1) T(n-2) = = = . . = = = = = = . . = T(n-1) + d T(n-2) + d T(n-3) + d

T(2) T(1)

T(1) + d c T(n-1) +d T((n-2)+d)+d (T(n-3)+d)+2d T(n-3)+3f

T(n-i)+id Si i=n-1 dn +c d

T(n)

Esto no es una prueba, es una secuencia lgica.


Hay que hacer induccin sobre i o sobre n. Reivindicacin: Para n = 1 T(n) T(n) = = dn +c d, prueba por induccin sobre n. d+c-d =c

Supuesto verdad por hiptesis sobre n, Ahora: T(n+1) = T(n)+d (dn + c d) + d dn + c

(hiptesis de induccin)

Teorema General
Si n es una potencia de c, la solucin para la recurrencia: T(n) = d aT(n/c) +bn si n 1 en otro caso

T(n) =

O(n) si a<c O(nlogn) si a=c O(nlogca) si a>c

Dividir y Reinar
Para solucionar un problema: * * * Dividir dentro de pequeos problemas Solucionar el pequeo problema Combinar las soluciones y ponerlas dentro del gran problema

Encontrar el Mximo y el Mnimo


Encontrar el mximo y mnimo se un arreglo S[1..n]. Cuntas comparaciones entre los elementos de S se necesitan?

Max Min Total

n n-1 2n-1

Multiplicacin de Matrices

Asume que toda operacin de enteros toma O(1) tiempo: El algoritmo de mutiplicacin de matriz ingenua toma O(n3). Se puede mejorar?

Dividir para Reinar


Dividir X,Y,Z cada uno en cuatro de (n/2)*(n/2) matrices

Entonces:

As, T(n) es el tiempo de multiplicar 2 n*n matrices. La aproximacin est dada por:

Si n= 1 otro caso c, d constantes

Entonces:
T(n) = 8T(n/2) + dn2 8(8T(n/4) +d(n/2)2) +dn2 82*T(n/4) + 2dn2 + dn2 83*T(n/8) + 4dn2 + 2dn2 + dn2 8 T(n/2 ) + dn 2j
j=0 i i 2 i-1

logn

T(1) + dn

logn-1 2j j=0

cn3 + dn2(n-1) O(n3)

Algoritmo de Strassen
Clculo

Entonces

Esto es:

Esto es:

Anlisis del algoritmo de Strassen

PROGRAMACION DINAMICA
Dividir para reinar con una tabla:
Combinatoria Problemas de Knapsack Contando Combinaciones Elige r desde n, a su Elegir el primer items. As elegir el remanente r-1 items desde n-1. No elegir el primer item. Entonces se debe elegir r entre los n-1 As:

PROGRAMACION DINAMICA
Dividir para reinar con una tabla:
Combinatoria Problemas de Knapsack Contando Combinaciones Elige r desde n, a su Elegir el primer items. As elegir el remanente r-1 items desde n-1. No elegir el primer item. Entonces se debe elegir r entre los n-1 As:

ALGORITMO PARA RESOLVER

Probar por Induccin Anlisis Entonces:

Anlisis:

Ejemplo:

Repiten clculos

Un mejor Algoritmo: Tabla Pascal

Inicializacin

Regla General
Para llenar T[i,j] = T[i-1,j-1] + T[i-1,j]

Se llena la tabla, de arriba a bajo de la siguiente manera:

Anlisis Algoritmo
Cuanto toma llenar la tabla. (n-r+1)(r+1) = nr + n r2 + 1 n(r + 1) +1 Cada entrada toma O(1) el total requerido es O(n2) es mejor que O(2n)

Programacin Dinmica
Cuando se subdivide para reinar, se generan un nmero importante de problemas idnticos, luego la recursin tambin se pude mejorar. Luego la solucin es una tabla. La tcnica es llamada programacin dinmica.

Tcnica de Programacin Dinmica


Para disear un algoritmo de programacin dinmica: Identificar: * Algoritmo de dividir y reinar * Analizar si el tiempo del algoritmo es exponencial. Algunos sub problemas son resueltos muchas veces. Hay que identificar del algoritmo la parte a dividir y la parte recursiva Registrar tabla de entrada Usar la base de dividir para reinar para llenar la tabla. Ver como queda y usarla.

En el caso del Ejemplo:

Grafos
Un grafo es un par ordenado G = (V,E) V es un conjunto finito de vrtices E C VxV es un conjunto de arcos Por Ejemplo:

V = {1,2,3,4,5}
E = {(1,2),(1,4),(1,5),(2,3),(3,4),(3,5),(4,5)} Grafo Dirigido Un grafo dirigido es un grafo con direcciones sobre los arcos. Por ejemplo:

Rotulado Grafo Dirigido


Un grafo dirigido es un grafo con direcciones sobre los arcos y costos positivos sobre los costos.

Aplicaciones: Ciudades y distancias de camino. Costos de produccin asociados a un proceso. Convencin: n es el nmero de vrtices e es el nmero de arcos

Caminos en Grafo
Un camino en un grafo G = (V,E) es una secuencia de arcos (v1,v2),(v2,v3),..,(vn,vn+1) E. El largo del sendero es el nmero de arcos. El costo del sendero es la suma del costo de los arcos. Por ejemplo; (1,2),(2,3),(3,5). Largo 23, costo 70.grafo dirigido es un grafo con direcciones sobre los arcos y costos positivos sobre los costos.

Todos los pares de caminos cortos


Dado un rotulado, para un grafo dirigido G = (V,E) encontrar para cada par de vrtices

v,w V en costo de los caminos (es decir al menos el costo) del camino de v a w.
Se define Ak una matriz de n*n con Ak[i,j] el costo de i a j con vrtices internos numerados <k. Ao[i,j] iguales * Si i j y (i,j) E, es el costo del arco desde i a j * Si i j y (i,j) no pertenece a E, entonces * Si i=j, entonces 0

Calculando Ak
Considerar el camino de i a j con vrtices internos 1..k. As, No pasa por k, en su lugar es el costo Ak-1[ i, j]. Pasa a travs de k, en cuyo caso pasa por k solo una vez, por lo que el costo Ak-1[i,k] + Ak-1[k,j]

Por lo tanto:

Todas entradas en Ak dependen a fila k y columna k de Ak-1 Las entradas en fila k y columna k de Ak son algunas de las elegidas en Ak-1

Para la fila y columna:

Entonces se pude usar algn arreglo:


Algoritmo Floyds

O(n3)

Entonces se pude usar algn arreglo:


Algoritmo Floyds

Almacenar el ms corto camino:

P[i,j] contiene el vrtice del camino ms corto i a j.

Programacin Dinmica