Advertisement
LaCaraDeLaVerga

reparar barcoMasCercano

Apr 30th, 2016
165
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 5.04 KB | None | 0 0
  1. package recuperatorio;
  2.  
  3.  
  4. import java.util.ArrayList;
  5.  
  6. public class Mapa {
  7. private Barco [] barcos;
  8. private int [][] distancias;  // distancia de i a j
  9. private int [][] distanciaEspejo; // distancia del barco i al espejo j
  10. ArrayList<Barco> quemado = new ArrayList<Barco>(); //recibo los barcos que voy a ir quemando
  11. private int n;
  12.  
  13. public Mapa(int tamano){
  14.     n= tamano;
  15.     barcos = new Barco [n];
  16.     distancias = new int [n][n];
  17.     distanciaEspejo = new int [n][2];
  18.    
  19.    
  20.    
  21.    
  22.     for (int i=0; i<n; i++){
  23.         barcos [i] = new Barco(i,"Barco" + i);
  24.         distanciaEspejo[i][0] = 0;
  25.         distanciaEspejo[i][1] = 0;
  26.         for (int j=0; j<n; j++){
  27.             distancias[i][j] = 0;   //distancias default en 0
  28.    
  29.         }
  30.     }
  31.    
  32. }
  33.  
  34.  
  35. public int tamano(){
  36.     return n;
  37. }
  38.  
  39.  
  40. public void asignarNombre(Integer ciudadID, String nombre){
  41.     barcos[ciudadID].Nombre = nombre;
  42. }
  43.  
  44. public void setDistIJ(int i, int j, int dist, boolean simetrico){
  45.     distancias[i][j] = dist;
  46.    
  47.     if (simetrico){
  48.         distancias[j][i] = dist;
  49.     }
  50. }
  51.  
  52. public void setDistEsp(int i, int dist, int espejo){
  53.     distanciaEspejo[i][espejo] = dist;
  54.  
  55. }
  56.  
  57. // distancias nominales
  58. public int getDistIJ(int i, int j){ // si es adyacente tomamos ady[i][j]
  59. return distancias[i][j];
  60. }
  61.  
  62.  
  63.  
  64. //para la 1er entretga asumimos un solo espejo
  65. TuplaCaminos  caminoMinimoProbable(){
  66.     ArrayList<Barco> ret0 = new ArrayList<Barco>();
  67.     ArrayList<Barco> ret1 = new ArrayList<Barco>();
  68.     TuplaCaminos  ret = new TuplaCaminos();
  69.  
  70.     Integer _barcoOrigen = 0;
  71.     int _cantBarcos = 2;
  72.     Barco actual = null ;
  73.     Barco actual01 = null ;
  74.  
  75. //     barco mas cercano al espejo 0 ;
  76.     ret0.add(BarcoCercaPrimerEspejo());
  77.    
  78. //  barco mas cercano al espejo 1 ;    
  79.     ret1.add(BarcoCercaSegundoEspejo(actual01));
  80.    
  81.    
  82.    // Barco _barcoMasCercana = barcos[_barcoOrigen];
  83.    
  84.   while (_cantBarcos < barcos.length ){  
  85.       _cantBarcos= _cantBarcos+2; // porque durante el ciclo pasa por 2 barcos
  86.      
  87.     // _barcoMasCercana = barcoMasCercano(ret0.get(ret0.size()-1).id, quemado);
  88.    //   private Barco barcoMasCercano(Barco barcoOrigen, ArrayList<Barco> quemado) {
  89.   barcoMasCercano (actual);
  90.   barcoMasCercano (actual01);
  91.  
  92.   }
  93.     ret.setC1(ret0);
  94.     ret.setC2(ret1);      //implementar ret1
  95.    
  96.     return ret;
  97. }
  98.  
  99. //01010101010101010001010101010101010101010100110011010010101010101010101010101010100101010101010101
  100. private Barco BarcoCercaPrimerEspejo() {
  101.     Barco cercano = null ;
  102.    
  103.     int distancia = 2^31-1 ;  //MAX_VALUE
  104.     for (int i = 0; i< distanciaEspejo.length; i++){
  105.         if (distanciaEspejo[i][0] < distancia ){
  106.             distancia = distanciaEspejo[i][0];
  107.             cercano = barcos[i] ;
  108.         }
  109.     }
  110.     quemado.add(cercano);
  111.     return cercano;
  112. }
  113. //01010101010101010001010101010101010101010100110011010010101010101010101010101010100101010101010101
  114. private Barco BarcoCercaSegundoEspejo(Barco actual01) {
  115.  
  116.     Barco cercano = actual01 ;
  117.    
  118.     int distancia = 2^31-1 ;  //MAX_VALUE
  119.     for (int i = 0; i< distanciaEspejo.length; i++){
  120.         if (distanciaEspejo[i][1] < distancia  && !quemado.contains(barcos[i])){
  121.             distancia = distanciaEspejo[i][1];
  122.             cercano = barcos[i] ;
  123.         }
  124.     }
  125.     quemado.add(cercano);
  126.     return cercano;
  127. }
  128.  
  129. //01010101010101010001010101010101010101010100110011010010101010101010101010101010100101010101010101
  130.  
  131. private Barco barcoMasCercano(Barco actual) {
  132.     int distancia =  2^31-1 ;  //MAX_VALUE
  133.     Barco masCercano = null;
  134.     Integer distMin = Integer.MAX_VALUE;
  135.     Integer barcoMin = Integer.MAX_VALUE;
  136.    
  137.    
  138.     for (int i = 0; i < tamano(); i++) {
  139.         if ((!quemado.contains (barcos[i])) ) {
  140. //            if (getDistIJ(actual, barcos[i].id) <= distancia) {
  141. //                distancia = getDistIJ(actual.id, barcos[i].id);
  142. //                masCercano = barcos[i];
  143.          
  144.                 if (distancias[actual][i] <distMin){
  145.                     distMin = distancias[actual][i];
  146.                     barcoMin=i;
  147.                 }
  148.            
  149.             }
  150.         }
  151.  
  152.     quemado.add(masCercano);
  153.     return masCercano;
  154. }
  155.  
  156. //para la 1er entretga asumimos un solo espejo
  157.  
  158.  
  159. private Barco barcoMasCercano(Integer barcoOrigen, int [] quemado){
  160.  
  161.    Integer distMin = Integer.MAX_VALUE;
  162.    Integer barcoMin = Integer.MAX_VALUE;
  163.  
  164.    for (int i=0;i< quemado.length;i++){  
  165.        if (quemado[i] != 1){
  166.            if (distancias[barcoOrigen][i] <distMin){
  167.                distMin = distancias[barcoOrigen][i];
  168.                barcoMin=i;
  169.            }
  170.        }
  171.    }
  172.  
  173.    return barcos[barcoMin];
  174.  
  175. }
  176.  
  177.  
  178.  
  179. Integer  distancia(ArrayList<Barco> camino){
  180.  
  181.     Integer _distancia = 0;
  182.  
  183.     if (camino.size() > 0){
  184.         _distancia = distanciaEspejo[camino.get(0).id][0];
  185.     }
  186.    
  187.            
  188.     for (int i=0;i< camino.size()-1;i++){
  189.         _distancia = _distancia + distancias[camino.get(i).id][camino.get(i+1).id];
  190.     }
  191.  
  192.     return _distancia;
  193.    
  194. }
  195.  
  196.  
  197.  
  198. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement