Tema 2 - Estructuras de Datos - Proceso de Creación de Un Algoritmo

ALGORITMICA
PARTE II: Creación de algoritmos
Eugenio Fco. Sánchez Úbeda

Cristina Puente Águeda
Universidad Pontificia Comillas
Estructuras de datos (I)
• No es el tema central de esta asignatura

– “formas de organizar los datos para procesarlos con un algoritmo”
• Estructuras básicas necesarias:

– Unidimensionales: arrays, listas enlazadas, pilas y colas
– Bidimensionales: árboles
+ operaciones básicas genéricas para manipular estas estructuras
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

-1
Estructuras de datos (II)
• Arrays
– Estructura básica fundamental
– Acceso directo (rápido)
– “Primitiva” en casi todos los lenguajes de programación
– Tradicionalmente estática (no se puede cambiar su tamaño de forma
dinámica, o es muy costoso)
1 size(vA)
vA:
vA(k) ó vA[k]
– Array de registros
• Cada elemento del array es un registro con varios campos
A[1] A[k] A[N]
clave

-2
Estructuras de datos (III)
• Listas enlazadas
– “Conjunto de elementos organizados secuencialmente”
– Dinámica (añadir y eliminar elementos sin problemas)
– Acceso secuencial (lento)
– No suele ser una “Primitiva” en casi ningún lenguaje de programación
cabeza(L) L
– Elemento básico:
• next(e) ó e.next
e • prev(e) ó e.prev (puede no existir)
• valor(e) ó e.valor
– Tipos de listas:
• Simples, doblemente enlazadas, circulares, ordenadas, ...
– Operaciones básicas:
• Insertar, sacar, buscar, borrar
-3
Estructuras de datos (IV)
• Listas enlazadas (ejemplo inserción) L = Insertar_Lista (L, x)
inicialmente: next(x) = next(nil(L));
prev(next(nil(L))) = x;
next(nil(L)) = x;
nil(L) 15 7 prev(x) = nil(L);
x 5
nil(L) 15 7 nil(L) 15 7
next(x) = next(nil(L)); next(nil(L)) = x;

5
prev(next(nil(L))) = x; 5 prev(x) = nil(L);
x x
Resultado final:
nil(L) 5 15 7

-4
Estructuras de datos (V)
• Pilas
– Dinámica LIFO
– Restricción importante en el acceso a los datos
• Menos operaciones, más portable
– Aplicaciones:
• Muchas, por ejemplo para almacenar resultados
intermedios en una operación: 2 * ((9+1) *(2+3) +50)
– Notación polaca inversa (calculadoras HP) Pila con un array P de 9 elementos:
pila
• Meter y sacar
3 7 5 8 9
Meter(P,4), Meter(P,2) :
– Implementación: ult imo(P)
pila
• Con listas enlazadas
• Con array (conocido el tamaño 3 7 5 8 9 4 2
máximo de la pila) Sacar(P): : ult imo(P)
pila
3 7 5 8 94 2
ult imo(P)
-5
Estructuras de datos (VI)
• Colas Caja@
– Dinámica FIFO
– Restricción importante en el acceso a los datos
• Menos operaciones, más portable
– Aplicaciones:
• Se usan menos que las pilas Cola implantada con array C de 9 elementos
Cola
• Insertar y sacar
8 5 4 7
– Implementación: pri mero(C) ult imo(C)
Insertar(C,9), Insertar(C,2), Insertar(C,3):
• Con listas enlazadas
• Con array (dado tño. máximo de la pila) 3 85 4 7 9 2
ult imo(C) pri mero(C)
Siguiente(C):
3 85 4 7 9 2
ult imo(C) pri mero(C)

-6
Estructuras de datos (VII)
• Árboles
– “Colección de vértices y arcos cumpliendo conjunto de requisitos”
• Un nodo (´vértice) es raíz
• Existe un único camino entre raíz y cualquier nodo
• Todo nodo tiene un padre (salvo el raíz)
– Terminología:
• padres, hijos, abuelos, tíos, ...
15
•
•
Raíz, terminales (hojas)
Altura, nivel
6 18
•
•
Subárbol, camino
Sucesor, antecesor
3 7 17 20
2 4 13
9
-7
Estructuras de datos (VIII)
• Árboles
– Tipos: binarios, n-arios (multicamino)
– Árbol vacío vs. completo (equilibrado)
15
– Los nodos terminales suelen ser distintos
6 18
(ficticios, sin hijos)
3 7 17 20
N IL N IL N IL N IL
2 4 N IL 13
N IL N IL N IL N IL N IL N IL
• Propiedades interesantes:
– Existe exactamente un único camino conectado 2 nodos en un árbol
– 2 nodos tienen al menos un ancestro común
– Un árbol con N nodos tiene N-1 arcos
– Un árbol binario con N nodos internos tiene N+1 terminales
– La altura de un árbol binario completo con N nodos internos es
aproximadamente log2(N)
-8
Estructuras de datos (IX)
• Árboles • Recorridos:
– Preorden: visitar 1º Padre, 2º Izq. y 3º Dcha.
– Se implementa sin recursividad con una pila
– Orden central (In order): visitar 1º Izq., 2º Padre y 3º Dcha.
– Es el más típico (usar pila para eliminar recursividad)
– Postorden: visitar 1º Izq. 2º Dcha. y 3º Padre
– Usar pila para evitar recursividad
– Por Niveles (Level-Order): arriba-abajo e Izq. a Dcha.
– Usar una cola
15 15 15
6 18 6 18 6 18
3 7 17 20 3 7 17 20 3 7 17 20
2 4 13 2 4 13 2 4 13
9 9 9
Pre-orden Orden cent ral Post -orden

15,6, 3,2,4, 7,13,9, 18,17,20 2,3, 4,6,7, 9,13,15, 17,18,20 2,4, 3,9,13, 7,6,17, 20,18,15
-9
Estructuras de datos (X)
• Árboles
– Representación
• Árboles binarios:
Cada nodo n:
rai z(T)
padre(n)
alt ura(T) clave(n)

hijo_izq(n) hijo_dcha(n)
• Árboles multicamino:
padre(n) raiz(T)
hermano(n)
hijo_izq(n)

- 10
2
Proceso de creación
- 11
Proceso de creación: idea (I)
• Finalidad última de un algoritmo: permitir solucionar un

problema
– Debe ser fácil de entender, codificar y depurar
– Uso eficiente de los recursos (tiempo y espacio)
• Fases típicas en la creación de soluciones informáticas

– Análisis del problema
– Diseño de la solución
– Implementación
Bla bla bla
...
Bueno sí, pero
realmente lo que
hay que hacer ....
Descripción del problema

a resolver (apuntes)
- 12
Proceso de creación: idea (II)
• Una vez especificado el problema a resolver

– Fase de creación del algoritmo
• Ciclo en espiral con cuatro etapas fundamentales
Descripción del problema a Descripción del problema

resolver (apuntes) • Formulación precisa
• En términos algorítmicos
Análisis resultados
• Uso de prototipos: • Exactitud Diseño del algoritmo
– Validar ideas iniciales, • Eficiencia
• Usar pseudocódigo
detectar errores de concepto
– Empezar con algoritmos
simples para determinar el Implementación prototipo
beneficio de posibles
• Probar la idea codificando el algoritmo
mejoras del mismo
- 13
Proceso de creación: diseño
• Fases típicas en la fase de diseño:

– Formular de forma informal el algoritmo
– Elegir la estructura de datos más conveniente para el
algoritmo
– Elegir el paradigma a seguir
– Perfilar el núcleo del algoritmo
– Añadir los detalles
– Controlar los casos especiales
– Revisar todo el algoritmo, usar ejemplos
– Optimizar de forma teórica (una vez que funciona)
– Estimar teóricamente el tiempo de ejecución y requisitos de
memoria

- 14
Proceso de creación: análisis (I)
• Qué mirar en el análisis

– Tiempos de ejecución y consumos de + A
memoria Memoria
– Casos especiales (robustez del algoritmo) B
-
– Posibles mejoras del algoritmo
Ideal
• Acelerarlo y/o reducir consumo C
- Tiempo CPU +

- 15
Proceso de creación: análisis (II)
• Es posible saber en qué puntos
se pierde más tiempo

- 16
Proceso de creación: implementación (I)
• Un programa es una representación concreta de un

algoritmo en un lenguaje de programación
• Los detalles de un lenguaje de programación específico se
deben obviar durante el diseño del algoritmo
– Es tan sólo un medio para expresar un algoritmo de forma que un
procesador lo pueda ejecutar
– Algunos lenguajes facilitan su programación mejor que otros
• Desde el punto de vista de los algoritmos, hay que prestar
especial atención en los lenguajes de programación:
– Estructura de los bucles (for, do, do-while, etc), valor del contador a
la salida, recorrido de matrices, ...
– Paso por valor / referencia
– Índices de vectores (empiezan en 0 ó en 1)
– Recursividad
– Funciones estándar (módulo, ordenación, ...)
- 17
Proceso de creación: implementación (II)
• Cada lenguaje tiene sus particularidades

• Alto nivel:
– Ej: Matlab
• Bajo Nivel:
– Ej: C
• Muy bajo nivel:

– Ensamblador

- 18
Proceso de creación: implementación (III)
• Ejemplo: recorrido de matrices

en Matlab
¿Por qué no tarda lo mismo? n xm

¿Es una diferencia en el
orden de crecimiento o es
una constante?
m xn

- 19
Técnicas de simplificación (I)
• Existen casos especiales que “ensucian y enmarañan” un

algoritmo inicialmente elegante
– Complican innecesariamente la algorítmica
– Son fuente de errores N1
N2 N3
N4 N5 N6
N7
• Ejemplos
– Existen elementos terminales en las estructuras que se usan
(inicio y fin normalmente)
– Naturaleza de la estructura (disposición ordenada de los
elementos, ...)
– Otras condiciones que no permiten tratar de igual forma todos los
elementos de la estructura
- 20
Ejemplo 1: Inserción directa (I)
• Idea Selecci ona

últ ima carta 7 Inserta en
posi ción correcta
2 4 9
mano
Cartas ya ordenadas
• Utilizando un vector de registros y ordenando sobre el
mismo (utilizando espacio auxiliar para un registro):
5 2 1 9 6 8
Es pac io d is ponible en
m em o r ia

- 21
Ejemplo 1: Inserción directa (II)
A = InserciónDirecta(A, N) %A vector de registros a ordenar, N: nº de registros
1 For i=2 to N
carta = A[i]; % selecciona última carta
j=i-1; %
busca punto de inserción
2 While (j>0 & carta < A[j]) % alternando comparaciones
A[j+1]=A[j]; % y movimientos
j=j-1;
end 2
A[j+1]=carta; % inserta la carta
end 1
Inserción directa
Seleccionar el
siguiente Búsqueda
Secuencia origen Secuencia destino

- 22
Ejemplo 2: ¿Es número primo?
• Problema
– Dado un número, ¿es primo?
• Idea
– Un número es primo si sólo es divisible por sí mismo y por la unidad
• El 9 no es primo porque 9/3 = 3. El 5 sí porque no es divisible entre 4,3,2
• Diseño del Algoritmo
– Planteamiento (algoritmo informal):
• “Para saber si el número n es primo hay que dividir sucesivamente el
número n por 2, 3, 4, ... hasta (n-1). En cuanto una división sea exacta,
ya se sabe que no es primo. Si no ocurre nunca, es primo.”
– Pseudocódigo:
Flag_es_primo = EsPrimo (n)
¿? ¿Existen formas de
optimizar el algoritmo?
Fin
- 23
Ejemplo 3: Horas de punta/llano/valle
• Problema
– Dada una curva de demanda para un día, determinar las horas de
punta, llano y valle (fijado el número que se quieren tener de cada
tipo) 33
31 13
11 12 14 15 16 17 18 19
29 10
9 20 21 22 23
Consumo
27
25 Horas de PUNTA 24
El consumo horario de 8
electricidad de un país tiene 23
un perfil muy característico. 21 1 7
Para cada día, dicho perfil 19 2 3 6
4 5
queda representado por 24 17
valores, uno para cada Horas de VALLE
15
hora. Por ejemplo, en el
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
array A y la gráfica asociada
se muestra el perfil de 1
Hora N
consumo de España para el A: 21.2 19.5 18.8 18.5 18.4 19 21.4 24.2 27.3 29.1 30.2 30.5 31.1 29.8 29.4 29.5 29.9 30.3 29.7 28 28.1 28.5 28.3 25.3
lunes 14 de junio de 2004
(ver www.ree.es). np=5
nv=7 Algoritmo pedido
nll =12
1 np 1 nv
HP: 13 12 18 11 17 HV: 5 4 3 6 2 1 7
[HP, HLL, HV]=HorasPLLV(A, np, nll, nv) 1 nll

HLL: 8 24 9 20 21 23 22 10 15 16 19 14

- 24
3
Paradigmas de diseño
- 25
Paradigmas
• Esquemas o modelos de diseño más o menos genéricos

• Muchos algoritmos utilizan alguno de los planteamientos
clásicos
– Conocerlos dan base para hacer desarrollos propios ...
• Paradigmas básicos clásicos:

– Fuerza bruta
– Divide y vencerás
– Voraz
– Paralelismo ...

- 26
Fuerza bruta
• Consiste en resolver el problema “rudamente”

– Probar sistemáticamente todas y una de las posibles soluciones al
problema y elegir
– La falta de habilidad o imaginación para mejorar el proceso es su
característica fundamental
• Se confía en la capacidad de cálculo del ordenador para
conseguir resolverlo
• Suele ser la primera versión del algoritmo, una cota superior
de “al menos se puede resolver en ...”
• Cuando usarlo:
– No se dispone de mucho tiempo para pensar (desarrollo rápido)
– Se ejecutará pocas veces

- 27
Fuerza bruta: ejemplo (I)
• ¿ Aparece el patrón P en el array A ?

1 N
A: 0 0 1 1 1 0 0 1 0 1 0 1 1 0 1 1 1 0 1
1 M
P: 0 1 1 0 1
• ¿Cuántos posibles encajes de P

no_existe = ExistePatron (A,N, P, M) en A hay que probar?
• ¿Cuál es el peor caso?
¿? • En el peor caso la versión de

fuerza bruta requiere del orden
de N • M
Fin • ¿cómo es dicha versión?
- 28
Fuerza bruta: ejemplo (II)
1 N
A: 0 0 1 1 1 0 1 0 1 1 0 1 1 1 0 1
• ¿ Aparece el patrón P en
M
el array A ?
1
P: 0 1 1 0 1
no_existe = ExistePatron (A,N, P, M)
i=2; i=5; i=13; El índice i se utiliza para
j=1 j=4 j=6 I=1; j=1; marcar qué “encaje” se está
Repeat probando (empieza en i=i-
0 0 1 1 1 0 1 0 1 1 0 1 1 1 0 1
1 if A(i) = P(j) j+2) y al mismo tiempo
comprobar las distintas
0 1 1 0 1 i=i+1; j=j+1;
posiciones del encaje (i=i+1)
0 1 1 0 1 Prueba fallida lenta Else
i = i-j+2; j=1;
0 1 1 0 1 Pruebas fallidas
rápidas (con una End 1
0 1 1 0 1 única comparación
se descartan estos Until ( j>M OR i>N);
3 encajes)
0 1 1 0 1 2 if j>M
0 1 1 0 1 no_existe = 0;
Else
0 1 1 0 1
no_existe = 1;
0 1 1 0 1 Finaliza End 2
búsqueda Fin
- 29
Divide y vencerás / Combina y vencerás (I)
• Consiste en:
– Dividir el problema en subproblemas, similares al original, pero de
tamaño menor.
– Se solucionan los problemas recursivamente. Si es suficientemente
pequeño se resuelve directamente.
– Se combinan esas soluciones para construir la solución al problema
original.
Problema Soluci ón
ori ginal fi nal
Subprobl emas Soluci ones

parci ales
• Existen muchos algoritmos basados en esta sencilla idea ...
- 30
Divide y vencerás / Combina y vencerás (II)
• Esquema general
sol = DivideyVenceras (problema)
1 if EsPequeño (problema)
sol = ResolverDirectamente (problema);
Else 1
[sub_problemas] = Divide (problema); % M subproblemas
2 For i = 1 to M
sol_parciales[i] = DivideyVenceras (sub_problemas[i]);
end 2
sol = Combinar (sol_parciales);
end 1
Fin
- 31
Divide y vencerás: ejemplo (I)
• Normalmente utiliza dos llamadas recursivas, típicamente

una para cada mitad
• Ejemplo:
– Dibujar una regla con las siguientes características:
• Dado un valor de n (por ejemplo n=4)
PintaMarca(8,n)
PintaMarca(4,n-1) n
n-1 n-1
n-2
Ojo, en los
extremos no
hay marca 2n
- 32
Divide y vencerás: ejemplo (II)
• Dibujar una regla
– Ejemplo con n = 7 (aparecen 126 marcas)
• El aspecto de la regla se repite recursivamente ...

- 33
Divide y vencerás: ejemplo (IV)
• Árbol de llamadas recursivas

– Ejemplo con n = 4 (aparecen 15 marcas)
– En cada nodo se representa iz, de y altura
0,16,4
0,8,3 8,16,3
0,4,2 4,8,2 8,12,2 12,16,2
0,2,1 2,4,1 4,6,1 6,8,1 8,10,1 10,12,1 12,14,1 14,16,1

- 34
Divide y vencerás: ejemplo (V)
PintaReglaICD (iz,de,a) %izq-cent-dcha
1 if a > 0
me = (iz +de)/2 ; % siempre es exacta
PintaReglaICD(iz,me,a-1);
PintaMarca(me,a);
PintaReglaICD(me,de,a-1);
end 1
Fin
0,16,4
0,8,3 8,16,3
0,4,2 4,8,2 8,12,2 12,16,2
0,2,1 2,4,1 4,6,1 6,8,1 8,10,1 10,12,1 12,14,1 14,16,1

- 35
Divide y vencerás: ejemplo (VI)
PintaReglaCID (iz,de,a) %cent-izq-dcha
1 if a > 0
me = (iz +de)/2 ; % siempre es exacta
PintaMarca(me,a);
PintaReglaCID(iz,me,a-1);
PintaReglaCID(me,de,a-1);
end 1
Fin
0,16,4
0,8,3 8,16,3
0,4,2 4,8,2 8,12,2 12,16,2
0,2,1 2,4,1 4,6,1 6,8,1 8,10,1 10,12,1 12,14,1 14,16,1

- 36
Divide y vencerás: ejemplo (VII)
Para saber más:

http://en.wikipedia.org/wiki/Mandelbrot_set
- 37
Algoritmo voraz (I)
• Producir un resultado “óptimo” a partir de un conjunto de

opciones candidatas
– Optimizar cierta medida o función objetivo
– Cumpliendo ciertas restricciones
• Hipótesis de partida:
– Al menos existe una solución óptima, si hay varias equivalentes
• Características de este enfoque:

– La solución se va formando poco a poco (incrementalmente)
• Se elige la mejor forma de incrementar la solución parcial eligiendo la
mejor opción candidata
• Una vez incrementada (mejorada) la solución parcial, no se puede
modificar eliminando elementos de la misma

- 38
Algoritmo voraz (II)
• Esquema general
sol = Voraz (candidatos)
sol = { };
1 while (candidatos  { } AND NoEsSolucion(sol) )
mejor = Seleccionar (candidatos);

candidatos = candidatos – {mejor};
2 if EsValida (sol  {mejor} )

sol = sol  {mejor} ;
end 2
end 1
Fin

- 39
Algoritmo voraz: ejemplo (I)
• Desglose de un importe
– Dado un importe, desglosarlo en el menor número de billetes y
monedas posible
– Útil en una máquina que tenga que devolver cambio (por ej. una
expendedora de billetes de metro)
• Se plantea utilizando un par de vectores:
1 N
• El vector de valores val: 50 20 10 5 2 1
de monedas está Desglose del importe
según las monedas con
ordenado de + a - importe: 123 los valores val,
minimizando el número
• Se supone que el de monedas
Devuelve el vector de
importe se puede
1 N cantidades (con el
desglosar número de monedas de
perfectamente cant: 2 1 0 0 1 1 cada tipo)

- 40
Algoritmo voraz: ejemplo (II)
• El desglose del dinero se puede plantear como un algoritmo

voraz ya que:
– Conjunto de candidatos
• Cada una de las monedas disponibles
– Solución posible
• Conjunto de monedas tal que sumen el importe a desglosar
– Condición de factibilidad (EsValida)
• En todo momento la suma de las monedas tiene que ser menor o igual al
importe
– Función de selección
• Elegir, mientras sea posible, la moneda de valor mayor de entre las
candidatas
– Función objetivo
• Minimizar el número de monedas

- 41
Algoritmo voraz: ejemplo (III)
• Desglose de un importe, tres posibles enfoques:
cant = DesgloseVersion1 (importe, val, N) cant = DesgloseVersion2 (importe, val, N)
cant = ceros (N); % inicializa a ceros cant = ceros (N); % inicializa a ceros
i=1; i=1;
1 while (i  N & importe > 0) 1 while (i  N & importe > 0)
2 if (val(i)  importe) 2 while (val(i)  importe)
cant(i) = cant(i) + 1; cant(i) = cant(i) + 1;
importe = importe - val(i); importe = importe - val(i);
else 2 end 2
i = i + 1; i = i + 1;
end 2 end 1
end 1 Fin
cant = DesgloseVersion3 (importe, val, N)
Fin
cant = ceros (N); % inicializa a ceros
i=1;
• ¿Son teóricamente
1 while (i  N & importe > 0) equivalentes en cuanto a
cant(i) = floor (importe / val(i)); tiempo de ejecución?
importe = mod (importe, val(i));
i = i + 1; • Desde el punto de vista
end 1 práctico ¿existirán
Fin diferencias?
- 42
Algoritmo voraz: ejemplo (IV)
• Desglose de un importe
DesgloseVersion1
El tiempo de ejecución es
lineal con el importe a
desglosar en las tres
versiones (asintóticamente DesgloseVersion2
equivalentes), pero las
constantes reales son
claramente diferentes
DesgloseVersion3

- 43

Tema 2 - Estructuras de Datos - Proceso de Creación de Un Algoritmo

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 2 - Estructuras de Datos - Proceso de Creación de Un Algoritmo

Cargado por

Copyright:

Formatos disponibles

ALGORITMICA

PARTE II: Creación de algoritmos

Eugenio Fco. Sánchez Úbeda

• No es el tema central de esta asignatura

• Estructuras básicas necesarias:

+ operaciones básicas genéricas para manipular estas estructuras

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

next(x) = next(nil(L)); next(nil(L)) = x;

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

Pre-orden Orden cent ral Post -orden

alt ura(T) clave(n)

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Finalidad última de un algoritmo: permitir solucionar un

• Fases típicas en la creación de soluciones informáticas

Descripción del problema

• Una vez especificado el problema a resolver

Descripción del problema a Descripción del problema

• Fases típicas en la fase de diseño:

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Qué mirar en el análisis

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Un programa es una representación concreta de un

• Cada lenguaje tiene sus particularidades

• Muy bajo nivel:

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Ejemplo: recorrido de matrices

¿Por qué no tarda lo mismo? n xm

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Existen casos especiales que “ensucian y enmarañan” un

• Idea Selecci ona

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

Secuencia origen Secuencia destino

[HP, HLL, HV]=HorasPLLV(A, np, nll, nv) 1 nll

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Esquemas o modelos de diseño más o menos genéricos

• Paradigmas básicos clásicos:

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Consiste en resolver el problema “rudamente”

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• ¿ Aparece el patrón P en el array A ?

• ¿Cuántos posibles encajes de P

• ¿Cuál es el peor caso?

¿? • En el peor caso la versión de

Subprobl emas Soluci ones

[sub_problemas] = Divide (problema); % M subproblemas

sol = Combinar (sol_parciales);

• Normalmente utiliza dos llamadas recursivas, típicamente

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

• Árbol de llamadas recursivas

0,4,2 4,8,2 8,12,2 12,16,2

0,2,1 2,4,1 4,6,1 6,8,1 8,10,1 10,12,1 12,14,1 14,16,1

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

0,4,2 4,8,2 8,12,2 12,16,2

0,2,1 2,4,1 4,6,1 6,8,1 8,10,1 10,12,1 12,14,1 14,16,1

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

0,4,2 4,8,2 8,12,2 12,16,2

0,2,1 2,4,1 4,6,1 6,8,1 8,10,1 10,12,1 12,14,1 14,16,1

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA

Para saber más:

• Producir un resultado “óptimo” a partir de un conjunto de