Réduire au minimum les étapes définies par une chaîne requises pour atteindre une destination via un point source donné

Minimiser le nombre d'étapes requises par une chaîne pour atteindre une destination à partir d'une source donnée est un problème courant en informatique. Il s’agit de trouver le chemin le plus court d’un point de départ à un point de destination en fonction d’un ensemble de directions. Dans cet article, nous verrons comment résoudre ce problème en C++, fournirons un exemple et discuterons des cas de test.

Énoncé du problème

Étant donné un point de départ (x, y) et une séquence de directions (N, S, E, W) sur un plan 2D, nous devons trouver le chemin le plus court depuis le point de départ jusqu'à un point de destination (x', y' ). Chaque caractère de la chaîne représente la direction dans laquelle nous devons nous déplacer. Par exemple, si la chaîne est « NNSE », alors nous devons nous déplacer de deux pas vers le nord, d’un pas vers le sud et d’un pas vers l’est. Nous ne pouvons nous déplacer que dans les quatre directions cardinales et non en dehors du plan.

Méthode

Pour résoudre ce problème, nous devons effectuer une traversée en largeur d'abord (BFS) du plan bidimensionnel à partir du point de départ. Lors du parcours, pour chaque point visité, nous devons calculer le nombre d'étapes nécessaires pour atteindre ce point. Si un point cible est rencontré pendant le parcours, nous renvoyons le nombre d'étapes nécessaires pour atteindre ce point.

Exemple

Le code C++ suivant implémente la méthode ci-dessus.

#include<bits/stdc++.h>
using namespace std;

int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};

int minSteps(string s, int x, int y) {
   int n = s.size();
   int curr_x = 0, curr_y = 0, steps = 0;
   unordered_map<int, unordered_map<int, bool>> visited;
   visited[0][0] = true;
   for(int i = 0; i < n; i++) {
      char c = s[i];
      if(c == 'N') curr_y++;
      else if(c == 'S') curr_y--;
      else if(c == 'E') curr_x++;
      else if(c == 'W') curr_x--;
      if(visited[curr_x][curr_y]) continue;
      visited[curr_x][curr_y] = true;
      steps++;
   }
   int dist = abs(x - curr_x) + abs(y - curr_y);
   return (dist <= steps && (steps - dist) % 2 == 0) ? steps : -1;
}

int main() {
   string s = "NNSE";
   int x = 2, y = 2;
   int res = minSteps(s, x, y);
   if(res == -1) cout << "Destination cannot be reached\n";
   else cout << "Minimum steps to reach destination: " << res << "\n";
   return 0;
}

Sortie

Destination cannot be reached

Le code ci-dessus accepte une chaîne s représentant la direction et le point de départ (x, y) en entrée. Nous initialisons d'abord le point actuel (curr_x, curr_y) à (0, 0) et le nombre de pas pour atteindre le point actuel (pas) à 0. Nous créons ensuite une carte non ordonnée pour garder une trace des points visités. Nous parcourons la chaîne s et mettons à jour le point actuel et le nombre d'étapes nécessaires pour atteindre ce point en fonction de la direction donnée par le caractère actuel. Nous vérifions si le point actuel a déjà été visité. Si c'est le cas, ignorez-le. Sinon, nous le marquons comme visité et incrémentons le nombre d'étapes pour atteindre le point actuel.

Après avoir parcouru la chaîne, nous calculons la distance entre le point cible et le point actuel. Si la distance entre le point cible et le point actuel est inférieure ou égale au nombre de pas effectués et que la différence entre le nombre de pas effectués et la distance est un nombre pair, alors le nombre de pas effectués est renvoyé sous la forme nombre minimum d'étapes nécessaires pour atteindre la destination. Sinon, nous renvoyons -1, indiquant que la destination ne peut pas être atteinte.

Exemple de cas de test

Considérons un exemple de cas de test pour comprendre comment fonctionne le code ci-dessus -

Entrez

string s = "NNSE";
int x = 2, y = 2;

Dans l'exemple de cas de test, le point de départ est (0,0) et la direction est "NNSE". Le point cible est (2,2). Cependant, si nous suivons la direction donnée, nous n’atteindrons que le point (0,2), pas le point cible. Le point cible (2,2) ne peut donc pas être atteint dans la direction donnée.

Conclusion

Dans cet article, nous avons expliqué comment minimiser le nombre d'étapes nécessaires pour atteindre une destination à partir d'une source donnée en fonction d'une séquence de directions. Nous avons implémenté la solution en C++ à l'aide du parcours BFS et avons fourni un exemple pour illustrer le fonctionnement du code. En suivant les méthodes décrites dans cet article, vous pouvez résoudre efficacement des problèmes similaires en C++.

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!