El problema del agente viajero resuelto por fuerza, programación dinámica y voraz

EL AGENTE VIAJERO

Análisis y diseño de algoritmos, MCC 2015

Luis Alfredo Moctezuma Pascual

BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA

FACULTAD DE CIENCIAS DE LA COMPUTACIÓN

INTRODUCCIÓN

El problema del agente viajero(TSP) ha sido

estudiado desde hace mucho tiempo, debido a su

complejidad computacional y por la gran cantidad

de aplicaciones a la vida real

La minimización de rutas de transporte, es decir

encontrar la ruta que nos cueste menos para ir de

un lugar a otro

En la industria por ejemplo se ha usado para la

distribución de mercancía

Logística en general

INTRODUCCIÓN

En la computación es muy importante analizar

estos problemas ya que inicialmente se

propusieron soluciones que tardaban mucho

tiempo

Lo que se busca es minimizar la complejidad

computacional que requiere un problema para

dar una solución

EL AGENTE VIAJERO

El problema consta de un conjunto de ciudades

por las que se tiene que pasar exactamente una

vez y regresar al punto de origen con el menor

costo posible.

EL AGENTE VIAJERO

Para esta tarea se han realizado distintos tipos

de algoritmos, como lo son:

Fuerza bruta

Divide y vencerás

Decrece y conquista

Programación dinámica

Algoritmos voraces

Algoritmos genéticos

Entre otros

EL AGENTE VIAJERO

Algunos de los métodos listados anteriormente

dan una solución parcial del problema, o también

llamadas soluciones locales. Cuando se resuelve

por fuerza bruta se asegura que se obtendrá la

mejor ruta, es decir la ruta que cuesta menos.

MÉTODOS

Se presentan tres diferentes técnicas usadas para

resolver el problema del agente viajero, así como

su complejidad computacional.

Con este análisis de cada uno de los métodos

usados se pueden mostrar las ventajas y

desventajas de usar cada uno de ellos.

1 FUERZA BRUTA

1 FUERZA BRUTA

En el problema del agente viajero la solución más

directa puede ser, intentar todas las

permutaciones y ver cuál de estas es la menor.

El tiempo de ejecución es un factor polinómico

del orden O(n!), el factorial del número de

ciudades, esta solución es impracticable para

dado solamente 20 ciudades por ejemplo.

2,432,902,008,000,000,000 permutaciones

1 FUERZA BRUTA

En general, se pueden resolver problemas con

subestructuras óptimas siguiendo estos tres

pasos:

Paso 1: Generar una permutación con cada vecino

hasta llegar al destino.

Paso 2: Guardar la posible ruta y calcular el costo

Repetir paso 1 y 2

Comparar todas las iteraciones, la ruta mínima es el

resultado óptimo.

1 FUERZA BRUTA

Es posible generar las permutaciones de todos los

nodos usando el algoritmo de Jhonson Trotter

para posteriormente usar como posible ruta cada

una de las permutaciones.

1 FUERZA BRUTA

Para generar las permutaciones se usó una clase predeterminada de java llamada nextPermutation, que aplica el algoritmo de Jhonson Trotter.

Johnson Trotter(n)

//Input: Un entero positive n

initialize the first permutation with: <0, <1, <2

//(Todos los elementos apuntando hacia la izquierda)

while ( //La ultima permutacion tenga un element movil)

// k ← el elemento movil k mas grande

//Intercambiar K con el elemento que lo apunta

//Invertir la direccion de todos los elementos > K

//Agregar la permutacion a la lista

1 FUERZA BRUTA

Al tener las iteraciones realizadas, podemos

tomar todas las rutas planteadas y calcular el

costo, después buscar la de menor costo y

proponer como la mejor.

Para cada permutación i

Para j=0 hasta permutacion.length

Costo[i] += path[j]+ path[j+1]

fin i++

fin

//Buscar el arreglo de menor costo.

mejorRuta=min(costo)

1 FUERZA BRUTA

TSP con 4 ciudades:

Permutaciones

C0C1C2C3C0

C0C1C3C2C0

C0C3C1C2C0

C0C3C2C1C0

C0C2C3C1C0

C0C2C1C3C0

Total de permutaciones: 3! si se parte de una ciudad especifica.

Ejemplo 1

C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

TSP con 4 ciudades:

Permutaciones

C0C1C2C3C0 costo = 8

C0C1C3C2C0

C0C3C1C2C0

C0C3C2C1C0

C0C2C3C1C0

C0C2C1C3C0

C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

TSP con 4 ciudades:

Permutaciones



C0C3C1C2C0

C0C3C2C1C0

C0C2C3C1C0

C0C2C1C3C0

C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

TSP con 4 ciudades:

Permutaciones




C0C3C2C1C0

C0C2C3C1C0

C0C2C1C3C0

C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

TSP con 4 ciudades:

Permutaciones





C0C2C3C1C0

C0C2C1C3C0

C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

TSP con 4 ciudades:

Permutaciones






C0C2C1C3C0

C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

TSP con 4 ciudades:

Permutaciones







C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

TSP con 4 ciudades:

Mejor ruta







C0 C1 C2 C3

C0 0 3 4 2

C1 3 0 1 5

C2 4 1 0 2

C3 2 5 2 0

1 FUERZA BRUTA

El problema se resolvió para 16 ciudades con las

distancias que se muestran en la siguiente tabla: C0 C1 C2 C3 C4 C6 C10 C13 C8 C7 C15 C12

C9 C5C14C110 costo = 24 tiempo de ejecución 11,164 ms

C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 C12 C13 C14 C15

C0 0 3 4 2 5 3 1 1 4 4 2 2 3 2 5 4

C1 3 0 1 5 3 3 4 2 2 5 3 2 2 3 5 5

C2 4 1 0 2 5 3 3 5 5 5 5 5 4 1 4 1

C3 2 5 2 0 1 1 2 1 3 2 3 2 2 3 5 3

C4 5 3 5 1 0 3 3 2 2 1 1 5 2 2 5 5

C5 3 3 3 1 3 0 4 3 1 1 3 5 3 4 1 3

C6 1 4 3 2 3 4 0 3 2 2 1 2 3 3 5 5

C7 1 2 5 1 2 3 3 0 1 4 5 5 1 4 4 2

C8 4 2 5 3 2 1 2 1 0 2 4 4 3 1 1 3

C9 4 5 5 2 1 1 2 4 2 0 3 3 1 3 5 5

C10 2 3 5 3 1 3 1 5 4 3 0 2 3 1 2 4

C11 2 2 5 2 5 5 2 5 4 3 2 0 5 3 2 5

C12 3 2 3 2 2 3 3 1 2 1 3 5 0 5 5 1

C13 2 3 1 3 2 4 3 4 1 3 1 3 5 0 2 5

C14 5 5 4 5 5 1 5 4 1 5 2 2 5 2 0 5

C15 4 5 1 3 5 3 5 2 3 5 4 5 1 5 5 0

Ejemplo 2

1 FUERZA BRUTA

Por fuerza bruta se ha logrado encontrar el

camino con un óptimo global, es decir el que

cuesta menos para recorrer el camino del agente

viajero.

Con 16 ciudades el algoritmo genera 16! 20, 922,

789, 888, 000 permutaciones, luego cada

permutación es usada para calcular el costo y

finalmente poder comparar cada ruta en busca de

la menor.

1 FUERZA BRUTA

Análisis de complejidad

Para realizar las permutaciones con el algoritmo de

Jhonson Trotter se necesita un tiempo de O(n!),

mas el tiempo que se necesite para recuperar la

distancia de cada posible ruta, necesita recorrer

todas las permutaciones, esto es O(n!),

En general el agente viajero resuelto por esta

técnica necesita un tiempo de O(n!).

2 PROGRAMACIÓN DINÁMICA


En este tipo de programación utiliza un método

para reducir el tiempo de ejecución de un

algoritmo mediante la división en subproblemas y

resolver recordando todas las soluciones por si en

las siguientes iteraciones fuera necesarias

nuevamente.

TSP con algoritmo Held–Karp

Resuelve el problema en 𝜃 𝑛2 2𝑛

Necesita 𝑛2 2𝑛 espacio para almacenar operaciones


𝐷(𝑉𝑖 𝑆) Será la longitud del camino mínimo

partiendo del vértice Vi que pasa por todos los

vértices del conjunto S y vuelve al vértice 𝑉𝑖

En general la relación de recurrencia es la

siguiente:

𝑔 𝑖, { } = 𝐿𝑖1 Cuando S es { }

𝑔 𝑖, 𝑆 = 𝑀𝑖𝑛𝑗∈𝑆 𝐿𝑖𝑗 + 𝑔 𝑗, 𝑆 𝑗

𝒈(𝒊, 𝑺) Será la longitud del camino mínimo

partiendo del vértice i que pasa por todos los

vértices del conjunto S y vuelve al vértice 𝒊.


Aplicar la ecuación de recurrencia

𝑔 𝑖, { } = 𝐿𝑖1 Cuando S es { }

g(1,Ø) = 5 g(2,Ø) = 6 g(3,Ø) = 8


𝑔(2, {3}) = 𝑀𝑖𝑛{ 𝐿23 + 𝑔(3, Ø) } = 9 + 6 = 15

𝑔(2, {4}) = 𝑀𝑖𝑛{ 𝐿24 + 𝑔(4, Ø) } = 10 + 8 = 18

𝑔(3, {2}) = 𝑀𝑖𝑛{𝐿32 + 𝑔(2, Ø) } = 13 + 5 = 18

𝑔(3, {4}) = 𝑀𝑖𝑛{𝐿34 + 𝑔(4, Ø) } = 12 + 8 = 20

𝑔(4, {2}) = 𝑀𝑖𝑛{𝐿42 + 𝑔(2, Ø) } = 8 + 5 = 13

𝑔(4, {3}) = 𝑀𝑖𝑛{𝐿43 + 𝑔(3, Ø) } = 9 + 6 = 15

L

0 10 15 205 0 9 106 13 0 128 8 9 0

Ejemplo 1



𝑔 𝑖, 𝑆 = 𝑀𝑖𝑛𝑗∈𝑆 𝐿𝑖𝑗 + 𝑔 𝑗, 𝑆 𝑗 𝑔 2, 3,4 = 𝑀𝑖𝑛 𝐿23 + 𝑔 3, 4 , 𝐿24+𝑔 4, 3 = 9 + 20, 10 +15 = 29, 25 = 25

g(3,{2,4}) =Min{ 𝐿32 + g(2,{4}) , 𝐿34 + g(4,{2})} = 13 +18, 12+13 = 31, 25= 25

g(4,{2,3}) = Min{ 𝐿42 + g(2,{3}) , 𝐿43 + g(3,{2})} = 8 +15, 9+18 = 23, 27= 23

L

0 10 15 205 0 9 106 13 0 128 8 9 0




𝑔 (1, {2,3,4}) = 𝑀𝑖𝑛{𝐿12 + 𝑔(2, {3,4}) ,

𝐿13 + 𝑔(3, {2,4}) ,

𝐿14 + 𝑔(4, {2,3}) }

=10+25, 15+25, 20+23 = 35, 40,43 = 35 es la ruta de menor costo

𝐿12 + 𝑔(2, {3,4}) = 𝐿12 + ( 𝐿24 + 𝑔(4, {3}) )

= 𝐿12 + 𝐿24 + (𝐿43 + 𝑔(3, Ø)) = 𝐿12 + 𝐿24 + 𝐿43 + 𝐿31 = 10 + 10 + 9 + 6 = 35

La ruta de menor costo es seguir: 124 31

L

0 10 15 205 0 9 106 13 0 128 8 9 0


La ruta de menor costo es seguir: 124 31


.

C0 C1 C2 C3 C4 C5 C6 C7

C0 0 2 1 3 4 5 5 6

C1 1 0 4 4 2 5 5 6

C2 5 4 0 2 2 6 5 6

C3 5 2 2 0 3 2 5 6

C4 4 2 4 2 0 3 5 6

C5 4 2 4 2 3 0 5 6

C6 4 2 4 2 4 3 0 6

C7 4 2 4 2 8 3 5 0

0 2 4 7 3 5 6 1 0

Ejemplo 2


Tiempo de ejecución en java 119 minutos 24 segundos

C0 C1 C2 C3 C4 C5 C6 C7 C8 C9

C0 0 3 4 2 5 3 1 1 4 4

C1 3 0 1 5 3 3 4 2 2 5

C2 4 1 0 2 5 3 3 5 5 5

C3 2 5 2 0 1 1 2 1 3 2

C4 5 3 5 1 0 3 3 2 2 1

C5 3 3 3 1 3 0 4 3 1 1

C6 1 4 3 2 3 4 0 3 2 2

C7 1 2 5 1 2 3 3 0 1 4

C8 4 2 5 3 2 1 2 1 0 2

C9 4 5 5 2 1 1 2 4 2 0

07349581260

Ejemplo 3

07349581260



Cálculo de g(j,Ø): n-1 consultas a una tabla, para

llenar la primera iteración.

Cálculo de los g(j,S) tales que 1≤ S=k ≤ n-2 :

Tiempo de cálculo:

𝜃 𝑛 − 1 + 𝑛 − 1 𝐾𝑛 − 2𝑘

𝑛−2𝑘=1 = 𝜃(𝑛2 2𝑛)

Costo en espacio (para conservar g y J): 𝑛22𝑛

Complejidad en tiempo: 𝜃(𝑛2 2𝑛)

(n 1) n 2

k

k sumas en total ,

3 ALGORITMO VORAZ

3 ALGORITMO VORAZ

El vecino más cercano

Permite al viajante elegir la ciudad no visitada más

cercana como próximo movimiento.

En promedio, retorna un camino de un 25% más largo

que el menor camino posible.

Revuelve el problema del agente viajero hasta con

14,900 ciudades rápidamente.

3 ALGORITMO VORAZ

Para el caso del agente viajero no se asegura que la solución dada sea la mejor. En general el proceso seguido es el siguiente.

Paso 1: Se inicia la distancia en 0 ”cero” y un arreglo de vecinos vacía

Paso 2: Se toma un nodo inicial, generalmente el primero del grafo.

Paso 3: Se calculan las distancias con todos sus vecinos que no estén en la lista de visitados.

Paso 4: Se elige el vecino más cercano al nodo inicial

Paso 5: La distancia se actualiza con la distancia acumulada más la distancia del vecino más próximo.

Paso 6: El nodo inicial se guarda en la lista de visitados, el vecino seleccionado ahora es el nodo inicial.

Paso 7: Repetir desde el paso 2 mientras no se llegue al destino.

3 ALGORITMO VORAZ

Ejemplo 1

C0 min(C1,C2,C3) = C0 C2

C2 min(C1,C3) = C2 C3

C3 min(C1) = C3 C1

C1 C0

C0C2C3C1C0

costo= 1+2+2+1=6

C0 C1 C2 C3

C0 0 2 1 3

C1 1 0 4 4

C2 5 4 0 2

C3 5 2 2 0

3 ALGORITMO VORAZ

Ejemplo 2

C0 min(C1,C2,C3,C4,C5) = C0 C2 costo=1

C2 min(C1,C3,C4,C5) = C2 C3 costo +=2

C3 min(C1,C4,C5) = C3 C1 costo += 2

C1 min(C4,C5) = C1 C4 costo +=2

C4 min(C5) = C4 C5 costo+=3

Regresar a C0 costo += 4

0231450 costo=1+2+2+2+3+4 = 14

C0 C1 C2 C3 C4 C5

C0 0 2 1 3 4 5

C1 1 0 4 4 2 5

C2 5 4 0 2 2 6

C3 5 2 2 0 3 2

C4 4 2 4 2 0 3

C5 4 2 4 2 3 0

3 ALGORITMO VORAZ

Ejemplo 2

0231450 costo=1+2+2+2+3+4 = 14

C0 C1 C2 C3 C4 C5

C0 0 2 1 3 4 5

C1 1 0 4 4 2 5

C2 5 4 0 2 2 6

C3 5 2 2 0 3 2

C4 4 2 4 2 0 3

C5 4 2 4 2 3 0

3 ALGORITMO VORAZ

Ejemplo 3

C0 min(C1,C3,C5) = C0 C2 costo +=1


C1 min(C4) = C1 C4 costo +=1


C3 min(C5) = C3 C5 costo +=2

Regresar a C0 costo +=4

0214350 costo= 14

C0 C1 C2 C3 C4 C5

C0 0 2 1 3

C1 1 0 2 5

C2 5 4 0 6

C3 5 2 0 3 2

C4 4 2 2 0 3

C5 4 2 0

3 ALGORITMO VORAZ

Ejemplo 3

0214350 costo= 1+2+2+2+4= 11

3 ALGORITMO VORAZ


El algoritmo toma un nodo y visita a sus vecinos para

calcular las distancias, elige el costo menor y repite el

proceso

En un grafo totalmente conectado y calculará todos

los vecinos que no hayan sido visitados antes,

eligiendo al menor costo. El problema es más pequeño

en cada iteración hasta llegar al destino. Por lo

tanto: 𝜃 𝑛 log 𝑛 , donde n son las ciudades.

COMPARACIÓN

TSP con 5 ciudades

FB = C0C4C2C1C3C0 costo = 13 ms=33

PD = C0C4C2C1C3C0 costo = 13 ms=33

V = C0C2C1C3C4C0 costo = 14 ms=1

C0 C1 C2 C3 C4

C0 0 3 2 3 4

C1 3 0 1 3 3

C2 2 1 0 3 2

C3 3 3 3 0 4

C4 4 3 2 4 0

COMPARACIÓN

TSP con 8 ciudades

FB = C0C6C7C5 C1C2C4C3C0

costo = 14 ms=47

PD = C0C6C7C5 C1C2C4C3C0

costo = 14 ms= 18,174

V = C0C6C7C5 C1C2C4C3 C0

costo = 14 ms=1

C

0

C

1

C

2

C

3

C

4

C

5

C

6

C

7

C0 0 3 4 2 3 1 1

C1 3 0 2 2 3 2 4

C2 4 2 0 3 3 4 2

C3 2 2 0 2 3

C4 3 3 2 0 3 3

C5 3 2 3 3 3 0 4 1

C6 1 4 3 4 0 1

C7 1 4 2 1 1 0

COMPARACIÓN

TSP con 10 ciudades

FB = C0C7C4C5C9C8C1C3C2C6C0

costo = 15 ms=450

PD = C0C7C4C5C9C8C1C3C2C6C0

costo = 15 394 minutos ~6hrs

V = 06231894570

costo = 16 ms=1

C

0

C

1

C

2

C

3

C

4

C

5

C

6

C

7

C

8

C

9

C0 0 3 4 2 99 3 1 1 4 4

C1 3 0 3 2 99 4 4 99 1 99

C2 4 3 0 2 2 99 3 2 2 3

C3 2 2 2 0 2 2 99 3 3 99

C4 99 99 2 2 0 1 4 1 2 2

C5 3 4 99 2 1 0 3 2 3 2

C6 1 4 3 99 4 3 0 3 3 3

C7 1 99 2 3 1 2 3 0 99 99

C8 4 1 2 3 2 3 3 99 0 1

C9 4 99 3 99 2 2 3 99 1 0

CONCLUSIONES

Rápido + No eficaz voraz

Eficaz + lento fuerza bruta

Eficaz + Alto uso de memoria programación

dinámica

Science

El problema del agente viajero resuelto por fuerza, programación dinámica y voraz