Ayuda con programa urgente!

[ivancea96]

Si solo es un laberinto de 1 carril, puedes hacer esto:

En unas variables X e Y guardas la posición actual. (Por donde estás en cada momento).
Buscas cuál es el 1 o 2 que hay delante. Haces que unas variables tempX y tempY guarden los datos de X e Y, y X e Y las igualas a la nueva posición.
Ahora vuelves a buscar, con una condición: El nuevo 1 o 2 a buscar no puede estar en la posición anterior (tempX o tempY).
Con cada paso, muestras la pantalla.

Es el algoritmo que se me ocurre. Solo para recorridos con 1 dirección y 1 de grosor en el camino.

Código (cpp) [Seleccionar] Expandir

/** Buscar unos o doses **/
for(int i=-1; i<2; i++)
    for(int j=-1; j<2; j++)
        if(!(x+i == tempX && y+j == tempY) && (i || j) && (vector[x+i][y+j] == 1 || vector[x+i][y+j] == 2)){
            tempX = X;
            tempY = Y;
            X = X+i;
            Y = Y+j;
        }
//.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
// - Mostrar pantalla, comprobar si es un 2 para finalizar, etc, etc... -
//'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'



----------------Breve explicación de las condiciones:----------------

Código (cpp) [Seleccionar] Expandir

!(x+i == tempX && y+j == tempY)

-Los nuevos valores NO pueden ser iguales a los anteriores (Para no retroceder en el laberinto)

Código (cpp) [Seleccionar] Expandir

(i || j)

-I y J NO pueden ser 0 (Significaría que nos situaremos en la misma casilla, donde estamos)

Código (cpp) [Seleccionar] Expandir

(vector[x+i][y+j] == 1 || vector[x+i][y+j] == 2)

-El siguiente paso en el laberinto DEBE ser un 1 o un 2 (Es el número asociado al camino)



Y bueno, suerte :3 Espero no haberme equivocado en nada jaja

[vangodp]

Alberto, aun que usas borland puedes instalar otros compiladores.
Si te paso un código echo en dev cpp o codeblocks no lo vas entender por que no tienes el compilador?
Instalas otro como codeblocks, al menos ves que hace el código.
No uso borland, por que doy preferencia al free.
Ni se si existe borland free. 
¿Que es mejor?Que tu muñeco vaya como un perro enseñado el camino o lo busque por si solo.
El camino puede no siempre ser directo, puede haber calles sin salida¿No?
Lo que te hablo y también ivancea96, es lo mejor.
Que se busque el su caminito

Y si declaras el mapa como lo hace yo te sera mas facil:

Código (cpp) [Seleccionar] Expandir


char mapa[26][26]={
"0000000000000000000000000",
"1111110000000000000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"0000011100000000000000000",
"0000000100000000000000000",
"0000000100000000000000000",
"0000000110000000000000000",
"0000000011111100000000000",
"0000000000000100000000000",
"0000011111111100000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"1111110000000000000000000",
"1000000000000000000000000",
"1000000000000000000000000",
"1111111111111111000000000",
"0000000000000001000000000",
"0000000000000001111100000",
"0000000000000000000100000",
"0000000000000000111100000",
"0000000001111111100000000",
"0000000001000000000000000",
"0000000001000000011111112",
"0000000001111111110000000",
};

¿Cuantas lineas de código eh ajorado aquí?
Pero se trata de char y no de int, se le guarda como un "string entre comillas doble"
si lo guardas como int se guarda { {1,2,3,4,5,6}, {9,2,5,7,8,8} } mas o menos, ya ves que tienes que ir poniendo comas entre los números y llaves y yo que se que mas.
De esta manera hasta ves el mapa como queda

[Albertocn]

Se ve mucho más fácil hacerlo así como dices, ¿pero cómo lo imprimo?, ¿también con el for?, créanme que es un problema tener un compilador como el que estamos usando y más ya que estoy empezando con esto de la programación, desafortunadamente el proyecto nos lo piden así, ya tomó mas forma el laberinto, aquí mi duda es, el for que me sugirieron, ¿dónde lo meto en mi programa?, ¿cómo quedaría?...he intentado otras cosas pero se me cicla!, es bastante desesperante esto...

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <conio.h>
#include <dos.h>
main()
{
textcolor(BLUE);
clrscr();
int arreglo[25][25]={0},x=0,y=0;
arreglo[1][0]=1;
arreglo[1][1]=1;
arreglo[1][2]=1;
arreglo[1][3]=1;
arreglo[1][4]=1;
arreglo[1][5]=1;
arreglo[2][5]=1;
arreglo[3][5]=1;
arreglo[6][7]=1;
arreglo[5][7]=1;
arreglo[4][5]=1;
arreglo[4][6]=1;
arreglo[4][7]=1;
arreglo[7][8]=1;
arreglo[7][7]=1;
arreglo[8][8]=1;
arreglo[8][9]=1;
arreglo[8][10]=1;
arreglo[8][11]=1;
arreglo[8][12]=1;
arreglo[8][13]=1;
arreglo[9][13]=1;
arreglo[10][13]=1;
arreglo[10][12]=1;
arreglo[10][11]=1;
arreglo[10][10]=1;
arreglo[10][9]=1;
arreglo[10][8]=1;
arreglo[10][7]=1;
arreglo[10][6]=1;
arreglo[10][5]=1;
arreglo[11][5]=1;
arreglo[12][5]=1;
arreglo[13][0]=1;
arreglo[13][1]=1;
arreglo[13][2]=1;
arreglo[13][3]=1;
arreglo[13][4]=1;
arreglo[13][5]=1;
arreglo[14][0]=1;
arreglo[15][0]=1;
arreglo[16][0]=1;
arreglo[16][1]=1;
arreglo[16][2]=1;
arreglo[16][3]=1;
arreglo[16][4]=1;
arreglo[16][5]=1;
arreglo[16][6]=1;
arreglo[16][7]=1;
arreglo[16][8]=1;
arreglo[16][9]=1;
arreglo[16][10]=1;
arreglo[16][11]=1;
arreglo[16][12]=1;
arreglo[16][13]=1;
arreglo[16][14]=1;
arreglo[16][15]=1;
arreglo[17][15]=1;
arreglo[18][15]=1;
arreglo[18][16]=1;
arreglo[18][17]=1;
arreglo[18][18]=1;
arreglo[18][19]=1;
arreglo[19][19]=1;
arreglo[20][19]=1;
arreglo[20][18]=1;
arreglo[20][17]=1;
arreglo[20][16]=1;
arreglo[21][16]=1;
arreglo[21][15]=1;
arreglo[21][14]=1;
arreglo[21][13]=1;
arreglo[21][12]=1;
arreglo[21][11]=1;
arreglo[21][10]=1;
arreglo[21][9]=1;
arreglo[22][9]=1;
arreglo[23][9]=1;
arreglo[24][9]=1;
arreglo[24][10]=1;
arreglo[24][11]=1;
arreglo[24][12]=1;
arreglo[24][13]=1;
arreglo[24][14]=1;
arreglo[24][15]=1;
arreglo[24][16]=1;
arreglo[24][17]=1;
arreglo[23][17]=1;
arreglo[23][18]=1;
arreglo[23][19]=1;
arreglo[23][20]=1;
arreglo[23][21]=1;
arreglo[23][22]=1;
arreglo[23][23]=1;
arreglo[23][24]=2;
arreglo[15][10]=1;
arreglo[14][10]=1;
arreglo[14][11]=1;
arreglo[14][12]=1;
arreglo[14][13]=1;
arreglo[6][8]=1;
arreglo[6][9]=1;
arreglo[6][10]=1;
arreglo[6][11]=1;
arreglo[6][12]=1;
arreglo[6][13]=1;
arreglo[7][13]=1;
arreglo[17][0]=1;
arreglo[18][0]=1;
arreglo[19][0]=1;
arreglo[19][1]=1;
arreglo[19][2]=1;
arreglo[19][3]=1;
arreglo[20][3]=1;
arreglo[20][4]=1;
arreglo[20][5]=1;
for(x=0;x<25;x++)
{
for(y=0;y<25;y++)
{
printf("%d",arreglo[x][y]);
}
printf("\n");
}
for(x=0;x<25;x++)
{
for(y=0;y<25;y++)
{
}
}
getch();
}

[Albertocn]

Quedó igual sólo le di más forma, tiene dos for debajo de los for que use para imprimir, no afectan en nada, es ahí donde no se que ponerle para que me empiece a recorrer el camino, hasta el momento es lo único que nos han enseñado, for, while, if, switch y funciones.

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <conio.h>
#include <dos.h>
main()
{
textcolor(BLUE);
clrscr();
int arreglo[25][25]={0},x=0,y=0;
arreglo[1][0]=1;
arreglo[1][1]=1;
arreglo[1][2]=1;
arreglo[1][3]=1;
arreglo[1][4]=1;
arreglo[1][5]=1;
arreglo[2][5]=1;
arreglo[3][5]=1;
arreglo[6][7]=1;
arreglo[5][7]=1;
arreglo[4][5]=1;
arreglo[4][6]=1;
arreglo[4][7]=1;
arreglo[7][8]=1;
arreglo[7][7]=1;
arreglo[8][8]=1;
arreglo[8][9]=1;
arreglo[8][10]=1;
arreglo[8][11]=1;
arreglo[8][12]=1;
arreglo[8][13]=1;
arreglo[9][13]=1;
arreglo[10][13]=1;
arreglo[10][12]=1;
arreglo[10][11]=1;
arreglo[10][10]=1;
arreglo[10][9]=1;
arreglo[10][8]=1;
arreglo[10][7]=1;
arreglo[10][6]=1;
arreglo[10][5]=1;
arreglo[11][5]=1;
arreglo[12][5]=1;
arreglo[13][0]=1;
arreglo[13][1]=1;
arreglo[13][2]=1;
arreglo[13][3]=1;
arreglo[13][4]=1;
arreglo[13][5]=1;
arreglo[14][0]=1;
arreglo[15][0]=1;
arreglo[16][0]=1;
arreglo[16][1]=1;
arreglo[16][2]=1;
arreglo[16][3]=1;
arreglo[16][4]=1;
arreglo[16][5]=1;
arreglo[16][6]=1;
arreglo[16][7]=1;
arreglo[16][8]=1;
arreglo[16][9]=1;
arreglo[16][10]=1;
arreglo[16][11]=1;
arreglo[16][12]=1;
arreglo[16][13]=1;
arreglo[16][14]=1;
arreglo[16][15]=1;
arreglo[17][15]=1;
arreglo[18][15]=1;
arreglo[18][16]=1;
arreglo[18][17]=1;
arreglo[18][18]=1;
arreglo[18][19]=1;
arreglo[19][19]=1;
arreglo[20][19]=1;
arreglo[20][18]=1;
arreglo[20][17]=1;
arreglo[20][16]=1;
arreglo[21][16]=1;
arreglo[21][15]=1;
arreglo[21][14]=1;
arreglo[21][13]=1;
arreglo[21][12]=1;
arreglo[21][11]=1;
arreglo[21][10]=1;
arreglo[21][9]=1;
arreglo[22][9]=1;
arreglo[23][9]=1;
arreglo[24][9]=1;
arreglo[24][10]=1;
arreglo[24][11]=1;
arreglo[24][12]=1;
arreglo[24][13]=1;
arreglo[24][14]=1;
arreglo[24][15]=1;
arreglo[24][16]=1;
arreglo[24][17]=1;
arreglo[23][17]=1;
arreglo[23][18]=1;
arreglo[23][19]=1;
arreglo[23][20]=1;
arreglo[23][21]=1;
arreglo[23][22]=1;
arreglo[23][23]=1;
arreglo[23][24]=2;
arreglo[15][10]=1;
arreglo[14][10]=1;
arreglo[14][11]=1;
arreglo[14][12]=1;
arreglo[14][13]=1;
arreglo[6][8]=1;
arreglo[6][9]=1;
arreglo[6][10]=1;
arreglo[6][11]=1;
arreglo[6][12]=1;
arreglo[6][13]=1;
arreglo[7][13]=1;
arreglo[17][0]=1;
arreglo[18][0]=1;
arreglo[19][0]=1;
arreglo[19][1]=1;
arreglo[19][2]=1;
arreglo[19][3]=1;
arreglo[20][3]=1;
arreglo[20][4]=1;
arreglo[20][5]=1;
for(x=0;x<25;x++)
{
for(y=0;y<25;y++)
{
printf("%d",arreglo[x][y]);
}
printf("\n");
}
for(x=0;x<25;x++)
{
for(y=0;y<25;y++)
{
}
}
getch();
}

[vangodp]

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <windows.h>

#define tiempo Sleep(5) /* Esto hace una pausa pero depende de windows.h */

void mostrar(char mapa[26][26]){
     system ("cls"); /*Esto limpia la pantalla pero depende de windows.h*/
     for(int y=0;y<25;y++){
          for(int x=0;x<25;x++){
               printf("%c",mapa[y][x]);
               /*tiempo;*/
          }
          printf("\n");
          /*tiempo; */
     }
}

int main (){

char mapa[26][26]={
"0000000000000000000000000",
"1111110000000000000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"0000011100000000000000000",
"0000000100000000000000000",
"0000000100000000000000000",
"0000000110000000000000000",
"0000000011111100000000000",
"0000000000000100000000000",
"0000011111111100000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"1111110000000000000000000",
"1000000000000000000000000",
"1000000000000000000000000",
"1111111111111111000000000",
"0000000000000001000000000",
"0000000000000001111100000",
"0000000000000000000100000",
"0000000000000000111100000",
"0000000001111111100000000",
"0000000001000000000000000",
"0000000001000000011111110",
"0000000001111111110000000",
};/*Fin de mapa*/

/*cuando quiera imprimir llamas a la funcion mostrar y le pasas el mapa.*/
mostrar(mapa);

}/*Fin de main*/


[leosansan]

Lo dejo a medio camino, entre la fuerza bruta de vangodp y la solución definitiva de ivancea96 - que usaría en un laberinto generado aleatoriamente, pero no es el caso- . Lo que hago es aprovecharme de que el laberinto está prefijado y con el la solución o alternativas de movimientos.

Esto hace lo que quieres:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
//#include <conio.h> //usar en TurboC

void mostrar(char a[25][26]){
   system ("cls");//creo que es clrscr() en TurboC
   int i,j;
   for( i=0;i<25;i++) {
       for( j=0;j<25;j++) {
           printf("%c ",a[i][j]);
       }
       printf("\n");
   }
   printf("\n");
   //system ("pause");//puedes usar getch() o delay en TurboC
}

int main (){
   char a[25][26]={
   "0000000000000000000000000",
   "1111110000000000000000000",
   "0000010000000000000000000",
   "0000010000000000000000000",
   "0000011100000000000000000",
   "0000000100000000000000000",
   "0000000100000000000000000",
   "0000000110000000000000000",
   "0000000011111100000000000",
   "0000000000000100000000000",
   "0000011111111100000000000",
   "0000010000000000000000000",
   "0000010000000000000000000",
   "1111110000000000000000000",
   "1000000000000000000000000",
   "1000000000000000000000000",
   "1111111111111111000000000",
   "0000000000000001000000000",
   "0000000000000001111100000",
   "0000000000000000000100000",
   "0000000000000000111100000",
   "0000000001111111100000000",
   "0000000001000000000000000",
   "0000000001000000011111112",
   "0000000001111111110000000",
   };
   int i=1,j=0,flag=0;
   while (j<24){
           if (i==1 && j==0)
           a[i][j++]='X';
           else if (a[i+1][j]=='1' && i<24 && flag==0)
               a[i++][j]='X';
           else if (a[i][j+1]=='1')
               a[i][j++]='X';
           else if (i<24 && a[i+1][j]=='0' && a[i][j+1]=='0'|| a[i][j+1]=='X')
               a[i][(j--)]='X';
           else if (i==24 && a[i][j+1]==1 )
               a[i][j++]='X';
           else if (i==24 && a[i][j+1]=='0' ){
               a[i--][j]='X';
               flag=1;
           }
           if (i==23 && j<24 && flag==1)
               a[i][j++]='X';
           //mostrar(a);
       }
   a[i][j]='X';
   mostrar(a);
   //getch();
   return 0;
}


Ya, ya sé que es mejorable pero me da pereza xD.

Reedito:

¿Quién dijo lento?. Para muestra un botón:

Código (cpp) [Seleccionar] Expandir


0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
X X X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 X X X X X X 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 X X X X X X X X X 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
X X X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
X X X X X X X X X X X X X X X X 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X X X X X 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X X X X 0 0 0 0 0
0 0 0 0 0 0 0 0 0 X X X X X X X X 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 X X X X X X X X
0 0 0 0 0 0 0 0 0 X X X X X X X X X 0 0 0 0 0 0 0

Process returned 0 (0x0)   execution time : 0.123 s


Saluditos! ..... !!!!        

[vangodp]

jaja muy buena leo .
eh pensado en hacer que ande todo el camino solo buscando la salida.
Pero se toma algún tiempo XDD
Por cierto en el array no se por que pero le tengo que poner a[26][26]
con 25 me da error.¿por que sera?
En la funcion y en main

[leosansan]

jaja muy buena leo .
eh pensado en hacer que ande todo el camino solo buscando la salida.
Pero se toma algún tiempo XDD

Es por tener que "dibujar" una matriz de 25x25, no creo que sea por otra cosa. Supongo que dependerá en gran medida de la tarjeta gráfica. O bien desactivas el system ("pause") de la función mostrar.

Por cierto en el array no se por que pero le tengo que poner a[26][26]
con 25 me da error.¿por que sera?
En la funcion y en main

Eso me extraña más ya que la matriz es de 25 elementos. A mí al menos me funciona sin problemas. Mira que error te "canta" y me cuentas a ver que ocurre.

Saluditos! ..... !!!!        

[vangodp]

Buenas que tal!
Eh mejorado un poco el código
Lo eh echo auto suficiente jaja
Este se busca la salida solo XD
Puedes cambiar el mapa a gusto.
Es algo ineficiente aun, lo estoy puliendo cosillas como cuando encuentra una calle sin salida, le tarda algo en volver al camino, pero lo encuentra.
Aquí le dejo el rollo, jaja me eh reído un montón con el código jaja

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <time.h>
using namespace std;

int rand2 (){
srand(time(NULL));
int n = (0 + rand() % 2);
return n;
}
int rand3 (){
srand(time(NULL));
int n = (0 + rand() % 3);
return n;
}
int rand4 (){
srand(time(NULL));
int n = (0 + rand() % 4);
return n;
}

void mostrar(char mapa[29][29]){
system ("cls");

    for(int y=0;y<29;y++)
    {
    for(int x=0;x<29;x++)
    {
    printf("%c",mapa[y][x]);
    //Sleep(5);
    }
    printf("\n");
    //Sleep(5);
    }
   
}

// GO ONE
void go_arriba( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
y--;
mapa [y][x]='X';
}
void go_izquierda( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
x--;
mapa [y][x]='X';
}
void go_derecha( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
x++;
mapa [y][x]='X';
}  
void go_abajo( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
y++;
mapa [y][x]='X';
}
// DECIDE 2
void decide_arriba_izquierda ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda"<<endl;
cin.ignore();
break;
}

}
void decide_arriba_derecha ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_arriba ( mapa, x, y );
break;
case 1:
go_derecha ( mapa, x, y );
break;
default:
cout << "error:decide_arriba_derecha"<<endl;
cin.ignore();
break;
}
}
void decide_arriba_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_abajo( mapa, x, y );
break;
default:
cout << "decide_arriba_abajo"<<endl;
cin.ignore();
break;
}
}
void decide_izquierda_derecha ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_izquierda( mapa, x, y );
break;
case 1:
go_derecha( mapa, x, y );
break;
default:
cout << "error:decide_izquierda_derecha"<<endl;
cin.ignore();
break;
}
}
void decide_izquierda_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_izquierda( mapa, x, y );
break;
case 1:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_izquierda_abajo"<<endl;
cin.ignore();
break;
}
}
void decide_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_derecha( mapa, x, y );
break;
case 1:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_derecha_abajo"<<endl;
cin.ignore();
break;
}
}
// DECIDE 3
void decide_arriba_izquierda_derecha ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
case 2:
go_derecha( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda_derecha"<<endl;
cin.ignore();
break;
}
}
void decide_arriba_izquierda_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
case 2:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda_abajo"<<endl;
cin.ignore();
break;
}  
}
void decide_arriba_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_derecha( mapa, x, y );
break;
case 2:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_arriba_derecha_abajo"<<endl;
cin.ignore();
break;
}  
}
void decide_izquierda_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_izquierda( mapa, x, y );
break;
case 1:
go_derecha( mapa, x, y );
break;
case 2:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_izquierda_derecha_abajo"<<endl;
cin.ignore();
break;
}  
}
// DECIDE 4
void decide_arriba_izquierda_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand4() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
case 2:
go_derecha( mapa, x, y );
break;
case 3:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda_derecha_abajo"<<endl;
cin.ignore();
break;
}  
}
// ESPECIAL CASES

//MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAINMAIN_MAIN_MAIN
int main (){



//MAPA DE TIPO CHAR, MAS ADELANTE HACEMOS UN CAST PARA INT
char mapa[29][29]={

"000000000000000000000000000",
"0X0222222222222222222222220",
"020200000000000000000000020",
"020222222222222200000000020",
"020200000000000000000000020",
"020222222222222200022222220",
"020000000000000200020000020",
"020222222222200200000000020",
"020200000000200222222222020",
"020222222200200000000002020",
"020000000200222222222222020",
"022222220200000000000000020",
"000000020200222222222222220",
"000000022200200000000000000",
"000000000000200222222222220",
"022222222222200200000000020",
"020000000000000222222202020",
"020000000000000200000202020",
"022222222222222200000202020",
"000000000000000000000202220",
"022222222222222222222200000",
"020000000000000000000000000",
"02222222222222222222222FIN0",
"000000000000000000000000000"

};

//VARIABLES LOCALES
int n;
cout << "velocidad de busqueda?" << endl;
cin >> n;

//POSICION INICIAL (CORRDENADAS)
int x = 1;
int y = 1;

//CONVERTIMOS EN INT LOS POCIBLES CAMINOS A TOMAR
int arriba = (int (mapa [ y - 1] [ x ])-48);
int izquierda = (int (mapa [ y ] [ x -1 ])-48);
int derecha = (int (mapa [ y ] [ x + 1 ])-48);
int abajo = (int (mapa [ y + 1] [ x ])-48);

//CONDICION DEL BUCLE PRINCIPAL: SI NO SE ENCUENTRA EL FIN DEL MAPA SIEMPRE SERA FALSO.
bool fin = false;

//BUCLE PRINCIPAL: COMPRUEBA QUE NO ENCONTREMOS LA SALIDA.
while ( !fin ){

//Valores de los pocibles caminos
arriba = (int (mapa [ y - 1] [ x ]-48));
izquierda = (int (mapa [ y ] [ x -1 ]-48));
derecha = (int (mapa [ y ] [ x + 1 ]-48));
abajo = (int (mapa [ y + 1] [ x ]-48));

//CASOS
if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(0,0,0,0)*
//NO SE elige NADA
}
if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(0,0,0,1)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(0,0,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 0 ) {//(0,0,1,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(0,0,1,1)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(0,0,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(0,0,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(0,0,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(0,0,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(0,1,0,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(0,1,0,1)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(0,1,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(0,1,1,0)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(0,1,1,1)*
//izquierda || derecha || abajo
decide_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(0,1,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(0,1,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(0,1,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(0,1,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(0,2,0,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(0,2,0,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(0,2,0,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(0,2,1,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(0,2,1,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(0,2,1,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(0,2,2,0)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(0,2,2,1)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(0,2,2,2)*
//izquierda || derecha || abajo
decide_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(1,0,0,0)*
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(1,0,0,1)*ESPECIAL
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(1,0,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 0 ){//(1,0,1,0)*
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(1,0,1,1)*
//arriba || derecha || abajo
decide_arriba_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(1,0,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(1,0,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(1,0,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(1,0,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(1,1,0,0)*
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(1,1,0,1)*
//arriba || izquierda || abajo
decide_arriba_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(1,1,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(1,1,1,0)*
//arriba || izquierda || derecha
}
if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(1,1,1,1)
//arriba || izquierda || derecha || abajo
decide_arriba_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(1,1,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(1,1,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(1,1,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(1,1,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(1,2,0,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(1,2,0,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(1,2,0,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(1,2,1,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(1,2,1,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(1,2,1,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(1,2,2,0)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(1,2,2,1)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(1,2,2,2)
//izquierda || derecha || abajo
decide_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(2,0,0,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(2,0,0,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(2,0,0,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 0 ){//(2,0,1,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(2,0,1,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(2,0,1,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(2,0,2,0)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(2,0,2,1)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(2,0,2,2)
//arriba || derecha || abajo
decide_arriba_derecha_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(2,1,0,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(2,1,0,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(2,1,0,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(2,1,1,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(2,1,1,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(2,1,1,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(2,1,2,0)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(2,1,2,1)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(2,1,2,2)
//arriba || derecha || abajo
decide_arriba_derecha_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(2,2,0,0)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(2,2,0,1)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(2,2,0,0)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(2,2,0,2)
//arriba || izquierda || abajo
decide_arriba_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(2,2,1,0)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(2,2,1,1)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(2,2,1,2)
//arriba || izquierda || abajo
decide_arriba_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(2,2,2,0)
//arriba || izquierda || derecha
decide_arriba_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(2,2,2,1)
//arriba || izquierda || derecha
decide_arriba_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(2,2,2,2)
//arriba || izquierda || derecha || abajo
decide_arriba_izquierda_derecha_abajo ( mapa, x, y );
}




// ON SCREEN PRINT
mostrar (mapa);
Sleep(n);
//system("pause");
}


return 0;
}


Esta echo en dev cpp orwell
Pronto subo la 2.0 o mejor lo mejoren vosotros si quieren  

Se debe de poner 0 en los bordes o puede ser bug
La X va buscando el 2, si no hay remedio busca 1 y el 0 es como pared.
Debe tener 0 en todo el lado externo.
Tomar el 0 como pared y rodear todo el mapa.

[ivancea96]

Perdona, que diga algo: Todos esos "if" los podrías cambiar por 1 único if dentro de un bucle de 4 "for". No se que algoritmo usaste, pero bueno, evitar hacer ese tipo de "copy&paste" es mejor. especialmente para la vista.