Contenido

1. Algoritmos Genéticos ........................................................................................................... 1

1.1 Problemas de optimización ........................................................................................... 1
1.2 Esquema de los algoritmos genéticos ........................................................................... 3
2. Un catálogo de tipos de cromosomas .................................................................................. 5
2.1 ValuesInRangeChromosome<E> ................................................................................... 5
2.1.1 BinaryChromosome ................................................................................................... 6
2.1.2 RangeChromosome ................................................................................................... 8
2.1.3 RealChromosome ...................................................................................................... 8
2.2 IndexChromosome ........................................................................................................ 9
2.2.1 IndexSubListChromosome......................................................................................... 9
2.2.2 IndexPermutationChromosome .............................................................................. 10
2.2.3 IndexPermutationSubListChromosome .................................................................. 11
3. Ejemplos de algoritmos genéticos ..................................................................................... 11
3.1 Problema de la Mochila .............................................................................................. 11
3.2 Problema de los Anuncios ........................................................................................... 12
3.3 Problema de extremo de una función ........................................................................ 13

1. Algoritmos Genéticos

1.1 Problemas de optimización

Los problemas que pretenden optimizar una función objetivo pueden escribirse de la forma:

min 𝑓(𝑥)
𝑥∈Ω

Donde 𝑥 es un vector de 𝑛 variables y Ω un dominio dónde las variables deben tomar valores.
Los valores de que cumplen 𝑥 ∈ Ω los llamaremos valores válidos. Consideramos que la función
objetivo ℎ es una expresión que devuelve valores reales.
 16. Algoritmos iterativos de aproximación 2

Los problemas de maximización pueden transformarse en problemas de minimización:

max 𝑓(𝑥) = min −𝑓(𝑥)

𝑥∈Ω 𝑥∈Ω

En general el dominio Ω se decribirá como un conjunto de restricciones. Las restricciones suelen

ser de los tipos:
𝑔(𝑥) ≤ 0
ℎ(𝑥) = 0
𝑎≤𝑥≤𝑏

Dónde 𝑥, 𝑎, 𝑏 son vectores de valores. Las primeras son restricciones de desigualdad, las
segundas de igualdad y las últimas de rango.

Un problema multiobjetivo puede ser convertido en otro uniobjetivo combinando los diferentes
objetivos:

min ∑ 𝜔𝑖 𝑓𝑖 (𝑥) , 𝜔𝑖 > 0

𝑥∈Ω
𝑖=1

Donde el valor relativo de las 𝜔𝑖 indicará la prioridad del objetivo correspondiente.

Las restricciones Ω de un problema pueden ser introducidas en la función objetivo. Algunas

equivalencias son:

min 𝑓(𝑥) 𝑟 𝑠
𝑥
𝑔𝑖 (𝑥) ≤ 0, 𝑖 = 1, … , 𝑟 ≡ max( −𝑓(𝑥) − 𝐾(∑(𝑐(𝑔𝑖 (𝑥)))2 − ∑(ℎ𝑗 (𝑥))2 ))
𝑥
ℎ𝑗 (𝑥) = 0, 𝑗 = 1, … , 𝑠 𝑖=1 𝑗=1

𝑎≤𝑥≤𝑏 𝑎≤𝑥≤𝑏

max 𝑓(𝑥) 𝑟 𝑠
𝑥
𝑔𝑖 (𝑥) ≤ 0, 𝑖 = 1, … , 𝑟 ≡ max( 𝑓(𝑥) − 𝐾(∑(𝑐(𝑔𝑖 (𝑥)))2 − ∑(ℎ𝑗 (𝑥))2 ))
𝑥
ℎ𝑗 (𝑥) = 0, 𝑗 = 1, … , 𝑠 𝑖=1 𝑗=1

𝑎≤𝑥≤𝑏 𝑎≤𝑥≤𝑏

Dónde 𝑐(𝑧) una función d ela forma:

0, 𝑧≤0
𝑐(𝑧) = max(0, 𝑧) = {
𝑧, 𝑧>0

Y 𝐾 un valor suficientemente grande. De forma similar podemos obtener equivalencias que

maximicen una función objetivo que incluya las restricciones del problema.
 16. Algoritmos iterativos de aproximación 3

1.2 Esquema de los algoritmos genéticos

Los algoritmos genéticos (GA) son algoritmos iterativos generales de optimización combinatoria.
Son algoritmos probabilísticos cuyo diseño está inspirado en los mecanismos evolutivos que se
encuentran en la naturaleza. Estos algoritmos tienen muchas similitudes, pero también poseen
características distintivas, principalmente en sus estrategias para buscar en el espacio de
soluciones.

Están orientados a resolver problemas de optimización. En un problema de optimización se

busca la solución 𝑥𝑜𝑝 que minimiza una función objetivo 𝑔(𝑥) que toma valores en el conjunto
de soluciones 𝑆 que cumplen las restricciones Ω(𝑥).

𝑆 = {𝑥: 𝑇|Ω(𝑥)}
min 𝑔(𝑥)
𝑥:𝑆

Dónde 𝑇 es el tipo de las soluciones del problema. Al conjunto 𝑆 se le suele llamar espacio de
soluciones del problema. En los algoritmos genéticos que vamos a considerar además un espacio
de valores 𝑉 y una función de transformación 𝑡(𝑣) que toma un valor en 𝑉 y devuelve otro en
𝑇. Cada valor 𝑥 de tipo 𝑇 puede ser obtenido de un valor 𝑣 en 𝑉 tras la aplicación de la función
𝑡. El espacio 𝑉 se escoge para que sus valores se puedan generar fácilmente usando uno de los
cromosomas disponibles.

Un cromosoma es un objeto que tiene un estado interno y una propiedad visible desde el
exterior que produce los valores del espacio de valores asociado al cromosoma. Llamamos
decodificar a la operación consistente en obtener la representación exterior de un cromosoma
a partir de su estado interno.

Para emular la selección natural los algoritmos genéticos usan un conjunto de cromosomas que
llamaremos de forma similar población. Una población va evolucionando a través de tres
operaciones: mutación, cruce y selección.

• Dado un cromosoma podemos obtener otro aplicándole un operador de mutación que

consiste en modificar aleatoriamente una parte de su estado interno.
• Dados dos cromosomas podemos obtener otro aplicando a ambos un operador de cruce
que combina aleatoriamente los estados internos de ambos cromosomas para obtener
el nuevo.
• A los cromosomas en una población le podemos aplicar un operador de selección para
escoger un subconjunto de los mismo.

Por último, definiremos la función de fitness de un cromosoma como una propiedad que toma
un valor real y que define lo bueno que es un cromosoma dentro de la población en la que se
encuentra.
 16. Algoritmos iterativos de aproximación 4

Con los anteriores elementos un algoritmo genético evoluciona partiendo de una población
inicial escogida aleatoriamente y de un tamaño fijado. A cada nueva población se le llama
generación. A esta población le aplica operadores de selección, cruce y mutación siguiendo el
esquema:

1. Se escogen los mejores individuos de una población según una tasa de elitismo y se
pasan a la siguiente generación sin modificación.
2. Se repiten los siguientes pasos hasta que la nueva población alcanza el tamaño
prefijado.
a. Con la política de selección escogida se escogen dos cromosomas para pasar a
la siguiente generación. En un porcentaje establecido dado por la tasa de cruce
se aplica el operador de cruce y en ese caso los hijos sustituyen a los padres. Si
no hay cruce los cromosomas escogidos pasan sin modificación a la siguiente
generación.
b. A cada individuo de los dos anteriores se le aplica en un porcentaje establecido
por la tasa de mutación el operador de mutación fijado.

El algoritmo termina cuando se cumpla la condición de finalización establecida sobre la

población. Los criterios de parada más frecuentes son:

• Número de generaciones
• Tiempo transcurrido
• Que existan en la población un número de cromosomas con las condiciones
especificadas.

Una política de selección muy usada es la denominada elección por torneo. Consiste en
seleccionar sin reemplazamiento un grupo de 𝑛 individuos al azar y de entre ellos escoger el
mejor par. El tamaño del grupo se denomina aridad del Torneo. Una aridad alta implica que los
individuos peores casi nunca son escogidos.

Para resolver un problema mediante técnicas algoritmos genéticos (o técnicas aleatorias en

general) tenemos que escoger un tipo de cromosomas que genere el espacio de valores 𝑉.
Pueden existir distintos tipos de cromosomas adecuados. La mejor alternativa es aquella en la
que el espacio de valores es de un tamaño cercano al espacio de soluciones. Es decir, el conjunto
de soluciones inválidas obtenidas a partir del conjunto de valores es lo más pequeño posible.

Para modelar un problema de optimización del tipo

𝑆 = {𝑥: 𝑇|Ω(𝑥)}
min 𝑔(𝑥)
𝑥:𝑆

Hay que reescribirlo en la forma:

max 𝑓(𝑡(𝑣))
𝑣:𝑉
𝑥 = 𝑡(𝑣)
 16. Algoritmos iterativos de aproximación 5

Donde 𝑓(𝑥) se obtiene a partir de 𝑔(𝑥) incluyendo las restricciones relevantes en la función
objetivo, tal como vimos arriba, y poniendo el problema de optimización en forma de
maximización. Cada cromosoma tiene asociado un valor 𝑣. A partir de ese valor podemos
calcular 𝑓(𝑡(𝑣)). A este valor le llamamos la adecuación del cromosoma. Su fitness.

2. Un catálogo de tipos de cromosomas

Hay una amplia gama de problemas combinatorios que pueden ser abordados partiendo de un
catálogo de cromosomas cuyos operadores de cruce y mutación son conocidos y pueden ser
reutilizados. Veamos los tipos adecuados para ser usados en los Algoritmos Genéticos.

Partimos del tipo genérico para construir los espacios de valores que llamaremos
Chromosome<V>:

public interface Chromosome<V> {

V decode();
double fitness();
}

• V decode(): Función de decodificación

• double fitness(): Función de fitness
• V: Tipo de los valores del cromosoma

Usaremos como base dos cromosomas proporcionados por el Software de Apache:

BinaryChromosome y RandonKey<T>. Son dos cromosomas muy estudiados con operadores de
cruce y mutación muy conocidos. A partir de ellos implementaremos los que siguen que son los
que usaremos en la asignatura. Muchísimos más son posibles.

2.1 ValuesInRangeChromosome<E>

Representa una lista de valores de tipo E que están en un rango. Dispondremos de 3 subtipos:
BinaryChromosome, RangeChromosome y DoubleChromosome. Los detalles específicos para
cada uno de estos cromosomas se indicarán en una implementación del tipo
ValuesInRangeProblemAG<E,S>. Dónde E es el tipo de los elementos del cromosoma y S el tipo
de la solución del problema.

interface ValuesInRangeChromosome<E> extends Chromosome<List<E>> {

}
interface ValuesInRangeProblemAG<E,S> extends ProblemaAG {
Double fitnessFunction(ValuesInRangeChromosome<E> cr);
E getMax(Integer i);
 16. Algoritmos iterativos de aproximación 6

E getMin(Integer i);
Integer getVariableNumber();
S getSolucion(ValuesInRangeChromosome<E> cr)
}

Restricciones:

• n = getVariableNumber();
• d = decode();
• d = decode.size();
• getMin()<= d[i] <= getMax(), i:0..n-1;

2.1.1 BinaryChromosome

Este cromosoma es un caso particular del anterior donde los valores son enteros de mínimo 0 y
máximo 1. Es un cromosoma básico a partir del cual se pueden construir otros más complejos.
Los operadores de mutación son muy conocidos y consisten fundamentalmente en permutar el
valor binario de una casilla escogida al azar.

Los operadores de cruce son también ampliamentre conocidos y pueden consultarse en la

literatura.

Usos:

Este cromosoma es adecuado para modelar un amplio abanico de situaciones. Puede ser
considerado el cromosoma básico a partir del cual construir otros. Con él podemos modelar
todos los problemas de Programación Lineal Entera con variables binarias.

Ejemplo 1: Problema de la Asignación

En este problema tenemos una lista de agentes 𝐿 y una lista de tareas 𝑇 ambas del mismo
tamaño 𝑛. El coste de que el agente 𝑖 realice la tarea 𝑗 sea 𝑐𝑖𝑗 . Se pretende asignar a cada agente
una tarea y sólo una de tal forma que se ejecuten todas las tareas con el coste mínimo.

Una primera versión del problema es hacer una implementación de la solución propuesta más
arriba mediante la técnica de la Programación Lineal Entera. En la solución asumimos las
variables binarias xij toman valor 1 si el agente i ejecuta la tarea j y cero si no la ejecuta. Decimos
que hemos codificado el problema mediante las variables binarias xij . La solución en
Programación Lineal Entera fue:
 16. Algoritmos iterativos de aproximación 7

𝑛−1,𝑛−1

min ∑ 𝑥𝑖𝑗 𝑐𝑖𝑗

𝑖=0,𝑗=0
𝑛−1

∑ 𝑥𝑖𝑗 = 1, 𝑖 ∈ [0, 𝑛 − 1]
𝑗=0
𝑛−1

∑ 𝑥𝑖𝑗 = 1, 𝑗 ∈ [0, 𝑛 − 1]
𝑖=0
𝑏𝑖𝑛 𝑥𝑖𝑗 , 𝑖 ∈ [0, 𝑛 − 1], 𝑗 ∈ [0, 𝑛 − 1]

El cromosoma BinaryChromosome dispone de un vector 𝑑, el resultado de la decodificación, que

debe contenedor todas la varaibles binarias en un total de 𝑛2 que será el tamaño del
cromosoma. Identificamos cada variable 𝑥𝑖𝑗 con una posición 𝑘 en el vector 𝑑 en la forma: 𝑥𝑖𝑗 =
𝑑[𝑘] si 𝑘 = 𝑛𝑖 + 𝑗. La función de fitnes debe tener en cuenta las restricciones tal como hemos
explicado arriba. Con todo ello la función de fitnes, teniendo en cuenta que los Algoritmos
Genéticos buscan el maximizar, puede ser:

𝑛−1,𝑛−1 𝑛−1 𝑛−1 𝑛−1 𝑛−1

𝑓 = −( ∑ 𝑥𝑖𝑗 𝑐𝑖𝑗 ) − 𝐾(∑(∑ 𝑥𝑖𝑗 ) − 1)^2 + ∑((∑ 𝑥𝑖𝑗 ) − 1)^2)

𝑖=0,𝑗=0 𝑖=0 𝑗=0 𝑗=0 𝑖=0

Hay otra forma mejor de resolver este problema como veremos más adelante con un
cromosoma de otro tipo.

La razón es que el porcentaje de valores de cromosomas que no son válidos (que no cumplen
las restricciones) es muy alto. En efecto el número total variables es 𝑛2 y de valores posibles es
2
2𝑛 . Dadas las restricciones de igualdad el número de variables libres es 𝑛2 − 2𝑛 y el total de
2
valores válidos, que cumplen lass restricciones, es 2𝑛 −2𝑛. El cociente nos da la probabilidad de
encontrar un valor válido al azar y es:
2 −2𝑛 2
2𝑛 2𝑛 1
2 = 2 =
2𝑛 22𝑛 2𝑛 22𝑛

Este valor nos da una medida de la calidad de la codificación.

Ejemplo 2: Problema de las estaciones de bomberos

Una ciudad se compone de 𝑛 barrios. Cada barrio es vecino de otros barrios y la relación de
vecindad se puede representar mediante un grafo no dirigido cuyos vértices representan los
barrios y existe una arista entre dos barrios si son vecinos. Queremos ubicar una estación de
bomberos en algunos barrios con la restricción que en cada barrio o en uno de sus vecinos haya
una estación de bomberos. El objetivo es minimizar el número de estaciones de bomberos. Si
las varaibles binarias 𝑥𝑗 indican si un barrio tendrá estación de bomberos o no y 𝑁(𝑗) los
vecinos del barrio 𝑗, el problema de Programación Lineal Entera era:
 16. Algoritmos iterativos de aproximación 8

𝑚−1

min ∑ 𝑥𝑗
𝑗=0

(∑ 𝑥𝑗 ) ≥ 1, 𝑖 ∈ [0, 𝑚)
𝑗:𝑁(𝑖)
𝑏𝑖𝑛 𝑥𝑗 , 𝑗 ∈ [0, 𝑚)

Que podemos podemos reescribir mediante la función de fitness:

𝑚−1 𝑚−1
𝑓 = − ( ∑ 𝑥𝑗 ) − 𝐾 ∑ 𝜑 (( ∑ 𝑥𝑗 ) − 1)
𝑗=0 𝑖=0 𝑗:𝑁(𝑖)
−𝑢, 𝑥<0
𝜑(𝑢) = {
0, 𝑥≥0

2.1.2 RangeChromosome

Es un subtipo de ValuesInRangeChromosome<Integer> cuyos valores son listas de enteros con

las siguientes restricciones del cromosoma. Es decir, la lista decodificada es de tamaño igual al
número de objetos y cada casilla de la misma es un entero positivo o cero y menor o igual que
el máximo permitido para ese tipo de objetos.

Usos:

Es un cromosoma adecuado para resolver problemas cuya solución es un Multiset formado con
elementos de un conjunto dado u otros problemas en los que aparecen variables enteras en un
rango.

Ejemplo: Problema de la Mochila

Ya lo hemos explicado arriba. Ahora las casillas de la lista decodificada es el número de unidaes
escogido de cada objeto. Si 𝑑 es la lista decodificada entonces la función de fitness es:

𝑛−1 𝑠−1

𝑓 = ∑ 𝑑[𝑖]𝑣(𝑖) − 𝐾𝜑((∑ 𝑑[𝑖]𝑤(𝑖 )) − 𝐶)

𝑖=0 𝑖=0
0, 𝑢≤0
𝜑(𝑢) = {
𝑢, 𝑢>0

2.1.3 RealChromosome

Es un subtipo de ValuesInRangeChromosome<Double>. Los valores de estos cromosomas son

listas de números reales en rangos especificados.

Usos:
 16. Algoritmos iterativos de aproximación 9

Este cromosoma es adecuado para modelar funciones de varias variables reales del tipo
𝑓(𝑥0 , 𝑥1 , … , 𝑥𝑛−1 ) de las que se quiere obtener el máximo o el mínimo en un dominio.

2.2 IndexChromosome

Sus valores son listas de Integer que se pueden construir a partir de una secuencia normal y
pueden ser usados como índices en una lista de objetos. Dispondremos de 3 subtipos:

• IndexSubListChromosome,
• IndexPermutationChromosome,
• IndexPermutationSubListChromosome.

Los detalles específicos para cada uno de estos cromosomas se indicarán en una
implementación del tipo IndexProblemAG<S>. Dónde S el tipo de la solución del problema.

interface IndexChromosome extends Chromosome<List<Integer>> {

}
interface IndexProblemAG<S> extends ProblemaAG {
Double fitnessFunction(IndexChromosome cr) ;
Integer getMaxMultiplicity(int index);
List<Integer> getNormalSequence();
Integer getObjectsNumber();
S getSolucion(IndexChromosome cr);
}

Restricciones y notación:

• n = getObjectsNumber();
• r = getNormalSequence().size();
• d = decode();
• s = d.size();
• n<=s<=r;
• m(i) = getMax(i);

Cada cromosoma de este tipo tiene asociada una secuencia normal. Esta secuencia está formada
por la concatenación de n sublistas L(i). Cada L(i) se compone de getMaxMultiplicity (i) copias
del entero i, con i en el rango 0..n-1.

2.2.1 IndexSubListChromosome

Es un subtipo de IndexChromosome cuyos valores son un subconjunto de la secuencia normal

sin importar el orden.

Usos:
 16. Algoritmos iterativos de aproximación 10

Es un cromosoma adecuado para resolver problemas cuya solución es un Multiset formado con
elementos de un conjunto dado.

Ejemplo: Problema de la Mochila

Se parte de 𝐿, una lista de objetos de tamaño 𝑛, y 𝑚 una lista de enteros del mismo tamaño
dónde 𝑚(𝑖) indica el número de repeticiones posibles del objeto en la posición 𝑖. A su vez cada
objeto 𝑜𝑏𝑖 de la lista es de la forma 𝑜𝑏𝑖 = (𝑤(𝑖), 𝑣(𝑖)) dónde 𝑤(𝑖), 𝑣(𝑖) son, respectivamente,
su peso y su valor unitario. Además la mochila tiene una capacidad 𝐶. El problema busca ubicar
en la mochila el máximo número unidades, siempre que no superen las máximas permitidas
para cada tipo de objeto, que quepan en la mochila para que el valor de los mismos sea máximo.

Si 𝑑 es el valor decodificado entonces la función de fitness es:

𝑠−1 𝑠−1

𝑓 = ∑ 𝑣(𝑑[𝑖]) − 𝐾𝜑((∑ 𝑤(𝑑[𝑖]) − 𝐶)

𝑖=0 𝑖=0
0, 𝑢≤0
𝜑(𝑢) = {
𝑢, 𝑢>0

Hemos de tener en cuenta que 𝑑 es un vector cuyas casillas son índices a la lista 𝐿 que se repiten
un máximo indicado en el problema.

2.2.2 IndexPermutationChromosome

Es un subtipo de IndexChromosome cuyos valores son listas de enteros que son permutaciones
de la secuencia normal. Cada entero es un índice a la lista de objetos proporcionada.

Usos:

Es un cromosoma adecuado para resolver problemas cuya solución es una permutación de un

multiconjunto dado de objetos.

Ejemplo: Problema de la Asignación

Como ya vimos en este problema tenemos una lista de agentes 𝐿 y una lista de tareas 𝑇 ambas
del mismo tamaño 𝑛. El coste de que el agente 𝑖 realice la tarea 𝑗 sea 𝑐𝑖𝑗 . Se pretende asignar a
cada agente una tarea y sólo una de tal forma que se ejecuten todas las tareas con el coste
mínimo.

Si asumimos que 𝑑[𝑖] es la tarea asignada al agente 𝑖 la función de fitness se puede escribir
como:
 16. Algoritmos iterativos de aproximación 11

𝑛−1

𝑓 = − ∑ 𝑐𝑖𝑑[𝑖]
𝑖=0

Si comparamos esta solución con la que usaba el BinaryChromosome podemos ver sus ventajas.
Aquí todos los valores son válidos y la función de fitness y mucho más simple de escribir.

2.2.3 IndexPermutationSubListChromosome

Es un subtipo de IndexChromosome cuyos valores son listas de enteros que son subconjuntos
de permutacionaciones de la secuencia normal. Cada entero es un índice a la lista de objetos
proporcionada.

Usos:

Es un cromosoma adecuado para resolver problemas cuya solución es una permutación de un

subconjunto de un multiconjunto dado de objetos.

Ejemplos: El problema de los anuncios simplificado.

Un canal de televisión quiere obtener el máximo rendimiento (en euros) de la secuencia

de anuncios que aparecerá en la cadena después de las campanadas de fin de año. La
secuencia de anuncios del año durará 𝑇 segundos como máximo. Hay una lista 𝐿, de
tamaño 𝑛, de anuncios que se ofertan para ser emitidos. Cada anuncio anuncio 𝑎(𝑖)
𝑏 𝑡(𝑖)
tiene un tiempo de duración 𝑡(𝑖) y está dispuesto a pagar un precio 𝑝(𝑖) = + 𝑐.
𝑝𝑜𝑠(𝑖)
Dónde 𝑏, 𝑐 son constantes y 𝑝𝑜𝑠(𝑖) es la posición en la que se emitirá el anuncio si llega
a ser emitido. Se quiere emitir el subconjunto de 𝐿 cuyo tiempo total de emisión sea
menor o igual que 𝑇 y maximice el precio total de los anuncios.

La función de fitness es:

𝑠−1 𝑠−1
𝑏 𝑡(𝑑[𝑖])
𝑓 = ∑( + 𝑐) − 𝐾𝜑(∑ 𝑡(𝑑[𝑖]) − 𝑇)
𝑖+1
𝑖=0 𝑖=0
0, 𝑥≤0
𝜑(𝑥) = {
𝑥, 𝑥>0

3. Ejemplos de algoritmos genéticos

3.1 Problema de la Mochila

Se parte de 𝐿, una lista de objetos de tamaño 𝑛, y 𝑚 una lista de enteros del mismo tamaño
dónde 𝑚(𝑖) indica el número de repeticiones posibles del objeto en la posición 𝑖. A su vez cada
 16. Algoritmos iterativos de aproximación 12

objeto 𝑜𝑏𝑖 de la lista es de la forma 𝑜𝑏𝑖 = (𝑤(𝑖), 𝑣(𝑖)) dónde 𝑤(𝑖), 𝑣(𝑖) son, respectivamente,
su peso y su valor unitario. Además, la mochila tiene una capacidad 𝐶. El problema busca ubicar
en la mochila el máximo número unidades, siempre que no superen las máximas permitidas
para cada tipo de objeto, que quepan en la mochila para que el valor de estos sea máximo.

Si 𝑑 es el valor decodificado usando un cromosoma tipo IndexChromosomeSubList entonces la

función de fitness es:

𝑠−1 𝑠−1

𝑓 = ∑ 𝑣(𝑑[𝑖]) − 𝐾𝜑((∑ 𝑤(𝑑[𝑖]) − 𝐶)

𝑖=0 𝑖=0
0, 𝑢≤0
𝜑(𝑢) = {
𝑢, 𝑢>0

Hemos de tener en cuenta que 𝑑 es un vector cuyas casillas son índices a la lista 𝐿 que se repiten
un máximo indicado en el problema.

Si 𝑑 es la lista decodificada usando un cromosoma tipo IndexChromosomeBinary entonces la

función de fitness es:

𝑛−1 𝑠−1

𝑓 = ∑ 𝑑[𝑖]𝑣(𝑖) − 𝐾𝜑((∑ 𝑑[𝑖]𝑤(𝑖 )) − 𝐶)

𝑖=0 𝑖=0
0, 𝑢≤0
𝜑(𝑢) = {
𝑢, 𝑢>0

3.2 Problema de los Anuncios

Un canal de televisión quiere obtener el máximo rendimiento (en euros) de la secuencia

de anuncios que aparecerá en la cadena después de las campanadas de fin de año. La
secuencia de anuncios del año durará 𝑇 segundos como máximo. Hay una lista 𝐿, de
tamaño 𝑛, de anuncios que se ofertan para ser emitidos. Cada anuncio anuncio 𝑎(𝑖)
𝑏 𝑡(𝑖)
tiene un tiempo de duración 𝑡(𝑖) y está dispuesto a pagar un precio 𝑝(𝑖) = + 𝑐.
𝑝𝑜𝑠(𝑖)
Dónde 𝑏, 𝑐 son constantes y 𝑝𝑜𝑠(𝑖) es la posición en la que se emitirá el anuncio si llega
a ser emitido. Se quiere emitir el subconjunto de 𝐿 cuyo tiempo total de emisión sea
menor o igual que 𝑇 y maximice el precio total de los anuncios.

La función de fitness es:

𝑠−1 𝑠−1
𝑏 𝑡(𝑑[𝑖])
𝑓 = ∑( + 𝑐) − 𝐾𝜑(∑ 𝑡(𝑑[𝑖]) − 𝑇)
𝑖+1
𝑖=0 𝑖=0
0, 𝑥≤0
𝜑(𝑥) = {
𝑥, 𝑥>0
 16. Algoritmos iterativos de aproximación 13

El problema puede ser ampliado para tener en cuenta otras restricciones como por ejemplo
que existan anuncios

3.3 Problema de extremo de una función

Dada una función en un rango y con unas restricciones encontrar su mínimo o su máximo.

max ℎ(𝑥)
𝑎≤𝑥≤𝑏, 𝑥∈Ω

La función de fitness es de la forma

𝑓 = ℎ(𝑑) − 𝐾 ∗ 𝑅(𝑑)

Usando el cromosoma RealChromosome el valor decodificado es una lista de valores reales en

el rango especificado. La función 𝑅(𝑑) mide la distancia del punto a la zona definida por las
restricciones