SoloCodigo

esto tengo en codigo

nose como empezarlo para q se explique bien el codigo
public static final int agua = -1;
public static final int libre = 1;
public static final int fueraPantano = -2;
public static final int enteroMaximo = 999999;
public static final int energia[][] = { { 7, 6, 5, 6, 7 },
                                         
               { 6, 3, 2, 3, 6 }, { 5, 2, 0, 2, 5 }, { 6, 3, 2, 3, 6 },
               { 7, 6, 5, 6, 7 } };
     public static void main(String[] args) {
          int c = 0, r = 0, cs = 0, rs = 0, ct = 0, rt = 0, b;
          int c1, r1, c2, r2;
          int i, j, k;
          int[][] pantano = null;
          int[][] costo = null;
          Scanner in = new Scanner(System.in);
          // leer las dimensiones del pantano
          c = in.nextInt();
          r = in.nextInt();
          while (c > 0) {
               // crear el pantano y matriz de costos
               pantano = new int[r + 4][c + 4];
               costo = new int[r + 4][c + 4];
               // indicar que la fila 0 y columa 0
               // estan fuera del pantano
               for (i = 0; i < c + 4; i++)
                   pantano[0] = pantano[1] = fueraPantano;
               for (i = 0; i < r + 4; i++)
                   pantano[0] = pantano[1] = fueraPantano;
               for (i = 2; i < c + 4; i++)
                   pantano[r + 2] = pantano[r + 3] = fueraPantano;
               for (i = 2; i < r + 4; i++)
                   pantano[c + 2] = pantano[c + 3] = fueraPantano;
               // Marcar las celdas del pantano como libres
               // y los costos como un entero grande
               for (i = 2; i < r + 2; i++) {
                   for (j = 2; j < c + 2; j++) {
                       pantano[j] = libre;
                       costo[j] = enteroMaximo;
                   }
               }
               // leer el origen y el destino
               cs = in.nextInt();
               rs = in.nextInt();
               ct = in.nextInt();
               rt = in.nextInt();
               // leer el numero de zonas acuosas
               b = in.nextInt();
               for (i = 0; i < b; i++) {
                    // leer las cordenadas de la region
                    c1 = in.nextInt();
                    r1 = in.nextInt();
                    c2 = in.nextInt();
                    r2 = in.nextInt();
                    c1 += 1;
                    c2 += 1;
                    r1 += 1;
                    r2 += 1;
                    for (k = r1; k <= r2; k++) {
                        for (j = c1; j <= c2; j++) {
                             pantano[k][j] = agua;
                        }
                    }
               }
               cs++;
               rs++;
               ct++;
               rt++;
               // ver(pantano,r, c);
               // ver(costo,r, c);
               dijkstra(pantano, costo, rs, cs, rt, ct);
               if (costo[rt][ct] < enteroMaximo)
                    System.out.println(costo[rt][ct]);
               else
                    System.out.println("Impossible");
               c = in.nextInt();
               r = in.nextInt();
          }
     }
}
  public static void dijkstra(
       int[][] pantano, int[][] costo,
       int rs, int cs,int rt, int ct) {
    int rv, cv;
    int i, j;
    Nodo filcol;
    PriorityQueue<Nodo> cp = new PriorityQueue<Nodo>();
    costo[rs][cs] = 0;
    rv = rs;
    cv = cs;
    cp.add(new Nodo(0, rs, cs));
    while (!cp.isEmpty()) {
        filcol = cp.remove();
        rv = filcol.fila;
        cv = filcol.col;
        for (i = -2; i < 3; i++) {
             for (j = -2; j < 3; j++) {
                 if (pantano[rv + i][cv + j] == libre) {
                     if (costo[rv + i][cv + j] >
                       (costo[rv][cv] + energia[i + 2][j + 2])) {
                         costo[rv + i][cv + j] = costo[rv][cv]
                                 + energia[i + 2][j + 2];
                         cp.add(new Nodo(costo[rv + i][cv + j],
                                         rv + i, cv + j));
                     }
                 }
             }
        }
    }
}
      PriorityQueue<Nodo> cp = new PriorityQueue<Nodo>();
   La clase nodo se deni como sigue:
                         o
class Nodo implements Comparable<Nodo> {
    int costo, fila, col;

  public Nodo(int costo, int fila, int col) {
      this.costo = costo;
      this.fila = fila;
      this.col = col;
  }
  public int compareTo(Nodo other) {
      return costo - other.costo;
  }
}

este es lo queme piden
y lo que te puse es el codigo
 que aun no puedo arreglarlos para dejarlo mas entendible
    El Sr. Frog vive en un pantano rectangular, compuesto por celdas todas del mismo tama ̃o, algunas secas,
                                                                                               n
otras llenas de agua. El Sr. Frog vive en una celda seca, y s ́lo puede saltar desde una celda seca a otra seca
                                                                o
en sus paseos por el pantano.
    El Sr. Frog quiere visitar a su novia, la Sra. Toad, que tambi ́n vive en una celda seca, en el mismo
                                                                        e
pantano. Pero el Sr. Frog es flojo, y quiere gastar la menor cantidad de energ ́ en sus saltos hasta llegar a
                                                                                   ıa
la casa de su novia. El Sr. Frog sabe cu ́nta energ ́ gasta en cada uno de sus saltos. Para cualquier salto,
                                           a           ıa
el Sr. Frog siempre usa la siguiente figura para determinar cu ́les son las celdas objetivo a las que puede
                                                                    a
llegar desde su posici ́n actual (marcada con la letra F ), y el correspondiente costo energ ́tico, en calor ́
                       o                                                                       e                 ıas.
Cualquier otra celda es inalcanzable para el Sr. Frog desde su posici ́n actual, en un unico salto.
                                                                          o                ́
                                                 7   6    5   6   7
                                                 6   3    2   3   6
                                                 5   2    F   2   5
                                                 6   3    2   3   6
                                                 7   6    5   6   7
    Su trabajo es determinar la menor cantidad de energ ́ que el Sr. Frog necesita para viajar desde su casa,
                                                            ıa
hasta la casa de su novia.
Entrada
    La entrada contiene varios casos de prueba. La primera l ́    ınea de un caso de prubea contiene dos enteros,
C y F , indicando respectivamente la cantidad de columnas y filas en el pantano (1 ≤ C, F ≤ 1000). La
segunda l ́ ınea de un caso de prueba contiene cuatro enteros Cf , Ff , Ct y Ft , donde (Cf , Ff ) especifica la
ubicaci ́n de la casa del Sr. Frog, y (Ct , Ft ) especifica la ubicaci ́n de la casa de la Sra. Toad (1 ≤ Cf , Ct ≤
        o                                                            o
C y 1 ≤ Ff , Ft ≤ F ).
                ınea de un caso de prueba contiene un unico n ́mero entero W (0 ≤ W ≤ 1000), indicando la
    La tercera l ́                                          ́       u
cantidad de pozos de agua en el pantano. Cada una de las siguientes W l ́     ıneas contiene 4 enteros, C1 , F1 , C2 ,
y F2 (1 ≤ C1 ≤ C2 ≤ C y 1 ≤ F1 ≤ F2 ≤ F ) describiendo un pozo de agua rectangular, formado por todas
las celdas (x, y) tal que C1 ≤ x ≤ C2 y F1 ≤ y ≤ F2 .
    El fin de la entrada se indica con el par 0 0.
    Un ejemplo de entrada es la siguiente:
4  4
1  1 4 2
2
2  1 3 3
4  3 4 4
4  4
1  1 4 2
1
2  1 3 4
7  6
4  2 7 6
5
4  1 7 1
5  1 5 5
2  4 3 4
7  5 7 5
6  6 6 6
0  0
    Estos datos deben ser le ́  ıdos desde la entrada est ́ndar, sin men ́ es ni opciones.
                                                            a                u
Salida
    Para cada caso de prueba de la entrada, su programa debe producir una l ́   ınea de salida, conteniendo la
menor cantidad de calor ́ consumidas por el Sr. Frog para viajar desde su casa, a la casa de la Sra. Toad.
                         ıas
Si no es posible para el Sr. Toad ir a visitar a la Sra. Toad, su programa debe imprimir “impossible”
    Para la entrada de ejemplo, la salida debiera ser:
14
impossible
12