Eliminacin de la recursividad

redundante
Algoritmos recursivos
Ventajas:
Sencillez
Desventajas:
Ineficiencia:
Muy grave su hay redundancia
Factores constantes si no hay redundancia
Tcnicas de eliminacin de la recursividad:
Recursividad general
Recursividad lineal
Recursividad redundante (mltiple)
Ejemplo de eliminacin de
recursividad lineal
Intercambiar 2 secciones de un vector :
Dado un vector v, intercambiar las l primeras celdas con
las n-l restantes
El intercambio debe realizarse sobre el mismo vector,
sin un vector auxiliar
Ejemplo de eliminacin de
recursividad lineal
public static void intercambiarSecciones (int l, int[ ] v) {
interAux (l, v.length-l, l, v);
}

donde:
interAux(i,j,k,v) intercambia dos secciones consecutivas
de v, de longitudes i y j, de forma que la segunda
comienza en la posicin k

Ejemplo de eliminacin de
recursividad lineal
Ejemplo de eliminacin de
recursividad lineal
interAux(i,j,k,v) intercambia dos secciones consecutivas de v, de
longitudes i y j, de forma que la segunda comienza en la posicin k
intercambiar(i,j,m,v) intercambia dos secciones consecutivas de v
de longitud m y que comienzan en las posiciones i y j

private static void interAux (int i, int j, int k, int[ ] v) {
if (i==j)
intercambiar (k-i, k, i, v);
else if (i<j) {
intercambiar (k-i, k+j-i, i, v);
interAux (i, j-i, k, v);
}
else {
intercambiar (k-i, k, j, v);
interAux (i-j, j, k, v);
}
}
Ejemplo de eliminacin de
recursividad lineal
intercambiar intercambia dos secciones consecutivas de
v de longitud m y que comienzan en las posiciones i y j:

public static void intercambiar (int i, int j, int m, int[ ] v) {
for (int k=0; k<m; k++) {
int temp = v[i+k];
v[i+k] = v[j+k];
v[j+k] = temp;
}
}
Ejemplo de eliminacin de
recursividad lineal
Usando un esquema de eliminacin de la recursividad
final:
public static void intercambiarSecciones (int l, int[ ] v) {
int i = l;
int j = v.length-l;
int k = l;
while (i!=j)
if (i<j) {
j = j-i;
intercambiar (k-i, k+j-i, i, v);
}
else {
intercambiar (k-i, k, j, v);
i = i-j;
}
intercambiar (k-i, k, i, v);
}

Puede expandirse la definicin de
intercambiar, resultando un
algoritmo con dos bucles
anidados:
Algoritmo iterativo difcil de
disear sin la versin recursiva
inicial
Eliminacin de la recursividad
redundante
Pasos:
1. Anlisis de la redundancia:
a. rbol de recursin
b. Grafo de dependencia
2. Tcnicas de eliminacin de la redundancia:
Memorizacin
Tabulacin
3. Optimizacin de memoria
Anlisis de redundancia
Algoritmo recursivo (mltiple) con
redundancias:
public static int fib (int n) {
if ((n==0) || (n==1))
return 1;
else
return fib(n-1) + fib(n-2);
}
Anlisis de redundancia
rbol de recursin
de fib(5):
Usando SRec
Anlisis de redundancia
rbol de recursin de
fib(5):







Grafo de dependencia
de fib(5):

Anlisis de redundancia
Definicin:
rbol de recursin de
C
5,2
:

Anlisis de redundancia
rbol de recursin de
C
5,2
:
Grafo de
dependencia de C
5,2
:
n+1
m-n+1
public static int fibRabbit (int n) {
return bebes(n) + adultos(n);
}
private static int bebes (int n) {
if (n==0)
return 1;
else
return adultos(n-1);
}
private static int adultos (int n) {
if (n==0)
return 0;
else
return adultos(n-1) + bebes(n-1);
}
Dificultad:
Recursividad mutua
Anlisis de redundancia
Dificultad:
Mtodos anidados
public static int ack (int m, int n) {
if (m==0)
return n+1;
else if (n==0)
return ack(m-1,1);
else
return ack(m-1,ack(m,n-1));
}
rbol de recursin
de ack(2,2)?
Anlisis de redundancia

Anlisis de redundancia
No todos los algoritmos recursivos
mltiples son redundantes:
Algoritmos de divide y vencers:
P.ej. ordenacin por mezcla (rbol de recursin
con ndices del subvector a ordenar)
Memorizacin
public static T f (T x) {
if (P<x>)
return B<x>;
else
return
C(E<x>,
f(D1<x>),f(D2<x>));
}
public static T F (T x) {
T[ ] t = new T[x];
for (i=0; i<=n; i++)
t[i] = v;
M (x,t);
return (t[x]);
}
private static void M (T x, T[ ] t) {
if (t[x] == v)
if (P<x>)
t[x] = B<x>;
else {
M(D1<x>,t);
M(D2<x>,t);
t[x] = C(E<x>,
t[D1<x>], t[D2<x>]);
}
}
Memorizacin
public static int fib (int n) {
if (n==0 || n==1)
return 1;
else
return
fib(n-1) + fib(n-2);
}
public static int fib (int n) {
int[ ] fibs = new int[n+1];
for (int i=0; i<=n; i++)
fibs[i] = -1;
fibMem (n, fibs);
return fibs[n];
}
private static void fibMem (int n, int[ ] fibs){
if (fibs[n] == -1)
if (n==0||n==1)
fibs[n] = 1;
else {
fibMem (n-1, fibs);
fibMem (n-2, fibs);
fibs[n] = fibs[n-1]+fibs[n-2];
}
}
public static int comb
(int m, int n) {
if (n==0||m==n)
return 1;
else
return comb(m-1,n) +
comb(m-1,n-1);
}
public static int comb (int m, int n) {
int[ ][ ] combs = new int[m-n+1][n+1];
for (int i=0; i<=m-n; i++)
for (int j=0; j<=n; j++)
combs[i][j] = 0;
combMem (m, n, combs);
return combs[m-n][n];
}
private static void combMem
(int m, int n, int[ ][ ] combs) {
if (combs[m-n][n] == 0)
if (n==0||m==n)
combs[m-n][n] = 1;
else {
combMem (m-1, n, combs);
combMem (m-1, n-1, combs);
combs[m-n][n] =
combs[m-n-1][n] + combs[m-n][n-1];
}
}
Memorizacin
Memorizacin
Tabulacin
Algoritmo con un orden lineal de cmputo y una
tabla auxiliar:
public static int fib (int n) {
int[ ] fibs = new int[n+1];
fibs[0] = 1;
fibs[1] = 1;
for (int i=2; i<=n; i++)
fibs[i] = fibs[i-1]+fibs[i-2];
return fibs[n];
}
Tabulacin
Algoritmo con orden lineal de cmputo (columnas):
public static int comb (int m, int n) {
int[ ][ ] combs = new int[m-n+1][n+1];
for (int j=1; j<=n; j++)
combs[0][j] = 1;
for (int i=1; i<=m-n; i++) {
combs[i][0] = 1;
for (int j=1; j<=n; j++)
combs[i][j] = combs[i-1][j] + combs[i][j-1];
}
return combs[m-n][n];
}
Tabulacin
Algoritmo con orden lineal de cmputo (filas):
public static int comb (int m, int n) {
int[ ][ ] combs = new int[m-n+1][n+1];
for (int i=1; i<=m-n; i++)
combs[i][0] = 1;
for (int j=1; j<=n; j++) {
combs[0][j] = 1;
for (int i=1; i<=m-n; i++)
combs[i][j] = combs[i-1][j] + combs[i][j-1];
}
return combs[m-n][n];
}
Minimizacin de memoria
Con optimizacin de
la memoria (f2 >= f1):
public static int fib (int n) {
int f1 = 1;
int f2 = 1;
for (int i=1; i<=n/2; i++) {
f1 = f1+f2;
f2 = f2+f1;
}
return (n%2==0)?f1:f2;
}
Minimizacin de memoria
Con optimizacin de
la memoria (f2 >= f1):
public static int fib (int n) {
int f1 = 1;
int f2 = 1;
for (int i=2; i<=n; i++) {
int temp = f2;
f2 = f1+f2;
f1 = temp;
}
return f2;
}
Minimizacin de memoria
Con optimizacin de la memoria (columnas):
public static int comb (int m, int n) {
int[] combs = new int[n+1];
for (int j=0; j<=n; j++)
combs[j] = 1;
for (int i=1; i<=m-n; i++)
for (int j=1; j<=n; j++)
combs[j] = combs[j] + combs [j-1];
return combs[n];
}
Competicin deportiva
Algoritmo recursivo:
P(0,j+1) = 0
P(i+1,0) = 1
P(i+1,j+1) = [P(i,j+1)+P(i+1,j)]
Anlisis de redundancia:
Competicin deportiva
Tabulacin (columnas):

public static float prob (int i, int j) {
float[][] tabla = new float[i+1][j+1];
for (int h=1; h<=i; h++)
tabla[h][0] = (float)1.0;
for (int k=1; k<=j; k++) {
tabla[0][k] = (float)0.0;
for (int h=1; h<=i; h++)
tabla[h][k] = (tabla[h][k-1]+tabla[h-1][k])/2;
}
return tabla[i][j];
}
Competicin deportiva
Tabulacin (filas):

public static float prob (int i, int j) {
float[][] tabla = new float[i+1][j+1];
for (int k=1; k<=j; k++)
tabla[0][k] = (float)0.0;
for (int h=1; h<=i; h++) {
tabla[h][0] = (float)1.0;
for (int k=1; k<=j; k++)
tabla[h][k] = (tabla[h][k-1]+tabla[h-1][k])/2;
}
return tabla[i][j];
}
Tabulacin, con memoria optimizada (filas):

public static float prob (int i, int j) {
float[] tabla = new float[j+1];
tabla[0] = (float)1.0;
for (int k=1; k<=j; k++)
tabla[k] = (float)0.0;
for (int h=1; h<=i; h++)
for (int k=1; k<=j; k++)
tabla[k] = (tabla[k-1]+tabla[k])/2;
return tabla[j];
}
Competicin deportiva
Competicin deportiva
Tabulacin (en diagonal):

public static float prob (int i, int j) {
float [ ][ ] tabla = new float[i+1][j+1];
for (int k=1; k<=i+j; k++) {
if (k<=j)
tabla[0][k] = (float)0.0;
if (k<=i)
tabla[k][0] = (float)1.0;
for (int h=1; h<k; h++)
if ((h<=i) && (k-h<=j))
tabla[h][k-h]=(tabla[h-1][k-h]+tabla[h][k-h-1])/2;
}
return tabla[i][j];
}
Mochila 0/1
ps=(3,6,9,5)
bs=(7,2,8,4)
c=15
c p n i para
p p si b p p i m p i m
p p si p i m
p i m
c p para p n m
i i i
i
s s s s

> + + +
< +
=
s s = +
0 , 1
) ) , 1 ( ), , 1 ( max(
) , 1 (
) , (
0 0 ) , 1 (
Mochila 0/1
ps=(3,6,9,5)
bs=(7,2,8,4)
c=15
c p n i para
p p si b p p i m p i m
p p si p i m
p i m
c p para p n m
i i i
i
s s s s

> + + +
< +
=
s s = +
0 , 1
) ) , 1 ( ), , 1 ( max(
) , 1 (
) , (
0 0 ) , 1 (
Mochila 0/1
ps=(3,6,9,5)
bs=(7,2,8,4)
c=15
c p n i para
p p si b p p i m p i m
p p si p i m
p i m
c p para p n m
i i i
i
s s s s

> + + +
< +
=
s s = +
0 , 1
) ) , 1 ( ), , 1 ( max(
) , 1 (
) , (
0 0 ) , 1 (
Mochila 0/1
ps=(3,6,9,5)
bs=(7,2,8,4)
c=15
Grafo variable:





Subgrafo de:
c p n i para
p p si b p p i m p i m
p p si p i m
p i m
c p para p n m
i i i
i
s s s s

> + + +
< +
=
s s = +
0 , 1
) ) , 1 ( ), , 1 ( max(
) , 1 (
) , (
0 0 ) , 1 (
Tabla mnima
Solucin recursiva:


um={200,100,50,20,10,5,2,1}
m(0,12):
Cambio de monedas
{ } ] [ / 0 , 1 0 ]) [ , 1 ( min ) , (
0 ) , (
i um x j n i para i um j x i m j x i m
c x para x x n m
s s s s + + =
s s =
Solucin recursiva:


um={7,5,1}, m(0,10):
Cambio de monedas
{ } ] [ / 0 , 1 0 ]) [ , 1 ( min ) , (
0 ) , (
i um x j n i para i um j x i m j x i m
c x para x x n m
s s s s + + =
s s =
Cambio de monedas
um={7,5,1}, c=10: