 Autor
|
Tema: [Reto] Backtracking - Laberinto (Leído 13,922 veces)
|
hadree
 Desconectado
Mensajes: 6
|
************************************ Hola a todos, soy nuevo en el foro y se ma ha ocurrido la idea de este hilo para explicar como realizar el algoritmo de "backtracking" para calcular el camino de ida desde la entrada de un laberinto, hasta la salida del mismo (en caso de haberla). Os propongo realizar un pequeño programa que cumpla lo siguiente:
Dado un laberinto escriba un programa que usando
los cuatro movimientos del laberinto, arriba, abajo,
izquierda y derecha calcule (si existen):
1) La primera solución.
2) El total de las soluciones
3) La mejor solución en cuanto a menor número de pasos.
Los datos de entrada son recibidos en un fichero
de texto laberinto.txt que tiene la siguiente estructura:
a.) La primera línea tiene dos números enteros que
son el número de filas nf y el número de columnas nc del laberinto.
b.) Las siguientes nf líneas tienen un total de nc números enteros cada
una de ellas separados por blancos que pueden ser: 0, 1, 2, 3 y 4
CERO: Indica muro (no se puede pisar la casilla);
UNO: Libre sin penalización. (+1 pasos)
DOS: Libre con penalización. (+2 pasos)
TRES: Libre con penalización. (+3 pasos)
CUATRO: Libre con penalización. (+4 pasos)
c.) La última línea del fichero tiene cuatro números enteros:
Fe = fila de entrada.
Ce = columna de entrada.
Fs = fila de salida.
Cs = columna de salida.
La estructura del laberinto en el archivo sería la siguiente:
---------------------------
nf nc
x x x x x x x x
x x x x x x x x
x x x x x x x x
x x x x x x x x
x x x x x x x x
fe fs ce cs
---------------------------
12 12
0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 0 0 1 1 1 0
0 4 0 4 0 4 3 3 4 0 4 0
0 3 0 2 0 3 0 1 0 0 1 0
0 4 0 3 0 3 0 1 0 1 4 0
0 3 0 4 0 3 0 4 0 1 0 0
0 4 0 1 1 1 3 1 2 1 0 0
0 3 0 0 1 0 0 1 0 1 3 1
0 4 0 0 1 1 0 2 0 4 0 0
0 2 0 0 0 1 0 3 0 4 0 0
0 1 1 1 1 1 0 4 1 4 3 0
0 0 0 0 0 0 0 0 0 0 0 0
1 0 7 11
---------------------------
//El código lo pondré en unos días, a ver si la gente participa...:D
.
|
|
|
|
« Última modificación: 23 Noviembre 2010, 05:29 am por [D4N93R] »
|
En línea
|
|
|
|
[D4N93R]
Wiki
Desconectado
Mensajes: 1.646
My software never has bugs. Its just features!
|
Hola, Excelente idea. Me tomé la molestia de modificar un poquito el títle del post  Y bueno, a ver quién se anota!!
|
|
|
|
|
En línea
|
|
|
|
hadree
Desconectado
Mensajes: 6
|
Gracias, me parece bien así...."reto" suena más interesante....jajajaja
|
|
|
|
|
En línea
|
|
|
|
diego_lp
Desconectado
Mensajes: 180
In a free world, who needs gates and windows?
|
La idea esta muy buena! Yo me anoto! En cuanto tenga un rato libre lo voy a intentar  Saludos. |
|
|
|
|
En línea
|
Los programadores hicimos un pacto con Dios, él no hace sistemas y nosotros no hacemos milagros!
|
|
|
ghastlyX
Ex-Staff
Desconectado
Mensajes: 1.900
|
El enunciado tiene muchas imprecisiones. Cuando dice la primera solución, entiendo que se refiere a la primera que encuentre el backtracking, pero no queda claro ni especifica qué criterio usar. Lo segundo que pide es, bajo mi punto de vista, erróneo. Con el enunciado actual no se prohíben los ciclos, de forma que existen infinitos caminos para la gran mayoría de laberintos. Se tendría que especificar una longitud máxima o bien exigir que no haya ciclos. Lo tercero es correcto, pero en lugar de un backtracking puede resolverse mediante Dijkstra, cuya complejidad para un grafo G = (V, E) es O((V + E)logV) mientras que el backtracking no es polinómico. He picado Dijkstra en C++ para el problema, he probado un par de ejemplos y los resuelve bien. El código es simple así que no debería ser problema pasarlo a otro lenguaje sabiendo un poco de C++. #include <iostream> #include <vector> #include <queue> using namespace std; const int INF = 1000000000; const int arr1[] = {1, -1, 0, 0}; const int arr2[] = {0, 0, 1, -1}; typedef pair<int, int> PII; typedef pair<int, PII> PIPII; void dijkstra(int fini, int cini, int ffin, int cfin, vector<vector<int> >& M) { int n = M.size(), m = M[0].size(); vector<vector<int> > d(n, vector<int>(m, INF)); d[fini][cini] = 0; priority_queue<PIPII> Q; Q.push(PIPII(0, PII(fini, cini))); while (not Q.empty()) { int f = Q.top().second.first, c = Q.top().second.second, dist = -Q.top().first; Q.pop(); if (dist != d[f][c]) continue; for (int i = 0; i < 4; ++i) { int nf = f + arr1[i], nc = c + arr2[i]; if (nc < 0 or nc >= m or nf < 0 or nf >= n or M[nf][nc] == 0) continue; if (d[nf][nc] > d[f][c] + M[nf][nc]) { d[nf][nc] = d[f][c] + M[nf][nc]; Q.push(PIPII(-d[nf][nc], PII(nf, nc))); } } } if (d[ffin][cfin] == INF) cout << "No existe camino" << endl; else cout << "Minima distancia: " << d[ffin][cfin] << endl; } int main() { int n, m; cin >> n >> m; vector<vector<int> > M(n, vector<int> (m)); for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) cin >> M[i][j]; int fini, ffin, cini, cfin; cin >> fini >> ffin >> cini >> cfin; if (M[fini][cini] == 0) cout << "Muro en posicion inicial" << endl; else dijkstra(fini, cini, ffin, cfin, M); }
|
|
|
|
|
En línea
|
|
|
|
.::IT::.
Desconectado
Mensajes: 167
|
No se porque paso por mi mente que podría ser una tarea jaja en fin esta interesante
|
|
|
|
|
En línea
|
Simplemente .::IT::.
|
|
|
hadree
Desconectado
Mensajes: 6
|
El enunciado tiene muchas imprecisiones. Cuando dice la primera solución, entiendo que se refiere a la primera que encuentre el backtracking, pero no queda claro ni especifica qué criterio usar.
Lo segundo que pide es, bajo mi punto de vista, erróneo. Con el enunciado actual no se prohíben los ciclos, de forma que existen infinitos caminos para la gran mayoría de laberintos. Se tendría que especificar una longitud máxima o bien exigir que no haya ciclos.
Lo tercero es correcto, pero en lugar de un backtracking puede resolverse mediante Dijkstra, cuya complejidad para un grafo G = (V, E) es O((V + E)logV) mientras que el backtracking no es polinómico.
He picado Dijkstra en C++ para el problema, he probado un par de ejemplos y los resuelve bien. El código es simple así que no debería ser problema pasarlo a otro lenguaje sabiendo un poco de C++.
1) Por supuesto lo de la primera solución se refiere a la primera solución es decir la primera encontrada, no me parece que haya ninguna duda... 2) En cuanto a los ciclos, si la verdad es que no lo había puesto, pero se da por hecho ya que realizando los movimientos básicos comentados se quedaría atascado si intentase pasar de nuevo por una casilla ya recorrida. 3) Se puede resolver con Dijkstra, pero la idea original era que fuera por backtracking y con una representación matricial que no que fuera considerada como un grafo. 4) El código no lo he probado pero parece tener buena pinta...  ****************************************************************
No se porque paso por mi mente que podría ser una tarea jaja en fin esta interesante
PD: Yo ya lo tengo resuelto y pensaba ponerlo más adelante simplemente quería saber si había gente dispuesta a intentarlo...  **************************************************************** .
|
|
|
|
« Última modificación: 25 Noviembre 2010, 17:06 pm por hadree »
|
En línea
|
|
|
|
pisa2
Desconectado
Mensajes: 1
|
hola pues a mi me iría genial la solución de este "maldito" problema en java!!  si la pones, me habrás hecho el regalo de navidad perfecto |
|
|
|
|
En línea
|
|
|
|
|
| Mensajes similares |
|
Asunto |
Iniciado por |
Respuestas |
Vistas |
Último mensaje |
|
|
|
Recursividad y Backtracking!!!!
Java
|
bwsr
|
2
|
8,265
|
28 Junio 2007, 00:40 am
por bwsr
|
|
|
|
Backtracking - Laberinto
Programación C/C++
|
hadree
|
3
|
7,012
|
23 Noviembre 2010, 03:08 am
por do-while
|
|
|
|
Suma de Conjuntos con Vuelta Atrás (Backtracking) en C
Programación General
|
maritere22
|
6
|
8,394
|
31 Mayo 2013, 05:39 am
por Kenkox
|
|
|
|
BACKTRACKING CIRCUITO HAMILTONIANO
Programación C/C++
|
yeah_2796
|
1
|
2,896
|
23 Mayo 2015, 11:19 am
por Stakewinner00
|
|
|
|
problema de backtracking y programacion dinamica
Programación C/C++
|
aprendiz de programador
|
6
|
6,411
|
12 Diciembre 2015, 16:08 pm
por SnzCeb
|
 |
