Problem D. Dragon Maze
Small input 8 points | |
Large input 12 points |
Problem
You are the prince of Dragon Kingdom and your kingdom is in danger of running out of power. You must find power to save your kingdom and its people. An old legend states that power comes from a place known as Dragon Maze. Dragon Maze appears randomly out of nowhere without notice and suddenly disappears without warning. You know where Dragon Maze is now, so it is important you retrieve some power before it disappears.
Dragon Maze is a rectangular maze, an N x M grid of cells. The top left corner cell of the maze is (0,0) and the bottom right corner is (N-1, M-1). Each cell making up the maze can be either a dangerous place which you never escape after entering, or a safe place that contains a certain amount of power. The power in a safe cell is automatically gathered once you enter that cell, and can only be gathered once. Starting from a cell, you can walk up/down/left/right to adjacent cells with a single step.
Now you know where the entrance and exit cells are, that they are different, and that they are both safe cells. In order to get out of Dragon Maze before it disappears, you must walk from the entrance cell to the exit cell taking as few steps as possible. If there are multiple choices for the path you could take, you must choose the one on which you collect as much power as possible in order to save your kingdom.
Input
The first line of the input gives the number of test cases, T. T test cases follow.
Each test case starts with a line containing two integers N and M, which give the size of Dragon Maze as described above. The second line of each test case contains four integers enx, eny, exx, exy, describing the position of entrance cell (enx, eny) and exit cell (exx, exy). Then N lines follow and each line has M numbers, separated by spaces, describing the N x M cells of Dragon Maze from top to bottom. Each number for a cell is either -1
, which indicates a cell is dangerous, or a positive integer, which indicates a safe cell containing a certain amount of power.
Output
For each test case, output one line containing "Case #x: y", where x is the case number (starting from 1). If it's possible for you to walk from the entrance to the exit, y should be the maximum total amount of power you can collect by taking the fewest steps possible. If you cannot walk from the entrance to the exit, y should be the string "Mission Impossible." (quotes for clarity). Please note that the judge requires an exact match, so any other output like "mission impossible." or "Mission Impossible" (which is missing the trailing period) will be judged incorrect.
Limits
The amount of power contained in each cell will not exceed 10,000.
1 ≤ T ≤ 30.
0 ≤ enx, exx < N.
0 ≤ eny, exy < M.
Small dataset
1 ≤ N, M ≤ 10.
Large dataset
1 ≤ N, M ≤ 100.
Sample
Input |
Output |
2 2 3 0 2 1 0 2 -1 5 3 -1 6 4 4 0 2 3 2 -1 1 1 2 1 1 1 1 2 -1 -1 1 1 1 1 1 |
Case #1: Mission Impossible. Case #2: 7 |
Small input 7 points | |
Large input 10 points |
Problem
Good programmers write fabulous comments. Igor is a programmer and he likes the old C-style comments in /* ... */
blocks. For him, it would be ideal if he could use this style as a uniform comment format for all programming languages or even documents, for example Python, Haskell or HTML/XML documents.
Making this happen doesn't seem too difficult to Igor. What he will need is a comment pre-processor that removes all the comment blocks in /*
, followed by comment text, and by another */
. Then the processed text can be handed over to the compiler/document renderer to which it belongs—whatever it is.
Igor's pre-processor isn't quite that simple, though. Here are some cool things it does:
printf("Hello /* a comment /* a comment inside comment */ inside /* another comment inside comment */ string */ world");After the pre-process step, it becomes:
printf("Hello world");
"/*...*/"
, a constant number 12/*...*/34
or even in a character escape \/*...*/n
Or more formally:
text: text-piece text-piece remaining-text text-piece: char-sequence-without-/* empty-string remaining-text: comment-block text comment-block: /* comment-content */ comment-content: comment-piece comment-piece remaining-comment comment-piece: char-sequence-without-/*-or-*/ empty-string remaining-comment: comment-block comment-content char: letters digits punctuations whitespaces
Our pre-processor, given a text
, removes all comment-block
instances as specified.
Notes
//*no recursion*/* file header */should generate:
/* file header */
*
character in any /*
or /*
cannot be re-used in another /*
or */
. For example the following does NOT form a proper comment block
/*/
Input
A text document with comment blocks in /*
and */
. The input file is valid. It follows the specification of text
in the problem statement. The input file always terminates with a newline symbol.
Output
We only have one test case for this problem. First we need to output the following line.
Case #1:Then, print the document with all comments removed, in the way specified in the problem statements. Don't remove any spaces or empty lines outside comments.
Limits
The input program contains only:
a-z, A-Z,
0-9
~ ! @ # % ^ & * ( ) - + = : ; " ' < > , . ? | / \ { } [ ] _
Small dataset
The small input contains a program of less than 2k bytes.
Large dataset
The large input contains a program of less than 100k bytes.
Sample
Input |
|
//*no recursion*/* file header ***********/************ * Sample input program * **********/************* */ int spawn_workers(int worker_count) { /* The block below is supposed to spawn 100 workers. But it creates many more. Commented until I figure out why. for (int i = 0; i < worker_count; ++i) { if(!fork()) { /* This is the worker. Start working. */ do_work(); } } */ return 0; /* successfully spawned 100 workers */ } int main() { printf("Hello /*a comment inside string*/ world"); int worker_count = 0/*octal number*/144; if (spawn_workers(worker_count) != 0) { exit(-1); } return 0; } |
|
|
|
Output
|
|
Case #1: /* file header ************************ */ int spawn_workers(int worker_count) { return 0; } int main() { printf("Hello world"); int worker_count = 0144; if (spawn_workers(worker_count) != 0) { exit(-1); } return 0; } |