Estoy atrapado analizando la complejidad temporal del siguiente algoritmo:
def fun (r, k, d, p):
if d > p:
return r
if d = 0 and p = 0:
r <- r + k
return r
if d > 0:
fun (r, k + 1, d - 1, p)
if p > 0:
fun (r, k - 1, d, p - 1)
La llamada raíz será fun (0, 0, n, n)
, y n
es el tamaño del problema.
Supongo que: la relación de recurrencia es , que es equivalente a , y entonces .
¿Es correcto mi análisis (sé que no es muy completo y exacto)? Si tiene un defecto grave, indíquelo o muéstreme una prueba correcta y completa de la complejidad temporal de este algoritmo.
d>0
y p>0
. No muestra lo que devuelve la función si alcanzamos las declaraciones if 3ra y 4ta. ¿Querías tener una return
declaración después de cada invocación recursiva de fun
? (¿querías fun (r, k + 1, d - 1, p)
ser return fun (r, k + 1, d - 1, p)
?) ¿O querías tener una return
declaración al final del cuerpo de la función? Edite su pseudocódigo para aclarar y asegúrese de mostrar lo que esto devuelve en todos los casos posibles.
d<=p
y d>0
y p>0
todos sostienen. ¿Qué se supone que debe pasar? ¿El algoritmo hace 2 invocaciones recursivas a la función? ¿O invoca recursivamente fun(r, k + 1, d - 1, p)
y luego regresa inmediatamente, sin invocar recursivamente fun(r, k - 1, d, p - 1)
? Si tomo su pseudocódigo literalmente, parece que hace 2 invocaciones recursivas y luego regresa con un valor de retorno indefinido, pero eso parece extraño y me hace preguntarme si hay un error tipográfico / error en el pseudocódigo.