jTPRA

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
ArrayList<Barco> quemado = new ArrayList<Barco>(); //recibo los barcos que voy a ir quemando
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 actual = null ;

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


    ret0.add(BarcoCercaPrimerEspejo(actual));
    ret1.add(BarcoCercaSegundoEspejo(actual));




//  int [] quemado = new int [barcos.length];
//  quemado[_barcoOrigen] = 1;  //ya pase barco origen
//  ret0.add(barcos[_barcoOrigen]);

    //ret1.add(barcoMasCercaEspejo2())

    Barco _barcoMasCercana = barcos[_barcoOrigen];

//  while (_cantBarcos < barcos.length ){
//      _cantBarcos++;
//
//      _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 BarcoCercaSegundoEspejo(Barco actual) {

    Barco cercano = null ;

    int distancia = 2^31-1 ;  //MAX_VALUE
    for (int i = 0; i< distanciaEspejo.length; i++){
        if (distanciaEspejo[i][1] < distancia){
            distancia = distanciaEspejo[i][1];
            cercano = barcos[i] ;
        }
    }
    quemado.add(cercano);
    return cercano;
}


private Barco BarcoCercaPrimerEspejo(Barco actual) {
    // TODO Auto-generated method stub

    Barco cercano = null ;

    int distancia = 2^31-1 ;  //MAX_VALUE
    for (int i = 0; i< distanciaEspejo.length; i++){
        if (distanciaEspejo[i][0] < distancia  && !quemado.contains(barcos[i])){
            distancia = distanciaEspejo[i][0];
            cercano = barcos[i] ;
        }
    }
    quemado.add(cercano);
    return cercano;
}


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;

}



}