Algoritmos recursivos Definicin Un algoritmo recursivo es aquel algoritmo tiene una definicin base en el caso mnimo.

es decir Un algoritmo A que resuelve un problema P es recursivo si est basado directa o indirectamente en s mismo.

En el ejemplo se ve el calculo de un numero factorial, basado en mltiples llamados recursivos hasta llegar al nodo base, que finaliza cuando N=0 y por lo tanto el resultado es R=1, pero en los nodos siguiente es decir una vez iniciada la vuelta tenemos que el resultado es R=R*N, esto

F (n)=n!

n=0 , f =1 n>0 , f =n(n1)!

Algoritmo del Calculo de Factorial Funcin Factorial (n) si n<=0 entonces factorial =1 si no Factorial= n* Factorial(n-1) fin si Fin Factorial Pila da llamadas n 3 2 1 0 Calculo al devolver ejecucin n 3 2 1 0 Complejidad si k= tiempo de evaluar n>0 y la multiplicacin T(n)= k+t(n-1) + k1+t(n-2)... t(0) entonces en el peor caso O(N) Conclusiones Este tipo de recursividad se llama Recursion Lineal no Final : el resultado de la llamada recursiva se complementa para obtener un nuevo resultado. Tambin existe la Recursion Lineal Final :se mantiene el valor del ultimo llamado recursivo. Factorial(n-1) 2 1 0 n*Factorial(n1) 3*2 2*1 1 1 Resultado 6 2 1 1t Forial(n-1) 2 1 0 n*Factorial(n-1) ? ?def ? ? Resultado ? ? ? ?

Algoritmos NP-Completos Definicin Los algoritmos que tienen solucin de complejidad polinomica ( 1,n,n2 , Log n ..) se les llama Tratables, pero tambin existen aquellos de complejidad super-polinomica (2n , n! , nn), a estos se les llama Intratables, NP, quiere decir que una computadora N no determinista(es una computadora que no esta sujeta a las reglas actuales es decir paso a paso),puede resolver un problema en tiempo polinomial P

Hay tres postes: A, B y C. En el poste A se ponen cinco discos de dimetro diferente de tal manera que un disco de dimetro mayor siempre queda f=1 debajo de uno de dimetro menor. El objetivo es mover los discos al poste C usando B como auxiliar. Slo puede moverse el disco superior de cualquier poste a otro poste, y un disco mayor jams puede quedar sobre uno menor. GRAFO Para un tablero de 1 pieza Si Torre (A,B,C) esto implica que la pieza pude ser movida a punto (B o C)

Para un tablero de 2 pieza Si Torre (A,B,C) esto implica que los movimientos aumentan a 2n-1, si observamos que para cada vertice se repite la figura 1(triangulo)

Algoritmo rutina Hanoi(n, inicial, temporal, final): si n > 0: Hanoi(n-1, inicial, final, temporal) Hanoi(n-1, temporal, inicial, final) fin si fin rutina Hanoi(n, 1, 2, 3) Cuya complejidad es : F (n)=

N =1 , X 1 =1 si N >1 , X n =2x( n1)+1

lo que es

n mov disco est en va hacia sentido 1

GRAF O
2 3 4 5 6 7 8 9 10

->

2 1 3 1 2 1 4 1 2

A B A C C A A B B

C C B A B B C C A

<-> -> -> <-> <-> <-

11 12 13 14 15

1 3 1 2 1

C B A A B

A C B C C

-> -> -> <->

Algoritmos de Paralelizacin Ejemplo : Recorrido de un laberinto

Existen bsicamente 2 mtodos para resolver un laberinto , el primero mira el laberinto como una unidad pasando por cada punto hasta llegar al final y la otra es ir llenando cada punto de esta manera solo queda la solucin final.
A continuacion se describen algunos tecnicas de recorridos para la resolucion de laberintos.

Rehacer caminos: : Este algoritmo traza un camino moviendoce en 4

direcciones cada vez que se encuentra con un camino sin salida lo marca, de esta manera encotrar una salida , pero no necesariamente en la mas optima o la unica.

Eliminar colisiones: este mtodo buscar las soluciones ms cortas. Es

rpido para todo tipo de laberintos y requiere como mnimo una copia de ste en la memoria. Bsicamente inunda el laberinto con "agua" de manera que todas las distancias desde el inicio se llenan al mismo tiempo y cada vez que dos "columnas" de agua unen dos caminos por sus respectivos finales (indicando una vuelta), se aade una pared al original. Cuando todas las partes del laberinto estn llenadas, debemos repetir el proceso hasta que no haya ms colisiones.

Para aplicar paralelismo se ha elegido el algoritmo de rehacer caminos, pero con 2 implementaciones una BackTraking y la otra paralela a continuacin se describe: Se debe crear un procesador por cada alternativa de camino disponible por nodo, solo se permite 4 movimientos (Arriba,Derecha,abajo,Izquierda), es decir en el peor de los casos tenemos 4 procesos paralelos para un nodo de Entrada(E), cada uno de estos procesadores deber buscar el camino de salida y obtener el que mas se aproxime al optimo. Es decir cada procesador usara el mtodo Ramificacin y poda para obtener el optimo y una vez finalizado el proceso paralelo se compara el resultado de cada procesador para obtener el mejor de todos( estrategia del menor costo) P=procesado o computador paralelo N= numero de camino a seguir o procesadores a utilizar E= Entrada S =salida Costo N = Costo para cada solucion de P(N) medido en paso Algoritmo: //////**** Esta es seccin lineal del proceso que define la cantidad de procesos paralelos/// identificar Entrada (E) //Evalua el caminos posible para cada procesador Pn(camino) donde n =cantidad de procesadores Costo1,costo2,costo3,costo4=0 si si si si E.arriba entonces E.derecha entonces E.abajo entonces (costo1,camino1)= P1(Arriba) (costo2,camino2)= P2(derecha) (costo3,camino3)= P3(abajo)

E.izquierda entonces (costo4,camino4)= P4(izquierda)

menor_costo= costo1 camino=camino1 si costo2< menor_costo entonces menor_costo=costo2, camino=camino2 si costo3< menor_costo entonces menor_costo=costo3,camino=camino3 si costo4< menor_costo entonces menor_costo=costo4,camino=camino4

mensaje ( ' el menor caminos es ' , camino, ' con un costo de ' ,menor_costo, 'Pasos) Fin proceos Algorito de Recorrido

P(N)

recorre (nodo,camino_posible) si nodo.camino=Pared o nodo.camino=salida

si nodo.camino=salida entonces retorna salida sino Descarta(nodo) retorna pared fin si sino //// llamado recursivo al retornar evalu si encontr solucin y busca el menor costo para cada camino

estado_ar,camino_ar= si estado_ar=salida

recorre (nodo.arriba,camino_posible) entonces camino_posible=nodo.arriba

fin si estado_de,camino_de= recorre(nodo.derecha,camino_posible)

si estado_de=salida y camino_posible> camino_ar entonces camino_posible=nodo.derecha fin si estado_ab,camino_ab= recorre(nodo.abajo,camino_posible) si estado_ab=salida y camino_posible> camino_ab entonces camino_posible=nodo.abajo fin si estado_iz,costo_iz= recorre(nodo.izquierda,camino_posible)

si estado_iz=salida y camino_posible> camino_iz entonces camino_posible=nodo.izquierda fin si fin si retorna ( estado_ar o estado_de o estado_ab or estado_iz , camino_posible) // devuelve si tiene salida para cualquiera de los nodos y el mejor camino_posible