AE | CLASE 2

Recursin

Universidad ORT
Uruguay
AGENDA
Introduccin

Motivacin

Recursin vs. Iteracin

Ejemplos

Pila de llamados
OBJETIVOS
Entender el concepto de recursividad.

Conocer los fundamentos del diseo de

algoritmos recursivos.

Ser capaces de ejecutar (a mano) un

algoritmo recursivo.

Identificar cuando es necesario utilizar un

algoritmo recursivo.
INTRODUCCIN
Qu es la recursin?

Segn la RAE
Volver una cosa al sitio dnde sali, retornar, repetirse, reaparecer.

En trminos de programacin
Un mtodo es recursivo si directa o indirectamente realiza una
llamada a si mismo.

Se dice que el mtodo se define en trminos de s mismo.

Diferente a la circularidad.
MOTIVACIN
Forma natural, lgica

Ms fcil de demostrar si la funcin es

correcta [factorial]
EJEMPLO: FUNCIN FACTORIAL
Para todo nmero natural n, se llama n
factorial o factorial de n al producto de todos
los naturales desde 1 hasta n:

n! = 1 * 2 * 3 * 4 * (n-1)*n

1, si n = 0
n! =
n*(n-1)!, si n>=1
RECURSIVO VS. ITERATIVO
[FACTORIAL]
FactorialIterativo FactorialRecursivo
Definicin de funcin
int factorial factorial
(int n){ int factorial (int n){
int f = 1; if n = 0
Fact
for (int i=2; (0)i =
i<=n; ++)1 return 1;
{ Fact (n) = n * Fact
else(n-1)
f = f * i; return n*factorial(n-1);
} }
return f;
}
MOTIVACIN
Forma natural, lgica

Ms fcil de demostrar si la funcin es

correcta [factorial]

Ineficiencia vs. Simplicidad

Nos permite resolver un problema grande,

concentrndonos en la resolucin de unos
pocos pasos.
EJEMPLOS ELIMINAR FACTORES DE 2
Eliminar los factores de 2 de un nmero natural positivo.
Tenemos que calcular num = 2^n * val
public class Entero{
public int valor;
}
//Post: Devuelve el Entero num factorizado (num = 2^n * val)
public void elimFact2(Entero num, Entero n, Entero val){
if par(num.valor)
n.valor += 1;
Entero nuevo = num.valor/2;
elimFact2(nuevo, n, val);
else
val.valor = num.valor;
}
EJEMPLOS SUCESIN DE FIBONACCI
La sucesin de Fibonacci se define de la siguiente
manera:
Fib (0) = 0
Fib (1) = 1
Fib (n) = Fib (n-1) + Fib (n-2)

//Pre: n>=0
int Fib (int n){
if (n <= 1)
return n;

return (Fib(n-1) + Fib(n-2));

}
 EJEMPLO SUCESIN DE FIBONACCI
Si llamamos, por ejemplo, afib(5), produciremos un
rbol de llamadas
con muchos llamados repetidos.

fib(5)
fib(4) + fib(3)
(fib(3) + fib(2)) + (fib(2) + fib(1))
((fib(2) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1))
(((fib(1) + fib(0)) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) +
fib(1))

En particular,fib(2)se ha calculado tres veces.

A medida que n crece el nmero de llamados repetidos
necesarios para resolver fib(n) crece
EJEMPLO SUCESIN DE FIBONACCI
Cmo podemos evitar recalcular resultados
repetidos?

Para evitar este inconveniente, podemos

almacenar los resultados ya calculados para
utilizarlos posteriormente.

As, llenaramos una tabla con los resultados de

los distintos sub-problemas, para reutilizarlos
cuando haga falta en lugar de volver a calcularlos.

La tabla resultante sera una tabla unidimensional

con los resultados desde 0 hasta n.
EJEMPLO SUCESIN DE FIBONACCI
// Inicializada en 0
int tabla[N+1]; Mejora importante, debido a
que no se vuelven a calcular
//PRE: n>=0 los sub-problemas. Requiere
int Fib2R (int [] T; int n){ de un costo de
if (n != 0){ almacenamiento
if (n == 1){
if(T[n]==0)
T[n] = 1;
} Evala si se ha calculado
else{
if(T[n]==0)
T[n] = Fib2R (T, n-1)+ Fib2R (T, n-2);
}
}
return T[n];
}
EJEMPLO SUCESIN DE FIBONACCI
int tabla[N];

//PRE: n>=0
int Fib2I (int [] T; int n){
if (n == 0)
return 0;
if (n == 1)
return 1;

T[0] = 0;
T[1] = 1;
for (int i = 2; i <= n; i++){
T[i] = T[i-1] + T[i-2];
}
return T[n];
} 0 0
1 0
1 0
2 0
3 0
5 0
8 13
0 21
0 34
0
FIBONACCI POSIBLES MEJORAS
Almacenar en una tabla los resultados obtenidos. De
esta forma, si queremos calcular fib(n) preguntaremos
previamente si dicho valor ya fue calculado.

Considerar la solucin iterativa.

Otro nivel de refinamiento que optimizara la solucin

sera quedarnos tan slo con los dos ltimos valores
calculados en lugar de toda la tabla, que son
realmente los que nos resultan tiles para calcular la
solucin a los sub-problemas.
CONSIDERACIONES - DEFINICIN
CORRECTA
Caso base: Siempre se debe tener uno o ms
casos base.

Caso recursivo: Para los pasos que deben

resolverse recursivamente, la llamada
recursiva siempre debe tender a un caso
base.

Corroborar que la definicin no es circular.

Funcin definida en trminos de s misma.
PILA DE LLAMADOS
Cada vez que un programa Q llama a otro R,
debe guardarse una indicacin del punto en Q
al cual debe devolverse el control al finalizar la
ejecucin de R.

Se utiliza una estructura de datos llamada Pila

para almacenar los puntos de retorno.

Pila:Estructura lineal dinmica donde se agregan y

quitan elementos slo en uno de sus extremos.
Cola: Estructura lineal dinmica donde se agregan
elementos en unos de sus extremos y se quitan en
el otro extremo.
PILA DE LLAMADOS
El tope de la pila es el punto donde debe
retornarse el control tras la terminacin del
subprograma corriente.

As mismo, si el subprograma corriente llama

a otro, el correspondiente punto de retorno
debe colocarse como nuevo tope de la pila.

Al finalizar un subprograma, se usa el tope

de la pila como direccin de retorno y se lo
remueve de la pila.
EJEMPLO: POTENCIA
y
Potencia (x, y)x =

Potencia (x, 0) = 1
Potencia (0, y) = 0

Potencia (x ,y) con y > 0 = x * x * x.*x

yveces

1
Potencia (x, y) con y < 0 =
Potencia ( x, y )
EJEMPLO: POTENCIA
int potencia (int x, int y){
if (y = 0)
return 1;
else if (x = 0)
return 0;
else if (y > 0)
return x * potencia(x, y-1);
else // (y < 0)
return 1/potencia(x, -y);
}
PILA DE LLAMADOS POTENCIA
(NMEROS POSITIVOS)

VARIABLES X = 2, Y = 3

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS POTENCIA
(NMEROS POSITIVOS)

VARIABLES X = 2, Y = 2

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 P(2,2),*x
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS POTENCIA
(NMEROS POSITIVOS)

VARIABLES X = 2, Y = 1

int potencia (int x, int y){

if y = 0
return 1
else
P(2,1),*x
if x = 0
return 0 P(2,2),*x
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS POTENCIA
(NMEROS POSITIVOS)

VARIABLES X = 2, Y = 0

int potencia (int x, int y){

if y = 0
return 1
else
P(2,1),*x
if x = 0
return 0 P(2,2),*x
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS POTENCIA
(NMEROS POSITIVOS)

VARIABLES X = 2, Y = 1

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 P(2,2),*x
1
else P(2,3),*x
potencia
return x * potencia (x, (x,
y-1)y-1)
end
}
stack
2
PILA DE LLAMADOS POTENCIA
(NMEROS POSITIVOS)

VARIABLES X = 2, Y = 2

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 2
else P(2,3),*x
potencia
return x * potencia (x, (x,
y-1)y-1)
end
}
stack
4
PILA DE LLAMADOS POTENCIA
(NMEROS POSITIVOS)

VARIABLES X = 2, Y = 3

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 4
else
potencia
return x * potencia (x, (x,
y-1)y-1)
end
}
stack
8
PILA DE LLAMADOS OTRO MTODO
RECURSIN VS. ITERACIN
Usando recursin no es necesario definir la
secuencia de pasos exacta para resolver el
problema.

La recursin podra ser menos eficiente

(mayor uso de memoria, y overhead por
llamados sucesivos).

Tanto la recursin como la iteracin pueden

incurrir en ejecuciones infinitas
Recursin: Mal definido el caso base.
Iteracin: Mal definido el criterio de parada del
loop.
OBJETIVOS - CUMPLIDOS?
Entender el concepto de recursividad.

Conocer los fundamentos del diseo de

algoritmos recursivos.

Ser capaces de ejecutar un algoritmo

recursivo.

Identificar cuando es necesario utilizar un

algoritmo recursivo.
EJERCICIO
int Recursivo (int []v, int i1, int i2) {
int aux1, aux2;
if (i1 = i2) //Caso base
return V[i1];
else { //Caso recursivo
aux1 = Recursivo(V, i1, (i1+i2)/2);
aux2 = Recursivo(V, ((i1+i2)/2)+1, i2);
if (aux1>aux2)
return aux1;
else
return aux2;
}
EJERCICIO
Ejecutar manualmente el cdigo con:
V [3,7,0,1]
i1 = 0
I2 = 3

Proponga un nombre nemotcnico para la

funcin.

Ejectelo nuevamente para:

V [9,2,3,7,8]
i1 = 1
I2 = 3
EN QUE ORDEN SE EJECUTA?
Disear una rutina que liste los nmeros del n al 1.
public void listarDesc(int n) {
if(n>0){
System.out.print (n+ " ");
listarDesc(n-1); 10987654321
10987654321
}
}

Podra lograr que los liste en orden inverso?

public void listarAsc(int n) {
if(n>0){ 12345678910
12345678910
listarAsc(n-1);
System.out.print (n+ " ");
}
}
 MXIMO COMN DIVISOR
Precondicin
Algoritmo de Euclides :
1. Dados dos nmeros n>m, comenzamos realizando la divisin entera de n entre m.

2. Cada paso consiste en una nueva divisin, en la que el dividendo es el nmero que
actu de divisor en la divisin anterior y el divisor es el nmero que se obtuvo
como resto en la divisin anterior.

3. Cuando en una divisin se obtiene resto nulo, el mximo comn divisor de los
nmeros de los que partimos ser el nmero que ha actuado como divisor en esa
ltima divisin efectuada y que result ser una divisin exacta.

public int MCDI(int a, int b){ public int MCDR(int a, int b){
int resto = a%b; int resto = a%b;
while (resto!=0){ if(resto==0){
a=b;
return b;
b=resto;
resto = a % b; }else{
} return MCDR(b, resto);
return b; }
}
}
EJERCICIO: ADOQUINES
Alprincipiodeljuegolosniosseubicaneneladoqunnumerado0.

Irdeunadoqunnumeradoialadoqunnumeradoi+1.

Irdeunadoqunnumeradoialadoquni+2(saltendoseeladoquni+1).

Sepidecalcularelnmerodecaminosposiblesparaalcanzarunadoqunobjetivo
numeradoconn(mayorquecero).

0 1 2 N N+1
ADOQUINES
1 58
1
= 54 3 =
2 5 +
0 3+ 3 4

2 3
2 2 2
1
1 0 1
0 0

=3
1 3 5 6
2+
8 3+
2 =1 5
1 4
0 3
2
1
0
EJERCICIO: ADOQUINES

adoquines (1) = 1;

adoquines (2) = 2;

adoquines (n) = adoquines (n-1) + adoquines (n-2);

//Pre: n>0
int adoquines (int n){

if(n = 1)
return 1;

if(n = 2)
return 2;

return (adoquines(n-1) + adoquines(n-2));

}
CONTADOR DE ISLAS (2.11)
int ContarIslas (int m[][], int d1, int d2)
// d1 y d2 son las dimensiones de la matriz
{
cant_islas = 0;
for(int i = 0; i<d1; i++){
for (int j=0; j<d2; j++){
if esTierra (m[i][j])
{
cant_islas++;
borrarIsla(m, d1, d2, i, j)
}
}
}
return cant_islas;
}
CONTADOR DE ISLAS (2.11)

void borrarIsla(int m[][], int d1, int d2, i, j)

{
if PerteneceAlMapa(d1, d2, i, j){
if esTierra(i,j){
Borrar(m, i, j);
for (int p=-1, p<=1, p++){
for(int q=-1, q<=1, q++){
borrarIsla(m, d1, d1, i+p, j+q);
}
}
}
}
}
CONTADOR DE ISLAS (2.11)
boolean PerteneceAlMapa(int d1, int d2, int i, int j)
{
return ((i>=0) and (i<d1) and (j>=0) and (i<d2))
}

void Borrar(int m[],int i,int j){

m[i][j]=0;
}

void esTierra (int m[][], int i, int j){

return (m[i][j] == 1)
{
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 1 1 0 0 0 1 0 cantIslas=0

1 0 0 1 0 1 0 0 0 1 1
2 0 1 0 0 1 1 1 0 0 0
3 0 1 0 0 0 0 0 1 0 0
4 0 0 1 0 1 0 1 0 0 1
5 0 0 1 0 1 0 1 0 0 1
6 0 0 1 0 1 0 1 0 0 1
7 0 0 0 1 1 1 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 1 1 0 0 0 1 0 cantIslas=1

1 0 0 1 0 1 0 0 0 1 1
2 0 1 0 0 1 1 1 0 0 0
3 0 1 0 0 0 0 0 1 0 0
4 0 0 1 0 1 0 1 0 0 1
5 0 0 1 0 1 0 1 0 0 1
6 0 0 1 0 1 0 1 0 0 1
7 0 0 0 1 1 1 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 1 1 0 0 0 1 0 cantIslas=1

1 0 0 1 0 1 0 0 0 1 1
2 0 1 0 0 1 1 1 0 0 0
3 0 1 0 0 0 0 0 1 0 0
4 0 0 1 0 1 0 1 0 0 1
5 0 0 1 0 1 0 1 0 0 1
6 0 0 1 0 1 0 1 0 0 1
7 0 0 0 1 1 1 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0 cantIslas=1

1 0 0 0 0 0 0 0 0 1 1
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0 cantIslas=2

1 0 0 0 0 0 0 0 0 1 1
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0 cantIslas=2

1 0 0 0 0 0 0 0 0 1 1
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=2

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=3

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=3

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=3

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 1 1 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=4

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 1 1 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=4

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 1 1 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=4

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=5

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=5

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas=5

1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 0 0
11 0 0 0 0 0 0 0 0 0 0