| 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**". |
|
|
|
|
