C/Visual C - Recursividad

 
Vista:
sin imagen de perfil

Recursividad

Publicado por Sebastián (31 intervenciones) el 25/12/2016 18:33:43
Hola buenos días a todos y Feliz navidad, les agradecería si me pueden orientar o ayudar con el siguiente ejercicios de arreglos con recursividad, les agradezco mucho la ayuda y disculpen cualquier molestia.

Mi princiapl pregunta es como puedo dar con la función recursiva, porque deberia generar una matriz aleatoria de 1 y 0 , para despues implementar la función.

El ejercicio es el siguiente:

La siguiente cuadrícula de unos y de ceros es un arreglo bidimensional, que representa un "laberinto".

matriz

Los unos representan los muros del laberinto, y los ceros representan cuadros en las trayectorias posibles a través del mismo.

El algoritmo para caminar a través de un laberinto que garantiza encontrar la salida (suponiendo que una exista), y si no existe salida, se llevará de regreso a la posición inicial es: colocar la mano derecha sobre el muro a la derecha y empezar a caminar hacia adelante, sin retirar nunca la mano de la pared, si el laberinto gira a la derecha, seguir el muro a la derecha. de tal forma se llegará a la salida del laberinto. Pudiera existir una trayectoria más corta de la que se haya tomado pero está garantiza de que se saldrá del laberinto.

Escribir la función recursiva para caminar a través del laberinto, la función deberá recibir como argumentos un arreglo de cualquier ancho y altura, de n por m caracteres, que representa el laberinto, y la posición inicial del laberinto. Conforme la función intenta localizar la salida del laberinto, deberá colocar el caracter x en cada uno de los cuadros de la trayectoria. Y después de cada movimiento la función deberá mostrar el laberinto, para que el usuario pueda observar conforme resuelve el laberinto.

Escribir una función que tiene como argumento un arreglo de n por m y que produzca en forma aleatoria un laberinto. La función también deberá proporcionar las posiciones iniciales y finales del mismo.


Realizar un programa para generar varios laberintos generados al azar, e imprima cada movimiento de los laberintos.
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
sin imagen de perfil
Val: 296
Bronce
Ha mantenido su posición en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Recursividad

Publicado por agustin (272 intervenciones) el 25/12/2016 20:45:07
No sabría ayudarte pero la lógica que usa para encontrar un camino válido no es cierta. Imagina este laberinto:
11111111111
10000011111
10111000111
00111010111
10111000111
10000011111
11111111111

En este caso no existe meta válida y regresará a la salida. ¿como asegurarte de crear un laberinto válido? Yo no se mucho pero lo único que se me ocurre es rellenar el laberinto con los valores aleatorios y probar todos los caminos hasta encontrar uno válido y si no hay caminos válidos repetir todo el proceso. A ver si alguien que sepa más te puede orientar.
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
sin imagen de perfil

Recursividad

Publicado por Sebastián (31 intervenciones) el 25/12/2016 21:05:57
Hola Agustín , gracias por tu ayuda, si a verdad el ejercicio esta bastante confuso, busque otros ejercicios similares en internet pero tenian un enunciado distinto y una lógica bien estructurada.

Gracias de nuevo por tu ayuda y tiempo!, voy a intentar preguntar a mi maestro.
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
sin imagen de perfil
Val: 296
Bronce
Ha mantenido su posición en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Recursividad

Publicado por agustin (272 intervenciones) el 25/12/2016 22:31:43
Para probar los caminos yo haría lo siguiente:
Uso una variable donde almaceno la última posición donde gire a la derecha y la inicializo con la posición de salida.
Uso otra para almacenar la posición inicial.
Inicio el avance comprobando que lo que tengo a la derecha sea un 1. Si es un 1 compruebo que delante sea un 0. Si lo que tengo es un 1 giro a la izquierda comprobando que sea 0. Si me encuentro con que a la derecha, a la izquierda y al frente hay un 1, no hay salida con lo que colocó un 1 en la dirección donde giré a la derecha por última vez y vuelvo al inicio. Si hago eso siempre solo quedará abierto el camino válido. Como el array será una copia no tocara el original y tendrás el original a buen recaudo.
Cada paso que vayas a dar será una llamada recursiva y la función de vería tener como parámetros el array, la variable con la posición inicial, y la variable con el último giro.
La función retornará un booleano con false si no te saliste del array y true si te saliste. Si te saliste es porque encontraste una ruta válida.
Yo primero intentaría hacerlo de una manera lineal y una vez funcione aplicar esa lógica a la recursiva porque depurar una función recursiva puede ser muy confuso.
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
sin imagen de perfil

Recursividad

Publicado por Sebastián (31 intervenciones) el 26/12/2016 02:33:47
Hola de nuevo mira, encontre algo de codigo en internet y tambien le modifique algo, pero queria ver si esta bien o aceptable al menos, lo que me faltaría es que el usuario defina el tamaño de la matriz :

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define tam 21
#define numero 140//numero de cuadritos
//este
int columna= tam-1,fila= tam-1;
int optima  = (tam*tam +1);//mejor ruta
int iter;
 
void carga_tablero(int arry[][tam])
{
     int j,i;
     for (j=0; j<tam; j++)
     {
         for (i=0; i<tam; i++)
         {arry[j][i] = 0;}
     }
}//carga
 
void mostrar(int arry[][tam])
{
     int j,i;
 
     for (i=0; i<tam; i++)
     {
         for (j=0; j<tam; j++)
         {printf(" %2d |",arry[j][i]);}
         printf("\n\n");
     }
}//carga
 
void diseno(int arry[][tam])
{
     int i,j;
     for (i=0; i<tam*3+2; i++)
     printf("%c",205);
     printf("\n%c",186);
     for (i=0; i<tam; i++)
     {
         for (j=0; j<tam; j++)
         {
             if (arry[j][i] == -1)
             printf("%c%c%c",48,49,48);
             if (arry[j][i] == 0)
             printf("   ");
             if (arry[j][i] != 0 && arry[j][i] != -1)
             printf(" %c ",15);
             ///if(i == columna && j == fila)
             //printf(" %c ",15);
 
         }
         printf("%c\n%c",186,186);
     }
     for (i=0; i<tam*3+1; i++)
     printf("%c",205);
}
 
void aleatorio(int arry[][tam])
{
     int i, x, y;
     srand(time(NULL));
     for (i=0; i<numero; i++)
     {
         x = rand()%tam;
         y = rand()%tam;
         if(x != columna || y != fila)
         arry[x][y] = -1;
 
     }
}//aleatorio
 
void traspaso(int antes[][tam], int despues[][tam])
{
     int j,i;
     for (i=0; i<tam; i++)
     {
         for (j=0; j<tam; j++)
         {
             despues[j][i] = antes[j][i];
         }
     }
}//traspaso
 
void recusividad(int tab[][tam], int tab_aux[][tam],int casilla, int x, int y)
{
     int arrx[]={1,0,-1,0};//movimiento
     int arry[]={0,1,0,-1};
 
     int indice = 0;//vector
     int newx, newy;
 
     while(indice <= 3)
     {
           newx= x+arrx[indice];
           newy= y+arry[indice];
 
           //getchar();
           if ((tab[newx][newy] == 0) && (newx < tam && newx >= 0 && newy < tam && newy >= 0)&& (casilla < optima))
           {
 
               tab[newx][newy] = casilla;
               //system("cls");
               //diseno(tab);
               if (columna == newx && fila == newy)//encontro la solucion
               {
                   system("cls");
                   diseno(tab);
 
 
                   if (casilla < optima)//solo la mejor ruta
                   {
                       traspaso(tab,tab_aux);
                       optima = casilla;
                   }
               }
 
               recusividad(tab,tab_aux,casilla+1,newx,newy);
           }
           indice+=1;
     iter = iter + 1;
     }//while
     tab[x][y]= 0;
}//movimiento
 
 
int main()
{
    int tablero[tam][tam];
    int tablero_aux[tam][tam];
    int j,i;
    carga_tablero(tablero);
    carga_tablero(tablero_aux);
    aleatorio(tablero);
    printf("\n                     SOLUCION  LABERINTO\n");
    diseno(tablero);
    printf("\ncolumna y fila\n");
    scanf("%d%d",&j,&i);
    tablero[j][i]=1;
    recusividad(tablero,tablero_aux,2,j,i);
    diseno(tablero_aux);
 
    return 0;
}
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