| Ethan is doing his second programming assignment: implementing pre-order tree | |
| traversal. | |
| Ethan has a binary tree with **N** nodes (numbered 1 to **N**), rooted at node | |
| 1. Each node _i_'s left child is node **Ai** (with **Ai** = 0 indicating no | |
| left child), and similarly its right child is **Bi** (with **Bi** = 0 | |
| indicating no right child). Each node _i_ is also assigned an integral label | |
| **Li**. | |
| Given such a tree, Ethan must compute its [pre-order | |
| traversal](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_\(NLR\)) | |
| (expressed as a sequence of node labels). The pre-order traversal of a tree | |
| involves taking its root node, then concatenating the pre-order traversal of | |
| the root's left sub-tree (if any), and then concatenating the pre-order | |
| traversal of the root's right sub-tree (if any). | |
| Ethan has attempted to solve this problem, but unfortunately he got his | |
| computer science terms mixed up, and now his algorithm finds the tree's [post- | |
| order traversal](https://en.wikipedia.org/wiki/Tree_traversal#Post- | |
| order_\(LRN\)) instead! The post-order traversal of a tree involves taking the | |
| post-order traversal of the root's left sub-tree (if any), and then | |
| concatenating the post-order traversal of the root's right sub-tree (if any), | |
| and finally concatenating the root node at the end. | |
| Since you were mean to Ethan on his first assignment, you'd like to cheer him | |
| up by making his algorithm work out after all. Though the tree's shape must | |
| stay as is, you can choose a set of labels **L1..N** for its nodes such that | |
| Ethan's algorithm will still produce the correct answer — in other words, such | |
| that the sequence of node labels in the tree's pre-order traversal is equal to | |
| the sequence of node labels in its post-order traversal. Your only two | |
| restrictions are that each node label must be between 1 and **K** (inclusive), | |
| and that every integer between 1 and **K** (inclusive) must be used as the | |
| label of at least one node. You'd like to find any way of validly labelling | |
| the nodes, or determine that no way exists. | |
| ### Input | |
| Input begins with an integer **T**, the number of trees. For each tree, there | |
| is first a line containing the space-separated integers **N** and **K**. Then, | |
| **N** lines follow. The _i_th of these lines contains the space-separated | |
| integers **Ai** and **Bi**. | |
| ### Output | |
| For the _i_th tree, print a line containing "Case #_i_: " followed by your | |
| chosen node labels **L1..N** separated by spaces, or "Impossible" if there's | |
| no valid way to label the nodes. | |
| ### Constraints | |
| 1 ≤ **T** ≤ 80 | |
| 1 ≤ **K** ≤ **N** ≤ 2,000 | |
| 0 ≤ **Ai**, **Bi** ≤ **N** | |
| Every tree is guaranteed to be a valid binary tree rooted at node 1. | |
| ### Explanation of Sample | |
| In the first case, if **L** = [1, 1], then both the pre-order and post-order | |
| label sequences will be [1, 1]. | |
| In the second case, for each label between 1 and **K** to be present, you must | |
| choose either **L** = [1, 2] or **L** = [2, 1], both of which would result in | |
| the pre-order and post-order label sequences differing. For example, if **L** | |
| = [1, 2], then the pre-order sequence will be [1, 2] while the post-order | |
| sequence will be [2, 1]. | |
| In the third case, if **L** = [2, 2, 1], then the pre-order and post-order | |
| label sequences will both be [2, 1, 2]. | |
| Note that other outputs for example cases 3 to 5 would also be accepted. | |