Recursion in a Tree-like Structure

Question

As a school project I have to find the solution path in a maze using the backtracking method recursively, I usually have no problem solving algorithms with recursion, on linear problems, however when it comes of having multiple choices/paths to follow I don't know how to find only 1 solution.

Problem parameters:

• A maze represented in a matrix which has multiple ways of getting to the same end point
• The starting point

Language used:

• F#

Output of the code:

████████████████████
█     █           ██
█ ███ ███ █████ █ ██
█   █   █   █   █ ██
█ █ █ █ █ █ █ ███ ██
█     █Sxxxx  █   ██
█ █████ █ █x███ █ ██
█     █   █xxx█   ██
█ █ █ ███████x██████
█ █ █   █   █x    ██
█ █ ███ █ █ █x███ ██
█   █   █ █  x█   ██
█ ███ ███ █ █x█ █ ██
█            x█   ██
███ █████████x███ ██
███ █     █xxx█ █ ██
███ █ █ █ █x███ █ ██
███   █ █xxx█     ██
█████████x██████████
█████████E██████████

#: Walls
 : Paths
E: End Point
S: Start Point

Portion of the code:

let rec dfs(x,y,path,visited) =
        let rec checkVisited point visited = 
            match visited with
            | [] -> false
            | (x,y)::xs -> if point = (x,y) then true else checkVisited point xs
        let adjacents = [(x,y+1);(x+1,y);(x,y-1);(x-1,y)]
        for point in adjacents do
            if point = this.endPoint then
                this.solutionPath <- path
            else
                if checkVisited point visited = false && this.checkPoint point && this.isWall point = false then
                    dfs(fst(point),snd(point),(path@[point]),(visited@[(x,y)]))

This is another way (mooore optimized) of searching the solution in a maze

let rec dfs(x,y,path) =
            // setting the point in the matrix visited (setting it to 'false')
            matrix.[y].[x] <- (fst(matrix.[y].[x]),false)
            // getting the adjacents of the point
            let adjacents = [(x,y+1);(x+1,y);(x,y-1);(x-1,y)]
            // iterate the adjacents
            for (x1,y1) in adjacents do
                // if the adjacent is the end point set the soultion path
                if (x1,y1) = this.endPoint then
                    this.solutionPath <- path
                else
                    // else check if the point is in the matrix and is not yet visited
                    if this.checkPoint(x1,y1) && snd(matrix.[y1].[x1]) <> false && this.isWall(x1,y1) = false then
                        // execute recursively the method in the point and add the current poisition to the path
                        dfs(x1,y1,((x1,y1)::path))
        dfs(x,y,[])

I have made it! if you have any troubles doing this i will help you (even in other languages)!

Answer 1

Your current approach looks mostly okay. But because you're doing a depth first search the main issue you have is that there's nothing preventing you from getting stuck trying an infinitely long paths like [(1,1);(1,2);(1,1);...] instead of getting to more productive paths. To avoid this you can either scan the path to see if the proposed next point is already in it (which takes time at most linear in the length of the list which may be fine for small problem sizes), or pass the set of visited points as an extra argument to the recursive function (which should allow faster membership queries).

The other issue you have is that you don't have any way of combining the results of the different branches you could take. One simple approach is to change the return type of your inner function to be an option type, and to return Some(path) from the top if and rewrite the else to something more like

[x, y+1
 x, y-1
 x+1, y
 x-1, y]
|> List.tryPick (fun (x',y') -> if this.checkPoint(x',y') then 
                                    sol(x', y', (x,y)::path)
                                else None)

This is recursively attempting each possible direction in turn and returning whatever the first successful one is. This will not necessarily return the shortest path because it's a depth-first search. You could also easily create a variant that returns a list of all possible paths instead of using an option (the biggest change would be using List.collect instead of List.tryPick), in which case you could choose the shortest solution from the list if you wanted to, although this would do a lot of intermediate computation.

A more involved change would be to switch to a breadth-first search instead of depth-first, which would let you return a shortest path very easily. Conceptually, here's how one approach to that would be to keep track of a shortest path to all "seen" points (starting with just [S,[]], along with a set of points whose children have not yet been explored (again starting with just [S]). Then, as long as there are points to explore, collect all of their distinct children; for each one that doesn't yet have a known path, add the path and put it in the next set of children to explore.