Metaheuristicas y Redes Neuronales

Metaheursticas y Redes Neuronales ESPOL, 2015/ 1
Metaheursticas y Redes Neuronales
Fernando Sandoya, Ph.D.

Contenido
1. Introduccin .......................................................................................................................... 5
1.1 Conceptos bsicos de grafos y redes ............................................................................ 5
1.2 Grafos y redes con Mathematica ................................................................................ 11
2. Los mtodos heursticos...................................................................................................... 12
2.1 Definicin y propiedades de los mtodos heursticos ................................................ 12
2.2 Tipos de mtodos heursticos ..................................................................................... 15
2.2.1 Mtodos de Descomposicin ............................................................................. 15
2.2.2 Mtodos Inductivos ............................................................................................ 16
2.2.3 Mtodos de Reduccin ....................................................................................... 16
2.2.4 Mtodos Constructivos ...................................................................................... 16
2.2.5 Mtodos de Bsqueda Local .............................................................................. 16
2.2.6 Mtodos combinados ......................................................................................... 16
2.2.7 Mtodos metaheursticos .................................................................................. 16
2.3 Problemas Estructurados ............................................................................................ 17
2.3.1 Problema de la Mochila (Knapsack Problem) .................................................... 18
2.3.2 Los problemas de Recubrimiento, empaquetamiento y particionamiento de
Conjuntos ............................................................................................................................ 19
2.3.3 Problema del Agente Viajero (Traveling Salesman Problem) ........................... 23
2.3.4 El Problema de la Asignacin Cuadrtica........................................................... 25
2.3.5 Problema de Asignacin Generalizada .............................................................. 26
2.3.6 Problema de la Ordenacin Lineal ..................................................................... 27
2.4 Medidas de Calidad de un Algoritmo .......................................................................... 28
2.4.1 Comparacin con la solucin ptima ................................................................. 28
2.4.2 Comparacin con una cota ................................................................................. 28
2.4.3 Comparacin con un mtodo exacto truncado ................................................. 29
2.4.4 Comparacin con otros heursticos.................................................................... 29
2.4.5 Anlisis del peor caso (worst case analisys) ...................................................... 29
3. Mtodos Constructivos ....................................................................................................... 30
3.1 Heursticos del Vecino ms Cercano ........................................................................... 30
3.2 Heursticos de Insercin .............................................................................................. 31
3.3 Heursticos Basados en rboles Generadores ............................................................ 33
3.4 Heursticos Basados en Ahorros .................................................................................. 37
4. Mtodos de Bsqueda Local ............................................................................................... 40
4.1 Procedimientos de 2 intercambio ............................................................................... 41
4.2 Procedimientos de k - intercambio ............................................................................. 43

4.3 Algoritmo de Lin y Kernighan ...................................................................................... 45

5. Mtodos Combinados ......................................................................................................... 49
5.1 Procedimientos Aleatorizados .................................................................................... 49
5.2 Mtodos Multi - Arranque .......................................................................................... 51
6. Mtodo GRASP (Greedy Randomized Adaptive Search Procedures) ................................. 53
6.1 Rencadenamiento de Trayectorias ............................................................................. 55
6.2 Bsqueda en Vecindades Variables ............................................................................ 56
6.3 Resolucin de un caso: implementacin GRASP en FS-scheduling:............................ 57
7. Bsqueda Tab .................................................................................................................... 63
7.1 Descripcin del mtodo de bsqueda tab ................................................................ 63
7.2 Resolucin de un caso: implementacin de Tabu Search para resolver el TSP: ......... 67
7.2.1 Introduccin: ....................................................................................................... 67
7.2.2 Algoritmo ............................................................................................................ 67
7.2.3 Resultados numricos ........................................................................................ 68
8. Recocido Simulado .............................................................................................................. 73
8.1 Origen: ......................................................................................................................... 73
8.2 El algoritmo SA ............................................................................................................ 74
8.3 Ejemplos de aplicacin ................................................................................................ 76
9. Mtodos Evolutivos ............................................................................................................. 77
9.1 Algoritmos Genticos .................................................................................................. 77
9.2 Bsqueda Dispersa (Scatter Search) ........................................................................... 83
10. Mtodos de evolucin diferencial................................................................................... 91
10.1 Introduccin ................................................................................................................ 91
10.2 Optimizacin combinatoria DE basada en permutaciones. ........................................ 92
10.3 Adecuacin de la DE como un optimizador combinatorio.......................................... 92
10.4 DE cannica para problemas de optimizacin contnuos. .......................................... 92
10.5 DE para problemas de optimizacin combinatorios basados en permutaciones. ...... 96
10.6 Enfoque de la indexacin de la posicin relativa o el enfoque Knapsack................... 97
10.6.1 Ejemplos .............................................................................................................. 98
11. Otras metaheursticas: Harmony Search y variantes .................................................... 108
11.1 Introduccin .............................................................................................................. 108
11.2 Descripcin del Proceso de Optimizacin ................................................................. 109
11.3 Pseudocdigo de la Metaheurstica Harmony Search .............................................. 110
11.4 Variantes de la Metaheurstica Harmony Search ...................................................... 111
11.4.1 Improved Harmony Search ............................................................................... 111
11.4.2 Global Best Harmony Search ............................................................................. 111
12. Redes neuronales .......................................................................................................... 111

22.1 Introduccin .............................................................................................................. 111

22.2 Modelos de neuronas ............................................................................................... 112
22.3 Arquitecturas............................................................................................................. 113
22.4 Reglas de aprendizaje................................................................................................ 114
22.5 Redes neuronales artificiales y los problemas de optimizacin combinatoria ......... 115
22.6 Aproximacin estadstica para el problema de la optimizacin. .............................. 115

1. Introduccin
El propsito de este curso es introducir los principales mtodos heursticos y metaheursticos
para resolver problemas de optimizacin combinatoria, y como analizar su eficiencia. Desde el
punto de vista prctico esto es muy interesante para la industria, la logstica, el transporte, los
servicios, etc., basta decir que muchos de los problemas que encontramos en la literatura de la
optimizacin combinatoria tienen sus orgenes en muchos problemas de ingeniera y
administracin reales, por ejemplo diseo de las de hospitales, diseo de chips y circuitos
electrnicos, asignacin de tareas, ruteo, diseo de lneas de ensamblaje, secuenciacin de
rdenes de produccin, asignacin de personal y determinacin de turnos, planificacin de
horarios, etc.. Todos estos problemas tienen sus abstracciones en la literatura cientfica, tales
como: Knapsack problem, set covering problem, set partitioning problem, permutation
assignment, travel salesman problem, vehiche routing problem, flow shop problem, job shop
problem, timetabling problem, etc. A lo largo del texto consideraremos algunos de estos
problemas para desarrollar e implementar los algoritmos propuestos.
La mayora de problemas de optimizacin combinatoria pueden ser representados

eficientemente a travs de grafos y redes, por lo que a continuacin se revisan algunos
aspectos relacionados con estos temas:
1.1 Conceptos bsicos de grafos y redes
Grafos Dirigidos: Un grafo dirigido (o dgrafo) = (, ) consiste en un conjunto de nodos

y un conjunto de arcos cuyos elementos son pares ordenados de nodos.
Red Dirigida: Una red dirigida es un grafo dirigido cuyos nodos o arcos tienen asociados
valores numricos tales como costos, capacidades, ofertas, demandas, tiempo etc. En general
se suele representar el nmero de nodos con la letra y al nmero de arcos con .
Grafos no Dirigidos: Un grafo no dirigido, o simplemente grafo, = (, ) consiste en un

conjunto de nodos y un conjunto de aristas cuyos elementos son pares no ordenados de
nodos distintos. En un grafo nos podemos referir a la arista que une a los nodos i-j, como (, )
o como (, ). Un grafo no dirigido permite el flujo en ambas direcciones, es decir desde el
nodo al nodo o viceversa.

Colas y Cabezas: Un arco dirigido (, ) tiene dos puntos de finalizacin . Nos referiremos
al nodo como la cola del arco y al nodo como su cabeza. Diremos que al arco (, ) emana
del nodo y termina en el nodo . El arco (, ) es incidente a los nodos .
El arco (, ) es un arco saliente del nodo y un arco entrante al nodo . Siempre que el arco
(, ) pertenezca al conjunto A, diremos que el nodo es adyacente al nodo .
Grados: El grado interno de un nodo es el nmero de arcos que llegan al nodo y su grado
externo es el nmero de arcos que salen del nodo. Al sumar el grado interno de un nodo con
su grado externo se obtiene el grado del nodo. Se observa que la suma de los grado interno de
todos los nodos es igual a la suma de todos los grados externos de todos los nodos y ambos
son iguales al nmero de arcos en la red.
Lista de Adyacencia: La lista de arcos de adyacencia () de un nodo i es el conjunto de arcos

que emanan del nodo i, esto es:
() = {(, ) :
SUBGRAFO: Un grafo = (, ) es un subgrafo de = (, ) si y . Diremos

que = (, ) es el subgrafo de inducido por si contiene cada arco de con ambos
puntos de finalizacin en .
Un grafo = (, ) es un subgrafo de expansin de = (, ) si = y .
CAMINO: Un camino (o denominado tambin camino no dirigido) en un grafo dirigido

= (, ) es un subgrafo de que satisface la propiedad que para todo , donde 1
1, se tiene que:
ak= (i k 1 , i k ) A o ak= (i k , i k 1 ) A.

CAMINO DIRIGIDO: Un camino dirigido es una versin orientada de un camino, en el

sentido de que para dos nodos consecutivos ik e ik+1 en el camino, se tiene que (i k , i k 1 ) A.
Por ejemplo en el siguiente grafo un camino dirigido del nodo 1 al nodo 3 es: 1-2-3-4-5-2-3
RUTA: Una ruta es un camino sin repeticin de nodos. Es posible particionar los arcos de un
camino en dos grupos: los arcos que van hacia delante y los arcos que van hacia atrs. Un arco
(i, j ) en el camino es un arco dirigido hacia delante si la ruta visita al nodo i antes de visitar
al nodo j, de ser contrario es un arco que est dirigido hacia atrs.
RUTA DIRIGIDA: Una ruta dirigida es un camino dirigido en el que no se repiten nodos. Dicho
de otra forma en una ruta dirigida no existen arcos dirigidos hacia atrs. Resulta fcil
almacenar una ruta en una computadora definiendo un ndice pred(j), para todo nodo j en la
ruta.
CICLO: Un ciclo es una ruta i1 i2 - ... ir , junto con el arco (i1 , ir ) o el arco (i r , i1 ) . Nos
referiremos a un ciclo empleando la notacin i1 i2 - ... ir ir. De manera anloga a las rutas
es posible definir arcos dirigidos hacia delante o hacia atrs.
CICLO DIRIGIDO: Un ciclo dirigido es una ruta dirigida i1 i2 - ... ir, junto con el arco (i r , i1 ) .

GRAFO ACCLICO: Un grafo es acclico si no contiene ciclos dirigidos.
CONECTIVIDAD: Dos nodos , estn conectados si el grafo contiene por lo menos una ruta
desde el nodo al nodo . Un grafo es conectado si cada par de nodos estn conectados. De
otra forma el grafo es desconectado. Nos referimos a los subgrafos conectados de una red
como sus componentes.
CONECTIVIDAD FUERTE: Un grafo conectado est fuertemente conectado si contiene por lo

menos una ruta dirigida desde cada nodo hacia todos los dems nodos.
RBOL: Un rbol es un grafo conectado acclico.
PROPIEDADES DE UN RBOL:
Un rbol de n nodos contiene exactamente n-1 arcos.

Un rbol contiene por lo menos dos nodos hojas, es decir con grado 1.
Cada pareja de nodos de un rbol estn conectados por una ruta nica.
BOSQUE:
Un bosque es un grafo acclico. De manera alternativa un bosque es una coleccin de rboles.
SUBRBOL: Un subrbol es un subgrafo conectado de un rbol.

RBOLES DE EXPANSIN: Un rbol es un rbol de expansin de si es un subgrafo de

expansin. Cada rbol de expansin de un grafo conectado de n nodos, tienen n-1 arcos.
DEFINICIONES PARA REDES NO DIRIGIDAS:
Las definiciones para redes dirigidas se pueden trasladar hacia las redes no dirigidas. Un arco
no dirigido (, ) tiene dos puntos de finalizacin y , pero la cabeza y la cola del arco no estn
definidos.
Si la red contiene al arco(, ), el nodo es adyacente al nodo y el nodo es adyacente al

nodo . Las listas de nodos y arcos de adyacencia estn definidas de manera similar, con la
diferencia de que el arco (, ) aparece en () y tambin en (). En consecuencia se tiene
que i N
A(i ) 2m .
El grado de un nodo es el nmero de nodos adyacentes al nodo . Los dems conceptos como
caminos, rutas, ciclos, cortaduras y rboles tienen las mismas definiciones para redes no
dirigidas, pero no existen diferencias entre rutas y rutas dirigidas, ciclos y ciclos dirigidos, y as
sucesivamente.
REPRESENTACIONES DE REDES: La resolucin de problemas de redes no solo depende de los

algoritmos empleados, sino tambin de la forma de representar la red en la computadora y el
esquema de almacenamiento empleado para guardar y actualizar los resultados que se vayan
obteniendo.
En la representacin de una red se necesitan dos clases de informacin:
La topologa de la red, es decir la estructura de los nodos y arcos.

Datos de inters como costos, capacidades, ofertas, demandas asociadas con los
nodos y los arcos.
A continuacin se presentan algunas representaciones.
MATRIZ DE INCIDENCIA DE NODOS Y ARCOS: Esta representacin almacena la red como una
matriz de , que contiene una fila por cada nodo, y una columna por cada arco. La

columna correspondiente al arco (, ) tiene solo dos elementos diferentes de cero, posee un
+1 en la fila correspondiente al nodo y un 1 en la fila correspondiente al nodo .
Esta matriz tiene una estructura particular. De los elementos de la matriz solo 2 son
diferentes de cero, las que toman los valores de +1 y 1 en cada columna. El nmero de
elementos en la fila -sima iguales a +1 representa el grado exterior del nodo y el nmero de
elementos en tal fila iguales a 1 representa el grado interior del nodo .
Debido a que la matriz de incidencia de nodos y arcos contiene pocos elementos diferentes de
cero en relacin al nmero total de elementos, esta representacin requiere del uso de
matrices dispersas o de lo contrario origina algoritmos poco eficientes.
MATRIZ DE ADYACENCIA DE NODO A NODO: Esta representacin almacena la red como una
matriz = { } de . La matriz posee una fila y una columna por cada nodo y la i-sima
entrada es igual 1 si el arco (, ) pertenece al conjunto , y es igual a cero en otro caso. Si
se pretende almacenar los costos y las capacidades de los arcos se pueden utilizar dos matrices
adicionales de , y .
De los n2 elementos que posee la matriz, solo m son diferentes de cero, cuyo nmero se debe
al nmero de arcos de la red. Por lo tanto esta representacin es eficiente si la red es
suficientemente densa, para redes esparcidas esta representacin desperdicia mucho espacio
en la matriz.
La manipulacin de esta matriz es muy fcil. Para determinar el costo o la capacidad del arco
(, ) basta con ubicar a los elementos situados en la posicin de las matrices y
respectivamente. Se puede conocer qu arcos emanan del nodo observando los elementos
iguales a 1 en la fila -sima de la matriz . De manera anloga se pueden obtener los arcos
que llegan al nodo examinando los elementos de la columna de la matriz , si elemento de
la fila -sima es igual a 1, entonces el arco (, ) pertenece a la red.
El tiempo requerido para determinar los arcos que llegan y salen de un nodo es proporcional a
n. En conclusin para redes densas se podra permitir emplear esta representacin, pero para
redes dispersas contribuira al mal desenvolvimiento del algoritmo empleado.
LISTAS DE ADYACENCIA: Anteriormente se defini a las listas de arcos de Adyacencia ()

como el conjunto de arcos que emanan del nodo y las listas de los nodos de adyacencia como
el conjunto de nodos tal que el arco (, ) pertenezca al conjunto .
Esta representacin almacena la lista de adyacencia de cada nodo en la estructura de datos

llamada lista enlazada en una direccin. Una lista enlazada es una coleccin de celdas, donde
cada celda puede contener uno o ms campos.
La lista de adyacencia del nodo i ser representada por una lista enlazada en una direccin,
la que tendr un nmero de celdas igual a la cardinalidad del conjunto (), y cada celda
corresponde a un arco (, ) perteneciente al conjunto . El nmero de campos de la celda
que hace referencia al arco (, ), ser consistente con la cantidad de informacin que se desee

almacenar. Un campo almacenar al nodo y los dems pueden ser utilizados para guardar el
costo c ij , los lmites de flujo del arco l ij y u ij .
1.2 Grafos y redes con Mathematica
Mathematica Wolfram incluye grandes capacidades para modelado y visualizacin de grafos y

redes. Esta plataforma contiene mecanismos simblicos prcticos para crear, etiquetar y dar
estilo a los grafos, desde pequeos y diagramticos a largos y complejos. Todas las funciones
estn integradas completamente con la programabilidad, grficos e interfaz dinmica.
En el documento: pasos para instalar MATHEMATICA.docx se encuentran las

instrucciones para descargar el programa y la licencia.
En los archivos sesion1.nb, sesion2.nb y sesion3.nb se encuentra el material
introductorio al uso y programacin con Mathematica.

2. Los mtodos heursticos

Los mtodos desarrollados para resolver problemas de optimizacin, que son abordados en
este curso, reciben el nombre de algoritmos heursticos o metaheursticos. Este trmino se
origina etimolgicamente en la palabra griega heuriskein que significa encontrar o descubrir y
se usa en el mbito de la optimizacin para describir una clase de algoritmos aproximados de
resolucin.
Aunque estos algoritmos (heursticos o Metaheursticos) son aplicables a la resolucin de

problemas de optimizacin contnuos o discretos, en particular en este curso se utilizan en el
contexto de la resolucin de problemas de optimizacin combinatoria, es decir en problemas
de optimizacin sobre un espacio discreto cuyo conjunto de decisiones factibles es
particularmente de gran cardinalidad.
2.1 Definicin y propiedades de los mtodos heursticos
En el lenguaje comn las personas utilizan el trmino optimizar en el sentido de mejorar;

pero, en el lenguaje de las matemticas la optimizacin es el proceso de buscar la mejor
solucin posible para un determinado problema. En un problema de optimizacin existen
diferentes soluciones, que conforman el conjunto de decisiones factibles, y una funcin que
mide la calidad de cada una de esas soluciones, denominada funcin objetivo o criterio, la cual
nos permite discriminar entre ellas, obviamente la meta es encontrar la solucin de mejor
calidad, que se denomina la solucin ptima del problema. De forma ms precisa, un
problema de optimizacin consiste en encontrar los valores que toman las variables de
decisin para los que una determinada funcin objetivo alcanza su valor mximo o mnimo. El
valor de las variables en ocasiones est sujeto a unas restricciones, que deben cumplirse de
manera estricta (dura) o de manera suave.
Algunos tipos de problemas de optimizacin son, desde un punto de vista matemtico,

relativamente fciles de resolver, este es el caso, por ejemplo, de los problemas de
programacin lineal, en los que tanto la funcin objetivo como las restricciones son
expresiones lineales y las variables pueden tomar valores dentro del conjunto de los nmeros
reales. Para estos problemas existen algoritmos que permiten resolverlos de una manera
eficiente, como con el mtodo Simplex, o los mtodos de punto interior; sin embargo, la
mayora de problemas de optimizacin son muy difciles de resolver. Es ms, casi todos los
problemas reales en la logstica, la industria y la ciencia que podemos encontrar en la prctica
entran dentro de esta categora. A partir de ah surge la necesidad de tener mtodos
aproximados, que a pesar que no permiten determinar la solucin ptima de estos problemas,
por lo menos nos proporcionan buenas soluciones, cercanas a la solucin ptima.
La idea intuitiva de los problemas difciles de resolver queda reflejada en el trmino

matemtico NP-duro (NP-hard) proveniente de la teora de la complejidad computacional. En
trminos resumidos podemos decir que un problema de optimizacin difcil es aquel para el
que no podemos garantizar el encontrar la mejor solucin posible en un tiempo razonable. La
existencia de una gran cantidad y variedad de problemas reales que pertenecen a esta clase
NP-hard impuls el desarrollo de procedimientos eficientes para encontrar buenas soluciones

aunque no fueran ptimas. Estos mtodos, en los que la rapidez del proceso es tan importante
como la calidad de la solucin obtenida, se denominan heursticos o aproximados. En (1) se
recogen algunas definiciones de algoritmo heurstico, entre las que se destaca la siguiente:
Un mtodo heurstico es un procedimiento simple, a menudo basado

en el sentido comn, que se supone ofrecer una buena solucin,
aunque no necesariamente la ptima, a problemas difciles, de un
modo fcil y rpido.
En ese sentido, al contrario de los mtodos exactos que proporcionan la solucin ptima al
problema, los mtodos heursticos se limitan a proporcionar una buena solucin. Lo
determinante es que el tiempo invertido por un mtodo exacto para encontrar la solucin
ptima de un problema difcil, en general es muy superior (o incluso prcticamente infinito) en
comparacin con el tiempo que se requiere hallar una buena solucin por el mtodo
heurstico.
Por su importancia en el campo de las aplicaciones en la industria, la logstica y el transporte,

en este curso consideraremos los llamados problemas de Optimizacin Combinatoria. En estos
problemas el objetivo es encontrar el mximo (o el mnimo) de una determinada funcin sobre
un conjunto finito de soluciones factibles que representaremos por S. No se exige ninguna
condicin o propiedad sobre la funcin objetivo (puede ser lineal, no lineal, convexa, no
convexa, etc.) ni sobre la estructura del conjunto S, salvo su carcter finito. Es importante
notar que dada la finitud de S, las variables de decisin son discretas, ya que su dominio queda
restringido a un conjunto finito de valores. El problema es que a pesar de ser finito, el nmero
de elementos de S es muy elevado, haciendo impracticable la exploracin exhaustiva de todas
sus soluciones para determinar el ptimo.
Aunque hemos mencionado que la razn de desarrollar y utilizar mtodos heursticos es la

resolucin de problemas difciles de tipo NP-duros, existen otras razones por las que se
necesita aplicar mtodos heursticos, entre las que se pueden resaltar:
El problema a tratar es de una naturaleza tal que no se conoce ningn mtodo exacto
para su resolucin.
Aunque existe un mtodo exacto para resolver el problema, su uso es

computacionalmente muy costoso.
Los mtodos heursticos son ms flexibles que los mtodos exactos, permitiendo, por
ejemplo, la incorporacin de condiciones de difcil modelizacin.
Se puede requerir la utilizacin de un mtodo heurstico como parte de un

procedimiento global para encontrar el ptimo de un problema, sobre todo en las
siguientes situaciones:
- El mtodo heurstico permite determinar una buena solucin inicial de partida.

- El mtodo heurstico participa en un paso intermedio del procedimiento, como por

ejemplo las reglas de seleccin de la variable a entrar en la base en el mtodo
Simplex.
Una caracterstica determinante de los algoritmos heursticos es que estos dependen en gran
medida del problema concreto para el que se han diseado, es decir el algoritmo diseado
para un problema no es directamente aplicable a otro problema de optimizacin. Esta
caracterstica los diferencia de los mtodos de resolucin de propsito general, como por
ejemplo los algoritmos exactos de Branch & Bound, para los cuales existe un procedimiento
conciso y preestablecido, independiente del problema abordado.
As, en los mtodos heursticos las tcnicas e ideas aplicadas a la resolucin de un problema
son especficas y aplicables solo a ste y aunque, en general, pueden ser trasladadas a otros
problemas, tienen que particularizarse y adaptarse en cada caso. As pues, es necesario
referirse a un problema concreto para estudiar con detalle los procedimientos heursticos, por
lo que, para su estudio, hay que considerar un problema de optimizacin combinatorio
especfico, y a partir de ah describir el desarrollo de los mtodos. Existen muchos problemas
que se prestan, por ser fciles de entender pero difciles de resolver, para esto. En general se
puede utilizar el Problema del Agente Viajero, que posee buenas propiedades combinatorias
propiedades que lo hacen especialmente indicado. Dicho problema puede enunciarse del
siguiente modo:
Un agente viajero ha de visitar n ciudades, comenzando y

finalizando en su propia ciudad. Conociendo el costo de ir de cada
ciudad a otra, determinar el recorrido de costo mnimo.
Entre las buenas caractersticas que posee el Problema del Agente Viajero que lo hacen ideal
para el estudio de las tcnicas heursticas se pueden nombrar las siguientes:
Resulta muy intuitivo y con un enunciado muy fcil de comprender.
Es extremadamente difcil de resolver por lo que resulta un desafo constante para los
investigadores y cientficos.
Es uno de los que ms inters ha suscitado en Optimizacin Combinatoria y sobre el que se

ha publicado abundante material.
Sus soluciones admiten una doble interpretacin: mediante grafos y mediante

permutaciones, dos herramientas de representacin muy habituales en problemas
combinatorios, por lo que las ideas y estrategias empleadas son, en gran medida,
generalizables a otros problemas.
La gran mayora de las tcnicas que han ido apareciendo en el rea de la Optimizacin
Combinatoria han sido probadas en l, puesto que su resolucin es de gran complejidad
EJERCICIO:
Analice el problema de agente viajero (TSP por sus siglas en ingls) con nodos a visitar

a. Cuntas soluciones factibles tiene este problema.

b. Considere ahora un problema con cuatro nodos, la base desde donde debe partir el
agente es la ciudad 1, las distancias inter-elemento estn dadas en la siguiente tabla:
1 2 3 4
1 - 12 14 42
2 12 - 9 13
3 14 9 - 15
4 42 13 15 -
- Utilizando la heurstica del vecino ms cercano (que funciona de la siguiente
manera: en cada paso el siguiente nodo a visitar es el ms cercano a la ubicacin
actual) determine una buena solucin a este problema.
- Explore exhaustivamente todas las soluciones posibles y determine cul es el tour
ptimo para visitar todas las ciudades.
- Cul es el GAP relativo (diferencia entre la solucin aproximada y la solucin
ptima). Considera que la heurstica del vecino ms cercando le proporcion una
buena solucin?
c. Cunto tiempo se demorara en encontrar una solucin ptima por el procedimiento
de exploracin exhaustiva para un problema que tiene 20 nodos, 50 nodos, 70 nodos.
Tomar en cuenta que una computadora promedio actualmente, tiene un rendimiento
de unos 15 teraFLOPS (151012 flops1).
d. Implemente en la computadora un algoritmo para la bsqueda exhaustiva de la
solucin ptima del TSP.
e. Implemente en una computadora el algoritmo del vecino ms cercano para determinar
una solucin al TSP.
Existen tambin otros problemas de optimizacin combinatoria que resultan tambin

atractivos para el estudio de las tcnicas heursticas, estas tcnicas tambin nos ayudaran a
explicar e ilustrar algunas de las tcnicas as como a plantear ejercicios para el estudiante,
entre ellos tenemos: el problema de la mochila (Knapsack Problem), el problema de
planificacin de un taller (Job Shop Problem), el problema de ruteo de vehculos (Vehicle
Routing Problem), el problema de asignacin cuadrtica y otros.
2.2 Tipos de mtodos heursticos
Existen muchos mtodos heursticos de naturaleza muy diferente, por lo que es complicado
dar una clasificacin completa. Adems, muchos de ellos han sido diseados para un problema
especfico sin posibilidad de generalizacin o aplicacin a otros problemas similares. El
siguiente esquema trata de dar unas categoras amplias, no excluyentes, en donde ubicar a los
heursticos ms conocidos:
2.2.1 Mtodos de Descomposicin
En estos mtodos heursticos el problema original se descompone en subproblemas ms

sencillos de resolver, teniendo en cuenta, aunque sea de manera general, que estos
pertenecen al mismo problema.
1
FLOPS es el acrnimo de FLoating-point Operations Per Seconds, es decir el nmero de
operaciones de punto flotante por segundo.

2.2.2 Mtodos Inductivos
La idea de estos mtodos es generalizar de versiones pequeas o ms sencillas al caso

completo. Propiedades o tcnicas identificadas en estos casos ms fciles de analizar pueden
ser aplicadas al problema completo.
2.2.3 Mtodos de Reduccin
Estos mtodos consisten en identificar propiedades que cumplen mayoritariamente las buenas
soluciones e introducirlas como restricciones del problema. El objeto es restringir el espacio
de soluciones, encogiendo el espacio de bsqueda de las soluciones y simplificando el
problema. El riesgo obvio es dejar fuera buenas soluciones e incluso la ptima del problema
original.
2.2.4 Mtodos Constructivos
Consisten en construir literalmente paso a paso una solucin del problema, incorporando un
nuevo elemento a la solucin en cada iteracin. Usualmente son mtodos deterministas.
2.2.5 Mtodos de Bsqueda Local
A diferencia de los mtodos anteriores, los procedimientos de bsqueda o mejora local

comienzan con una solucin del problema y la mejoran progresivamente. El procedimiento
realiza en cada paso un movimiento de una solucin a otra con mejor valor. El mtodo finaliza
cuando, para una solucin, no existe ninguna solucin accesible que la mejore.
2.2.6 Mtodos combinados
Si bien todos estos mtodos han contribuido a ampliar nuestro conocimiento para la
resolucin de problemas reales, la integracin de los mtodos constructivos y los de bsqueda
local constituyen la base de los procedimientos metaheursticos. Por ello, estudiaremos en
captulos independientes los mtodos constructivos y los mtodos de bsqueda local, mientras
que se harn menciones a lo largo del texto a cualquiera de los mtodos de descomposicin,
inductivos o de reduccin, pero no dedicaremos una seccin especfica a su estudio.
Alternativamente, prestaremos especial atencin a los mtodos resultantes de combinar la
construccin con la bsqueda local y sus diferentes variantes, puesto que puede considerarse
un punto de inicio en el desarrollo de los mtodos metaheursticos.
2.2.7 Mtodos metaheursticos
Existen una serie de mtodos que se conocen bajo el nombre de Metaheursticos, los cuales
tienen el propsito de obtener mejores resultados que los alcanzados por los heursticos
tradicionales. El trmino metaheurstico fue introducido por Fred Glover en 1986. En este
curso utilizaremos la acepcin de heursticos para referirnos a los mtodos clsicos en
contraposicin a la de metaheursticos que reservamos para los ms recientes y complejos,
con los que se obtienen mejores soluciones. En algunos textos podemos encontrar la expresin
heursticos modernos refirindose a los Metaheursticos. En (2) se introduce la siguiente
definicin:

Los procedimientos Metaheursticos son una clase de mtodos

aproximados que estn diseados para resolver problemas difciles
de optimizacin combinatoria, en los que los heursticos clsicos no
son efectivos. Los Metaheursticos proporcionan un marco general
para crear nuevos algoritmos hbridos combinando diferentes
conceptos derivados de la inteligencia artificial, la evolucin biolgica
y los mecanismos estadsticos
De esta manera, los procedimientos Metaheursticos se sitan conceptualmente por encima

de los heursticos en el sentido que guan el diseo de stos. As, al enfrentarnos a un
problema de optimizacin, podemos escoger cualquiera de estos mtodos para disear un
algoritmo especfico que lo resuelva aproximadamente.
En estos momentos existe un gran desarrollo y crecimiento de estos mtodos. En este curso
vamos a limitarnos a aquellos procedimientos relativamente consolidados y que han probado
su eficacia sobre una coleccin significativa de problemas. Especficamente consideraremos en
sendos captulos la Bsqueda Tab, el Recocido Simulado, los diferentes Mtodos Evolutivos,
incluyendo los Algoritmos Genticos y la Bsqueda Dispersa (Scatter Search), la evolucin
diferencial, el rencadenamiento de trayectorias y los mtodos GRASP.
Es importante notar que para la correcta compresin y asimilacin de los mtodos descritos,
resulta indispensable su puesta en prctica, para lo cual el lector deber implementar en un
lenguaje de computacin los algoritmos descritos y resolver algn problema de optimizacin
combinatoria. Se recomendamos utilizar cualquier lenguaje de programacin que permita
controlar los detalles de implementacin y que incluya la posibilidad de programacin
funcional y un buen manejo de estructuras de datos, en particular Wolfram Mathematica tiene
esas caractersticas. La seccin 2.3 incluye una coleccin de problemas de entre los que el
lector puede escoger alguno e ir trabajando con l, aplicando los mtodos descritos a lo largo
de todo el texto.
Al resolver un problema de forma heurstica debemos de medir la calidad de los resultados

puesto que, como ya hemos mencionado, la optimalidad no est garantizada. En la seccin 2.4
de este captulo se recogen los principales mtodos para medir la calidad y eficiencia de un
algoritmo y poder determinar su vala frente a otros.
2.3 Problemas Estructurados
El objeto de esta seccin no es nicamente dar una coleccin de ejemplos reales, sino el de
establecer modelos que han sido muy estudiados. As, al enfrentarse el lector a un problema
dado, tratar de reconocer las estructuras especiales que aparecen en estos modelos y de esta
forma se podr aprovechar la extensa literatura y experiencia computacional al respecto.
Adems, no debemos olvidar la limitada, pero significativa, importancia prctica de estos
modelos.

2.3.1 Problema de la Mochila (Knapsack Problem)
El problema de la mochila (KP por sus siglas en ingls), es un problema de optimizacin

combinatoria muy referenciado en la literatura de investigacin de operaciones, tanto por sus
aplicaciones como por su estructura, que lo hace ideal para la evaluacin del desempeo de
mtodos de bsqueda inteligente en problemas de optimizacin combinatoria.
El problema KP es un problema de optimizacin combinatoria de formulacin sencilla, aunque

su resolucin es compleja, y que aparece, directamente, o como un subproblema, en una gran
variedad de aplicaciones, incluyendo planificacin de la produccin, modelizacin financiera,
muestreo estratificado, planificacin de la capacidad de instalaciones, etc., como se observa en
(3). Adems de sus potenciales aplicaciones, el KP es de particular inters por sus
caractersticas combinatorias y su estructura sencilla, que lo vuelve un problema ideal para el
diseo de mtodos de bsqueda inteligente. Con el tratamiento del problema KP se pueden
evaluar las ventajas y desventajas de estos algoritmos, sobretodo su robustez, precisin y
rapidez.
El KP es un problema combinatorio que es NP-duro, como se puede ver en (4), con respecto a
la codificacin binaria estndar, y consta en la lista de 21 problemas NP-completos de Karp,
por tanto es improbable que, en algn momento, pueda ser encontrado un algoritmo que
pueda resolverlo en tiempo polinomial. Sin embargo KP no es del tipo fuertemente NP-duro, y
por tanto puede ser resuelto en tiempo seudo-polinomial, particularmente por programacin
dinmica, como se demuestra en (5) ; es decir, que en su codificacin uniaria el problema es
resoluble polinomialmente. De esta manera, incluso grandes instancias del problema pueden
ser resueltas de manera exacta con solvers que utilizan mtodos como la bsqueda dinmica o
branch & bound (en particular Cplex), y el planteamiento de mtodos aproximados, como los
basados en metaheursticas, se da para probar la eficiencia de estos procedimientos.
La formulacin del KP se realiza de la siguiente manera:
Dado un conjunto de objetos = {1, 2, 3, , }, con utilidades unitarias 1 , 2 , , , y

con pesos 1 , 2 , , , respectivamente, y dado que se tiene un recipiente (la mochila), de
capacidad , el problema KP consiste en determinar qu objetos debo seleccionar para incluir
en la mochila, de tal manera que la utilidad total de los objetos que se cargan sea la mxima
posible, como se puede ver esquemticamente en la Figura 1.
Figura 1. Como cargar ptimamente la mochila sin rebasar su capacidad

As, el KP puede ser representado sencillamente por la siguiente formulacin de

programacin binaria:

=1

. .
=1
{0, 1}; = 1, 2, ,
En donde: = 1 si decidimos incluir el objeto en la mochila, y = 0 sino.
Este problema tiene numerosas aplicaciones tales como:
La denominada Cutting Stock, en donde hay que cortar una plancha de acero en diferentes
piezas.
Determinar los artculos que puede almacenar un depsito para maximizar su valor total.
Maximizar el beneficio en asignacin de inversiones cuando slo hay una restriccin.
EJERCICIO:
Describir el problema Cutting Stock y plantearlo como un problema de la mochila.
2.3.2 Los problemas de Recubrimiento, empaquetamiento y particionamiento de

Conjuntos
Estos problemas, en ingls conocidos como Set Covering (SCP), Set Packing (SSP) y Set
Partitioning (SPP), respectivamente, son problemas de optimizacin de tipo NP-hard con un
tronco comn con muchas aplicaciones, en particular sern tratados como problemas de
prueba para los mtodos basados en evolucin diferencial (Captulo 0) y que se pueden
enunciar del siguiente modo:
Sea una matriz binaria 0/1 de dimensiones y = {1 , , } un vector de coeficientes

enteros, entontes se definen los problemas SCP, SSP y SPP como:
SCP SSP SPP
. . 1 . . 1 . . = 1
{0,1} {0,1} {0,1}
Los tres problemas, SCP, SSP y SPP, pueden ser muy tiles para mostrar la transformacin y
relaciones entre problemas. As podemos ver que el Set Packing y el Set Partitioning son
equivalentes. Para pasar del primero al segundo basta con aadir variables de holgura. La

transformacin inversa se realiza mediante variables artificiales. Estos dos problemas son ms
fciles de resolver de forma exacta que el Set Covering ya que en ellos las restricciones
lineales estn ms ajustadas respecto al conjunto de soluciones enteras posibles, por lo que los
ptimos de las relajaciones lineales estn ms cerca de las soluciones enteras.
2.3.2.1 SCP (Problema del recubrimiento de Conjuntos):
Un ejemplo el problema de recubrimiento SPP podra ser el siguiente: Sea un conjunto de

clientes = {1,2, . . , } a los cuales se pretende dar un servicio, y un conjunto H de posibles
ubicaciones de facilidades logsticas desde donde se da servicio a los clientes; es decir, cada
elemento de H da cobertura a un subconjunto de S, H={H1,H2,. .,Hn}, cada Hi tiene un costo ci
asociado. El problema consiste en cubrir con costo mnimo todos los clientes con elementos de
H.
Para formular el problema se define una variable = 1 si Hi est en la solucin y 0 en otro

caso. Tambin se introduce una matriz A={aij} de cobertura, en la que = 1 si el elemento j
de S est en Hi y 0 en otro caso. La formulacin es la siguiente:

=1
. .: 1; = 1, ,
=1
{0, 1}; = 1, ,
Este problema tiene diferentes aplicaciones, entre las que podemos destacar la localizacin de
servicios, tales como hospitales, bomberos, etc. y, la asignacin de tripulaciones a vuelos.
El problema del Set Covering es relativamente fcil de resolver con mtodos de Ramificacin y
Acotacin ya que la solucin ptima del problema lineal coincide, en ocasiones, con la del
problema MIP o est bastante cerca de l. La dificultad del problema proviene del nmero
enorme de variables que suelen aparecer en problemas reales.
EJERCICIO: (Resolver con GAMS)
INSTALACION DE CENTROS DE SEGURIDAD
Una empresa de seguridad residencial e industrial ofrece respuesta rpida a llamadas de

auxilio (en menos de 5 minutos de la alarma ellos estarn en el sitio auxiliando al afiliado). Para
cumplir este objetivo la empresa deber instalar Centros de Auxilio Inmediato en diferentes
sectores de la ciudad, desde donde partirn patrullas armadas hacia el lugar de auxilio.
El gerente de operaciones ha establecido 15 locales que pueden ser adecuados como centros,
as como tambin el costo de alquiler de estos locales. As mismo se ha zonificado la ciudad en
17 zonas. En la tabla adjunta constan los costos as como tambin las zonas de la ciudad que

pueden ser servidas por cada uno de los mismos El objetivo es determinar que centros instalar
de tal manera que se minimice el costo total y que permita dar el servicio a todas las zonas.
CENTRO DE AUXILIO INMEDIATO

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 1 0 0 1 1 0 0 0 0 1 1 1 1 0 0
2 1 1 1 1 0 0 0 0 1 1 1 0 1 0 0
3 1 0 1 0 1 0 0 0 0 0 0 1 1 1 1
4 0 0 0 0 1 1 1 1 0 0 0 1 1 0 1
5 1 0 0 0 1 1 1 1 0 1 1 1 1 0 0
6 0 0 0 0 1 1 1 0 0 1 0 0 0 1 1
7 1 0 0 0 0 0 0 0 0 1 1 1 0 0 1
8 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0
ZONA
9 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
10 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0
11 0 1 1 0 0 0 0 0 1 1 1 0 0 0 1
12 0 0 0 1 1 1 0 0 0 0 0 1 0 1 0
13 1 1 0 0 0 0 0 0 0 0 0 0 1 0 1
14 1 0 0 0 0 0 0 0 1 1 1 1 1 0 0
15 0 0 0 0 0 0 0 1 1 1 0 0 0 1 1
16 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1
17 1 1 1 0 0 0 1 0 1 0 1 0 1 0 1
ALQUILER 600 500 380 400 600 280 500 480 510 390 420 450 500 600 550
EJERCICIO: (Resolver con GAMS)
ASIGNACION DE TRIPULACIONES
Una empresa area necesita asignar sus tripulaciones para cubrir todos sus vuelos. En
particular, se quiere resolver el problema de asignar TRES tripulaciones con base en Bogot a
los vuelos listados en la primera columna de la tabla. Las otras columnas muestran las 12
secuencias factibles de vuelos para una tripulacin cualquiera. Los nmeros de cada columna
indican el orden de los vuelos. Se necesita elegir tres secuencias (una por tripulacin) de
manera que se cubran todos los vuelos. Se permite tener ms de una tripulacin en un vuelo,
donde la tripulacin extra viaja como pasajeros, pero como parte del contrato colectivo cada
tripulacin extra que le toque viajar cobra como si estuviera trabajando. El coste de asignacin
de una tripulacin a cada secuencia de vuelos se da en miles de dlares en la ltima fila.
El objetivo es determinar una forma ptima de asignacin de las tres tripulaciones de tal
manera que se minimice el costo total para cubrir todos los vuelos.
1 2 3 4 5 6 7 8 9 10 11 12
1 BOG-UIO 1 1 1 1
2 BOG-GYE 1 1 1 1
3 BOG-LIM 1 1 1 1
4 UIO-HAV 2 2 3 2 3
5 UIO-BOG 2 3 5 5
6 HAV-GYE 3 3 4
7 HAV-LIM 3 3 3 3 4

8 GYE-BOG 2 4 4 5
9 GYE-HAV 2 2 2
10 LIM-BOG 2 4 4 5
11 LIM-UIO 2 2 4 4 2
12 Costo 20 30 40 60 70 50 70 80 90 90 80 90
2.3.2.2 SPP (Problema de la Particin de Conjuntos)
Ahora consideremos el Set Partitioning y, al igual que en los dos anteriores, se tienen los
conjuntos S y H. As como en el Set Covering cada elemento de S tiene que aparecer al menos
en uno de H, en este problema cada elemento de S tiene que aparecer exactamente en uno de
H, por lo tanto la solucin representa una particin del conjunto S. La funcin objetivo puede
ser maximizar o minimizar, segn la aplicacin.
Aplicaciones:
Asignacin de tripulaciones en una versin ms restringida que la anteriormente

mencionada.
Creacin de distritos Electorales: Asignacin de electores a un colegio electoral.
EJEMPLO:
EL PROBLEMA DEL COLOREO DE GRAFOS
Dado un grafo G, el problema de coloreamiento del grafo consiste en colorear todos los nodos
con la cantidad mnima de colores de tal manera que no existan dos nodos adyacentes (unidos
con una arista) del mismo color. Este problema representa muchas situaciones reales como en
la planificacin de horarios para una serie de actividades que deben tener lugar, algunas de las
cuales no pueden suceder simultneamente, tales como horarios de exmenes, horarios de
competencias deportivas, etc. Se desea conseguir una planificacin que asegure la menor
duracin total de todo el plan.
Para formular este problema se define un grafo en el que cada nodo representa una actividad,
y cada arista (, ) significa que las actividades , no pueden ocurrir simultneamente. El
problema consiste en particionar el conjunto de nodos en el menor conjunto posible de
subconjuntos disjuntos, de tal forma que no existan dos nodos adyacentes en el mismo
subconjunto.
Para formular el problema se consideran todos los posibles conjuntos de nodos tales que no
contengan dos nodos adyacentes, y a cada se le asocia una variable de decisin . La matriz
= ( ) se define como: = 1 si el nodo j pertenece al subconjunto , y cero en caso
contrario. Entonces la formulacin es:

=1

. .: = 1; = 1, ,
=1
{0, 1}; = 1, ,
EJEMPLO:
Resolver con GAMS el problema de coloreo del grafo de Petersen:
2.3.2.3 SSP (Problema del empaquetamiento de Conjuntos):
Ahora consideremos una aplicacin del Set Packing. Igual que en el problema anterior se
tienen los conjuntos S y H, pero ahora cada Hi tiene un valor asociado. El objetivo es
empaquetar tantos elementos de S como sea posible de forma que el beneficio obtenido sea
mximo y no haya solapamientos (ningn elemento de S puede aparecer ms de una vez).
En cierto modo, la relajacin lineal del Set Covering y la del Set Packing son problemas duales.
Sin embargo esto no sirve para establecer una relacin entre los problemas enteros originales.
Uno de los ejemplos/aplicaciones es el problema del Acoplamiento Mximo o Matching. Un

acoplamiento es un subconjunto de las aristas de un grafo de manera que cualquier vrtice no
sea incidente con ms de una de esas aristas. El problema del acoplamiento mximo consiste
en encontrar un acoplamiento de mximo cardinal.
EJERCICIO:
Plantear una aplicacin del SSP y resolverlo con GAMS
2.3.3 Problema del Agente Viajero (Traveling Salesman Problem)
Este problema, tambin conocido como Traveling Salesman Problem (TSP), ha sido uno de los
ms estudiados en Investigacin Operativa, por lo que merece una atencin especial. Cuando
se desarroll la teora de la Complejidad Algortmica, el TSP fue uno de los primeros problemas
en estudiarse, probando Karp en 1972 que pertenece a la clase de los problemas difciles (NP-
hard).
Desde los mtodos de Ramificacin y Acotacin hasta los basados en la Combinatoria

Polidrica, pasando por los procedimientos Metaheursticos, todos han sido inicialmente

probados en el TSP, convirtindose ste en un problema de prueba obligado para validar

cualquier tcnica de resolucin de problemas enteros o combinatorios. La librera TSPLIB
(http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/) de domino pblico contiene un
conjunto de ejemplos del TSP para ser usados como ejemplos de prueba en los algoritmos, y
en los que consta la mejor solucin obtenida hasta la fecha y, en algunos casos, la solucin
ptima. A efectos de medir empricamente la bondad de los algoritmos que se describe,
consideraremos un conjunto de 30 ejemplos de la TSPLIB basados en problemas reales con
ptimos conocidos.
El Problema del Agente Viajero puede enunciarse del siguiente modo:
Un agente viajero ha de visitar n ciudades, comenzando y finalizando en su

propia ciudad. Conociendo el costo de ir de cada ciudad a otra, determinar el
recorrido de costo mnimo.
Para enunciar el problema formalmente introducimos la siguiente terminologa:
Sea un grafo G=(V,A,C) donde V es el conjunto de vrtices, A es el de aristas y C=(cij) es la

matriz de costos. Esto es, cij es el costo o distancia de la arista (i, j).
Un camino (o cadena) es una sucesin de aristas (e1, e2, , ek) en donde el vrtice final de
cada arista coincide con el inicial de la siguiente. Tambin puede representarse por la
sucesin de vrtices utilizados.
Un camino es simple o elemental si no utiliza el mismo vrtice ms de una vez.
Un ciclo es un camino (e1, e2, , ek) en el que el vrtice final de ek coincide con el inicial de
e1.
Un ciclo es simple si lo es el camino que lo define.
Un subtour es un ciclo simple que no pasa por todos los vrtices del grafo.
Un tour o ciclo hamiltoniano es un ciclo simple que pasa por todos los vrtices del grafo.
El Problema del Agente Viajero consiste en determinar un tour de costo mnimo. La figura 2
muestra un grafo de 8 vrtices en el que aparece destacado un ciclo hamiltoniano.
8 5 4
1
6
4
3 6
5
4 3
10
2 5 6
8 10
6 7
4
4 8 4
3 8
Figura 2. Ciclo Hamiltoniano
Consideraremos, sin prdida de generalidad, que el grafo es completo; es decir, que para cada
par de vrtices existe una arista que los une. Notar que, de no ser as, siempre podemos aadir
una arista ficticia entre dos vrtices con el costo del camino ms corto que los une. As por
ejemplo, en el grafo de la figura 2 podemos aadir una arista entre los vrtices 1 y 6 con costo
9 correspondiente al camino 1-3-6.

Entre las aplicaciones ms importantes del TSP podemos destacar:
Fabricacin de circuitos integrados

Rutas de vehculos
Recogida (robotizada) de material en almacenes
Instalacin de componentes en computadores
Aparece como subproblema en otras aplicaciones
Este problema puede ser formulado mediante un modelo de programacin lineal entera con
variables binarias. Para ello basta considerar las variables xij que valen 1 si el viajante va de la
ciudad i a la j y 0 en otro caso y llamar cij al costo de ir de la ciudad i a la j:
MIN c
i j
ij xij
s.t. :
x x
i j
ij
j i
ji 2 i 1,2,...,n
xij 2 S {1,2,.., n}, 3 S n / 2

( i , j ) ( S )
xij 0,1 i j
Donde (S) representa el conjunto de aristas incidentes con exactamente un vrtice de S.
Las restricciones que aparecen en segundo lugar (vinculadas a todos los subconjuntos de
vrtices S) reciben el nombre de restricciones de eliminacin de subtours y garantizan que la
solucin sea un tour. El problema es que al haber una por cada subconjunto del conjunto de
vrtices, aparecen en una cantidad del orden de 2n, lo cual hace inmanejable tal formulacin.
Se han encontrado restricciones alternativas para evitar la formacin de subtours que suponen
la incorporacin de una cantidad polinmica de restricciones (Miller, Tucker y Zemlin, 1960).
An as, la resolucin ptima del problema ha resultado poco eficiente, salvo para ejemplos
relativamente pequeos, dado el elevado tiempo de computacin requerido por cualquier
mtodo exacto.
2.3.4 El Problema de la Asignacin Cuadrtica
Introduciremos el problema mediante el siguiente ejemplo: Se tienen n mdulos electrnicos

y n posiciones en donde situarlos sobre una placa. Sea tik el nmero de cables que conectan los
mdulos i y k, y sea djl la distancia entre las posiciones j y l de la placa. El problema consiste en
determinar la ubicacin de los mdulos minimizando la longitud total del cable utilizado
Al igual que en los otros modelos de asignacin vistos, se introducen variables binarias xij que
toman el valor 1 si el mdulo i se asigna a la posicin j y 0 en otro caso. La formulacin MIP es
la siguiente:

n n n n
MIN
i 1 j 1 k 1 l 1
tik d jl xij xkl
s.t. :
n
x
j 1
ij 1 i 1,2,...,n
x
i 1
ij 1 j 1,2,...,n
xij 0,1
El problema se llama cuadrtico por la funcin objetivo ya que el costo viene dado por parejas
de variables que aparecen como producto. As pues la funcin objetivo es no lineal, aunque se
puede transformar en un problema lineal entero introduciendo variables que representen a los
productos. Notar que esta transformacin obligara a reformular las restricciones.
Este problema tiene numerosas aplicaciones ya que podemos encontrar en mbitos muy
diversos situaciones como la descrita. As, por ejemplo, el problema de ubicar determinados
servicios (como laboratorios, rayos X,... etc.) en un hospital en donde se conoce el flujo
previsto de personal entre tales servicios. Anlogamente el guardar determinados productos
en un almacn.
El objeto de introducir este problema es doble: por una parte mostrar un problema no lineal,
con un gran nmero de aplicaciones prcticas, que puede transformarse en un PLE y, por otra,
presentar uno de los problemas ms difciles (sino el que ms) dentro de los ya de por s
difciles problemas enteros.
EJERCICIO:
Introduciendo nuevas variables plantear el problema de asignacin cuadrtica como un

problema MIP.
2.3.5 Problema de Asignacin Generalizada
Se tiene un conjunto J={1,2,..,n} de ndices de los trabajos a realizar y otro conjunto I={1,2,..,m}
de personas para realizarlos. El costo (o valor) de asignar la persona i al trabajo j viene dado
por cij. Adems se tiene una disponibilidad bi de recursos de la persona i (como por ejemplo
horas de trabajo) y una cantidad aij de recursos de la persona i necesarias para realizar el
trabajo j.
Con todo esto, el problema consiste en asignar las personas a los trabajos con el mnimo costo
(o el mximo valor).
Al igual que en los otros modelos de asignacin vistos, se introducen variables xij que valen 1 si
la persona i se asigna al trabajo j y 0 en otro caso.

n n
MIN c x
i 1 j 1
ij ij
s.t. :
n
x
i 1
ij 1 j 1,2,...,n
n
a x
j 1
ij ij bi i 1,2,...,n
xij 0,1
En este modelo de asignacin se puede asignar una persona a ms de un trabajo, respetando

obviamente las limitaciones en los recursos.
Algunas de las aplicaciones ms relevantes son:
Asignacin de clientes a camiones (de reparto o recogida) de mercancas.

Asignacin de tareas a programadores.
Asignacin de trabajos a una red de computadores.
2.3.6 Problema de la Ordenacin Lineal
Este problema consiste en determinar una permutacin p de las filas y columnas de una matriz
cuadrada dada, de manera que la suma de los elementos por encima de la diagonal sea
mxima. Notar que la permutacin p proporciona el orden tanto de las filas como de las
columnas.
En trminos econmicos este problema es equivalente al de triangulacin de matrices input-

output, que puede describirse del siguiente modo: La economa de una regin se divide en m
sectores, se construye una matriz m*m donde la entrada aij denota la cantidad de mercancas
(en valor monetario) que el sector i sirve al j en un ao dado. El problema de triangulacin
consiste en permutar las filas y columnas de la matriz simultneamente de manera que la
suma de elementos por encima de la diagonal sea lo mayor posible. Una solucin ptima
presenta una ordenacin de sectores de modo que los proveedores (sectores que producen
para otros) van en primer lugar seguidos de los consumidores.
Este problema tambin puede enunciarse en trminos de grafos, lo cual ayuda a formularlo del
siguiente modo:
n n
MAX
i 1 j 1
cij xij
s.t. :
xij x ji 1 i, j V , i j
xij x jk xki 2 1 i < j < k n
xij 0,1

Donde xij=1 representa que el sector (vrtice) i precede al j en la ordenacin dada por la
solucin.
2.4 Medidas de Calidad de un Algoritmo
Un buen algoritmo heurstico debe de tener las siguientes propiedades:
1. Eficiente. Un esfuerzo computacional realista para obtener la solucin.

2. Bueno. La solucin debe de estar, en promedio, cerca del ptimo.
3. Robusto. La probabilidad de obtener una mala solucin (lejos del ptimo) debe
ser baja.
Para medir la calidad de un heurstico existen diversos procedimientos, entre los que se
encuentran los siguientes:
2.4.1 Comparacin con la solucin ptima
Aunque normalmente se recurre al algoritmo aproximado por no existir un mtodo exacto

para obtener el ptimo, o por ser ste computacionalmente muy costoso, en ocasiones puede
ser que dispongamos de un procedimiento que proporcione el ptimo para un conjunto
limitado de ejemplos (usualmente de tamao reducido). Este conjunto de ejemplos puede
servir para medir la calidad del mtodo heurstico.
Normalmente se mide, para cada uno de los ejemplos, la desviacin porcentual de la solucin
heurstica frente a la ptima, calculando posteriormente el promedio de dichas desviaciones.
Si llamamos ch al valor objetivo en la solucin del algoritmo heurstico y copt al valor objetivo de
la solucin ptima de un ejemplo dado, en un problema de optimizacin el GAP absoluto
(desviacin absoluta) viene dada por la expresin:
= | |
Y el GAP relativo (desviacin relativa) como:
| |
= 100%

2.4.2 Comparacin con una cota
En ocasiones el ptimo del problema no est disponible ni siquiera para un conjunto limitado
de ejemplos. Un mtodo alternativo de evaluacin consiste en comparar el valor de la solucin
que proporciona el heurstico con una cota del problema (inferior si es un problema de
minimizacin y superior si es de maximizacin). Obviamente la bondad de esta medida
depender de la bondad de la cota (cercana de sta al ptimo), por lo que, de alguna manera,
tendremos que tener informacin de lo buena que es dicha cota. En caso contrario la
comparacin propuesta no tiene demasiado inters.

2.4.3 Comparacin con un mtodo exacto truncado
Un mtodo enumerativo como el de Ramificacin y Acotacin explora una gran cantidad de

soluciones, aunque sea nicamente una fraccin del total, por lo que los problemas de grandes
dimensiones pueden resultar computacionalmente inabordables con estos mtodos. Sin
embargo, podemos establecer un lmite de iteraciones (o de tiempo) mximo de ejecucin
para el algoritmo exacto.
Tambin podemos saturar un nodo en un problema de maximizacin cuando su cota inferior

sea menor o igual que la cota superior global ms un cierto (anlogamente para el caso de
minimizar). De esta forma se garantiza que el valor de la mejor solucin proporcionada por el
procedimiento no dista ms de del valor ptimo del problema. En cualquier caso, la mejor
solucin encontrada con estos procedimientos truncados proporciona una cota con la que
contrastar el heurstico.
2.4.4 Comparacin con otros heursticos
Este es uno de los mtodos ms empleados en problemas difciles (NP-duros) sobre los que se
ha trabajado durante tiempo y para los que se conocen algunos buenos heursticos. Al igual
que ocurre con la comparacin con las cotas, la conclusin de dicha comparacin est en
funcin de la bondad del heurstico escogido.
2.4.5 Anlisis del peor caso (worst case analisys)
Uno de los mtodos que durante un tiempo tuvo bastante aceptacin es analizar el
comportamiento en el peor caso del algoritmo heurstico; esto es, considerar los ejemplos que
sean ms desfavorables para el algoritmo y acotar analticamente la mxima desviacin
respecto del ptimo del problema. Lo mejor de este mtodo es que acota el resultado del
algoritmo para cualquier ejemplo; sin embargo, por esto mismo, los resultados no suelen ser
representativos del comportamiento medio del algoritmo. Adems, el anlisis puede ser muy
complicado para los heursticos ms sofisticados.
Aquellos algoritmos que, para cualquier ejemplo, producen soluciones cuyo costo no se aleja
de un porcentaje del costo de la solucin ptima, se llaman Algoritmos -Aproximados. Esto
es; en un problema de minimizacin se tiene que cumplir para un > 0 que:
ch (1+) copt

3. Mtodos Constructivos
Los mtodos constructivos son procedimientos iterativos que, en cada paso, aaden un
elemento hasta completar una solucin. Usualmente son mtodos deterministas y estn
basados en seleccionar, en cada iteracin, el elemento con mejor evaluacin. Estos mtodos
son muy dependientes del problema que resuelven, por lo que utilizaremos el Problema del
Agente Viajero (TSP) para describirlos. En este captulo se describen cuatro de los mtodos
ms conocidos para el TSP.
3.1 Heursticos del Vecino ms Cercano
Uno de los heursticos ms sencillos para el TSP es el llamado del vecino ms cercano, que es
un algoritmo glotn (Greedy) que trata de construir un ciclo Hamiltoniano de bajo costo
basndose en el vrtice cercano a uno dado. Este algoritmo en una versin estndar tiene el
siguiente cdigo:
Algoritmo del Vecino ms cercano
Inicializacin
Seleccionar un vrtice j al azar.
Hacer t = j y W = V \ {j}.
Mientras ( W )
Tomar j de W / ctj = min {cti / i en W}
Conectar t a j
Hacer W = W \ {j} y t =j.
Este procedimiento realiza un nmero de operaciones de orden O(n2). Si seguimos la evolucin

del algoritmo al construir la solucin de un ejemplo dado, veremos que comienza muy bien,
seleccionando aristas de bajo costo. Sin embargo, al final del proceso probablemente
quedarn vrtices cuya conexin obligar a introducir aristas de costo elevado. Esto es lo que
se conoce como miopa del procedimiento, ya que, en una iteracin escoge la mejor opcin
disponible sin ver que esto puede obligar a realizar malas elecciones en iteraciones
posteriores.
El algoritmo tal y como aparece puede ser programado en unas pocas lneas de cdigo. Sin
embargo una implementacin directa ser muy lenta al ejecutarse sobre ejemplos de gran
tamao (10,000 vrtices). As pues, incluso para un heurstico tan sencillo como ste, es
importante pensar en la eficiencia y velocidad de su cdigo.
Para reducir la miopa del algoritmo y aumentar su velocidad se introduce el concepto de

subgrafo candidato, junto con algunas modificaciones en la exploracin.

Un subgrafo candidato es un subgrafo del grafo completo con los vrtices y nicamente las
aristas consideradas atractivas para aparecer en un ciclo Hamiltoniano de bajo costo. Una
posibilidad es tomar, por ejemplo, el subgrafo de los k vecinos ms cercanos; esto es, el
subgrafo con los vrtices y para cada uno de ellos las aristas que lo unen con los k vrtices
ms cercanos. Este subgrafo tambin ser usado en otros procedimientos.
El algoritmo puede mejorarse en los siguientes aspectos:
Para seleccionar el vrtice j que se va a unir a t (y por lo tanto al tour parcial en

construccin), en lugar de examinar todos los vrtices, se examinan nicamente los
adyacentes a t en el subgrafo candidato. Si todos ellos estn ya en el tour parcial, entonces
s que se examinan todos los posibles.
Cuando un vrtice queda conectado (con grado 2) al tour en construccin, se eliminan del
subgrafo candidato las aristas incidentes con l.
Se especifica un nmero s < k de modo que cuando un vrtice que no est en el tour est
conectado nicamente a s o menos aristas del subgrafo candidato se considera que se est
quedando aislado. Por ello se inserta inmediatamente en el tour. Como punto de insercin
se toma el mejor de entre los k vrtices ms cercanos presentes en el tour.
Considerando el estudio emprico sobre las 30 ejemplos utilizados, la versin inicial del
algoritmo presenta un porcentaje de desviacin en promedio respecto del ptimo de 24.2%,
mientras que la mejorada con k=10 y s=4 de 18.6%. La primera tiene un tiempo de ejecucin
medio de 15.3 segundos mientras que la segunda lo tiene de 0.3 segundos.
EJERCICIO:
Implemente un cdigo para hallar una solucin al TSP por medio del algoritmo del vecino ms
cercano.
3.2 Heursticos de Insercin
Otra aproximacin intuitiva a la resolucin del TSP consiste en comenzar construyendo ciclos
que visiten nicamente unos cuantos vrtices, para posteriormente extenderlos insertando los
vrtices restantes. En cada paso se inserta un nuevo vrtice en el ciclo hasta obtener un ciclo
Hamiltoniano. Este procedimiento es debido a los mismos autores que el anterior y su
esquema es el siguiente:
Algoritmo de Insercin
Inicializacin
Seleccionar un ciclo inicial (subtour) con k vrtices.
Hacer W = V \ {vrtices seleccionados}.
Mientras ( W )
Tomar j de W de acuerdo con algn criterio preestablecido

Insertar j donde menos incremente la longitud del ciclo
Hacer W = W \ {j}.
Existen varias posibilidades para implementar el esquema anterior de acuerdo con el criterio
de seleccin del vrtice j de W a insertar en el ciclo. Se define la distancia de un vrtice v al
ciclo como el mnimo de las distancias de v a todos los vrtices del ciclo:
dmin (v) = min { civ / i V \ W }
Los criterios ms utilizados son:
Insercin ms cercana: Seleccionar el vrtice j ms cercano al ciclo.
dmin (j) = min { dmin (v) / v W }
Insercin ms lejana: Seleccionar el vrtice j ms lejano al ciclo.
dmin (j) = max { dmin (v) / v W }
Insercin ms barata: Seleccionar el vrtice j que ser insertado
con el menor incremento del costo.
Insercin aleatoria: Seleccionar el vrtice j al azar.
La figura 2 muestra la diferencia entre estos criterios en un caso dado. El ciclo actual est
formado por 4 vrtices y hay que determinar el prximo a insertar. La insercin ms cercana
escoger el vrtice i, la ms lejana el s y la ms barata el k.
i
k
Figura 2. Seleccin del vrtice a insertar
Todos los mtodos presentan un tiempo de ejecucin de O(n2) excepto la insercin ms

cercana que es de O(n2log n). Respecto al estudio emprico sobre los 30 grafos de la TSPLIB los
porcentajes de desviacin del ptimo son de 20%, 9.9% 16.8% y 11.1% para el ms cercano,
ms lejano, ms barato y aleatorio, respectivamente, aunque el tiempo de ejecucin del ms
barato es mucho mayor. Respecto al ciclo inicial se ha tomado k=3 vrtices y se comprueba
experimentalmente que el procedimiento no depende mucho del ciclo inicial
(aproximadamente un 6% de variacin).

EJERCICIO:
Implemente un cdigo para hallar una solucin al TSP por medio del algoritmo de insercin.
3.3 Heursticos Basados en rboles Generadores
Los heursticos considerados anteriormente construyen un ciclo Hamiltoniano basndose

nicamente en los costos de las aristas. Los heursticos de este apartado se basan en el rbol
generador de costo mnimo, lo que aporta una informacin adicional sobre la estructura del
grafo. Comenzaremos por ver algunos conceptos de teora de grafos.
Un grafo es conexo si todo par de vrtices est unido por un camino.

Un rbol es un grafo conexo que no contiene ciclos. El nmero de aristas de un rbol es
igual al nmero de vrtices menos uno.
Un rbol generador de un grafo G=(V,A,C) es un rbol sobre todos los vrtices y tiene, por
tanto, |V| - 1 aristas de G.
Un rbol generador de mnimo peso (o de costo mnimo) es aquel que de entre todos los
rboles generadores de un grafo dado, presenta la menor suma de los costos de sus aristas.
Un acoplamiento de un grafo G=(V,A,C) es un subconjunto M del conjunto A de aristas
cumpliendo que cada vrtice del grafo es a lo sumo incidente con una arista de M.
Un acoplamiento sobre un grafo G=(V,A,C) es perfecto si es de cardinalidad mxima e igual
a V/ 2.
Las figuras siguientes ilustran los conceptos vistos sobre un grafo completo de 8 vrtices. En la
figura 3 tenemos un rbol generador. Notar que contiene a todos los vrtices y no hay ningn
ciclo. La figura 4 muestra un acoplamiento perfecto en el que podemos ver cmo cada vrtice
es incidente con una, y solo una, de las aristas. Al ser un grafo de 8 vrtices el nmero mximo
de aristas en un acoplamiento es de 4, por lo que el de la figura es perfecto.
5 5
1 1
6 6
3 3
2 2
7 7
4 4
8 8
Figura 3. rbol generador Figura 4. Acoplamiento Perfecto
El algoritmo debido a Prim (1957) obtiene un rbol generador de mnimo peso de un grafo G
completo. El algoritmo comienza por definir el conjunto T de aristas del rbol (inicialmente
vaco) y, el conjunto U de vrtices del rbol (inicialmente formado por uno elegido al azar). En
cada paso se calcula la arista de menor costo que une U con V\U, aadindola a T y pasando su
vrtice adyacente de V\U a U. El procedimiento finaliza cuando U es igual a V; en cuyo caso el
conjunto T proporciona la solucin.

Dado un ciclo vi0, vi1,, vik que pasa por todos los vrtices de G (no necesariamente simple), el
siguiente procedimiento obtiene un ciclo Hamiltoniano comenzando en vi0 y terminando en vik
(vi0= vik). En el caso de grafos con costos cumpliendo la desigualdad triangular (como es el caso
de grafos eucldeos), este procedimiento obtiene un ciclo de longitud menor o igual que la del
ciclo de partida.
Algoritmo de Obtencin de Tour

Inicializacin
Hacer T = { vi0 }, v = vi0 y s=1.
Mientras ( |T| < |V| )
Si vi s no est en T, hacer:
T = T { vi s }
Conectar v a vi s y hacer v = vi s
Hacer s = s+1
Conectar v a vi0 y formar el ciclo Hamiltoniano
A partir de los elementos descritos se puede disear un algoritmo para obtener un ciclo
Hamiltoniano. Basta con construir un rbol generador de mnimo peso (figura 5), considerar el
ciclo en el que todas las aristas del rbol son recorridas dos veces, cada vez en un sentido
(figura 6), y aplicar el algoritmo de obtencin de tour a dicho ciclo (figura 7). El ejemplo de las
figuras mencionadas ilustra dicho procedimiento sobre un grafo completo con 10 vrtices.
16 3 4
3 4
25
2 2
25 1 1
19
10 10
15 14
5 9 5 9
19
7 7
8 8
17 6 9 6
Figura 5. rbol Generador Figura 6. Duplicacin de aristas Figura 7. Ciclo Hamiltoniano
La figura 5 muestra un rbol generador de mnimo peso e igual a 156. En la figura 6 se han
duplicado las aristas y se seala mediante flechas la direccin del ciclo resultante. Su costo
obviamente ser de 156x2=312.
Aplicando el procedimiento de obtencin de tour al ciclo de la figura 6, se obtiene el ciclo

Hamiltoniano de la figura 7 con un costo de 258.
El proceso de duplicacin de las aristas (recorrerlas todas en ambos sentidos) para obtener un
tour aumenta en gran medida el costo de la solucin. Podemos ver que es posible obtener un

ciclo que pase por todos los vrtices de G a partir de un rbol generador sin necesidad de
duplicar todas las aristas. De hecho, basta con aadir aristas al rbol de modo que todos los
vrtices tengan grado par.
El siguiente procedimiento, debido a Christofides (1976), calcula un acoplamiento perfecto de

mnimo peso sobre los vrtices de grado impar del rbol generador. Aadiendo al rbol las
aristas del acoplamiento se obtiene un grafo con todos los vrtices pares, y por lo tanto, un
ciclo del grafo original, a partir del cual ya hemos visto cmo obtener un tour.
Algoritmo de Christofides
1. Calcular un rbol Generador de Mnimo Peso
2. Obtener el conjunto de vrtices de grado impar en el rbol.
3. Obtener un Acoplamiento Perfecto de mnimo peso sobre dichos vrtices.
4. Aadir las aristas del Acoplamiento al rbol.
5. Aplicar el procedimiento de Obtencin de Tour.
El clculo del acoplamiento perfecto de costo mnimo sobre un grafo de k vrtices se realiza en
un tiempo O(k3) con el algoritmo de Edmonds (1965). Dado que un rbol generador de
mnimo peso tiene como mximo n-1 hojas (vrtices de grado 1 en el rbol), el procedimiento
de Christofides tendr un tiempo de orden O(n3).
Propiedad: El algoritmo de Christofides sobre ejemplos cuya matriz de distancias cumple la

desigualdad triangular produce una solucin cuyo valor es como mucho 1.5 veces el valor
ptimo:
3
cH c
2 OPT
Es decir, es un algoritmo - aproximado sobre esta clase de ejemplos.
Prueba:
Sea c(AGMP) el costo del rbol generador de mnimo peso y c(A) el costo del acoplamiento
perfecto calculado en el algoritmo de Christofides. Al aadir las aristas del acoplamiento al
rbol se obtiene un ciclo (con posibles repeticiones) cuyo costo es la suma de ambos costos.
Dado que la matriz de distancias cumple la desigualdad triangular, al aplicar el algoritmo de
obtencin de tour el costo puede reducirse eventualmente. Por ello el costo de la solucin
obtenida, cH, cumple:
cH c(AGMP) + c(A) (1)
Un rbol generador de mnimo peso, por construccin, tiene un costo menor que cualquier
ciclo Hamiltoniano y, por lo tanto, que el ciclo Hamiltoniano de costo mnimo (tour ptimo).
Para probarlo basta con considerar un ciclo Hamiltoniano y quitarle una arista, con lo que se
obtiene un rbol generador.

El rbol generador de mnimo peso tiene, obviamente, un costo menor que dicho rbol
generador y, por lo tanto, que el ciclo Hamiltoniano.
Luego:
c(AGMP) cOPT (2)
El acoplamiento del paso 3 del algoritmo de Christofides tiene un costo menor o igual que la
mitad de la longitud de un tour ptimo en un grafo Eucldeo. Para probarlo consideremos un
tour ptimo y llamemos S al conjunto de vrtices de grado impar en el rbol. El algoritmo
calcula un acoplamiento perfecto de costo mnimo sobre los vrtices de S. La figura 8 muestra
un ciclo Hamiltoniano ptimo y los vrtices de S en oscuro. Adems aparecen dos
acoplamientos perfectos sobre S, A1 (trazo continuo) y A2 (trazo discontinuo), en donde cada
vrtice est acoplado al ms prximo en el tour ptimo.
Figura 8. Dos acoplamientos sobre S
Como se cumple la desigualdad triangular, se tiene que c(A1)+c(A2) cOPT. . Es evidente que por
ser el de costo mnimo c(A) c(A1) y c(A) c(A2), de donde:
2 c(A) cOPT (3)
De (1), (2) y (3) se concluye el resultado.
Las figuras siguientes ilustran el mtodo de Christofides sobre el mismo ejemplo de las figuras
5, 6 y 7. En la figura 9 aparecen oscurecidos los vrtices de grado impar en el rbol generador,
y en trazo discontinuo las aristas del acoplamiento perfecto de costo mnimo sobre tales
vrtices. Al aadirlas se obtiene un tour de costo 199. La figura 10 muestra el ciclo
Hamiltoniano que se obtiene al aplicarle el procedimiento de obtencin del ciclo al tour de la
figura anterior. La solucin tiene un costo de 203, mientras que la obtenida con el
procedimiento de duplicar aristas (figura 7) tena un costo de 258.

16 16
3 4 3 4
25 25
21
21
2 2
25 19 1 19 1
10 10
15 14 15 14
5 9 5 9
48
19 19
19
7 7
8 8
6 9 6 9
17 17
Figura 9. Acoplamiento Perfecto Figura 10. Ciclo Hamiltoniano.
El procedimiento del rbol generador y posterior duplicacin de aristas obtiene, sobre el

conjunto de ejemplos considerados de la TSPLIB, una desviacin del ptimo de 38%, mientras
que el heurstico de Christofides de 19.5%.
3.4 Heursticos Basados en Ahorros
Los mtodos de esta seccin son debidos a Clarke y Wright (1964) y fueron propuestos
inicialmente para problemas de rutas de vehculos. Veamos una adaptacin de estos
procedimientos al Problema del Agente Viajero.
El algoritmo siguiente se basa en combinar sucesivamente subtours hasta obtener un ciclo

Hamiltoniano. Los subtours considerados tienen un vrtice comn llamado base.
El procedimiento de unin de subtours se basa en eliminar las aristas que conectan dos
vrtices de diferentes subtours con el vrtice base, uniendo posteriormente los vrtices entre
si. Llamamos ahorro a la diferencia del costo entre las aristas eliminadas y la aadida.
Algoritmo de Ahorros
Inicializacin
Tomar un vrtice zV como base.
Establecer los n-1 subtours [( z,v),(v,z)] vV \{z} .
Mientras ( Queden dos o ms subtours )
Para cada par de subtours calcular el ahorro de unirlos al eliminar en
cada uno una de las aristas que lo une con z y conectar los dos vrtices
asociados.
Unir los dos subtours que produzcan un ahorro mayor.
En las figuras 11 y 12 se ilustra una iteracin del procedimiento. Podemos ver cmo se
combinan dos subtours eliminando las aristas de los vrtices i y j al vrtice base z, e insertando
la arista (i,j).

i i
z j z j
Figura 11. Conjunto inicial de Figura 12. Conjunto final de

subtours subtours
En la implementacin del algoritmo se tiene que mantener una lista con las combinaciones
posibles. El punto clave de la implementacin es la actualizacin de esta lista.
Sin embargo, al unir dos subtours nicamente se ven afectados aquellos en los que su mejor
conexin pertenece a alguno de los dos subtours recin unidos. Luego basta con actualizar
estos en cada iteracin sin necesidad de actualizarlos todos cada vez que se realiza una unin.
Al igual que en otros heursticos, podemos utilizar el subgrafo candidato (en el que estn todos
los vrtices y slo las aristas consideradas atractivas) para acelerar los clculos. As, al
actualizar la lista de la mejores conexiones nicamente se consideran aristas del subgrafo
candidato.
El mtodo presenta un tiempo de ejecucin de O(n3). Respecto al estudio emprico sobre los
30 ejemplos de la TSPLIB los porcentajes de desviacin respecto del ptimo son de 9.8% para
el mtodo original y 9.6% para el mejorado con el uso del subgrafo candidato. Adems, el
tiempo de ejecucin es mucho menor para este ltimo.
La siguiente tabla recoge los resultados del estudio comparativo sobre los cuatro algoritmos
descritos, con los 30 ejemplos de la TSPLIB considerados:
Heurstico Desviacin T. Ejecucin

del ptimo (pr2392)
Vecino ms cercano (bsico) 24.2% 29.2
Vecino ms cercano (mejorado) 18.6% 0.30
Insercin ms Lejana 9.9% 35.4
MST/duplicacin de aristas 38.0% 1.2
Christofides 19.5% 0.70
Ahorros 9.6% 5.07
Todos los mtodos estn basados en clculos relativamente sencillos y han sido
implementados eficientemente, por lo que los tiempos de computacin son muy parecidos
entre s e inferiores a 1 segundo en promedio. Por ello, para distinguir entre todos, en la tabla

se muestra el tiempo en segundos sobre el ejemplo de mayor tamao considerado (pr2392) de

casi 2,400 vrtices.
A la vista de los resultados podemos concluir que tanto el mtodo de los ahorros como el de
insercin basado en el elemento ms lejano son los que mejores resultados obtienen, aunque
presentan un tiempo de computacin mayor que los otros dos.

4. Mtodos de Bsqueda Local

En general, las soluciones obtenidas con los mtodos constructivos suelen ser de una calidad
moderada. En este apartado vamos a estudiar diversos algoritmos basados en la bsqueda
local para mejorarlas. Al igual que ocurra con los mtodos descritos en la seccin anterior,
estos algoritmos son muy dependientes del problema que resuelven, por lo que al igual que
all, utilizaremos el TSP para describirlos. Especficamente, consideraremos tres de los
mtodos ms utilizados, tal y como aparecen descritos en Jnger, Reinelt y Rinaldi (1995).
Comenzaremos por definir y explicar algunos de los conceptos genricos de estos mtodos.
Los procedimientos de bsqueda local, tambin llamados de mejora, se basan en explorar el

entorno o vecindad de una solucin. Utilizan una operacin bsica llamada movimiento que,
aplicada sobre los diferentes elementos de una solucin, proporciona las soluciones de su
entorno. Formalmente:
Definicin: Sea X el conjunto de soluciones del problema combinatorio. Cada solucin x tiene
un conjunto de soluciones asociadas N(x) X, que denominaremos entorno de x.
Definicin: Dada una solucin x, cada solucin de su entorno, x N(x), puede obtenerse
directamente a partir de x mediante una operacin llamada movimiento.
Un procedimiento de bsqueda local parte de una solucin inicial x0, calcula su entorno N(x0) y
escoge una nueva solucin x1 en l. Dicho de otro modo, realiza el movimiento m1 que
aplicado a x0 da como resultado x1. Este proceso puede ser aplicado reiteradamente tal y
como muestra el diagrama siguiente:
x0 1 x1 2 x2 3 x3
m m m
Un procedimiento de bsqueda local queda determinado al especificar un entorno y el criterio

de seleccin de una solucin dentro del entorno.
La definicin de entorno/movimiento, depende en gran medida de la estructura del problema

a resolver, as como de la funcin objetivo. Tambin se pueden definir diferentes criterios para
seleccionar una nueva solucin del entorno. Uno de los criterios ms simples consiste en
tomar la solucin con mejor evaluacin de la funcin objetivo, siempre que la nueva solucin
sea mejor que la actual. Este criterio, conocido como Greedy (glotn o voraz), permite ir
mejorando la solucin actual mientras se pueda. El algoritmo se detiene cuando la solucin no
puede ser mejorada. A la solucin encontrada se le denomina ptimo local respecto al
entorno definido.
El ptimo local alcanzado no puede mejorarse mediante el movimiento definido. Sin embargo,
el mtodo empleado no permite garantizar, de ningn modo, que sea el ptimo global del
problema. Ms an, dada la miopa de la bsqueda local, es de esperar que en problemas de
cierta dificultad, en general no lo sea.
La figura 13 muestra el espacio de soluciones de un problema de maximizacin de dos

dimensiones donde la altura del grfico (el eje ) mide el valor de la funcin objetivo. Se

considera un procedimiento de bsqueda local greedy iniciado a partir de una solucin x0 con
valor 0.00001 y que realiza 8 movimientos de mejora hasta alcanzar la solucin x8 con valor
0.000015. La figura muestra cmo x8 es un ptimo local y cualquier movimiento que se le
aplique proporcionar una solucin con peor valor. Podemos ver cmo el ptimo global del
problema, con un valor de 0.00002, no puede ser alcanzado desde x8, a menos que
permitamos realizar movimientos que empeoren el valor de las soluciones y sepamos dirigir
correctamente la bsqueda
PTIMO GLOBAL
8 (PTIMO LOCAL)
0 (VALOR INICIAL)
Figura 13. ptimo local y global
Esta limitacin de la estrategia greedy es el punto de partida de los procedimientos

Metaheursticos basados en bsqueda local: evitar el quedar atrapados en un ptimo local
lejano del global. Para lo cual, como hemos visto, se hace preciso el utilizar movimientos que
empeoren la funcin objetivo. Sin embargo esto plantea dos problemas. El primero es que al
permitir movimientos de mejora y de no mejora, el procedimiento se puede ciclar, revisitando
soluciones ya vistas, por lo que habra que introducir un mecanismo que lo impida. El segundo
es que hay que establecer un criterio de parada ya que un procedimiento de dichas
caractersticas podra iterar indefinidamente. Los procedimientos Metaheursticos incorporan
mecanismos sofisticados para solucionar eficientemente ambas cuestiones as como para
tratar, en la medida de lo posible, de dirigir la bsqueda de forma inteligente.
Pese a la miopa de los mtodos de bsqueda local simples, suelen ser muy rpidos y
proporcionan soluciones que, en promedio, estn relativamente cerca del ptimo global del
problema. Adems, dichos mtodos suelen ser el punto de partida en el diseo de algoritmos
Metaheursticos ms complejos. En este apartado vamos a estudiar algunos mtodos
heursticos de bsqueda local para el Problema del Agente Viajero.
4.1 Procedimientos de 2 intercambio
Este procedimiento est basado en la siguiente observacin para grafos eucldeos. Si un ciclo
Hamiltoniano se cruza a si mismo, puede ser fcilmente acortado, basta con eliminar las dos
aristas que se cruzan y reconectar los dos caminos resultantes mediante aristas que no se
corten. El ciclo final es ms corto que el inicial.

Un movimiento 2-opt consiste en eliminar dos aristas y reconectar los dos caminos resultantes
de una manera diferente para obtener un nuevo ciclo. Las figuras 14 y 15 ilustran este
movimiento en el que las aristas (i,j) y (l,k) son reemplazadas por (l,j) y (i,k). Notar que slo
hay una manera de reconectar los dos caminos formando un nico tour.
l l
i i
j k j k
Figura 14. Solucin original Figura 15. Solucin mejorada
El siguiente cdigo recoge el algoritmo heurstico de mejora 2-ptimo. Consiste en examinar

todos los vrtices, realizando, en cada paso, el mejor movimiento 2-opt asociado a cada
vrtice.
Algoritmo 2-ptimo
Inicializacin
Considerar un ciclo Hamiltoniano inicial
move = 1
Mientras (move = 1)
move=0. Etiquetar todos los vrtices como no explorados.
Mientras (Queden vrtices por explorar)
Seleccionar un vrtice i no explorado.
Examinar todos los movimientos 2-opt que incluyan la arista de i a su

sucesor en el ciclo. Si alguno de los movimientos examinados reduce la
longitud del ciclo, realizar el mejor de todos y hacer move = 1. En otro caso
etiquetar i como explorado.

La variable move vale 0 si no se ha realizado ningn movimiento al examinar todos los vrtices,
y 1 en otro caso. El algoritmo finaliza cuando move=0, con lo que queda garantizado que no
existe ningn movimiento 2-opt que pueda mejorar la solucin.
El orden en el que el algoritmo examina los nodos incide de manera notable en su

funcionamiento. En una implementacin sencilla podemos considerar el orden natural 1,2,..,.
Sin embargo, es fcil comprobar que cuando se realiza un movimiento hay muchas
posibilidades de encontrar movimientos de mejora asociados a los vrtices que han
intervenido en el movimiento recin realizado. Por ello, una implementacin ms eficiente
consiste en considerar una lista de vrtices candidatos a examinar. El orden inicial es el de los
vrtices en el ciclo comenzando por uno arbitrario y en cada iteracin se examina el primero
de la lista. Cada vez que se examina un vrtice , ste se coloca al final de la lista y, los vrtices
involucrados en el movimiento (vrtices , y de la figura 15) se insertan en primer lugar.
Dado que el proceso de examinar todos los movimientos 2-opt asociados a cada vrtice es muy
costoso computacionalmente, se pueden introducir las siguientes mejoras para acelerar el
algoritmo:
Exigir que al menos una de las dos aristas aadidas en cada movimiento, para formar la
nueva solucin, pertenezca al subgrafo candidato.
Observando el funcionamiento del algoritmo se puede ver que en las primeras iteraciones
la funcin objetivo decrece substancialmente, mientras que en las ltimas apenas se
modifica. De hecho la ltima nicamente verifica que es un ptimo local al no realizar
ningn movimiento. Por ello, si interrumpimos el algoritmo antes de su finalizacin,
ahorraremos bastante tiempo y no perderemos mucha calidad.
Es evidente que ambas mejoras reducen el tiempo de computacin a expensas de perder la

garanta de que la solucin final es un ptimo local. As pues, dependiendo del tamao del
ejemplo a resolver, as como de lo crtico que sea el tiempo de ejecucin, se deben
implementar o no.
El comprobar si existe, o no, un movimiento 2-opt de mejora utiliza un tiempo de orden O(n2),
ya que hay que examinar todos los pares de aristas en el ciclo. Podemos encontrar clases de
problemas para los que el tiempo de ejecucin del algoritmo no est acotado
polinmicamente. Respecto al estudio emprico sobre los ejemplos de la TSPLIB considerados,
partiendo de la solucin del algoritmo del Vecino ms cercano, el promedio de desviacin del
ptimo es del 8.3%.
4.2 Procedimientos de k - intercambio
Para introducir mayor flexibilidad al modificar un ciclo Hamiltoniano, podemos considerar el

dividirlo en k partes, en lugar de dos, y combinar los caminos resultantes de la mejor manera
posible. Llamamos movimiento k-opt a tal modificacin.
Es evidente que al aumentar k aumentar el tamao del entorno y el nmero de posibilidades

a examinar en el movimiento, tanto por las posibles combinaciones para eliminar las aristas del

ciclo, como por la reconstruccin posterior. El nmero de combinaciones para eliminar k

aristas en un ciclo viene dado por el nmero n
k
Examinar todos los movimientos k-opt de una solucin lleva un tiempo del orden de O(nk) por
lo que, para valores altos de k, slo es aplicable a ejemplos de tamao pequeo.
En este apartado vamos a estudiar el caso de k=3 y adems impondremos ciertas restricciones
para reducir el entorno y poder realizar los clculos en un tiempo razonable.
En un movimiento 3-opt, una vez eliminadas las tres aristas hay ocho maneras de conectar los
tres caminos resultantes para formar un ciclo. Las figuras siguientes ilustran algunos de los
ocho casos. La figura 16 muestra el ciclo inicial en el que se encuentran las aristas (a, b), (c, d)
y (e, f) por las que se dividir ste. La figura 17 utiliza la propia arista (e,f) para reconstruir el
ciclo, por lo que, este caso equivale a realizar un movimiento 2-opt sobre las aristas (a,b) y
(c,d). Anlogamente podemos considerar los otros dos casos en los que se mantiene una de
las tres aristas en el ciclo y se realiza un movimiento 2-opt sobre las restantes. Las figuras 18 y
19 muestran un movimiento 3-opt puro en el que desaparecen del ciclo las tres aristas
seleccionadas.
e e
a a
f f
b b
c c
d d
Figura 16. Ciclo inicial Figura 17. Movimiento 2-opt
e e
a a
f f
b b
c c
d d
Figura 18. Movimiento 3-opt Figura 19. Movimiento 3-opt

A diferencia de los movimientos 2-opt, el reconstruir el ciclo una vez eliminadas las tres aristas
es muy costoso. Notar que la direccin en el ciclo puede cambiar en todos los caminos menos
en el ms largo por lo que hay que realizar varias actualizaciones. Adems, el mero hecho de
examinar todas las posibilidades representa un esfuerzo computacional enorme (ms de 1
hora en los problemas considerados). Por ello, se consideran nicamente algunos de los
movimientos 3-opt. En concreto se define para cada vrtice i un conjunto de vrtices N(i) de
modo que al examinar los movimientos 3-opt asociados a una arista (i,j), nicamente se
consideran aquellos en los que las otras dos aristas tengan al menos uno de los vrtices en
N(i). Una posibilidad para definir N(i) consiste en considerar los vrtices adyacentes a i en el
subgrafo candidato.
Algoritmo 3-ptimo restringido

Inicializacin
Para cada vrtice i definir un conjunto de vrtices N(i)
move = 1
Mientras (move = 1)
move=0
Etiquetar todos los vrtices como no explorados.
Mientras (Queden vrtices por explorar)
Examinar todos los movimientos 3-opt que eliminen 3 aristas teniendo

cada una, al menos un vrtice en N(i).
Si alguno de los movimientos examinados reduce la longitud del ciclo,

realizar el mejor de todos y hacer move = 1. En otro caso etiquetar i
como explorado.
El promedio de las desviaciones al ptimo sobre el conjunto test considerado (TSPLIB) es de

3.8% con esta versin restringida, partiendo de la solucin del Vecino ms cercano, y de 3.9%
partiendo de una solucin al azar.
4.3 Algoritmo de Lin y Kernighan
Como vimos en la introduccin a los mtodos de mejora (figura 13), el problema de los
algoritmos de bsqueda local es que suelen quedarse atrapados en un ptimo local. Vimos
que para alcanzar una solucin mejor a partir de un ptimo local habra que comenzar por
realizar movimientos que empeoren el valor de la solucin, lo que conducira a un esquema de

bsqueda mucho ms complejo, al utilizar el algoritmo tanto movimientos de mejora como de

no mejora.
El algoritmo de Lin y Kernighan parte de este hecho y propone un movimiento compuesto, en

donde cada una de las partes consta de un movimiento que no mejora necesariamente pero el
movimiento compuesto s es de mejora. De esta forma es como si se realizaran varios
movimientos simples consecutivos en donde algunos empeoran y otros mejoran el valor de la
solucin, pero no se pierde el control sobre el proceso de bsqueda ya que el movimiento
completo s que mejora. Adems, combina diferentes movimientos simples, lo cual es una
estrategia que ha producido muy buenos resultados en los algoritmos de bsqueda local. En
concreto la estrategia denominada cadenas de eyeccin se basa en encadenar movimientos
y ha dado muy buenos resultados en el contexto de la Bsqueda Tab.
Se pueden considerar muchas variantes para este algoritmo. En este apartado consideraremos
una versin sencilla basada en realizar dos movimientos 2-opt seguidos de un movimiento de
insercin. Ilustraremos el procedimiento mediante el ejemplo desarrollado en las figuras
siguientes sobre un grafo de 12 vrtices. Consideramos el ciclo Hamiltoniano inicial dado por el
orden natural de los vrtices y lo representamos tal y como aparece en la figura 20.
1 2 3 4 5 6 7 8 9 10 11 12
Figura 21
Figura 20
Paso 1: Realiza un movimiento 2-opt reemplazando las aristas (12,1) y (5,6) por (12,5) y (1,6).
El resultado se muestra en la figura 21.
1 2 3 4 5 6 7 8 9 10 11 12
Figura 22
Figura 21
Paso 2: Realiza un movimiento 2-opt reemplazando las aristas (6,1) y (3,4) por (6,3) y (1,4). Ver
figura 22.
1 2 3 4 5 6 7 8 9 10 11 12
Figura 23
Figura 22
Paso 3: Realiza un movimiento de insercin, insertando el vrtice 9 entre el 1 y el 4 (figura 23).
1 2 3 4 5 6 7 8 9 10 11 12
Figura 24
Figura 23

El algoritmo funciona de igual modo que el 2-ptimo o el 3-ptimo: parte de un ciclo

Hamiltoniano inicial y realiza movimientos de mejora hasta alcanzar un ptimo local.
Algoritmo de Lin y Kernighan

Inicializacin
move = 1
Mientras (move = 1)
move=0
Etiquetar todos los vrtices como no explorados.
Mientras( Queden vrtices por explorar)
Examinar todos los movimientos (2-opt, 2-opt, insercin)

que incluyan la arista de i a su sucesor en el ciclo.
Si alguno de los movimientos examinados reduce la

longitud del ciclo, realizar el mejor de todos y hacer move =
1. En otro caso etiquetar i como explorado.
Dado el gran nmero de combinaciones posibles para escoger los movimientos, es evidente
que una implementacin eficiente del algoritmo tendr que restringir el conjunto de
movimientos a examinar en cada paso. De entre las numerosas variantes estudiadas para
reducir los tiempos de computacin del algoritmo y aumentar la eficiencia del proceso,
destacamos las dos siguientes:
Utilizar el subgrafo candidato en el que nicamente figuran las aristas relativas a los 6
vecinos ms cercanos para cada vrtice. Se admiten movimientos compuestos de hasta 15
movimientos simples todos del tipo 2-opt o insercin. Para el primer movimiento simple
nicamente se examinan 3 candidatos.
El subgrafo candidato est formado por las aristas relativas a los 8 vecinos ms cercanos.
Se admiten hasta 15 movimientos simples del tipo 2-opt o insercin por cada movimiento
completo. En los 3 primeros movimientos simples nicamente se examinan 2 aristas.
Respecto al estudio computacional sobre los ejemplos de la TSPLIB considerados, la desviacin

del ptimo partiendo de la solucin del heurstico del Vecino ms cercano es de 1.9% para la
primera variante y de 1.5% para la segunda.
La siguiente tabla recoge el promedio de las desviaciones del ptimo y tiempos de ejecucin
de los 4 algoritmos de mejora considerados sobre los 30 ejemplos de la TSPLIB. Todos ellos
toman como solucin inicial la obtenida con el mtodo del Vecino ms cercano.

Heurstico Desviacin T. Ejecucin

del ptimo (pr2392)
2-ptimo 8.3 % 0.25
3-ptimo 3.8 % 85.1
Lin y Kernighan 1 1.9 % 27.7
Lin y Kernighan 2 1.5 % 74.3
Respecto a los tiempos de ejecucin, podemos ver cmo el pasar de una exploracin 2-opt a 3-
opt aumenta considerablemente el tiempo, incluso en la versin restringida planteada.
Tambin es de sealar cmo aumenta el tiempo, en casi un factor de 3, de una versin a otra
del algoritmo de Lin y Kernighan, mientras que el porcentaje de desviacin respecto del
ptimo nicamente gana un 0.4 %.
A la vista de los resultados, parece ms interesante utilizar movimientos compuestos, que

permiten controlar movimientos simples de no mejora, que utilizar movimientos k-ptimos
con valores altos de k que, por su complicacin, consumen mucho tiempo y, sin embargo, no
llegan a tan buenos resultados.

5. Mtodos Combinados
En los apartados anteriores hemos visto los mtodos constructivos que obtienen una solucin
del problema y los mtodos de mejora que, a partir de una solucin inicial, tratan de obtener
nuevas soluciones con mejor valor. Es evidente que ambos mtodos pueden combinarse,
tomando los segundos como solucin inicial la obtenida con los primeros. En este apartado
estudiaremos algunas variantes y mejoras sobre tal esquema.
Como hemos visto, una de las limitaciones ms importantes de los mtodos heursticos es la
denominada miopa provocada por seleccionar, en cada paso, la mejor opcin. Resulta muy
ilustrativo que en los mtodos de insercin, se obtengan mejores resultados al elegir al azar el
vrtice a insertar, que al tomar el elemento ms cercano (11.1% frente a 20% de promedio de
desviacin del ptimo). Sin embargo, es evidente que el tomar una opcin al azar como norma
puede conducirnos a cualquier resultado, por lo que parece ms adecuado recurrir a algn
procedimiento sistemtico que compendie la evaluacin con el azar. Veamos dos de los ms
utilizados.
5.1 Procedimientos Aleatorizados
Una modificacin en el algoritmo de construccin consiste en sustituir una eleccin greedy por
una eleccin al azar de entre un conjunto de buenos candidatos. As, en cada paso del
procedimiento, se evalan todos los elementos que pueden ser aadidos y se selecciona un
subconjunto con los mejores. La eleccin se realiza al azar sobre ese subconjunto de buenos
candidatos.
Existen varias maneras de establecer el subconjunto de mejores candidatos. En un problema

de maximizacin, en donde cuanto mayor es la evaluacin de una opcin ms atractiva
resulta, podemos destacar:
Establecer un nmero fijo k para el subconjunto de mejores candidatos e incluir los k

mejores.
Establecer un valor umbral e incluir en el conjunto todos los elementos cuya evaluacin
est por encima de dicho valor. Incluir siempre el mejor de todos.
Establecer un porcentaje respecto del mejor, e incluir en el subconjunto todos aquellos
elementos cuya evaluacin difiere, de la del mejor en porcentaje, en una cantidad menor o
igual que la establecida.
En todos los casos la eleccin final se realiza al azar de entre los preseleccionados.
Una estrategia alternativa a la anterior consiste en considerar las evaluaciones como pesos y
utilizar un mtodo probabilstico para seleccionar una opcin. As, si v1, v2,vk son los posibles
elementos a aadir en un paso del algoritmo, se calculan sus evaluaciones e1, e2,, ek, y se les
asigna un intervalo del siguiente modo:
Elemento Evaluacin Intervalo

v1 e1 [0, e1[
v2 e2 [e1, e1 +e2[


k 1 k
ei , ei
vk ek i 1 i 1
k
Se genera un nmero a al azar entre 0 y e
i 1
i , y se selecciona el elemento correspondiente al
intervalo que contiene a a.
Al algoritmo constructivo modificado, tanto con la opcin primera como con la segunda, lo
llamaremos algoritmo constructivo aleatorizado. Este algoritmo puede que produzca una
solucin de peor calidad que la del algoritmo original. Sin embargo, dado que el proceso no es
completamente determinista, cada vez que lo realicemos sobre un mismo ejemplo
obtendremos resultados diferentes. Esto permite definir un proceso iterativo consistente en
ejecutar un nmero prefijado de veces (MAX_ITER) el algoritmo y quedarnos con la mejor de
las soluciones obtenidas. Obviamente, cada una de dichas soluciones puede mejorarse con un
algoritmo de bsqueda local. El siguiente procedimiento incorpora el algoritmo de mejora a
dicho esquema.
Algoritmo combinado aleatorizado

Inicializacin
Obtener una solucin con el algoritmo constructivo aleatorizado.
Sea c* el costo de dicha solucin.
Hacer i =0
Mientras ( i < MAX_ITER)
Obtener una solucin x(i) con el algoritmo constructivo
aleatorizado.
Aplicar el algoritmo de bsqueda local a x(i).
Sea x*(i) la solucin obtenida y S*(i) su valor.
Si ( S*(i) mejora a c*)
Hacer c* = S*(i) y guardar la solucin actual
i = i +1
En cada iteracin el algoritmo construye una solucin (fase 1) y despus trata de mejorarla
(fase 2). As, en la iteracin i, el algoritmo construye la solucin x(i) con valor S(i) y
posteriormente la mejora obteniendo x*(i) con valor S*(i). Notar que x*(i) puede ser igual a x(i)
si el algoritmo de la segunda fase no encuentra ningn movimiento que mejore la solucin.
Despus de un determinado nmero de iteraciones es posible estimar el porcentaje de mejora

obtenido por el algoritmo de la fase 2 y utilizar esta informacin para aumentar la eficiencia
del procedimiento. En concreto, al construir una solucin se examina su valor y se puede
considerar que la fase 2 la mejorara en un porcentaje similar al observado en promedio. Si el
valor resultante queda alejado del valor de la mejor solucin encontrada hasta el momento,
podemos descartar la solucin actual y no realizar la fase 2 del algoritmo, con el consiguiente
ahorro computacional.

Dadas las numerosas variantes posibles sobre el esquema propuesto, no las incluiremos en la
comparativa realizada sobre los 30 ejemplos de la TSPLIB. nicamente citar que en general los
resultados son de mejor calidad que los obtenidos por el heurstico de Lin y Kernighan
(alrededor de un 0.5 %) aunque a expensas de emplear tiempos de computacin bastante
mayores (del orden de algunos minutos).
Dado el inters por resolver problemas enteros en general, y en particular el TSP, se han
propuesto numerosas mejoras y nuevas estrategias sobre el esquema anterior. Una de las ms
utilizadas es la denominada tcnica de Multi-Arranque que abordamos en la prxima seccin.
5.2 Mtodos Multi - Arranque
Los mtodos Multi-Start (tambin llamados Re-Start) generalizan el esquema anterior. Tienen
dos fases: la primera en la que se genera una solucin y la segunda en la que la solucin es
tpicamente, pero no necesariamente, mejorada. Cada iteracin global produce una solucin,
usualmente un ptimo local, y la mejor de todas es la salida del algoritmo.
Algoritmo Multi-Arranque
Mientras (Condicin de parada)
Fase de Generacin
Construir una solucin.
Fase de Bsqueda
Aplicar un mtodo de bsqueda para mejorar la solucin
construida
Actualizacin
Si la solucin obtenida mejora a la mejor almacenada,
actualizarla.
Dada su sencillez de aplicacin, estos mtodos han sido muy utilizados para resolver gran
cantidad de problemas. En el contexto de la programacin no lineal sin restricciones, podemos
encontrar numerosos trabajos tanto tericos como aplicados. Rinnoy Kan y Timmer (1989)
estudian la generacin de soluciones aleatorias (mtodos Monte Carlo) y condiciones de
convergencia. Las primeras aplicaciones en el mbito de la optimizacin combinatoria
consistan en mtodos sencillos de construccin, completa o parcialmente aleatorios, y su
posterior mejora con un mtodo de bsqueda local. Sin embargo el mismo esquema permite
sofisticar el procedimiento basndolo en unas construcciones y/o mejoras ms complejas.
Numerosas referencias y aplicaciones se pueden encontrar en Mart (2000).
Uno de los artculos que contiene las ideas en que se basa el mtodo Tab Search (Glover,
1977) tambin incluye aplicaciones de estas ideas para los mtodos de multi-start.
Bsicamente se trata de almacenar la informacin relativa a soluciones ya generadas y
utilizarla para la construccin de nuevas soluciones. Las estructuras de memoria reciente y
frecuente se introducen en este contexto. Diferentes aplicaciones se pueden encontrar en
Rochat y Taillard (1995) y Lokketangen y Glover (1996).

Utilizando como procedimiento de mejora un algoritmo gentico, Ulder y otros (1990)

proponen un mtodo para obtener buenas soluciones al problema del agente viajero. Los
autores muestran cmo el uso de las tcnicas de re-starting aumenta la eficiencia del
algoritmo comparndolo con otras versiones de heursticos genticos sin re-starting.
Un problema abierto actualmente para disear un buen procedimiento de bsqueda basada

en multi- arranque es si es preferible implementar un procedimiento de mejora sencillo que
permita realizar un gran nmero de iteraciones globales o, alternativamente, aplicar una rutina
ms compleja que mejore significativamente unas pocas soluciones generadas. Un
procedimiento sencillo depende fuertemente de la solucin inicial pero un mtodo ms
elaborado consume mucho ms tiempo de computacin y, por tanto, puede ser aplicado pocas
veces, reduciendo el muestreo del espacio de soluciones.
Una de las variantes ms populares de estos mtodos se denomina GRASP (Feo y Resende,
1995) y est obteniendo resultados excelentes en la resolucin de numerosos problemas
combinatorios. La prxima seccin describe en detalle estos mtodos.

6. Mtodo GRASP (Greedy Randomized Adaptive Search

Procedures)
Los mtodos GRASP fueron desarrollados al final de la dcada de los 80 con el objetivo inicial
de resolver problemas de cubrimientos de conjuntos (Feo y Resende, 1989). El trmino GRASP
fue introducido por Feo y Resende (1995) como una nueva tcnica metaheurstica de
propsito general.
GRASP es un procedimiento de multi-arranque en donde cada paso consiste en una fase de

construccin y una de mejora. En la fase de construccin se aplica un procedimiento
heurstico constructivo para obtener una buena solucin inicial. Esta solucin se mejora en la
segunda fase mediante un algoritmo de bsqueda local. La mejor de todas las soluciones
examinadas se guarda como resultado final.
La palabra GRASP proviene de las siglas de Greedy Randomized Adaptive Search Procedures
que en castellano sera algo as como: Procedimientos de Bsqueda basados en funciones
Greedy Aleatorizadas Adaptativas (que se adaptan). Veamos los elementos de este
procedimiento.
En la fase de construccin se construye iterativamente una solucin posible, considerando un

elemento en cada paso. En cada iteracin la eleccin del prximo elemento para ser aadido a
la solucin parcial viene determinada por una funcin greedy. Esta funcin mide el beneficio
de aadir cada uno de los elementos segn la funcin objetivo y elegir la mejor. Notar que
esta medida es miope en el sentido que no tiene en cuenta qu ocurrir en iteraciones
sucesivas al realizar una eleccin, sino nicamente en esta iteracin.
Se dice que el heurstico greedy se adapta porque en cada iteracin se actualizan los
beneficios obtenidos al aadir el elemento seleccionado a la solucin parcial. Es decir, la
evaluacin que se tenga de aadir un determinado elemento a la solucin en la iteracin j, no
coincidir necesariamente con la que se tenga en la iteracin j+1.
El heurstico es aleatorizado porque no selecciona el mejor candidato segn la funcin greedy

adaptada sino que, con el objeto de diversificar y no repetir soluciones en dos construcciones
diferentes, se construye una lista con los mejores candidatos de entre los que se toma uno al
azar.
Al igual que ocurre en muchos mtodos, las soluciones generadas por la fase de construccin
de GRASP no suelen ser ptimos locales. Dado que la fase inicial no garantiza la optimalidad
local respecto a la estructura de entorno en la que se est trabajando (notar que hay
selecciones aleatorias), se aplica un procedimiento de bsqueda local como
Postprocesamiento para mejorar la solucin obtenida
En la fase de mejora se suele emplear un procedimiento de intercambio simple con el objeto

de no emplear mucho tiempo en esta mejora. Notar que GRASP se basa en realizar mltiples
iteraciones y quedarse con la mejor, por lo que no es especialmente beneficioso para el
mtodo el detenerse demasiado en mejorar una solucin dada.

El siguiente esquema muestra el funcionamiento global del algoritmo:
Algoritmo GRASP
Mientras (Condicin de parada)
Fase Constructiva
Seleccionar una lista de elementos candidatos.
Considerar una Lista Restringida de los mejores Candidatos.
Seleccionar un elemento aleatoriamente de la Lista Restringida.
Fase de Mejora
Realizar un proceso de bsqueda local a partir de la solucin construida hasta
que no se pueda mejorar ms.
Actualizacin
Si la solucin obtenida mejora a la mejor almacenada, actualizarla.
El realizar muchas iteraciones GRASP es una forma de realizar un muestreo del espacio de
soluciones. Basndonos en las observaciones empricas, se ve que la distribucin de la
muestra generalmente tiene un valor en promedio que es inferior al obtenido por un
procedimiento determinista, sin embargo, la mejor de las soluciones encontradas
generalmente supera a la del procedimiento determinista con una alta probabilidad.
Las implementaciones GRASP generalmente son robustas en el sentido de que es difcil el

encontrar ejemplos patolgicos en donde el mtodo funcione arbitrariamente mal.
Algunas de las sugerencias de los autores para mejorar el procedimiento son:
Se puede incluir una fase previa a la de construccin: una fase determinista con el objetivo
de ahorrar esfuerzo a la fase siguiente.
Si se conoce que ciertas subestructuras forman parte de una solucin ptima, stas pueden
ser el punto de partida de la fase constructiva.
Tal y como sealan Feo y Resende una de las caractersticas ms relevantes de GRASP es su
sencillez y facilidad de implementacin. Basta con fijar el tamao de la lista restringida de
candidatos y el nmero de iteraciones para determinar completamente el procedimiento. De
esta forma se pueden concentrar los esfuerzos en disear estructuras de datos para optimizar
la eficiencia del cdigo y proporcionar una gran rapidez al algoritmo, dado que ste es uno de
los objetivos principales del mtodo.
El enorme xito de este mtodo se puede constatar en la gran cantidad de aplicaciones que
han aparecido en los ltimos aos. Festa y Resende (2001) comentan cerca de 200 trabajos en
los que se aplica o desarrolla GRASP.
Por ltimo, hay que resaltar que los algoritmos basados en GRASP pueden ser mejorados
grandemente si se los combina con procedimientos provenientes de otras Metaheursticas,
como Rencadenamiento de trayectorias (Path Relinking) o Bsqueda en vecindades variables
(Variable neighborhood search)

6.1 Rencadenamiento de Trayectorias
El trmino Rencadenamiento de Trayectorias se refiere a una tcnica de intensificacin de

la bsqueda en regiones atractivas del espacio de soluciones, que fue originalmente propuesta
por Glover en el contexto de la metaheurstica de bsqueda TABU. La tcnica consiste en
utilizar una poblacin de buenas soluciones que han sido creadas previamente con algn
mtodo, por ejemplo con GRASP, para luego intentar crear mejores soluciones. El objetivo del
Rencadenamiento de trayectorias no es construir una solucin a partir de otras, sino ms bien
crear un conjunto de soluciones, vecinas unas de otras, que conecten dos soluciones de buena
calidad, creando as un camino o una trayectoria entre estas dos soluciones. Usualmente cada
una de las soluciones del camino formado se mejora con un procedimiento de bsqueda local.
Ms especficamente, dada una solucin denominada solucin inicial, , y una solucin

denominada solucin gua, , se denomina un camino de a a la sucesin de soluciones:
= (0), (1), (2), , ( 1), () = , donde ( + 1) es obtenida al introducir en
() un atributo que reduce la distancia de () hasta la solucin gua . Es decir, en el
camino originado, cada nuevo elemento que se genera en la sucesin se parece ms a la
solucin gua.
Algunas estrategias que se pueden considerar para el desarrollo de la tcnica son:
Forward: La peor entre las soluciones y se pone como el origen y la otra

es la solucin gua;
Backward: La mejor entre las soluciones y se pone como el origen y la
otra es la solucin gua;
Backward y Forward: Se exploran las dos trayectorias diferentes, de a y
de a , es decir intercambiando sus roles;
En algunas implementaciones se ha considerado explorar el entorno de las soluciones

intermedias para dar ms posibilidad al descubrimiento de buenas soluciones.
Actualmente se propone el uso de Rencadenamiento de trayectorias en el contexto de

GRASP. As, una vez generada una coleccin de soluciones mediante las fases de construccin
y mejora de GRASP, se seleccionan parejas (o subconjuntos) de soluciones para unirlas
mediante este procedimiento. A partir de una solucin se realiza una bsqueda local para
llegar a la otra (o a una combinacin de las otras en el caso de subconjuntos).
La hibridacin de GRASP y Rencadenamiento de trayectorias se muestra muy prometedora,

por lo que ha despertado gran inters entre la comunidad de investigacin de operaciones y
de ciencias de la computacin, una muestra de ello es que algunos autores la han usado para
tratar con xito los problemas combinatorios.

6.2 Bsqueda en Vecindades Variables
La Bsqueda en Vecindades Variables (Variable Neighborhood Search, VNS por sus siglas) es
una metaheurstica de desarrollo reciente, propuesta por Hansen y Madlenovic para resolver
problemas de optimizacin combinatoria, cuya idea bsica es cambiar sistemticamente la
vecindad, por medio de un procedimiento aleatorio o determinstico, dentro de un
procedimiento de bsqueda local. Este cambio de vecindad puede favorecer enormemente la
eficiencia de los algoritmos pues diversifica la bsqueda y as la bsqueda no queda viciada por
algn sesgo en el tipo de vecindad seleccionada, por lo que VNS constituye una herramienta
simple y poderosa para mejorar la eficiencia de los algoritmos de bsqueda.
La idea original fue considerar distintas estructuras de entornos y cambiarlas

sistemticamente para escapar de los mnimos locales. El VNS bsico obtiene una solucin del
entorno de la solucin actual, ejecuta una bsqueda montona local desde ella hasta alcanzar
un ptimo local, que remplaza a la solucin actual si ha habido una mejora y modifica la
estructura de entorno en caso contrario. Una variante de esta estrategia bsica es la bsqueda
descendente por entornos variables (VND), que aplica una bsqueda montona por entornos
cambiando de forma sistemtica la estructura de entornos cada vez que se alcanza un mnimo
local.
La ventaja de utilizar varias estructuras de entornos, como se plantea en VNS, radica en el

hecho de que un ptimo local para un determinado entorno, no tiene por qu serlo para otro,
por lo que la bsqueda podr continuar hasta obtener una solucin que sea un buen ptimo
local para el problema. VNS ha sido hibridizado con xito con otras metaheursticas como
Bsqueda Tab o Scatter Search, y en particular con GRASP en su fase de bsqueda local.
La filosofa del procedimiento VNS es la siguiente: se empieza representando por

, = 1, 2, , al conjunto de estructuras de vecindades preseleccionadas, de tal
manera que () representa el conjunto de soluciones, vecinas de , en la
vecindad de . Estas vecindades pueden ser inducidas a partir de una o ms mtricas
introducidas en el espacio de soluciones considerado. Entonces la VNS se basa en tres
principios generales:
1. Si es un ptimo local con respecto a una estructura de vecindad, no tiene

necesariamente que serlo para otra estructura de vecindad diferente.
2. Un ptimo global es un ptimo local respecto a todas las estructuras de
vecindad.
3. En muchos problemas combinatorios, los ptimos locales respecto a una o varias
estructuras de vecindad estn relativamente cerca unos de otros.
Con VNS se deben tener en cuenta estos tres principios a la hora de disear un algoritmo,
pudiendo efectuar los cambios de vecindad de manera determinista o estocstica.

6.3 Resolucin de un caso: implementacin GRASP en FS-scheduling:
Se considera el problema de permutacin de Flow Shop Scheduling con el objetivo de

minimizar el Makespan. Se enfoca la solucin a travs de un algoritmo basado en GRASP.
1. FORMULACIN DEL PROBLEMA DE FLOW SHOP SCHEDULING.- El problema de Flow

Shop scheduling consiste en secuenciar trabajos con los tiempos de procesamiento
dados en mquinas. La secuencia de procesamiento (la ruta de produccin) de un
trabajo en todas las mquinas es idntica y unidireccional.
FUNCIN OBJETIVO
El objetivo de este problema es minimizar el Makespan (el tiempo total de ejecucin

de todos los trabajos).
Minimizar { }.
Donde es el tiempo de procesamiento del trabajo i en la mquina j.
n: el nmero total de trabajos a ser secuenciados .
m: el total de mquinas en el Flow Shop.
[,] : El tiempo de completacin del trabajo en posicin i en la mquina j.
: [,] =makespan
:Es el conjunto ordenado de trabajos ya secuenciados, secuencia parcial.
SUPOSICIONES.- En el Flow Shop hacemos las siguientes suposiciones:
(1) Un conjunto de n trabajos con mltiples operaciones estn disponibles para

procesar en el tiempo.
(2) Cada trabajo requiere m operaciones y cada operacin requiere diferentes

mquinas.
(3) Tiempos de Setup para los trabajos son independientes de la secuencia de

trabajos y pueden ser concluidos en el tiempo de procesamiento.
(4) Descripcin de los trabajos son conocidos de antemano.
(5) Una vez que el procesamiento inicia en un trabajo, se procede a completarlo sin
interrupcin (sin derechos preferentes).
DESCRIPCIN del GRASP
El algoritmo Greddy resuelve problemas haciendo la eleccin que parece la mejor en

ese momento. Un algoritmo Greddy exhibe dos propiedades denominadas:
PROPIEDAD de eleccin voraz y estructura suboptimal. Sea:
Z: FUNCIN OBJETIVO

: PARMETRO VORAZ
RCL: Lista de candidatos restringida.
() : Rango de elementos.
[()]: Funcin de sesgo.
() : Probabilidad de seleccionar un trabajo.
Primero inicializamos el tiempo de terminacin de un trabajo en una mquina igual a

cero. Esto indica el tiempo de disponibilidad de un trabajo en el Flow Shop. La funcin
objetivo a considerar es la minimizacin del Makespan. Determinamos un parmetro
voraz determinado experimentalmente y su valor vara de 0 a 1. En este paper se
toma = 0,5. De todos los candidatos, los mejores candidatos son puestos en la lista
de candidatos restringida (RCL) de acuerdo al rango y ancho:
RANGO= {mximo tiempo de completar de un trabajo mnimo tiempo de completar

de un trabajo)
ANCHO= Rango x
RCL= {mnimo, mnimo+ ancho}
ESTRUCTURA GENERAL DEL GRASP.
En esta fase una solucin factible es construida iterativamente un ELEMENTO a la vez.

En cada iteracin de construccin, la eleccin del prximo elemento a ser aadido es
determinada ordenando todos los elementos candidatos en una lista de candidatos
con respecto a la funcin Greddy. Un parmetro Greddy es determinado
experimentalmente y su rango es en [0,1]. La heurstica es adaptativa por cuanto los
beneficios asociados con cada elemento son actualizados en cada iteracin para
reflejar los cambios provocados por la seleccin del elemento previo. El componente
probabilstico de GRASP es caracterizado por aleatorizar la eleccin el MEJOR
candidato. La lista de los mejores candidatos se denomina LISTA de CANDIDATOS
RESTRINGIDA (RCL).
El pseudocdigo describe la fase bsica de construccin del algoritmo GRASP.
PROCEDIMIENTO DE CONSTRUCCIN (g(.), , )
1. x=0
2. Inicializar la lista de candidatos C.
3. Mientras c0 hacer.
4. =min {g(T)/ };
5. =mx { g(T)/ };
6. = { / g(s) [[ ]]}
7. Seleccionar aleatoriamente s ;

8. = {}
9. Actualizar la lista de candidatos C;
10. End Mientras
11. End Construccin
El pseudocdigo muestra que controla la cantidad de voracidad y aleatoriedad en el

algoritmo.
FUNCIONES DE SESGO
Un GRASP estndar usa una funcin de sesgo aleatoria. Otras funciones de sesgo tales
como sesgo lineal, sesgo logartmico, sesgo exponencial y sesgo polinomial pueden ser
usados en el algoritmo de GRASP. Sin embargo, cualquier distribucin de probabilidad
puede ser usada para sesgar la seleccin hacia ciertos candidatos en particular. En este
paper hemos considerado sesgo aleatorio para la ejecucin de GRASP.
ESTRUCTURA DEL ALGORITMO GRASP
Paso 1: Consideramos un conjunto vaco para inicializacin.
Paso 2: Averiguar las operaciones de.
Paso 3: Calcule la funcin objetivo (Makespan) de las operaciones..
Paso 4: Averiguar el valor mnimo y mximo de la funcin objetivo.
Paso 5: Averiguar el rango, es decir,(MAX-MIN)
Paso 6: Elegir el parmetro (valor glotn) (0.2, 0.4, 0.5,...)
Paso 7: Calcular el ancho (Rango x )
Paso 8: Elegir candidatos para formar RCL, si Z () [min(Z ()) + ANCHO]
Paso 9: Defina rangor para cada operacin en RCL.
Paso 10: Calcular RANGO para funcin de sesgo aleatorio.
Paso 11: Muestrear y actualizar la solucin.
FASE DE BSQUEDA LOCAL
Las soluciones generadas en la fase de construccin GRASP no garantizan ser el ptimo

global con respecto a una definicin simple de vecindad. As siempre es beneficioso
para aplicar bsqueda local para mejorar cada construccin. Un algoritmo de
bsqueda local trabaja en una funcin iterativa por reemplazar sucesivamente la
solucin actual por una mejor solucin en la vecindad de la solucin actual.
El pseudocdigo siguiente describe un procedimiento de bsqueda local bsico:
PROCEDIMIENTO LOCAL (f(.),h(.),x)

1. H={ y pertenece a n(x)/f(y)<f(x)}
2. Mientras H>0 hacer
3. Seleccionar n H;
4. H={y () /f(y)<f(x)}
5. FIN WHILE
6. FIN LOCAL
RESULTADOS NUMRICOS
Consideremos un ejemplo con 5 mquinas y 5 trabajos, con tiempos de procesamiento

en horas (incluido el tiempo de Setup) dados en la tabla 1.
TABLA 1
Mquinas
Trabajos 1 2 3 4 5
1 2 4 6 8 10
2 3 2 4 5 7
3 4 3 1 4 5
4 3 4 3 8 4
5 3 6 5 7 3
TABLA: Tiempo (en horas) de ejecucin de los trabajos en cada mquina
Primero inicializamos con tiempo cero para todas las mquinas
0 0 0 0 0
Ahora tomamos el trabajo 1 y calculamos el tiempo que tomar todas las mquinas
completarlo. Similarmente esto es calculado para todos los trabajos.
Trabajo 1
2 6 12 20 30
Trabajo 2
3 5 9 14 21
Trabajo 3
4 7 8 12 17
Trabajo 4
3 7 10 18 22
Trabajo 5
3 9 14 21 24
MXIMO TIEMPO DE COMPLETACIN= 30

MNIMO TIEMPO DE COMPLETACIN=17

RANGO= MX.TIEMPO MN.TIEMPO =30-17=13
Sea = 0.5
Ancho=Range x =13(0.5)=6.5
RCL= {Tiempo mnimo de completacin, tiempo mn. completacin+ Ancho}
= {17, 23.5}
Los trabajos que tienen tiempo de completacin en el rango RCL son los trabajos 2, 3 y
4.
ELECCIN 1: Podemos elegir cualquier trabajo elegible o usando la funcin de sesgo y
probabilidad de seleccionar.
ELECCIN 2: Sea r el sesgo de los trabajos elegibles asignados por el tiempo de
completacin.
R [2]=2
R [3]=1
R [4]=3
1
El sesgo lineal est dado por
Se acumula al fitness del trabajo 2 es 0.5, del trabajo 3 es 1 y el trabajo 4 es 0.3.
0.5
Prob. Trabajo 2 = = 0.28
1.8
1
Prob. Trabajo 3 = = 0.55
1.8
0.3
Prob. Trabajo 4 =1.8 = 0.17
Ahora generamos un nmero aleatorio talque:
Si 0.28 elegir 2
Si 0.28< 0.83 elegir el trabajo 4, sino
Elegiremos el trabajo 3.
Supongamos que el trabajo 2 es escogido

Trabajo 2
3 5 9 14 21
Trabajo (2 1)
5 9 15 23 33
Trabajo (2 3)
7 10 11 18 26
Trabajo (2 4)
6 10 13 22 26
Trabajo (2 5)
6 12 17 24 27
Mximo tiempo de terminacin= 33
Mnimo tiempo de terminacin= 26
Rango= 7
Cuando =0.5
Ancho =7(0.5)= 3.5
RCL= {26,29.5}

Trabajos {3,4,5} caen en ese rango
Supongamos que el trabajo 3 es escogido

Ahora fijamos el trabajo (23). Tratamos con otras combinaciones y seguimos el mismo
procedimiento.
Trabajo (2 3)
7 10 11 18 26
Trabajo (2 3 1)
9 13 19 27 37
Trabajo (2 3 4)
10 14 17 26 30
Trabajo (2 3 5)
10 16 21 28 31
Rango= 37 -30 = 7
Con = 0.5
Ancho= 7*0.5= 3.5
RCL = {30, 33.5)
Los trabajos (2 3 4) y (2 3 5) caen en este rango.
Supongamos que se elige el trabajo (2 3 4)
Fijamos (2 3 4) y probamos sus combinaciones
TRABAJO (2 3 4)
10 14 17 26 30
TRABAJO (2 3 4 1)
12 18 24 34 44
TRABAJO (2 3 4 5)
13 20 25 33 36
Rango= 44-36= 8
Ancho=8*0.5= 4
RCL= {36,40}
El trabajo (2 3 4 5) cae en este rango
Elegimos el trabajo (2 3 4 5) y hacemos combinaciones.
TRABAJO (2 3 4 5)
13 20 25 33 36
TRABAJO (2 3 4 5 1)
15 24 31 41 51
La secuencia construida por el algoritmo de GRASP (2 3 4 5 1) con MAKESPAN 51.
Luego de esta construccin viene la fase de bsqueda local, que no est explicada aqu.

7. Bsqueda Tab
El mtodo tab es considerado, en general, como la metaheurstica ms eficiente para
resolver problemas de optimizacin combinatorios. Sin embargo la estructuracin de un
algoritmo basado en este mtodo puede tener asociada una complejidad grande. Es decir hay
que pesar la relacin eficiencia complejidad.
Los orgenes de la Bsqueda Tab (Tab Search, TS) pueden situarse en diversos trabajos
publicados a finales de los 70 (Glover, 1977). Oficialmente, el nombre y la metodologa fueron
introducidos posteriormente por Fred Glover (1989). Numerosas aplicaciones han aparecido
en la literatura, as como artculos y libros para difundir el conocimiento terico del
procedimiento (Glover and Laguna, 1997).
La Bsqueda Tab es un mtodo metaheurstico que puede utilizarse para resolver

problemas de optimizacin combinatoria, tales como el TSP, utilizando un procedimiento de
bsqueda local o por vecindades para moverse iterativamente desde una solucin x hacia una
solucin x en la vecindad de x, hasta satisfacer algn criterio de parada.
7.1 Descripcin del mtodo de bsqueda tab
Para poder explorar regiones del espacio de bsqueda que seran dejadas de lado por el
procedimiento de bsqueda local, la bsqueda tab diversifica la bsqueda, modificando la
estructura de vecinos para cada solucin a medida que la bsqueda progresa. Las soluciones
admitidas para N (x), el nuevo vecindario, son determinadas mediante el uso de estructuras de
memoria. La bsqueda entonces progresa movindose iterativamente de una solucin x hacia
una solucin x en N (x)
TS es una tcnica para resolver problemas combinatorios de gran dificultad que est basada
en principios generales de Inteligencia Artificial (IA). En esencia es un metaheurstico que
puede ser utilizado para guiar cualquier procedimiento de bsqueda local en la bsqueda
agresiva del ptimo del problema. Por agresiva nos referimos a la estrategia de evitar que la
bsqueda quede atrapada en un ptimo local que no sea global. A tal efecto, TS toma de la
IA el concepto de memoria y lo implementa mediante estructuras simples con el objetivo de
dirigir la bsqueda teniendo en cuenta la historia de sta. Es decir, el procedimiento trata de
extraer informacin de lo sucedido y actuar en consecuencia. En este sentido puede decirse
que hay un cierto aprendizaje y que la bsqueda es inteligente. El principio de TS podra
resumirse como:
Es mejor una mala decisin basada en informacin que una buena decisin
al azar, ya que, en un sistema que emplea memoria, una mala eleccin
basada en una estrategia proporcionar claves tiles para continuar la
bsqueda. Una buena eleccin fruto del azar no proporcionar ninguna
informacin para posteriores acciones.
TS comienza de la misma forma que cualquier procedimiento de bsqueda local,

procediendo iterativamente de una solucin x a otra y en el entorno de la primera: N(x). Sin
embargo, en lugar de considerar todo el entorno de una solucin, TS define el entorno

reducido N*(x) como aquellas soluciones disponibles del entorno de x. As, se considera que a
partir de x , slo las soluciones del entorno reducido son alcanzables.
N * ( x) N ( x)
Existen muchas maneras de definir el entorno reducido de una solucin. La ms sencilla

consiste en etiquetar como tab las soluciones previamente visitadas en un pasado cercano.
Esta forma se conoce como memoria a corto plazo (short term memory) y est basada en
guardar en una lista tab T las soluciones visitadas recientemente (Recency). As en una
iteracin determinada, el entorno reducido de una solucin se obtendra como el entorno
usual eliminando las soluciones etiquetadas como tab.
N *(x) N (x) T
El objetivo principal de etiquetar las soluciones visitadas como tab es el de evitar que la
bsqueda se cicle. Por ello se considera que tras un cierto nmero de iteraciones la bsqueda
est en una regin distinta y puede liberarse del status tab (pertenencia a T) a las soluciones
antiguas. De esta forma se reduce el esfuerzo computacional de calcular el entorno reducido
en cada iteracin. En los orgenes de TS se sugeran listas de tamao pequeo, actualmente se
considera que las listas pueden ajustarse dinmicamente segn la estrategia que se est
utilizando.
Se define un nivel de aspiracin como aquellas condiciones que, de satisfacerse,

permitiran alcanzar una solucin aunque tenga status tab. Una implementacin sencilla
consiste en permitir alcanzar una solucin siempre que mejore a la mejor almacenada, aunque
est etiquetada tab. De esta forma se introduce cierta flexibilidad en la bsqueda y se
mantiene su carcter agresivo.
Es importante considerar que los mtodos basados en bsqueda local requieren de la

exploracin de un gran nmero de soluciones en poco tiempo, por ello es crtico el reducir al
mnimo el esfuerzo computacional de las operaciones que se realizan a menudo. En ese
sentido, la memoria a corto plazo de TS est basada en atributos en lugar de ser explcita; esto
es, en lugar de almacenar las soluciones completas (como ocurre en los procedimientos
enumerativos de bsqueda exhaustiva) se almacenan nicamente algunas caractersticas de
stas.
La memoria mediante atributos produce un efecto ms sutil y efectivo en la bsqueda, ya

que un atributo o grupo de atributos identifica a un conjunto de soluciones, del mismo modo
que los hiperplanos o esquemas utilizados en los algoritmos Genticos (ver seccin 7.1). As,
un atributo que fue etiquetado como tab por pertenecer a una solucin visitada hace n
iteraciones, puede impedir en la iteracin actual, el alcanzar una solucin por contenerlo,
aunque sta sea diferente de la que provoc el que el atributo fuese etiquetado. Esto permite,
a largo plazo, el que se identifiquen y mantengan aquellos atributos que inducen una cierta
estructura beneficiosa en las soluciones visitadas.
Con los elementos descritos puede disearse un algoritmo bsico de TS para un problema
de optimizacin dado. Sin embargo, TS ofrece muchos ms elementos para construir

algoritmos realmente potentes y eficaces. A menudo, dichos elementos han sido ignorados en
muchas aplicaciones y actualmente la introduccin de estos en la comunidad cientfica
constituye un reto para los investigadores del rea.
Un algoritmo TS est basado en la interaccin entre la memoria a corto plazo y la memoria

a largo plazo. Ambos tipos de memoria llevan asociadas sus propias estrategias y atributos, y
actan en mbitos diferentes. Como ya hemos mencionado la memoria a corto plazo suele
almacenar atributos de soluciones recientemente visitadas, y su objetivo es explorar a fondo
una regin dada del espacio de soluciones. En ocasiones se utilizan estrategias de listas de
candidatos para restringir el nmero de soluciones examinadas en una iteracin dada o para
mantener un carcter agresivo en la bsqueda.
La memoria a largo plazo almacena las frecuencias u ocurrencias de atributos en las

soluciones visitadas tratando de identificar o diferenciar regiones. La memoria a largo plazo
tiene dos estrategias asociadas: Intensificar y Diversificar la bsqueda. La intensificacin
consiste en regresar a regiones ya exploradas para estudiarlas ms a fondo. Para ello se
favorece la aparicin de aquellos atributos asociados a buenas soluciones encontradas. La
Diversificacin consiste en visitar nuevas reas no exploradas del espacio de soluciones. Para
ello se modifican las reglas de eleccin para incorporar a las soluciones atributos que no han
sido usados frecuentemente.
Intensificacin
Examinar entornos de buenas soluciones.
Volver a regiones atractivas para explorarlas ms a fondo.
Diversificacin
Examinar regiones no visitadas.
Dirigir la bsqueda a regiones aparentemente malas.
La siguiente tabla muestra los elementos mencionados.
Memoria Atributos Estrategias mbito

Corto Plazo Reciente Tab - Aspiracin Local
Listas de Candidatos
Largo Plazo Frecuente Intensif. - Diversif. Global
Existen otros elementos ms sofisticados dentro de TS que, aunque poco probados, han
dado muy buenos resultados en algunos problemas. Entre ellos se pueden destacar:
Movimientos de Influencia: Son aquellos movimientos que producen un cambio importante

en la estructura de las soluciones. Usualmente, en un procedimiento de bsqueda local, la
bsqueda es dirigida mediante la evaluacin de la funcin objetivo. Sin embargo, puede ser
muy til el encontrar o disear otros evaluadores que guen a sta en determinadas ocasiones.
Los movimientos de influencia proporcionan una evaluacin alternativa de la bondad de los
movimientos al margen de la funcin objetivo. Su utilidad principal es la determinacin de
estructuras subyacentes en las soluciones. Esto permite que sean la base para procesos de
Intensificacin y Diversificacin a largo plazo.

Oscilacin Estratgica: La Oscilacin Estratgica opera orientando los movimientos en relacin

a una cierta frontera en donde el mtodo se detendra normalmente. Sin embargo, en vez de
detenerse, las reglas para la eleccin de los movimientos se modifican para permitir que la
regin al otro lado de la frontera sea alcanzada. Posteriormente se fuerza al procedimiento a
regresar a la zona inicial. El proceso de aproximarse, traspasar y volver sobre una determinada
frontera crea un patrn de oscilacin que da nombre a esta tcnica. Una implementacin
sencilla consiste en considerar la barrera de la factibilidad / infactibilidad de un problema
dado. Implementaciones ms complejas pueden crearse identificando determinadas
estructuras de soluciones que no son visitadas por el algoritmo y considerando procesos de
construccin / destruccin asociados a stas. La oscilacin estratgica proporciona un medio
adicional para lograr una interaccin muy efectiva entre intensificacin y diversificacin.
Elecciones Probabilsticas: Normalmente TS se basa en reglas sistemticas en lugar de

decisiones al azar. Sin embargo, en ocasiones se recomienda el aleatorizar algunos procesos
para facilitar la eleccin de buenos candidatos o cuando no est clara la estrategia a seguir
(quiz por tener criterios de seleccin enfrentados). La seleccin aleatoria puede ser uniforme
o seguir una distribucin de probabilidad construida empricamente a partir de la evaluacin
asociada a cada movimiento.
Umbrales Tab: El procedimiento conocido como Tab Thresholding (TT) se propone para
aunar ideas que provienen de la Oscilacin Estratgica y de las Estrategias de Listas de
Candidatos en un marco sencillo que facilite su implementacin. El uso de la memoria es
implcito en el sentido que no hay una lista tab en donde anotar el status de los movimientos,
pero la estrategia de eleccin de los mismos previene el ciclado. TT utiliza elecciones
probabilsticas y umbrales en las listas de candidatos para implementar los principios de TS.
Re-encadenamiento de Trayectorias (Path Relinking): Este mtodo se basa en volver a unir

dos buenas soluciones mediante un nuevo camino. As, si en el proceso de bsqueda hemos
encontrado dos soluciones x e y con un buen valor de la funcin objetivo, podemos considerar
el tomar x como solucin inicial e y como solucin final e iniciar un nuevo camino desde x
hasta y. Para seleccionar los movimientos no consideraremos la funcin objetivo o el criterio
que hayamos estado utilizando hasta el momento, sino que iremos incorporando a x los
atributos de y hasta llegar a sta. Por eso esperamos que alguna de las soluciones intermedias
que se visitan en este proceso de Entorno Constructivo sea muy buena. En algunas
implementaciones se ha considerado el explorar el entorno de las soluciones intermedias para
dar ms posibilidad al descubrimiento de buenas soluciones. Detalles sobre el mtodo pueden
encontrarse en Glover, Laguna y Mart (2000)
Laguna y Mart (1999) proponen el uso de Path Relinking (PR) en el contexto de GRASP,
aunque aqu su significado es diferente ya que las soluciones no han estado unidas por ningn
camino previo. As, una vez generada una coleccin de soluciones mediante las fases de
construccin y mejora de GRASP, se seleccionan parejas (o subconjuntos) de soluciones para
unirlas mediante PR. A partir de una solucin se realiza una bsqueda local para llegar a la otra
(o a una combinacin de las otras en el caso de subconjuntos).

Es importante destacar el hecho de que muchas de las aplicaciones basadas en TS no

utilizan los ltimos elementos descritos, por lo que son susceptibles de ser mejoradas. Al
mismo tiempo, los xitos de las numerosas implementaciones del procedimiento han
promovido la investigacin hacia formas de explotar con mayor intensidad sus ideas
subyacentes. En este territorio podemos destacar los ltimos trabajos de Modelos de
entrenamiento y aprendizaje tab, Maquinas tab y Diseo tab.
7.2 Resolucin de un caso: implementacin de Tabu Search para resolver el TSP:
7.2.1 Introduccin:
El algoritmo propuesto basado en TS utiliza la memoria a corto y largo plazo y hace uso de
la matriz de frecuencias que permite la exploracin de nuevas regiones liberando de esta
manera los movimientos sealados como tab.
La matriz de frecuencias lleva la historia de los movimientos admisibles y es la responsable

de definir el criterio de bsqueda en otras regiones. Para iniciar el mtodo se requiere que se
genere una solucin inicial (por ejemplo con la heurstica del vecino ms cercano) y a partir de
esta acta la bsqueda tab.
Cuando la funcin objetivo no mejora despus de una cantidad determinada de iteraciones

en la bsqueda tab basada en memoria de corto plazo, es conveniente emplear
diversificacin a partir de la memoria de largo plazo basada en frecuencias. La estrategia de
diversificacin emplea memoria de largo plazo, usando un vector ordenado de forma
ascendente segn el nmero de cambios de un evento. De este vector ordenado se toman los
primeros elementos (que corresponden a aquellos sucesos que menos han cambiado) donde
el nmero de eventos y el nmero de iteraciones con los que se hace diversificacin son
parmetros adicionales de la bsqueda tab. La programacin de los eventos seleccionados es
cambiada de manera forzada, para que se direccione la bsqueda a regiones no visitadas ( o
poco frecuentadas ).
Parmetros:
LongitudTabu: nmero mximo de prohibiciones sobre la posicin de determinado nodo.
CiclosDiver: permite al algoritmo revisar el nmero de iteraciones en las que el ptimo local
no se ha actualizado, permitiendo la diversificacin para explorar nuevas regiones.
7.2.2 Algoritmo
1. Ingrese: MatrizDistancia, longitudTabu, Maxiter, ciclosdiver, listatabu
2. Generar solucin inicial (vecino ms cercano) , y longitudtour ().
3. Mientras Iter < Maxiter
3.1. Actualice matriztabu.

3.2. () = Menor distancia.
3.3. Generar las 1 permutaciones de dos nodos consecutivos.
3.4. Determinar la distancia de cada permutacin.
3.5. Clasifique los movimientos en prohibidos y no prohibidos.
3.6. Determinar la menor distancia de los movimientos no prohibidos y

seleccione la permutacin.
3.7. Si todos los movimientos son prohibidos, aplique el criterio de aspiracin.

Sino pare.
3.8. Actualice ().
3.9. Si () < (), entonces actualice (). Regresar a 3.1.
3.10. Si en k iteraciones no se actualiza (), entonces diversifique, regrese a

3.1.
4. El ptimo encontrado es ()
El mtodo funciona de manera iterativa. Una vez cumplido el criterio de parada, se evala
la solucin inicial y la resultante con el fin de observar la mejora, si el valor es inferior al inicial
se ha encontrado un nuevo valor mnimo.
7.2.3 Resultados numricos
Consideremos 10 nodos y la siguiente matriz de distancias:
TABLA 1: Matriz de distancias
Supongamos que los parmetros son:
Solucin inicial: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1}, longinicial = 89.18

Maxiter = 200
longitudTabu = 4

CiclosDiver = 20
Se deben construir 3 tablas: La matriz de las secuencias (tablas 2 y 3), la matriz tab (tabla
4) y la matriz de frecuencias (tabla 5).
TABLA 2: Permutacin inicial
En la iteracin que se muestra en la Tabla 3, se observa que la permutacin factible mejor

para generar el siguiente vecindario es {2, 1, 3, 4, 5, 6, 7, 8, 9, 10, 2} con longitud 78.76.
Quedando prohibido el nodo 1 en la posicin 1 y el nodo 2 en la posicin 2. As las matrices de
memoria (Tab y frecuencia) quedan de la forma representada en la tabla 4 y la tabla 5, en las
cuales las columnas representan nodos y las filas posiciones.
TABLA 3: Permutaciones de la iteracin 1
TABLA 4: Matriz tab
Por otro lado se construye la matriz de frecuencias (Tabla 5), en la que se ha marcado que
lo mejor factible es ubicar el nodo 1 en la posicin 2 y el nodo 2 en la posicin 1.

TABLA 5. Matriz de frecuencias (memoria de largo plazo)
Una vez almacenada esta informacin, se obtiene la iteracin 2, como se muestra en la

Tabla 6. Se observa que la mejor es la secuencia con longitud 73.41, quedando tab la
permutacin con suma 89.18.
TABLA 6. Iteracin 2.
Continuando as llegamos a la iteracin 33, cuyo resultado se muestra en la Tabla 7. Hasta

ese momento, en las ltimas 20 iteraciones el ptimo local no se actualiza, por lo que el
algoritmo llama a un procedimiento para diversificar la bsqueda.
TABLA 7. Iteracin 33.

TABLA 8. Matriz de frecuencias.
Es importante sealar que la diversificacin no se hace de manera aleatoria, sino mediante

el anlisis de la informacin recopilada por la matriz de frecuencias.
El criterio para ubicar el nodo en cierta posicin, ser la menor frecuencia registrada. Se
observa en la Tabla 8 que el nodo 1 tiene la menor frecuencia (0= en las posiciones 1, 6, 7, 8, 9
y 10, as que es buen candidato para ocupar la posicin 1. Anlogamente, el nodo 2 es buen
candidato para la posicin 3, el nodo 3 es buen candidato para la posicin 1, pero sta ya est
ocupada por lo que se situar en la posicin 5, el nodo 4 es buen candidato para la posicin 6,
el nodo 5 para la posicin 1, que ya est ocupada, por lo que se ubica en la posicin 2, y as
sucesivamente, as se genera la secuencia: {1, 5, 2, 8, 3, 4, 7, 6, 9, 10} con longitud 77.96, como
se observa en la Tabla 9.
El ptimo se encuentra en la iteracin 144, en el tour {5, 6, 9, 4, 10, 2, 8, 3, 7, 1, 5}, con una
longitud de 36.79, como se puede observar en la Tabla 10.
TABLA 9. Iteracin 34 despus de la diversificacin

TABLA 10. Iteracin 144
Con el fin de visualizar el papel que desempea la diversificacin, se muestra en la siguiente

figura, el grfico para los 200 tours factibles generados en cada vecindario. Es claro que en el
momento de encontrar un ptimo local y ubicarse en un valle profundo la diversificacin
permite explorar nuevas regiones para mejorar el ptimo local.

8. Recocido Simulado
8.1 Origen:
La tcnica heurstica del recocido simulado (RS), en ingls Simulated Anneling, est basada
en un algoritmo propuesto por Metropolis et al. (1953) en el marco de la termodinmica
estadstica, para simular el proceso de enfriamiento de un material (recocido). Kirkpatrick et al.
(1983) e independientemente Cerni (1985) establecieron una analoga entre el proceso de
recocido y el reto de resolver problemas de optimizacin combinatoria de gran escala. Desde
entonces el recocido simulado ha sido utilizado para resolver en forma exitosa una amplia
variedad de problemas de optimizacin combinatoria, convirtindose en una Metaheurstica
clsica. Debido a su sencillez de implementacin as como a los buenos resultados que iban
apareciendo, experiment un gran auge en la dcada de los 80.
Kirpatrick y otros trabajando en el diseo de circuitos electrnicos consideraron aplicar el

algoritmo de Metrpolis en alguno de los problemas de optimizacin combinatoria que
aparecen en este tipo de diseos. El algoritmo de Metrpolis simula el cambio de energa en
el proceso de enfriamiento de un sistema fsico. Las leyes de la termodinmica establecen
que, a una temperatura , la probabilidad de un aumento de energa de magnitud viene
dada por la expresin siguiente:
E
p( E ) e kt , donde k es la constante de Boltzmann.
La simulacin de Metrpolis genera una perturbacin y calcula el cambio resultante en la

energa. Si sta decrece, el sistema se mueve al nuevo estado, en caso contrario, se acepta el
nuevo estado de acuerdo con la probabilidad dada en la ecuacin anterior.
Kirpatrick y otros, pensaron que era posible establecer una analoga entre los parmetros
que intervienen en la simulacin termodinmica de Metrpolis y los que aparecen en los
mtodos de optimizacin local, tal y como muestra la tabla adjunta.
Termodinmica Optimizacin
Configuracin Solucin Posible
Configuracin Fundamental Solucin ptima
Energa de la Configuracin Costo de la Solucin
Para ello, establecen un paralelismo entre el proceso de las molculas de una sustancia que
van colocndose en los diferentes niveles energticos buscando un equilibrio, y las soluciones
visitadas por un procedimiento de bsqueda local. As pues, SA es un procedimiento basado
en bsqueda local en donde:
En cada iteracin se genera un nmero concreto de vecinos, que puede ser fijo para
toda la ejecucin o depender de la iteracin concreta
Cada vez que se genera un vecino, se aplica el criterio de aceptacin para ver si
sustituye a la solucin actual:

- Si la solucin vecina es mejor que la actual, se acepta automticamente, tal

como se hara en la bsqueda local clsica.
- En cambio, si es peor, an existe la probabilidad de que el vecino sustituya a
la solucin actual. Esto permite al algoritmo salir de ptimos locales, en los
que la bsqueda local clsica quedara atrapada.
Es decir, en SA todo movimiento de mejora es aceptado y adems se permiten

movimientos de no mejora de acuerdo con unas probabilidades. Dichas probabilidades estn
basadas en la analoga con el proceso fsico de enfriamiento y se obtienen como funcin de la
temperatura del sistema.
8.2 El algoritmo SA
La estrategia de SA es comenzar con una temperatura inicial alta, lo cual proporciona una
probabilidad tambin alta de aceptar un movimiento de no mejora. En cada iteracin se va
reduciendo la temperatura por medio de algn mecanismo de enfriamiento, y por lo tanto las
probabilidades son cada vez ms pequeas conforme avanza el procedimiento y nos
acercamos a la solucin ptima. De este modo, inicialmente se realiza una diversificacin de la
bsqueda sin controlar demasiado el costo de las soluciones visitadas. En iteraciones
posteriores resulta cada vez ms difcil el aceptar malos movimientos, y por lo tanto se
produce un descenso en el costo.
xt
1.0
0.8 T 20
T 10
0.6
T 5
0.4 T 1
T 0.5
0.2
d
1 2 3 4 5 6 7
En resumen, cada vecino de una solucin tiene una probabilidad de reemplazar a la

solucin actual, de forma tal que a medida que avanzan las iteraciones, aceptar soluciones con
grandes empeoramientos es menos probable (pero sigue existiendo una probabilidad positiva
de aceptarlos).
Existen varios mecanismos de enfriamiento:
Enfriamiento basado en sucesivas temperaturas descendentes T0, T1, T2,, Tmaxiter

fijadas por el usuario
Enfriamiento con descenso constante (c) de temperatura Tk+1= Tk - c

Descenso geomtrico: Tk+1 = r Tk (lo ms usado), k = iteracin actual, r constante

cercana a 1 (usualmente, escogida en [0.8, 0.99])

0
Criterio de Boltzmann: = 1+()

0
Esquema de Cauchy: = 1+
De esta forma, SA tiene la habilidad de salir de ptimos locales al aceptar movimientos de

no mejora en los estados intermedios. Al final del proceso estos son tan poco probables que
no se producen, con lo que, sin no hay movimientos de mejora, el algoritmo finaliza. El
diagrama siguiente muestra un esquema general del algoritmo:
Algoritmo Recocido Simulado

Tomar una solucin inicial x
Tomar una temperatura inicial T
Mientras (no congelado)
Realizar L veces
Tomar x de N(x).
d = f(x) f(x)
Si (d<0) hacer x=x
Si (d>0) hacer x=x con p=e - d/T
Hacer accin del mecanismo de enfriamiento (por ejemplo: T = rT)
Para disear un algoritmo a partir del esquema general anterior hay que determinar los
parmetros del sistema:
La Temperatura Inicial
- Se determina realizando una serie de pruebas para alcanzar una determinada fraccin de
movimientos aceptados.
La Velocidad de Enfriamiento
La longitud
- Proporcional al tamao esperado de ().
El instante en que la Secuencia de Enfriamiento finaliza (est congelada)
- cont = cont+1 cada vez que se completa una temperatura y el porcentaje de
movimientos aceptados es menor de MinPercent. cont=0 cuando se mejora la mejor
solucin almacenada.
La clave de una implementacin de SA es el manejo de la cola o secuencia de enfriamiento:

Cual es la temperatura inicial y cmo disminuye la temperatura en cada iteracin son las dos
preguntas a responder para disear un algoritmo. Podemos encontrar numerosos estudios en
donde se comparan colas lentas (aquellas en las que la temperatura disminuye poco a poco)
con colas rpidas que vienen a ser mtodos de descenso simple con pequeas perturbaciones.
Johnson y otros (1989) sugieren:
Realizar mejoras y especializaciones aunque no se basen en la analoga fsica.

Utilizar soluciones posibles y no posibles. Penalizar en la funcin de evaluacin las

soluciones imposibles.
- El objetivo es diversificar y considerar ms soluciones.

- Notar que con bajas temperaturas la solucin tender a ser posible.
Las ltimas implementaciones de SA apuntan a olvidarse de la analoga fsica y manejar la

cola de enfriamiento como una estructura de memoria. Es decir, la probabilidad de aceptar o
rechazar un movimiento de no mejora depende no de la iteracin (tiempo transcurrido) sino
de lo sucedido en la bsqueda. En este sentido, la probabilidad ser funcin de algunas
variables de estado del proceso. En la actualidad se estn diseando numerosos algoritmos
hbridos en donde la bsqueda local se realiza con un procedimiento basado en SA, en
ocasiones combinado con bsqueda Tab.
8.3 Ejemplos de aplicacin
SA PARA RESOLVER EL TSP: Para la codificacin se consideran las ciudades numeradas de

1 a . Se considera la estructura de vecindad 2-opt; es decir, si la solucin actual () =
{: }. Una solucin inicial la podemos
obtener por el algoritmo Greedy.
Algoritmo Recocido Simulado para el TSP

Tomar una solucin inicial generada con el vecino ms cercano
Tomar una temperatura inicial y un factor de enfriamiento (cooling schedule).
Mientras (no congelado)
Realizar veces
Tomar un tour de () (permutando dos aristas de ).
Sea = () ()
Si ( < 0) hacer =
Si ( > 0) hacer = con probabilidad = /
Hacer =
EJERCICIO:
Desarrollar un algoritmo SA para resolver el TSP e implementarlo, en el cual la estructura de

vecindad est determinada por la permutacin de 2 nodos consecutivos; es decir, si la
solucin actual () = {: }, la solucin
inicial obtenida por Greedy.

9. Mtodos Evolutivos
Los mtodos evolutivos estn basados en poblaciones de soluciones. A diferencia de los
mtodos vistos hasta ahora, en cada iteracin del algoritmo no se tiene una nica solucin sino
un conjunto de stas. Estos mtodos se basan en generar, seleccionar, combinar y reemplazar
un conjunto de soluciones. Dado que mantienen y manipulan un conjunto en lugar de una
nica solucin a lo largo de todo el proceso de bsqueda, suelen presentar tiempos de
computacin sensiblemente ms altos que los de otros metaheursticos. Este hecho se ve
agravado por la convergencia de la poblacin que requiere de un gran nmero de iteraciones
en el caso de los algoritmos genticos, tal y como se describe a continuacin.
9.1 Algoritmos Genticos
Los Algoritmos Genticos (GA) fueron introducidos por John Holland en 1970 inspirndose
en el proceso observado en la evolucin natural de los seres vivos.
Los Bilogos han estudiado en profundidad los mecanismos de la evolucin, y aunque

quedan parcelas por entender, muchos aspectos estn bastante explicados. De manera muy
general podemos decir que en la evolucin de los seres vivos el problema al que cada
individuo se enfrenta cada da es la supervivencia. Para ello cuenta con las habilidades innatas
provistas en su material gentico. A nivel de los genes, el problema es el de buscar aquellas
adaptaciones beneficiosas en un medio hostil y cambiante. Debido en parte a la seleccin
natural, cada especie gana una cierta cantidad de conocimiento, el cual es incorporado a la
informacin de sus cromosomas.
As pues, la evolucin tiene lugar en los cromosomas, en donde est codificada la

informacin del ser vivo. La informacin almacenada en el cromosoma vara de unas
generaciones a otras. En el proceso de formacin de un nuevo individuo, se combina la
informacin cromosmica de los progenitores aunque la forma exacta en que se realiza es an
desconocida.
Aunque muchos aspectos estn todava por discernir, existen unos principios generales de
la evolucin biolgica ampliamente aceptados por la comunidad cientfica. Algunos de estos
son:
1. La evolucin opera en los cromosomas en lugar de en los individuos a los que

representan.
2. La seleccin natural es el proceso por el que los cromosomas con buenas estructuras
se reproducen ms a menudo que los dems.
3. En el proceso de reproduccin tiene lugar la evolucin mediante la combinacin de los
cromosomas de los progenitores. Llamamos Recombinacin a este proceso en el que
se forma el cromosoma del descendiente. Tambin son de tener en cuenta las
mutaciones que pueden alterar dichos cdigos.
4. La evolucin biolgica no tiene memoria en el sentido de que en la formacin de los
cromosomas nicamente se considera la informacin del perodo anterior

Los algoritmos genticos establecen una analoga entre el conjunto de soluciones de un

problema y el conjunto de individuos de una poblacin natural, codificando la informacin de
cada solucin en un string (vector binario) a modo de cromosoma. En palabras del propio
Holland:
Se pueden encontrar soluciones aproximadas a problemas de gran complejidad

computacional mediante un proceso de evolucin simulada
A tal efecto se introduce una funcin de evaluacin de los cromosomas, que llamaremos
calidad (fitness) y que est basada en la funcin objetivo del problema. Igualmente se
introduce un mecanismo de seleccin de manera que los cromosomas con mejor evaluacin
sean escogidos para reproducirse ms a menudo que los que la tienen peor.
Los algoritmos desarrollados por Holland inicialmente eran sencillos pero dieron buenos
resultados en problemas considerados difciles. Un primer esquema de un algoritmo gentico
se muestra en la Figura 24.
Crear y evaluar la poblacin

inicial de cromosomas
Seleccionar y reproducir
dos cromosomas
Evaluar el fitness del nuevo hijo
Sustituir cromosomas de la
poblacin por el hijo.
Figura 24. Algoritmo Gentico Bsico
Los algoritmos Genticos estn basados en integrar e implementar eficientemente dos

ideas fundamentales: Las representaciones simples como strings binarios de las soluciones del
problema y la realizacin de transformaciones simples para modificar y mejorar estas
representaciones.
Para llevar a la prctica el esquema anterior y concretarlo en un algoritmo, hay que

especificar los siguientes elementos:
Una representacin cromosmica

Una poblacin inicial
Una medida de evaluacin
Un criterio de seleccin / eliminacin de cromosomas
Una o varias operaciones de recombinacin
Una o varias operaciones de mutacin
A continuacin pasamos a comentar y detallar todos estos elementos.

En los trabajos originales las soluciones se representaban por strings binarios, es decir,
listas de 1s y 0s. Este tipo de representaciones ha sido ampliamente utilizada incluso en
problemas en donde no es muy natural. En 1985, De Jong introduce la siguiente cuestin:
Qu se debe hacer cuando los elementos del espacio de bsqueda se representan de

modo natural por estructuras complejas como vectores, rboles o grafos?, Se debe
intentar linealizar en un string o trabajar directamente con estas estructuras?
En la actualidad podemos distinguir dos escuelas, la primera se limita a strings binarios,

mientras que la segunda utiliza todo tipo de configuraciones. Hemos de notar que las
operaciones genticas dependen del tipo de representacin, por lo que la eleccin de una
condiciona a la otra.
La ventaja de las primeras es que permite definir fcilmente operaciones de recombinacin,

adems los resultados sobre convergencia estn probados para el caso de strings binarios. Sin
embargo en algunos problemas puede ser poco natural y eficiente el utilizarlas. Por ejemplo
en el problema del agente viajero sobre 5 ciudades y 20 aristas, el string
01000100001000100010 representa una solucin sobre las aristas ordenadas. Sin embargo
dicha representacin no es muy natural y adems, no todos los strings con cinco 1s
representan soluciones lo cual complica substancialmente la definicin de una operacin de
sobrecruzamiento. Es ms natural la ruta de ciudades: (2,3,1,5,4), lo cual permite definir
naturalmente diferentes operaciones estables.
La poblacin inicial suele ser generada aleatoriamente. Sin embargo, ltimamente se estn
utilizando mtodos heursticos para generar soluciones iniciales de buena calidad. En este
caso, es importante garantizar la diversidad estructural de estas soluciones para tener una
representacin de la mayor parte de poblacin posible o al menos evitar la convergencia
prematura.
Respecto a la evaluacin de los cromosomas, se suele utilizar la calidad como medida de la

bondad segn el valor de la funcin objetivo en el que se puede aadir un factor de
penalizacin para controlar la infactibilidad. Este factor puede ser esttico o ajustarse
dinmicamente, lo cual producira un efecto similar al de la Oscilacin Estratgica en Tab
Search:
calidad = Valor Objetivo Normalizado - Penalizacin * Medida Infactibilidad
En resumen, en el proceso de seleccin se escoge qu individuos tendrn la oportunidad de

reproducirse, habitualmente mediante probabilidades segn su fitness. Habrn individuos que
aparezcan ms de una vez y habrn individuos que no aparezcan. Principalmente hay dos
tcnicas para realizar esta funcin: Ruleta y Torneo. La primera tcnica elige individuos con
probabilidad proporcional a su funcin de fitness. La segunda establece k torneos aleatorios
entre parejas de individuos y selecciona aquellos que ganen cada torneo.
Los Operadores de Cruzamiento ms utilizados son:

De un punto: Se elige aleatoriamente un punto de ruptura en los padres y se intercambian

sus bits.
De dos puntos: Se eligen dos puntos de ruptura al azar para intercambiar.
Uniforme: En cada bit se elige al azar un padre para que contribuya con su bit al del hijo,
mientras que el segundo hijo recibe el bit del otro padre.
PMX, SEX: Son operadores ms sofisticados fruto de mezclar y aleatorizar los anteriores.
La operacin de Mutacin ms sencilla, y una de la ms utilizadas consiste en reemplazar

con cierta probabilidad el valor de un bit. Notar que el papel que juega la mutacin es el de
introducir un factor de diversificacin ya que, en ocasiones, la convergencia del procedimiento
a buenas soluciones puede ser prematura y quedarse atrapado en ptimos locales. Otra forma
obvia de introducir nuevos elementos en una poblacin es recombinar elementos tomados al
azar sin considerar su fitness.
A continuacin mostramos la implementacin de un algoritmo gentico propuesta por

Michalewicz (1996), en donde se combinan los elementos genticos con la bsqueda local.
Algoritmo Gentico
1. Generar soluciones Construir un conjunto de soluciones P con tamao PopSize
mediante generacin aleatoria.
2. Mejorar soluciones Aplicar un mtodo de bsqueda local a cada solucin del
conjunto P.
Mientras (nmero de evaluaciones < MaxEval )
3. Evaluacin Evaluar las soluciones en P y actualizar, si es necesario, la
mejor solucin almacenada.
4. Supervivencia Calcular la probabilidad de supervivencia basada en la
calidad de las soluciones. Segn dichas probabilidades seleccionar aleatoriamente
PopSize soluciones (con reemplazamiento) de P. Sea P el nuevo conjunto formado
por las soluciones seleccionadas (algunas pueden aparecer repetidas).
5. Combinacin Seleccionar una fraccin pc de soluciones de P para ser
combinadas. La seleccin es aleatoria y equi-probable para todos los elementos de
P. Los elementos seleccionados se emparejan al azar y, por cada pareja, se generan
dos descendientes que reemplazaran a los padres en P.
6. Mutacin Una fraccin pm de las soluciones de P se selecciona para
aplicar el operador de mutacin. La solucin resultante reemplaza a la original en P.
Parmetros habituales (pero no son los nicos posibles, ya que dependen de la aplicacin
concreta):
Poblacin: entre 50 y 100 cromosomas.
Longitud del cromosoma: depende del problema.
Generaciones: entre 20 y 1000.
Probabilidad (o porcentaje) de cruce: de 20% a 60% por cromosoma.
Probabilidad (o porcentaje) de mutacin: de 0.1% a 5% por gen.

Convergencia del Algoritmo
Dado que el algoritmo gentico opera con una poblacin en cada iteracin, se espera que el
mtodo converja de modo que al final del proceso la poblacin sea muy similar, y en el infinito
se reduzca a un slo individuo.
Se ha desarrollado toda una teora para estudiar la convergencia de estos algoritmos en el

caso de strings binarios. Esta teora se basa principalmente en considerar que un string es un
representante de una clase de equivalencia o esquema, reinterpretando la bsqueda en lugar
de entre strings, entre esquemas. De este modo se concluye lo que se conoce como
paralelismo intrnseco: En una poblacin de m strings se estn procesando implcitamente
O(m3) esquemas. A partir de este resultado el teorema de esquemas prueba que la poblacin
converge a unos esquemas que cada vez son ms parecidos, y en el lmite a un nico string.
En el caso de strings no binarios se introducen los conceptos de forma y conjunto de

similitud que generalizan al de esquema. Se consideran una serie de condiciones sobre los
operadores de manera que se garantice la convergencia. Bsicamente se exige que al cruzar
dos strings de la misma clase se obtenga otro dentro de sta. Adems hay que respetar ciertas
condiciones sobre seleccin de los progenitores. Bajo toda esta serie de hiptesis se prueba la
convergencia del algoritmo.
En la prctica no se suelen respetar las condiciones vistas ya que son difciles de seguir y
probar, encontrndonos con que, en ocasiones los algoritmos genticos resuelven
satisfactoriamente un problema de optimizacin dado y otras se quedan muy alejados del
ptimo. Los estudiosos del tema han tratado de caracterizar lo que han denominado
problemas AG-fciles (aquellos en los que los AG proporcionan buenos resultados) y AG-
difciles con el objetivo de saber de antemano, al estudiar un nuevo problema, si los AG son
una buena eleccin para su resolucin.
Se han tratado de caracterizar estas clases mediante el concepto de engao considerando

que si el algoritmo converge al mejor esquema (aquel con mejor promedio del fitness de sus
strings) y en ste se encuentra el ptimo, entonces es fcil que se resuelva satisfactoriamente.
En caso de que el ptimo est en un esquema con bajo promedio se denomina engao y se
pensaba que en estos casos es cuando el problema es AG-difcil. Sin embargo se ha visto que
esta caracterizacin mediante el engao no es siempre cierta y no constituye un criterio fiable.
Es importante citar que, a diferencia de otros metaheursticos, los Algoritmos Genticos

han crecido de forma espectacular, hasta el punto de poder encontrar referencias sobre ellos
en revista de informtica de carcter general. Adems muchos de los investigadores de este
campo estn trabajando en desarrollar los aspectos tericos de la materia, e incorporando
algunas otras tcnicas de bsqueda local en el esquema gentico. Los Algoritmos Memticos
son un caso particular de estos nuevos hbridos que anan los elementos de combinacin con
los de bsqueda local bajo el nombre de cooperacin y competicin.
Podemos encontrar esquemas de procedimientos genticos ya implementados en los que

incorporar nuestras funciones de evaluacin y con poco ms, tener un algoritmo gentico para
nuestro problema. Existen numerosos accesibles (algunos de libre distribucin y otros

comercializados por compaas de software) y son muy populares especialmente en el

entornos informticos. Entre los ms populares estn:
Solver de Excel (Frontline Systems, Inc.) con un lmite de 100 restricciones y 200
variables
RiskOptimizer (Palisade Inc.) sin lmite aparente,
Estos esquemas reciben el nombre de context-independent y habitualmente slo utilizan

la evaluacin de la solucin como informacin del problema. En general proporcionan
resultados de menor calidad que la de los algoritmos especficos (dependientes del contexto)
diseado para un problema dado, pero por otro lado, su aplicacin es muy sencilla.
EJERCICIO:
Se trata de resolver el problema de la mochila por medio de algoritmos genticos.
En primer lugar se debe generar el problema a resolver de tamao n de la siguiente

manera: la utilidad unitaria es un entero aleatorio entre 100 y 1000, el peso unitario es un
entero aleatorio entre 200 y 1200 y la capacidad de la mochila es igual al promedio del peso
unitario de los objetos multiplicado por n y dividido para 2. Fijar la semilla aleatoria en 1234.
Disear dos algoritmos genticos para resolver el problema del KP:
PRIMER ALGORITMO:

2. Mientras (nmero de evaluaciones < MaxEval )
2 soluciones (p1 padre y p2 madre) de P.
5. Combinacin Aparear p1 con p2 y p2 con p1, generando dos
descendientes que, de generar soluciones factibles, sern h1 y h2.
6. Mutacin Para h1 y h2 aplicar el operador de mutacin. La solucin
resultante reemplaza a la peor solucin que se encuentra en P.
SEGUNDO ALGORITMO:

2. Mejorar soluciones Aplicar un mtodo de bsqueda local a cada solucin del
conjunto P.
Mientras (nmero de evaluaciones < MaxEval )


n_cand soluciones de P. Sea P el nuevo conjunto formado por las soluciones
seleccionadas (algunas pueden aparecer repetidas).
5. Combinacin Seleccionar una fraccin pc de soluciones de P para ser
combinadas. La seleccin es aleatoria y equi-probable para todos los elementos de
P. Los elementos seleccionados se emparejan al azar y, por cada pareja, se generan
dos descendientes que reemplazaran a los padres en P.
6. Mutacin Una fraccin pm de las soluciones de P se selecciona para
aplicar el operador de mutacin. La solucin resultante reemplaza a la original en P.
OBSERVACIN: las fracciones se eligen tal que: pc + pm < 1 y n_cand < PopSize.
9.2 Bsqueda Dispersa (Scatter Search)
La Bsqueda Dispersa (BD) es un mtodo evolutivo que ha sido aplicado en la resolucin de

un gran nmero de problemas de optimizacin. Los conceptos y principios fundamentales del
mtodo, fueron propuestos a comienzo de la dcada de los setenta, basados en las estrategias
para combinar reglas de decisin, especialmente en problemas de secuenciacin, as como en
la combinacin de restricciones (como el conocido mtodo de las restricciones subrogadas). La
BD se basa en el principio de que la informacin sobre la calidad o el atractivo de un conjunto
de reglas, restricciones o soluciones puede ser utilizado mediante la combinacin de stas. En
concreto, dadas dos soluciones, se puede obtener una nueva mediante su combinacin de
modo que mejore a las que la originaron.
Al igual que los algoritmos genticos, el mtodo que nos ocupa se basa en mantener un
conjunto de soluciones y realizar combinaciones con stas; pero a diferencia de stos no est
fundamentado en la aleatorizacin sobre un conjunto relativamente grande de soluciones sino
en las elecciones sistemticas y estratgicas sobre un conjunto pequeo de stas. Como
ilustracin basta decir que los algoritmos genticos suelen considerar una poblacin de 100 o
ms soluciones mientras que en la bsqueda dispersa es habitual trabajar con un conjunto de
tan slo 10 soluciones.
La primera descripcin del mtodo fue publicada en 1977 por Fred Glover donde establece
los principios de la BD. En este primer artculo se determina que la BD realiza una exploracin
sistemtica sobre una serie de buenas soluciones llamadas conjunto de referencia. Los
siguientes comentarios resumen los principales aspectos de este trabajo:
1. El mtodo se centra en combinar dos o ms soluciones del conjunto de referencia.

La combinacin de ms de dos soluciones tiene como objetivo el generar
centroides.
2. Generar soluciones en la lnea que unen dos dadas se considera una forma
reducida del mtodo.

3. Al combinar se deben de seleccionar pesos apropiados y no tomar valores al azar.

4. Se deben de realizar combinaciones convexas y no convexas de las soluciones.
5. La distribucin de los puntos se considera importante y deben de tomarse
dispersos.
En Glover (1994) se introduce la combinacin ponderada (weighted combination) como el

mecanismo principal para generar nuevas soluciones. En esta versin se enfatizan las
bsquedas lineales entre dos soluciones y el uso de pesos para muestrear en dicha lnea.
Asimismo, se introduce el concepto de combinar soluciones de calidad con soluciones diversas.
Adems, el mtodo incluye una componente de intensificacin que consiste en tomar una
muestra mayor de la lnea que ha producido mejores soluciones.
En este trabajo el autor especifica que para trabajar con problemas con variables enteras,
binarias o que forman una permutacin, hay que disear mtodos especficos de combinacin
(notar que no tiene sentido hablar de combinacin lineal de dos permutaciones). Para ello se
introducen los mecanismos de combinacin basados en votos. En estos se definen reglas
mediante las que cada solucin vota para que sus caractersticas aparezcan en la solucin
que se est construyendo. Estos mtodos de votos han sido muy utilizados en las rutinas de
combinacin de los algoritmos de BD y parece que constituyen uno de las claves del xito de
estos mtodos. A continuacin mostramos un ejemplo sobre un problema de rutas de
vehculos introducido en Corbern et al. (2000) para ilustrarlos.
Dada una serie de localizaciones en donde hay que recoger a unos estudiantes, el problema
consiste en encontrar un conjunto de rutas de modo que cada una sea recorrida por un
autobs. A los efectos que aqu nos ocupan podemos omitir el resto de detalles y considerar
que tenemos dos soluciones del problema para ver cmo se combinan. Consideremos un
ejemplo con 10 localizaciones y dos soluciones (A y B) con dos rutas cada una:
Solucin A: A1 = { 4, 2, 7, 1 }, A2 = { 5, 10, 6, 9, 3, 8 }
Solucin B: B1 = { 2, 6, 8, 10, 9 }, B2 = { 3, 4, 7, 1, 5 }
Para poder combinar A y B, tendremos que asociar las rutas de cada una. Si consideramos
las dos asociaciones posibles (A1 con B1 y A2 con B2 , A1 con B2 y A2 con B1) y contamos el
nmero de elementos comunes, podemos tomar la que mayor nmero de coincidencias
presente. As, asociamos A2 con B1 y A1 con B2 ya que la primera tiene cuatro elementos en
comn (6, 8, 9 y 10), y la segunda tiene tres (4, 7 y 1), mientras que la otra asignacin presenta
1+2= 3 coincidencias. La nueva solucin (N1 y N2) se construye en n pasos, en los que una
localizacin se asigna a una ruta en cada paso. La siguiente tabla muestra el proceso.
Paso Par Voto Voto Asignacin Regla de

1 2 seleccin
1 (A1,B2) 4 3 N1 = { 4 } azar
2 (A2,B1) 5 2 N2 = { 2 } azar
3 (A1,B2) 7 3 N1 = { 4, 3 } 3 antes 7
4 (A2,B1) 5 6 N2 = { 2, 5 } 5 antes 6
5 (A1,B2) 7 7 N1 = { 4, 3, 7 } igual

6 (A2,B1) 10 6 N2 = { 2, 5, 6 } azar
7 (A1,B2) 1 1 N1 = { 4, 3, 7, 1 } igual
8 (A2,B1) 10 8 N2 = { 2, 5, 6, 10 } 10 antes 8
9 9 8 N2 = { 2, 5, 6, 10, 8 } 8 antes 9
10 9 9 N2 = { 2, 5, 6, 10, 8, 9 igual
}
En el paso 1, comenzamos construyendo la ruta N1 con el par (A1,B2). El primer elemento

en la ruta A1 es el 4, as que esta ruta vota para que el 4 sea el primer elemento de la ruta N 1
(Voto 1). Anlogamente el voto asociado con B2 es para la localizacin 3 (Voto 2). Como ambas
localizaciones ocupan en sus rutas la misma posicin (la primera) los dos votos valen lo mismo
por lo que desempatamos al azar y gana el 4. En el paso 2 realizamos lo mismo para la otra
pareja de rutas. En el paso 3, A1 vota por la localizacin 7 (la 4 y la 2 ya han sido asignadas) y
B2 vota por la 3. Como la 7 est en la tercera posicin de la ruta A1 y la localizacin 3 est en la
primera posicin de la ruta B2, la regla especifica dar preferencia a la localizacin en una
posicin anterior, por lo que 3 es seleccionada. Procediendo de igual forma se completa la
nueva solucin hasta obtener N1 = {4, 3, 7, 1} y N2 = {2, 5, 6, 10, 8, 9 }.
En 1977 Glover publica una versin ms especfica del mtodo en donde se recogen y
simplifican muchas de las ideas expuestas en trabajos anteriores. Esta publicacin tuvo un
gran impacto en lo que a la difusin del mtodo se refiere y se ha quedado como la referencia
standard de la bsqueda dispersa. Numerosos investigadores comenzaron a aplicar la BD a la
resolucin de problemas de optimizacin obteniendo resultados de gran calidad. La siguiente
seccin describe esta versin del mtodo, actualizada segn implementaciones y desarrollos
posteriores.
Glover, Laguna y Mart (2000) estudian las implementaciones ms recientes del mtodo en
la resolucin de problemas de optimizacin combinatoria. Adems, muestran las conexiones
entre este mtodo y el denominado Re-encadenamiento de Trayectorias (Path relinking).
Desde un punto de vista espacial, el proceso de generar combinaciones lineales de un conjunto
de referencia de soluciones, puede ser visto como el generar caminos entre, y ms all, de
estas soluciones. Esto lleva a una concepcin ms amplia del significado de combinar que es la
introducida en el re-encadenamiento de trayectorias (RT).
RT se basa en el hecho de que entre dos soluciones se puede trazar un camino que las una,
de modo que las soluciones en dicho camino contengan atributos de ellas. Las soluciones
originales pueden haber sido generadas mediante un mtodo basado en una bsqueda local y
estar unidas por un camino, o haber sido generadas por otro mtodo y no estar unidas de
ningn modo; en cualquier caso, ahora generaremos un nuevo camino que las una. Las
caractersticas de dicho camino vendrn especificadas respecto de los atributos que son
aadidos o eliminados, o por los movimientos realizados para alcanzar una solucin desde la
otra. Esto constituye una extensin del concepto de combinacin en tanto que se obtienen
varias soluciones a partir de dos o mas originales.
Consideremos en un problema de permutaciones dos soluciones x=(1,3,4,2) e y=(2,3,1,4).

Si aplicamos un mtodo de combinacin podemos obtener una determinada solucin z =

(1,3,2,4), mientras que si tratamos de obtener y partiendo de x, podemos obtener la secuencia

z1=(2,1,3,4), z2=(2,3,1,4). En este sentido decimos que RT es una extensin de los mtodos de
combinacin.
Dado que la bsqueda dispersa se basa es realizar combinaciones y aplicar mtodos de

bsqueda local, se puede considerar incluido en los llamados algoritmos memticos (una clase
de algoritmos evolutivos en donde la bsqueda local se aplica de forma selectiva).
Actualmente, existen implementaciones comerciales del mtodo (del tipo context-
independent mencionado), cmo Opt Quest Callable Library (Laguna y Mart, 2000), que
estn compitiendo en la industria con mtodos de optimizacin establecidos en la resolucin
de problemas reales. A continuacin se describen las partes esenciales de un algoritmo de
bsqueda dispersa para pasar despus a comentar algunas mejoras y aspectos avanzados del
mtodo.
El Algoritmo de Bsqueda Dispersa
El mtodo se basa en combinar las soluciones que aparecen en el llamado conjunto de

referencia. En este conjunto se tienen las soluciones buenas que se han ido encontrando. Es
importante destacar que el significado de buena no se restringe a la calidad de la solucin, sino
que tambin se considera la diversidad que esta aporta al conjunto. La Bsqueda Dispersa
consta bsicamente de los siguientes elementos:
1. Un generador de soluciones diversas. El mtodo se basa en generar un conjunto P de

soluciones diversas (alrededor de 100), del que extraeremos un subconjunto pequeo
(alrededor de b =10) con el que realizar las combinaciones y que denominamos R.
2. Un conjunto de referencia R. Extrado del conjunto de soluciones diversas segn el

criterio de contener soluciones de calidad y diferentes entre s (Calidad y Diversidad). Si el
mtodo no logra mejorar a la solucin, se considera que el output es la propia solucin
considerada. Las soluciones en este conjunto estn ordenadas de mejor a peor respecto
de su calidad.
2.1. Creacin. Iniciamos el conjunto de referencia con las b/2 mejores soluciones de P.
Las b/2 restantes se extraen de P por el criterio de mxima distancia con las ya
incluidas en el conjunto de referencia. Para ello debemos de definir previamente una
funcin de distancia en el problema.
2.2. Actualizacin. Las soluciones fruto de las combinaciones pueden entrar en el

conjunto de referencia y reemplazar a alguna de las ya incluidas si las mejoran. As
pues, el conjunto de referencia mantiene un tamao b constante pero va mejorando
a lo largo de la bsqueda. En implementaciones sencillas, la actualizacin de este
conjunto se realiza nicamente por calidad, aunque podemos hacerlo tambin por
diversidad.
3. Un mtodo de combinacin. BD se basa en combinar todas las soluciones del conjunto de

referencia. Para ello, se consideran subconjuntos de 2 o mas elementos del conjunto de
referencia y se combinan mediante una rutina diseada a tal efecto. La solucin o

soluciones que se obtienen de esta combinacin pueden ser inmediatamente introducidas

en el conjunto de referencia (actualizacin dinmica) o almacenadas temporalmente en
una lista hasta terminar de realizar todas las combinaciones y despus ver qu soluciones
entran en ste (actualizacin esttica).
4. Un mtodo de mejora. Tpicamente se trata de un mtodo de bsqueda local para

mejorar las soluciones, tanto del conjunto de referencia como las combinadas antes de
estudiar su inclusin en el conjunto de referencia.
El siguiente esquema muestra cmo actan los elementos descritos en un esquema bsico
del algoritmo.
Algoritmo de Bsqueda Dispersa
1. Comenzar con P = . Utilizar el mtodo de generacin para construir una solucin y el

mtodo de mejora para tratar de mejorarla; sea x la solucin obtenida. Si x P entonces
aadir x a P. (i.e., P P x ), en otro caso, rechazar x. Repetir esta etapa hasta que P
tenga un tamao prefijado.
2. Construir el conjunto de referencia R = { x1, , xb } con las b/2 mejores soluciones de P y

las b/2 soluciones de P ms diversas a las ya incluidas.
3. Evaluar las soluciones en R y ordenarlas de mejor a peor respecto a la funcin objetivo.
4. Hacer NuevaSolucin = TRUE
Mientras (NuevaSolucin)
5. NuevaSolucion = FALSE
6. Generar los subconjuntos de R en los que haya al menos una nueva solucin.
Mientras (Queden subconjuntos sin examinar)
7. Seleccionar un subconjunto y etiquetarlo como examinado.
8. Aplicar el mtodo de combinacin a las soluciones del subconjunto.
9. Aplicar el mtodo de mejora a cada solucin obtenida por combinacin.

Sea x la solucin mejorada:
Si f(x) mejora a f(xb) y x no est en R)
10. Hacer xb = x y reordenar R
11. Hacer NuevaSolucion = TRUE
El algoritmo hace referencia a los subconjuntos de R ya que podemos combinar parejas,

tros o cualquier nmero de soluciones. Es usual el limitar las combinaciones a parejas, por lo

que el punto 6 equivaldra a decir: Generar todas las parejas de soluciones de R en las que al
menos una de las dos sea nueva; donde por nueva entenderemos que haya entrado al
conjunto despus de realizar la ltima combinacin de todo R.
Notar que el algoritmo se detiene cuando al tratar de combinar vemos que no hay nuevos
elementos en el conjunto de referencia (la variable NuevaSolucin est en 0). Este algoritmo
puede ser anidado en un esquema global que permita reconstruir el conjunto de referencia
cuando ste ya ha sido explotado. As, si el lmite de tiempo (o evaluaciones) no se ha
excedido, una estrategia habitual es regenerar el conjunto de referencia dejando la mitad
superior (b/2 mejores) y eliminando la mitad inferior. Despus, se genera un conjunto P como
al comienzo del algoritmo, del que se extraen nicamente las b/2 soluciones ms diversas con
las ya existentes en R. As obtenemos un nuevo conjunto de referencia en el que mantenemos
las soluciones de calidad y renovamos las debidas a diversidad. Ahora se vuelve a combinar
como anteriormente sobre este conjunto de referencia (pasos 5 a 11). De este modo se
obtiene un esquema cclico indefinido al que hay que aadirle una variable de control para
detenerlo, tpicamente esta variable est en funcin del tiempo o del nmero de iteraciones
(evaluaciones de la funcin objetivo).
Desarrollo y Mejoras
La bsqueda dispersa es un mtodo relativamente reciente que hemos de considerar en

desarrollo. Durante los ltimos aos se han realizado nuevas contribuciones aplicando esta
metodologa en la resolucin de conocidos problemas de optimizacin. Algunas de estas
aplicaciones han abierto nuevos campos de estudio, ofreciendo alternativas a los diseos
conocidos. Laguna y Armentano (2001) realizan una revisin de los aspectos clave del mtodo
desarrollados durante estos aos. A continuacin las resumimos de forma esquemtica:
a. Considerar el uso de memoria basada en la frecuencia para desarrollar mtodos de

diversificacin eficientes. En lugar de generar las soluciones al azar, se propone
construir un mtodo que basado en el nmero de apariciones de los elementos
significativos en la solucin, evite la repeticin de estructuras similares.
b. Inicializar el conjunto de referencia a partir de un gran conjunto de soluciones creado

con el generador antes mencionado.
c. Aplicar la rutina de mejora de forma selectiva. Las pruebas indican que el aplicar el
mtodo de mejora a todas las soluciones generadas y combinadas, no garantiza el
obtener mejores resultados finales. Establecer umbrales de calidad para no aplicar la
mejora a soluciones que difcilmente van a proporcionar la mejor solucin, es un gasto
innecesario de tiempo de computacin (Ugray et al., 2001). Por otro lado, al aplicar el
mtodo de mejora a todas las soluciones se acelera la convergencia de ste, lo cual
pude ser deseable si disponemos de poco tiempo de computacin, pero debemos de
evitarlo si queremos ejecutar el mtodo en un horizonte largo para obtener soluciones
de gran calidad.
d. Es necesario estudiar el porcentaje de tiempo que el mtodo est generando

soluciones y el tiempo que est combinando. En esencia esta es la cuestin que se

plantea en todos los mtodos heursticos: el equilibrio entre la intensificacin y la

diversificacin.
e. Inicializar el conjunto de referencia con la mitad de soluciones por calidad y la otra

mitad por diversidad. Se han realizado experimentos con distintos tamaos y parece
ser que esta proporcin es la que mejores resultados est dando.
f. La calidad es ms importante que la diversidad al actualizar el conjunto de referencia.

Notar que aunque el mtodo comienza con un conjunto de referencia con soluciones
de calidad y diversidad, al realizar las combinaciones, slo entran al conjunto las
soluciones por el criterio de calidad (hasta llegar a la etapa de regenerarlo). En Laguna
y Mart (2000) se han probado actualizaciones de este conjunto por diversidad,
obteniendo resultados finales peores.
g. Comparar las actualizaciones del conjunto de referencia esttica y dinmica. Notar

que al combinar las soluciones podemos aplicar dos estrategias, introducirlas en el
conjunto, si procede, nada ms generarlas, o anotarlas en una pila y cuando
terminemos de realizar todas las combinaciones, proceder a la actualizacin. La
primera estrategia es dinmica y ms agresiva, en tanto que las soluciones buenas
entran rpidamente en el conjunto de referencia, pero dado que este es de tamao
constante, esto implica que hay soluciones que salen sin llegar a haber sido utilizadas
para realizar combinaciones. Es necesario comparar ambas estrategias para ver cual
proporciona mejores resultados finales.
h. La mayor parte de las soluciones de calidad proceden de combinaciones de dos

soluciones. Asimismo, las buenas soluciones suelen proceder de combinar buenas
soluciones. Campos et al. (1999) realizan numerosos experimentos realizando un
seguimiento a lo largo de la bsqueda de las soluciones de calidad en un problema
concreto.
i. El uso de mltiples mtodos de combinacin ha de ser considerado. Campos, Laguna

y Mart (2001) realizan un anlisis de diferentes mtodos de combinacin, algunos con
elementos aleatorios y otros deterministas, de modo que el algoritmo selecciona el
mtodo de combinacin probabilsticamente, de acuerdo con los xitos obtenidos por
ste. De la misma forma que los mtodos de bsqueda local basados en distintos
entornos (Variable Neighborhood Search) estn proporcionando muy buenos
resultados, hemos de considerar el definir varios entornos de combinacin para
realizar una bsqueda ms completa del espacio de soluciones.
Como conclusin podemos decir que la bsqueda dispersa es un mtodo evolutivo que se
encuentra en desarrollo. Sus orgenes se pueden situar en la dcada de los 70 y, aunque
menos conocida que los algoritmos genticos, se est aplicando en la resolucin de numerosos
problemas difciles de optimizacin.
En la actualidad no existe un esquema nico para aplicar la bsqueda dispersa. En este

trabajo hemos tratado de introducir aquellos aspectos bsicos del mtodo que son

ampliamente aceptados, as como revisar las ltimas implementaciones realizadas y las

cuestiones que son actualmente objeto de estudio.
EJERCICIO:
Aplicar la bsqueda dispersa a la resolucin del VRP capacitado.

10. Mtodos de evolucin diferencial

10.1 Introduccin
La evolucin diferencial (DE) fue originalmente diseada por Price y Storn en 1999 (Storn,
R., Price, K.: Differential evolution a simple and efficient adaptive scheme for global
optimization over continuous spaces, Technical Report 1999) para resolver problemas de
optimizacin contnuos, pero luego ha sido extendida para resolver problemas combinatorios
basados en permutaciones.
La DE fue desarrollada con el fin de satisfacer los tres requerimientos bsicos para que una
tcnica de optimizacin sea buena:
1. Independientemente de los valores iniciales el mtodo deber encontrar buenas

soluciones.
2. La convergencia deber ser rpida.
3. El programa deber tener unos pocos parmetros de control para que sea fcil de
usar.
Por otro lado la DE ha demostrado ser un mtodo que se desempea muy bien en una
amplia gama de problemas de prueba, y es intrnsecamente paralelo ya que est basado en
una poblacin. La estrategia bsica emplea la diferencia de dos vectores de parmetros
seleccionados aleatoriamente como la fuente de variaciones aleatorias para un tercer vector
de parmetros.
Desde el punto de vista de la DE los problemas de optimizacin del mundo real pueden ser
clasificados en uno de los dos tipos siguientes:
1. Aquellos que son caracterizados por parmetros contnuos.

2. Aquellos que son caracterizados por parmetros combinatorios basados en
permutaciones.
La DE original fue desarrollada solo para problemas caracterizados por parmetros

contnuos, pero recientemente ha sido ampliada a la resolucin de problemas combinatorios
(Onwubolu, G., Davendra, D.: Differential Evolution: A Handbook for Global Permutation-Based
Combinatorial Optimization).
9.1 Problemas de Optimizacin DE en el espacio contnuo.
Un tpico problema de optimizacin DE en el espacio contnuo es la function generalizada

de Rosenbrock dada como:
2
2
(1 , 2 , , ) = (100(+1 2 ) + ( 1)2 ),
=0
30 30, = 0,1, , 1, > 1,

La solucin del problema (1 , 2 , , ) es ( ) = 0, = 1, pero aunque es

aparentemente simple es extremadamente difcil encontrarla por medio de algn mtodo
numeric (con DE no es muy complicado).
10.2 Optimizacin combinatoria DE basada en permutaciones.
Un problema tpico de optimizacin combinatorio DE basado en permutaciones es el Job

Shop Problem. El objetivo es hallar la mejor secuencia que garantice el makespan ptimo.
Como se puede ver, este problema es muy diferente que el problema en el espacio contnuo
ya que estamos interesados en una secuencia de los trabajos, que tiene una naturaleza de
permutacin. As, si , es el tiempo de operacin del trabajo en la mquina , y , es el
instante de finalizacin de la ejecucin del trabajo en la mquina , entonces el problema es:

min = { }
= 1, . . , ,
, = {1, , ,1 } + ,
10.3 Adecuacin de la DE como un optimizador combinatorio.
En los ltimos aos se ha adaptado bastante bien la DE para resolver problemas

combinatorios, hacienda esta tcnica muy competitive frente a otras Metaheursticas. Algunas
de estas adaptaciones incluyen:
1. Enfoque de transformacin Forward/Backward;

2. Enfoque de indexacin de la posicin relativa;
3. Enfoque de la posicin del valor ms pequeo;
4. Enfoque Discreto/binario; y,
5. Enfoque de manipulacin de conjunto discrete.
En este texto abordaremos el enfoque de indexacin de la indexacin de la posicin

relativa, que es ms simple de implementar computacionalmente, y que ha dado Buenos
reusltoados en algunos problemas de optimizacin combinatorial.
10.4 DE cannica para problemas de optimizacin contnuos.
Los parmetros usados en DE son = costo o valor de la function objetivo, = dimension

del problema, = tamao de la poblacin, = poblacin de -vectores, =nmero de
generacin, = mximo nmero de generacin, = vector compuesto de parmetros,
= vector de pruebas compuesto de parmetros, =factor de cruce. Otros son: =factor
de escala (0 < 1.2), ()= cota superior, ()= cota inferior, y =vectores de pruebas,
() ()
= vector con mnimo costo en la generacin , = i-simo vector en la generacin ,
() () ()
= i-simo vector regulador (buffer) en la generacin , 1 , 2 = vector seleccionado
aleatoriamente, =entero aleatorio (0 < < 1). En la formulacin = nmero de
ciudades.

La evolucin diferencial DE es un mtodo de bpusqueda paralela directa, que utiliza

vectores de parmetros:
()
, = 0, 1, 2, , 1
Como una poblacin para cada generacin . El tamao de la poblacin, , no cambia

durante el proceso de minimizacin. La poblacin inicial es generada aleatoriamente
asumiendo una distribucin de probabilidad uniforme para todas las decisions aleatorias si no
hay informacin inteligente inicial para el sistema. La idea crucial detrs de DE es un Nuevo
esquema para la generacin de los vectores de parmetros de prueba. DE genera nuevos
vectores de parmetros al aadir el vector de diferencias ponderado entre dos miembros de la
poblacin a un tercer miembro. Si el vector resultante produce un valor objetivo menor que un
miembro predeterminado de la poblacin, el nuevo vector generado reemplaza al vector con
el cual fue comparado. El vector de comparacin puede, pero no necesita ser parte del
()
proceso de generacin mencionado. Adicionalmente el mejor vector de parmetros , es
evaluado para cada generacin con el fin de realizar un seguimiento del progreso que se ha
logrado durante el proceso de minimizacin. La extraccin de informacin de distancia y
direccin desde la poblacin para generar desviaciones aleatorias resulta en un esquema
adaptativo con excelentes propiedades de convergencia.
Las descripciones para las primeras dos variants mas prometedoras de DE, que se conocen
como DE2 y DE3, son las siguientes:
ESQUEMA DE2
Inicializacin: Como con todos los algoritmos evolutivos, DE trabaja con una poblacin de
soluciones, no con una solucin nica para el problema de optimizacin. La poblacin de la
generacin contiene vectores solucin llamados individuos de la poblacin y cada vector
representa una solucin potencial para el problema de optimizacin:
()
() = , = 1, 2, , ; = 1, ,
Adicionalmente, cada vector contiene parmetros:
() ()
= {, } , = 1, 2, , ; = 1, ,
En orden a establecer un punto de inicio para la bsqueda del ptimo, la poblacin deber
ser inicializada. A menudo no hay ms conocimiento acerca de la ubicacin del ptimo global
que las cotas de las variables del problema. En ese caso, una manera natural para inicializar la
poblacin (0) (poblacin inicial) es sembrarla con valores aleatorios dentro de las
restricciones de acotamiento dadas:
(0) () () ()
(0) = {, } = + [0,1] ( ) , [1, ]; [1, ]
Donde [0,1] representa un nmero aleatorio uniformemente distribuido en [0,1]. Las

restricciones de acotamiento superior e inferior son () y () , respectivamente:

() ()
, [1, ]
Para este y otros esquemas, tres operadores son cruciales: mutacin, cruce y seleccin.
MUTACIN: La primera variante de DE trabaja de la siguiente manera: para cada vector

()
, = 0,1,2, , 1, un vector de prueba es generado de acuerdo a:
(+1) () () ()
, = 1, + (2, 3, )
Donde [1, ]; [1, ], > 0 y los enteros 1, 2 y 3 [1, ] son aleatoriamente

generados, con tal que 1 2 3 .
Los tres indices seleccionados aleatoriamente, 1, 2 y 3 se refieren a tres vectores

seleccionados aleatoriamente de la poblacin, los cuales on mutuamente diferentes y tambin
diferentes de el ndice que se est corriendo . Nuevos valores aleatorios 1, 2 y 3 se asignan
para cada valor del ndice (para cada vector). Un Nuevo valor para el nmero aleatorio
[0,1] es asignado para cada valor de ndice (para cada vector parmetro). es un factor
constant y real, que controla la aplificacin de la variacin diferencial. El siguiente grfico
ilustra los diferentes vectores de DE2 para una function de dos variables.
: NP Vectores parmetros de la generacin G.

: Nuevo vector parmetro generado
Mnimo
() ()
2 3
()
3
() ()
() 1 () ()
2 (2 3 )
() () ()
= 1 + (2 3 )
CRUCE: Para incrementar la diversidad de los vectores parmetros se construye el vector:
()
para = , + 1 , , + 1
()
= {1 , 2 , , }; = { ()
( ) Si no


Donde representa la function modulo con modulo . Esto hace que una secuencia de
los elementos de son idnticos a los elementos de , mientras los otros elementos de
()
toman los valores originales de . Escoger un subgrupo de parmetros para mutacin es
similar al proceso de cruce de los algoritmos genticos. El ndice inicial es escogido
aleatoriamente en [0, 1], mientras que es escogido en [0, 1] con probabilidad
( = ) = () , donde [0.1] es la probabilidad de cruce, que es una variable de
control en el esquema DE2. La determinacin aleatoria de y se hace para cada vector de
prueba . Esta idea es representada en la siguiente figura con = 7, = 2 y = 3.
() () () ()
= 1 + (2 3 )
j=0 j=0 j=0
1 1 1
2 2 =2 2
3 3 =3 3
4 4 =4 4
5 5 5
6 6 6
Vector parmetro
con los parmetros

,={0,1,,1}
Para decidir si el nuevo vector pasar a ser un miembro de la poblacin de la generacin

()
+ 1, se lo compara con . Si el vector da un menor valor de la function objetivo que en
() (+1) ()
, es igual a , sino se retiene el viejo valor de .
ESQUEMA DE3:
Bsicamente, el esquema DE3 trabaja de la misma manera que DE2, pero genera el vector
introduciendo una nueva variable de control :
() () () () ()
= + ( ) + (2 3 )
La idea detrs de es proveer un mecanismo para aumentar el character glotn del

()
esquema incorporando el major vector encontrado . La construccin de y al igual que
el proceso de decision es idntico a DE2. La siguiente figura ilustra el proceso de genracin de
vectores de la ecuacin anterior.

: NP Vectores parmetros de la generacin G.

: Nuevo vector parmetro generado v
Mnimo
() ()
2 3
()

()
3 () ()
(2 3 )
()

()
2
() () ()
+ ( )
Tambin existen otras estrategias DE para generar el vector , cuya efectividad dpende del
tipo de problema para el cual son aplicadas. Estas estrategias pueden variar basadas en el
vector a ser perturbado, nmero de vectores diferencia consideradospara la perturbacin y
finalmente del tipo de cruce usado.
10.5 DE para problemas de optimizacin combinatorios basados en permutaciones.
La DE cannica no puede ser aplicada a problemas permutativos o discretos, a menos que

sea modificada. El mecanismo interno de cruce y mutacin cambia invariablemente en cada
nmero real, esto en si mismo conducir a soluciones infactibles. La solucin es una
transformacin o bien en la poblacin o en el mecanismo interno de mutacin y cruce. Algunos
invstigadores han decidido no modificar las estrategias de operacin de DE, pero si manipular
la poblacin de tal manera que permita a la DE operar sin obstculos. Ya que la solucin para
una poblacin es permutativa, son necesarias rutinas de conversion adecuadas para cambiar la
solucin desde los enteros a los reales y luego regresar a los enteros despus del cruce.
Algunas reas de aplicacin donde puede aplicarse la DE para problemas de optimizacin

combinatoria basadas en permutaciones son las siguientes:
Scheduling: Flow Shop, Job Shop, Open Shop, etc.

Knapsack Problem.
Problema de asignamiento lineal (LAP)
Problema de asignamiento cuadrtico (QAP)
Problema del Agente Viajero (TSP)
Problema de ruteo de vehculos (VRP)
Modelo pick-and-place dinmico.

10.6 Enfoque de la indexacin de la posicin relativa o el enfoque

Knapsack.
El enfoque de la indexacin de la posicin relativa tambin es conocido como

representacin basada en el orden, y aunque puede que no sea el mejor mtodo para resolver
los problemas combinatorios, se muestra como una herramienta muy verstil que se puede
adaptar para encontrar resultados razonables a un amplio rango de problemas de optimizacin
combinatoria, y lo ms til es que requiere de muy poco cdigo computacional, y en particular
DE est implementada en Mathematica.
Para explicar el enfoque establecemos lo siguiente:
Tenemos un grupo de vectores denominados cromosomas, constituidos por genes de

valores contnuos, ellos se aparean de acuerdo a una probabilidad de cruce, mutan por
diferencias con otros pares y compiten con un cromosoma padre para ver quien pasa a la
siguiente generacin. En Mathematica estas opciones se manipulan por medio de los
comandos CrossProbability, ScalingFactor y SearchPoints. Cada variable corresponde a un gen
en cada cromosoma.
CrossProbability es el parmetro CR, SearchPoints es NP, es decir el tamao de la poblacin

o nmero de vectores cromosoma, y ScalingFactor es F. Los valores por defecto de estos
parmetros son los que se recomienda en el artculo original de DE.
La funcin de Mathematica que invoca a DE es NMinimize, en la cual se debe establecer

como Method DifferentialEvolution. Tambin se debe establecer la opcin MaxIterations,
que corresponde al nmero de generaciones. Es decir, se invoca a DE en Mathematica con las
siguientes instrucciones:
NMinimize[objetivo, restricciones, variables, Method {DifferentialEvolution, opciones mtodo}, otras opc.]
Los valores que estn por defecto para las opciones de DE en Mathematica se pueden
consultar con la opcin:
Options[NMinimize`DifferentialEvolution]
Estas opciones que estn establecidas por defecto (pero pueden ser cambiadas) son:
{"CrossProbability" 1/2, "InitialPoints" Automatic, "PenaltyFunction" Automatic, "PostProcess"

Automatic, "RandomSeed" 0, "ScalingFactor" 3/5, "SearchPoints" Automatic, "Tolerance" 0.001}
Un parmetro importante es el del nmero de iteraciones (MaxIterations), que est puesto

por defecto en 100, lo cual podra ser muy poco en la resolucin de problemas de
optimizacin, si uno desea mejoras ms grandes en la funcin objetivo este parmetro debe
ser puesto en 1,000 o ms.
Una parte importante que se debe definir es el campo de restricciones, en el cual se debe
especificar, entre otras, la restriccin de integralidad de las variables. Para esto hay al menos
dos enfoques viables:

El primero es permitir que las variables tomen valores en los reales, pero usar
funciones de penalidad para empujarlas al campo de los enteros. Por ejemplo se
2
puede aadir para cada variable , una penalidad del tipo ( ()) ;
donde es una constante grande adecuada. NMinimize no usa este enfoque, pero
el usuario puede ponerlo de manera explcita usando la opcin PenaltyFunction.
El segundo mtodo (que es el que usa por defecto NMinimize, es redondear
explcitamente todas las variables de valor real antes de evaluarlas en la funcin
objetivo. La experiencia en el desempeo de esta funcin indica que es el enfoque
ms eficiente.
Esto todava no aborda el tema del cumplimiento del rango. Por ejemplo, supongamos que
estamos usando variables en el rango {1,,n} para construir una permutacin de n elementos.
Si un valor resbala fuera del rango el efecto podra ser muy malo, por ejemplo se podra colgar
la ejecucin o un resultado sin sentido, por lo tanto es importante en el cdigo hacer cumplir
cuidadosamente las cotas de las variables. La implementacin hace exactamente eso. SI una
variable es restringida a tomar valores entre una cota inferior y una cota superior (restriccin
rectangular), entonces el cdigo de NMinimize la forzar a caer dentro de las cotas, esto est
ya implementado y no necesita ser invocado por el usuario.
En la literatura de los mtodos basados en evolucin, frecuentemente se asocian las

nociones de genotipo y fenotipo, el primero se refiere a los valores actuales de los
cromosomas. Recordemos el trabajo bsico de DE. Tpicamente se forma un nuevo cromosoma
a partir del apareamiento de sus cromosomas padre con una mutacin proveniente de un
segundo padre aleatorio. Dicha mutacin es a su vez dada como una diferencia de otros dos
cromosomas aleatorios. Estas operaciones son todas dadas en el nivel genotipo. Es en la
traduccin del cromosoma a un objeto combinatorio (por ejemplo una permutacin) que se
encuentra el fenotipo, que se refiere a la expresin del cromosoma como algo que puede ser
usado para su evaluacin en la funcin objetivo, dicho de otra manera uno decodifica un
genotipo para obtener un fenotipo. Queremos genotipos que sean dciles para las
operaciones de mutacin y apareamiento de la DE, y fenotipos que respondan bien al
genotipo, en el sentido de que permitan mejoras razonables de la funcin objetivo.
10.6.1 Ejemplos
Consideremos primero dos ejemplos simples para introducir la forma en que DE resuelve
los problemas de optimizacin:
10.6.1.1 TRIPLETAS PITAGRICAS:
Son ternas ordenadas de enteros (x, y, z) tales que x 2 + y 2 = z 2 .
El problema es hallar estas tripletas (supongamos que en un rango adecuado, por ejemplo los
nmeros enteros entre 1 y 25 que cumplen esto). Una forma de resolverlo es:
( 2 + 2 2 )2
. . 1 25; 1 25; 1 25; ; , ,

La expresin (NMinimize por defecto utiliza el mtodo Nelder-Mead, que es un mtodo

numrico ampliamente utilizado) sera:
NMinimize[{( 2 + 2 2 )2 , Element[{, , }, Integers],1 25,1 25,1 25, }, {, , }]
El resultado es {0. , { 7, 24, 25}}
Pero, usando el mtodo DE, cambiando aleatoriamente la semilla en cada corrida, podemos
obtener muchas tripletas pitagricas:
Quiet
2
a Table NMinimize x2 y2 z2 , x, y, z Integers, 1 x 25, 1 y 25, 1 z 25, x y , x, y, z ,
Method "DifferentialEvolution", RandomSeed RandomInteger 1000 , 10
TableForm DeleteDuplicates Cases a, 0., All, 2
El resultado es el siguiente:
7 24 25
9 12 15
5 12 13
8 15 17
12 16 20
3 4 5
6 8 10
10.6.1.2 EL PROBLEMA DE LAS MONEDAS:
Supongamos que tenemos 143,267 monedas de 1, 5, 10 y 25 centavos, por un valor total de

$12,563.29, y queremos determinar cuntas monedas de cada tipo hay.
Una formulacin al problema entonces ser:
(1 + 52 + 103 + 254 1256329)2 + (1 + 2 + 3 + 4 143267)2
. . 0 1 143267; 0 2 143267; 0 3 125632;
0 4 50253; 1 , 2 , 3 , 4
Donde 1 , 2 , 3 4 es el nmero de monedas de 1 centavo, 5, 10 y 25, respectivamente.
El cdigo en Mathematica sera:
a Table
2 2
NMinimize x1 5 x2 10 x3 25 x4 1 256 329 x1 x2 x3 x4 143 267 , Element x1, x2, x3, x4 , Integers ,
0 x1 143 267, 0 x2 143 267, 0 x3 125 632, 0 x4 50 253 , x1, x2, x3, x4 , MaxIterations 1000,
Method "DifferentialEvolution", RandomSeed RandomInteger 1000 , 10
DeleteDuplicates Cases a, 0., All, 2 TableForm
Con las siguientes soluciones:

x1 13224 x2 34451 x3 87930 x4 7662

x1 40579 x2 57689 x3 13178 x4 31821
x1 37714 x2 30923 x3 53450 x4 21180
x1 31859 x2 16466 x3 82094 x4 12848
x1 56919 x2 31889 x3 21434 x4 33025
x1 404 x2 50237 x3 87394 x4 5232
x1 12799 x2 75752 x3 33542 x4 21174
x1 10179 x2 32063 x3 95986 x4 5039
x1 45954 x2 42608 x3 24686 x4 30019
x1 16739 x2 80348 x3 21110 x4 25070
10.6.1.3 EL PROBLEMA DEL PARTICIONAMIENTO DE CONJUNTOS (SPP):
Este es un problema que aparece en muchos contextos, en particular en la geometra

computacional (ver aplicaciones en http://www.cs.ou.edu/~qcheng/paper/essr.pdf)
Empecemos con un caso sencillo, supongamos que tenemos que particionar el conjunto de
enteros del 1 al 100 en dos conjuntos de 50 elementos cada uno, de tal manera que la suma de
las races cuadradas de los nmeros de cada grupo sea lo ms cercana posible.
Hay varias maneras de expresar este problema con NMinimize, una forma es utilizando una
forma sencilla de elegir 50 elementos de un conjunto de 100: usamos 100 nmeros aleatorios
entre 0 y 1, tomamos sus posiciones relativas, que definen una permutacin de los nmeros 1,
2, , 100.
datos Range 100 ;

val RandomReal 1, 100 ;
Ordering val
pIndices, gIndices Take , 50 , Drop , 50 & Ordering val
s1, s2 Map datos &, pIndices, gIndices
En este caso particular como los nmeros son todos del 1 al 100 los conjuntos {pIndices,
gIndices} y {s1, s2} coinciden, la misma idea aplica para la particin de cualquier conjunto en
un nmero par de elementos, y con pequeas modificaciones se puede efectuar la divisin en
un nmero impar o una divisin en subconjuntos de cardinalidades distintas.
SET PARTITIONNING VIA INDEXACIN DE LA POSICIN RELATIVA: Implementamos una

funcin que particione un conjunto en dos (siguiendo las reglas anteriores):
partirRango v : With nuevov Ordering v , mitad Floor Length v 2 ,

Take nuevov, mitad , Drop nuevov, mitad ;
partirRango val
Una vez que tenemos esta funcin para partir un conjunto en dos, construimos la funcin
objetivo, que podra ser el valor absoluto de la diferencia, o la suma de los cuadrados de las
diferencias (que es muy usado en las tcnicas de optimizacin que requieren
diferenciabilidad), en particular DE es un algoritmo de optimizacin libre de la derivada y por
tanto se puede utilizar el valor absoluto.

partirfun v : Real : With vals partirRango v ,

Abs Total N First vals Total N Last vals ;
val 0.13, 0.8, 0.28, 0.69, 0.67, 0.25 ;
partirfun val
Ahora si, una vez construida la funcin objetivo podemos invocar a la DE para resolver
nuestro problema:
resolverDE n , opc Rule : Module vars, xx, rangos, nmin, vals ,

vars Array xx, n ;
rangos Map , 0, 1 &, vars ;
nmin, vals NMinimize partirfun vars , rangos, opc ;
nmin, Map Sort, partirRango vars . vals
resolverDE 100, MaxIterations 1000,

Method DifferentialEvolution, CrossProbability 0.8, SearchPoints 100, PostProcess False
Aqu es conveniente poner otros valores a los parmetros, distintos de los que vienen por
defecto, la fase de postprocesamiento (PostProcess) la ponemos en falso porque casi siempre
la bsqueda de un ptimo local a partir de la configuracin actual ser improductiva y adems
tomar mucho tiempo porque DE est diseado para variables contnuas, as el tiempo
ahorrado lo podemos usar para incrementar el nmero de generaciones (MaxIterations) o el
tamao de cada generacin (NP o SearchPoints). Una pregunta razonable que surge es como
debemos poner el valor del parmetro CrossProbability, lo ms usado es ejecutando varias
veces el cdigo con pocas generaciones y de tamaos pequeos, hasta lograr detectar el mejor
valor.
SET PARTITIONNING VIA KNAPSACK: Otro enfoque para este problema es el siguiente:
Tomamos el conjunto completo y escogemos aleatoriamente nmeros 0 o 1 (0 indicar que
pertenece al un conjunto y 1 que pertenece al otro). Para que esto de una particin par se
debe imponer adems la restriccin que el tamao de cada subconjunto debe ser la mitad del
total.
Definimos nuestra funcin objetivo con las siguientes caractersticas:
Entrada: un vector vec de 0 o 1s de longitud .

Convertimos cada 0 en -1.
Formamos la lista de las races cuadradas de los enteros en {1,2, , }.
Multiplicamos, componente a componente, con la lista de 1 y -1s.
Como salida obtenemos el valor absoluto de la suma de lo anterior.
Por ejemplo con el conjunto {1,2,3,5,6} si lo partimos en {1,3,6} y {2,4,5}, vec={1,0,1,0,0,1}.
partirfun2 vec : Integer : Abs Total 2 vec 1 N Range Length vec ;

vec 1, 0, 1, 0, 0, 1 ;
partirfun2 vec

Con esto podemos construir el procedimiento de optimizacin de la siguiente manera:
Entrada: , numero par entero, y opciones para NMinimize.

Crear una lista de variables de longitud :
vars Array x, 6 ;
rangos Map 0 1 &, vars ;
Join rangos, Element vars, Integers , Total vars 3 ;
Fijar las restricciones para las variables: entre 0 y 1, enteras y su suma total igual a
/2.
Llamar a NMinimize con la funcin objetivo partirfun2 y las restricciones descritas
antes.
Como salida dar el mnimo valor hallado, y los dos subconjuntos determinados.
As, el cdigo es el siguiente:
resolverDE2 n , opc : Module vars, x, nmin, vals, rangos, s1 ,

vars Array x, n ;
nmin, vals NMinimize partirfun2 vars ,
Join rangos, Element vars, Integers , Total vars n 2 , vars, opc ;
s1 Select Inner Times, Range n , vars . vals , List , 0& ;
nmin, s1, Complement Range n , s1
resolverDE2 100, MaxIterations 1000,

Method DifferentialEvolution, CrossProbability 0.8, SearchPoints 100
EJERCICIO:
Resolver el problema anterior con Solver de Excel (Utilice el mtodo Evolutionary).
10.6.1.4 EL PROBLEMA DEL RECUBRIMIENTO DE CONJUNTOS
Este problema es NP-duro, al igual que el problema anterior, se trata de seleccionar un

conjunto de mnima cardinalidad que contenga a toda una familia de subconjuntos.
Por ejemplo en los siguientes datos se observan clientes numerados del 1 al 64, y en
subconjuntos la cobertura que se puede dar desde el subconjunto 1, 2, , 62, y deseamos
determinar el menor nmero de esos subconjuntos que cubran a todos los clientes.

subconjuntos 1, 2, 4, 8, 16, 32, 64 , 2, 1, 3, 7, 15, 31, 63 , 3, 4, 2, 6, 14, 30, 62 ,

4, 3, 1, 5, 13, 29, 61 , 5, 6, 8, 4, 12, 28, 60 , 6, 5, 7, 3, 11, 27, 59 ,
7, 8, 6, 2, 10, 26, 58 , 8, 7, 5, 1, 9, 25, 57 , 9, 10, 12, 16, 8, 24, 56 ,
10, 9, 11, 15, 7, 23, 55 , 11, 12, 10, 14, 6, 22, 54 , 12, 11, 9, 13, 5, 21, 53 ,
13, 14, 16, 12, 4, 20, 52 , 14, 13, 15, 11, 3, 19, 51 , 15, 16, 14, 10, 2, 18, 50 ,
16, 15, 13, 9, 1, 17, 49 , 17, 18, 20, 24, 32, 16, 48 , 18, 17, 19, 23, 31, 15, 47 ,
19, 20, 18, 22, 30, 14, 46 , 20, 19, 17, 21, 29, 13, 45 , 21, 22, 24, 20, 28, 12, 44 ,
22, 21, 23, 19, 27, 11, 43 , 23, 24, 22, 18, 26, 10, 42 , 24, 23, 21, 17, 25, 9, 41 ,
25, 26, 28, 32, 24, 8, 40 , 26, 25, 27, 31, 23, 7, 39 , 27, 28, 26, 30, 22, 6, 38 ,
28, 27, 25, 29, 21, 5, 37 , 29, 30, 32, 28, 20, 4, 36 , 30, 29, 31, 27, 19, 3, 35 ,
31, 32, 30, 26, 18, 2, 34 , 32, 31, 29, 25, 17, 1, 33 , 33, 34, 36, 40, 48, 64, 32 ,
34, 33, 35, 39, 47, 63, 31 , 35, 36, 34, 38, 46, 62, 30 , 36, 35, 33, 37, 45, 61, 29 ,
37, 38, 40, 36, 44, 60, 28 , 38, 37, 39, 35, 43, 59, 27 , 39, 40, 38, 34, 42, 58, 26 ,
40, 39, 37, 33, 41, 57, 25 , 41, 42, 44, 48, 40, 56, 24 , 42, 41, 43, 47, 39, 55, 23 ,
43, 44, 42, 46, 38, 54, 22 , 44, 43, 41, 45, 37, 53, 21 , 45, 46, 48, 44, 36, 52, 20 ,
46, 45, 47, 43, 35, 51, 19 , 47, 48, 46, 42, 34, 50, 18 , 48, 47, 45, 41, 33, 49, 17 ,
49, 50, 52, 56, 64, 48, 16 , 50, 49, 51, 55, 63, 47, 15 , 51, 52, 50, 54, 62, 46, 14 ,
52, 51, 49, 53, 61, 45, 13 , 53, 54, 56, 52, 60, 44, 12 , 54, 53, 55, 51, 59, 43, 11 ,
55, 56, 54, 50, 58, 42, 10 , 56, 55, 53, 49, 57, 41, 9 , 57, 58, 60, 64, 56, 40, 8 ,
58, 57, 59, 63, 55, 39, 7 , 59, 60, 58, 62, 54, 38, 6 , 60, 59, 57, 61, 53, 37, 5 ,
61, 62, 64, 60, 52, 36, 4 , 62, 61, 63, 59, 51, 35, 3 , 52, 51, 49, 53, 61, 45, 13 ,
53, 54, 56, 52, 60, 44, 12 ;
Resolveremos el problema por medio de la formulacin basada en Knapsack. Primero

debemos transformar el conjunto de subconjuntos en un vector de 0 y 1s, pasando de una
representacin dispersa a una representacin densa.
vecdenso dispvec , len : Module

vec Table 0, len ,
Do vec dispvec i 1, i, Length dispvec ;
vec ;
Aqu un 1 indica que en el subconjunto si se incluye el elemento determinado por esa

posicin y un 0 que ese elemento no est cubierto por ese subconjunto. Lo aplicamos a cada
uno de los subconjuntos:
mat Map vecdenso , 64 &, subconjuntos ;
Por ejemplo, encontremos mat[[4]], por otro lado es fcil verificar que podramos volver
fcilmente a la representacin anterior con:
Flatten Position mat 4 , 1
Como en el problema de particin debemos trabajar con variables binarias y minimizar su

suma, sujeta a ciertas restricciones. Unamos un 1 cuando el conjunto es cubierto y un cero
cuando no. Cmo podemos asegurar que todo el conjunto est cubierto? Supongamos por
ejemplo que de los 64 subconjuntos se han seleccionado los 12 primeros y los otros no

primeros12 Join ConstantArray 1, 12 , ConstantArray 0, 52

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
Si hacemos el producto punto de este vector por la matriz, como un 1 en la fila columna
de la matriz significa que el subconjunto contiene al elemento , entonces el producto punto
del vector por la matriz da un vector cuyos elementos indican el nmero de veces que ese
elemento aparece en el recubrimiento primeros12. Es decir la restriccin que debemos
imponer es que este producto punto debe contener slo elementos mayores a cero.
primeros12.mat
4, 4, 4, 4, 5, 5, 5, 5, 4, 4, 4, 4, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
As, el cdigo para optimizar este problema de set covering ser el siguiente:
Recubrimiento set , iter , sp , semilla , cp : 0.5 : Module

vars, rangos, max Length set , nmin, vals ,
vars Array xx, max ;
nmin, vals NMinimize Total vars , Join rangos, Element vars, Integers ,
Thread vars.set Table 0, max , vars, MaxIterations iter ,
Method DifferentialEvolution, CrossProbability cp ,
SearchPoints sp , RandomSeed semilla ;
vals vars . vals;
nmin, vals ;
Recubrimiento mat, 2000, 100, 0, 0.9
EJERCICIO:
Un bar tiene la capacidad de cubrir las necesidades de bebida de los habitantes tanto de su
barrio como de los barrios adyacentes a l, por
ejemplo un bar construido en el barrio 1 cubrir las
demandas de bebida de los barrios 1, 2, 3 y 5. Se
necesitan construir tantos bares como sean
necesarios para cubrir todas las necesidades de
bebida de todo ese sector, es decir que todos los
barrios estn atendidos por al menos un bar,
minimizando el nmero de bares a construir.
a. Resolver el problema con DE.

b. Plantear un modelo MIP para el problema y resolverlo con GAMS
10.6.1.5 EL PROBLEMA DE ASIGNACIN CUADRTICA

El problema de asignacin cuadrtica (Quadratic Assignment Problem, QAP) es uno de los
problemas ms difciles de optimizacin combinatoria, estudiaremos un caso particular, el
problema NUG25 que consiste en que tenemos dos matrices cuadradas, y buscamos una
permutacin que, cuando la aplicamos a las filas y las columnas de la segunda matriz, y
multiplicamos cada elemento por los correspondientes elementos de la primera, y sumamos
todos estos productos, el resultado es el menor posible.

Consideramos las siguientes matrices:
mat1 0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8 ,
1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 6, 5, 4, 5, 6, 7 ,
2, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 6, 5, 4, 5, 6 ,
3, 2, 1, 0, 1, 4, 3, 2, 1, 2, 5, 4, 3, 2, 3, 6, 5, 4, 3, 4, 7, 6, 5, 4, 5 ,
4, 3, 2, 1, 0, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 8, 7, 6, 5, 4 ,
1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7 ,
2, 1, 2, 3, 4, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 6 ,
3, 2, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5 ,
4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 4, 3, 2, 1, 2, 5, 4, 3, 2, 3, 6, 5, 4, 3, 4 ,
5, 4, 3, 2, 1, 4, 3, 2, 1, 0, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3 ,
2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6 ,
3, 2, 3, 4, 5, 2, 1, 2, 3, 4, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5 ,
4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4 ,
5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 4, 3, 2, 1, 2, 5, 4, 3, 2, 3 ,
6, 5, 4, 3, 2, 5, 4, 3, 2, 1, 4, 3, 2, 1, 0, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2 ,
3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 1, 2, 3, 4, 5 ,
4, 3, 4, 5, 6, 3, 2, 3, 4, 5, 2, 1, 2, 3, 4, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4 ,
5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1, 2, 3 ,
6, 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 4, 3, 2, 1, 2 ,
7, 6, 5, 4, 3, 6, 5, 4, 3, 2, 5, 4, 3, 2, 1, 4, 3, 2, 1, 0, 5, 4, 3, 2, 1 ,
4, 5, 6, 7, 8, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4 ,
5, 4, 5, 6, 7, 4, 3, 4, 5, 6, 3, 2, 3, 4, 5, 2, 1, 2, 3, 4, 1, 0, 1, 2, 3 ,
6, 5, 4, 5, 6, 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 2 ,
7, 6, 5, 4, 5, 6, 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1 ,
8, 7, 6, 5, 4, 7, 6, 5, 4, 3, 6, 5, 4, 3, 2, 5, 4, 3, 2, 1, 4, 3, 2, 1, 0 ;
mat2 0, 3, 2, 0, 0, 10, 5, 0, 5, 2, 0, 0, 2, 0, 5, 3, 0, 1, 10, 0, 2, 1, 1, 1, 0 ,
3, 0, 4, 0, 10, 0, 0, 2, 2, 1, 5, 0, 0, 0, 0, 0, 1, 6, 1, 0, 2, 2, 5, 1, 10 ,
2, 4, 0, 3, 4, 5, 5, 5, 1, 4, 0, 4, 0, 4, 0, 3, 2, 5, 5, 2, 0, 0, 3, 1, 0 ,
0, 0, 3, 0, 0, 0, 2, 2, 0, 6, 2, 5, 2, 5, 1, 1, 1, 2, 2, 4, 2, 0, 2, 2, 5 ,
0, 10, 4, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 5, 0, 2, 1, 0, 2 ,
10, 0, 5, 0, 2, 0, 10, 10, 5, 10, 6, 0, 0, 10, 2, 10, 1, 5, 5, 2, 5, 0, 2, 0, 1 ,
5, 0, 5, 2, 0, 10, 0, 1, 3, 5, 0, 0, 2, 4, 5, 10, 6, 0, 5, 5, 5, 0, 5, 5, 0 ,
0, 2, 5, 2, 0, 10, 1, 0, 10, 2, 5, 2, 0, 3, 0, 0, 0, 4, 0, 5, 0, 5, 2, 2, 5 ,
5, 2, 1, 0, 0, 5, 3, 10, 0, 5, 6, 0, 1, 5, 5, 5, 2, 3, 5, 0, 2, 10, 10, 1, 5 ,
2, 1, 4, 6, 0, 10, 5, 2, 5, 0, 0, 1, 2, 1, 0, 0, 0, 0, 6, 6, 4, 5, 3, 2, 2 ,
0, 5, 0, 2, 0, 6, 0, 5, 6, 0, 0, 2, 0, 4, 2, 1, 0, 6, 2, 1, 5, 0, 0, 1, 5 ,
0, 0, 4, 5, 0, 0, 0, 2, 0, 1, 2, 0, 2, 1, 0, 3, 10, 0, 0, 4, 0, 0, 4, 2, 5 ,
2, 0, 0, 2, 0, 0, 2, 0, 1, 2, 0, 2, 0, 4, 5, 0, 1, 0, 5, 0, 0, 0, 5, 1, 1 ,
0, 0, 4, 5, 0, 10, 4, 3, 5, 1, 4, 1, 4, 0, 0, 0, 2, 2, 0, 2, 5, 0, 5, 2, 5 ,
5, 0, 0, 1, 2, 2, 5, 0, 5, 0, 2, 0, 5, 0, 0, 2, 0, 0, 0, 6, 3, 5, 0, 0, 5 ,
3, 0, 3, 1, 0, 10, 10, 0, 5, 0, 1, 3, 0, 0, 2, 0, 0, 5, 5, 1, 5, 2, 1, 2, 10 ,
0, 1, 2, 1, 0, 1, 6, 0, 2, 0, 0, 10, 1, 2, 0, 0, 0, 5, 2, 1, 1, 5, 6, 5, 5 ,
1, 6, 5, 2, 2, 5, 0, 4, 3, 0, 6, 0, 0, 2, 0, 5, 5, 0, 4, 0, 0, 0, 0, 5, 0 ,
10, 1, 5, 2, 0, 5, 5, 0, 5, 6, 2, 0, 5, 0, 0, 5, 2, 4, 0, 5, 4, 4, 5, 0, 2 ,
0, 0, 2, 4, 5, 2, 5, 5, 0, 6, 1, 4, 0, 2, 6, 1, 1, 0, 5, 0, 4, 4, 1, 0, 2 ,
2, 2, 0, 2, 0, 5, 5, 0, 2, 4, 5, 0, 0, 5, 3, 5, 1, 0, 4, 4, 0, 1, 0, 10, 1 ,
1, 2, 0, 0, 2, 0, 0, 5, 10, 5, 0, 0, 0, 0, 5, 2, 5, 0, 4, 4, 1, 0, 0, 0, 0 ,
1, 5, 3, 2, 1, 2, 5, 2, 10, 3, 0, 4, 5, 5, 0, 1, 6, 0, 5, 1, 0, 0, 0, 0, 0 ,
1, 1, 1, 2, 0, 0, 5, 2, 1, 2, 1, 2, 1, 2, 0, 2, 5, 5, 0, 0, 10, 0, 0, 0, 2 ,
0, 10, 0, 5, 2, 1, 0, 5, 5, 2, 5, 5, 1, 5, 5, 10, 5, 0, 2, 2, 1, 0, 0, 2, 0 ;
Primero definimos una funcin para permutar filas y columnas de una matriz (reordenamos
una matriz de acuerdo a una permutacin dada). Los pasos son:

Entradas: una matriz cuadrada y una permutacin del conjunto {1,2, , }.

Construimos reacomodando filas y columnas de como especifica .
permutaMatriz mat , perm : mat perm, perm
Por ejemplo a una matriz 4x4 realizar la permutacin {2,4,1,3}:
MatrixForm mat Array x, 4, 4

x 1, 1 x 1, 2 x 1, 3 x 1, 4
x 2, 1 x 2, 2 x 2, 3 x 2, 4
x 3, 1 x 3, 2 x 3, 3 x 3, 4
x 4, 1 x 4, 2 x 4, 3 x 4, 4
MatrixForm permutaMatriz mat, 2, 4, 1, 3

x 2, 2 x 2, 4 x 2, 1 x 2, 3
x 4, 2 x 4, 4 x 4, 1 x 4, 3
x 1, 2 x 1, 4 x 1, 1 x 1, 3
x 3, 2 x 3, 4 x 3, 1 x 3, 3
Volvamos al problema QAP, para las matrices consideradas con una permutacin dada
debemos obtener el valor de la funcin objetivo:
Por ejemplo calculemos el valor que da la funcin objetivo para la configuracin inicial de
las matrices (es decir sin permutarlas), y luego con otra permutacin cualquiera (a propsito la
permutacin ptima para este problema est reportada en la literatura y es igual a: {5, 11, 20,
15, 22, 2, 25, 8, 9, 1, 18, 16, 3, 6, 19, 24, 21, 14, 7, 10, 17, 12, 4, 23, 13}
p 16, 11, 20, 15, 22, 2, 25, 8, 9, 18, 1, 5, 3, 6, 19, 24, 21, 14, 7, 10, 17, 12, 4, 23, 13 ;
fo Total Flatten mat1 permutaMatriz mat2, p
4270
p 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ;
fo Total Flatten mat1 mat2
4838
Y el ptimo:
p 5, 11, 20, 15, 22, 2, 25, 8, 9, 1, 18, 16, 3, 6, 19, 24, 21, 14, 7, 10, 17, 12, 4, 23, 13 ;
fo Total Flatten mat1 permutaMatriz mat2, p
3744
RESOLUCIN DEL QAP POR MEDIO DE INDEXACIN DE LA POSICIN RELATIVA:
Entradas: matrices cuadradas 1 , 2 de dimensin y parmetros para NMinimize.

Formar un vector de variables de longitud , con rangos iniciales de 0 a 1.
Formar una funcin objetivo que sume los 2 productos de los elementos de la
primera matriz con los de la segunda matriz permutada filas y columnas.

La permutacin es determinada por la ordenacin de los valores del vector de

variables.
Llamamos a NMinimize con la funcin objetivo, rangos, restricciones y las opciones
para DE.
Como salida se obtiene el mnimo valor hallado y la permutacin con la que se lo
obtuvo.
QAP mat1 , mat2 , cp , it , sp , sc :

Module len Length mat1 , obfunc, obfunc2, vars, x, nmin, vals, rangos ,
vars Array x, len ;
obfunc vec : Real : obfunc2 Ordering vec ;
obfunc2 perm : obfunc2 perm Total Flatten mat1 permutaMatriz mat2 , perm ;
nmin, vals NMinimize obfunc vars , rangos,
Method DifferentialEvolution, SearchPoints sp , CrossProbability cp ,
ScalingFactor sc , PostProcess False , MaxIterations it ;
Clear obfunc2 ;
nmin, Ordering vars . vals
Timing min, perm QAP mat1, mat2, .11, 10 000, 200, .6

379.734, 3872.,
5, 2, 8, 11, 18, 22, 25, 9, 6, 16, 10, 3, 23, 19, 1, 20, 4, 14, 7, 21, 15, 12, 17, 13, 24
RESOLUCIN DEL QAP CON DE+2-Opt:
Aqu resolvemos el QAP con DE ms el procedimiento de bsqueda local 2-Opt, es decir con
intercambios de parejas. El cdigo crea un valor aleatorio para decidir cundo usar un
intercambio si este resulta en una no mejora. Esto puede ser una buena manera de mantener
variacin en el conjunto de cromosomas.

QAP4 mat1 , mat2 , cp , it , sp , sc , maxj : 4, keep : 0.4, restaurevector ,

imprima : False :
Module len Length mat1 , objfunc, objfunc2, vars, vv, nmin, vals, rangos,
mejor, mejorvec, indx 0, i 0, tt TimeUsed , vars Array vv, len ;
objfunc2 vec : objfunc2 vec Total Flatten mat1 permutaMatriz mat2 , vec ;
objfunc vec : Real :
Module val1, val2, r1, r2, vec1 vec , vec2 vec , max Max Abs vec , j 0 ,
vec1, vec2 vec1, vec2 max;
val1 objfunc2 Ordering vec1 ;
While j maxj , j ;
r1, r2 RandomInteger 1, len , 2 ;
If restaurevector , vec2 vec1 ;
vec2 r1, r2 vec2 r2, r1 ;
val2 objfunc2 Ordering vec2 ;
If val2 mejor, j ;
If imprima , Print "Mejora local", mejor, val2 ;
If val2 val1 val1 mejor && RandomReal keep ,
Optimize`NMinimizeDump`vec vec2;
If val2 val1, vec1 vec2 ;
val1 Min val1, val2 , Optimize`NMinimizeDump`vec vec1 ;
If val1 mejor, mejor val1;
vec1 mejorvec Optimize`NMinimizeDump`vec;
If imprima , Print "Nuevo valor mejor ", indx,
" iteration, elapsed time, new value ", i, TimeUsed tt, mejor ;
tt TimeUsed ; ; ;
val1 ;
mejorvec Range len ;
mejor Total Flatten mat1 mat2 ;
nmin, vals NMinimize objfunc vars , rangos, MaxIterations it ,
Compiled False, StepMonitor i ,
Method DifferentialEvolution, SearchPoints sp , CrossProbability cp ,
ScalingFactor sc , PostProcess False ;
Clear objfunc2 ;
Total Flatten mat1 permutaMatriz mat2 , Ordering mejorvec , Ordering mejorvec
Timing QAP4 mat1, mat2, .08, 400, 320, .4, 4, .4, False, True
EJERCICIO:
Aplicar DE para resolver el problema del agente viajero, note que el TSP es un problema de
permutacin, por lo tanto puede modificar el mtodo anterior para optimizar el TSP.
11. Otras metaheursticas: Harmony Search y variantes

11.1 Introduccin
La metaheurstica Harmony Search fue introducida por primera vez por Zong Woo Geem (6)
en el ao 2001 como respuesta a la creciente necesidad de desarrollar algoritmos de
optimizacin para problemas de programacin no lineal que no requieran informacin
substancial sobre el gradiente de la funcin de objetivo. La filosofa de esta metaheurstica se
basa en el proceso musical para buscar un estado perfecto de la armona. La armona en la
msica es anloga con el vector de soluciones del problema de optimizacin, y el proceso de

mejora de los msicos es comparable con los esquemas de bsqueda local y global de las
tcnicas de optimizacin (7).
El algoritmo utiliza un procedimiento de bsqueda estocstica aleatorizado basado en la

informacin que se tiene en la memoria junto con otros parmetros que se definirn ms
adelante, de tal manera que la informacin del gradiente y el uso de las derivadas de la funcin
objetivo del problema ya no es necesaria.
11.2 Descripcin del Proceso de Optimizacin
Las interpretaciones musicales tratan de encontrar una armona agradable guiados por un
patrn esttico, tal y como, los procesos de optimizacin buscan encontrar la solucin global a
un problema guiados por la funcin objetivo. El tono de cada instrumento musical determina
una calidad esttica, de igual forma que el valor de la funcin objetivo es determinado por el
conjunto de valores asignados a cada variable de decisin.
En las prcticas de los grupos musicales, cada miembro del grupo toca una nota
seleccionada al azar de un rango posible de opciones, haciendo todos juntos una armona
(Harmony Vector). Si la armona entonada es buena, la experiencia es recordada en la
memoria de cada miembro (Harmony Memory) y la posibilidad de entonar una mejor armona
se incrementa para la prxima vez. De manera similar, en optimizacin, cada variable de
decisin toma un valor seleccionado al azar dentro un intervalo posible, haciendo todas juntas
un vector solucin. Si todas las variables de decisin forman una buena solucin del problema,
el resultado es almacenado en la memoria de cada variable y la posibilidad de formar una
mejor solucin la prxima iteracin aumenta.
Cuando un msico mejora un tono, usualmente sigue una de las siguientes tres reglas:
Toca cualquier tono que se encuentre almacenado en su memoria.

Toca un tono adyacente al tono actual basado en su memoria y en un ajuste de tono.
Toca un nuevo tono al azar.
De manera similar, cuando una variable de decisin toma un valor dentro de la

metaheurstica Harmony Search, sigue uno de estos tres pasos:
Toma un valor seleccionado al azar de entre los que se encuentran almacenados en la

memoria de la variable.
Toma un valor adyacente a uno de los valores que se encuentre en la memoria de la
variable, determinado por el ancho de banda.
Toma un valor seleccionado al azar dentro de un intervalo posible.
Las tres reglas en el algoritmo son dirigidas de manera efectiva por medio de la utilizacin
de los siguientes parmetros:
La probabilidad de consideracin de memoria ().

La probabilidad de ajuste de tono ().
El ajuste de ancho de banda ().

Utilizando la harmony memory y las tres reglas mencionadas se puede crear una nueva
armona, la cual es anloga con encontrar una nueva solucin del problema de optimizacin. Si
la nueva armona es mejor que alguna de las que se encuentran almacenadas en la harmony
memory, sta reemplaza a la peor de todas las armonas almacenadas. Caso contrario, se crea
una nueva armona siguiendo el procedimiento descrito. Se repiten los pasos anteriores hasta
que el criterio de parada sea cumplido.
En resumen, la metaheurstica Harmony Search se sintetiza en los siguientes pasos:
1. Inicializar los parmetros del algoritmo (, , ).

2. Establecer el tamao de la memoria () e inicializar la harmony memory ().
3. Crear una nueva armona a partir de la harmony memory.
4. Actualizar la harmony memory.
5. Repetir los pasos 3 y 4 hasta que el criterio de parada sea cumplido.
11.3 Pseudocdigo de la Metaheurstica Harmony Search

Sea = (1 , 2 , , ) el vector de variables de decisin del problema de
optimizacin:
= ()
. :
= 1,2, ,
Donde y son las cotas inferior y superior asociadas a la variable de decisin .
Paso 1
Se inicializan los parmetros del algoritmo:
= 0.9, = 10
= 0.5, = 100
Paso 2
Inicializar la harmony memory creando armonas aleatorias utilizando el siguiente
procedimiento:
= 1 =
= 1 =
= ~( , )

Paso 3
Crear una nueva armona considerando los parmetros del algoritmo y la
harmony memory. Para ello se utiliza el siguiente procedimiento:
= 1 =
~(0,1)
= ~(1, )
~(0,1)
= + ~(1,1)

= ~( , )


Paso 4
Comparar la nueva armona con la peor armona almacenada en la harmony
memory. Si es mejor que la que se tiene almacenada, reemplazar la peor
armona por .
Paso 5
Repetir los pasos 3 y 4 hasta que se alcance el criterio de parada establecido. La
mejor solucin almacenada en la harmony memory ser la solucin final
encontrada para el problema de optimizacin que se est resolviendo.
11.4 Variantes de la Metaheurstica Harmony Search
Desde su reaparicin en el ao 2005, algunas variantes han sido propuestas para mejorar el
rendimiento del algoritmo original desarrollado por Geem. Las variantes ms conocidas son:
11.4.1 Improved Harmony Search
La cual propone un mtodo adaptativo para ir actualizando algunos de los parmetros del
algoritmo. El modelizador slo necesita inicializar los parmetros PAR min , PAR max , Bwmin y
Bwmax y, a travs del mtodo propuesto, se irn calculando iteracin tras iteracin los valores
reales de PAR y Bw. La principal desventaja de este mtodo radica en que se necesita
inicializar los valores de Bwmin y Bwmax los cuales son muy dependientes del problema y
difciles de ajustar.
11.4.2 Global Best Harmony Search
La cual propone, en lugar de actualizar iterativamente el valor de Bw, eliminarlo del

algoritmo y realizar el ajuste de tono asignndole a la variable de decisin que se est
explorando, el valor que toma una de las variables de decisin (seleccionada de manera
aleatoria) que forma parte de la mejor armona almacenada hasta esa iteracin en la harmony
memory. Su principal desventaja radica en que las variables de decisin del problema pueden
representar cosas completamente ajenas a lo que representa la variable que se explora en esa
iteracin.
12. Redes neuronales

22.1 Introduccin
Las redes neuronales constituyen una floreciente tecnologa que puede ayudar muy
significativamente en una gran cantidad de aplicaciones. Son sistemas de clculo que se
asemejan las caractersticas biolgicas del cerebro, y estn siendo adaptadas para su uso en
una variedad de aplicaciones comerciales, militares y tecnolgicas, que van desde el
reconocimiento de patrones hasta la optimizacin y planificacin. En este captulo se mostrar
cmo las redes neuronales pueden ser utilizadas para manejar un tipo de complejos problemas
de tipo combinatorio.
DEL CEREBRO A LAS REDES NEURONALES

A pesar de que el cerebro humano ya haba sido estudiado desde la Edad Media e incluso
antes, su estructura profunda n fue desvelada hasta finales del pasado siglo. En ese momento
los cientficos, en controversia, se dividan en reticularistas y neurologistas. Para los primeros
el cerebro es una glndula cuya secrecin se distribuye por todo el cuerpo por medio de las
fibras nerviosas.
En cambio, para los neurologistas, el cerebro es un sistema complejo constituido por

unidades individuales bien diferenciasdas, llamadas neuronas, unidas unas a otras por una
malla de fibras nerviosas. El trabajo desarrollado entre 1894 y 1911 por el mdico espaol
Ramn y Cajal disip la controversia a favor por Golgi en 1888 basada en la tincin de las fibras
nerviosas, e identific las neuronas como las unidades constitutivas del cerebro. El examen de
esta estructura tan compleja por medio del microscopio electrnico revel que a pesar de la
gran variedad existente de neuronas, tienen las mismas partes principales:
Cuerpo (o soma)
Dendritas
Axn (o cilindro eje)
Esta estructura se corresponde con la de un proceso, con sus respectivas funciones de

entrada y salida. Las dendritas reciben las seales de las neuronas adyacentes y las transmiten
al cuerpo en forma de un potencial elctrico. Estas seales elctricas son integradas por el
cuerpo celular (soma). Si este potencial elctrico es superior a un valor umbral, el soma genera
un corto impulso elctrico. Este impulso se transmite por el axn, que es una fibra nerviosa
con una longitud que vara entre milmetros y varios metros. El axn se ramifica y dirige el
impulso a varias neuronas va sinapsis.
La sinapsis es la unin del axn con otras neuronas. Hay dos tipos de sinapsis. El primero se
llama sinapsis de excitacin, cuyo efecto es incrementar el potencial en la neurona destino. El
segundo tipo es el de sinapsis inhibitoria cuya misin es hacer decaer el potencial en la
neurona de destino. Esta descripcin de los componentes fundamentales del sistema nervioso
es bastante simplificada. De hecho, en la teora de redes neuronales, las neuronas se
consideran como cajas negras, y por tanto no se necesita una descripcin ms detallada de a
neurona. No obstante, no es posible comprender la capacidad del cerebro para realizar
funciones tan complejas como la percepcin visual o el control motriz si se permanece al nivel
de la neurona.
22.2 Modelos de neuronas
El primer modelo artificial de neurona establecido por McCulloch y Pitts {1943}. Este
modelo consista en un dispositivo no lineal de mltiples entradas con interconexiones con
peso. En este modelo las interconexiones afectadas por los pesos representaban las
dendritas; el cuerpo celular se representaba por una funcin no lineal; la neurona artificial
sumaba las entradas ya ponderadas, les aplicaba la funcin no lineal y transmita la salida.
Veamos un caso muy simple en el cual la neurona tiene dos entradas, representadas por un
vector x=(x1, x2). A los pesos para las interconexiones los llamaremos w1 y w2, y la funcin no

lineal es una funcin umbral g(x), cuyo valor umbral es , siendo la salida un escalar y. Esto se
puede representar como
y= g(= )
con

g(h)={
>
A pesar de su simplicidad, este modelo artificial puede resolver funciones booleanas. Por
ejemplo, esta simple red es capaz de resolver la funcin booleana OR;para valores booleanos
+1(cierto) y -1(falso),basta tomar los pesos w1=w2=1, y el umbral = 0.5.
Cuando este modelo se extiende a vectores de entrada n-dimensionales reales, la ecuacin

es
y=g (= )
A la funcin g se la denomina funcin de transferencia o ganancia, y representa cmo la

neurona calcula la salida y para una entrada x, y unos pesos dados. Cuando g es una funcin
umbral, como en el caso anterior, la neurona se llama unidad umbral.Pero esta clase de
funciones umbrales no es la nica posible. En la figura 3 se muestran otras funciones de
ganancia de uso frecuente.
22.3 Arquitecturas
Una red neuronal artificial est formada por un conjunto de neuronas interconectadas
entre ellas. El modo en que se interconectan constituye la arquitectura de la red.
Hay varias arquitecturas y las ms comunes son las redes por capas, las redes recurrentes y
las redes de conexin lateral. Estas arquitecturas estn muy ligadas a la regla de aprendizaje
para adiestrar a la red. En este apartado se representan estas arquitecturas y en el siguiente
las correspondientes reglas de aprendizaje.
Redes neuronales por capas
La estructura de una red neuronal de este tipo est dispuesta en capas. En estas redes cada
capa de neuronas recibe seales slo de las capas previas. Por esto se llaman redes feed-
forward o perceptrn. La primera red feed-forward fue presentad por Rosenblatt {1957}, y
tena una capa de entrada y una capa de salida constituida por un conjunto de unidad umbral.
La figura 4 ilustra la arquitectura del preceptrn. En la primera capa no se realiza clculo (capa
de entrada) y por este motivo se considera a esta red como de una capa.
La segunda clase de red por capas es la multicapa con fedd-forward, tambin denominada
perceptrn multicapa. En esta a clase, se tiene al menos una capa (las denominadas capas
ocultas) entre las de entrada y la salida. Cuando cada unidad de una capa se conecta a cada

nodo de la capa adyacente siguiente, la red se denomina totalmente conectada en

contraposicin a la que es parcialmente conectada. En la figura 5 se tien un ejemplo de cada
red.
Redes neuronales recurrentes
En estas redes cada neurona se conecta a todas las neuronas de la red, incluso contigo
misma, lo que significas que se tienen bucles en la arquitectura de la red. Las entradas de una
neurona son las salidas del resto de las neuronas de la etapa previa. En estas redes es muy
importante la dinmica de las mismas. La salida de cada neurona se lllama estado de la
neurona, y el estado de la red quedar definido por el estado de cada neurona. La red es
estable cuando su estado permanece igual tras varias iteraciones.
La estabilidad es un concepto muy importante es esta clase de redes. La red de Hopfield es

un caso muy importante de esta clase. La figura 6 ilustra un ejemplo de red de Hopfiels.
Redes conectadas lateralmente
En esta clase de redes, las neuronas se colocan en los nodos de un retculo dimensin 1 2
(aunque puede haber dimensiones mayores, no se suelen utilizar). La figura 7 ilustra un
ejemplo de una red de dimensin uno, conectada lateralmente y otra de dimensin 2. La red
de esta clase ms comn es la de Kohonen.
22.4 Reglas de aprendizaje
La caracterstica ms interesante de las redes neuronales artificiales es su capacidad de

aprendizaje. Hay dos modos principales de aprendizaje: el aprendizaje supervisado y el no
supervisado.
En la prctica, las reglas de aprendizaje especifican cmo adaptar los pesos sinpticos. Esta
adaptacin se realiza mediante una interaccin continua entre la red neuronal y el entorno.
La primera hiptesis sobre el proceso de aprendizaje en los cerebros naturales fue

formulada por Hebb [1949].Introdujo el siguiente principio: Los pesos de sinapsis aumentan
cuando tanto las neuronas pre-sinpticas como la post-sinpticas se activan
simultneamente.
Una componente esencial en el aprendizaje supervisado es la existencia de un maestro o

supervisor. La misin de la red neuronal es dar la salida deseada para cada entrada. Cuando se
pasa un vector de entrada a la red, el instructor sabe cual ha de ser la salida (salida deseada).
La regla de aprendizaje adaptar los pesos de las sinpsis de tal modo que el error entre la
salida real y la deseada sea mnimo. El perceptrn y las redes multicapa utilizan este mtodo
de aprendizaje.
El procedimiento seguido para ensear a una red neuronal es el siguiente: se disea un

conjunto de ejemplos de entrenamiento. Cada ejemplo consta de un par de vectores, uno de
entrada y otro de salida deseada. Durante la fase de entrenamiento, los pesos sinpticos se
adaptan para minimizar el error entre las salidas real y deseada. Cuando termina la fase de

entrenamiento (por ejemplo cuando el ndice de error sea menor del 1% ) dejan de variar los
pesos sinpticos y quedan fijados para las operaciones siguientes. A continuacin viene la fase
de generalizacin. Basndose en los pesos determinados en la fase de entrenamiento, la red
encontrar la salida adecuada, incluso aunque el supervisor no conozca dicha salida.
En el proceso de aprendizaje no supervisado, no se dispone de instructor. En este caso no

hay conjunto de entrenamiento, y no se conocen las salidas deseadas. La tarea de una red no
supervisada es clasificar los vectores de entrenamiento en clases y grupos. La tarea de
aprendizaje se realiza aplicando el concepto de similitud. La similitud de dos vectores se suele
medir por su producto escalar (sta no es la nica medida). La regla de aprendizaje
competitiva se usa para realizar un proceso no supervisado de aprendizaje. Cuando se
presenta un vector de entrada a la red, se selecciona una neurona (lo que significa que todas
las neuronas tratan de ser seleccionadas), pero slo la ganadora es seleccionada. El modelo de
Kohonen es un ejemplo de red que utiliza el mtodo no supervisado.
22.5 Redes neuronales artificiales y los problemas de optimizacin combinatoria
Los modelos conexionistas han atrado la atencin por su prometedora potencialidad como
mtodos heursticos para hallar soluciones aproximadas a complejos problemas de
optimizacin. En sus pioneros trabajos, Hopfield y Tank[1985] mostraron que las redes
neuronales artificiales pueden ofrecer buenas aproximaciones a la solucin del problema del
viajante,TSP. El principal resultado de este artculo fue mostrar la posibilidad de empleo de
redes neuronales artificiales para la resolucin de problemas, aunque desde el punto de vista
de lso investigadores de operaciones los resultados de este mtodo distaban de ser
convincentes. De hecho, el mtodo se aplicaba a problemas pequeos (el tamao del
problema variaba entre 10 y 30 ciudades). Despus de este artculo, hubo muchos intentos
para desarrollar algoritmos neuronales para solucionar ste y otros problemas dde
optimizacin.
Hay dos aproximaciones bsicas para el uso de redes neuronales en la solucin de

problemas de optimizacin. La primera se basa en la fsica estadstica. Entre los diferentes
algoritmos neuronales basados en esta aproximacin estudiaremos el Modelo de Hopfield y el
recocido del campo medio (mean field annealig en ingls).
La segunda aproximacin se basa en las redes competitivas y tienen dos variantes

principales. Como veremos, la primera se basa en la red de Kohonen y la segunda en las redes
deformables, especialmente adaptadas al problema del viajante. No obstante, mostraremos
como extender estas aproximaciones a problemas ms generales como mltiple TSP y el de
rutificacin.
22.6 Aproximacin estadstica para el problema de la optimizacin.
En este apartado expondremos la relacin entre la termodinmica y los problemas de

optimizacin combinatoria. En la ltima dcada se ha visto que los problemas de optimizacin
combinatoria estn relacionados, de esta forma sencilla, con la fsica estadstica :

Una instancia de un problema de optimizacin combinatoria es equivalente a una

muestra en fsica estadstica.
Una prueba en optimizacin combinatoria es una configuracin en fsica
estadstica.
La funcin de coste equivale a la energa.
Una solucin ptima corresponde a la energa mnima.
El coste mnimo es el estado de mnima energa.
Consecuentemente, el primer paso para solucionar el problema de la optimizacin en el

marco de la fsica estadstica es inscribirlo en trminos de estados que sean variables discretas
en un espacio Eucldeo.
BIBLIOGRAFA:
Campos V., Laguna M. y Mart R. (1999), Scatter Search for the Linear Ordering Problem,
New Ideas in Optimisation, D. Corne, M. Dorigo and F. Glover (Eds.), McGraw-Hill. 331-341.
Campos V., Laguna M. y Mart R. (2001) Context-Independent Scatter and Tab Search for
Permutation Problems, Technical report TR03-2001, Departamento de Estadstica e I.O.,
Universidad de Valencia.
Campos, V., F. Glover, M. Laguna and R. Mart (1999) An Experimental Evaluation of a
Scatter Search for the Linear Ordering Problem to appear in Journal of Global Optimization.
Corbern A., E. Fernndez, M. Laguna and R. Mart (2000), Heuristic Solutions to the
Problem of Routing School Buses with Multiple Objectives, Technical report TR08-2000,
Departamento de Estadstica e I.O., Universidad de Valencia.
Davis, L. (1996), Handbook of Genetic Algorithms, International Thomson Computer Press,
Londres.
Daz, A., Glover, F., Ghaziri, H.M., Gonzalez, J.L., Laguna, M, Moscato, P. y Tseng, F.T. (1996).
Optimizacin Heurstica y Redes Neuronales, Paraninfo, Madrid.
Feo, T. and Resende, M.G.C. (1989), A probabilistic heuristic for a computational difficult set
covering problems, Operations research letters, 8, 67-71.
Feo, T. and Resende, M.G.C. (1995), Greedy Randomized Adaptive Search Procedures,
Journal of Global Optimization, 2, 1-27.
Festa, P. and Resende, M.G.C. (2001), GRASP: An Annotated Bibliography, AT&T Labs
Research Tech. Report.
Fisher, M.L. (1980), Worst-Case Analysis of Heuristic Algorithms", Management Science,
26, pg. 1-17.
Glover, F. (1977) Heuristics for Integer Programming Using Surrogate Constraints,
Decision Sciences, Vol. 8, pp. 156-166.
Glover, F. (1986) Future Paths for Integer Programming and Links to Artifical Intelligence,
Computers and Operations Research , 13, 533.
Glover, F. (1989), Tab Search: Part I, ORSA Journal on Computing, 1, 190.
Glover, F. (1990), Tab Search: Part II, ORSA Journal on Computing, 1, 4.
Glover, F. (1998) A Template for Scatter Search and Path Relinking, in Artificial Evolution,
Lecture Notes in Computer Science 1363, J.-K. Hao, E. Lutton, E. Ronald, M. Schoenauer and
D. Snyers (Eds.), Springer-Verlag, pp. 13-54.

Glover, F., M. Laguna and R. Mart (1999) Scatter Search, to appear in Theory and
Applications of Evolutionary Computation: Recent Trends, A. Ghosh and S. Tsutsui (Eds.),
Springer-Verlag.
Glover, F., M. Laguna and R. Mart (2000), Fundamentals of Scatter Search and Path
Relinking, Control and Cybernetics, 29 (3), 653-684.
Glover, F., M. Laguna, E. Taillard and D. de Werra (1993), A users guide to Tab search,
Annals of Operations Research, 4, 3-28.
Glover, F.and Laguna, M. (1997), Tab Search, Ed. Kluwer, London.
Holland, J.H. (1992), Genetic Algorithms, Scientific American, 267, 66.
Johnson, D.S., Aragon, C.R., McGeoch, L.A. and Schevon, C. (1989), Optimization by
Simulated Annealing: An experimental evaluation; Part I, Graph Partitioning, Operations
Research 37.
Johnson, D.S., Aragon, C.R., McGeoch, L.A. and Schevon, C. (1991), Optimization by
Simulated Annealing: An experimental evaluation; Part II, Graph Coloring and Number
Partitioning, Operations Research 39.
Jnger, M., Reinelt, G. y Rinaldi, G. (1995), The Traveling Salesman Problem", En: Ball,
M.O., Magnanti, T.L., Monma, C.L. y Nemhauser, G.L. (eds.), Handbook in Operations
Research and Management Science, Vol. 7, Network Models, pg 225--330. North-
Holland, Amsterdam.
Kirkpatrick, S., Gelatt, C.D. and Vecchi, P.M. (1983), Optimization by simulated annealing,
Science, 220, 671-680
Laguna M. and Mart R. (2000) Experimental Testing of Advanced Scatter Search Designs
for Global Optimization of Multimodal Functions. Technical report TR11-2000,
Departamento de Estadstica e I.O., Universidad de Valencia.
Laguna M. and Mart R. (1999), GRASP and Path relinking for two layer straight-line
crossing minimization, INFORMS Journal on Computing, 11(1), 44-52.
Laguna M. and Mart R. (2002), The OptQuest Callable Library Optimization Software
Class Libraries, Voss and Woodruff (Eds.), 193-218,Kluwer.
Laporte, G. (1992), The Travelling Salesman Problem: An Overview of Exact and
Approximate Algorithms", European Journal of Operational Research, 59, pg. 231--247.
Lawler, E.L., Lenstra, J.K., Rinnooy Kan, A.H.G. y Shmoys, D.B. (eds.) (1985), The Traveling
Salesman Problem. A Guided Tour to Combinatorial Optimization, John Wiley and Sons,
Chichester.
Lin, S. y Kernighan, B.W. (1973), An Effective Heuristic Algorithm for the Traveling
Salesman Problem", Operations Research, 21, pg. 498--516.
Lokketangen, A. and Glover, F. (1996) Probabilistic move selection in Tab search for 0/1
mixed integer programming problems Meta-Heuristics: Theory and Practice, Kluwer, pp.
467-488.
Mart, R. (2000), MultiStart Methods to appear in Handbook on MetaHeuristics, Kluwer.
Michalewicz, Z. (1996), Genetic Algorithms + Data Structures = Evolution Programs, tercera
edicin, Springer Verlag.
Osman, I.H. and Kelly, J.P. (eds.) (1996), Meta-Heuristics: Theory and Applications, Kluwer
Academic, Boston.

Padberg, M.W. y Hong, S. (1980), On the Symmetric Travelling Salesman Problem: A

Computational Study", Mathematical Programming Study, 12, pg. 78-107.
Reeves, C.R. (1995), Modern Heuristic Techniques for Combinatorial Problems, McGraw-Hill,
UK.
Rinnooy Kan, A.H.G. and Timmer, G.T. (1989) Global Optimization Handbooks in
operations research and management science, Vol. 1, Ed. Rinnoy Kan and Todds, North
Holland, pp. 631-662.
Rochat and Taillard (1995) Probabilistic diversification and intensification in local search
for vehicle routing Journal of heuristics, Vol. 1, 1, pp 147-167.
Silver, E.A., Vidal, R.V. y De Werra, D. (1980), A Tutorial on Heuristic Methods", European
Journal of Operational Research, 5, pg. 153162.
Ugray Z., L. Lasdon, J. Plummer, F. Glover, J. Kelly and R. Mart (2001) A Multistart Scatter
Search Heuristic for Smooth NLP and MINLP Problems, Technical report, University of
Texas at Austin.
Ulder, N.L.J., Aarts, E.H.L., Bandelt, H.J., Van Laarhoven, P.J.M. and Pesch, E. (1990)
Genetic Local Search algorithms for the traveling salesman problem, Parallel problem
solving from nature, Eds. Schwefel and Mnner, Springer Verlag, pp. 109-116.
Whitley D. (1993), A genetic Algorithm Tutorial, Tech. Report CS-93-103, Colorado State
University.

Metaheuristicas y Redes Neuronales

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Metaheuristicas y Redes Neuronales

Enviado por

Direitos autorais:

Formatos disponíveis

Metaheursticas y Redes Neuronales ESPOL, 2015/ 1

Metaheursticas y Redes Neuronales

Fernando Sandoya, Ph.D.

Fernando Sandoya, Ph.D.

4.3 Algoritmo de Lin y Kernighan ...................................................................................... 45

Fernando Sandoya, Ph.D.

22.1 Introduccin .............................................................................................................. 111

Fernando Sandoya, Ph.D.

La mayora de problemas de optimizacin combinatoria pueden ser representados

1.1 Conceptos bsicos de grafos y redes

Grafos Dirigidos: Un grafo dirigido (o dgrafo) = (, ) consiste en un conjunto de nodos

Grafos no Dirigidos: Un grafo no dirigido, o simplemente grafo, = (, ) consiste en un

Fernando Sandoya, Ph.D.

Lista de Adyacencia: La lista de arcos de adyacencia () de un nodo i es el conjunto de arcos

SUBGRAFO: Un grafo = (, ) es un subgrafo de = (, ) si y . Diremos

Un grafo = (, ) es un subgrafo de expansin de = (, ) si = y .

CAMINO: Un camino (o denominado tambin camino no dirigido) en un grafo dirigido

Fernando Sandoya, Ph.D.

CAMINO DIRIGIDO: Un camino dirigido es una versin orientada de un camino, en el

Fernando Sandoya, Ph.D.

GRAFO ACCLICO: Un grafo es acclico si no contiene ciclos dirigidos.

CONECTIVIDAD FUERTE: Un grafo conectado est fuertemente conectado si contiene por lo

RBOL: Un rbol es un grafo conectado acclico.

Un rbol de n nodos contiene exactamente n-1 arcos.

Un bosque es un grafo acclico. De manera alternativa un bosque es una coleccin de rboles.

SUBRBOL: Un subrbol es un subgrafo conectado de un rbol.

Fernando Sandoya, Ph.D.

RBOLES DE EXPANSIN: Un rbol es un rbol de expansin de si es un subgrafo de

DEFINICIONES PARA REDES NO DIRIGIDAS:

Si la red contiene al arco(, ), el nodo es adyacente al nodo y el nodo es adyacente al

REPRESENTACIONES DE REDES: La resolucin de problemas de redes no solo depende de los

En la representacin de una red se necesitan dos clases de informacin:

La topologa de la red, es decir la estructura de los nodos y arcos.

A continuacin se presentan algunas representaciones.

Fernando Sandoya, Ph.D.

LISTAS DE ADYACENCIA: Anteriormente se defini a las listas de arcos de Adyacencia ()

Esta representacin almacena la lista de adyacencia de cada nodo en la estructura de datos

Fernando Sandoya, Ph.D.

1.2 Grafos y redes con Mathematica

Mathematica Wolfram incluye grandes capacidades para modelado y visualizacin de grafos y

En el documento: pasos para instalar MATHEMATICA.docx se encuentran las

Fernando Sandoya, Ph.D.

2. Los mtodos heursticos

Aunque estos algoritmos (heursticos o Metaheursticos) son aplicables a la resolucin de

2.1 Definicin y propiedades de los mtodos heursticos

En el lenguaje comn las personas utilizan el trmino optimizar en el sentido de mejorar;

Algunos tipos de problemas de optimizacin son, desde un punto de vista matemtico,

La idea intuitiva de los problemas difciles de resolver queda reflejada en el trmino

Fernando Sandoya, Ph.D.

Un mtodo heurstico es un procedimiento simple, a menudo basado

Por su importancia en el campo de las aplicaciones en la industria, la logstica y el transporte,

Aunque hemos mencionado que la razn de desarrollar y utilizar mtodos heursticos es la

Aunque existe un mtodo exacto para resolver el problema, su uso es

Se puede requerir la utilizacin de un mtodo heurstico como parte de un

- El mtodo heurstico permite determinar una buena solucin inicial de partida.

Fernando Sandoya, Ph.D.

- El mtodo heurstico participa en un paso intermedio del procedimiento, como por

Un agente viajero ha de visitar n ciudades, comenzando y

Resulta muy intuitivo y con un enunciado muy fcil de comprender.

Es uno de los que ms inters ha suscitado en Optimizacin Combinatoria y sobre el que se

Sus soluciones admiten una doble interpretacin: mediante grafos y mediante

Fernando Sandoya, Ph.D.

a. Cuntas soluciones factibles tiene este problema.