Best First Search algorithm in Scheme

Question

Okay this is a homework question, and I just don't have a clue how I suppose to start. Some help and hints will be much appreciated.

I need to use a heuristic function to solve a maze type problem.

Suppose I have a 5x5 grid, and a robot in position (1,5) and my goal is to move the robot to (5,1). Along the way there are few obstacles, say (X,1,3), (X,2,3), (X,5,3), (X,4,2)

Print out the route the robot has gone through.

I'm thinking using the greedy best first search algorithm to find a path for robot to the goal

My problem is, I'm new to scheme have no idea how I should start on solving this kinda problem.

Should I ?

(define grid l w) --define the length and width of the grid ? 

(define robot) --define the initial position

(define goal) --define the goal position 

(define blocks) --define the obstacle blocks

and create a main function (define bestfirstslove)

to solve the problem ?

How can I create a grid ? How should I approach to this problem ? How can I print out the steps the robot travels ?

Help is much appreciated :)

Answer 1

Ok, so the first thing you do is discretize your search space. Using your example of a 5x5 grid, this means you have a total of 25 points your robot can occupy.

Then, you select your search algorithm. You've chosen Greedy Best First Search (GBFS), so let's go with that, but in a real situation you should choose it as per your problem requirements.

GBFS is a simple algorithm and requires the following ( and you'll need most of these modules for any path finding algorithm):

1. A function to list all the neighbors of any node. E.g. in the grid we've specified above, the neighbors are trivially determined (+1,-1 permutations in both directions with some boundary checking and of course, check if it's an obstacle).

2. A data structure to keep track of Open nodes: Open nodes are nodes which are yet to be examined. So in the example code in Wikipedia, you start with the initial position, find its successors (using the above function) and based on a heuristic (you can use the Euclidean or Manhattan distance between the goal and the successor as a heuristic) you add it to the Open "list" - which is better implemented as a priority queue.

3. Your main function: This will essentially start with the initial position (1,5) and find its neighbors and add them to the priority queue based on the Euclidean distance to the goal. Then recurse (i.e. do the same thing as what you did with the initial position) on that list until you find your goal.

So, what you should note about Greedy Best First is you may not have the optimal path, but you're guaranteed termination and a path (if one exists). You should think about other algorithms like A* or Breadth First or Depth First and see what works for your requirements.

Answer 2

Probably related: C#: A-Star is born at CodeProject