Beruflich Dokumente
Kultur Dokumente
Integrantes :
Cárdenas Fernández Carlos Mauro
Espinoza Rimas José Luis
Silvera Irupailla Joel Armando
Vega Calero Wilder
Sección : “X”
2007 – I
Algoritmo del Cartero
INDICE
Introducción......................................................................................................................4
Capitulo I
Desventajas.......................................................................................................................6
Aproximaciones................................................................................................................7
Solución............................................................................................................................7
Capitulo II
Capítulo III
Anexos............................................................................................................................24
Bibliografía.....................................................................................................................25
Investigación de Operaciones II 3
Algoritmo del Cartero
INTRODUCCIÓN
Los alumnos
Investigación de Operaciones II 4
Algoritmo del Cartero
CAPITULO I
Si los arcos no son unicursivos, (en una sola dirección) se pueden utilizar reglas
muy sencillas para saber si hay una solución de ruta Euler.
Fue una revista china de matemáticas donde se planteó por primera vez una
solución óptima a un circuito Euler. Describiendo las actividades de un cartero en
caminar su ruta postal (en otras palabras "la ruta del cartero chino"). En este problema la
ruta buscada es la que reduce la distancia viajando a lo largo de las calles (arcos) un
sentido único y de regreso a su central de correos.
Investigación de Operaciones II 5
Algoritmo del Cartero
Desventajas
Los algoritmos del agente viajero y del cartero chino no toman en cuenta
prioridades dentro de la microruta. Una prioridad puede ser una mayor generación (más
demanda del servicio) en cierto sitio entre muchos otros de menor generación (demanda
menor). Son poco flexibles. Cualquier cambio en la topografía, generación,
climatología, cambios en la velocidad de crucero del vehículo recolector, cambio en
sentido de las calles; hacen necesario reformular toda la subrutina para encontrar rutas
disponibles.
APROXIMACIONES
Investigación de Operaciones II 6
Algoritmo del Cartero
SOLUCION
• Se toma como punto para almorzar Ap, el cual ofrece el camino mínimo entre Ci y
cada uno de los Aj (vértices donde se puede almorzar) con 1≤j≤m. Después de elegir
este vértice Ap se halla el camino mínimo de Ap a Cf. Aunque este algoritmo puede
funcionar para algunos casos es incorrecto. Suponga el camino entre Ci y Ap tiene
una tamaño p1, y que, el camino de Ap a Cf tiene tamaño p2. Suponga ahora que se
tiene un camino que pasa por un vértice Aq que a su vez es un vértice donde se
puede almorzar. De acuerdo con el algoritmo tenemos la certeza de que p1≤
costo{Ci..Aq} para cualquier Aq, pero no tenemos ninguna certeza acerca de que p2≤
Investigación de Operaciones II 7
Algoritmo del Cartero
Supongamos que tenemos como solución el camino Ci-Ap-Cf y que existe otro
camino con costo menor que también tiene como vértice para almorzar a Ap, esto
contradice el hecho de que Ci-Ap y Ap-Cf sean caminos mínimos (si fuese así tendríamos
un Ci-Ap y/o un Ap-Cf de menor costo entonces Ci-Ap y/o Ap-Cf no hubiesen sido
considerados como mínimos). De otro lado, no es posible que con otro vértice Aq se
logre un costo menor pues de hecho se han analizado todos los Aj (que incluye a Aq) y
fue descartado como solución.
Investigación de Operaciones II 8
Algoritmo del Cartero
CAPITULO II
Primero debemos crear las clases que necesitaremos para la creación del
algoritmo, en la figura adjunta notamos que hemos creado la clase Main, en donde
definimos los arreglos que necesitaremos, además esta clase cuenta con métodos que
nos ayudarán a solucionar el algoritmo.
Investigación de Operaciones II 9
Algoritmo del Cartero
package cartero;
import java.io.*;
import java.util.*;
void solucion()
{ minimaRutaCosto();
verificandoValidez();
encontrandoNoBalanceado();
encontrandoFactibles();
while( mejoras() );
}
// agregar Trayectos
Main addArc(String eti, int u, int v, float costo)
{ if( !definido[u][v] ) etiqueta[u][v] = new Vector();
etiqueta[u][v].addElement(eti);
costoBasico += costo;
if( !definido[u][v] || c[u][v] > costo )
{ c[u][v] = costo;
etiquetaMinima[u][v] = eti;
definido[u][v] = true;
ruta[u][v] = v;
}
arcs[u][v]++;
delta[u]++;
Investigación de Operaciones II 10
Algoritmo del Cartero
delta[v]--;
return this;
}
//
void minimaRutaCosto()
{ for( int k = 0; k < N; k++ )
for( int i = 0; i < N; i++ )
if( definido[i][k] )
for( int j = 0; j < N; j++ )
if( definido[k][j]
&& (!definido[i][j] || c[i][j]
> c[i][k]+c[k][j]) )
{ ruta[i][j] = ruta[i][k];
c[i][j] = c[i][k]+c[k][j];
definido[i][j] = true;
if( i == j && c[i][j] < 0 )
return;
}
}
//Validando
void verificandoValidez()
{ for( int i = 0; i < N; i++ )
{ for( int j = 0; j < N; j++ )
if( !definido[i][j] ) throw new Error("El
grafico no es correcto");
if( c[i][i] < 0 ) throw new Error("El grafico tiene
ciclo negativo");
}
}
// Costo
float costo()
{ return costoBasico+phi();
}
float phi()
{ float phi = 0;
for( int i = 0; i < N; i++ )
for( int j = 0; j < N; j++ )
phi += c[i][j]*f[i][j];
return phi;
}
//Encontrando no balanceados
void encontrandoNoBalanceado()
{ int nn = 0, np = 0; // numero de nodo positivos y negativos
de los deltas
Investigación de Operaciones II 11
Algoritmo del Cartero
nn = np = 0;
for( int i = 0; i < N; i++ ) // inciando pasos
if( delta[i] < 0 ) neg[nn++] = i;
else if( delta[i] > 0 ) pos[np++] = i;
}
void encontrandoFactibles()
{
int delta[] = new int[N];
for( int i = 0; i < N; i++ )
delta[i] = this.delta[i];
// Haciendo Mejoras
boolean mejoras()
{ Main residual = new Main(N);
for( int u = 0; u < neg.length; u++ )
{ int i = neg[u];
for( int v = 0; v < pos.length; v++ )
{ int j = pos[v];
residual.addArc(null, i, j, c[i][j]);
if( f[i][j] != 0 ) residual.addArc(null, j, i,
-c[i][j]);
}
}
residual.minimaRutaCosto(); // encontrando un ciclo
negativo
for( int i = 0; i < N; i++ )
if( residual.c[i][i] < 0 ) // cancelando un ciclo o
alguno
{ int k = 0, u, v;
boolean kunset = true;
u = i; do // encontrando un k
{ v = residual.ruta[u][i];
if( residual.c[u][v] < 0 && (kunset || k
> f[v][u]) )
{ k = f[v][u];
kunset = false;
}
} while( (u = v) != i );
u = i; do // cancelando un ciclo de vida
{ v = residual.ruta[u][i];
if( residual.c[u][v] < 0 ) f[v][u] -= k;
else f[u][v] += k;
} while( (u = v) != i );
return true; //
}
return false; // no hay soluciones
Investigación de Operaciones II 12
Algoritmo del Cartero
// Imprimir
static final int NONE = -1; // alguno < 0
while( true )
{ int u = v;
if( (v = encontrandoRuta(u, f)) != NONE )
{ f[u][v]--; // removiendo las direcciones
for( int p; u != v; u = p ) // Rompiendo
{ p = ruta[u][v];
System.out.println("Tomando el arco
"+etiquetaMinima[u][p]
+" desde "+u+" a "+p);
}
}
else
{ int nodoPuente = ruta[u][verticeInicio];
if( arcs[u][nodoPuente] == 0 )
break; // hallar un arco
v = nodoPuente;
for( int i = 0; i < N; i++ ) // hallar un arco
usado
if( i != nodoPuente && arcs[u][i] > 0 )
{ v = i;
break;
}
arcs[u][v]--; // decrementando cuenta de arcos
paralelos
System.out.println("Tomando el arco
"+etiqueta[u][v].elementAt(arcs[u][v])
+" desde "+u+" a "+v); // uso de cada
etiqueta de arco
}
}
}
Investigación de Operaciones II 13
Algoritmo del Cartero
class IniciandoCartero
{ class Arc
{ String eti; int u, v; float costo;
Arc(String eti, int u, int v, float costo) // Definiendo
los Arcos
{ this.eti = eti; // etiqueta un String
this.u = u; // Nodo Inicial
this.v = v; // Nodo Final
this.costo = costo; // Costo del Arco
}
}
IniciandoCartero(int nodo)
{ N = nodo;
}
Investigación de Operaciones II 14
Algoritmo del Cartero
InputStreamReader isr=new
InputStreamReader(System.in);
//Creación del filtro para optimizar la lectura de datos
BufferedReader br=new BufferedReader(isr);
System.out.print("Introduce el Numero de Nodos: ");
//Lectura de datos mediante el método readLine()
String texto1=br.readLine();
//Conversión a int de la String anterior para poder sumar
int N=Integer.parseInt(texto1);
IniciandoCartero G = new IniciandoCartero(N);
/*
* G.addArc("a", 0, 1, 1).addArc("b", 0, 2,
1).addArc("c", 1, 2, 1)
.addArc("d", 1, 3, 1).addArc("e", 2, 3,
1).addArc("f", 3, 0, 1);
*/
/*
G.addArc("1", 0, 1, 1).addArc("2", 1, 2,
3).addArc("3",
2, 3, 1)
.addArc("4", 3, 4, 3).addArc("5", 4, 5, 4).addArc("6", 5,
2, 6)
.addArc("7", 4, 6, 6).addArc("8", 6, 7,
9).addArc("9",
7, 8, 4)
.addArc("10", 8, 9, 1).addArc("11", 9, 7,
5).addArc("12", 8, 1, 4)
.addArc("13", 9, 0, 2);
*/
Investigación de Operaciones II 15
Algoritmo del Cartero
int mejori = 0;
float mejorCosto = 0;
for( int i = 0; i < 4; i++ )
{ System.out.println("Solucion de "+i);
float c = G.imprimiendoCartero(i);
System.out.println("Costo = "+c);
if( i == 0 || c < mejorCosto )
{ mejorCosto = c;
mejori = i;
}
}
System.out.println("Iniciando....");
G.imprimiendoCartero(mejori);
System.out.println("El Menor Costo = "+mejorCosto+"" +
"\n=====================");
Investigación de Operaciones II 16
Algoritmo del Cartero
Introduce el Numero
de Nodos: 4
Introduce el Numero
de Arcos: 6
Arco: 0 Nodo
Inicio, Nodo Fin,
Costo:
0
1
1
0 1 1 Arco: 1 Nodo
Inicio, Nodo Fin, Costo:
0
2
1
0 2 1 Arco: 2 Nodo Inicio, Nodo Fin, Costo:
1
2
1
1 2 1 Arco: 3 Nodo Inicio, Nodo Fin, Costo:
1
3
1
1 3 1 Arco: 4 Nodo Inicio, Nodo Fin, Costo:
2
3
1
2 3 1 Arco: 5 Nodo Inicio, Nodo Fin, Costo:
3
0
1
3 0 1Solucion de 0
Iniciando el Algoritmo para 0 (ignoro el arco virtual)
Tomando el arco 'inicio virtual' desde 4 a 0
Tomando el arco 0 desde 0 a 1
Tomando el arco 3 desde 1 a 3
Tomando el arco 5 desde 3 a 0
Tomando el arco 0 desde 0 a 1
Tomando el arco 2 desde 1 a 2
Tomando el arco 4 desde 2 a 3
Tomando el arco 5 desde 3 a 0
Tomando el arco 1 desde 0 a 2
Tomando el arco 'fin virtual' desde 2 a 4
Costo = 8.0
Solucion de 1
Iniciando el Algoritmo para 1 (ignoro el arco virtual)
Tomando el arco 'inicio virtual' desde 4 a 1
Tomando el arco 3 desde 1 a 3
Investigación de Operaciones II 17
Algoritmo del Cartero
Investigación de Operaciones II 18
Algoritmo del Cartero
CAPITULO III
3 3
4
4
2 6
6 6
5
3
4
1 8 7
1
0
2 5
9
A
Investigación de Operaciones II 19
Algoritmo del Cartero
Solución:
3 3
4
4
2 6
6 6
5
3
4
1 8 7
1
0
2 5
9
A
Investigación de Operaciones II 20
Algoritmo del Cartero
3
1
2 3 1 Arco: 3 Nodo Inicio, Nodo Fin, Costo:
3
4
3
3 4 3 Arco: 4 Nodo Inicio, Nodo Fin, Costo:
4
5
4
4 5 4 Arco: 5 Nodo Inicio, Nodo Fin, Costo:
5
2
6
5 2 6 Arco: 6 Nodo Inicio, Nodo Fin, Costo:
4
6
6
4 6 6 Arco: 7 Nodo Inicio, Nodo Fin, Costo:
6
7
9
6 7 9 Arco: 8 Nodo Inicio, Nodo Fin, Costo:
7
8
4
7 8 4 Arco: 9 Nodo Inicio, Nodo Fin, Costo:
8
9
1
8 9 1 Arco: 10 Nodo Inicio, Nodo Fin, Costo:
9
7
5
9 7 5 Arco: 11 Nodo Inicio, Nodo Fin, Costo:
8
1
4
8 1 4 Arco: 12 Nodo Inicio, Nodo Fin, Costo:
9
0
2
9 0 2Solucion de 0
Iniciando el Algoritmo para 0 (ignoro el arco virtual)
Tomando el arco 'inicio virtual' desde 10 a 0
Tomando el arco 0 desde 0 a 1
Tomando el arco 1 desde 1 a 2
Tomando el arco 2 desde 2 a 3
Tomando el arco 3 desde 3 a 4
Tomando el arco 4 desde 4 a 5
Tomando el arco 5 desde 5 a 2
Tomando el arco 2 desde 2 a 3
Tomando el arco 3 desde 3 a 4
Tomando el arco 6 desde 4 a 6
Tomando el arco 7 desde 6 a 7
Tomando el arco 8 desde 7 a 8
Tomando el arco 9 desde 8 a 9
Tomando el arco 10 desde 9 a 7
Tomando el arco 8 desde 7 a 8
Tomando el arco 9 desde 8 a 9
Tomando el arco 12 desde 9 a 0
Investigación de Operaciones II 21
Algoritmo del Cartero
Investigación de Operaciones II 22
Algoritmo del Cartero
Investigación de Operaciones II 23
Algoritmo del Cartero
ANEXOS
Este diagrama muestra que existe otra alternativa para resolver el algoritmo del
cartero utilizando otros algoritmos, como el de Fleury, Edmonds, Diestra, Euler, etc.
Investigación de Operaciones II 24
Algoritmo del Cartero
BIBLIOGRAFIA
eneracion_recoleccion.pdf
• Técnicas heurísticas aplicadas al problema del problema del cartero, disponible en:
http://www.utp.edu.co/~planeamiento/prod_aca/articulos/Tecnicas_heuristicas_TSP
4.pdf
Investigación de Operaciones II 25