1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem A ## Arbitrage
Source file: arbitrage.c
Input file: arbitrage.in
Arbitrage is the use of discrepancies in currency exchange rates to transform one unit of a currency into more than one unit of the same currency. For example, suppose that 1 US Dollar buys 0.5 British pound, 1 British pound buys 10.0 French francs, and 1 French franc buys 0.21 US dollar. Then, by converting currencies, a clever trader can start with 1 US dollar and buy 0.5 * 10.0 * 0.21 = 1.05 US dollars, making a profit of 5 percent.
Your job is to write a program that takes a list of currency exchange rates as input and then determines whether arbitrage is possible or not.
The input file will contain one or more test cases. Om the first line of each test case there is an integer *n* (1<=*n*<=30), representing the number of different currencies. The next *n* lines each contain the name of one currency. Within a name no spaces will appear. The next line contains one integer *m*, representing the length of the table to follow. The last *m* lines each contain the name *c*_{i} of a source currency, a real number *r*_{ij} which represents the exchange rate from *c*_{i} to *c*_{j} and a name *c*_{j} of the destination currency. Exchanges which do not appear in the table are impossible.
Test cases are separated from each other by a blank line. Input is terminated by a value of zero (0) for *n*.
### Output Specification
For each test case, print one line telling whether arbitrage is possible or not in the format "Case *case*: Yes" respectively "Case *case*: No".
### Sample Input
3
USDollar
BritishPound
FrenchFranc
3
USDollar 0.5 BritishPound
BritishPound 10.0 FrenchFranc
FrenchFranc 0.21 USDollar
3
USDollar
BritishPound
FrenchFranc
6
USDollar 0.5 BritishPound
USDollar 4.9 FrenchFranc
BritishPound 10.0 FrenchFranc
BritishPound 1.99 USDollar
FrenchFranc 0.09 BritishPound
FrenchFranc 0.19 USDollar
0
### Sample Output
Case 1: Yes
Case 2: No
1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem B ## The Tower of Babylon
Source file: babylon.c
Input file: babylon.in
Perhaps you have heard of the legend of the Tower of Babylon. Nowadays many details of this tale have been forgotten. So now, in line with the educational nature of this contest, we will tell you the whole story:
The babylonians had *n* types of blocks, and an unlimited supply of blocks of each type. Each type-*i* block was a rectangular solid with linear dimensions (*x*_{i}*, y*_{i}*, z*_{i}). A block could be reoriented so that any two of its three dimensions determined the dimensions of the base and the other dimension was the height.
They wanted to construct the tallest tower possible by stacking blocks. The problem was that, in building a tower, one block could only be placed on top of another block as long as the two base dimensions of the upper block were both strictly smaller than the corresponding base dimensions of the lower block. This meant, for example, that blocks oriented to have equal-sized bases couldn't be stacked.
Your job is to write a program that determines the height of the tallest tower the babylonians can build with a given set of blocks.
### Input Specification
The input file will contain one or more test cases. The first line of each test case contains an integer *n*,
representing the number of different blocks in the following data set. The maximum value for *n* is 30.
Each of the next *n* lines contains three integers representing the values *x*_{i}, *y*_{i} and *z*_{i}.
Input is terminated by a value of zero (0) for *n*.
### Output Specification
For each test case, print one line containing the case number (they are numbered sequentially starting from 1) and the height of the tallest possible tower in the format "Case *case*: maximum height = *height*"
### Sample Input
1
10 20 30
2
6 8 10
5 5 5
7
1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
6 6 6
7 7 7
5
31 41 59
26 53 58
97 93 23
84 62 64
33 83 27
0
### Sample Output
Case 1: maximum height = 40
Case 2: maximum height = 21
Case 3: maximum height = 28
Case 4: maximum height = 342
1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem C ## The Circumference of the Circle
Source file: circle.c
Input file: circle.in
To calculate the circumference of a circle seems to be an easy task - provided you know its diameter. But what if you don't?
You are given the cartesian coordinates of three non-collinear points in the plane.
Your job is to calculate the circumference of the unique circle that intersects all three points.
### Input Specification
The input file will contain one or more test cases. Each test case consists of one line containing six real numbers *x*_{1}*,y*_{1}*, x*_{2}*,y*_{2}*,x*_{3}*,y*_{3}, representing the coordinates of the three points. The diameter of the circle determined by the three points will never exceed a million. Input is terminated by end of file.
### Output Specification
For each test case, print one line containing one real number telling the circumference of the circle determined by the three points. The circumference is to be printed accurately rounded to two decimals. The value of pi is approximately 3.141592653589793.
### Sample Input
0.0 -0.5 0.5 0.0 0.0 0.5
0.0 0.0 0.0 1.0 1.0 1.0
5.0 5.0 5.0 7.0 4.0 6.0
0.0 0.0 -1.0 7.0 7.0 7.0
50.0 50.0 50.0 70.0 40.0 60.0
0.0 0.0 10.0 0.0 20.0 1.0
0.0 -500000.0 500000.0 0.0 0.0 500000.0
### Sample Output
3.14
4.44
6.28
31.42
62.83
632.24
3141592.65
1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem D ## Knight Moves
Source file: knight.c
Input file: knight.in
A friend of you is doing research on the *Traveling Knight Problem (TKP)* where you are to find the shortest closed tour of knight moves that visits each square of a given set of *n* squares on a chessboard exactly once. He thinks that the most difficult part of the problem is determining the smallest number of knight moves between two given squares and that, once you have accomplished this, finding the tour would be easy.
Of course you know that it is vice versa. So you offer him to write a program that solves the "difficult" part.
Your job is to write a program that takes two squares *a* and *b* as input and then determines the number of knight moves on a shortest route from *a* to *b*.
### Input Specification
The input file will contain one or more test cases. Each test case consists of one line containing two squares separated by one space. A square is a string consisting of a letter (a-h) representing the column and a digit (1-8) representing the row on the chessboard.
### Output Specification
For each test case, print one line saying "To get from *xx* to *yy* takes *n* knight moves.".
### Sample Input
e2 e4
a1 b2
b2 c3
a1 h8
a1 h7
h8 a1
b1 c3
f6 f6
### Sample Output
To get from e2 to e4 takes 2 knight moves.
To get from a1 to b2 takes 4 knight moves.
To get from b2 to c3 takes 2 knight moves.
To get from a1 to h8 takes 6 knight moves.
To get from a1 to h7 takes 5 knight moves.
To get from h8 to a1 takes 6 knight moves.
To get from b1 to c3 takes 1 knight moves.
To get from f6 to f6 takes 0 knight moves.
1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem E ## Eeny Meeny Moo
Source file: eenymeeny.c
Input file: eenymeeny.in
Surely you have made the experience that when too many people use the Internet simultaneously, the net becomes very, very slow.
To put an end to this problem, the University of Ulm has developed a contingency scheme for times of peak load to cut off net access for some cities of the country in a systematic, totally fair manner. Germany's cities were enumerated randomly from 1 to *n*. Freiburg was number 1, Ulm was number 2, Karlsruhe was number 3, and so on in a purely random order.
Then a number *m* would be picked at random, and Internet access would first be cut off in city 1 (clearly the fairest starting point) and then in every *m*th city after that, wrapping around to 1 after *n*, and ignoring cities already cut off. For example, if *n*=17 and *m*=5, net access would be cut off to the cities in the order [1,6,11,16,5,12,2,9,17,10,4,15,14,3,8,13,7]. The problem is that it is clearly fairest to cut off Ulm last (after all, this is where the best programmers come from), so for a given *n*, the random number *m* needs to be carefully chosen so that city 2 is the last city selected.
Your job is to write a program that will read in a number of cities *n* and then determine the smallest integer *m* that will ensure that Ulm can surf the net while the rest of the country is cut off.
### Input Specification
The input file will contain one or more lines, each line containing one integer *n* with 3 <= *n* < 150, representing the number of cities in the country.
Input is terminated by a value of zero (0) for *n*.
### Output Specification
For each line of the input, print one line containing the integer *m* fulfilling the requirement specified above.
### Sample Input
3
4
5
6
7
8
9
10
11
12
0
### Sample Output
2
5
2
4
3
11
2
3
8
16
1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem F ## Lotto
Source file: lotto.c
Input file: lotto.in
In the German Lotto you have to select 6 numbers from the set {1,2,...,49}. A popular strategy to play Lotto - although it doesn't increase your chance of winning - is to select a subset S containing *k* (*k*>6) of these 49 numbers, and then play several games with choosing numbers only from S. For example, for *k*=8 and S = {1,2,3,5,8,13,21,34} there are 28 possible games: [1,2,3,5,8,13], [1,2,3,5,8,21], [1,2,3,5,8,34], [1,2,3,5,13,21], ... [3,5,8,13,21,34].
Your job is to write a program that reads in the number *k* and the set S and then prints all possible games choosing numbers only from S.
### Input Specification
The input file will contain one or more test cases. Each test case consists of one line containing several integers separated from each other by spaces. The first integer on the line will be the number *k* (6 < *k* < 13). Then *k* integers, specifying the set S, will follow in ascending order. Input will be terminated by a value of zero (0) for *k*.
### Output Specification
For each test case, print all possible games, each game on one line. The numbers of each game have to be sorted in ascending order and separated from each other by exactly one space. The games themselves have to be sorted lexicographically, that means sorted by the lowest number first, then by the second lowest and so on, as demonstrated in the sample output below. The test cases have to be separated from each other by exactly one blank line. Do not put a blank line after the last test case.
### Sample Input
7 1 2 3 4 5 6 7
8 1 2 3 5 8 13 21 34
0
### Sample Output
1 2 3 4 5 6
1 2 3 4 5 7
1 2 3 4 6 7
1 2 3 5 6 7
1 2 4 5 6 7
1 3 4 5 6 7
2 3 4 5 6 7
1 2 3 5 8 13
1 2 3 5 8 21
1 2 3 5 8 34
1 2 3 5 13 21
1 2 3 5 13 34
1 2 3 5 21 34
1 2 3 8 13 21
1 2 3 8 13 34
1 2 3 8 21 34
1 2 3 13 21 34
1 2 5 8 13 21
1 2 5 8 13 34
1 2 5 8 21 34
1 2 5 13 21 34
1 2 8 13 21 34
1 3 5 8 13 21
1 3 5 8 13 34
1 3 5 8 21 34
1 3 5 13 21 34
1 3 8 13 21 34
1 5 8 13 21 34
2 3 5 8 13 21
2 3 5 8 13 34
2 3 5 8 21 34
2 3 5 13 21 34
2 3 8 13 21 34
2 5 8 13 21 34
3 5 8 13 21 34
1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem G ## Matrix Chain Multiplication
Source file: matrix.c
Input file: matrix.in
Suppose you have to evaluate an expression like A*B*C*D*E where A,B,C,D and E are matrices.
Since matrix multiplication is associative, the order in which multiplications are performed is arbitrary. However, the number of elementary multiplications needed strongly depends on the evaluation order you choose.
For example, let A be a 50*10 matrix, B a 10*20 matrix and C a 20*5 matrix.
There are two different strategies to compute A*B*C, namely (A*B)*C and A*(B*C).
The first one takes 15000 elementary multiplications, but the second one only 3500.
Your job is to write a program that determines the number of elementary multiplications needed for a given evaluation strategy.
### Input Specification
Input consists of two parts: a list of matrices and a list of expressions.
The first line of the input file contains one integer *n* (1 <= *n* <= 26), representing the number of matrices in the first part. The next *n* lines each contain one capital letter, specifying the name of the matrix, and two integers, specifying the number of rows and columns of the matrix.
The second part of the input file strictly adheres to the following syntax (given in EBNF):
SecondPart = Line { Line }
Line = Expression
Expression = Matrix | "(" Expression Expression ")"
Matrix = "A" | "B" | "C" | ... | "X" | "Y" | "Z"
### Output Specification
For each expression found in the second part of the input file, print one line containing the word "error" if evaluation of the expression leads to an error due to non-matching matrices. Otherwise print one line containing the number of elementary multiplications needed to evaluate the expression in the way specified by the parentheses.
### Sample Input
9
A 50 10
B 10 20
C 20 5
D 30 35
E 35 15
F 15 5
G 5 10
H 10 20
I 20 25
A
B
C
(AA)
(AB)
(AC)
(A(BC))
((AB)C)
(((((DE)F)G)H)I)
(D(E(F(G(HI)))))
((D(EF))((GH)I))
### Sample Output
0
0
0
error
10000
error
3500
15000
40500
47500
15125
1996/97 ACM International Collegiate Programming Contest
University of Ulm Internal Contest
## Problem H ## Humble Numbers
Source file: number.c
Input file: number.in
A number whose only prime factors are 2,3,5 or 7 is called a *humble* number. The sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, ... shows the first 20 humble numbers.
Write a program to find and print the *n*th element in this sequence.
### Input Specification
The input consists of one or more test cases. Each test case consists of one integer *n* with *1 <= n <= 5842*. Input is terminated by a value of zero (0) for *n*.
### Output Specification
For each test case, print one line saying "The *n*th humble number is *number*.". Depending on the value of *n*, the correct suffix "st", "nd", "rd", or "th" for the ordinal number *n*th has to be used like it is shown in the sample output.
### Sample Input
1
2
3
4
11
12
13
21
22
23
100
1000
5842
### Sample Output
The 1st humble number is 1.
The 2nd humble number is 2.
The 3rd humble number is 3.
The 4th humble number is 4.
The 11th humble number is 12.
The 12th humble number is 14.
The 13th humble number is 15.
The 21st humble number is 28.
The 22nd humble number is 30.
The 23rd humble number is 32.
The 100th humble number is 450.
The 1000th humble number is 385875.
The 5842nd humble number is 2000000000.
**Share with your friends:** |