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



}