1 parte a

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

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


TuplaCaminos  caminoMinimoProbable(){
    //****************************************DECLARO VARIABLES *************************** ************************************************ PRIMERO ANALIZAMOS QUE HACE CADA UNA

        ArrayList<Barco> ret0 = new ArrayList<Barco>(); //lista de espejo 0
        ArrayList<Barco> ret1 = new ArrayList<Barco>(); //lista de espejo 1
        TuplaCaminos  ret = new TuplaCaminos();         //creo una tupla de caminos

        Integer _min = Integer.MAX_VALUE ;              //_min con un valor maximo int
        Integer _barcoOrigen = 0;                       //barco actual
        Integer _cantBarcos = 1;                        //contador de barcos


    //***********ACA ARRANCA*********************PRIMERO CON EL ESPEJO 0******************************************************************
        // barco mas cercano al espejo
        for (int i = 0; i< distanciaEspejo.length; i++){ //ciclo para buscar barco mas cercano a espejo 0
            if (distanciaEspejo[i][0] < _min){
                _min = distanciaEspejo[i][0];
                _barcoOrigen = i;
            }
        }

        int [] quemado = new int [barcos.length];       //lista de barcos quemados
        quemado[_barcoOrigen] = 1;                      //quemo primer barco
        ret0.add(barcos[_barcoOrigen]);                 //agrego a barco quemado a camino de espejo 0

        Barco _barcoMasCercana = barcos[_barcoOrigen]; //guardo el barco que quemé en otra variable


    //********************************AHORA COMIENZA CICLO************** AHORA LE TOCA A ESPEJO 1 ******************************************************************

        while (_cantBarcos < barcos.length ){   //comparo hasta q haya contado todos los barcos


    //*************************************PARTE DE CICLO PARA ESPEJO 1*******************************************************************
            _cantBarcos++;

    //incremento cada vez q paso por un espejo ATENCION! DUPLIQUE ESTA INSTRUCCION. DOS VECES EN EL WHILE PORQUE PASAN DOS ESPEJOS..
    //QUEMO DOS BARCOS... POR LO TANTO EL CONTADOR AUMENTA DOS VECES.

            _barcoMasCercana = barcoMasCercano(ret0.get(ret0.size()-1).id, quemado);  //LEER ABAJO

            /*                                 ¿¿¿¿QUE HICE?
              ACTUALIZO A "_barcoMasCercana" ( O SEA EL BARCO ACTUAL) CON EL BARCO MAS CERCANO,
              LLAMANDO A LA FUNCION "barcoMasCercano".

                                            ¿¿¿QUE LE INGRESO???
              EL BARCO QUE ACABÒ DE QUEMAR EL ESPEJO 1 ( ret0.get(ret0.size()-1).id ) QUE ESTÀ EN SU LISTA
              Y LA LISTA DE QUEMADOS
             */

            //                                  LISTO! TENGO EL NUEVO BARCO.

            quemado[_barcoMasCercana.id] = 1;    //lo quemo

            //                                AHORA LO AGREGO A LA LISTA DEL ESPEJO 1
            ret1.add(_barcoMasCercana);   //cambiè ret0.add(_barcoMasCercana)  por:  ret1.add(_barcoMasCercana)



            //                          ¿¿¿Y AHORA???? LE TOCA AL ESPEJO 0 OTRA VEZ



    //**********************************PARTE DEL CICLO PARA ESPEJO 0***************************************************

            _cantBarcos++;                     //incremento cada vez q paso por un espejo

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

                                                    //ACA CAMBIÈ ALGO

            // PRIMERO EXPLICO QUE HACE:  busco el basco mas cercano al barco actual con la funcion barco mas cercano
            //     le ingreso la id del ultimo barco que quemé con espejo cero y la lista de quemados
            //me devuelve el barco mas cercano al barco ingresado y que no esta quemado

            /*                          ¿¿¿¿QUE CAMBIE???
             *
             * CUANDO INGRESO EN LA FUNCION barcoMasCercano LA ID DEL ULTIMO BARCO QUE QUEMÉ Y LA LISTA DE QUEMADOS
            *  TENGO QUE INGRESAR LA ID DEL ULTIMO BARCO QUE QUEMÉ PERO... ¿¿CON QUE ESPEJO LO QUEME??
            *
            *                                           CON ESPEJO 1!!
            *
            *                 POR LO TANTO TENGO QUE INGRESAR LA LISTA DE BARCOS DE ESPEJO 1
            *
            *                 ASI LA FUNCION barcoMasCercano BUSCA EL BARCO MAS CERCANO DEL ULTIMO BARCO QUEMADO
            *
            *                 ENTONCES:
            *
            *                A _barcoMasCercana = barcoMasCercano(ret0.get(ret0.size()-1).id, quemado);
            *
            *                LO CAMBIO POR
            *
            *                _barcoMasCercana = barcoMasCercano(ret1.get(ret1.size()-1).id, quemado);
            */

            quemado[_barcoMasCercana.id] = 1;   //quemo el nuevo barco
            ret0.add(_barcoMasCercana);         //agrego el barco que queme a la lista del espejo

    //*********************************************************************************************************

        }
                                                //termina ciclo
        ret.setC1(ret0);                        //agrego camino a la tupla

        ret.setC2(ret1);        // UNA VEZ IMPLEMENTADO.  PUEDO AGREGAR LA LISTA DEL ESPEJO 1 AL OBJETO TUPLA

        //ANTES ESTABA ret.setC1(ret1);  y pasó a ret.setC2(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;

}



}