Path planning using 2D array - c++

Question

The problem require user input the size of 2D grid. Then input each of the entries.
Like this:
5 5
-1 -1 -1 -1 -1
-1 0 0 0 -1
-1 1 -1 0 -1
-1 0 0 -2 -1
-1 -1 -1 -1 -1
Then the output should be 3. Which is the smallest path from the starting point " 1 " to end point "-2". Where the " -1 " are the obstacle, 0 as a feasible space.
The method given by the instructor is:
first, locate the starting point " 1 " . The filling its feasible space 4-neighbours ( left, right, up and down) with " 2 "
Then, repeat the steps by filling the neighbours feasible space by " 3 " and so on.
When the possible feasible space is " -2 ". Stop and print out the minimum steps number.
I will try to write it out.
Find the starting point.
-1 -1 -1 -1 -1
-1 0 0 0 -1
-1 **1** -1 0 -1
-1 0 0 -2 -1
-1 -1 -1 -1 -1
Replace it neighbours "0" by " 2 " and find the other possible feasible space.
-1 -1 -1 -1 -1
-1 **2** **0** 0 -1
-1 1 -1 0 -1
-1 **2** **0** -2 -1
-1 -1 -1 -1 -1
Repeat the steps.
-1 -1 -1 -1 -1
-1 2 3 **0** -1
-1 1 -1 0 -1
-1 2 3 **-2** -1
-1 -1 -1 -1 -1
As the neighbour is " -2 " . So the shortest path is 3.
// Find the Starting point " 1 ".
#include <iostream>
using namespace std;
const int MAX_SIZE = 100;
///////// DO NOT MODIFY ANYTHING ABOVE THIS LINE /////////
// IMPORTANT: Do NOT change any of the function headers already provided to you
// It means that you will need to use the function headers as is
// You may implement additional functions here
bool NextFill(int(&map)[MAX_SIZE][MAX_SIZE], int n)
{
const int offx = { -1, 0, 0, 1 };
const int offy = { 0, -1, 1, 0 }
bool found = false;
for (int x = 0; x != MAX_SIZE; ++x) {
for (int y = 0; y != MAX_SIZE; ++y) {
if (map[x][y] == n) {
for (int i = 0; i != 4) {
auto& neighbor = map[x + offx[i]][y + offy[i]];
if (neighbor == -1) { }
else if (neighbor == -2) { found = true; }
else if (neighbor == 0) { neighbor = n + 1; }
}
}
}
}
return found;
}
// Function: find the smallest number of steps to go from the starting point
// to the destination in a given map.
//
// Input: int map[][]: 2D-array map
// int map_h: the height of the map
// int map_w: the width of the map
// Output: return true if a path is found, and store the smallest number of
// steps taken in &num_steps (pass-by-reference)
// return false if there is no path
// ==============================================================
bool FindPath(int map[][MAX_SIZE], int map_h, int map_w, int& num_steps)
{
// ==========================
int time = 0;
if (NextFill(map, time))
return true;
else
return false;
}
///////// DO NOT MODIFY ANYTHING BELOW THIS LINE /////////
// Function: main function
// ==============================================================
int main()
{
int map_h;
int map_w;
cin >> map_h >> map_w;
int map[MAX_SIZE][MAX_SIZE];
// initialize map
for (int i = 0; i < MAX_SIZE; i++)
for (int j = 0; j < MAX_SIZE; j++)
map[i][j] = -1;
// read map from standard input
for (int i = 0; i < map_h; i++)
for (int j = 0; j < map_w; j++)
cin >> map[i][j];
int steps;
// print to screen number of steps if a path is found, otherwise print "No"
if (FindPath(map, map_h, map_w, steps))
cout << steps << endl;
else
cout << "No" << endl;
}
My code can find the starting point and find its possible feasible space as well as replace it by " 2 ". But i have no idea of find the possible feasible space of mine " 2 " and replace it by " 3 " and so on.
However, I can't include any header in my program.
Thanks for reading a long long question :)!

Answer 1

You have either to store in some queue your open nodes, or fill from whole map each time:
bool NextFill(int (&map)[MAX_SIZE][MAX_SIZE], int n)
{
const int offx = {-1, 0, 0, 1};
const int offy = {0, -1, 1, 0}
bool found = false;
for (int x = 0; x != MAX_SIZE; ++x) {
for (int y = 0; y != MAX_SIZE; ++y) {
if (map[x][y] == n) {
for (int i = 0; i != 4) {
auto& neighbor = map[x + offx[i]][y + offy[i]];
if (neighbor == -1) { /*Nothing*/ } // wall
else if (neighbor == -2) { found = true; } // Found
else if (neighbor == 0) { neighbor = n + 1; } // unvisited
// else {/*Nothing*/} // Already visited.
}
}
}
}
return found;
}