| Ethan is doing his third programming assignment: finding the shortest path | |
| between two nodes in a graph. | |
| Given an undirected, weighted graph with **N** nodes (numbered from 1 to | |
| **N**), having no self-loops or duplicate edges, Ethan must compute the length | |
| of the shortest path from node 1 to node **N**. Ethan has implemented an | |
| algorithm to solve this problem, described by the following pseudocode: | |
| 1. Set _i_ to be equal to 1, and _d_ to be equal to 0 | |
| 2. If _i_ is equal to **N**, output _d_ and stop | |
| 3. Find the edge incident to node _i_ that has the smallest weight (if no edges are incident to _i_ or if there are multiple such edges tied with the smallest weight, then crash instead) | |
| 4. Increase _d_ by the weight of this edge, and set _i_ to be equal to the other node incident to this edge | |
| 5. Return to Step 2 | |
| Since you were nice to Ethan on his second assignment, and since that | |
| encouragement clearly hasn't helped improve the quality of his code, you'd | |
| like to find a graph that shows as clearly as possible why this solution is | |
| incorrect. | |
| You're given the number of nodes in the graph **N**, as well as the maximum | |
| allowable edge weight **K** (each edge's weight must be an integer in the | |
| interval [1, **K**]). Under these constraints you want to maximize the | |
| absolute difference between Ethan's output and the actual shortest distance | |
| between nodes 1 and **N**. However, you don't want Ethan's algorithm to either | |
| crash or run forever. Note that node **N** must actually be reachable from | |
| node 1 in the graph, though the graph may be otherwise disconnected. You can | |
| output any valid graph which gets the job done. | |
| ### Input | |
| Input begins with an integer **T**, the number of graphs. For each graph, | |
| there is a line containing the space-separated integers **N** and **K**. | |
| ### Output | |
| For the _i_th graph, first output a line containing "Case #_i_: " followed by | |
| the maximum possible absolute difference between Ethan's algorithm's output | |
| and the correct answer. Then, output a line containing as single integer | |
| **E**, the number of edges in your chosen graph which yields the above maximum | |
| absolute difference. Then, output **E** lines, the _j_th of which contains | |
| three integers **Uj**, **Vj**, and **Wj** denoting that there is an edge | |
| between nodes **Uj** and **Vj** with weight **Wj**. | |
| Note that there must be no self-loops (no edge may connect a node to itself), | |
| and no two edges may connect the same unordered pair of nodes. | |
| ### Constraints | |
| 1 ≤ **T** ≤ 200 | |
| 2 ≤ **N** ≤ 50 | |
| 1 ≤ **K** ≤ 50 | |
| ### Explanation of Sample | |
| In the first case, there are exactly two possible valid graphs, either of | |
| which would be accepted: | |
| 1 | |
| 1 2 1 | |
| 1 | |
| 2 1 1 | |
| In each of the above graphs, Ethan's algorithm's answer and the correct answer | |
| are both equal to 1. There's an absolute difference of 0 between those | |
| answers, which is the maximum possible absolute difference. | |
| In the second case, one possible graph which would be accepted is as follows | |
| (with Ethan's algorithm's answer and the correct answer both equal to 42): | |
| 1 | |
| 1 2 42 | |
| In the third case, one possible graph which would be accepted is as follows | |
| (with Ethan's algorithm's answer and the correct answer both equal to 1): | |
| 3 | |
| 1 2 2 | |
| 4 1 1 | |
| 4 2 1 | |
| Putting those together, the following is one possible sequence of outputs for | |
| the first 3 cases which would be accepted: | |
| Case #1: 0 | |
| 1 | |
| 1 2 1 | |
| Case #2: 0 | |
| 1 | |
| 1 2 42 | |
| Case #3: 0 | |
| 3 | |
| 1 2 2 | |
| 4 1 1 | |
| 4 2 1 | |
| Do not output the line "**Multiple possible accepted graphs**". | |