Analisis de Tecnicas Algoritmicas

5 Metodologa y Tecnologa de la Programacin II
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Fuerza Bruta
Fuerza Bruta
f La tcnica de FUERZA BRUTA es la que se utiliza para
resolver un problema siguiendo la estrategia ms obvia de
solucin.
f Generalmente suele comportar ms operaciones de las
necesarias para resolver el problema, por lo suelen tener un
coste bastante alto.
f Por el contrario, suelen ser bastante sencillos de
implementar.
f Suelen utilizarse para problemas de tamaos pequeos.
f Algunos ejemplos de algoritmos por fuerza bruta son:
El algoritmo de bsqueda lineal.
El algoritmo ordenacin por el mtodo de seleccin.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Bsqueda Binaria
Ejemplo
Bsqueda Binaria
f Ya vimos una funcin en C++ para buscar un nmero en un
vector de enteros de tamao n:
f El algoritmo utiliza la fuerza bruta para buscar el nmero
mirando uno por uno todos los elementos del vector, incluso
si el vector estuviese ordenado.
f Tambin vimos que el coste de este algoritmo es O(n).
f Aunque no es la forma ptima de buscar un elemento en un
vector ordenado, cuando el tamao del vector es pequeo
resulta bastante rpido.
int buscar(const int a[n], int x){
for (int i=0; i<n; i++){
if (a[i]==x) return i;
}
return -1;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Ordenacin por Insercin
Ejemplo
f La siguiente funcin es una implementacin en C++ del
algoritmo de ordenacin por Insercin
void ordenacion_insercion(int a[],int n){
int aux;
for(int i=1;i<n;i++){
aux=a[i];
for(j=i-1;j>=0;j--){
if(aux>array[j]){
array[j+1]=aux;
break;
}
else array[j+1]=array[j];
}
if(j==-1) array[0]=aux;
}
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Ejemplo
f Este algoritmo divide el vector en dos partes, una con
elementos ya ordenados y la otra con elementos todava sin
ordenar.
f Inicialmente la parte ordenada est vaca y la que no est
ordenada contiene todos los nmeros.
f El algoritmo utiliza la fuerza bruta para ir tomando uno por
uno los elementos de la parte ordenada y los va insertado en
la parte ordenada en el lugar que les corresponde.
f Resulta sencillo comprobar que este algoritmo tiene un coste
temporal O(n
2
).
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo de
Ejemplo de
6 3 9 5
i=1
i
aux 3 6 9 5
i
9 aux
i=3
6 3 9 5
i=1
i
3 aux
j
3 6 9 5
i
5 aux
i=3
j
6 6 9 5
i
3 aux
j
i=1 3 6 9 9
i
5 aux
i=3
j
3 6 9 5
i
3 aux
i=2 3 6 6 9
i
5 aux
i=3
j
3 6 9 5
i
9 aux
i=2
j
3 5 6 9
i
5 aux
i=3
j
Parte ordenada Parte desordenada
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Divide y Vencers
Divide y Vencers
f La tcnica de DIVIDE Y VENCERS consiste bsicamente
en descomponer el problema inicial en varios subproblemas
del mismo tipo pero ms sencillos, resolver los subproblemas
y combinar sus soluciones para obtener la solucin del
problema inicial.
f A su vez, para resolver cada uno de los subproblemas puede
volver a aplicarse la tcnica de divide y vencers
recursivamente para descomponerlo en otros subproblemas
de menor complejidad, y as hasta que los subproblemas
obtenidos tengan una solucin trivial.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Genrico de
Divide y Vencers
Algoritmo Genrico de
Divide y Vencers
Donde: n es el tamao del problema,
n
0
es el umbral de tamao por debajo del cual el problema es trivial
n
i
son los tamaos de los subproblemas en que se descompone el
problema inicial.
s
i
son las soluciones de los subproblemas de tamao n
i
s es la solucin del problema inicial.
funcion divide_venceras(n)
si n<n
0
s=resolver(n)
si_no
[n
1
,,n
k
]=descomponer(n)
desde i=1 hasta k hacer s
i
=divide_venceras(n
i
)
s=combinar(s1,,sk)
fin_si
devolver s
fin_funcion
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Condiciones Necesarias para
Aplicar Divide y Vencers
f Los problemas resolubles mediante la tcnica de divide y
vencers tienen que cumplir una serie de condiciones:
Es necesario que el problema admita una formulacin
recursiva.
El problema inicial debe poder resolverse mediante la
combinacin de las soluciones de los subproblemas.
Los subproblemas deben ser del mismo tipo que el
problema inicial pero con un tamao estrictamente menor.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Condiciones Deseables para
Condiciones Deseables para
f Adems de las condiciones anteriores, si queremos que el
algoritmo sea eficiente, debemos exigir las condiciones:
El tamao de los subproblemas debe ser los ms
parecido posible y debe decrecer en progresin
geomtrica, es decir, debe ser n/c con c>0 una constante.
Nunca se debe resolver un mismo subproblema ms de
una vez
Las operaciones de descomponer y de combinar deben
costar poco.
Hay que evitar generar nuevas llamadas cuando el
tamao de los subproblemas es suficientemente
pequeo. Por tanto, hay que elegir bien el umbral n
0
.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste del Algoritmo
Divide y Venceras
Coste del Algoritmo
Divide y Venceras
f Suponiendo que la funcin de descomposicin origina k
subproblemas de tamao n/c, el coste del algoritmo divide y
vencers es la suma de
El tiempo que tarda en descomponer el problema inicial
t
d
(n)
El tiempo que tarda en resolver los k suproblemas en que
se divide el problema original
kt(n/c)
El tiempo que tarda en combinar las soluciones de los
subproblemas
t
c
(n)
es decir
t(n) = kt(n/c) + t
d
(n) + t
c
(n)
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste del Algoritmo
Divide y Venceras
Coste del Algoritmo
Divide y Venceras
f Si la descomposicin y la combinacin no son
excesivamente costosas, tendrn a lo sumo un coste
polinmico, es decir
t(n) = kt(n/c) + O(n
i
)
f Por tanto la solucin a esta ecuacin recursiva depender de
k, c e i:
Si k<c
i
entonces t(n) O(n
i
).
Si k=c
i
entonces t(n) O(n
i
log n).
Si k>c
i
entonces t(n) O(n
log
c
k
).
f As pues, la utilizacin de divide y vencers no garantiza
nada acerca de la eficiencia del algoritmo obtenido. Puede
suceder que el coste empeore, se mantenga o mejore
respecto al de un algoritmo iterativo para el mismo problema.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplos de Divide y Vencers
Ejemplos de Divide y Vencers
f Algunos algoritmos conocidos que utilizan la tcnica de
divide y vencers son:
El algoritmo de Karatsuba y Ofman para la multiplicacin
de enteros grande.
El algoritmo de Strassen para el producto de matrices.
El algoritmo de bsqueda binaria.
El algoritmo de ordenacin rpida Quicksort.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Bsqueda Binaria
Ejemplo
Bsqueda Binaria
f La siguiente funcin es una implementacin en C++ de la
bsqueda binaria recursiva de un elemento en un vector
ordenado
int busqueda_binaria(int x,const int a[],int i,int j){
int k;
if (i>j) return -1;
else{
k=(i+j)/2;
if (a[k]==x) return k;
else
if(a[k]>x) return busqueda_binaria(x,a,i,k-1);
else return busqueda_binaria(x,a,k+1,j);
}
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo de Bsqueda Binaria
Ejemplo de Bsqueda Binaria
2 3 5 9 12 18 25 32 37 41 48 50
i=7 j=12
a
busqueda_binaria(25,a,7,12)
(i+j)/2=9
32>18
2 3 5 9 12 18 25 32 37 41 48 50
(i+j)/2=i=7 j=8
a
25<37
2 3 5 9 12 18 25 32 37 41 48 50
i=1 j=12
a
(i+j)/2=6
25=25
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste de la Bsqueda Binaria
Coste de la Bsqueda Binaria
f En la bsqueda binaria, el problema principal se
descompone en 1 subproblema de tamao n/2. Por otro lado,
el coste de la descomposicin y la combinacin de
soluciones es constante, as que el coste total es
t(n) = t(n/2) + O(1)
Resolviendo la ecuacin recursiva tenemos
f Por tanto, el algoritmo de busqueda binaria es ms eficiente
que el de bsqueda lineal.
) (log ) 1 ( O log 1
) 1 ( O log ) 1 ( ) 1 ( O log ) 2 / (
) 1 ( O ) 1 ( O ) 4 / ( ) 1 ( O ) 2 / ( ) (
2
2 2
log
2
n O n
n t n n t
n t n t n t
n
+ =
= + = + =
= + + = + = L
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Multiplicacin de Enteros Grandes
Ejemplo
f Todos conocemos el algoritmo para multiplicar enteros que
nos ensearon en el colegio
f El coste de este algoritmo es O(n
2
).
f Se pueden multiplicar dos enteros con un conste menor?
x
* * * * * *
* * * * * * * *
* * * * * * * *
* * * * * * * *
* * * * * * * *
* * * * * * * *
* * * * * * * *
* * * * * * * *
n
2
* * * * * * * * * * * * *
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
mediante Divide y Vencers
mediante Divide y Vencers
f Supongamos que queremos multiplicar dos enteros x e y de
tamao n expresados en una base i.
f Se comprueba fcilmente que
xy = ac i
n
+ (ad+bc) i
n/2
+ bd
y de esta forma, se puede calcular xy mediante 4 productos
entre enteros de tamao n/2.
f El coste que se obtiene es t(n) = 4t(n/2) + O(n)
a b
c d
n/2 n/2
n dgitos
x
y
x=ai
n/2
+b
y=ci
n/2
+d
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Calculo del Coste de la
f Resolviendo la ecuacin mediante deplegado tenemos
t(n)
n
t(n/2)
t(n/2) t(n/2) t(n/2)
=
n/2
t(n/4)t(n/4)t(n/4)t(n/4)
=
n/2
t(n/4)t(n/4)t(n/4)t(n/4)
=
n/2
t(n/4)t(n/4)t(n/4)t(n/4)
=
n/2
t(n/4)t(n/4)t(n/4)t(n/4)
=

A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Resolviendo la ecuacin mediante deplegado tenemos

n
n/2
n/4 n/4 n/4 n/4
n/2
n/4 n/4 n/4 n/4
n/2
n/4 n/4 n/4 n/4
n/2
n/4 n/4 n/4 n/4

111111111111111111111111111111111111111111111111
log
2
n
= 16n/4
= 4n/2
= 1n
= 4
i
n/2
i
= 4
log
2
n
n/2
log
2
n
Nivel
4
i
copias de n/2
i
0
1
2
i
+
+
+
+
=
n
i
i i
n
2
log
0
2 / 4
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Mejora del Algoritmo de
Mejora del Algoritmo de
f As pues, tenemos un coste total
de modo que este algoritmo, a pesar de aplicar la tcnica de
divide y vencers no es ms eficiente que el anterior.
f Se puede construir un algoritmo mediante divide y vencers
ms eficiente que el anterior?
f Karatsuba y Ofman desarrollaron un algoritmo ms eficiente
a partir de la misma descomposicin anterior pero
basndose en la propiedad
xy = ac i
n
+ ((a-b)(d-c)+ac+bd) i
n/2
+ bd
f De este modo, slo se realizan 3 productos de enteros de
tamao n/2.
f El coste de este algorimo es t(n) = 3t(n/2) + O(n) O(n
1.57
)
) ( O 2 2 ) 2 / 4 ( 2 / 4 2 / 4 ) (
2 2 log
log
0
log
0
log
0
log
0
2
2 2 2 2
n n n n n n n n t
n
n
i
i
n
i
i
n
i
i i
n
i
i i
= = = = = =

= = = =
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
(Karatsuba y Ofman)
(Karatsuba y Ofman)
f Suponiendo que x e y son enteros de n dgitos, el algoritmo
de Karatsuba y Ofman puede escribirse as
f Para que el algoritmo sea ms eficiente debe fijarse el
umbral en n
0
=500 dgitos.
funcion productoK&O(enterogrande x,enterogrande y)
si n=1 devolver xy
si_no
(a,b)=descomponer(x)
(c,d)=descomponer(y)
ac=productoK&O(a,c)
bd=productoK&O(b,d)
abdc=productoK&O(a-b,d-c)
devolver ac*i
n
+ (abdc+ac+bd)*i
n
/2 + bd
fin_si
fin_funcion
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmos Voraces
Algoritmos Voraces
f La tcnica VORAZ consiste en resolver un problema de
manera gradual tomando decisiones o realizando acciones
que permiten ir construyendo progresivamente la solucin
del problema.
f Con cada decisin tomada se obtiene una solucin parcial
del problema y se reduce la dimensionalidad del mismo.
f Suele utilizarse en problemas de optimizacin.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Aplicar la Tcnica Voraz
Aplicar la Tcnica Voraz
f Debe existir un funcin que hay que maximizar o minimizar
conocida como FUNCIN OBJETIVO.
f La funcin objetivo depende de varias variables que toman
valores en un conjunto conocido como DOMINIO.
f Existe una funcin, conocida como FUNCIN SOLUCIN,
que permite saber si unos determinados valores de las
variables son o no solucin del problema. La asignacin de
un valor a una variable se denomina DECISIN.
f Existe un conjunto de restricciones que deben satisfacer los
valores de las variables de la funcin objetivo y existe una
funcin para saber si las decisiones tomadas hasta el
momento satisfacen o no las restricciones. Esta funcin se
suele llamar FACTIBLE, y el conjunto de decisiones factibles
tomadas hasta el momento se llama SOLUCIN EN
CURSO.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Funcionamiento de la
Tcnica Voraz
Funcionamiento de la
Tcnica Voraz
f La tcnica voraz intenta resolver el problema fijando
progresivamente los valores de las variables de la funcin
objetivo, sin violar las restricciones, hasta llegar al mximo o
mnimo de funcin.
f En cada paso se determina el valor de una de las variables
an no fijada mediante una FUNCIN DE SELECCIN. En
cada instante, la funcin de seleccin siempre toma la
decisin factible que es localmente ptima, es decir, la que
hace que la funcin objetivo tome el mejor valor posible
hasta el momento, sin intentar averiguar si forma parte de la
solucin ptima global.
f Una de las caractersticas que diferencian a la tcnica voraz
de otras que estudiaremos despus es que nunca
reconsidera una decisin tomada!
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Genrico Voraz
Algoritmo Genrico Voraz
f Suponiendo que el dominio de las variables de la funcin
objetivo fuese C, podemos expresar el algoritmo voraz as:
funcion voraz(conjunto_candidatos c)
s=
mientras(no solucion(s) no vacio(c))
x=seleccion(c)
c=c-{x}
si factible(s{x}) entonces s=s{x}
fin_mientras
si solucion(s) entonces devoler s
si_no devolver
fin_funcion
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste Temporal del Algoritmo Voraz
Coste Temporal del Algoritmo Voraz
f El coste de un algoritmo voraz depende de dos factores:
El nmero de iteraciones del bucle, que depende del
tamao de la solucin construida y del tamao del
conjunto de candidatos.
El coste de las funciones seleccion y factible.
La funcin factible suele tener un coste constante,
pero la funcin seleccion ha de explorar el conjunto de
candidatos y depende de su tamao.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ventajas e Inconvenientes de los
Algoritmos Voraces
Ventajas e Inconvenientes de los
Algoritmos Voraces
f La principal ventaja de los algoritmos voraces es que suelen
ser bastante eficientes.
f Sin embargo, puesto que siempre toman decisiones
localmente ptimas y no reconsideran nunca las decisiones
tomadas, no garantizan que se obtenga la solucin ptima
del problema, ni siquiera que se obtenga una solucin, an
cuando dicha solucin exista.
f Esto es debido a que las decisiones localmente ptimas no
garantizan la obtencin de la solucin ptima global.
f Los problemas resolubles mediante la tcnica voraz, deben
cumplir el principio de optimalidad:
Una secuencia ptima de decisiones, toda subsecuencia ha
de ser tambin ptima.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplos de Algoritmos Voraces
Ejemplos de Algoritmos Voraces
f Algunos problemas conocidos que pueden resolverse
mediante la tcnica voraz son:
El problema del cambio en monedas.
El problema de los cdigos de Huffman.
El problema de los tiempos de espera mnimos.
El problema de la mochila.
El problema de los caminos mnimos en grafos.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
El Problema del Cambio de Monedas
f Dado un conjunto C de monedas de n tipos, se trata de
encontrar el nmero mnimo de monedas que sumen una
cantidad x.
f Este problema satisface el principio de optimalidad, ya que
puede demostrarse que si se tiene una solucin ptima
S={e
1
,,e
k
} para el problema de sumar una cantidad x,
entonces, S-{e
i
} tambin es la solucin ptima para sumar la
cantidad x-e
i
.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Elementos del Algoritmo Voraz
f Funcin objetivo: El nmero de monedas, que hay que
minimizar.
f Dominio o conjunto de candidatos: El conjunto C formado por
todas las monedas de que disponemos.
f Funcin solucin: S={e
1
,,e
k
} es solucin si
i
e
i
= x.
f Funcin factible: S={e
1
,,e
k
} es factible si
i
e
i
x.
f Funcin seleccin: Elegir si es posible la moneda de mayor
valor de C.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Voraz
Algoritmo Voraz
f El siguiente algoritmo implementado en C++ utiliza la tcnica
voraz para resolver el problema del cambio de monedas:
bool cambio(int x,const int valor[n],int solucion[n]){
for (int i=0;i<n;i++) solucion[i]=0;
int i=0, suma=0;
while (suma<x && i<n)
if (suma+valor[i]<=x){
solucion[i]++;
suma+=valor[i];}
else
i++;
if (suma==x) return true;
else{
for (int i=0;i<n;i++) solucion[i]=0;
return false;}
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Optimalidad
Optimalidad
f El algoritmo anterior no siempre proporciona la solucin
ptima.
f Ejemplo. Si tenemos 5 monedas de valores
valor[5]={50,25,20,5,1} y queremos sumar x=42, el
algoritmo nos dara la solucin s[5]={0,1,0,3,2}, es
decir, 6 monedas, mientras que la solucin ptima es
s[5]={0,0,2,0,2}, que son 4 monedas.
f Adems, en caso de que C no contenga la moneda unidad,
ni siquiera se garantiza que el problema tenga la solucin.
f Para que el algoritmo alcance la solucin ptima es
necesario que C est formado por tipos de monedas que
sean potencia de un tipo bsico t (por ejemplo,
C={125,25,5,1}). En este caso, el problema se reduce a
encontrar la descomposicin de x en base t, que es nica y
mnima.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste Temporal
Coste Temporal
f Para que la funcin de seleccin de la funcin cambio
funcione adecuadamente, el vector de valores de las
monedas debe estar ordenado en orden decreciente.
f El coste de este algoritmo es de O(max(nlog n, m)) donde n
es el nmero de tipos de monedas de C, y m es el nmero
de iteraciones que realiza el bucle.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
El Problema de la Mochila
El Problema de la Mochila
f Se dispone de una coleccin de n objetos o
1
,,o
n
, cada uno
de ellos con un peso p
i
y un valor v
i
asociados.
f Por otro lado se tiene una mochila capaz de soportar un
peso mximo p
max
.
f El problema consiste en maximizar el valor de los objetos
que se introduzcan en la mochila sin sobrepasar p
max
.
f Dependiendo de si los objetos se pueden fraccionar o no,
existen dos variantes del problema:
Mochila fraccionada: Los objetos se pueden fraccionar,
es decir se puede colocar en la mochila trozos de objetos.
Mochila entera: Los objetos no se pueden fraccionar y
por tanto deben ir enteros en la mochila.
f Ambas versiones satisfacen el principio de optimalidad pero
slo el primero puede resolverse con la tcnica voraz.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Problema de la Mochila Fraccionada
f Puesto que los objetos se pueden fraccionar, llamaremos x
i
al la fraccin del objeto o
i
que colocamos en la mochila.
f Funcin objetivo: El valor de los objetos introducidos en la
mochila
i
x
i
v
i
, que hay que maximizar.
f Dominio o conjunto de candidatos: La coleccin de objetos C
que queremos introducir en la mochila.
f Funcin solucin: S={x
1
,,x
k
} es solucin si
i
x
i
p
i
= p
max
.
f Funcin factible: S={x
1
,,x
k
} es factible si
i
x
i
p
i
p
max
.
f Funcin seleccin: Existen varias estrategias posibles
Seleccionar los objetos en orden decreciente de valor.
Seleccionar los objetos en orden creciente de peso.
Seleccionar los objetos por orden decreciente de relacin
valor/peso. (Slo esta conduce a la solucin ptima).
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Voraz
Algoritmo Voraz
f El siguiente algoritmo implementado en C++ utiliza la tcnica
voraz para resolver el problema de la mochila fraccionada:
float mochila(float v[n],float p[n],float x[n],float
pmax){
struct objeto{
float coste;
int posicion;
};
objeto vp[n];
for (int i=0;i<n;i++){
vp[i].coste=v[i]/p[i];
vp[i].posicion=i;
x[i]=0;}
ordenar_decreciente_coste(vp)
float peso=0, valor=0;
int i=0, j;
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Voraz (continuacin)
Algoritmo Voraz (continuacin)
while (peso<=pmax && i<n){
j=vp[i].posicion;
si (peso+p[j]<=pmax){
x[j]=1;
valor+=v[j];
peso+=p[j];
} else {
x[j]=(pmax-peso)/p[j];
valor+=v[j]*x[j];
peso=pmax;
}
i++;
}
return valor;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste Temporal
Coste Temporal
f El tamao del problema es el nmero de objetos n.
f El primer bucle realiza n iteraciones y el coste de su cuerpo
es constante, de modo que el coste total del bucle es O(n).
f El coste de la funcin de ordenacin decreciente de los
objetos por valor/peso es el coste del algoritmo de
ordenacin utilizado ( en el mejor caso O(n log n)).
f El segundo bucle realiza, a lo sumo n iteraciones, y el coste
de su cuerpo es constante, de manera que el coste total del
bucle tambin es O(n).
f Por tanto, el coste total del algoritmo es
O(n) + O(n log n) + O(n) = O(n log n).
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Programacin Dinmica
Programacin Dinmica
f Con la tcnica de divide y vencers, la descomposicin
natural de un problema puede originar subproblemas que se
solapen, de manera que al resolverlos independientemente
se acabe resolviendo el mismo problema mltiples veces.
f La tcnica de PROGRAMACIN DINMICA es similar a la
de divide y vencers, slo que los subproblemas obtenidos
slo se resuelven una vez. Esto exige guardar la solucin de
cada subproblema para, si se presenta de nuevo, no tener
que volver a resolverlo.
Se sacrifica espacio para ganar tiempo de ejecucin!
f Es una tcnica ascendente, que se inicia con la resolucin
de subproblemas ms pequeos, y utiliza sus soluciones en
la resolucin de los subproblemas de niveles superiores.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Los Nmeros de Fibonacci
Ejemplo
f La sucesin de Fibonacci viene dada por la expresin
f El programa resultante utilizando divide y vencers es:
f En la resolucin se repiten llamadas recursivas:
<
+
=
. 2 si
; 2 si
) 2 ( ) 1 (
1
) (
n
n
n- f n- f
n f
long int fibonacci(int n){
if (n<2) return 1;
else return fibonacci(n-2)+fibonacci(n-1);
}
f(n)
f(n-1) f(n-2)
f(n-2) f(n-3) f(n-3) f(n-4)
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
con Programacin Dinmica
con Programacin Dinmica
f Resulta sencillo evitar la repeticin de llamadas recursivas
utilizando el siguiente esquema:
f La siguiente funcin en C++ calcular la sucesin de
Fibonacci hasta el trnimo n con programacin dinamica:
f El coste de este algoritmo es O(n) frente a O(2
n
) del anterior.
f(n) f(n-1) f(n-2) f(n-3) f(n-4)
int * fibonacci(int f[n]){ // Se supone n>2
f[0]=0;
f[1]=1;
for (int i=2;i<n;i++)
f[i]=f[i-1]+f[i-2];
return f;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Caractersticas de la
Programacin Dinmica
Caractersticas de la
Programacin Dinmica
f La descomposicin en subproblemas suele hacerse de
acuerdo al principio de optimalidad.
f La estructura de datos donde se van guardando las
soluciones de los subproblemas resueltos suele ser una
tabla.
f La mayor dificultad de esta tcnica consiste en determinar el
orden en que se deber rellenar la tabla. Para resolver un
subproblema, previamente deben estar almacenadas todas
las soluciones necesarias.
f La programacin dinmica supone un compromiso entre el
coste espacial y el coste temporal. Si para reducir un poco el
coste temporal se requiere un excesivo coste espacial,
puede no ser una buena tcnica.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplos de
Programacin Dinmica
Ejemplos de
Programacin Dinmica
mediante programacin dinmica son:
El clculo de los nmeros de Fibonacci.
El clculo de nmeros combinatorios.
El problema de la mochila entera.
El problema de los caminos mnimos en grafos.
La multiplicacin de una secuencia de matrices.
El problema del viajante.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
El Problema de la Mochila Entera
f Ya vimos un algoritmo voraz para resolver el problema de la
mochila fraccionaria, sin embargo, la tcnica voraz no
garantiza la obtencin de la solucin ptima cuando los
objetos no se pueden fraccionar.
f Ejemplo. Si tenemos 3 objetos con valores v
1
=18, v
2
=20 y
v
3
=12, y pesos p
1
=6, p
2
=4 y p
3
=2, y el peso mximo de la
mochila es pmax=10, entonces el algoritmo voraz calcula la
solucin (x
1
=0, x
2
=1, x
3
=1) que tiene un valor 32, mientras
que la solucin ptima es (x
1
=1, x
2
=1, x
3
=0) que tiene un
valor 38.
f Veremos cmo la programacin dinmica si permite llegar a
la solucin ptima.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Si llamamos f(n,p
max
) al valor de la mochila en la solucin
ptima, aplicando el principio de optimalidad, se tiene
f El algoritmo recursivo que implementa directamente la
funcin anterior tiene un coste exponencial O(2
n
).
f Sin embargo, el nmero total de subproblemas a resolver no
es tan grande, ya que el primer parmetro de f puede oscilar
entre 1 y n, y el segundo entre 0 y p
max
, en total n(p
max
+1).
f As pues, hay subproblemas que se repiten! Podemos
utilizar una tabla para almacenar los subproblemas resueltos,
en la que en la posicin (i,j) se almacene el valor de f(i,j).
n
n
n n
p p n
p p n
p p n
p p n
v p p n f p n f
p n f
v
p n f
>
< >
=
< =
=
max
max
1 max
1 max
max max
max
1
max
y 1 si
y 1 si
y 1 si
y 1 si
) ) , 1 ( ), , 1 ( max(
) , 1 (
0
) , (
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Programacin Dinmica
f La siguiente funcin implementada en C++ calcula la tabla
de subproblemas con programacin dinmica:
void tabla_f(int n,int v[n],int p[n],int pmax,
int f[n][pmax]){
for (int j=0;j<=pmax;j++)
if (j<p[0]) f[0][j]=0;
else f[0][j]=v[0];
for (int i=1;i<n;i++)
for (int j=0;j<=pmax;j++)
if (j<p[i]) f[i][j]=f[i-1][j];
else
if (f[i-1][j]>f[i-1][j-p[i]]+v[i])
f[i][j]=f[i-1][j];
else f[i][j]=f[i-1][j-p[i]]+v[i];
return;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Ejemplo
f Supongamos que tenemos 5 objetos con pesos
p[0]=5, p[1]=4, p[2]=2, p[3]=3, p[4]=4,
y valores
v[0]=20, v[1]=15, v[2]=10, v[3]=12, v[4]=14,
entonces, si el peso mximo de la mochila es 10, la funcin
anterior generara la siguiente tabla:
Peso 0 1 2 3 4 5 6 7 8 9 10
Objeto 0 0 0 0 0 0 20 20 20 20 20 20
Objeto 1 0 0 0 0 15 20 20 20 20 35 35
Objeto 2 0 0 10 10 15 20 25 30 30 35 35
Objeto 3 0 0 10 12 15 22 25 30 32 37 42
Objeto 4 0 0 10 12 15 22 25 30 32 37 42
Valor mximo de la mochila
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f El valor mximo de la mochila ser f[n,pmax].
f Por otro lado, los objetos incluidos en la mochila en la
solucin ptima pueden obtenerse mediante la funcin
void objetos(int n,int v[n],int p[n],int pmax,
int f[n][pmax],int sol[n]){
for (int i=n-1;i>0;i--)
if (p[i]>pmax) sol[i]=0;
else
if (f[i-1][pmax-p[i]]+v[i]>f[i-1][pmax]){
sol[i]=1;
pmax-=p[i];
} else sol[i]=0;
if (p[0]<pmax) sol[0]=1;
else sol[0]=0;
return;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste Temporal
Coste Temporal
f Cada componente de la tabla se calcula en un tiempo
constante, luego la construccin de la tabla es O(np
max
).
f Por otro lado, la funcin que determina los objetos
introducidos en la mochila a partir de la tabla, slo tiene un
bucle que recorre todos los objetos para ver si estn o no
dentro de la mochila. Como el cuerpo del bucle tiene un
coste constante, su coste es O(n).
f As pues, el coste total es O(np
max
) + O(n) = O(np
max
).
f Se observa que si p
max
es muy grande (p
max
n) sera un
coste cuadrtico o superior, por lo que no sera muy
eficiente.
f Por ltimo, hay que notar que si los pesos no fuesen enteros,
el algoritmo no valdra.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
El Problema del Viajante
f Un viajante tiene que recorrer n ciudades y regresar a la
ciudad de partida, sin pasar dos veces por la misma ciudad.
f Se supone que los caminos son unidireccionales y se conoce
la distancia de cada camino.
f Cul es recorrido que debe seguir para que sea lo ms
corto posible?
?
%
%
%
%
6
4
3
2
5
2
4
6
5
3
0
1
2
3
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Modelizacin Mediante Grafos
f Si representamos cada ciudad mediante un nodo de un grafo
y cada camino como una arista dirigida, tendremos un grafo
dirigido G=(V,A) donde
V={1,,n} es el conjunto de vrtices (ciudades).
A es el conjunto de aristas (i,j) con i,j V (caminos).
D(i,j) es la longitud de (i,j) si (i,j) A, o si (i,j) A.
f Se trata de un problema de bsqueda en un grafo del ciclo
Hamiltoniano de longitud mnima.
4 5 2 3
6 6 2 2
4 5 1
3 3 0
3 2 1 0 De\A
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Suponiendo que la ciudad de partida es la 0, si llamamos
C(i,W) a la longitud del camino mnimo de i a 0 que pasa por
todos los vrtices de W V, siendo 0W, entonces
f Como la ciudad de partida es la 0, la solucin al problema
ser C(0,V-{0}).
f Se cumple el principio de optimalidad.
+
=
=
W j W j C j i D
W i D
W i C
W j
si })) { , ( ) , ( ( min
si ) 0 , (
) , (
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Recursivo (Fuerza Bruta)
f La siguiente funcin en C++ implementa la funcin anterior
de manera recursiva
float c(int n,int i,const conjunto &w,float **d){
conjunto cw(w);
cw.eliminar(i);
if (cw.vacio()) return d[i][0];
float dist,dmin=DMAX;
for(int j=0;j<n;j++)
if (cw.pertenece(j)){
dist=d[i][j]+c(n,j,cw,d);
if (dist<dmin) dmin=dist;
}
return dmin;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Siendo la interfaz de la clase conjunto la siguiente
f Y DMAX una constante con un valor alto para simular .
class conjunto{
private:
int numel; // Cardinal del conjunto universal
bool elementos[]; // Vector de pertenencia a conjunto
public:
conjunto(int n); // Inicializa al conjunto vacio
conjunto(const conjunto &a); // Constructor de copia
void aniadir(int i);// Aade el elemento i
void eliminar(int i);// Elimina el elemento i
bool pertenece(int i); // Pertenencia de i
int cardinal(); // Cardinal del conjunto
bool vacio(); // Comprueba si el conjunto est vacio
};
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste del Algoritmo de Fuerza Bruta
Coste del Algoritmo de Fuerza Bruta
f Esta funcin estudia todos los posibles caminos por fuerza
bruta
f El coste es O(n!).
0
1
3 2
0 0
2 3
15
6
2
4
2
4
2
3 1
0 0
1 3

2
5
5
6 6
3
2 1
0 0
1 2
14 18
4
2
6
5
5 4
3

3
Origen
1 visita
2 visita
3 visita
Destino
Distancia
R
e
c
o
r
r
i
d
o
Min
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Mejora de la eficiencia
Mejora de la eficiencia
f La funcin anterior repite llamadas para calcular C(i,W), y
por tanto es ineficiente.
f Utilizando la tcnica de programacin dinmica, podemos
guardar los valores de C(i,W) en una tabla para evitar repetir
su clculo.
f Para indexar la tabla en la segunda dimensin, asignaremos
un cdigo nico a cada subconjunto W para identificarlo.
f Puesto que el nmero de ciudades es n, el nmero de
posibles subconjuntos es 2
n
. Si representamos cada
subconjunto mediante un vector
entonces, id(W) = x
0
2
0
+ x
1
2
1
++ x
n-1
2
n-1
asigna un cdigo
nico a cada subconjunto.
= =

w i
w i
x x x W
i n
si 1
si 0
con ] ,..., [
1 0
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f La siguiente funcin en C++ calcula la distancia mnima
utilizando programacin dinmica
float dist_min(int n,int i,const conjunto &w,
float **d,float **c){
conjunto cw(w); cw.eliminar(i);
if (cw.vacio()) return d[i][0];
if (c[i][cw.id()]>0) return c[i][cw.id()];
float dist,dmin=DMAX;
if (cw.pertenece(j)){
dist=d[i][j]+dist_min(n,j,cw,d,c);
if (dist<dmin) dmin=dist;
}
c[i][cw.id()]=dmin;
return dmin;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Construccin de la Tabla
Construccin de la Tabla
f Para el ejemplo anterior, con D(i,j)
la tabla de distancias mnimas resultante C(i,W) es
4 5 2 3
6 6 2 2
4 5 1
3 3 0
3 2 1 0 De\A
i \ W 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 14 -1
1 -1 -1 -1 -1 6 -1 -1 -1

-1 -1 -1 12 -1 -1 -1
2 -1 -1 11 -1 -1 -1 -1 -1 8 -1 16 -1 -1 -1 -1 -1
3 -1 -1 10 -1 6 -1 11 -1 -1 -1 -1 -1 -1 -1 -1 -1
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste de la Programacin Dinmica
Coste de la Programacin Dinmica
f El coste del algoritmo para completar la tabla C(i,W) supone:
Clculo de C(i,) para i=1,,n-1: n-1 consultas a tabla;
Clculo de C(i,W) para 1 k = Cardinal(W) n-2:
Clculo C(0,V): n-1 sumas.
f En total
que, aunque es exponencial, es de orden menor que O(n!).
f El precio de esta mejora es el coste espacial de la tabla
C(i,W) que es (n2
n
).
sumas; k
k
n
n
|
.
|
\
|

2
) 1 (
) 2 (
2
) 1 ( ) 1 ( 2
2
2
1
n
n
k
n
k
n
k n n =
|
.
|
\
|
|
.
|
\
|

+

=
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Itinerario del Recorrido Mnimo
f El itinerario del recorrido mnimo podemos calcularlo a partir
de la tabla C(i,W) mediante la siguiente funcin
void camino_min(int n,conjunto &w,float **d,
float **c,int *camino){
float dist,dmin; int jmin;
for (int i=1;i<n;i++){
dmin=DMAX;
if (w.pertenece(j)){
w.eliminar(j);
dist=d[camino[i-1]][j]+c[j][w.id()];
w.aniadir(j);
if (dist<dmin) {dmin=dist; jmin=j;}
}
camino[i]=jmin; w.eliminar(jmin)}
return;}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Para el ejemplo, la funcin anterior devuelve el itinerario
camino[4]={0,1,2,3}, es decir
Que efectivamente es el camino de mnima longitud!
%
%
%
%
6
4
3
2
5
2
4
6
5
3
0
1
2
3
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Vuelta Atrs (Backtracking)
Vuelta Atrs (Backtracking)
f La tcnica de VUELTA ATRS es parecida a la tcnica
devoradora en que resuelve un problema de manera gradual
tomando decisiones o realizando acciones que permiten ir
construyendo progresivamente la solucin del problema. Sin
embargo, a diferencia de la tcnica devoradora, las
decisiones tomadas pueden volverse a reconsiderar si no se
llega una solucin aceptable u ptima.
f Bsicamente, esta tcnica comienza a resolver el problema
buscando todas las soluciones posibles, como lo hace la
tcnica de fuerza bruta, pero cuando detecta que una
solucin parcial no puede llegar a ser ptima, la rechaza y no
construye ms soluciones a partir de ella.
f Se suele aplicar tambin a problemas de decisin u
optimizacin con o sin restricciones, cuando no existe un
criterio ptimo de toma de decisiones locales.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Recordemos los Elementos de un
Problema de Decisin
Recordemos los Elementos de un
Problema de Decisin
f FUNCIN OBJETIVO, que hay que minimizar o maximizar y
depende de las variables x
1
, , x
n
.
f DOMINIO, que contiene el conjunto de valores que pueden
tomar las variables.
f FUNCIN SOLUCIN, que permite saber si unos
determinados valores de las variables son o no solucin del
problema.
f DECISIN, que es la asignacin de un valor a una variable.
f RESTRICCIONES, que son las condiciones que deben
cumplir las soluciones.
f FUNCIN FACTIBLE, que permite saber si una solucin
cumple o no las restricciones.
f SOLUCIN EN CURSO, que es el conjunto de decisiones
factibles tomadas hasta el momento.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Espacio de Bsqueda
Espacio de Bsqueda
f La solucin del problema puede expresarse como una tupla
(x
1
,,x
n
) con x
i
C
i
, siendo C
i
el dominio de x
i
.
f As pues, el nmero total de posibles soluciones es
siendo k
i
el nmero de elementos de C
i
.
f El conjunto de todas las posibles soluciones se conoce como
ESPACIO DE BSQUEDA y se representa como un rbol
=
n
i
i
k
1
x
11
x
21
1 decisin
2 decisin
n decisin
R
e
c
o
r
r
i
d
o

e
n

p
r
o
f
u
n
d
i
d
a
d
x
22
x
2k2
x
n1
x
n2
x
nkn
x
12
x
21
x
22
x
2k2
x
21
x
22
x
2k2
x
1k1
...
x
n1
x
n2
x
nkn
... ... ...
...
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Recorrido en Profundidad del
Espacio de Bsqueda
Recorrido en Profundidad del
Espacio de Bsqueda
f Las soluciones se construyen partiendo de la raz del
espacio de bsqueda y tomando decisiones realizando un
recorrido en profundidad del mismo.
f Se dice una solucin en curso es COMPLETABLE si a partir
de ella se puede alcanzar la solucin del problema.
f Mientras que la tcnica de fuerza bruta recorrera todo el
espacio de bsqueda, lo que supondra un coste
exponencial, la tcnica de vuelta atrs, cuando llega a una
solucin no completable, da marcha atrs y busca por otro
camino del espacio de bsqueda, evitando as recorrer todo
el subrbol que queda por debajo de dicha solucin no
completable.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Diferentes Versiones de
Algoritmos con Vuelta Atrs
Diferentes Versiones de
Algoritmos con Vuelta Atrs
f Dependiendo del tipo de problema que tengamos que
resolver existen diferentes formas de aplicar la vuelta atrs:
Vuelta atrs para una solucin: El algoritmo recorre el
espacio de bsqueda hasta que encuentra la primera
solucin. Es el ms sencillo.
Vuelta atrs para todas las soluciones: El algoritmo
recorre el espacio de bsqueda guardando todas las
soluciones que encuentra hasta que ya no haya ms.
Vuelta atrs para la mejor solucin: El algoritmo
recorre el espacio de bsqueda comparando cada
solucin que encuentra con la mejor solucin obtenida
hasta el momento, y quedndose con la mejor. Cuando
ya no hay ms soluciones, devuelve la mejor encontrada.
Suele aplicarse a problemas de optimizacin.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algortmo Genrico con Vuelta
Atrs para Todas las Soluciones
Algortmo Genrico con Vuelta
Atrs para Todas las Soluciones
f El siguiente algoritmo calcula todas las soluciones de un
problema con la tcnica de vuelta atrs
funcion vuelta_atras(entero i,sol[n])
para_todo x en Ci
sol[i]=x
si completable(sol,i) entonces
si solucion(sol) entonces
guardar(sol)
fin_si
si (i<k) entonces
vuelta_atras(i+1,sol)
fin_si
fin_si
fin_para_todo
fin_funcion
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Poda del Espacio de Bsqueda
Poda del Espacio de Bsqueda
f El algoritmo anterior no genera el espacio de bsqueda de
forma explcita, sino implcitamente mediante llamadas
recursivas.
f Cuando se llega a una solucin en curso no completable, no
se realizan ms llamadas recursivas y por tanto no se
construye el subrbol correspondiente del espacio de
bsqueda. Esto se conoce como PODA del espacio de
bsqueda.
f La poda es un mecanismo que permite descartar del
recorrido ciertas zonas del espacio de bsqueda, bien
porque all no haya soluciones, bien porque ninguna de las
soluciones de esas zonas es la ptima.
f Cuanto mayor sea el nmero de nodos podados, ms
eficiente ser la bsqueda de soluciones.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coste Temporal del Algoritmo de
Vuelta Atrs
Coste Temporal del Algoritmo de
Vuelta Atrs
f El coste temporal de un algoritmo que utilice la tcnica de
vuelta atrs, suele depender de:
El nmero de nodos del espacio de bsqueda que se
visitan v(n).
El coste de las funciones solucion y completable en
cada nodo p(n).
En total O(p(n)v(n)).
f Si se consigue que la funcin completable pode muchos
nodos, el tamao de v(n) se puede reducir drsticamente:
Si se reduce a un solo nodo (solucin voraz) tendremos
un coste O(p(n)n).
Por el contrario, en el peor de los casos (solucin por
fuerza bruta), tendremos un coste O(p(n)k
n
).
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplos de Vuelta Atrs
Ejemplos de Vuelta Atrs
mediante la tcnica de vuelta atrs:
El problema de las ocho reinas.
La suma de subconjuntos.
El problema de la mochila entera.
El problema del coloreado de grafos.
La bsqueda de ciclos Hamiltonianos en grafos.
El recorrido de un laberinto.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
El Problema del Coloreado de
Grafos
El Problema del Coloreado de
Grafos
f Se dispone de un grafo G y de k colores. Es posible
colorear los vrtices de G de manera que no haya dos
vrtices adyacentes con el mismo color?
f Otro famoso problema reducible a este es el del coloredado
de mapas. Puede pintarse un mapa de manera que no
haya dos regiones adyacentes con el mismo color, utilizando
k colores?
f Cada regin se representa como un vrtice del grafo y si dos
regiones son adyacentes, sus respectivos vrtices de
conectan con una arista.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coloreado de Grafos
Espacio de Bsqueda
Coloreado de Grafos
Espacio de Bsqueda
f Si el grafo tiene n vrtices, representaremos el color de cada
vrtice en un vector color[n]={c
1
,,c
n
} siendo, c
i
{1,,k}
el color del vrtice i.
f El espacio de bsqueda asociado tiene k
n
posibles
soluciones. Por ejemplo, para n=3 y k=3 se tiene el siguiente
espacio de bsqueda con 27 posibles soluciones.
1
1
er
vrtice
2 vrtice
3
er
vrtice
1
2 1 3
2
2 1 3
3
2 1 3
2
1
2 1 3
2
2 1 3
3
2 1 3
3
1
2 1 3
2
2 1 3
3
2 1 3
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coloreado de Grafos
Algoritmo con Vuelta Atrs
Coloreado de Grafos
f La siguiente funcin en C++ resuelve el problema del
coloreado de grafos con la tcnica de vuelta atrs:
void colorea(int n,int k,bool **ady,int color[],int i){
for (int j=0;j<k;j++){
color[i]=j;
if (completable(ady,color,i))
if (i==n-1) imprimir(n,color);
else colorea(n,k,ady,color,i+1);
}
return;
}
bool completable(bool **adj,int color[],int i){
int j=0;
for (int j=0;j<i;j++)
if (adj[j][i] && color[j]==color[i]) return false;
return true;}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Coloreado de Grafos
Ejemplo
Coloreado de Grafos
Ejemplo
f Aplicando la funcin anterior al mapa de 5 regiones
con 3 colores 0, 1 y 2, se obtienen seis posibles soluciones
0 1
4 3
2
|
|
|
|
|
.
|
\
|
=
0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0
Ady
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Genrico con Vuelta
Atrs para la Mejor Solucin
Algoritmo Genrico con Vuelta
Atrs para la Mejor Solucin
f El siguiente algoritmo calcula la mejor solucin de un
problema de optimizacin con la tcnica de vuelta atrs
funcion vuelta_atras(entero i,sol[n])
para_todo x en Ci hacer
sol[i]=x
si completable(sol,i)coste(sol,i)<mcoste entonces
mejor_solucion=sol
mcoste=coste(sol,i)
fin_si
si (i<k) entonces
vuelta_atras(i+1,sol)
fin_si
fin_si
fin_para_todo
fin_funcion
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Poda Basada en la Mejor Solucin
f Cuando estemos ante un problema de optimizacin, el
objetivo del algoritmo es recorrer el espacio de bsqueda
para encontrar la mejor solucin.
f En este caso, adems de la poda que realiza la funcin
completable, podemos realizar otra poda basada en el
coste de la mejor solucin en curso.
f La idea es que una solucin en curso se poda, cuando, a
pesar de ser completable, no es posible conseguir una
solucin mejor que la mejor solucin en curso, an cuando
se genere todo el subrbol del espacio de bqueda que
cuelga de ella (coste(sol,i)mejorcoste).
f Como antes, esta poda es ms efectiva cuantos ms nodos
consiga eliminar.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Espacio de Bsqueda
Espacio de Bsqueda
f El problema de la mochila entera tambin puede resolverse
mediante la tcnica de vuelta atrs.
f Si tenemos n objetos y representamos el contenido de la
mochila con un vector sol[n]={x
1
,,x
n
} donde
entonces el espacio de bsqueda asociado es
=
mochila la en est objeto el si 1
mochila la en est no objeto el si 0
i
i
x
i
Objeto 1
Objeto 2
Objeto n
0 1
0 1
... ... ...
0 1
0 1
0 1
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Puesto que se trata de un problema de optimizacin,
aplicaremos tambin la poda basada en la mejor solucin en
curso.
f Para ello resulta til disponer de una funcin cota(sol,i) que
calcule una cota superior del valor de la mochila en las
soluciones que pueden obtenerse a partir de la solucin en
curso.
f Con esta funcin, cada vez que cota(sol,i) < maxval, siendo
maxval el mximo valor de la mochila encontrado hasta el
momento (al comienzo maxval=0), podaremos el subrbol
del espacio de bsqueda que cuelgue de dicha solucin en
curso y haremos la vuelta atrs.
f En nuestro caso, esta cota puede obtenerse mediante el
algoritmo voraz para el problema de la mochila fraccionada.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f La siguiente funcin en C++ resuelve el problema de la
mochila entera con la tcnica de vuelta atrs:
void llenar(int sol[],float valact,float pesoact,
int mejorsol[],float &maxval,int i){
float tval,tpeso;
for (int j=1;j>=0;j--){
sol[i]=j;
tval=valact+j*valor[i]; tpeso=pesoact-j*peso[i];
if (tpeso>=0 && maxval<cotaval(tempval,tpeso,i+1)){
if (i<n-1)
fillup(sol,tval,tpeso,mejorsol,maxval,i+1);
else {maxvalue=tempvalue; copiar(sol,bestsol);}
}
}
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Funcin Cota del Valor Mximo
Funcin Cota del Valor Mximo
f Siendo n (nmero de objetos) valor[] (valor de los
objetos) y peso[] (peso de los objetos) variables globales, y
siendo la funcin cotaval la siguiente:
f Para que esta funcin trabaje correctamente, es necesario
que los objetos estn ordenados de manera decreciente por
valor/peso.
f Adems, no es necesario que los pesos sean enteros como
ocurra con la programacin dinmica.
float cotaval(float val,float pesomax,int i){
for (int j=i;j<n;j++)
if (peso[j]>pesomax)
return val+pesomax/peso[j]*valor[j];
else {val+=valor[j]; pesomax-=peso[j];}
return val;
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Ejemplo
f Si hay 5 objetos de valores valor[]={30,40,60,10,20}
y pesos peso[]={6,10,20,5,15}, entonces la funcin
realiza el siguiente recorrido del espacio de bsqueda
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
Objeto 0
Objeto 1
Objeto 3
1
1
1 0
1 0 1 0
0
1 0
1 0 1 0
0
1
1 0
1 0 1 0
0
1 0
1 0 1 0
Objeto 2
Objeto 4
p=6,v=30
p=10,v=40
p=20,v=60
p=5,v=10
p=15,v=20
maxval 80 90 100

A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Mejoras de la Vuelta Atrs
Mejoras de la Vuelta Atrs
f Una posible mejora sera comenzar buscando una solucin
factible por algn procedimiento rpido, e inicializar el valor
de la mejor solucin con el valor de dicha solucin. De esta
manera, la poda basada en mejor solucin comenzara a
funcionar antes.
f Otra posible mejora consiste en guardar para cada variable
x
i
la lista de los valores de su dominio C
i
:
Cada vez que se asigna un valor a una variable, se
eliminan de todas las variables no asignadas los valores
incompatibles con la asignacin. Esto reduce el espacio
de bsqueda aunque tambin supone un coste.
Si a alguna variable no le quedan valores posibles,
entonces no es posible la solucin y se hace vuelta atrs.
f Tambin est la posibilidad de considerar rboles con
recorrido dinmico para los espacios de bsqueda.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ramificacin y Poda
(Branch & Bound)
Ramificacin y Poda
(Branch & Bound)
f La tcnica de RAMIFICACIN Y PODA es bsicamente una
mejora de la tcnica de vuelta atrs que se basa en un
recorrido dinmico ms eficiente del espacio de bsqueda.
f La principal diferencia es que, mientras que la tcnica de
vuelta atrs realiza un recorrido ciego del espacio de
bsqueda, la tcnica de ramificacin y poda realiza un
recorrido informado.
f En un recorrido ciego, bien sea en profundidad o en
anchura, se conoce perfectamente el siguiente nodo a visitar
(siguiente hijo o hermano del nodo actual), es decir, el orden
del recorrido est establecido a priori, mientras que en un
recorrido informado, se busca el siguiente nodo ms
prometedor en base a la informacin de que se disponga.
f Se aplica fundamentalmente a problemas de optimizacin
con restricciones, donde el espacio de bsqueda es un rbol.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Nodos Prometedores
Nodos Prometedores
f Diremos que un nodo del espacio de bsqueda es
PROMETEDOR, si la informacin que tenemos de ese nodo
en el recorrido indica que expandindolo se puede conseguir
una solucin mejor que la mejor solucin obtenida hasta el
momento.
f Esta informacin puede provenir de la evaluacin del camino
ya recorrido hasta el nodo, o bien de la evaluacin de los
caminos quedan por recorrer desde el nodo a posibles
soluciones.
f Para guiar la bsqueda es fundamental disponer de una
funcin que, no slo diga si un nodo es o no prometedor,
sino que adems estime lo prometedor que es.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Caracterizacin del Espacio de
Bsqueda en Ramificacin y Poda
Caracterizacin del Espacio de
Bsqueda en Ramificacin y Poda
f El espacio de bsqueda se representa mediante un rbol en
el que hay tres clases de nodos:
Nodo vivo: Es un nodo hasta el cual la solucin en curso
es factible, prometedora, y del que no se han generado
an todos sus hijos (no se ha completado la solucin).
Indican caminos abiertos de bsqueda.
Nodo muerto: Es un nodo del que no van a generarse
ms hijos porque, o bien ya se han generado todos sus
hijos, o bien no es factible, o bien no es prometedor.
Indican caminos cerrados de bsqueda.
Nodo en expansin: Es aquel del que se estn
generando sus hijos en un determinado instante.
f En un determinado instante de la bsqueda puede haber
muchos nodos vivos y muertos pero slo uno en expansin.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Funcionamiento de la Bsqueda en
Ramificacin y Poda
Funcionamiento de la Bsqueda en
Ramificacin y Poda
f En la tcnica de vuelta atrs, cada vez que se generaba un
hijo del nodo en expansin, este pasaba inmediatamente a
ser el nodo en expansin. En consecuencia, los nicos
nodos vivos son los que estn en el camino de la raz al
nodo en expansin.
f Por el contrario, en la tcnica de ramificacin y poda se
generan todos los hijos del nodo en expansin antes de que
cualquier otro nodo vivo pase a ser el nuevo nodo en
expansin.
Esto supone que puede haber nodos vivos en distintos
caminos y tendremos que guardar la lista de nodos vivos en
alguna estructura de datos (suelen ser pilas o colas).
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Estrategias de Bsqueda
Estrategias de Bsqueda
f Existen diferentes estrategias para elegir el siguiente nodo
en expansin de la lista de nodos vivos:
Ms antiguo. Se elige como nodo en expansin el ms
antiguo de la lista. En este caso la lista se implementa
como una cola. Produce un recorrido en anchura.
Menos antiguo. Se elige como nodo en expansin el
menos antiguo de la lista. En este caso la lista se
implementa como una pila. Produce un recorrido en
profundidad.
Ms prometedor. Se elige como nodo de expansin el
nodo ms prometedor de la lista. La lista se implementa
como una cola con prioridades, donde la prioridad de un
nodo es lo prometedor que es. Produce un recorrido
informado y es el que suele utilizar la tcnica de
ramificacin y poda!
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo Genrico con
Ramificacin y Poda
Ramificacin y Poda
f El siguiente algoritmo calcula la mejor solucin de un
problema de optimizacin con ramificacin y poda:
funcion ramificacion_y_poda()
inicializar(C); insertar(C,<sol,0,prioridad(sol,0)>)
mientras no_vacia(C) hacer
<sol,k>=primero(C)
para_todo x en C
k
hacer
sol[k]=x
si completable(sol,k)coste(sol,k)<mcoste entonces
mejor_solucion=sol; mcoste=coste(sol,k)
si_no insertar(C,<sol,k+1,prioridad(sol,k+1)>)
fin_si
fin_para_todo
fin_mientras
devolver (mejor_solucion, mcoste)
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ramificacin y Poda
Ramificacin y Poda
f En el algoritmo anterior se tiene que:
C es una cola con prioridades, es decir, sus elementos
estn ordenados de acuerdo a sus prioridades.
prioridad(sol,k) es una funcin que devuelve la
prioridad de un nodo vivo, que ser lo prometedor que es.
Esta funcin sirve para dirigir la bsqueda y llegar pronto
a la solucin ptima.
La condicin completable(sol,k) sirve para realizar
una poda cuando la solucin no es factible, mientras que
la condicin coste(sol,k)<mcoste sirve para realizar
una poda basada en la mejor solucin. En ambos casos
el nodo correspondiente se convierte en un nodo muerto.
f Habitualmente la funcin de prioridad tambin suele ser la
funcin de coste.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ramificacin y Poda
Coste Temporal
Ramificacin y Poda
Coste Temporal
f El coste temporal de un algoritmo que utilice la tcnica de
ramificacin y poda, depende fundamentalmente de:
El nmero de nodos del espacio de bsqueda que se
visitan v(n). Que depende a su vez de lo buenas que
sean las funciones completable y coste para hacer
podas, y lo buena que sea la funcin prioridad para
dirigir la bsqueda.
El coste de las funciones prioridad, completable y
coste en cada nodo p(n).
El coste del mantenimiento de la cola con prioridad.
En total O(p(n)v(n)), donde v(n) suele ser d
n
con d= max |C
k
|.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Mejora con Ramificacin y Poda
Mejora con Ramificacin y Poda
f Se puede mejorar la solucin dada al problema de la mochila
entera con la tcnica de vuelta atrs, si, adems de las
podas que realizaba esta, se dirige la bsqueda con la
funcin de prioridad.
f Tomando como funcin de prioridad la misma funcin que la
que calculaba una cota superior del valor de la mochila para
cada nodo del espacio de bsqueda, se expandirn primero
los nodos que tengan una cota mayor, y que probablemente
llevarn a una solucin con un valor de la mochila mayor.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Estructura de un Nodo
Estructura de un Nodo
f Cada nodo del espacio de bsqueda debe contener la
informacin necesaria para generar sus hijos o para decidir
si es solucin o no puede serlo.
f Utilizaremos la siguiente estructura de datos en C++:
Los valores de pes y val podran calcularse sin necesidad
de almacenarlos pero es ms eficiente pasarlos a los hijos.
Esto se conoce como MARCAJE.
class nodo{
private:
int numel; // Nmero total de objetos
int *sol; // Vector solucin
int actual; // Objeto hasta el que se han tomado decisiones
float pes; // Peso restante de la mochila
float val; // Valor de la mochila
float prio; // Prioridad del nodo
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Funcin de Coste y Prioridad
Funcin de Coste y Prioridad
f La siguiente funcin en C++ se utiliza como funcin de coste
parar la poda y tambin como funcin de prioridad para
dirigir la bsqueda
float cotavalor(nodo *x){
nodo *sig;
int i=x->etapa();
if (i>=x->numobjetos() || x->peso()==0) return x->valor();
else if (weight[i]>x->peso())
return x->valor()+x->peso()/weight[i]*value[i];
else {
sig=new nodo(*x);
sig->suma_valor(value[i]);
sig->resta_peso(weight[i]);
sig->sig_etapa();
return val_bound(sig);
}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Algoritmo con Ramificacin y Poda
f La siguiente funcin en C++ resuelve el problema de la
mochila entera con la tcnica de ramificacin y poda:
nodo* rellenar(int n,float pesomax){
priority_queue<nodo*,vector<nodo*>,mayor_pri> c;
nodo raiz(n,pesomax);
nodo *hijo,*nodoexp,*solucion;
c.push(&raiz); solucion=&raiz;
while (!c.empty()){
nodoexp=c.top();
c.pop();
if (nodoexp->prioridad()>=solucion->valor())
for (int j=1;j>=0;j--){
hijo=new nodo(*nodoexp);
hijo->fija_objeto(j);
hijo->suma_valor(j*value[hijo->etapa()]);
hijo->resta_peso(j*weight[hijo->etapa()]);
hijo->sig_etapa();
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Siendo c una cola con prioridad implementada en la librera
de plantillas estndar de C++, con el orden
f Y siendo valor[] (valor de los objetos) y peso[] (peso de
los objetos) variables globales.
hijo->fija_prio(cotaval(hijo));
if (hijo->peso()>=0 &&
solucion->valor()<hijo->prioridad())
if (hijo->solucion()) solucion=hijo;
else c.push(hijo);
}
delete nodoexp;
}
return solucion;
}
bool mayor_pri::operator()(nodo *a,nodo *b){
return (a->prioridad()<b->prioridad()); }
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo
Ejemplo
f Si hay 5 objetos de valores valor[]={30,40,60,10,20}
y pesos peso[]={6,10,20,5,15}, entonces la funcin
realiza el siguiente recorrido del espacio de bsqueda
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
Objeto 0
Objeto 1
Objeto 3
1
1
1 0
1 0 1 0
0
1 0
1 0 1 0
0
1
1 0
1 0 1 0
0
1 0
1 0 1 0
Objeto 2
Objeto 4
p=6,v=30
p=10,v=40
p=20,v=60
p=5,v=10
p=15,v=20
maxval 100
c=112
c=112
c=118 c=92
c=98
c=100
c=100 c=76,67
c=100 c=70
c=103 c=100
120 100
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Recordemos que se trata de buscar el camino ms corto
para visitar n ciudades y volver a la ciudad de partida sin
pasar dos veces por la misma ciudad.
f Ya vimos una solucin con programacin dinmica, pero
requera un coste en memoria excesivo.
?
%
%
%
%
6
4
3
2
5
2
4
6
5
3
0
1
2
3
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Como ya vimos, modelizaremos el problema con un grafo
G=(V,A) donde
V={1,,n} es el conjunto de vrtices (ciudades).
A es el conjunto de aristas (i,j) con i,j V (caminos).
D(i,j) es la longitud de (i,j) si (i,j) A, o si (i,j) A.
f Representaremos la solucin con un vector sol[n] que
almacenar en la posicin i, la ciudad a visitar en i-esimo
lugar.
4 5 2 3
6 6 2 2
4 5 1
3 3 0
3 2 1 0 De\A
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Espacio de Bsqueda
Espacio de Bsqueda
f El conjunto de posibles soluciones sern todas las
permutaciones de las n-1 ciudades que hay que visitar, es
decir (n-1)!
f Si por ejemplo, tenemos 4 ciudades, el rbol del espacio de
bsqueda tendr 3!= 6 ramas, que sern
0
1
3 2
0 0
2 3
2
3 1
0 0
1 3
3
2 1
0 0
1 2
Origen
1 visita
2 visita
3 visita
Destino
R
e
c
o
r
r
i
d
o
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Determinacin de una Cota del
Coste para una Solucin en Curso
Determinacin de una Cota del
Coste para una Solucin en Curso
f Para que la poda basada en la mejor solucin sea efectiva,
conviene utilizar un buena funcin que acote inferiormente el
coste del camino mnimo para una solucin en curso.
f Una cota muy sencilla podra ser la suma de los caminos ya
elegidos.
f Parece lgico tambin utilizar esta cota como prioridad, ya
que, en principio, los caminos ms cortos recorridos hasta el
momento, parecen los ms prometedores y deben intentarse
en primer lugar.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f La siguiente funcin en C++ resuelve el problema del
viajante con al tcnica de ramificacin y poda:
nodo* camino_minimo(int n){
priority_queue<node*,vector<node*>,menor_pri> c;
nodo raiz(n);
raiz.sig_etapa();
c.push(&raiz);
nodo *hijo,*nodoexp,*sol;
sol=new nodo(n);
sol->fija_distancia(DMAX);
while (!c.empty()){
nodoexp=c.top();
c.pop();
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
if (nodoexp->distance()<sol->distance())
for (int j=1;j<n;j++)
if (!nodoexp->visitado(j)){
hijo=new nodo(*nodoexp); hijo->visita(j);
if (hijo->distancia()<sol->distancia())
if (hijo->solucion()){
hijo->visita(0);
if (hijo->distancia()<sol->distancia())
sol=hijo;
}
else c.push(child);
else delete hijo;
}
delete nodoexp;
}
return sol;}
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Siendo la interfaz de la clase nodo la siguiente
class nodo{
int numel; // Nmero de ciudades
int *camino; // Ciudades visitadas hasta el momento
int actual; // Etapa actual del viaje
float dist; // Distancia recorrida hasta el momento
public:
nodo(int n); // Constructor por defecto
nodo(const nodo &a); // Constructor de copia.
void visita(int x); // Vista la ciudad x
void sig_etapa(); // Pasa a la siguiente etapa
void fija_distancia(float a); // Fija la distancia
float distancia(); // Devuelve la distancia recorrida
bool visitado(int x); //Comprueba si se ha visitado x
bool solucion(); // Mira si ha terminado el viaje
};
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo con Ramificacin y Poda
Ejemplo con Ramificacin y Poda
f Para nuestro ejemplo, esta funcin realizara el siguiente
recorrido del espacio de bsqueda:
15 14 18
0
1
3 2
0 0
2 3
2
3 1
0 0
1 3
3
2 1
0 0
1 2
Origen
1 visita
2 visita
3 visita
Destino
Distancia
R
e
c
o
r
r
i
d
o
Min
3

3
7 8 7
13
15
13
18
12
14

A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Mejora de la Poda
Mejora de la Poda
f Se puede conseguir una poda ms efectiva del espacio de
bsqueda si se calcula la cota inferior del coste del camino
mnimo reduciendo la matriz de adyacencia.
f Una matriz reducida es una matriz cuyos elementos son no
negativos y adems, cada fila y cada columna contiene al
menos un 0.
f Se puede reducir una matriz restando cantidades constantes
a los elementos de sus filas o columnas. En tal caso, si se
resta la misma constante c a todos los elementos de una fila
o columna de la matriz de adyacencia, cualquier circuito
hamiltoniano se ver reducido en dicha cantidad c.
f En consecuencia, se puede utilizar la suma de constantes
utilizadas en la reduccin de la matriz de adyacencia como
cota inferior de la distancia mnima.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Reduccin de la Matriz de
Adyacencia (Ejemplo)
f Consideremos la matriz de adyacencia del ejemplo:
f Para reducir la primera fila, tomamos como c el mnimo
elemento de dicha fila y lo restamos a toda la fila
f Y la cota inferior del camino mnimo es 3.
|
|
|
|
.
|
\
|

4 5 2
6 6 2
4 5
3 3
|
|
|
|
.
|
\
|

4 5 2
6 6 2
4 5
3 3
|
|
|
|
.
|
\
|

4 5 2
6 6 2
4 5
0 0
Fila 1 c=3
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
f Continuando con la reduccin queda
f Y la suma total de las constantes restadas es 3+4+2+2=11,
que es una cota inferior del camino mnimo.
f Utilizando esta cota como la prioridad de cada nodo, la poda
es mucho mayor y el algoritmo ms eficiente.
|
|
|
|
.
|
\
|

4 5 2
6 6 2
4 5
0 0
|
|
|
|
.
|
\
|

4 5 2
6 6 2
0 1
0 0
Fila 2 c=4
|
|
|
|
.
|
\
|

4 5 2
4 4 0
0 1
0 0
Fila 3 c=2
|
|
|
|
.
|
\
|

4 5 2
4 4 0
0 1
0 0
|
|
|
|
.
|
\
|

2 3 0
4 4 0
0 1
0 0
Fila 4 c=2
Matriz
Reducida!
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Clculo de la Cota Inferior para los
Nodos del Espacio de Bsqueda
Clculo de la Cota Inferior para los
Nodos del Espacio de Bsqueda
f Veamos cmo calcular la cota inferior para los nodos
distintos del raz.
f Supongamos que A es la matriz de adyacencia reducida
para un nodo x, y sea y el nodo hijo de x que se obtiene al
incluir la arista (i,j) en el recorrido. Entonces para calcular la
cota inferior del nodo y, hay que seguir los pasos siguientes:
Cambiar todos los elementos de la fila i y la columna j de
A por .
Reducir la matriz A con excepcin de la fija i y columna j.
La cota del nodo y es la suma de la cota del nodo x, A(i,j)
y las constantes restadas al reducir A.
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Clculo de la Cota Inferior
Ejemplo
Clculo de la Cota Inferior
Ejemplo
f Siguiendo con el ejemplo:
|
|
|
|
.
|
\
|

2 3 0
4 4 0
0 1
0 0
Cota=11
|
|
|
|
.
|
\
|

2 0
0 0
0 1
|
|
|
|
.
|
\
|

0 0
0 1 0
0
|
|
|
|
.
|
\
|

2 0 0
1 0
0 1
Cota=11+0+4 Cota=11++8 Cota=11+0+3
1 2 3
0
A
n
l
i
s
i
s
d
e

T
c
n
i
c
a
s
A
l
g
o
r
t
m
i
c
a
s
Ejemplo con Mejora de la Poda
Ejemplo con Mejora de la Poda
f Para nuestro ejemplo, con esta otra cota se realizara el
siguiente recorrido el espacio de bsqueda:
14
0
1
3 2
0 0
2 3
2
3 1
0 0
1 3
3
2 1
0 0
1 2
Origen
1 visita
2 visita
3 visita
Destino
Distancia
R
e
c
o
r
r
i
d
o
Min
15

14
14 18
14
14
11

Analisis de Tecnicas Algoritmicas

Cargado por

Información del documento

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

Analisis de Tecnicas Algoritmicas

Cargado por

Copyright:

Formatos disponibles

5 Metodologa y Tecnologa de la Programacin II

... ... ...

86 Metodologa y Tecnologa de la Programacin II

109 Metodologa y Tecnologa de la Programacin II

También podría gustarte