Computer Science/61b/Homework/hw9

Contents

Files

• /Maze.java
• /MazeTest.java
• /Wall.java
• /set package
• /GRADER

Description

                             CS 61B  Homework 9
                     Due 4pm Monday, November 27, 2006

Part I (8 points)

Edit the file Maze.java and complete the implementation of the Maze constructor. Use our disjoint sets data structure to create a random rectangular maze. Your random mazes should have two properties: there is a path from any given cell to any other cell, and there are no cycles (loops)-- in other words, there is only one path from any given cell to any other cell.

Each maze is an h-by-v grid of square cells (where h is the number of cells in the horizontal direction, and v is the number of cells in the vertical direction). The cell in the upper left corner is numbered (0, 0). The cell to its right is numbered (1, 0). The cell below the upper left cell is numbered (0, 1).

There are vertical walls and horizontal walls separating adjacent cells. Each interior horizontal wall has the same numbering as the cell immediately above it. Each interior vertical wall has the same numbering as the cell to its immediate left. Hence, horizontal wall (i, j) separates cell (i, j) from cell (i, j + 1), and vertical wall (i, j) separates cell (i, j) from cell (i + 1, j). Here is a depiction of a 6-by-3 grid.

  +-----------+-----------+-----------+-----------+-----------+-----------+
  |           |           |           |           |           |           |  
  |           |           |           |           |           |           |  
  |   (0,0) (0,0) (1,0) (1,0) (2,0) (2,0) (3,0) (3,0) (4,0) (4,0) (5,0)   |
  |           |           |           |           |           |           |  
  |           |           |           |           |           |           |  
  +---(0,0)---+---(1,0)---+---(2,0)---+---(3,0)---+---(4,0)---+---(5,0)---+
  |           |           |           |           |           |           |  
  |           |           |           |           |           |           |  
  |   (0,1) (0,1) (1,1) (1,1) (2,1) (2,1) (3,1) (3,1) (4,1) (4,1) (5,1)   |
  |           |           |           |           |           |           |  
  |           |           |           |           |           |           |  
  +---(0,1)---+---(1,1)---+---(2,1)---+---(3,1)---+---(4,1)---+---(5,1)---+
  |           |           |           |           |           |           |  
  |           |           |           |           |           |           |  
  |   (0,2) (0,2) (1,2) (1,2) (2,2) (2,2) (3,2) (3,2) (4,2) (4,2) (5,2)   |
  |           |           |           |           |           |           |  
  |           |           |           |           |           |           |  
  +-----------+-----------+-----------+-----------+-----------+-----------+

Note that there is an h-by-(v-1) set of horizontal walls, and an (h-1)-by-v set of vertical walls. In your maze, some of these walls will be present and some will be missing. The walls present are indicated by the arrays hWalls and vWalls, which are an h-by-(v-1) boolean array and an (h-1)-by-v boolean array, respectively. (Exterior walls are numbered according to the same system, but there is no explicit storage for them, because they are presumed to always be present.)

The Maze constructor currently creates a "maze" in which every possible wall is present. To make a proper maze, you will need to eliminate walls selectively. Do so as follows.

1. Create a disjoint sets data structure in which each cell of the maze is represented as a separate item. Use the DisjointSets class (described in the Lecture 33 notes), which is in the set package we've provided.
2. Order the interior walls of the maze in a random order.

   One way to do this is to create an array in which every wall (horizontal and vertical) is represented. (How you represent each wall is up to you.) Scramble the walls by reodering them into a random permutation. Each possible permutation (ordering) of walls should be equally likely.

   Here's how to do that. Put all the walls into the array. The idea is to randomly choose (from all the walls) the wall that will be at the end of the array. Swap it to the end, then never move it again. From the remaining walls, choose the wall that will come second-last. Swap it to its final position, then never move it again. Repeat until you've chosen a wall for each slot in the array.

   Here's an algorithmic rephrasing of what I just said. Maintain a counter w, initially set to the number of walls. Iterate the following procedure: select one of the first w walls in the array at random, and swap it with the wth wall in the array (at index w - 1). This permanently establishes the randomly chosen wall as the wth wall. Then decrease w by one. Repeat this operation until w is one.

3. Visit the walls in the (random) order they appear in in the array. For each wall you visit:
   1. Determine which cell is on each side of the wall.
   2. Determine whether these two cells are members of the same set in the disjoint sets data structure. If they are, then there is already a path between them, so you must leave the wall intact to avoid creating a cycle.
   3. If the cells are members of different sets, eliminate the wall separating them (thereby creating a path from any cell in one set to any cell in the other) by setting the appropriate element of hWalls or vWalls to false. Form the union of the two sets in the disjoint sets data structure.

When you have visited every wall once, you have a finished maze!

Be forewarned that the DisjointSets class has no error checking, and will fail catastrophically if you union() vertices that are not roots of their respective sets, or if you union() a set with itself. You may want to add error checking to DisjointSets.java to help you find your bugs, and/or augment union() so it always calls find() on both inputs first. This error checking can help you with Project 3 as well.

All the other methods you need, including test methods, are provided for you.

 toString() converts the maze to a string so you can print it.
 randInt(c) generates a random number from 0 to c - 1, and is provided to
     help you write the Maze() constructor.  To keep the mazes interesting, it
     generates a different sequence of random numbers each time you run the
     program.
 diagnose() tests your maze for cycles or unreachable cells using depth-first
     search.  DON'T CHANGE IT.  YOUR CODE MUST WORK WITH OUR COPY OF THIS
     METHOD.
 main() generates a maze (using your constructor), prints it, and tests it.

diagnose() depends on the following two methods, so don't make changes that will prevent these from working:

 horizontalWall(x, y) determines whether a horizontal wall is intact.
 verticalWall(x, y) determines whether a vertical wall is intact.

You may see how you're doing by compiling and running Maze.java. To look at a 30 x 10 maze, run:

 java Maze 30 10

The default dimensions, if you don't specify any on the command line, are 39 x 15. �

Part II (2 points)

You have probably noticed the similarity between your maze and a graph data structure. Think of the cells of the maze as vertices of a graph. Two adjacent cells are connected by an edge if there is no wall separating them. Our diagnose() method uses depth-first search to test your maze.

If the depthFirstSearch() method ever examines an "edge" and discovers a cell that has already been visited, then there is a cycle in the maze. (The depth- first search implementation used here never walks back over an edge it's just traversed, so it won't look back and mistakenly diagnose a cycle.) If some cell is not visited at all, then it is not reachable from the cell where the search started. Hence, depth-first search can diagnose both potential deficiencies of a bad maze: having more than one path between two cells, or having no path between two cells. (You may want to look at the diagnose() and depthFirstSearch() methods to see how this is done.)

In your /GRADER file, suggest (in simple English) how you could use depth-first search to generate a random maze (or more importantly, lots of different random mazes), without using disjoint sets at all.

1. How would your algorithm ensure that there is a path between every pair of cells, but no more than one path between any pair of cells (i.e., no cycles)?
2. How does your algorithm use random numbers to generate a different maze each time? Specifically, what decision should be made by random numbers at each recursive invocation of the depth-first search method?

These questions can be answered with just a few sentences.