### Problem Set #4

#### Due: 3pm, Nov 10th, 2008

1. Text problem 3.8.

2. Text problem 3.24. Justify the correctness and running time of your algorithm. (Note that it says dag and not digraph. If we ask the same problem about a digraph, there is no known polynomial-time algorithm!)

3. A chain of words is a list of words where the i-th word is the (i-1)st word with one extra character and some mixing of letters. For example, AN, TAN, RANT, TRAIN, RETINA, NASTIER is a chain of length 6. Find the longest chain you can in our wordlist.

In order to do this, first build a dag. The dag will consist of a node for each word (you might want to collapse words into a single node when it makes sense to), and an edge from word x to word y if y can follow x in a chain. Then run DFS from each source node in the dag and keep track of the maximum depth you reach. Print out the list of words you find.

4. Text problem 4.11.

5. You are given two hour glasses. They measure M and N minutes respectively. You wish to use these two hour glasses to measure a target period of T minutes. Each hour glass consists of two glass bowls connected by a narrow section (the ``narrows") where sand can flow from one bowl into the other. If all of the sand is in the lower bowl and the hour glass is turned upside down (``flipped"), the sand will flow into the other bowl (which is now the lower bowl) in M or N minutes, respectively.

Initially (at time = 0), all of the sand is in the lower bowl in each of the hour glasses, and both hour glasses are flipped. Subsequently, one can flip one or both of the hour glasses according to the following rules.

1. When only one of the hour glasses expires at a particular instant, one has four choices of action:

1. flip the hour glass that expired;
2. flip the hour glass that did not expire;
3. flip both hour glasses;
4. do not flip either one, just let one hour glass sit idle until the other one expires.

2. When both of the hour glasses happen to expire simultaneously, or if one hour glass has been sitting idle and the other one has just expired, one must flip at least one of the hour glasses.
3. Any hour glass may be flipped only at an instant when either the same hour glass, or the other one, or both have just expired.

A particular time T can be measured if there is a sequence of hour glass flips such that one (or both) of the hour glasses expires at time T during the sequence. You may assume that flipping an hour glass is instantaneous and does not take any time.

## Input

The input consists of a number of lines, each representing one instance of the problem. Each line contains three positive integers which represent the values of M , N , and T . You may assume that 2 <= M < N <= 200 and N <= T <= 2000. The input is terminated by a line containing three zeroes.

## Output

For each instance of the problem, print the shortest sequence of flips which measures the target time T . For each flip, print on a single line the time, followed by a colon and a space, followed by the capacities of the hour glasses to be flipped (separated by a comma if both are flipped). The sequence of flips should be printed in chronological order. If there are multiple shortest sequences, any one is acceptable. If it is impossible to measure the target time T , print `Impossible!' on a single line. The output for each instance of the problem should be followed by a line consisting of ten hyphens.

```
4 17 21
4 17 22
8 13 23
0 0 0
```

## Sample Output

```
0: 4,17
17: 4,17
----------
0: 4,17
4: 4
8: 4
12: 4
16: 4
17: 4
18: 4,17
----------
0: 8,13
8: 8
13: 8,13
18: 8,13
----------
```

This is similar to the homework problem (Text Problem 3.8) where you had to build a graph representing the contents of three containers and 11 pints of water. Except here you have to solve the problem in the fewest number of steps. This is a red flag that BFS is indicated instead of just DFS.

To solve this problem, take an approach similar to what you did for Text Problem 3.8: build a graph where the root is the starting state (both hourglasses pouring sand). Then make an arc to all states that can be legally reached from there by an hourglass-flip.

It's best to build the graph dynamically instead of building it in advance: just create the nodes as you run BFS. If you reach the target time, you have to print the path in the graph that got you there. If you pass the target time, you print "Impossible!". The best way to detect when no solution is possible is to simply avoid enqueuing any nodes whose time value exceeds the target time. If the queue comes up empty and you haven't hit the target, you know there is no solution.

Hand in your code in hardcopy along with sample runs for these test cases:

```4 17 21
4 17 22
8 13 23
171 177 1846
173 194 746
144 187 1186
157 198 378
33 127 1250
168 197 1487
176 187 1776
130 180 1998
177 195 694
172 188 1161
85 193 924
0 0 0
```

Feel free to consult with your fellow students on the answers you're getting to these test cases. Or ask Neeti or me what we got for a given test case if you're feeling worried that something's wrong.

6. Text problem 5.3.

7. Text problem 5.14.

8. Text problem 5.34.