로봇이 그리드의 특정 셀에 도달하기 위해 필요한 점프 횟수를 찾는 C++ 프로그램

h x w의 그리드가 있다고 가정합니다. 그리드는 'initGrid'라는 2차원 배열로 표시되며 그리드의 각 셀은 '#' 또는 '.'으로 표시됩니다. '#'은 그리드에 장애물이 있음을 의미하고, '.'은 해당 셀에 경로가 있음을 의미합니다. 이제 로봇은 행 번호 x와 열 번호 y가 있는 그리드의 'c' 셀에 배치됩니다. 로봇은 행 번호가 p이고 열 번호가 q인 셀 'd'에서 다른 셀로 이동해야 합니다. 셀 좌표 c와 d는 모두 정수 쌍으로 제공됩니다. 이제 로봇은 다음과 같이 한 셀에서 다른 셀로 이동할 수 있습니다.

• 로봇이 이동하려는 셀이 현재 셀과 수직 또는 수평으로 인접해 있는 경우 로봇은 한 셀에서 다른 셀로 직접 걸어갈 수 있습니다.

• 로봇은 현재 위치를 중심으로 5x5 영역의 모든 셀로 점프할 수 있습니다.

• 로봇은 장애물이 없는 그리드의 다른 셀로만 이동할 수 있습니다. 로봇도 그리드를 떠날 수 없습니다.

로봇이 목표에 도달하는 데 걸리는 홉 수를 알아내야 합니다.

그러므로 입력이 h = 4, w = 4, c = {2, 1}, d = {4, 4}, initGrid = {"#...", ".##.", ".. .#", "..#."}이면 출력은 1이 됩니다. 로봇은 목적지에 도달하기 위해 한 번의 점프만 하면 됩니다.

이 문제를 해결하기 위해 다음 단계를 따릅니다.

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])

Example

더 나은 이해를 위해 아래 구현을 살펴보겠습니다. −

#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

위 내용은 로봇이 그리드의 특정 셀에 도달하기 위해 필요한 점프 횟수를 찾는 C++ 프로그램의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!