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

1. 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

2. 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

3. 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

4. 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.

5. 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

6. 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.

7. 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.

8. 1 FUERZA BRUTA

9. 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

10. 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.

11. 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.

12. 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

13. 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)

14. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Permutaciones
C0C1C2C3C0
C0C1C3C2C0
C0C3C1C2C0
C0C3C2C1C0
C0C2C3C1C0
C0C2C1C3C0
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

15. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Permutaciones
C0C1C2C3C0 costo = 8
C0C1C3C2C0
C0C3C1C2C0
C0C3C2C1C0
C0C2C3C1C0
C0C2C1C3C0
C0 C1 C2 C3
C0 0 3 4 2
C1 3 0 1 5
C2 4 1 0 2
C3 2 5 2 0

16. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Permutaciones
C0C1C2C3C0 costo = 8
C0C1C3C2C0 costo = 14
C0C3C1C2C0
C0C3C2C1C0
C0C2C3C1C0
C0C2C1C3C0
C0 C1 C2 C3
C0 0 3 4 2
C1 3 0 1 5
C2 4 1 0 2
C3 2 5 2 0

17. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Permutaciones
C0C1C2C3C0 costo = 8
C0C1C3C2C0 costo = 14
C0C3C1C2C0 costo = 12
C0C3C2C1C0
C0C2C3C1C0
C0C2C1C3C0
C0 C1 C2 C3
C0 0 3 4 2
C1 3 0 1 5
C2 4 1 0 2
C3 2 5 2 0

18. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Permutaciones
C0C1C2C3C0 costo = 8
C0C1C3C2C0 costo = 14
C0C3C1C2C0 costo = 12
C0C3C2C1C0 costo = 8
C0C2C3C1C0
C0C2C1C3C0
C0 C1 C2 C3
C0 0 3 4 2
C1 3 0 1 5
C2 4 1 0 2
C3 2 5 2 0

19. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Permutaciones
C0C1C2C3C0 costo = 8
C0C1C3C2C0 costo = 14
C0C3C1C2C0 costo = 12
C0C3C2C1C0 costo = 8
C0C2C3C1C0 costo = 14
C0C2C1C3C0
C0 C1 C2 C3
C0 0 3 4 2
C1 3 0 1 5
C2 4 1 0 2
C3 2 5 2 0

20. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Permutaciones
C0C1C2C3C0 costo = 8
C0C1C3C2C0 costo = 14
C0C3C1C2C0 costo = 12
C0C3C2C1C0 costo = 8
C0C2C3C1C0 costo = 14
C0C2C1C3C0 costo = 12
C0 C1 C2 C3
C0 0 3 4 2
C1 3 0 1 5
C2 4 1 0 2
C3 2 5 2 0

21. 1 FUERZA BRUTA
 TSP con 4 ciudades:
Mejor ruta
C0C1C2C3C0 costo = 8
C0C1C3C2C0 costo = 14
C0C3C1C2C0 costo = 12
C0C3C2C1C0 costo = 8
C0C2C3C1C0 costo = 14
C0C2C1C3C0 costo = 12
C0 C1 C2 C3
C0 0 3 4 2
C1 3 0 1 5
C2 4 1 0 2
C3 2 5 2 0

22. 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 C5C14C110 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

23. 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.

24. 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!).

25. 2 PROGRAMACIÓN DINÁMICA

26. 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

27. 2 PROGRAMACIÓN DINÁMICA
 𝐷(𝑉𝑖 𝑆) 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 𝒊.

28. 2 PROGRAMACIÓN DINÁMICA
 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 20
5 0 9 10
6 13 0 12
8 8 9 0








Ejemplo 1

29. 2 PROGRAMACIÓN DINÁMICA
 Aplicar la ecuación de recurrencia
𝑔 𝑖, 𝑆 = 𝑀𝑖𝑛𝑗∈𝑆 𝐿𝑖𝑗 + 𝑔 𝑗, 𝑆 𝑗
 𝑔 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 20
5 0 9 10
6 13 0 12
8 8 9 0









30. 2 PROGRAMACIÓN DINÁMICA
 Aplicar la ecuación de recurrencia
𝑔 𝑖, 𝑆 = 𝑀𝑖𝑛𝑗∈𝑆 𝐿𝑖𝑗 + 𝑔 𝑗, 𝑆 𝑗
 𝑔 (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: 124 31
L 
0 10 15 20
5 0 9 10
6 13 0 12
8 8 9 0









31. 2 PROGRAMACIÓN DINÁMICA
 La ruta de menor costo es seguir: 124 31

32. 2 PROGRAMACIÓN DINÁMICA
.
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

33. 2 PROGRAMACIÓN DINÁMICA
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
07349581260
Ejemplo 3

34. 07349581260

35. 2 PROGRAMACIÓN DINÁMICA
 Análisis de complejidad
 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): 𝑛2
2 𝑛
 Complejidad en tiempo: 𝜃(𝑛2
2 𝑛
)
(n 1) n  2
k




k sumas en total ,

36. 3 ALGORITMO VORAZ

37. 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.

38. 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.

39. 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
C0C2C3C1C0
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

40. 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
0231450 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

41. 3 ALGORITMO VORAZ
 Ejemplo 2
0231450 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

42. 3 ALGORITMO VORAZ
 Ejemplo 3
C0  min(C1,C3,C5) = C0  C2 costo +=1
C2  min(C1,C5) = C2  C1 costo +=4
C1 min(C4) = C1  C4 costo +=1
C4  min(C3,C5) = C4  C3 costo +=2
C3  min(C5) = C3  C5 costo +=2
Regresar a C0 costo +=4
0214350 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

43. 3 ALGORITMO VORAZ
 Ejemplo 3
0214350 costo= 1+2+2+2+4= 11

44. 3 ALGORITMO VORAZ
 Análisis de complejidad
 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.

45. COMPARACIÓN
 TSP con 5 ciudades
FB = C0C4C2C1C3C0 costo = 13 ms=33
PD = C0C4C2C1C3C0 costo = 13 ms=33
V = C0C2C1C3C4C0 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

46. COMPARACIÓN
 TSP con 8 ciudades
FB = C0C6C7C5 C1C2C4C3C0
costo = 14 ms=47
PD = C0C6C7C5 C1C2C4C3C0
costo = 14 ms= 18,174
V = C0C6C7C5 C1C2C4C3 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

47. COMPARACIÓN
 TSP con 10 ciudades
FB = C0C7C4C5C9C8C1C3C2C6C0
costo = 15 ms=450
PD = C0C7C4C5C9C8C1C3C2C6C0
costo = 15 394 minutos ~6hrs
V = 06231894570
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

48. CONCLUSIONES
 Rápido + No eficaz  voraz
 Eficaz + lento  fuerza bruta
 Eficaz + Alto uso de memoria  programación
dinámica