FACULTAD DE INGENIERÍA

Carrera de Ingeniería de Sistemas Computacionales

“PROBLEMA DEL AGENTE VIAJERO”

Autores:
Cabrera Abanto, Jorge Fernando

Asesor:
Ing. López Martos Rosa Marleny
Cajamarca - Perú
2019
Problema del agente viajero:
Un agente viajero debe pasar por n ciudades diferentes. El objetivo es encontrar una
ruta que, comenzando y terminando en la misma ciudad, pase una sola vez por cada una
de las ciudades y minimice el costo del recorrido por el viajero. Se conocen los costos
entre cada una de las ciudades, de tal manera que se puede construir un grafo pesado
no dirigido en el que los vértices (o nodos) son las ciudades y el peso de las aristas es el
costo entre las ciudades.

Solución:

El siguiente algoritmo es capaz de generar diversos grafos de ciudades para ser

recorridas por el viajero y mostrarlas en un matriz de adyacencia para comprender la
restricción que el viajero tiene (recorrer todas las ciudades y pasar solo una vez por cada
ciudad).

Ilustración 1. Funciones: generar_Grafo y mostrar_Grafo.

Una vez establecidos los costos en “cero” de la matriz de adyacencia [][] y la ciudad de
inicio (int ciudadactual = 0), el código compara en la matriz todos los costos de visitar

Ilustración 2. generar_Grafo: Asignación de costos en 0

una ciudad, estando en la “ciudad actual” selecciona la siguiente ciudad con el menor
costo posible y almacena esta ciudad en el vector solución (Trayectoria[]).

Ilustración 3. Inicio del recorrido del Grafo

Ilustración 4. busca_Mejorciudad: Comparación de los costos de las ciudades del Grafo

Al completar el recorrido de todas las ciudades se emplea el vector solución

(Trayectoria[]), que guarda el recorrido del viajero y se analiza la matriz de costos según
la solución y se suman todos los costos seleccionados por la “Trayectoria[]”.

Ilustración 6. calcula_Costo: Suma del costo de las ciudades seleccionadas por busca_Mejorciudad.

Ilustración 5. Mostrando la solución de la Trayectoria con menor costo.

Pseudocódigo:

Función AgenteViajeroVoraz (↓A ε Entero [1…NumNodos, 1…NumNodos],

↑trayectoria ε Entero [1…NumNodos+1] )
Constantes
NumNodos 4
Variables
nodoActual, nodoSiguiente ε Entero
trayectoria ε Entero[1…NumNodos+1]
nodosAsignados ε Booleano[1…NumNodos]
Acciones
nodoActual ←0
Para i←1 hasta NumNodos hacer
nodosAsignados[nodoActual] ← true
trayectoria[i] ← nodoActual
nodoSiguiente← BuscaMejorNodo(nodoActual)
nodoActual← nodoSiguiente
Fin Para
Mensaje “el costo total es” CalculaCosto()
trayectoria[NumNodos+1] ←0
regresa trayectoria
Fin Función AgenteViajeroVoraz

El mejor nodo es aquel que tiene la arista de menor peso, siempre y cuando no haya
sido ya tomado en cuenta previamente en la trayectoria.

Función BuscaMejorNodo (↓nodoActual ε Entero, ↑mejorNodo ε Entero)

Constantes
Max 1E10
Variables
mejorNodo ε Entero
menor ε Entero
Acciones
menor ← Max
Para j←1 hasta NumNodos hacer
Si (j ≠ nodoActual) entonces
Si (A[ nodoActual][j] < menor AND NOT nodosAsignados[j]) entonces
menor← A[nodoActual][j]
mejorNodo← j
fin Si
fin Si
Fin Para
regresa mejorNodo
Fin Función BuscaMejorNodo

Finalmente, el siguiente algoritmo que calcula el costo basándose en la trayectoria y en

el costo correspondiente en la matriz de adyacencias.
Función CalculaCosto(↑suma ε Real)
Constantes
NumNodos 4
Variables
suma ε real
nodoActual, nodoSig ε Entero
Acciones
suma ← 0
Para i←1 hasta NumNodos hacer
nodoActual ← trayectoria[i]
nodiSig← trayectoria[i+1]
suma ← suma + A[nodoActual][nodoSig]
Fin Para
regresa suma
Fin Función CalculaCosto

Codificación en C++:

#include <cstdlib>
#include <iostream>
#include <windows.h>
#include <vector>
#define MAX_VALUE 1E10

#include <ctime>
using namespace std;

void generar_Grafo(float Grafo[20][20], int n);

void mostrar_Grafo(float Grafo[20][20], int n);

int busca_Mejorciudad(float Grafo[20][20], int n, int ciudadActual, bool empleado[]);

float calcula_Costo(float Grafo[20][20], int n, int trayectoria[]);

int main(int argc, char *argv[]){

char caracter;
srand(time(NULL));

do{
cout<<"\n\nCantidad de ciudades: ";
int n;
cin>>n;

float Grafo[20][20];
int trayectoria[21] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
bool empleado[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int ciudadActual, siguienteCiudad;

 generar_Grafo(Grafo,n);

cout<<"\nLa matriz de costos es: \n\n";

mostrar_Grafo(Grafo,n);

ciudadActual = 0;

for(int i=0;i<n;i++){
empleado[ciudadActual] = 1;
trayectoria[i] = ciudadActual;
siguienteCiudad =
busca_Mejorciudad(Grafo,n,ciudadActual,empleado);
ciudadActual = siguienteCiudad;
};
trayectoria[n] = 0;

cout<<"\n Trayectoria: {";

for(int i=0; i< n+1;i++){
cout<<trayectoria[i];
if(i<n){
cout<<", ";
}
}

cout<<"}"<<endl;
cout<<"\nEl menor costo del recorrido voraz es:
"<<calcula_Costo(Grafo,n,trayectoria)<<endl<<endl;

cout<<"\n¿Desea valuar otro grafo?. Presione 's'/'n: ";

cin>>caracter;
Sleep(500);
system("cls");

}while((caracter == 's') || (caracter == 'S'));

return 0;
}

void generar_Grafo(float Grafo[20][20], int n){

for(int i=0;i<n;i++){
Grafo[i][i] = 0;
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
cout<<"Grafo["<<i<<", "<<j<<"] = ";
Grafo[i][j] = 3 + rand()% 20;
Sleep(300);cout<<Grafo[i][j]<<endl;
Grafo[j][i] = Grafo[i][j];
}
}
}

void mostrar_Grafo(float Grafo[20][20], int n){

cout<<"\nGRAFO:";

for(int i=0; i<n; i++){

for(int j=0; j<n; j++){
cout<<"\t"<<Grafo[i][j];
}
cout<<endl;
}
return;
}

int busca_Mejorciudad(float Grafo[20][20], int n, int ciudadActual, bool empleado[]){

float menor = MAX_VALUE;

int mejorCiudad;
for(int j=0;j<n;j++){
if(j != ciudadActual){
if(Grafo[ciudadActual][j] < menor && !empleado[j]){
menor = Grafo[ciudadActual][j];
mejorCiudad = j;
 }
}
}
return mejorCiudad;
}

float calcula_Costo(float Grafo[20][20], int n, int trayectoria[]){

float suma = 0;
int ciudadActual, ciudadSiguiente;
for(int i=0;i<n;i++){
ciudadActual = trayectoria[i];
ciudadSiguiente = trayectoria[i+1];
suma = suma + Grafo[ciudadActual][ciudadSiguiente];
}
return suma;