codigo espejo

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
//int [] quemado; // recibe una lista con  barcos destruidos ;

private int n;

public Mapa(int tamano){
    n= tamano;
    barcos = new Barco [n];
    distancias = new int [n][n];
    distanciaEspejo = new int [n][2];
//  quemado = new int[n];
    for (int i=0; i<n; i++){
//      quemado[i] = 0;  // 0 =true
        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];
}



Integer barcoCercanoEspejo (int espejo ){
    Integer ret=0 ;
    Integer _min = Integer.MAX_VALUE ;

    for (int i = 0; i< distanciaEspejo.length; i++){
        if (distanciaEspejo[i][espejo] < _min){
            _min = distanciaEspejo[i][espejo];
            ret = i;
        }
    }

    return ret ;
}


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

    Integer _min = Integer.MAX_VALUE ;
    Integer _barcoOrigen = 0;
    Integer _cantBarcos = 1;



    // barco mas cercano al espejo
//  for (int i = 0; i< distanciaEspejo.length; i++){
//      if (distanciaEspejo[i][0] < _min){
//          _min = distanciaEspejo[i][0];
//          _barcoOrigen = i;
//      }
//  }

    _barcoOrigen = barcoCercanoEspejo( 0 );

    quemado[_barcoOrigen] = 1;  //ya pase barco origen
    ret0.add(barcos[_barcoOrigen]);
    //busca barco mas cercano , lo quema y lo añade a ret0

    // barco mas cercano al espejo1
//      for (int i = 0; i< distanciaEspejo.length; i++){
//          if (distanciaEspejo[i][1] < _min){
//              _min = distanciaEspejo[i][1];
//              _barcoOrigen = i;
//          }
//      }
//
//      quemado[_barcoOrigen] = 1;  //ya pase barco origen
//      ret1.add(barcos[_barcoOrigen]); -

    //--------------------------------------------


    Barco _barcoMasCercana = barcos[_barcoOrigen];

    while (_cantBarcos < barcos.length ){
        _cantBarcos++;

        _barcoMasCercana = barcoMasCercano(ret1.get(ret1.size()-1).id, quemado);
        quemado[_barcoMasCercana.id] = 1;
        ret1.add(_barcoMasCercana);


        _barcoMasCercana = barcoMasCercano(ret0.get(ret0.size()-1).id, quemado);
        quemado[_barcoMasCercana.id] = 1;
        ret0.add(_barcoMasCercana);



    }

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

    return ret;
}

private Barco barcoMasCercano(Integer barcoOrigen, int [] quemado){

    Integer distMin = Integer.MAX_VALUE;
    Integer barcoMin = Integer.MAX_VALUE;

    for (int i=0;i< quemado.length;i++){
        if (quemado[i] != 1){
            if (distancias[barcoOrigen][i] <distMin){
                distMin = distancias[barcoOrigen][i];
                barcoMin=i;
            }
        }
    }

    return barcos[barcoMin];

}



//para la 1er entretga asumimos un solo espejo

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;

}



}