Algoritmos Taller 1 Edwin Leonardo Bohrquez Buitrago Damian Diaz Devivero 1) a) Sean y funciones asintticamente no negativas.

. Usando la definicin bsica de la notacin , demuestre que . Suponiendo que existen y que tales que ( ( tales que . ? ) ) y se obtiene: y . Por definicin se sabe que . Al dividir ( ). . Se sigue un 257741 257752

todos los trminos entre Como

, se deben escoger

razonamiento similar en el caso de b) Es Si ? Es entonces

De esto se concluye que En el caso de se tiene

si se escoge

Por lo tanto se concluye que c) Use un rbol de recursin para determinar una buena cota asinttica superior para la recurrencia Como ( ) . Use el mtodo de sustitucin para verificar la respuesta. ( ) tambin sirve para ( )

, la cota superior de

( ) ( ) ( )

( ) (( ) )

( ) ( ( ) )

( ) Usando el mtodo de sustitucin: Hay que probar que

. Asumiendo que ( ) ( )

para

Esto no demuestra la hiptesis inductiva. Por lo tanto hay que reforzarla: Asumiendo con y ( ) ( ) ( ) ( ) ( )

Si

d) Utilice el mtodo maestro para obtener el limite asinttico de las siguientes recurrencias: a. ( )

Entonces, ( ( ) )

b.

Entonces,

c.

( )

Entonces,

d.

( )

Entonces,

e) El profesor Caesar desea desarrollar un algoritmo para multiplicar matrices que sea asintticamente mas rpido que el algoritmo de Strassen. Su algoritmo usara el mtodo divide y conquistaras, dividiendo cada matriz en piezas de tamao , y los pasos de dividir y combinar tomaran un tiempo . l necesita determinar cuantos subproblemas debe crear su algoritmo para superar el algoritmo de Strassen. Si su algoritmo crea subproblemas, entonces la recurrencia para el tiempo de ejecucin es ( ) . Cul es el valor entero mas grande de para que el algoritmo del profesor Caesar sea asintticamente mas rpido que el algoritmo de Strassen? La recurrencia del algoritmo de Strassen es ( ) . Usando el teorema maestro con y se ve que con , por lo tanto . Para que el algoritmo del profesor Caesar sea mejor que el algoritmo de Strassen, su cota superior debe ser menor que , as que aplicando el teorema maestro en la recurrencia del algoritmo de Caesar se obtiene . Esto se iguala con el que se obtuvo en el algoritmo de Strassen, quedando as . Despejando se obtiene . Tomando un se concluye que debe ser menor de 49.

2) Dado el siguiente seudocdigo:

def misterio(n): if n<=1: return i=1 while i<=5: i=i+1 misterio(n/2) for j in range(1,n): for k in range(i,j): print 'nada'

a) Plantee una ecuacin de recurrencia para T(n), el tiempo que toma la funcin misterio(n):

( )
b) Determine el comportamiento asinttico de T(n) justificando de manera detallada: Esta funcin de recurrencia esta expresada en trminos en los cuales puede ser aplicado el Teorema Maestro, entonces tenemos que: ( )

Segn el teorema maestro podemos decir que: Si , en este caso Por tanto: .

, entonces,

3) El algoritmo para el Selection Sort es el siguiente:

def selection_sort(A): for i in range(0,(len(A)-1)): k=i for j in range ((i+1),len(A)): if(A[j]<A[k]): k=j A[k],A[i]=A[i],A[k]

1 2 3 4 5 6

a) Defina un invariante de ciclo para el algoritmo Selection Sort. Un Invariante de ciclo adecuado para el algoritmo sera: El arreglo ordenado A[] entre la posicin 0 y la posicin i Inicializacin: A[0] esta ordenado, ya que posee un solo elemento Ejecucin: A[0i] esta ordenado ya que se toma el menor elemento el arreglo A[i+1n] y se coloca en la posicin i. Finalizacin: i se encuentra con valor n, por tanto el arreglo A[0i] ya se ha ordenado totalmente por medio del algoritmo . b) Determine cul sera un buen barmetro para el algoritmo. Un buen barmetro para el algoritmo seria la lnea 5: if A[j]<A[k], ya que esta lnea se ejecuta tantas veces como cualquier otra del algoritmo c) Haga un anlisis de la complejidad del tiempo del algoritmo T(n) para el peor caso. Tiempo de Asignacin, aritmtica, n= Tamao del arreglo Lnea 1 2 3 4 5 6 Complejidad del tiempo Tiempo de Comparacin, Tiempo de Operacin

d) Grafique el comportamiento del algoritmo T(n) en el peor caso vs el comportamiento del algoritmo T(n) en el mejor caso.

25 20 15 Mejor Caso 10 5 0 1000 Peor Caso

3000

5000

7000

9000

e) Determine el comportamiento asinttico de T(n) justificndolo de manera detallada. # Lnea Costo de Ejecucin 1 2 3 4 5 6 n n+1 n +1

4) a)
def insertion_sort(A): '''Insertion sort''' for j in xrange(1,len(A)): key=A[j] i=j-1 while i>-1 and A[i]>key: A[i+1]=A[i] i=i-1 A[i+1]=key def merge(A,p,q,r): n1=q-p+1 n2=r-q L=range(0,n1+1) R=range(0,n2+1)

for i in xrange(0,n1): L[i]=A[p+i] for j in xrange(0,n2): R[j]=A[q+j+1] L[n1]=9999999999 R[n2]=9999999999 i=0 j=0 for k in xrange(p,r+1): if L[i]<=R[j]: A[k]=L[i] i=i+1 else: A[k]=R[j] j=j+1 def merge_sort(A,p,r): if p<r: q=(p+r)/2 merge_sort(A,p,q) merge_sort(A,q+1,r) merge(A,p,q,r) def selection_sort(a): for i in range(0,(len(a)-1)): k=i for j in range ((i+1),len(a)): if(a[j]<a[k]): k=j a[k],a[i]=a[i],a[k]

Los datos para las graficas se obtuvieron con este cdigo:

if __name__=='__main__': for k in xrange(1000,11000,1000): t=0 for j in xrange(0,10): A = [random.randint(0, k) for i in xrange(k)] t1=time.clock() ordenar(A) #llamado al algoritmo de ordenamiento t2=time.clock() t=t+(t2-t1) print t/10

25

20

15

insertion-sort selection-sort merge-sort Polinmica (insertion-sort)

10

Polinmica (selection-sort) Logartmica (merge-sort)

t
0 1000

3000

5000

7000

9000

c. Merge-sort: La recurrencia es {

( ) , entonces .

Usando el teorema maestro se tiene que como Esto quiere decir que existen

5. Para encontrar una solucin a este problema, primero hay que separarle en subproblemas bsico: - Ordenar el arreglo: Esto se hizo con merge-sort, el cual tiene un tiempo - Buscar los factores: Para esto se us el algoritmo de bsqueda binaria el cual tiene un tiempo de . [] Para buscar los factores primero se verifica que es igual a cero. Si esto es as, se [ ] desde la posicin del arreglo. Esto se hace busca el nmero resultante de la operacin hasta encontrar el nmero o hasta llegar al ltimo elemento del arreglo. Al finalizar las iteraciones se imprime un mensaje en el que se informa si se hallaron o no los factores de . En el peor de los casos el algoritmo de bsqueda binaria se llamar veces dando como resultado un tiempo de ejecucin de
def merge(A,p,q,r): n1=q-p+1 n2=r-q L=range(0,n1+1) R=range(0,n2+1) for i in xrange(0,n1): L[i]=A[p+i] for j in xrange(0,n2): R[j]=A[q+j+1] L[n1]=9999999999 R[n2]=9999999999 i=0 j=0 for k in xrange(p,r+1): if L[i]<=R[j]: A[k]=L[i] i=i+1 else: A[k]=R[j] j=j+1 def merge_sort(A,p,r): if p<r: q=(p+r)/2 merge_sort(A,p,q) merge_sort(A,q+1,r) merge(A,p,q,r) def binary_search(A, x, p=0, r=None): if r==None: r=len(A)-1 while p <= r:

q = (p + r) / 2 if A[q] > x: r = q - 1 elif A[q] < x: p = q + 1 else: return q return -1 def buscar(A,x): merge_sort(A,0,len(A)-1) n1=0 n2=n1 for i in xrange(0,len(A)-2): if A[i]==0: continue else: if(x%A[i]==0): n1=binary_search(A,x/A[i],i+1) if n1!=-1: n2=i break if n1!=-1: print 'Los numeros son: ',A[n1],' y ',A[n2] else: print 'No hay numeros en el arreglo cuyo producto sea ',x