Example #1
0
  /**
   * Calcula el valor de <code>mu</code>.
   *
   * @param c Cliente.
   * @param dep Colección de depósitos.
   */
  private int calcularMu(ClienteCap2 c, Collection<Deposito> dep) {
    /*Deposito  masCercano=null;
    if(dep.size()>0)
    {
    	masCercano=dep.iterator().next();
    }
    else
    {
    	return 0;
    }
    int distanciaMasCercano=Integer.MAX_VALUE;
    Iterator<Deposito> it=dep.iterator();
    while(it.hasNext())
    {
    	Deposito n=it.next();
    	if(n.getCapacidadLibre()>=c.getNodo().getDemanda())
    	{
    		if(Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo())<distanciaMasCercano)
    		{
    			masCercano=n;
    			distanciaMasCercano=Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
    		}
    	}
    }

    int sumatoriaDistancias=0;
    Iterator<Deposito> it2=dep.iterator();
    while(it2.hasNext())
    {
    	Deposito n=it2.next();
    	if(n.getCapacidadLibre()>=c.getNodo().getDemanda())
    	{
    		if(n.getNodo().getId()!=masCercano.getNodo().getId())
    		{
    			sumatoriaDistancias=sumatoriaDistancias+Distancia.getInstancia().getDistancia(n.getNodo(),c.getNodo());
    		}
    	}
    }
    c.setMasCercano(masCercano);
    return sumatoriaDistancias-distanciaMasCercano;*/
    Deposito masCercano = null;

    int distanciaMasCercano = Integer.MAX_VALUE;
    Iterator<Deposito> it = dep.iterator();
    while (it.hasNext()) {
      Deposito n = it.next();
      if (n.getCapacidadLibre() >= c.getNodo().getDemanda()) {
        if (Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo()) < distanciaMasCercano) {
          masCercano = n;
          distanciaMasCercano = Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
        }
      }
    }

    if (masCercano != null) {
      int sumatoriaDistancias = 0;
      Iterator<Deposito> it2 = dep.iterator();
      while (it2.hasNext()) {
        Deposito n = it2.next();
        if (n.getCapacidadLibre() >= c.getNodo().getDemanda()) {
          if (n.getNodo().getId() != masCercano.getNodo().getId()) {
            sumatoriaDistancias =
                sumatoriaDistancias
                    + Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
          }
        }
      }
      c.setMasCercano(masCercano);
      return sumatoriaDistancias - distanciaMasCercano;
    } else {
      int distanciaMasCercano2 = Integer.MAX_VALUE;
      Iterator<Deposito> it2 = dep.iterator();
      while (it2.hasNext()) {
        Deposito n = it2.next();
        if (Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo())
            < distanciaMasCercano2) {
          masCercano = n;
          distanciaMasCercano2 = Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
        }
      }
      c.setMasCercano(masCercano);
      return 0;
    }
  }
Example #2
0
  /**
   * 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;
  }
Example #3
0
  /** Calcula los nodos que son enajendados. */
  private void calcularEnagenamiento() {
    Iterator<Deposito> itd1 = depositos.iterator();
    this.enajenados = new ArrayList<Enajenado>();
    while (itd1.hasNext()) {
      Deposito dep1 = itd1.next();
      Iterator<Cliente> itc1 = dep1.getAsignados().iterator();

      while (itc1.hasNext()) {
        Cliente clientebase = itc1.next();
        Iterator<Deposito> it4 = depositos.iterator();
        while (it4.hasNext()) {
          boolean encontre1 = false;
          boolean encontre2 = false;
          Deposito dep2 = it4.next();
          if (dep1.getNodo().getId() != dep2.getNodo().getId()) {

            Iterator<Cliente> it5 = dep2.getAsignados().iterator();
            while (it5.hasNext()) {
              Cliente cliente = it5.next();
              if (((ClienteCap2) clientebase).getClieteMasCercano1().getNodo().getId()
                  == cliente.getNodo().getId()) encontre1 = true;
              if (((ClienteCap2) clientebase).getClieteMasCercano2().getNodo().getId()
                  == cliente.getNodo().getId()) encontre2 = true;
            }
            if (encontre1 && encontre2) {
              this.enajenados.add(new Enajenado(((ClienteCap2) clientebase), dep1, dep2));
              break;
            }
          }
        }
      }
    }

    // limpio lista de enegenados por la distancia al deposito.
    int distCaC1, distCaC2, distDep;
    Iterator<Enajenado> itena = this.enajenados.iterator();
    ArrayList<Enajenado> asacar = new ArrayList<Enajenado>();
    while (itena.hasNext()) {
      Enajenado ena = itena.next();
      distCaC1 =
          Distancia.getInstancia()
              .getDistancia(
                  ena.getCliente().getClieteMasCercano1().getNodo(), ena.getCliente().getNodo());
      distCaC2 =
          Distancia.getInstancia()
              .getDistancia(
                  ena.getCliente().getClieteMasCercano2().getNodo(), ena.getCliente().getNodo());
      distDep =
          Distancia.getInstancia()
              .getDistancia(ena.getCliente().getNodo(), ena.getDeposito().getNodo());

      System.out.println(
          "Clientes mas cercanos a "
              + ena.getCliente().getNodo().getId()
              + " ( "
              + ena.getDeposito().getNodo().getId()
              + " ). c 1 y c2 "
              + ena.getCliente().getClieteMasCercano1().getNodo().getId()
              + " ,"
              + ena.getCliente().getClieteMasCercano2().getNodo().getId()
              + "("
              + ena.getDepositoDestino().getNodo().getId()
              + ")");

      if (distCaC1 + distCaC2 > distDep) asacar.add(ena); // this.enajenados.remove(ena);
      else ena.setMu(distDep - (distCaC1 + distCaC2));
    }
    Iterator<Enajenado> itsacar = asacar.iterator();
    while (itsacar.hasNext()) {
      this.enajenados.remove(itsacar.next());
    }
  }