Cap 03 - Induccion recursividad divide y venceras

Capítulo III. Inducción, recursividad

Robert Espinoza Domínguez

Inducción matemática

Inferencia de lo general a lo particular Si las dos premisas son ciertas, entonces la conclusión

necesariamente será cierta.Todos los patos de este corral son blancos

Estos patos son de este corral

Entonces, estos patos son blancos Simétricamente, si la conclusión es falsa, entonces una

o las dos premisas deben ser falsas. La deducción es el único método de inferencia que

puede probar que una proposición es verdadera.

Deducción

Inferir una ley general a partir de la observación de casos particulares.

Aunque puede dar lugar a conclusiones falsas, es necesaria para formular conjeturas y es la clave para hacer progresar a las ciencias.

Una vez que se ha descubierto por inducción una ley matemática general, debemos demostrarla rigurosamente aplicando el proceso deductivo.

Inducción

Se puede inducir que:

“La suma de los cubos de los primeros enteros positivos es siempre un cuadrado perfecto”

o que:

“La suma de los cubos de los primeros enteros positivos es el cuadrado de su suma”

Proceso inductivo - Ejemplo

13 = 1 = 12 = 12

13 + 23 = 9 = 32 = (1 + 2)2

13 + 23 + 33 = 36 = 62 = (1 + 2 + 3)2

13 + 23 + 33 + 43 = 100 = 102 = (1 + 2 + 3 + 4)2

13 + 23 + 33 + 43 + 53 = 225 = 152 = (1 + 2 + 3 + 4 + 5)2

Si observamos que:

Caso base:

Existe un entero a tal que

P(a) es cierto.

Hipótesis de inducción:

Para cualquier entero n ≥ a

P(n-1) es válido

Conclusión

Entonces, para todos los enteros n ≥ a

P(n) es cierto


Para demostrar por inducción se debe: Probar la validez del enunciado para el caso

base P(a) Suponiendo que la hipótesis de inducción P(n-

1) es verdadera se debe demostrar la afirmación para el caso P(n)


Demostrar por inducción matemática que:

Inducción matemática - Ejemplo

Para a = 1

P(1) = 1(1+1) / 2 = 1

Suponiendo que para un n ≥ 1, P(n-1) es válido, debemos demostrar para P(n)

P(n) = 1 + 2 + 3 + … + (n-1) + n

= (n-1)((n-1)+1)/2 + n = (n-1)n/2 + n

= n((n-1)/2 + 1) = n(n+1) / 2

Por lo tanto: P(n) = n(n+1) / 2, que era lo que queríamos demostrar.

n

i

nni

1 2

)1(

Vamos a demostrar que el siguiente algoritmo, devuelve el cuadrado de un número para todo n >= 0

Función cuadrado (n)

Si (n = 0) entonces

retornar 0

Sino

retornar 2n + cuadrado (n-1) – 1

Fin si

Fin Función

Demostrar un algoritmo mediante Inducción matemática

Si probamos con unas cuantas entradas se obtiene:

cuadrado (0) = 0

cuadrado (1) = 1

cuadrado (2) = 4

cuadrado (3) = 9

cuadrado (4) = 16 Por inducción parece evidente que:

cuadrado (n) = n2 para todos los n >= 0 Usaremos la inducción matemática para demostrar la

conclusión rigurosamente.


Está demostrado que: cuadrado (1) = 1 Sea cualquier entero n >=1, supóngase que

cuadrado (n-1) = (n-1)2

Debemos probar, que para todos los n >= 0

cuadrado (n) = n2

Reemplazando:

cuadrado (n) = 2n + cuadrado(n-1) – 1

= 2n + (n-1)2 – 1

= 2n + (n2 – 2n + 1) – 1 = n2

Por lo tanto:

cuadrado (n) = n2, para n >= 0, pues para n = 0 ya se demostró.


Ahora, para demostrar la corrección (exactitud) del algoritmo por contradicción, supongamos que existe al menos un entero positivo en el cual falla el algoritmo.

Sea n el menor de estos enteros. En primer lugar n >=5, pues ya está demostrado

cuadrado(n) = n2 para n < 5. En segundo lugar cuadrado(n-1) debe tener éxito,

porque en caso contrario n no sería el primer entero positivo en el cual falla.

Pero esto implica que el algoritmo también tiene éxito en n, por regla general.

Demostrar un algoritmo mediante inducción matemática

Lo anterior contradice nuestra suposición acerca de la selección de n.

Por lo tanto este n no puede existir, lo cual significa que el algoritmo tiene éxito para todos los enteros positivos, inclusive 0 que ya está probado.

Demostrar un algoritmo mediante inducción matemática

Algoritmos recursivos

Recursión

La recursión permite definir un objeto (problemas, estructuras de datos) en términos de sí mismo.

Ejemplos de recursión son las estructuras: Árboles, Listas enlazadas.

La representación de una recursión en forma gráfica se puede realizar por medio de un árbol recursivo.

Un procedimiento recursivo debe tener: Un criterio llamado criterio básico, por el que el

método no se llame a sí mismo, sino que llegue a una solución directa.

Cada vez que el método se llame a sí mismo (directa o indirectamente), debe estar más cerca del criterio base.

Una ecuación de recurrencia es aquella que define una secuencia recursiva; cada término de la secuencia es definido como una función de términos anteriores.

an = f (an−1, an−2, . . . )

Ejemplos: En Análisis de algoritmos, aparece la relación

T(n) = aT(n/b) + g(n) donde a>=1, b>=1 La “función logística”

xn+1 = r xn (1 − xn)

se usa para calcular modelos de crecimiento.

Ecuaciones de recurrencia

Sucesión de Fibonacci

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . .

Ecuaciones de Recurrencia

2

1;0

21

10

nparafff

ff

nnn

Recursividad - Ejemplos: Fibonacci

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . .

Ley de recurrencia (n término fibonacci)

f(n)=1 si n = 0, 1

f(n)=f(n-1)+f(n-2) si n>1

Recursividad - Ejemplos: Fibonacci

Clase cFibonacci Método fibonacci(numero) Si (numero=0) o (numero=1) entonces retornar 1 sino retornar fibonacci(numero-1) + fibonacci(numero-2) Fin si Fin MétodoFin Clase

Recursividad – Ejemplo: Factorial

n! = n (n-1) (n-2)........1

(n-1)! = (n-1) (n-2).......1

de donde:

Ley de recurrencia:

0! = 1 si n=0

n! = n (n-1)! si n>0

Algoritmo

Clase cFactorialMétodo calculaFactorial(num)

Si num = 0 then

retornar 1

sino

retornar num * calculaFactorial(num-1)

fin si

Fin Método

Fin Clase

Factorial (num-1) crea una réplica del subprograma con el nuevo parámetro.

Recursividad - Ejemplo

Fac(4)=4*Fac(3)

Fac(4)=4*(3*Fac(2))

Fac(4)=4*(3*(2*Fac(1)))

Fac(4)=4*(3*(2*(1*Fac(0))))

Fac(4)=4*(3*(2*(1*1)))

Fac(4)=4*(3*(2*1))

Fac(4)=4*(3*2)

Fac(4)=4*6=24

Tipos de Recursión

Recursión Directa: El subprograma se llama directamente a sí mismo.

Llamada a P

Sub Programa P

Tipos de Recursión

Recursión Indirecta El subprograma llama a otro subprograma, y éste a

su vez llama al primero ó de lo contrario a un tercero.

Llamada a QLlamada a Q

Llamada a PLlamada a P

Sub Programa P Llamada a QLlamada a Q

Llamada a VLlamada a V

Sub Programa P

Sub Programa Q

Sub Programa V

Sub Programa Q

Propiedades de la Recursión

Un procedimiento recursivo con criterio base y aproximación constante a este criterio base se dice que está bien definido.

Se dice profundidad recursiva al número de veces que se llama recursivamente un subprograma.

La representación en forma gráfica se puede realizar por medio de un árbol recursivo.

Un procedimiento recursivo con estas dos propiedades se dice que está bien definido.

Funcionamiento Interno de la Recursión

Valores a Almacenar:

Cuando un programa que llama a otro subprograma, debe guardarse varios elementos:

Debe guardarse los valores de los parámetros del subprograma que llama; para poder encontrarlos después que retorna el control a este subprograma.

Debe guardarse la dirección de la instrucción que se debe ejecutar a continuación del subprograma llamado, para retornar el control a esta instrucción.

Funcionamiento Interno de la Recursión

Pila Es una lista de elementos a la cual se le puede insertar

o eliminar elementos, sólo por uno de sus extremos. (LIFO)

Internamente se utiliza una estructura tipo pila, que guarda una copia de los valores de variables y constantes locales del subprograma que efectúa la llamada.

Además, se guarda una referencia a la siguiente instrucción a ejecutar.

Proceso de ejecución de un programa recursivo

El problema de Torres de Hanoi

Tenemos 3 torres y N discos de diferentes tamaños; cada uno con una perforación en el centro que le permite deslizarse por las torres.

Inicialmente los N discos están ordenados de mayor a menor en la primera de las torres.

Se debe pasar los discos a otra torre en el mismo orden, utilizando la tercera torre como auxiliar.

En cada movimiento sólo se puede mover un disco y no puede quedar uno de mayor tamaño sobre uno menor tamaño.

Torres de Hanoi con dos discos

Origen Destino Auxiliar

Torres de Hanoi con dos discos

Torres de Hanoi con tres discos


Clase CTorres viene-de Cobjeto

Atributos

nDiscos

Métodos

Hanoi(Origen, Destino, Auxiliar)

fClase

Método CTorres.Hanoi (Origen, Destino, Auxiliar)

Si (nDiscos = 1) entonces

Escribir(“Mover disco Origen a Destino”)

sino

Torres.Hanoi( Origen, Auxiliar, Destino)

Escribir(“Mover disco Origen a Destino”)

Torres.Hanoi( Auxiliar, Destino , Origen)

FMétodo


Concluimos que árbol recursivo nos permite calcular en función del # de hojas, cuantas llamadas recursivas se dan: 2n - 1

Árbol recursivo de Torres de Hanoi para n = 3

H(3,1,2,3)

H(2,3,2,1)

H(1,1,2,1)

H(2,1,3,2)

H(1,1,2,3)

H(1,3,1,2)H(1,2,3,1)

1-2 2-3 2-3 1-2 3-1 3-2 1-2

Recorrido de Árboles Binarios

La operación de recorrer un árbol binario se realiza de diversas maneras. El orden en el que se visitan los elementos puede variar. Debe la operación pasar exactamente una vez por cada uno de los

elementos del árbol.

Preorden: Visite la raíz, recorra en preorden el subárbol izquierdo y, recorra en preorden el subárbol derecho.

Inorden: Recorra en inorden el subárbol izquierdo, luego visite la raíz y, recorra en inorden el subárbol derecho.

Postorden: Recorra en postorden el subárbol izquierdo y luego el subárbol derecho en postorden y, visite la raíz.

Recorrido de Árboles Binarios

PreOrden: 1, 15, 5, 9, 17, 3, 2, 19, 23, 25

InOrden: 5, 15, 17, 9, 3, 1, 2, 19, 25, 23

PostOrden: 5, 17, 3, 9, 15, 25, 23, 19, 2, 1

1

15 2

5 9 19

17 3 23

25

Comparación Recursión vs. Iteración

Un programa recursivo crea una pila dinámica mientras atraviesa el árbol recursivo.

Un programa iterativo crear una pila explícita, nos permite definir cualquier programa recursivo en una forma no recursiva.

El programa resultante es más complicado y difícil de entender que la versión recursiva, y el ahorro de tiempo es mínimo.

Divide y vencerás

El término Divide y Vencerás en su acepción más amplia es una filosofía general para resolver problemas.

Por esta razón se utiliza en muchos otros ámbitos como la estrategia militar o la política.

En nuestro contexto utilizaremos ésta expresión para nombrar una técnica de diseño de algoritmos.

Esta técnica sirve para resolver un problema a partir de la solución de subproblemas del mismo tipo pero de menor tamaño.

Introducción

Divide y Vencerás

La resolución de un problema mediante esta técnica consta de los siguientes pasos: Plantearse el problema de forma que pueda

descomponerse en k subproblemas del mismo tipo, pero de menor tamaño. A ésta tarea se le conoce como división.

Resolver de manera sucesiva e independiente cada uno de estos subproblemas, bien directamente si son elementales (caso base) o bien de forma recursiva.

Combinar las soluciones obtenidas en el paso anterior para construir la solución del problema original.

Justificación del Divide y Vencerás

Para que se justifique divide y vencerás se necesitan tres condiciones. Tiene que ser posible descomponer el problema

en subproblemas y recomponer las soluciones parciales de forma bastante eficiente.

Los subproblemas deben ser en lo posible aproximadamente del mismo tamaño.

La decisión de utilizar el subalgoritmo básico en lugar de hacer llamadas recursivas debe tomarse cuidadosamente.

Esquema General

Consideremos un problema arbitrario, y sea caso un algoritmo sencillo capaz de resolver el problema.

Nos interesa que caso sea eficiente para casos pequeños, pero su rendimiento para casos grandes no nos interesa.

Se le llama subalgoritmo básico.

Esquema General

Clase Cclase

i,k: cardinal

S: TipoSolucion

subproblemas: Arreglo de TipoProblema

subsoluciones: Arreglo de TipoSolucion

Método CClase.DyV(x)

Si (x es caso base) entonces

S ResuelveCasoBase(x)

SinoK Divide(x, subproblemas)

Para i desde 1 hasta k hacer

subsoluciones[i] DyV(subproblemas[i])

fPara

Esquema General

S Combina (subsoluciones)

Retornar S

Fin Si

FinMétodo

Fin Clase

Esquema General

El número k de subproblemas debe ser independiente y pequeño de una entrada determinada, es decir no debe haber solapamiento entre ellos. De lo contrario el tiempo de ejecución será exponencial. La sucesión fibonacci es recursivo pero no es Divide y

Vencerás pues su tiempo de ejecución es exponencial. Cuando k = 1, no tiene sentido descomponer x en un

subproblema más sencillo x1. Lo que si tiene sentido es reducir la solución de un caso muy grande a la de uno más pequeño.

El tamaño de los k subproblemas es aproximadamente n/k para alguna constante k, en donde n es el tamaño del caso original.

Esquema General

Sea g(n) el tiempo requerido por DV en casos de tamaño n, sin contar el tiempo necesario para llamadas recursivas. El tiempo total t(n) requerido por este algoritmo de divide y vencerás es parecido a:

Siempre que n sea suficientemente grande.

)()(*)( ngkntknt

Algoritmos de simplificación

En el caso particular de los algoritmos Divide y Vencerás que contienen sólo una llamada recursiva, es decir k=1, hablaremos de algoritmos de simplificación. Ejemplo: Factorial Búsqueda binaria en un vector Hallar el k-ésimo elemento.

La ventaja de los algoritmos de simplificación es que consiguen reducir el tamaño del problema en cada paso, por lo que sus tiempos de ejecución suelen ser muy buenos (logarítmicos o lineal)

Estos algoritmos van a heredar las ventajas e inconvenientes que la recursión plantea: El diseño suele ser simple, claro, robusto y elegante. Mayor legibilidad y facilidad de depuración y

mantenimiento. Conllevan normalmente un mayor tiempo de ejecución

que los iterativos. Mayor complejidad espacial que puede representar el

uso de la pila de recursión.

Ventajas y desventajas

Clase BusquedaBinaria

Método BusBin (a, prim, ult, val ) Si (prim > ult) entonces

retornar ‘No encontrado’

Sino

mitad (prim + ult) div 2

Si (val = a[mitad])

retornar ‘Encontrado en ‘, mitad

Else

Ejemplo: Búsqueda binaria

Si (val < a[mitad]) entonces

BusBin(a, prim, mitad – 1, val)

Else

BusBin(a, mitad + 1, ult, val)

Fin si

Fin si

Fin si

Fin Metodo

Fin Clase

Ejemplo: Búsqueda binaria

Cap 03 - Induccion recursividad divide y venceras

Documents

Transcript of Cap 03 - Induccion recursividad divide y venceras