[Reto] Backtracking - Laberinto

[hadree]

************************************

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:

Código [Seleccionar] Expandir



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.



Código [Seleccionar] Expandir



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



Os animáis a intentarlo :cool: ??

Código [Seleccionar] Expandir


//El código lo pondré en unos días, a ver si la gente participa...:D



.

[[D4N93R]]

Hola,

Excelente idea. Me tomé la molestia de modificar un poquito el títle del post Y bueno, a ver quién se anota!!

[hadree]

Gracias, me parece bien así...."reto" suena más interesante....jajajaja

[diego_lp]

La idea esta muy buena!
Yo me anoto!
En cuanto tenga un rato libre lo voy a intentar 
Saludos.

[ghastlyX]

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++.

Código (cpp) [Seleccionar] Expandir

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

[.::IT::.]

No se porque paso por mi mente que podría ser una tarea jaja en fin esta interesante

[hadree]

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...

****************************************************************


.

[pisa2]

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