将数组转换为节点

Question

Let me start off with saying that I have very basic knowledge of nodes and graphs.

My goal is to make a solver for a maze which is stored as an array. I know exactly how to implement the algorithm for solving (I'm actually implementing a couple of them) but what my problem is, is that I am very confused on how to implement the nodes that the solver will use in each empty cell.

Here is an example array:

char maze[5][9] = 
        "#########",
        "#  #    #",
        "# ## ## #",
        "#     # #",
        "#########"

My solver starts at the top left and the solution (exit) is at the bottom right.

I've read up on how nodes work and how graphs are implemented, so here is how I think I need to make this:

• Starting point will become a node
• Each node will have as property the column and the row number
• Each node will also have as property the visited state
• Visited state can be visited , visited and leads to dead end , not visited
• Every time a node gets visited, every directly adjacent, empty and not visited cell becomes the visited node's child
• Every visited node gets put on top of the solutionPath stack (and marked on the map as '*')
• Every node that led to a dead end is removed from the stack (and marked on the map as '~')

Example of finished maze:

"#########",
"#*~#****#",
"#*##*##*#",
"#****~#*#",
"#########"

Basically my question is, am I doing something really stupid here with my way of thinking (since I am really inexperienced with nodes) and if it is could you please explain to me why? Also if possible provide me other websites to check which implement examples of graphs on real world applications so I can get a better grasp of it.

Answer 1

The answer really depends on what you find most important in the problem. If you're searching for efficiency and speed - you're adding way too many nodes. There's no need for so many.

The efficient method

Your solver only needs nodes at the start and end of the path, and at every possible corner on the map. Like this:

"#########",
"#oo#o  o#",
"# ## ## #",
"#o  oo#o#",
"#########"

There's no real need to test the other places on the map - you'll either HAVE TO walk thru them, or won't have need to even bother testing.

If it helps you - I got a template digraph class that I designed for simple graph representation. It's not very well written, but it's perfect for showing the possible solution.

#include <set>
#include <map>

template <class _nodeType, class _edgeType>
class digraph
{
public:
    set<_nodeType> _nodes;
    map<pair<unsigned int,unsigned int>,_edgeType> _edges;
};

I use this class to find a path in a tower defence game using the Dijkstra's algorithm. The representation should be sufficient for any other algorithm tho.

Nodes can be of any given type - you'll probably end up using pair<unsigned int, unsigned int> . The _edges connect two _nodes by their position in the set.

The easy to code method

On the other hand - if you're looking for an easy to implement method - you just need to treat every free space in the array as a possible node. And if that's what you're looking for - there's no need for designing a graph, because the array represents the problem in a perfect way.

You don't need dedicated classes to solve it this way.

bool myMap[9][5]; //the array containing the map info. 0 = impassable, 1 = passable
vector<pair<int,int>> route; //the way you need to go
pair<int,int> start = pair<int,int>(1,1); //The route starts at (1,1)
pair<int,int> end = pair<int,int>(7,3); //The road ends at (7,3)

route = findWay(myMap,start,end); //Finding the way with the algorithm you code

Where findWay has a prototype of vector<pair<int,int>> findWay(int[][] map, pair<int,int> begin, pair<int,int> end) , and implements the algorithm you desire. Inside the function you'll probably need another two dimensional array of type bool, that indicates which places were tested.

When the algorithm finds a route, you usually have to read it in reverse, but I guess it depends on the algorithm.

In your particular example, myMap would contain:

bool myMap[9][5] = {0,0,0,0,0,0,0,0,0,
                    0,1,1,0,1,1,1,1,0,
                    0,1,0,0,1,0,0,1,0,
                    0,1,1,1,1,1,0,1,0,
                    0,0,0,0,0,0,0,0,0};

And findWay would return a vector containing (1,1),(1,2),(1,3),(2,3),(3,3),(4,3),(4,2),(4,1),(5,1),(6,1),(7,1),(7,2),(7,3)