Hints for TCCO 2005, Qualification 1, 500-Pointer (LandMines)

James S. Plank

Fri Oct 23 11:41:17 EDT 2015
Problem Statement.

The key in this problem is to turn the instance of a problem into a directed graph, where there is a node for each square, and an edge from square a to b if the soldier can walk from square a to b without detecting a sensor in that direction.

Then the problem is to identify all of the squares reachable from the first square and count them. This is a connected component problem, which you solve with depth-first search.

Some of you get confused with the part of the problem statement that says "he will not move onto a square if his sensor beeps when pointed in that direction, unless he has previously visited that square." That doesn't mean that you should put an edge from b to a if there is an edge from a to b. It just says that you can backtrack on your depth first search.

Let's take example zero. Here's the graph:

I'm drawing the mines red, and nodes that you can reach from the starting square yellow. The other nodes are blue. Even though the graph above has edges into the starting node, there are none coming out, so there are no other nodes that you can reach from the starting node. The answer is one.

Here are the other examples. In all of them, you discover the yellow nodes by doing a DFS from the starting node.

Example 1:

Example 2:

Example 3:

Now, how you represent your graph and do the DFS is up to you. If you want to implement adjacency lists in the nodes, you can do that. That may well be the best way to do it. An adjacency matrix will work, because the constraints of the problem are small, but I believe it will make your life harder rather than easier.

You may want to represent a node with a single number -- that way it's easy to store the node on the adjacency list. In fact, were I solving this problem anew, I would probably have two vectors, both of size layout.size()*layout[0].size().

One is of states -- '-' or 'M'. I'll be using this as the visited field of my DFS.
One has adjacency lists -- these are integer vectors.

I'll initialize my states so that states[i] = layout[i/layout[0].size()][i%layout[0].size()].

Then, I'll go through each row and column and add links to the adjacency lists, so that the graph is built.

I'll do a DFS to find the connected component containing node 0. I'll use the states fields for the visited field, changing state to '.' when I visit a node.

Finally, I'll count the '.' states and return the sum.