codigoFernet

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];

    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>();
    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;
        }
    }

    int [] quemado = new int [barcos.length];
    quemado[_barcoOrigen] = 1;  //ya pase barco origen
    ret0.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.setC1(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;

}



}