Programme C++ pour trouver le nombre de sauts requis par un robot pour atteindre une cellule spécifique dans une grille

Supposons que nous ayons une grille de h x w. La grille est représentée dans un tableau bidimensionnel appelé « initGrid », où chaque cellule de la grille est représentée par un « # » ou un « . ». '#' signifie qu'il y a un obstacle dans la grille, '.' signifie qu'il y a un chemin sur cette cellule. Maintenant, un robot est placé sur une cellule « c » de la grille, qui porte le numéro de ligne x et le numéro de colonne y. Le robot doit se déplacer d'une cellule « d » avec le numéro de ligne p et le numéro de colonne q vers une autre cellule. Les coordonnées de cellule c et d sont toutes deux données sous forme de paires d'entiers. Désormais le robot peut se déplacer d'une cellule à l'autre comme suit :

• Si la cellule vers laquelle le robot souhaite se déplacer est située verticalement ou horizontalement à côté de la cellule actuelle, le robot peut marcher directement d'une cellule à l'autre.

• Le robot peut sauter vers n'importe quelle cellule dans une zone 5x5 centrée sur son emplacement actuel.

• Le robot ne peut se déplacer que vers une autre cellule de la grille qui ne contient pas d'obstacles. Le robot ne peut pas non plus quitter la grille.

Nous devons connaître le nombre de sauts nécessaires au robot pour atteindre la cible.

Donc, si l'entrée est h = 4, w = 4, c = {2, 1}, d = {4, 4}, initGrid = {"#...", ".##.", ".. .#", "..#."}, alors la sortie sera 1. Le robot n'a besoin que d'un seul saut pour atteindre sa destination.

Pour résoudre ce problème, nous suivrons les étapes suivantes :

N:= 100
Define intger pairs s and t.
Define an array grid of size: N.
Define an array dst of size: N x N.
Define a struct node that contains integer values a, b, and e.
Define a function check(), this will take a, b,
   return a >= 0 AND a < h AND b >= 0 AND b < w
Define a function bfs(), this will take a, b,
   for initialize i := 0, when i < h, update (increase i by 1), do:
   for initialize j := 0, when j < w, update (increase j by 1), do:
      dst[i, j] := infinity
   dst[a, b] := 0
   Define one deque doubleq
   Insert a node containing values {a, b, and dst[a, b]} at the end of doubleq
   while (not doubleq is empty), do:
      nd := first element of doubleq
      if e value of nd > dst[a value of nd, b value of nd], then:
         Ignore the following part, skip to the next iteration
   for initialize diffx := -2, when diffx <= 2, update (increase diffx by 1), do:
   for initialize diffy := -2, when diffy <= 2, update (increase diffy by 1), do:
      tm := |diffx + |diffy||
      nx := a value of nd + diffx, ny = b value of nd + diffy
      if check(nx, ny) and grid[nx, ny] is same as &#39;.&#39;, then:
         w := (if tm > 1, then 1, otherwise 0)
         if dst[a value of nd, b value of nd] + w < dst[nx, ny], then:
            dst[nx, ny] := dst[a value of nd, b value of nd] + w
            if w is same as 0, then:
               insert node containing values ({nx, ny, dst[nx, ny]}) at the beginning of doubleq.
          Otherwise
insert node containing values ({nx, ny, dst[nx, ny]}) at the end of doubleq.
s := c
t := d
(decrease first value of s by 1)
(decrease second value of s by 1)
(decrease first value of t by 1)
(decrease second value of t by 1)
for initialize i := 0, when i < h, update (increase i by 1), do:
grid[i] := initGrid[i]
bfs(first value of s, second value of s)
print(if dst[first value of t, second value of t] is same as infinity, then -1, otherwise dst[first value of t, second value of t])

Exemple

Voyons l'implémentation ci-dessous pour mieux comprendre −

#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
#define N 100
int h, w;
pair<int, int> s, t;
string grid[N];
int dst[N][N];
struct node {
   int a, b, e;
};
bool check(int a, int b) {
   return a >= 0 && a < h && b >= 0 && b < w;
}
void bfs(int a, int b) {
   for (int i = 0; i < h; i++) {
      for (int j = 0; j < w; j++)
         dst[i][j] = INF;
   }
   dst[a][b] = 0;
   deque<node> doubleq;
   doubleq.push_back({a, b, dst[a][b]});

   while (!doubleq.empty()) {
      node nd = doubleq.front();
      doubleq.pop_front();
      if (nd.e > dst[nd.a][nd.b])
         continue;
      for (int diffx = -2; diffx <= 2; diffx++) {
         for (int diffy = -2; diffy <= 2; diffy++) {
            int tm = abs(diffx) + abs(diffy);
            int nx = nd.a + diffx, ny = nd.b + diffy;
            if (check(nx, ny) && grid[nx][ny] == &#39;.&#39;) {
               int w = (tm > 1) ? 1 : 0;
               if (dst[nd.a][nd.b] + w < dst[nx][ny]) {
                  dst[nx][ny] = dst[nd.a][nd.b] + w;
                  if (w == 0)
                     doubleq.push_front({nx, ny, dst[nx][ny]});
                  else
                     doubleq.push_back({nx, ny, dst[nx][ny]});
               }
            }
         }
      }
   }
}
void solve(pair<int,int> c, pair<int, int> d, string initGrid[]){
   s = c;
   t = d;
   s.first--, s.second--, t.first--, t.second--;
   for(int i = 0; i < h; i++)
      grid[i] = initGrid[i];
   bfs(s.first, s.second);
   cout << (dst[t.first][t.second] == INF ? -1 :
      dst[t.first][t.second]) << &#39;\n&#39;;
}
int main() {
   h = 4, w = 4;
   pair<int,int> c = {2, 1}, d = {4, 4};
   string initGrid[] = {"#...", ".##.", "...#", "..#."};
   solve(c, d, initGrid);
   return 0;
}

Input

4, 4, {2, 1}, {4, 4}, {"#...", ".##.", "...#", "..#."}

Output

1

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!