/**
* El metodo se encarga de realizar la asignación Hibrida para depósitos con capacidad limitada
* (Algoritmo 1).
*
* <p>Recibe por parámetro <code>DTDepositoVRP</code> donde contiene toda la información del
* problema a resolver.
*
* <p>Retorna una colección de <code>DTAsignacion</code>. Cada <code>DTAsignacion</code> contiene
* un deposito y una colección de clientes que estan asignados al deposito.
*
* @param d <code>DTDepositoVRP</code> donde contiene toda la información del problema a resolver.
* @return Devuelve una colección de <code>DTAsignacion</code>..
*/
public Collection<DTAsignacion> asignar(DTDepositoVRP d) {
System.out.println("Asignar capacidad");
clientes = new ArrayList<ClienteCap2>();
depositos = new ArrayList<Deposito>();
enajenados = new ArrayList<Enajenado>();
Iterator<DTNodo> it = d.getNodos().iterator();
while (it.hasNext()) {
DTNodo dt = it.next();
if (dt.getEsDesposito()) {
Deposito dep = new Deposito(dt);
depositos.add(dep);
}
}
Iterator<DTNodo> it2 = d.getNodos().iterator();
while (it2.hasNext()) {
DTNodo dt = it2.next();
if (!dt.getEsDesposito()) {
ClienteCap2 cli = new ClienteCap2(dt);
cli.setMu(calcularMu(cli, depositos));
clientes.add(cli);
}
}
// Calculo los 2 clientes mas cercanos para cada cliente (precalculo para fase 2)
Iterator<ClienteCap2> it3 = this.clientes.iterator();
while (it3.hasNext()) {
ClienteCap2 cliente = it3.next();
cliente = addClientesMasCercanos(cliente);
System.out.println(
"Clientes mas cercanos"
+ cliente.getNodo().getId()
+ " y nodos "
+ cliente.getClieteMasCercano1().getNodo().getId()
+ " ,"
+ cliente.getClieteMasCercano2().getNodo().getId());
}
// Asigno los nodos por urgencia (fase 1).
while (clientes.size() > 0) {
TreeSet<ClienteCap2> tr = new TreeSet<ClienteCap2>(clientes);
Iterator<ClienteCap2> itc = tr.iterator();
ClienteCap2 proximo = itc.next();
proximo
.getMasCercano()
.agregarCliente(proximo); // agrego el cliente en el deposito mas cercano.
clientes.remove(proximo);
Iterator<ClienteCap2> itcli = clientes.iterator();
while (itcli.hasNext()) {
ClienteCap2 n = itcli.next();
n.setMu(calcularMu(n, depositos));
}
}
// agrego a lista si los 2 cliente + cercanos a cada cliente pertencen al mismo deposito
// deposito (que no es el mismo que el deposito asignado para el cliente).
// acaaaa
int capacidadvehiculo = Integer.valueOf(d.getCAPACITY());
System.out.println("cap del vehiculo " + capacidadvehiculo);
ArrayList<DTAsignacion> ar = null;
int costomenor = 0;
Iterator<Deposito> itdd = this.depositos.iterator();
while (itdd.hasNext()) {
Deposito dep = itdd.next();
DTAsignacion dta = new DTAsignacion(dep.getNodo());
Iterator<Cliente> itcli = dep.getAsignados().iterator();
while (itcli.hasNext()) {
Cliente cli = itcli.next();
dta.agregarCliente(cli.getNodo());
}
Iterator<DTRuteo> itrut =
Fabrica.getInstancia().getRuteo().rutear(dta, capacidadvehiculo).iterator();
while (itrut.hasNext()) {
DTRuteo next = itrut.next();
costomenor = costomenor + next.getCosto();
}
}
System.out.println("costo inicial " + costomenor);
int cantidadIteraciones = 0;
// Inicializo el Tiempo en Config
Config.getInstancia().empezarAlgoritmo(costomenor);
ArrayList<Integer> aux, tmp;
tmp = new ArrayList<Integer>();
boolean terminar = false;
while (!terminar) {
cantidadIteraciones++;
System.out.println("Cantidad Iteraciones " + cantidadIteraciones);
this.calcularEnagenamiento();
// Aplico todos los cambios de la lista de enajenados ....
aux = new ArrayList<Integer>();
Iterator<Enajenado> itena = this.enajenados.iterator();
while (itena.hasNext()) {
Enajenado ena = itena.next();
aux.add(ena.getCliente().getNodo().getId());
if (ena.getDepositoDestino().getCapacidadLibrePonderada()
>= ena.getCliente().getNodo().getDemanda()) {
Iterator<Deposito> respita = this.depositos.iterator();
while (respita.hasNext()) {
Deposito dep = respita.next();
Deposito nuevo = new Deposito(dep);
if (nuevo.getNodo().getId() == ena.getDeposito().getNodo().getId())
nuevo.sacarCliente(ena.getCliente());
if (nuevo.getNodo().getId() == ena.getDepositoDestino().getNodo().getId())
nuevo.agregarCliente(ena.getCliente());
DTAsignacion dta = new DTAsignacion(nuevo.getNodo());
Iterator<Cliente> itcli = nuevo.getAsignados().iterator();
while (itcli.hasNext()) {
Cliente cli = itcli.next();
dta.agregarCliente(cli.getNodo());
}
}
ena.getDeposito().sacarCliente(ena.getCliente());
ena.getDepositoDestino().agregarCliente(ena.getCliente());
}
}
boolean equalLists = ((aux.size() == tmp.size()) && (tmp.containsAll(aux)));
tmp = new ArrayList<Integer>();
tmp.addAll(aux);
if ((Config.getInstancia().terminarPorConfig(cantidadIteraciones, costomenor)) || equalLists)
terminar = true;
}
// construir DT de salida.
ar = new ArrayList<DTAsignacion>();
Iterator<Deposito> itd = depositos.iterator();
while (itd.hasNext()) {
Deposito dep = itd.next();
DTAsignacion dta = new DTAsignacion(dep.getNodo());
Iterator<Cliente> itcli = dep.getAsignados().iterator();
while (itcli.hasNext()) {
Cliente cli = itcli.next();
dta.agregarCliente(cli.getNodo());
}
ar.add(dta);
}
Penalization.getInstancia().getCalculoPenalidad(ar);
return ar;
}
/** Constructor por defecto. */
private UrgenciasCap2() {
// UrgenciasCap2 - Algoritmo = 0
Config.getInstancia().setAlgoritmo(Config.urgenciasCapRapido);
}
