Labyrinthe 2-BFS

Question:
Avec votre aide, la tête d'ail s'est finalement échappée du labyrinthe, mais la tête d'ail ne s'est pas immergée dans la joie, mais est rapidement revenue à la réflexion, quel est le nombre minimum d'étapes pour s'échapper de ce labyrinthe?
Entrez
deux entiers n et m dans la première ligne du format d'entrée , indiquant qu'il s'agit d'un labyrinthe n × m.
L'entrée suivante est un labyrinthe avec n lignes et m colonnes. Parmi eux, `` S '' signifie la position de la tête d'ail, '' signifie le mur, la tête d'ail ne peut pas passer ''. 'Signifie la route, la tête d'ail peut traverser'. Quatre positions adjacentes à lui-haut, bas, gauche, droite).
Le format de sortie
produit un entier, indiquant le nombre minimum d'étapes pour que la tête d'ail s'échappe du labyrinthe. Si la tête d'ail ne peut pas s'échapper du labyrinthe, elle sort -1.
La plage de données est
1≤n, m≤10.
L'espace supplémentaire à la fin de chaque ligne lors de la sortie, n'affecte pas l'exactitude de la réponse

Exemple d'entrée 1

3 4 
S **. 
.. *. 
*** T

Exemple de sortie 1

-1

Exemple d'entrée 2

3 4 
S **. 
.... 
*** T

Exemple de sortie 2

5 

Code:

#include <iostream> 
#include <queue>
 using  namespace std; 

struct Node 
{ 
    int x, y, step; 
    Noeud ( int xx, int yy, int ss): x (xx), y (yy), étape (ss) {} 
}; 

file d'attente <Node> q;
marque booléenne [ 20 ] [ 20 ];
int n, m, beginx, beginy, endx, endy, step = 0 ; 

carbonisation map [ 20 ] [ 20 ];
int dx [ 5 ] = { 0 , 0 , - 1, 1 };
 int dy [ 5 ] = { -1 , 1 , 0 , 0 };
 // fonction de limite 
bool check ( int r, int c) {
     if (r> = 0 && r <n && c> = 0 && c < m )
         return  true ;
     return  false ;     
} 
void BFS ( int r, int c) {
     // La première étape, place le point de départ dans la file d'attente, définit le nombre d'étapes step = 0 
    q.push (Node (r, c, 0 ) );
     //La deuxième étape consiste à trouver, si la file d'attente n'est pas vide, il y a une chance de trouver 
    tandis que (! Q.empty ()) 
    { 
        // La troisième étape consiste à prendre le bon 
        nœud Node s = q.front ();
         // Si vous le trouvez, vous pouvez quitter 
        if (sx = = endx && s.y == endy) 
        { 
            cout << s.step << endl;
             return ; 
        } else 
        { 
            // Traversée des nœuds enfants 
            pour ( int i = 0 ; i < 4 ; i ++ ) 
            { 
                int newx = s.x + dx [i];
                 int newy = s.y + dy [i]; 

                //Déterminez si le nœud enfant peut passer, s'il peut passer, puis poussez la pile, définissez le 
                if auquel vous accédez (vérifier (newx, newy) &&! Mark [newx] [newy] && map [newx] [newy]! = ' * ' ) 
                { 
                    Mark [newx) ] [newy] = true ; 
                    q.push (Node (newx, newy, s.step + 1 )); 
                } 
            } 
        } 
        q.pop (); 
    } 
    cout << " -1 " << endl;
     return ; 
    
} 
int main () { 
    cin >> n >> m;
     pour ( inti = 0 ; i <n; i ++ ) 
    { 
        cin >> map [i];
        for ( int j = 0 ; j <m; j ++ ) 
        { 
            if (map [i] [j] == ' S ' ) 
            { 
                beginx = i; 
                beginy = j; 
            } else  if (map [i] [j] == ' T ' ) 
            { 
                endx = i; 
                endy = j;
            }            
        } 
    } 
    FSO (beginx, beginy); 
}