Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Representar una carretera de 4 carriles con una matriz de 4 filas por n columnas

Java - Representar una carretera de 4 carriles con una matriz de 4 filas por n columnas

Volver
Nuevo Tema
<<>>
 
Vista:

Representar una carretera de 4 carriles con una matriz de 4 filas por n columnas

Publicado por Mar (1 intervención) el 03/06/2020 02:40:33
Representaremos una carretera de 4 carriles con una matriz de 4 filas por n columnas. Las posiciones dónde exista un auto tendrán un carácter * y las posiciones libres tendrán un carácter de espacio. El viaje se lo realizará en auto, éste puede moverse, después de algunas maniobras, a cualquiera de las 8 posiciones adyacentes, siempre y cuando estén libres. El objetivo es recorrer la carretera de izquierda (columna 0) a derecha (columna n-1).

Se quiere saber si es posible LLEGAR AL FINAL DE LA CARRETERA O NO.
Considera, que el auto siempre empezará desde la posición [0, 0], la cuál será una posición sin obstáculo.

la matriz se representa de esta manera:
{' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', ' '},
{'*', '*', ' ', '*', '*', '*', ' ', ' ', '*', ' '},
{'*', ' ', '*', '*', ' ', ' ', '*', ' ', '*', ' '},
{' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Representar una carretera de 4 carriles con una matriz de 4 filas por n columnas

Publicado por Kabuto (1381 intervenciones) el 04/06/2020 21:13:23
Esto puede ser más complicado de lo que parece.

Primero hay que entender bien como "moverse" por una matriz. Si la consideramos como una tabla, que tiene Filas y Columnas, es más sencillo entender como moverse.
Cada casilla de la tabla/matriz está señalada por dos punteros para indicar su posicion, el de la fila y la columna --> matriz[fila][columna]

Podemos movernos en 8 direcciones: Norte (Arriba), Sur (Abajo), Oeste(izquierda), Este(Derecha), y sus combinaciones: NorEste, Sureste, NorOeste y SurOeste.

Bien, las Filas van de 0 a n. La fila más al norte, (más arriba) es la 0 y la más al sur es la n.
Así que moverse al Norte, hacia arriba, será decrementar Fila

Si estoy en la fila 5, y quiero subir, tengo que ir a la 4, luego a la 3, a la 2, la 1.. hasta la 0 que es el máximo que pudo subir. Estoy al Norte del todo

Si quiero bajar, es decir, ir al Sur, tengo que incrementar la Fila. Irme a la 6, la 7, la 8... hasta la N que sería la última abajo de todo.

Es decir, alterando el valor del puntero de la fila, subo y bajo, voy al norte y voy al sur.

Del mismo modo, alterando el de la columna, me muevo de izquierda a derecha, de Oeste a Este.

Alternado los dos valores, me muevo en las otras 4 direcciones, arriba-derecha (NorEste), abajo-izquierda(SurOeste), etc...


Bien, nuestro "Coche Virtual" tiene que moverse de este modo por la Carretera, que es en realidad una matriz/tabla.

Y para poder movernos, necesitaremos dos variables en nuestro programa, para controlar en que fila y columna se encuentra nuestro Coche en cada momento y averiguar en cuál de las 8 direcciones posibles puede moverse.

Para movernos, antes de hacer el movimiento, hay que comprobar donde hay espacio libre para moverse.
Para hacer esto en el programa, se me ocurre escribir 8 métodos de tipo boolean, cada uno para intentar moverse en una de las 8 direcciones.
Estos métodos intentarán mover el coche cada uno por su cuenta, y si es posible, lo harán y retornarán TRUE, de modo que el resto de métodos ya no intentarán movimiento.

Si todos fracasan, es que el coche está atascado y ya no puede moverse

Estos métodos han de comprobar si hay espacio libre, pero también han de comprobar que no se han salido fuera de la matriz/carretera. Esto produce una excepción en la ejecución del programa, que podemos controlar con TRY ..CATCH... y evitar que el programa se rompa.

Tras cada movimiento, se comprueba si se ha llegado al destino, es decir, a la derecha del todo de alguno de los carriles de la carretera.


Dicho así parece sencillo, pero no lo es tanto. Para empezar, hay que decidir que movimientos tendrán prioridad.
Puesto que queremos ir a la derecha, el primer intento de movimiento sería al Este --> E.
Si no es posible, probamos con el NorEste--> NE y luego con SE
Si estos fallan, intentamos Norte --> N y Sur --> S
Si también fallan, significa que hay que volver hacia atrás, al Oeste -> O , así que los movimientos al O serán los últimos en intentarse.

Este podría ser el código del programa.
Hay muchas líneas pero es porque hay un método por cada dirección de movimiento, pero en realidad es todo muy sencillo.
He puesto que en cada movimiento se muestre la matriz/carretera y uso el carácter 'C' para representar el coche y ver donde está en cada momento.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
public class Carreteras {
 
	private static char[][] carretera;
	private static int fila;
	private static int col;
 
	private static Scanner teclado = new Scanner(System.in); //Solo lo usaremos para pausar el bucle
 
	public static void main(String[] args) {
 
		//Creamos la carretera
		carretera = new char[][]{
			{' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', ' '},
			{'*', '*', ' ', '*', '*', '*', ' ', ' ', '*', ' '},
			{'*', ' ', '*', '*', ' ', ' ', '*', ' ', '*', ' '},
			{' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'}
			};
 
		//Inicializamos Posicion
		fila = 0; col = 0;
 
		//Colocamos coche en carretera. Representamos con una 'C'
		carretera[fila][col] = 'C';
		//Mostramos carretera
		mostrarCarretera();
 
		boolean fin = false; //Para controlar cuando se da por finalizado
		while (!fin) {
 
			if (moverCoche()) {
				//Hemos podido desplazarnos, comprobamos si hemos llegado a destino
				if (col == carretera[0].length - 1) {
					System.out.println("\n!!Destino alcanzado");
					fin = true;
				}
			}
			else { //Coche no se puede mover en ninguna direccion
				System.out.println("Coche atascado. Imposible llegar a Destino");
				fin = true;
			}
 
			mostrarCarretera();
		}
 
 
		System.out.println("\n\t\t--FIN DE PROGRAMA--");
	}
 
	/**
	 * Muestra en pantalla la Carretera con la posicion actual del Coche
	 */
	private static void mostrarCarretera() {
		System.out.println();
		for (int j = 0; j < carretera.length; j++)
			System.out.println(Arrays.toString(carretera[j]));
		System.out.println();
		System.out.println("\nPulse ENTER para continuar...\n");
		teclado.nextLine();
	}
 
	/**
	 * Intentará mover el coche en una de las 8 posibles direcciones.
	 * Informará de si ha podido moverse o no.
	 * @return True si pudo moverse, False si no pudo.
	 */
	private static boolean moverCoche() {
		//Si alguno de estos métodos tiene éxito, devolverá TRUE.
		return moverE() || moverNE() || moverSE() || moverN()
				|| moverS() || moverO() || moverNO() || moverSO();
		//Si todos fracasan, devolverá FALSE.
	}
 
	/**
	 * Intenta el desplazamiento hacia el Este
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverE() {
		//Mover al Este implica incrementar la Columna -> col++
		try {
			//Antes de mover, comprobamos si hay espacio libre al Este
			if (carretera[fila][col + 1] == ' ') {
				//Sí, esta libre
				carretera[fila][col] = ' '; //Dejamos libre posicion actual
				col++; //Movemos
				carretera[fila][col] = 'C'; //Colocamos Coche en nueva posicion
				return true;
			}
			else //No hay espacio libre
				return false;
 
		}catch(Exception e) {
			return false; //Nos hemos salido de la carretera/matriz
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el NorEste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverNE() {
		//Mover al NE implica decrementar la Fila e incrementar la Columna
		try {
			if (carretera[fila - 1][col + 1] == ' ') {
				carretera[fila][col] = ' ';
				fila--;
				col++;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el SurEste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverSE() {
		//Mover al SE implica incrementar la Fila y la Columna
		try {
			if (carretera[fila + 1][col + 1] == ' ') {
				carretera[fila][col] = ' ';
				fila++;
				col++;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el Norte
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverN() {
		//Mover al N implica decrementar la Fila
		try {
			if (carretera[fila - 1][col] == ' ') {
				carretera[fila][col] = ' ';
				fila--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el Sur
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverS() {
		//Mover al N implica incrementar la Fila
		try {
			if (carretera[fila + 1][col] == ' ') {
				carretera[fila][col] = ' ';
				fila++;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el Oeste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverO() {
		//Mover al Oeste implica decrementar la Columna
		try {
			if (carretera[fila][col - 1] == ' ') {
				carretera[fila][col] = ' ';
				col--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el NorOeste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverNO() {
		//Mover al NO implica decrementar Fila y Columna
		try {
			if (carretera[fila - 1][col - 1] == ' ') {
				carretera[fila][col] = ' ';
				fila--;
				col--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el SurOeste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverSO() {
		//Mover al SO implica incrementar la Fila y decrementar la Columna
		try {
			if (carretera[fila + 1][col - 1] == ' ') {
				carretera[fila][col] = ' ';
				fila++;
				col--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
}

Al ejecutarlo, podemos ver por qué no es tan sencillo como parece.
El coche se queda atascado a los pocos movimientos yendo de Este a Oeste infinitamente. Y hay que cortar el programa por las bravas porque no terminaría nunca:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
[C,  , *,  ,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ , C, *,  ,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *,  ,  , *,  ,  , *,  ]
[*, *, C, *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *, C,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *,  , C, *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *, C,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *,  , C, *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *, C,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *,  , C, *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *, C,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]

¿Cuál es el problema?
El Coche intenta la misma ruta una y otra vez, sin ser saber que esa ruta es un callejón sin salida.

¿Cómo solucionarlo?...
Pues no lo se...

He intentado un sistema donde guardo las posiciones "rechazadas". Es decir, cuando el coche tiene que ir hacia el Oeste, o sea, hacia atrás, es porque la posición actual es un callejón sin salida, así que la guardo para que el coche no vuelva a intentar ir por esa posición.
Estas posiciones las guardo en un ArrayList y antes de mover en una dirección, compruebo si esa dirección me lleva a una posición guardada en este ArrayList. Lo cuál indica que es rechazada y ya no intento el movimiento.
Marco en negrita los cambios en el codigo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
public class Carreteras {
 
	private static char[][] carretera;
	private static int fila;
	private static int col;
	private static ArrayList<Integer[]> rutasRechazadas; //Posiciones que no queremos volver a estar
 
	private static Scanner teclado = new Scanner(System.in); //Solo lo usaremos para pausar el bucle
 
	public static void main(String[] args) {
 
		rutasRechazadas = new ArrayList<Integer[]>();
 
		//Creamos la carretera
		carretera = new char[][]{
			{' ', ' ', '*', ' ', ' ', '*', ' ', ' ', '*', ' '},
			{'*', '*', ' ', '*', '*', '*', ' ', ' ', '*', ' '},
			{'*', ' ', '*', '*', ' ', ' ', '*', ' ', '*', ' '},
			{' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'}
			};
 
		//Inicializamos Posicion
		fila = 0; col = 0;
 
		//Colocamos coche en carretera. Representamos con una 'C'
		carretera[fila][col] = 'C';
		//Mostramos carretera
		mostrarCarretera();
 
		boolean fin = false; //Para controlar cuando se da por finalizado
		while (!fin) {
 
			if (moverCoche()) {
				//Hemos podido desplazarnos, comprobamos si hemos llegado a destino
				if (col == carretera[0].length - 1) {
					System.out.println("\n!!Destino alcanzado");
					fin = true;
				}
			}
			else { //Coche no se puede mover en ninguna direccion
				System.out.println("Coche atascado. Imposible llegar a Destino");
				fin = true;
			}
 
			mostrarCarretera();
		}
 
 
		System.out.println("\n\t\t--FIN DE PROGRAMA--");
	}
 
	/**
	 * Muestra en pantalla la Carretera con la posicion actual del Coche
	 */
	private static void mostrarCarretera() {
		System.out.println();
		for (int j = 0; j < carretera.length; j++)
			System.out.println(Arrays.toString(carretera[j]));
		System.out.println();
		System.out.println("\nPulse ENTER para continuar...\n");
		teclado.nextLine();
	}
 
	/**
	 * Intentará mover el coche en una de las 8 posibles direcciones.
	 * Informará de si ha podido moverse o no.
	 * @return True si pudo moverse, False si no pudo.
	 */
	private static boolean moverCoche() {
		//Si alguno de estos métodos tiene éxito, devolverá TRUE.
		return moverE() || moverNE() || moverSE() || moverN()
				|| moverS() || moverO() || moverNO() || moverSO();
		//Si todos fracasan, devolverá FALSE.
	}
 
	/**
	 * Intenta el desplazamiento hacia el Este
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverE() {
		//Mover al Este implica incrementar la Columna -> col++
 
		//Comprobamos si esta ruta ya la hemos intentado
		if (rutaRechazada(fila, col + 1))
			return false;
 
		try {
			//Antes de mover, comprobamos si hay espacio libre al Este
			if (carretera[fila][col + 1] == ' ') {
				//Sí, esta libre
				carretera[fila][col] = ' '; //Dejamos libre posicion actual
				col++; //Movemos
				carretera[fila][col] = 'C'; //Colocamos Coche en nueva posicion
				return true;
			}
			else //No hay espacio libre
				return false;
 
		}catch(Exception e) {
			return false; //Nos hemos salido de la carretera/matriz
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el NorEste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverNE() {
		//Mover al NE implica decrementar la Fila e incrementar la Columna
		if (rutaRechazada(fila - 1, col + 1))
			return false;
 
		try {
			if (carretera[fila - 1][col + 1] == ' ') {
				carretera[fila][col] = ' ';
				fila--;
				col++;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el SurEste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverSE() {
		//Mover al SE implica incrementar la Fila y la Columna
		if (rutaRechazada(fila + 1, col + 1))
			return false;
 
		try {
			if (carretera[fila + 1][col + 1] == ' ') {
				carretera[fila][col] = ' ';
				fila++;
				col++;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el Norte
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverN() {
		//Mover al N implica decrementar la Fila
		if (rutaRechazada(fila - 1, col))
			return false;
 
		try {
			if (carretera[fila - 1][col] == ' ') {
				carretera[fila][col] = ' ';
				fila--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el Sur
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverS() {
		//Mover al N implica incrementar la Fila
		if (rutaRechazada(fila + 1, col))
			return false;
 
		try {
			if (carretera[fila + 1][col] == ' ') {
				carretera[fila][col] = ' ';
				fila++;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el Oeste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverO() {
		//Mover al Oeste implica decrementar la Columna
		if (rutaRechazada(fila, col - 1))
			return false;
 
		try {
			if (carretera[fila][col - 1] == ' ') {
				//Si vamos al Oeste, es porque esta posicion nos deja sin salida
				rutasRechazadas.add(new Integer[] {fila, col}); //No queremos volver por aquí :P
				carretera[fila][col] = ' ';
				col--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el NorOeste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverNO() {
		//Mover al NO implica decrementar Fila y Columna
		if (rutaRechazada(fila - 1, col - 1))
			return false;
 
		try {
			if (carretera[fila - 1][col - 1] == ' ') {
				rutasRechazadas.add(new Integer[] {fila, col});
				carretera[fila][col] = ' ';
				fila--;
				col--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	/**
	 * Intenta el desplazamiento hacia el SurOeste
	 * @return True si tuvo éxito, False en caso contrario
	 */
	private static boolean moverSO() {
		//Mover al SO implica incrementar la Fila y decrementar la Columna
		if (rutaRechazada(fila + 1, col - 1))
			return false;
 
		try {
			if (carretera[fila + 1][col - 1] == ' ') {
				rutasRechazadas.add(new Integer[] {fila, col});
				carretera[fila][col] = ' ';
				fila++;
				col--;
				carretera[fila][col] = 'C';
				return true;
			}
			else
				return false;
 
		}catch(Exception e) {
			return false;
		}
	}
 
	private static boolean rutaRechazada(int f, int c) {
		for (Integer[] ruta: rutasRechazadas) {
			if (ruta[0] == f && ruta[1] == c) {
				return true; //Ya hemos estado aqui
			}
		}
		return false; //Aun no hemos probado esta ruta
	}
}

Pero tampoco ha funcionado bien, solo he conseguido que vuelva hacia atrás hasta el punto de partida, marcando toda la ruta como rechazada y al llegar ahí dice que está atascado y se termina el programa xD
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
[C,  , *,  ,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ , C, *,  ,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *,  ,  , *,  ,  , *,  ]
[*, *, C, *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *, C,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *,  , C, *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *, C,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ ,  , *,  ,  , *,  ,  , *,  ]
[*, *, C, *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[ , C, *,  ,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
 
[C,  , *,  ,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]
 
 
Pulse ENTER para continuar...
 
 
Coche atascado. Imposible llegar a Destino
 
[C,  , *,  ,  , *,  ,  , *,  ]
[*, *,  , *, *, *,  ,  , *,  ]
[*,  , *, *,  ,  , *,  , *,  ]
[ , *,  ,  , *,  , *,  ,  , *]

Y ahora mismo, pues no se me ocurre como solucionarlo, ni tengo más tiempo para dedicarle a esto.

Quizás marcar las casillas que consideramos rechazadas con una X y las casillas por las que hemos pasado con una P.
Las X no nos movemos, las que sean P, no están descartadas del todo, pero a la hora de movernos, dar prioridad a las casillas libres, las marcadas con espacio en blanco.
Asi el coche intentará rutas por las que no ha pasado, en lugar de volver por donde ha venido como me ha pasado a mí.

Pero escribir una lógica para esto, puede ser complejo.

Quizás alguien conoce una solución más sencilla para todo este embrollo, que yo no soy capaz de ver.
A ver si alguien nos ilumina.

Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar