estrategia b jere tp 1a parte B

package recuperatorio;


import java.util.ArrayList;

public class Mapa {
private Barco [] barcos;
private int [][] distancias;  // distancia de i a j
private int [][] distanciaEspejo; // distancia del barco i al espejo j

private int n;

public Mapa(int tamano){
    n= tamano;
    barcos = new Barco [n];
    distancias = new int [n][n];
    distanciaEspejo = new int [n][2];
    ArrayList<Barco> listaQuemados = new ArrayList<Barco>();



    for (int i=0; i<n; i++){
        barcos [i] = new Barco(i,"Barco" + i);
        distanciaEspejo[i][0] = 0;
        distanciaEspejo[i][1] = 0;
        for (int j=0; j<n; j++){
            distancias[i][j] = 0;   //distancias default en 0

        }
    }

}


public int tamano(){
    return n;
}


public void asignarNombre(Integer ciudadID, String nombre){
    barcos[ciudadID].Nombre = nombre;
}

public void setDistIJ(int i, int j, int dist, boolean simetrico){
    distancias[i][j] = dist;

    if (simetrico){
        distancias[j][i] = dist;
    }
}

public void setDistEsp(int i, int dist, int espejo){
    distanciaEspejo[i][espejo] = dist;

}

// distancias nominales
public int getDistIJ(int i, int j){ // si es adyacente tomamos ady[i][j]
return distancias[i][j];
}


//para la 1er entretga asumimos un solo espejo
TuplaCaminos  caminoMinimoProbable(){
  ArrayList<Barco> ret0 = new ArrayList<Barco>();
  ArrayList<Barco> ret1 = new ArrayList<Barco>();

  ArrayList<Barco> listaQuemados = new ArrayList<Barco>();// es donde voy a agregar los barcos que va quemando


  TuplaCaminos  ret = new TuplaCaminos();

  Integer _min = Integer.MAX_VALUE ;
  Integer _barcoOrigen = 0;
  Integer _cantBarcos = 1;
  Barco cercano1 = null ;
  Barco cercano = null ;
  Barco actual = null ;
  Barco actual1 = null ;
  int contador = barcos.length-3 ;
  // agrego el primer barco al primer camino y lo quemo

      int distancia = 2^31-1 ;  //MAX_VALUE
      for (int i = 0; i< distanciaEspejo.length; i++){
          if (distanciaEspejo[i][0] < distancia ){
              distancia = distanciaEspejo[i][0];
              cercano = barcos[i] ;
          }
      }
      ret0.add(cercano) ;  // lo pongo en ret0 (ret0 + ret1 forman la tupla ret )

      listaQuemados.add(cercano); // marco que esta quemado
     // System.out.println(" primero agrego en lista0   " + cercano.Nombre);
   // agrego el primer barco al segundo camino y lo quemo


      int distancia1 = 2^31-1 ;  //MAX_VALUE
      for (int i = 0; i< distanciaEspejo.length; i++){
          if (distanciaEspejo[i][1] < distancia1 && !listaQuemados.contains(barcos[i]) ){
              distancia1 = distanciaEspejo[i][1];
              cercano1 = barcos[i] ;
          }
      }
      ret1.add(cercano1) ;
      listaQuemados.add(cercano1);



     /*  HASTA ACA EL CODIGO ANDA DE FORMA PERFECTA */


//0000000000000000000000000101010101111111111111111110101010110110010101101101101011011001110110111110001011010110110110gato110
// while (contador!=0 ){
    actual = barcoCercanoEspejo(cercano,listaQuemados);
    ret0.add(actual);
    listaQuemados.add(actual);


      actual = barcoMasCercano(cercano , listaQuemados);
      ret0.add(actual);
      listaQuemados.add(actual);


      contador--;

//      if (contador == 0){
//          break;
//      }
//-------------------------------------------------------------------------------------------------------
      actual1 = barcoCercanoEspejo1(cercano1 , listaQuemados);
      ret1.add(actual1);
      listaQuemados.add(actual1);
      actual1 = cercano1 ;

      contador--;

//      if (contador == 0){
//          break;
//      }
//   }

  ret.setC1(ret0);
  ret.setC2(ret1);        //implementar ret1

  return ret;




}
private Barco barcoCercanoEspejo1(Barco cercano1, ArrayList<Barco> listaQuemados) {
    // TODO Auto-generated method stub
    int distancia1 = 2^31-1 ;  //MAX_VALUE
        for (int i = 0; i< distanciaEspejo.length; i++){
            if (distanciaEspejo[i][1] < distancia1 && !listaQuemados.contains(barcos[i]) ){
                distancia1 = distanciaEspejo[i][1];
                cercano1 = barcos[i] ;
            }
        }
    return cercano1;
}




private Barco barcoCercanoEspejo(Barco cercano, ArrayList<Barco> listaQuemados) {
    // TODO Auto-generated method stub
    int distancia1 = 2^31-1 ;  //MAX_VALUE
    Barco cercano1=null;
    for (int i = 0; i< distanciaEspejo.length; i++){
        if (distanciaEspejo[i][1] < distancia1 && !listaQuemados.contains(barcos[i]) ){
            distancia1 = distanciaEspejo[i][1];
            cercano1 = barcos[i] ;
        }
    }
    return cercano1;
}


private Barco barcoMasCercano(Barco barcoOrigen, ArrayList<Barco> listaQuemados) {
  int distancia = 2^31-1 ;  //MAX_VALUE
  Barco masCercano = null;
  for (int i = 0; i < tamano(); i++) {
      if (!listaQuemados.contains(barcos[i])) {
          if (getDistIJ(barcoOrigen.id, barcos[i].id) <= distancia) {
              distancia = getDistIJ(barcoOrigen.id, barcos[i].id);
              masCercano = barcos[i];
          }
      }
  }

  return masCercano;
}






Integer  distancia(ArrayList<Barco> camino){

  Integer _distancia = 0;

  if (camino.size() > 0){
      _distancia = distanciaEspejo[camino.get(0).id][0];
  }

  for (int i=0;i< camino.size()-1;i++){
   _distancia = _distancia + distancias[camino.get(i).id][camino.get(i+1).id];
  }
  return _distancia;

}



}