PCTSP/PCTSP_L_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
PCTSP,PCTSP,"Someone in charge of the grocery vans has to plan one closed loop out of the depot, choosing which local stores to hit so the total expected restock meets the target quantity. The trade-off is clear: skipping a store costs a penalty, and every mile costs in distance, so the winner is the loop that makes the sum of miles driven plus penalties as small as possible. The loop must start and end at the depot, visit each chosen store only once, and collect enough restock from the visited stops. The specific store numbers, travel distances and penalties appear below.

There are 19 locations including depot 1, and the loop must collect at least 475.0 expected restock.

| store_node_id | x_coordinate | y_coordinate | expected_restock_amount | skip_penalty_cost |
|---|---|---|---|---|
| 1 | 82 | 63 | 0 | 0 |
| 2 | 12 | 60 | 55 | 13 |
| 3 | 82 | 87 | 97 | 29 |
| 4 | 74 | 48 | 71 | 24 |
| 5 | 66 | 95 | 70 | 27 |
| 6 | 82 | 0 | 22 | 5 |
| 7 | 95 | 59 | 98 | 2 |
| 8 | 0 | 87 | 1 | 18 |
| 9 | 5 | 0 | 25 | 5 |
| 10 | 9 | 81 | 43 | 22 |
| 11 | 72 | 84 | 78 | 13 |
| 12 | 38 | 60 | 20 | 16 |
| 13 | 34 | 84 | 86 | 29 |
| 14 | 100 | 0 | 98 | 16 |
| 15 | 54 | 67 | 16 | 3 |
| 16 | 85 | 100 | 60 | 5 |
| 17 | 25 | 30 | 1 | 17 |
| 18 | 26 | 25 | 39 | 16 |
| 19 | 25 | 21 | 4 | 20 |

The planner must pick a closed loop starting and ending at depot 1 that minimizes miles driven plus skip penalties while meeting the 475.0 target.

Also, when you send the final route, please use a simple JSON shape like this so it's easy to read and process:

{
  ""solution"": [depot_id, store_id, ..., depot_id]
}

This just means: the ""solution"" entry is the loop — put the depot identifier first, then each store you plan to visit in order, and finish with the depot again. Think of it as filling out a little form with the route; that JSON is only a sketch of the expected shape, not the actual answer.

Please make sure you use the exact identifiers from the instance input — don't rename them or invent new labels. 
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[82, 63], [12, 60], [82, 87], [74, 48], [66, 95], [82, 0], [95, 59], [0, 87], [5, 0], [9, 81], [72, 84], [38, 60], [34, 84], [100, 0], [54, 67], [85, 100], [25, 30], [26, 25], [25, 21]], 'prizes': [0, 55, 97, 71, 70, 22, 98, 1, 25, 43, 78, 20, 86, 98, 16, 60, 1, 39, 4], 'penalties': [0, 13, 29, 24, 27, 5, 2, 18, 5, 22, 13, 16, 29, 16, 3, 5, 17, 16, 20], 'required_prize': 475.0, 'depot': 0, 'route_length': 242.06477279660578, 'route_prize': 544.0, 'unvisited_penalty': 70.0, 'objective': 312.0647727966058}","[0, 2, 10, 4, 12, 9, 1, 16, 17, 18, 3, 0]",312.0647727966058,"{'problem_type': 'PCTSP', 'num_nodes': 19, 'nodes': [{'id': 1, 'x': 82, 'y': 63, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 12, 'y': 60, 'prize': 55, 'penalty': 13}, {'id': 3, 'x': 82, 'y': 87, 'prize': 97, 'penalty': 29}, {'id': 4, 'x': 74, 'y': 48, 'prize': 71, 'penalty': 24}, {'id': 5, 'x': 66, 'y': 95, 'prize': 70, 'penalty': 27}, {'id': 6, 'x': 82, 'y': 0, 'prize': 22, 'penalty': 5}, {'id': 7, 'x': 95, 'y': 59, 'prize': 98, 'penalty': 2}, {'id': 8, 'x': 0, 'y': 87, 'prize': 1, 'penalty': 18}, {'id': 9, 'x': 5, 'y': 0, 'prize': 25, 'penalty': 5}, {'id': 10, 'x': 9, 'y': 81, 'prize': 43, 'penalty': 22}, {'id': 11, 'x': 72, 'y': 84, 'prize': 78, 'penalty': 13}, {'id': 12, 'x': 38, 'y': 60, 'prize': 20, 'penalty': 16}, {'id': 13, 'x': 34, 'y': 84, 'prize': 86, 'penalty': 29}, {'id': 14, 'x': 100, 'y': 0, 'prize': 98, 'penalty': 16}, {'id': 15, 'x': 54, 'y': 67, 'prize': 16, 'penalty': 3}, {'id': 16, 'x': 85, 'y': 100, 'prize': 60, 'penalty': 5}, {'id': 17, 'x': 25, 'y': 30, 'prize': 1, 'penalty': 17}, {'id': 18, 'x': 26, 'y': 25, 'prize': 39, 'penalty': 16}, {'id': 19, 'x': 25, 'y': 21, 'prize': 4, 'penalty': 20}], 'depot': 1, 'required_prize': 475.0, 'route_prize': 544.0, 'unvisited_penalty': 70.0, 'route_length': 242.06477279660578, 'objective': 312.0647727966058}","[1, 3, 11, 5, 13, 10, 2, 17, 18, 19, 4, 1]",1,markdown_table,1
PCTSP,PCTSP,"I run the mobile clinic and need to plan one continuous loop that leaves the clinic, stops at some farms to pick up booked vet appointments, and comes back to the clinic. The decision is which farms to include on that single circuit so the total number of appointments (or health coverage) collected hits a required target. A good plan keeps the driving time low but also avoids big fines for farms that get skipped — the score for any candidate route is simply the total drive time plus the penalties charged for farms left out. No farm should be visited more than once and the route must start and end at the clinic. The specific farm locations, penalties, appointment values and the target coverage are shown below.

The instance has 17 locations (clinic is node 1), and I must collect at least 425.0 appointments on the single loop.
Farm 1 at (0, 100) provides 0 appointments and carries a skip penalty of 0.
Farm 2 at (10, 20) provides 65 appointments and carries a skip penalty of 31.
Farm 3 at (19, 0) provides 40 appointments and carries a skip penalty of 15.
Farm 4 at (19, 45) provides 62 appointments and carries a skip penalty of 28.
Farm 5 at (27, 100) provides 77 appointments and carries a skip penalty of 14.
Farm 6 at (28, 94) provides 18 appointments and carries a skip penalty of 31.
Farm 7 at (38, 100) provides 38 appointments and carries a skip penalty of 14.
Farm 8 at (41, 6) provides 50 appointments and carries a skip penalty of 11.
Farm 9 at (45, 31) provides 69 appointments and carries a skip penalty of 20.
Farm 10 at (47, 13) provides 25 appointments and carries a skip penalty of 29.
Farm 11 at (81, 0) provides 55 appointments and carries a skip penalty of 29.
Farm 12 at (82, 45) provides 62 appointments and carries a skip penalty of 20.
Farm 13 at (84, 1) provides 90 appointments and carries a skip penalty of 3.
Farm 14 at (87, 20) provides 36 appointments and carries a skip penalty of 20.
Farm 15 at (100, 100) provides 64 appointments and carries a skip penalty of 8.
Farm 16 at (16, 7) provides 19 appointments and carries a skip penalty of 25.
Farm 17 at (37, 20) provides 50 appointments and carries a skip penalty of 31.
I will choose one circuit that starts and ends at clinic 1, meets the 425.0 target, and minimizes total drive time plus penalties for skipped farms.

Also, to keep things easy to read, please send the route using a simple JSON layout like the one below.

{
  ""solution"": [clinic_id, farm_id, ..., clinic_id]
}

This ""solution"" list is just the tour: put the clinic (the depot) first, then the farms you plan to stop at in order, and finish back at the clinic. Think of it as a short form — a sketch of the route rather than the full technical answer.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. 
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 100], [10, 20], [19, 0], [19, 45], [27, 100], [28, 94], [38, 100], [41, 6], [45, 31], [47, 13], [81, 0], [82, 45], [84, 1], [87, 20], [100, 100], [16, 7], [37, 20]], 'prizes': [0, 65, 40, 62, 77, 18, 38, 50, 69, 25, 55, 62, 90, 36, 64, 19, 50], 'penalties': [0, 31, 15, 28, 14, 31, 14, 11, 20, 29, 29, 20, 3, 20, 8, 25, 31], 'required_prize': 425.0, 'depot': 0, 'route_length': 262.8607948025625, 'route_prize': 475.0, 'unvisited_penalty': 94.0, 'objective': 356.86079480256257}","[0, 4, 5, 8, 16, 9, 7, 2, 15, 1, 3, 0]",356.86079480256257,"{'problem_type': 'PCTSP', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 0, 'y': 100, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 10, 'y': 20, 'prize': 65, 'penalty': 31}, {'id': 3, 'x': 19, 'y': 0, 'prize': 40, 'penalty': 15}, {'id': 4, 'x': 19, 'y': 45, 'prize': 62, 'penalty': 28}, {'id': 5, 'x': 27, 'y': 100, 'prize': 77, 'penalty': 14}, {'id': 6, 'x': 28, 'y': 94, 'prize': 18, 'penalty': 31}, {'id': 7, 'x': 38, 'y': 100, 'prize': 38, 'penalty': 14}, {'id': 8, 'x': 41, 'y': 6, 'prize': 50, 'penalty': 11}, {'id': 9, 'x': 45, 'y': 31, 'prize': 69, 'penalty': 20}, {'id': 10, 'x': 47, 'y': 13, 'prize': 25, 'penalty': 29}, {'id': 11, 'x': 81, 'y': 0, 'prize': 55, 'penalty': 29}, {'id': 12, 'x': 82, 'y': 45, 'prize': 62, 'penalty': 20}, {'id': 13, 'x': 84, 'y': 1, 'prize': 90, 'penalty': 3}, {'id': 14, 'x': 87, 'y': 20, 'prize': 36, 'penalty': 20}, {'id': 15, 'x': 100, 'y': 100, 'prize': 64, 'penalty': 8}, {'id': 16, 'x': 16, 'y': 7, 'prize': 19, 'penalty': 25}, {'id': 17, 'x': 37, 'y': 20, 'prize': 50, 'penalty': 31}], 'depot': 1, 'required_prize': 425.0, 'route_prize': 475.0, 'unvisited_penalty': 94.0, 'route_length': 262.8607948025625, 'objective': 356.86079480256257}","[1, 5, 6, 9, 17, 10, 8, 3, 16, 2, 4, 1]",2,nl,1
PCTSP,PCTSP,"I run an ice cream truck and need to plan one round trip that leaves from and returns to the garage, picking which city blocks to stop at so the day’s sales hit a required target. The trade-off is simple: choose stops so the route is short but also so missed blocks don’t cost too much in lost sales — the “score” for any plan is just total miles driven plus the sum of lost‑sales penalties for blocks skipped, and a smaller score is better. The trip must be a single loop (no visiting blocks twice) and must bring in at least the required sales. Concrete details about the blocks, sales, and penalties are shown below.

Below are the 22 locations (including my garage 1); I must collect at least 550.0 in expected sales.
Block 1 at (95, 49) would add 0 to my sales; skipping it incurs a lost-sales penalty of 0.
Block 2 at (93, 70) would add 60 to my sales; skipping it incurs a lost-sales penalty of 6.
Block 3 at (96, 56) would add 7 to my sales; skipping it incurs a lost-sales penalty of 15.
Block 4 at (68, 62) would add 54 to my sales; skipping it incurs a lost-sales penalty of 12.
Block 5 at (38, 45) would add 13 to my sales; skipping it incurs a lost-sales penalty of 19.
Block 6 at (95, 76) would add 61 to my sales; skipping it incurs a lost-sales penalty of 13.
Block 7 at (100, 96) would add 36 to my sales; skipping it incurs a lost-sales penalty of 8.
Block 8 at (6, 54) would add 77 to my sales; skipping it incurs a lost-sales penalty of 13.
Block 9 at (48, 0) would add 5 to my sales; skipping it incurs a lost-sales penalty of 13.
Block 10 at (28, 16) would add 11 to my sales; skipping it incurs a lost-sales penalty of 28.
Block 11 at (78, 65) would add 68 to my sales; skipping it incurs a lost-sales penalty of 30.
Block 12 at (3, 35) would add 51 to my sales; skipping it incurs a lost-sales penalty of 19.
Block 13 at (19, 43) would add 57 to my sales; skipping it incurs a lost-sales penalty of 3.
Block 14 at (85, 100) would add 84 to my sales; skipping it incurs a lost-sales penalty of 23.
Block 15 at (92, 81) would add 49 to my sales; skipping it incurs a lost-sales penalty of 21.
Block 16 at (82, 6) would add 81 to my sales; skipping it incurs a lost-sales penalty of 25.
Block 17 at (37, 58) would add 51 to my sales; skipping it incurs a lost-sales penalty of 11.
Block 18 at (83, 3) would add 93 to my sales; skipping it incurs a lost-sales penalty of 2.
Block 19 at (95, 54) would add 67 to my sales; skipping it incurs a lost-sales penalty of 19.
Block 20 at (0, 56) would add 15 to my sales; skipping it incurs a lost-sales penalty of 4.
Block 21 at (45, 33) would add 36 to my sales; skipping it incurs a lost-sales penalty of 23.
Block 22 at (22, 36) would add 87 to my sales; skipping it incurs a lost-sales penalty of 24.
Use these entries to pick a single-loop route that starts and ends at my garage 1 and meets the 550.0 sales target.

Also, when you send the plan back, just stick to this simple JSON shape so it's easy to read and check:

{
  ""solution"": [""garage_id"", ""block_id"", ""..."", ""garage_id""]
}

Think of it like a little form: the first item is the garage where the truck starts, the middle items are the blocks you stop at in order, and the last item is the garage again to show the loop is closed. This JSON is just a sketch of the expected shape — not your actual answer.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[95, 49], [93, 70], [96, 56], [68, 62], [38, 45], [95, 76], [100, 96], [6, 54], [48, 0], [28, 16], [78, 65], [3, 35], [19, 43], [85, 100], [92, 81], [82, 6], [37, 58], [83, 3], [95, 54], [0, 56], [45, 33], [22, 36]], 'prizes': [0, 60, 7, 54, 13, 61, 36, 77, 5, 11, 68, 51, 57, 84, 49, 81, 51, 93, 67, 15, 36, 87], 'penalties': [0, 6, 15, 12, 19, 13, 8, 13, 13, 28, 30, 19, 3, 23, 21, 25, 11, 2, 19, 4, 23, 24], 'required_prize': 550.0, 'depot': 0, 'route_length': 225.4828207393952, 'route_prize': 564.0, 'unvisited_penalty': 110.0, 'objective': 335.4828207393952}","[0, 20, 9, 21, 4, 16, 3, 10, 14, 5, 1, 2, 18, 0]",335.4828207393952,"{'problem_type': 'PCTSP', 'num_nodes': 22, 'nodes': [{'id': 1, 'x': 95, 'y': 49, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 93, 'y': 70, 'prize': 60, 'penalty': 6}, {'id': 3, 'x': 96, 'y': 56, 'prize': 7, 'penalty': 15}, {'id': 4, 'x': 68, 'y': 62, 'prize': 54, 'penalty': 12}, {'id': 5, 'x': 38, 'y': 45, 'prize': 13, 'penalty': 19}, {'id': 6, 'x': 95, 'y': 76, 'prize': 61, 'penalty': 13}, {'id': 7, 'x': 100, 'y': 96, 'prize': 36, 'penalty': 8}, {'id': 8, 'x': 6, 'y': 54, 'prize': 77, 'penalty': 13}, {'id': 9, 'x': 48, 'y': 0, 'prize': 5, 'penalty': 13}, {'id': 10, 'x': 28, 'y': 16, 'prize': 11, 'penalty': 28}, {'id': 11, 'x': 78, 'y': 65, 'prize': 68, 'penalty': 30}, {'id': 12, 'x': 3, 'y': 35, 'prize': 51, 'penalty': 19}, {'id': 13, 'x': 19, 'y': 43, 'prize': 57, 'penalty': 3}, {'id': 14, 'x': 85, 'y': 100, 'prize': 84, 'penalty': 23}, {'id': 15, 'x': 92, 'y': 81, 'prize': 49, 'penalty': 21}, {'id': 16, 'x': 82, 'y': 6, 'prize': 81, 'penalty': 25}, {'id': 17, 'x': 37, 'y': 58, 'prize': 51, 'penalty': 11}, {'id': 18, 'x': 83, 'y': 3, 'prize': 93, 'penalty': 2}, {'id': 19, 'x': 95, 'y': 54, 'prize': 67, 'penalty': 19}, {'id': 20, 'x': 0, 'y': 56, 'prize': 15, 'penalty': 4}, {'id': 21, 'x': 45, 'y': 33, 'prize': 36, 'penalty': 23}, {'id': 22, 'x': 22, 'y': 36, 'prize': 87, 'penalty': 24}], 'depot': 1, 'required_prize': 550.0, 'route_prize': 564.0, 'unvisited_penalty': 110.0, 'route_length': 225.4828207393952, 'objective': 335.4828207393952}","[1, 21, 10, 22, 5, 17, 4, 11, 15, 6, 2, 3, 19, 1]",3,nl,1
PCTSP,PCTSP,"Recently the team had to plan a single pickup loop out of the center: the driver will leave, call on selected donors, and end the loop back at the center once the campaign total is reached. Each stop gives a known contribution and carries a penalty for not stopping, so a smarter route is the one that meets the fundraising target while keeping the combined tally of travel distance and missed-donor penalties as low as possible. The route must be one uninterrupted circuit with each chosen house visited only once. Concrete specifics are shown below.

The instance lists 20 locations, the charity center is node A, and the route must collect at least 500.0 in donations before returning.

| location_id | map_x_coord | map_y_coord | donation_amount | skip_penalty |
|---|---|---|---|---|
| A | 28 | 52 | 0 | 0 |
| B | 57 | 45 | 94 | 3 |
| C | 19 | 43 | 17 | 18 |
| D | 17 | 29 | 94 | 8 |
| E | 0 | 17 | 47 | 12 |
| F | 56 | 4 | 76 | 23 |
| G | 63 | 2 | 75 | 10 |
| H | 19 | 0 | 98 | 27 |
| I | 0 | 67 | 97 | 21 |
| J | 3 | 89 | 4 | 16 |
| K | 11 | 93 | 2 | 5 |
| L | 20 | 100 | 54 | 12 |
| M | 83 | 2 | 3 | 22 |
| N | 100 | 10 | 66 | 29 |
| O | 94 | 18 | 53 | 2 |
| P | 87 | 52 | 67 | 4 |
| Q | 86 | 62 | 44 | 22 |
| R | 84 | 68 | 27 | 24 |
| S | 95 | 79 | 95 | 3 |
| T | 87 | 85 | 73 | 24 |

Choose a single uninterrupted loop that meets the fundraising target while minimizing travel distance and missed-donor penalties.

Also, when you send the chosen loop back to us, please use this simple JSON shape so it's easy to parse:

{
  ""solution"": [center_id, donor_id, ..., center_id]
}

This is just a loose sketch of the shape we need: the array lists the stops in order (starting and ending at the center), using the exact stop identifiers from the instance. It's just a format guide, not the actual route.

Please be sure to use the identifiers exactly as they appear in the instance input—no renaming, no extra labels.
- Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[28, 52], [57, 45], [19, 43], [17, 29], [0, 17], [56, 4], [63, 2], [19, 0], [0, 67], [3, 89], [11, 93], [20, 100], [83, 2], [100, 10], [94, 18], [87, 52], [86, 62], [84, 68], [95, 79], [87, 85]], 'prizes': [0, 94, 17, 94, 47, 76, 75, 98, 97, 4, 2, 54, 3, 66, 53, 67, 44, 27, 95, 73], 'penalties': [0, 3, 18, 8, 12, 23, 10, 27, 21, 16, 5, 12, 22, 29, 2, 4, 22, 24, 3, 24], 'required_prize': 500.0, 'depot': 0, 'route_length': 258.55135361290064, 'route_prize': 620.0, 'unvisited_penalty': 96.0, 'objective': 354.5513536129007}","[0, 17, 16, 15, 14, 13, 12, 6, 5, 7, 3, 2, 0]",354.5513536129007,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 'A', 'x': 28, 'y': 52, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 57, 'y': 45, 'prize': 94, 'penalty': 3}, {'id': 'C', 'x': 19, 'y': 43, 'prize': 17, 'penalty': 18}, {'id': 'D', 'x': 17, 'y': 29, 'prize': 94, 'penalty': 8}, {'id': 'E', 'x': 0, 'y': 17, 'prize': 47, 'penalty': 12}, {'id': 'F', 'x': 56, 'y': 4, 'prize': 76, 'penalty': 23}, {'id': 'G', 'x': 63, 'y': 2, 'prize': 75, 'penalty': 10}, {'id': 'H', 'x': 19, 'y': 0, 'prize': 98, 'penalty': 27}, {'id': 'I', 'x': 0, 'y': 67, 'prize': 97, 'penalty': 21}, {'id': 'J', 'x': 3, 'y': 89, 'prize': 4, 'penalty': 16}, {'id': 'K', 'x': 11, 'y': 93, 'prize': 2, 'penalty': 5}, {'id': 'L', 'x': 20, 'y': 100, 'prize': 54, 'penalty': 12}, {'id': 'M', 'x': 83, 'y': 2, 'prize': 3, 'penalty': 22}, {'id': 'N', 'x': 100, 'y': 10, 'prize': 66, 'penalty': 29}, {'id': 'O', 'x': 94, 'y': 18, 'prize': 53, 'penalty': 2}, {'id': 'P', 'x': 87, 'y': 52, 'prize': 67, 'penalty': 4}, {'id': 'Q', 'x': 86, 'y': 62, 'prize': 44, 'penalty': 22}, {'id': 'R', 'x': 84, 'y': 68, 'prize': 27, 'penalty': 24}, {'id': 'S', 'x': 95, 'y': 79, 'prize': 95, 'penalty': 3}, {'id': 'T', 'x': 87, 'y': 85, 'prize': 73, 'penalty': 24}], 'depot': 'A', 'required_prize': 500.0, 'route_prize': 620.0, 'unvisited_penalty': 96.0, 'route_length': 258.55135361290064, 'objective': 354.5513536129007}","['A', 'R', 'Q', 'P', 'O', 'N', 'M', 'G', 'F', 'H', 'D', 'C', 'A']",4,markdown_table,names
PCTSP,PCTSP,"We imagine the city inspector drawing a single circuit from headquarters, choosing which lamp posts to inspect until the team has collected enough priority points to meet the quota. Better plans are simply those where the sum of road miles driven plus the penalties for any uninspected posts comes out lower — compute it by adding the total travel distance to the penalty amounts for skipped posts. The day’s work must be done as one continuous tour that returns to HQ, and revisiting posts just wastes distance. The concrete post-by-post details are listed below.

{
  ""total_locations_including_hq"": 19,
  ""nodes"": [
    {
      ""post_node_id"": 0,
      ""x_coordinate"": 79,
      ""y_coordinate"": 49,
      ""priority_points"": 0,
      ""skip_penalty"": 0
    },
    {
      ""post_node_id"": 1,
      ""x_coordinate"": 69,
      ""y_coordinate"": 59,
      ""priority_points"": 69,
      ""skip_penalty"": 7
    },
    {
      ""post_node_id"": 2,
      ""x_coordinate"": 68,
      ""y_coordinate"": 50,
      ""priority_points"": 34,
      ""skip_penalty"": 10
    },
    {
      ""post_node_id"": 3,
      ""x_coordinate"": 5,
      ""y_coordinate"": 55,
      ""priority_points"": 44,
      ""skip_penalty"": 8
    },
    {
      ""post_node_id"": 4,
      ""x_coordinate"": 4,
      ""y_coordinate"": 53,
      ""priority_points"": 37,
      ""skip_penalty"": 10
    },
    {
      ""post_node_id"": 5,
      ""x_coordinate"": 1,
      ""y_coordinate"": 15,
      ""priority_points"": 84,
      ""skip_penalty"": 4
    },
    {
      ""post_node_id"": 6,
      ""x_coordinate"": 0,
      ""y_coordinate"": 19,
      ""priority_points"": 33,
      ""skip_penalty"": 11
    },
    {
      ""post_node_id"": 7,
      ""x_coordinate"": 1,
      ""y_coordinate"": 22,
      ""priority_points"": 32,
      ""skip_penalty"": 1
    },
    {
      ""post_node_id"": 8,
      ""x_coordinate"": 0,
      ""y_coordinate"": 100,
      ""priority_points"": 94,
      ""skip_penalty"": 16
    },
    {
      ""post_node_id"": 9,
      ""x_coordinate"": 0,
      ""y_coordinate"": 100,
      ""priority_points"": 92,
      ""skip_penalty"": 29
    },
    {
      ""post_node_id"": 10,
      ""x_coordinate"": 1,
      ""y_coordinate"": 100,
      ""priority_points"": 97,
      ""skip_penalty"": 14
    },
    {
      ""post_node_id"": 11,
      ""x_coordinate"": 100,
      ""y_coordinate"": 17,
      ""priority_points"": 81,
      ""skip_penalty"": 19
    },
    {
      ""post_node_id"": 12,
      ""x_coordinate"": 99,
      ""y_coordinate"": 17,
      ""priority_points"": 9,
      ""skip_penalty"": 19
    },
    {
      ""post_node_id"": 13,
      ""x_coordinate"": 99,
      ""y_coordinate"": 17,
      ""priority_points"": 9,
      ""skip_penalty"": 29
    },
    {
      ""post_node_id"": 14,
      ""x_coordinate"": 99,
      ""y_coordinate"": 18,
      ""priority_points"": 56,
      ""skip_penalty"": 22
    },
    {
      ""post_node_id"": 15,
      ""x_coordinate"": 100,
      ""y_coordinate"": 21,
      ""priority_points"": 86,
      ""skip_penalty"": 25
    },
    {
      ""post_node_id"": 16,
      ""x_coordinate"": 100,
      ""y_coordinate"": 92,
      ""priority_points"": 88,
      ""skip_penalty"": 10
    },
    {
      ""post_node_id"": 17,
      ""x_coordinate"": 99,
      ""y_coordinate"": 98,
      ""priority_points"": 64,
      ""skip_penalty"": 28
    },
    {
      ""post_node_id"": 18,
      ""x_coordinate"": 100,
      ""y_coordinate"": 0,
      ""priority_points"": 96,
      ""skip_penalty"": 6
    }
  ],
  ""headquarters_node_id"": 0,
  ""required_priority_score"": 475.0
}

You can send your answer in a simple JSON form like this so it's easy to check automatically — just a single tour as a list that starts and ends at the depot.

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of that as a little form: ""solution"" is the tour, and the array is the order you visit things (starting and finishing at the depot). It's only a sketch of the shape I want here, not the actual route — replace those placeholders with the real IDs from the instance.

Please use the exact identifiers from the instance input — no renaming and no new labels.  
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[79, 49], [69, 59], [68, 50], [5, 55], [4, 53], [1, 15], [0, 19], [1, 22], [0, 100], [0, 100], [1, 100], [100, 17], [99, 17], [99, 17], [99, 18], [100, 21], [100, 92], [99, 98], [100, 0]], 'prizes': [0, 69, 34, 44, 37, 84, 33, 32, 94, 92, 97, 81, 9, 9, 56, 86, 88, 64, 96], 'penalties': [0, 7, 10, 8, 10, 4, 11, 1, 16, 29, 14, 19, 19, 29, 22, 25, 10, 28, 6], 'required_prize': 475.0, 'depot': 0, 'route_length': 189.2789005775865, 'route_prize': 496.0, 'unvisited_penalty': 99.0, 'objective': 288.2789005775865}","[0, 2, 1, 17, 16, 15, 11, 13, 12, 14, 0]",288.2789005775865,"{'problem_type': 'PCTSP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 79, 'y': 49, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 69, 'y': 59, 'prize': 69, 'penalty': 7}, {'id': 2, 'x': 68, 'y': 50, 'prize': 34, 'penalty': 10}, {'id': 3, 'x': 5, 'y': 55, 'prize': 44, 'penalty': 8}, {'id': 4, 'x': 4, 'y': 53, 'prize': 37, 'penalty': 10}, {'id': 5, 'x': 1, 'y': 15, 'prize': 84, 'penalty': 4}, {'id': 6, 'x': 0, 'y': 19, 'prize': 33, 'penalty': 11}, {'id': 7, 'x': 1, 'y': 22, 'prize': 32, 'penalty': 1}, {'id': 8, 'x': 0, 'y': 100, 'prize': 94, 'penalty': 16}, {'id': 9, 'x': 0, 'y': 100, 'prize': 92, 'penalty': 29}, {'id': 10, 'x': 1, 'y': 100, 'prize': 97, 'penalty': 14}, {'id': 11, 'x': 100, 'y': 17, 'prize': 81, 'penalty': 19}, {'id': 12, 'x': 99, 'y': 17, 'prize': 9, 'penalty': 19}, {'id': 13, 'x': 99, 'y': 17, 'prize': 9, 'penalty': 29}, {'id': 14, 'x': 99, 'y': 18, 'prize': 56, 'penalty': 22}, {'id': 15, 'x': 100, 'y': 21, 'prize': 86, 'penalty': 25}, {'id': 16, 'x': 100, 'y': 92, 'prize': 88, 'penalty': 10}, {'id': 17, 'x': 99, 'y': 98, 'prize': 64, 'penalty': 28}, {'id': 18, 'x': 100, 'y': 0, 'prize': 96, 'penalty': 6}], 'depot': 0, 'required_prize': 475.0, 'route_prize': 496.0, 'unvisited_penalty': 99.0, 'route_length': 189.2789005775865, 'objective': 288.2789005775865}","[0, 2, 1, 17, 16, 15, 11, 13, 12, 14, 0]",5,json,0
PCTSP,PCTSP,"Many people do one-day pop-up rounds from a home studio: drive a loop, stop at selected meetup spots, and return. The choice here is which stops to take so that the bookings from those stops meet a minimum target. To pick the best loop, sum the driving expense for the entire circuit plus the penalties for any meetups not visited — lower combined cost is better. The trip must be exactly one circuit beginning and ending at the studio, with each meetup visited at most once. The full list of meetups, their booking values, penalties, and the required total are given below.

# total_locations_including_studio=20
# studio_node_id=A
# required_total_bookings=500.0
location_id,x_coord,y_coord,booking_value,missed_session_penalty
A,0,0,0,0
B,10,79,74,2
C,19,100,33,16
D,26,86,89,17
E,16,34,86,28
F,21,10,17,27
G,39,34,23,15
H,56,34,5,22
I,37,62,86,28
J,56,100,34,21
K,48,83,39,28
L,48,89,27,27
M,40,72,12,14
N,63,45,46,19
O,60,14,23,5
P,54,0,56,13
Q,92,48,20,25
R,89,59,51,17
S,100,72,95,8
T,31,79,37,4

If you want the tour back in a simple, machine-friendly form, you can use this relaxed JSON shape — nothing fancy, just an ordered list that starts and ends at the studio:

{
  ""solution"": [studio_id, meetup_id, ..., studio_id]
}

Think of ""solution"" as the single loop: the list shows the stops in order, beginning and ending at your studio. The studio_id and meetup_id entries are placeholders for the studio and each meetup stop, and the ""..."" just means you can have as many meetups in the middle as needed. This is only a sketch of the shape I expect, not the actual answer.

Please be sure to use the exact identifiers from the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [10, 79], [19, 100], [26, 86], [16, 34], [21, 10], [39, 34], [56, 34], [37, 62], [56, 100], [48, 83], [48, 89], [40, 72], [63, 45], [60, 14], [54, 0], [92, 48], [89, 59], [100, 72], [31, 79]], 'prizes': [0, 74, 33, 89, 86, 17, 23, 5, 86, 34, 39, 27, 12, 46, 23, 56, 20, 51, 95, 37], 'penalties': [0, 2, 16, 17, 28, 27, 15, 22, 28, 21, 28, 27, 14, 19, 5, 13, 25, 17, 8, 4], 'required_prize': 500.0, 'depot': 0, 'route_length': 321.31116300557863, 'route_prize': 572.0, 'unvisited_penalty': 44.0, 'objective': 365.31116300557863}","[0, 4, 8, 12, 19, 3, 10, 11, 9, 17, 16, 13, 7, 6, 5, 0]",365.31116300557863,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 10, 'y': 79, 'prize': 74, 'penalty': 2}, {'id': 'C', 'x': 19, 'y': 100, 'prize': 33, 'penalty': 16}, {'id': 'D', 'x': 26, 'y': 86, 'prize': 89, 'penalty': 17}, {'id': 'E', 'x': 16, 'y': 34, 'prize': 86, 'penalty': 28}, {'id': 'F', 'x': 21, 'y': 10, 'prize': 17, 'penalty': 27}, {'id': 'G', 'x': 39, 'y': 34, 'prize': 23, 'penalty': 15}, {'id': 'H', 'x': 56, 'y': 34, 'prize': 5, 'penalty': 22}, {'id': 'I', 'x': 37, 'y': 62, 'prize': 86, 'penalty': 28}, {'id': 'J', 'x': 56, 'y': 100, 'prize': 34, 'penalty': 21}, {'id': 'K', 'x': 48, 'y': 83, 'prize': 39, 'penalty': 28}, {'id': 'L', 'x': 48, 'y': 89, 'prize': 27, 'penalty': 27}, {'id': 'M', 'x': 40, 'y': 72, 'prize': 12, 'penalty': 14}, {'id': 'N', 'x': 63, 'y': 45, 'prize': 46, 'penalty': 19}, {'id': 'O', 'x': 60, 'y': 14, 'prize': 23, 'penalty': 5}, {'id': 'P', 'x': 54, 'y': 0, 'prize': 56, 'penalty': 13}, {'id': 'Q', 'x': 92, 'y': 48, 'prize': 20, 'penalty': 25}, {'id': 'R', 'x': 89, 'y': 59, 'prize': 51, 'penalty': 17}, {'id': 'S', 'x': 100, 'y': 72, 'prize': 95, 'penalty': 8}, {'id': 'T', 'x': 31, 'y': 79, 'prize': 37, 'penalty': 4}], 'depot': 'A', 'required_prize': 500.0, 'route_prize': 572.0, 'unvisited_penalty': 44.0, 'route_length': 321.31116300557863, 'objective': 365.31116300557863}","['A', 'E', 'I', 'M', 'T', 'D', 'K', 'L', 'J', 'R', 'Q', 'N', 'H', 'G', 'F', 'A']",6,csv,names
PCTSP,PCTSP,"I’m the person in charge of the pharmacy’s delivery run: plan one single round trip that leaves from the pharmacy, visits a selection of patient homes, and comes back. The decision is which homes to include and in what order so that the total number of medicines handed out hits the required quota. A better plan is one that keeps the bill low — add up the driving cost (miles/time/fuel/driver pay) for the whole loop and then add any fines or customer penalty amounts for homes that were skipped; the sum is what matters, and the plan with the smaller sum wins. The trip must be a single loop starting and ending at the pharmacy, no split trips, and no visiting the same house twice. Concrete details of addresses, delivery amounts, and penalty values are shown below.

Here are the 19 locations (pharmacy is node A); my chosen single loop must collect at least 475.0 medicines.

| location_id | coord_x | coord_y | medicines_delivered_at_stop | missed_delivery_penalty |
|---|---|---|---|---|
| A | 0 | 6 | 0 | 0 |
| B | 0 | 8 | 12 | 5 |
| C | 38 | 12 | 23 | 10 |
| D | 2 | 14 | 38 | 18 |
| E | 52 | 29 | 4 | 1 |
| F | 33 | 36 | 84 | 20 |
| G | 1 | 41 | 40 | 19 |
| H | 61 | 49 | 57 | 7 |
| I | 37 | 62 | 64 | 13 |
| J | 8 | 72 | 13 | 6 |
| K | 54 | 79 | 8 | 1 |
| L | 38 | 100 | 16 | 18 |
| M | 55 | 16 | 99 | 14 |
| N | 56 | 24 | 10 | 26 |
| O | 79 | 0 | 42 | 6 |
| P | 70 | 26 | 88 | 13 |
| Q | 88 | 72 | 58 | 20 |
| R | 100 | 79 | 2 | 2 |
| S | 99 | 96 | 89 | 11 |

I will plan a single loop starting and ending at pharmacy A; the route must meet or exceed the 475.0 medicine quota for the 19 listed locations while minimizing driving cost plus any missed-delivery penalties.

When you send your planned loop back, just use this simple JSON layout so I can pick it up cleanly:

{
  ""solution"": [""pharmacy_id"", ""patient_id"", ..., ""pharmacy_id""]
}

The ""solution"" list is just the ordered loop: start with the pharmacy's id, list the patient home ids you plan to visit in order, and finish with the pharmacy id again to close the trip. It's just a little form — nothing fancy — and it's only a sketch of the shape I expect, not the actual route.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[0, 6], [0, 8], [38, 12], [2, 14], [52, 29], [33, 36], [1, 41], [61, 49], [37, 62], [8, 72], [54, 79], [38, 100], [55, 16], [56, 24], [79, 0], [70, 26], [88, 72], [100, 79], [99, 96]], 'prizes': [0, 12, 23, 38, 4, 84, 40, 57, 64, 13, 8, 16, 99, 10, 42, 88, 58, 2, 89], 'penalties': [0, 5, 10, 18, 1, 20, 19, 7, 13, 6, 1, 18, 14, 26, 6, 13, 20, 2, 11], 'required_prize': 475.0, 'depot': 0, 'route_length': 202.77588070407944, 'route_prize': 475.0, 'unvisited_penalty': 84.0, 'objective': 286.77588070407944}","[0, 1, 3, 5, 8, 7, 15, 13, 12, 2, 0]",286.77588070407944,"{'problem_type': 'PCTSP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 0, 'y': 6, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 0, 'y': 8, 'prize': 12, 'penalty': 5}, {'id': 'C', 'x': 38, 'y': 12, 'prize': 23, 'penalty': 10}, {'id': 'D', 'x': 2, 'y': 14, 'prize': 38, 'penalty': 18}, {'id': 'E', 'x': 52, 'y': 29, 'prize': 4, 'penalty': 1}, {'id': 'F', 'x': 33, 'y': 36, 'prize': 84, 'penalty': 20}, {'id': 'G', 'x': 1, 'y': 41, 'prize': 40, 'penalty': 19}, {'id': 'H', 'x': 61, 'y': 49, 'prize': 57, 'penalty': 7}, {'id': 'I', 'x': 37, 'y': 62, 'prize': 64, 'penalty': 13}, {'id': 'J', 'x': 8, 'y': 72, 'prize': 13, 'penalty': 6}, {'id': 'K', 'x': 54, 'y': 79, 'prize': 8, 'penalty': 1}, {'id': 'L', 'x': 38, 'y': 100, 'prize': 16, 'penalty': 18}, {'id': 'M', 'x': 55, 'y': 16, 'prize': 99, 'penalty': 14}, {'id': 'N', 'x': 56, 'y': 24, 'prize': 10, 'penalty': 26}, {'id': 'O', 'x': 79, 'y': 0, 'prize': 42, 'penalty': 6}, {'id': 'P', 'x': 70, 'y': 26, 'prize': 88, 'penalty': 13}, {'id': 'Q', 'x': 88, 'y': 72, 'prize': 58, 'penalty': 20}, {'id': 'R', 'x': 100, 'y': 79, 'prize': 2, 'penalty': 2}, {'id': 'S', 'x': 99, 'y': 96, 'prize': 89, 'penalty': 11}], 'depot': 'A', 'required_prize': 475.0, 'route_prize': 475.0, 'unvisited_penalty': 84.0, 'route_length': 202.77588070407944, 'objective': 286.77588070407944}","['A', 'B', 'D', 'F', 'I', 'H', 'P', 'N', 'M', 'C', 'A']",7,markdown_table,names
PCTSP,PCTSP,"Picture this: a map with a depot and lots of little neighborhood bins, each labeled with how much material it holds and how much it costs if skipped. The supervisor needs to pick a single loop that leaves and returns to the depot, visits some of those bins (no duplicates) until the truck’s load meets the target, and does so cheaply. “Cheaply” here means the total of the miles driven plus the fines for any skipped bins — that sum is what’s being minimized. The exact figures and distances are listed below.

{
  ""total_locations_including_depot"": 19,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""x_coord"": 0,
      ""y_coord"": 37,
      ""bin_recyclable_weight"": 0,
      ""skip_fine"": 0
    },
    {
      ""location_id"": 1,
      ""x_coord"": 0,
      ""y_coord"": 52,
      ""bin_recyclable_weight"": 25,
      ""skip_fine"": 22
    },
    {
      ""location_id"": 2,
      ""x_coord"": 38,
      ""y_coord"": 0,
      ""bin_recyclable_weight"": 36,
      ""skip_fine"": 15
    },
    {
      ""location_id"": 3,
      ""x_coord"": 38,
      ""y_coord"": 30,
      ""bin_recyclable_weight"": 58,
      ""skip_fine"": 17
    },
    {
      ""location_id"": 4,
      ""x_coord"": 41,
      ""y_coord"": 18,
      ""bin_recyclable_weight"": 41,
      ""skip_fine"": 18
    },
    {
      ""location_id"": 5,
      ""x_coord"": 41,
      ""y_coord"": 11,
      ""bin_recyclable_weight"": 88,
      ""skip_fine"": 5
    },
    {
      ""location_id"": 6,
      ""x_coord"": 58,
      ""y_coord"": 18,
      ""bin_recyclable_weight"": 86,
      ""skip_fine"": 11
    },
    {
      ""location_id"": 7,
      ""x_coord"": 62,
      ""y_coord"": 18,
      ""bin_recyclable_weight"": 83,
      ""skip_fine"": 13
    },
    {
      ""location_id"": 8,
      ""x_coord"": 62,
      ""y_coord"": 30,
      ""bin_recyclable_weight"": 43,
      ""skip_fine"": 2
    },
    {
      ""location_id"": 9,
      ""x_coord"": 58,
      ""y_coord"": 30,
      ""bin_recyclable_weight"": 19,
      ""skip_fine"": 22
    },
    {
      ""location_id"": 10,
      ""x_coord"": 64,
      ""y_coord"": 45,
      ""bin_recyclable_weight"": 64,
      ""skip_fine"": 10
    },
    {
      ""location_id"": 11,
      ""x_coord"": 68,
      ""y_coord"": 41,
      ""bin_recyclable_weight"": 43,
      ""skip_fine"": 15
    },
    {
      ""location_id"": 12,
      ""x_coord"": 70,
      ""y_coord"": 26,
      ""bin_recyclable_weight"": 51,
      ""skip_fine"": 29
    },
    {
      ""location_id"": 13,
      ""x_coord"": 64,
      ""y_coord"": 8,
      ""bin_recyclable_weight"": 65,
      ""skip_fine"": 27
    },
    {
      ""location_id"": 14,
      ""x_coord"": 81,
      ""y_coord"": 56,
      ""bin_recyclable_weight"": 94,
      ""skip_fine"": 8
    },
    {
      ""location_id"": 15,
      ""x_coord"": 81,
      ""y_coord"": 79,
      ""bin_recyclable_weight"": 81,
      ""skip_fine"": 12
    },
    {
      ""location_id"": 16,
      ""x_coord"": 100,
      ""y_coord"": 100,
      ""bin_recyclable_weight"": 12,
      ""skip_fine"": 17
    },
    {
      ""location_id"": 17,
      ""x_coord"": 89,
      ""y_coord"": 70,
      ""bin_recyclable_weight"": 91,
      ""skip_fine"": 4
    },
    {
      ""location_id"": 18,
      ""x_coord"": 96,
      ""y_coord"": 89,
      ""bin_recyclable_weight"": 68,
      ""skip_fine"": 24
    }
  ],
  ""depot_id"": 0,
  ""required_total_recyclable_weight"": 475.0
}

Oh, and when you send back the chosen loop, please stick to this simple JSON shape so it's easy to read and check:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

This just means ""solution"" should be an ordered list of the stops on the single loop — start at the depot, list each visited location once in the order you visit them, and finish back at the depot. Think of it like filling out a short form: the array is the route from beginning to end. This is only a sketch of the expected shape, not the actual route — replace those placeholders with the real identifiers from the instance when you answer.

Please make sure all identifiers are used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 37], [0, 52], [38, 0], [38, 30], [41, 18], [41, 11], [58, 18], [62, 18], [62, 30], [58, 30], [64, 45], [68, 41], [70, 26], [64, 8], [81, 56], [81, 79], [100, 100], [89, 70], [96, 89]], 'prizes': [0, 25, 36, 58, 41, 88, 86, 83, 43, 19, 64, 43, 51, 65, 94, 81, 12, 91, 68], 'penalties': [0, 22, 15, 17, 18, 5, 11, 13, 2, 22, 10, 15, 29, 27, 8, 12, 17, 4, 24], 'required_prize': 475.0, 'depot': 0, 'route_length': 211.2142905204936, 'route_prize': 535.0, 'unvisited_penalty': 87.0, 'objective': 298.21421962077716}","[0, 1, 3, 9, 10, 11, 12, 13, 7, 6, 4, 0]",298.21421962077716,"{'problem_type': 'PCTSP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 0, 'y': 37, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 0, 'y': 52, 'prize': 25, 'penalty': 22}, {'id': 2, 'x': 38, 'y': 0, 'prize': 36, 'penalty': 15}, {'id': 3, 'x': 38, 'y': 30, 'prize': 58, 'penalty': 17}, {'id': 4, 'x': 41, 'y': 18, 'prize': 41, 'penalty': 18}, {'id': 5, 'x': 41, 'y': 11, 'prize': 88, 'penalty': 5}, {'id': 6, 'x': 58, 'y': 18, 'prize': 86, 'penalty': 11}, {'id': 7, 'x': 62, 'y': 18, 'prize': 83, 'penalty': 13}, {'id': 8, 'x': 62, 'y': 30, 'prize': 43, 'penalty': 2}, {'id': 9, 'x': 58, 'y': 30, 'prize': 19, 'penalty': 22}, {'id': 10, 'x': 64, 'y': 45, 'prize': 64, 'penalty': 10}, {'id': 11, 'x': 68, 'y': 41, 'prize': 43, 'penalty': 15}, {'id': 12, 'x': 70, 'y': 26, 'prize': 51, 'penalty': 29}, {'id': 13, 'x': 64, 'y': 8, 'prize': 65, 'penalty': 27}, {'id': 14, 'x': 81, 'y': 56, 'prize': 94, 'penalty': 8}, {'id': 15, 'x': 81, 'y': 79, 'prize': 81, 'penalty': 12}, {'id': 16, 'x': 100, 'y': 100, 'prize': 12, 'penalty': 17}, {'id': 17, 'x': 89, 'y': 70, 'prize': 91, 'penalty': 4}, {'id': 18, 'x': 96, 'y': 89, 'prize': 68, 'penalty': 24}], 'depot': 0, 'required_prize': 475.0, 'route_prize': 535.0, 'unvisited_penalty': 87.0, 'route_length': 211.2142905204936, 'objective': 298.21421962077716}","[0, 1, 3, 9, 10, 11, 12, 13, 7, 6, 4, 0]",8,json,0
PCTSP,PCTSP,"Someone in charge of billboard upkeep needs to map out one circuit leaving from and returning to the operations office, stopping at selected signs until the required maintenance coverage is reached. The key decision is which signs to include — the balance to strike is shorter driving against the contractual penalties for signs that don’t get visited. The way to compare plans is straightforward: add the trip’s travel cost to the sum of penalties for any unvisited billboards and aim for the smallest total. Each billboard should be visited at most once, the trip must start and end at the office, and the inspected set must meet the minimum coverage. The specific instance data follow below.

# total_locations_including_office=19
# operations_office_id=A
# required_maintenance_coverage=475.0
billboard_id,x_coordinate,y_coordinate,coverage_value,contractual_penalty
A,22,58,0,0
B,17,57,12,28
C,22,85,71,22
D,23,100,51,25
E,36,59,3,5
F,33,14,56,26
G,51,46,76,13
H,39,59,3,9
I,60,94,66,17
J,60,59,25,26
K,57,57,44,13
L,75,46,7,2
M,70,58,53,9
N,75,71,94,9
O,70,85,30,21
P,85,94,6,29
Q,75,7,85,17
R,100,85,95,8
S,0,0,49,22

You can just hand the route back in a tiny JSON snippet so it's clear and machine-friendly. Something like this:

{
  ""solution"": [office_id, sign_id, ..., office_id]
}

This is just a sketch of the shape I want: the solution array lists the office (start), the signs you plan to visit in order, and the office again (end). The placeholders here are just placeholders — replace them with the actual identifiers from the instance when you give the real route.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[22, 58], [17, 57], [22, 85], [23, 100], [36, 59], [33, 14], [51, 46], [39, 59], [60, 94], [60, 59], [57, 57], [75, 46], [70, 58], [75, 71], [70, 85], [85, 94], [75, 7], [100, 85], [0, 0]], 'prizes': [0, 12, 71, 51, 3, 56, 76, 3, 66, 25, 44, 7, 53, 94, 30, 6, 85, 95, 49], 'penalties': [0, 28, 22, 25, 5, 26, 13, 9, 17, 26, 13, 2, 9, 9, 21, 29, 17, 8, 22], 'required_prize': 475.0, 'depot': 0, 'route_length': 216.92617708666563, 'route_prize': 534.0, 'unvisited_penalty': 75.0, 'objective': 291.9261770866656}","[0, 4, 7, 6, 10, 9, 12, 13, 15, 14, 8, 3, 2, 1, 0]",291.9261770866656,"{'problem_type': 'PCTSP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 22, 'y': 58, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 17, 'y': 57, 'prize': 12, 'penalty': 28}, {'id': 'C', 'x': 22, 'y': 85, 'prize': 71, 'penalty': 22}, {'id': 'D', 'x': 23, 'y': 100, 'prize': 51, 'penalty': 25}, {'id': 'E', 'x': 36, 'y': 59, 'prize': 3, 'penalty': 5}, {'id': 'F', 'x': 33, 'y': 14, 'prize': 56, 'penalty': 26}, {'id': 'G', 'x': 51, 'y': 46, 'prize': 76, 'penalty': 13}, {'id': 'H', 'x': 39, 'y': 59, 'prize': 3, 'penalty': 9}, {'id': 'I', 'x': 60, 'y': 94, 'prize': 66, 'penalty': 17}, {'id': 'J', 'x': 60, 'y': 59, 'prize': 25, 'penalty': 26}, {'id': 'K', 'x': 57, 'y': 57, 'prize': 44, 'penalty': 13}, {'id': 'L', 'x': 75, 'y': 46, 'prize': 7, 'penalty': 2}, {'id': 'M', 'x': 70, 'y': 58, 'prize': 53, 'penalty': 9}, {'id': 'N', 'x': 75, 'y': 71, 'prize': 94, 'penalty': 9}, {'id': 'O', 'x': 70, 'y': 85, 'prize': 30, 'penalty': 21}, {'id': 'P', 'x': 85, 'y': 94, 'prize': 6, 'penalty': 29}, {'id': 'Q', 'x': 75, 'y': 7, 'prize': 85, 'penalty': 17}, {'id': 'R', 'x': 100, 'y': 85, 'prize': 95, 'penalty': 8}, {'id': 'S', 'x': 0, 'y': 0, 'prize': 49, 'penalty': 22}], 'depot': 'A', 'required_prize': 475.0, 'route_prize': 534.0, 'unvisited_penalty': 75.0, 'route_length': 216.92617708666563, 'objective': 291.9261770866656}","['A', 'E', 'H', 'G', 'K', 'J', 'M', 'N', 'P', 'O', 'I', 'D', 'C', 'B', 'A']",9,csv,names
PCTSP,PCTSP,"There’s a field season coming up and someone has to sketch a single sampling circuit that begins and ends at base and visits selected locations. The decision is which locations to include so that the collected data adds up to at least the required threshold. To compare plans, tally the distance or time for the whole loop and then add a penalty for each location that isn’t visited — the plan with the smallest total is preferred. The tour must be one continuous loop without revisiting places, and the concrete details are shown below.

There are 21 sites in total (base camp is 1); the tour must collect at least 525.0 total data.
Site 1 at (61, 91) provides 0 data and incurs 0 if not visited.
Site 2 at (0, 72) provides 6 data and incurs 12 if not visited.
Site 3 at (60, 67) provides 65 data and incurs 26 if not visited.
Site 4 at (96, 56) provides 38 data and incurs 22 if not visited.
Site 5 at (48, 53) provides 45 data and incurs 16 if not visited.
Site 6 at (36, 33) provides 7 data and incurs 18 if not visited.
Site 7 at (57, 32) provides 48 data and incurs 31 if not visited.
Site 8 at (63, 91) provides 61 data and incurs 21 if not visited.
Site 9 at (100, 70) provides 98 data and incurs 20 if not visited.
Site 10 at (91, 70) provides 2 data and incurs 12 if not visited.
Site 11 at (55, 53) provides 52 data and incurs 25 if not visited.
Site 12 at (84, 100) provides 49 data and incurs 28 if not visited.
Site 13 at (27, 100) provides 63 data and incurs 10 if not visited.
Site 14 at (24, 1) provides 85 data and incurs 11 if not visited.
Site 15 at (24, 0) provides 50 data and incurs 22 if not visited.
Site 16 at (20, 100) provides 57 data and incurs 9 if not visited.
Site 17 at (77, 99) provides 50 data and incurs 3 if not visited.
Site 18 at (77, 99) provides 80 data and incurs 9 if not visited.
Site 19 at (4, 0) provides 91 data and incurs 22 if not visited.
Site 20 at (91, 1) provides 32 data and incurs 16 if not visited.
Site 21 at (30, 0) provides 72 data and incurs 19 if not visited.
Prefer the single continuous loop with the smallest sum of travel distance and missed-sample penalties.

When you send the chosen loop back, just drop it in a tiny JSON snippet like this so it's easy to parse:

{
  ""solution"": [base_id, site_id, ..., base_id]
}

Think of that array as the ordered loop: start at the base, list each site you plan to visit in the order you'll hit them, and finish back at the base. It's just a shape sketch — not the final plan itself.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[61, 91], [0, 72], [60, 67], [96, 56], [48, 53], [36, 33], [57, 32], [63, 91], [100, 70], [91, 70], [55, 53], [84, 100], [27, 100], [24, 1], [24, 0], [20, 100], [77, 99], [77, 99], [4, 0], [91, 1], [30, 0]], 'prizes': [0, 6, 65, 38, 45, 7, 48, 61, 98, 2, 52, 49, 63, 85, 50, 57, 50, 80, 91, 32, 72], 'penalties': [0, 12, 26, 22, 16, 18, 31, 21, 20, 12, 25, 28, 10, 11, 22, 9, 3, 9, 22, 16, 19], 'required_prize': 525.0, 'depot': 0, 'route_length': 194.08887161978245, 'route_prize': 588.0, 'unvisited_penalty': 139.0, 'objective': 333.0888716197824}","[0, 2, 10, 4, 6, 3, 8, 9, 11, 16, 17, 7, 0]",333.0888716197824,"{'problem_type': 'PCTSP', 'num_nodes': 21, 'nodes': [{'id': 1, 'x': 61, 'y': 91, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 0, 'y': 72, 'prize': 6, 'penalty': 12}, {'id': 3, 'x': 60, 'y': 67, 'prize': 65, 'penalty': 26}, {'id': 4, 'x': 96, 'y': 56, 'prize': 38, 'penalty': 22}, {'id': 5, 'x': 48, 'y': 53, 'prize': 45, 'penalty': 16}, {'id': 6, 'x': 36, 'y': 33, 'prize': 7, 'penalty': 18}, {'id': 7, 'x': 57, 'y': 32, 'prize': 48, 'penalty': 31}, {'id': 8, 'x': 63, 'y': 91, 'prize': 61, 'penalty': 21}, {'id': 9, 'x': 100, 'y': 70, 'prize': 98, 'penalty': 20}, {'id': 10, 'x': 91, 'y': 70, 'prize': 2, 'penalty': 12}, {'id': 11, 'x': 55, 'y': 53, 'prize': 52, 'penalty': 25}, {'id': 12, 'x': 84, 'y': 100, 'prize': 49, 'penalty': 28}, {'id': 13, 'x': 27, 'y': 100, 'prize': 63, 'penalty': 10}, {'id': 14, 'x': 24, 'y': 1, 'prize': 85, 'penalty': 11}, {'id': 15, 'x': 24, 'y': 0, 'prize': 50, 'penalty': 22}, {'id': 16, 'x': 20, 'y': 100, 'prize': 57, 'penalty': 9}, {'id': 17, 'x': 77, 'y': 99, 'prize': 50, 'penalty': 3}, {'id': 18, 'x': 77, 'y': 99, 'prize': 80, 'penalty': 9}, {'id': 19, 'x': 4, 'y': 0, 'prize': 91, 'penalty': 22}, {'id': 20, 'x': 91, 'y': 1, 'prize': 32, 'penalty': 16}, {'id': 21, 'x': 30, 'y': 0, 'prize': 72, 'penalty': 19}], 'depot': 1, 'required_prize': 525.0, 'route_prize': 588.0, 'unvisited_penalty': 139.0, 'route_length': 194.08887161978245, 'objective': 333.0888716197824}","[1, 3, 11, 5, 7, 4, 9, 10, 12, 17, 18, 8, 1]",10,nl,1
PCTSP,PCTSP,"We’ve got to map out one uninterrupted sales run from headquarters and back, choosing a subset of boutiques to visit until the target order volume is reached. The decision is which boutiques make the cut — each chosen boutique is visited one time during the loop and the tour must be continuous. The “score” for a route is simple: total travel mileage plus the lost-commission penalties for boutiques that weren’t visited, and the aim is to make that sum as small as possible while reaching the order goal. The specific numbers and locations appear below.

# total_locations_including_office=20
# office_node_id=0
# target_order_volume=500.0
location_node_id,map_x_coordinate,map_y_coordinate,order_volume_from_boutique,lost_commission_penalty
0,75,8,0,0
1,0,6,54,10
2,50,31,96,20
3,5,82,81,5
4,5,100,96,10
5,96,96,69,4
6,39,93,80,20
7,100,23,75,16
8,77,11,94,13
9,5,4,34,7
10,72,44,32,25
11,22,12,1,12
12,71,76,7,27
13,36,13,96,8
14,47,15,47,19
15,64,0,12,21
16,24,79,11,5
17,92,32,52,5
18,40,61,65,22
19,48,95,83,3

Also, when you send the chosen loop back, please use this simple JSON layout so I can read it automatically:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

""solution"" should be a single list that starts at the depot, lists each boutique you visit in the order you visit them, and ends back at the depot. Think of it like filling in a short route sheet: depot → shop → shop → ... → depot.

Just a quick reminder: use the exact identifiers shown in the instance input — don’t rename them or invent new ones. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[75, 8], [0, 6], [50, 31], [5, 82], [5, 100], [96, 96], [39, 93], [100, 23], [77, 11], [5, 4], [72, 44], [22, 12], [71, 76], [36, 13], [47, 15], [64, 0], [24, 79], [92, 32], [40, 61], [48, 95]], 'prizes': [0, 54, 96, 81, 96, 69, 80, 75, 94, 34, 32, 1, 7, 96, 47, 12, 11, 52, 65, 83], 'penalties': [0, 10, 20, 5, 10, 4, 20, 16, 13, 7, 25, 12, 27, 8, 19, 21, 5, 5, 22, 3], 'required_prize': 500.0, 'depot': 0, 'route_length': 160.7239486498709, 'route_prize': 504.0, 'unvisited_penalty': 125.0, 'objective': 285.72394864987086}","[0, 8, 7, 17, 10, 2, 13, 14, 15, 0]",285.72394864987086,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 75, 'y': 8, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 0, 'y': 6, 'prize': 54, 'penalty': 10}, {'id': 2, 'x': 50, 'y': 31, 'prize': 96, 'penalty': 20}, {'id': 3, 'x': 5, 'y': 82, 'prize': 81, 'penalty': 5}, {'id': 4, 'x': 5, 'y': 100, 'prize': 96, 'penalty': 10}, {'id': 5, 'x': 96, 'y': 96, 'prize': 69, 'penalty': 4}, {'id': 6, 'x': 39, 'y': 93, 'prize': 80, 'penalty': 20}, {'id': 7, 'x': 100, 'y': 23, 'prize': 75, 'penalty': 16}, {'id': 8, 'x': 77, 'y': 11, 'prize': 94, 'penalty': 13}, {'id': 9, 'x': 5, 'y': 4, 'prize': 34, 'penalty': 7}, {'id': 10, 'x': 72, 'y': 44, 'prize': 32, 'penalty': 25}, {'id': 11, 'x': 22, 'y': 12, 'prize': 1, 'penalty': 12}, {'id': 12, 'x': 71, 'y': 76, 'prize': 7, 'penalty': 27}, {'id': 13, 'x': 36, 'y': 13, 'prize': 96, 'penalty': 8}, {'id': 14, 'x': 47, 'y': 15, 'prize': 47, 'penalty': 19}, {'id': 15, 'x': 64, 'y': 0, 'prize': 12, 'penalty': 21}, {'id': 16, 'x': 24, 'y': 79, 'prize': 11, 'penalty': 5}, {'id': 17, 'x': 92, 'y': 32, 'prize': 52, 'penalty': 5}, {'id': 18, 'x': 40, 'y': 61, 'prize': 65, 'penalty': 22}, {'id': 19, 'x': 48, 'y': 95, 'prize': 83, 'penalty': 3}], 'depot': 0, 'required_prize': 500.0, 'route_prize': 504.0, 'unvisited_penalty': 125.0, 'route_length': 160.7239486498709, 'objective': 285.72394864987086}","[0, 8, 7, 17, 10, 2, 13, 14, 15, 0]",11,csv,0
PCTSP,PCTSP,"Picture this: the library needs the bookmobile to do one tidy circuit — leave the library, stop at a selection of community drop boxes, collect enough returns to hit the target, and pull back into the library. The job is choosing which boxes make the list and in what order so driving distance is minimized while avoiding big overdue or service penalties for any boxes skipped. The way to compare routes is straightforward: add up the driving distance and the penalties for unvisited boxes — smaller totals are better. The trip has to be a single continuous loop, each box visited at most once, and the pickups must meet or exceed the required total. The concrete box-by-box details, distances, return counts, and skip penalties follow below.

{
  ""total_locations_including_library"": 16,
  ""nodes"": [
    {
      ""location_node_id"": ""A"",
      ""x_coordinate"": 32,
      ""y_coordinate"": 42,
      ""returns_at_box"": 0,
      ""missed_box_penalty"": 0
    },
    {
      ""location_node_id"": ""B"",
      ""x_coordinate"": 97,
      ""y_coordinate"": 28,
      ""returns_at_box"": 8,
      ""missed_box_penalty"": 11
    },
    {
      ""location_node_id"": ""C"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 10,
      ""returns_at_box"": 96,
      ""missed_box_penalty"": 28
    },
    {
      ""location_node_id"": ""D"",
      ""x_coordinate"": 46,
      ""y_coordinate"": 90,
      ""returns_at_box"": 84,
      ""missed_box_penalty"": 17
    },
    {
      ""location_node_id"": ""E"",
      ""x_coordinate"": 22,
      ""y_coordinate"": 1,
      ""returns_at_box"": 23,
      ""missed_box_penalty"": 28
    },
    {
      ""location_node_id"": ""F"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 21,
      ""returns_at_box"": 84,
      ""missed_box_penalty"": 6
    },
    {
      ""location_node_id"": ""G"",
      ""x_coordinate"": 25,
      ""y_coordinate"": 8,
      ""returns_at_box"": 75,
      ""missed_box_penalty"": 25
    },
    {
      ""location_node_id"": ""H"",
      ""x_coordinate"": 11,
      ""y_coordinate"": 82,
      ""returns_at_box"": 11,
      ""missed_box_penalty"": 29
    },
    {
      ""location_node_id"": ""I"",
      ""x_coordinate"": 4,
      ""y_coordinate"": 44,
      ""returns_at_box"": 27,
      ""missed_box_penalty"": 32
    },
    {
      ""location_node_id"": ""J"",
      ""x_coordinate"": 63,
      ""y_coordinate"": 22,
      ""returns_at_box"": 64,
      ""missed_box_penalty"": 11
    },
    {
      ""location_node_id"": ""K"",
      ""x_coordinate"": 86,
      ""y_coordinate"": 46,
      ""returns_at_box"": 71,
      ""missed_box_penalty"": 33
    },
    {
      ""location_node_id"": ""L"",
      ""x_coordinate"": 55,
      ""y_coordinate"": 43,
      ""returns_at_box"": 34,
      ""missed_box_penalty"": 21
    },
    {
      ""location_node_id"": ""M"",
      ""x_coordinate"": 3,
      ""y_coordinate"": 83,
      ""returns_at_box"": 13,
      ""missed_box_penalty"": 11
    },
    {
      ""location_node_id"": ""N"",
      ""x_coordinate"": 90,
      ""y_coordinate"": 24,
      ""returns_at_box"": 49,
      ""missed_box_penalty"": 1
    },
    {
      ""location_node_id"": ""O"",
      ""x_coordinate"": 89,
      ""y_coordinate"": 100,
      ""returns_at_box"": 76,
      ""missed_box_penalty"": 24
    },
    {
      ""location_node_id"": ""P"",
      ""x_coordinate"": 24,
      ""y_coordinate"": 0,
      ""returns_at_box"": 52,
      ""missed_box_penalty"": 35
    }
  ],
  ""library_node_id"": ""A"",
  ""required_returns_target"": 400.0
}

Oh, and when you send the chosen route back, please use this simple JSON shape so it's easy to read by whatever's checking the answers:

{
  ""solution"": [""library_id"", ""box_id"", ..., ""library_id""]
}

This little sketch means: the ""solution"" array is the tour in order — start at the library, list each drop box you plan to visit (at most once), and finish back at the library. It's just an example of the shape I need, not the actual final route.

Please use the exact identifiers from the instance input — don't rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[32, 42], [97, 28], [0, 10], [46, 90], [22, 1], [100, 21], [25, 8], [11, 82], [4, 44], [63, 22], [86, 46], [55, 43], [3, 83], [90, 24], [89, 100], [24, 0]], 'prizes': [0, 8, 96, 84, 23, 84, 75, 11, 27, 64, 71, 34, 13, 49, 76, 52], 'penalties': [0, 11, 28, 17, 28, 6, 25, 29, 32, 11, 33, 21, 11, 1, 24, 35], 'required_prize': 400.0, 'depot': 0, 'route_length': 224.2788832173516, 'route_prize': 442.0, 'unvisited_penalty': 99.0, 'objective': 323.27888321735156}","[0, 11, 10, 9, 6, 15, 4, 2, 8, 0]",323.27888321735156,"{'problem_type': 'PCTSP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 32, 'y': 42, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 97, 'y': 28, 'prize': 8, 'penalty': 11}, {'id': 'C', 'x': 0, 'y': 10, 'prize': 96, 'penalty': 28}, {'id': 'D', 'x': 46, 'y': 90, 'prize': 84, 'penalty': 17}, {'id': 'E', 'x': 22, 'y': 1, 'prize': 23, 'penalty': 28}, {'id': 'F', 'x': 100, 'y': 21, 'prize': 84, 'penalty': 6}, {'id': 'G', 'x': 25, 'y': 8, 'prize': 75, 'penalty': 25}, {'id': 'H', 'x': 11, 'y': 82, 'prize': 11, 'penalty': 29}, {'id': 'I', 'x': 4, 'y': 44, 'prize': 27, 'penalty': 32}, {'id': 'J', 'x': 63, 'y': 22, 'prize': 64, 'penalty': 11}, {'id': 'K', 'x': 86, 'y': 46, 'prize': 71, 'penalty': 33}, {'id': 'L', 'x': 55, 'y': 43, 'prize': 34, 'penalty': 21}, {'id': 'M', 'x': 3, 'y': 83, 'prize': 13, 'penalty': 11}, {'id': 'N', 'x': 90, 'y': 24, 'prize': 49, 'penalty': 1}, {'id': 'O', 'x': 89, 'y': 100, 'prize': 76, 'penalty': 24}, {'id': 'P', 'x': 24, 'y': 0, 'prize': 52, 'penalty': 35}], 'depot': 'A', 'required_prize': 400.0, 'route_prize': 442.0, 'unvisited_penalty': 99.0, 'route_length': 224.2788832173516, 'objective': 323.27888321735156}","['A', 'L', 'K', 'J', 'G', 'P', 'E', 'C', 'I', 'A']",12,json,names
PCTSP,PCTSP,"Picture running a mobile detailing service and having to draw one continuous circuit from the shop that picks up certain customers so the bookings meet the minimum revenue goal. The selection should keep costs down, where cost means the total time spent driving that loop plus any refunds or cancellation costs paid to customers who don’t get a visit. It has to be a single outing that leaves and returns to the shop, visiting each chosen address once and not revisiting places. The exact instance information — locations, booking values, penalties, and the revenue requirement — is listed below.

# total_addresses_including_shop=25
# shop_node_id=1
# required_booking_revenue=625.0
location_id,x_coordinate,y_coordinate,booking_revenue_if_served,refund_or_cancellation_cost_if_skipped
1,0,0,0,0
2,29,0,30,17
3,29,10,33,22
4,27,10,49,8
5,29,15,98,4
6,25,21,43,24
7,25,33,39,21
8,21,36,49,10
9,29,41,22,16
10,31,44,29,6
11,25,46,81,9
12,30,49,89,19
13,29,49,37,21
14,24,49,48,24
15,19,49,90,18
16,31,54,71,22
17,37,54,46,5
18,36,56,96,19
19,36,67,89,27
20,44,74,46,25
21,44,82,19,21
22,44,85,84,24
23,44,87,90,12
24,40,100,67,9
25,100,39,81,17

When you send back the route, just use this simple JSON layout so it's easy to parse:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of ""solution"" as the ordered list of stops for the single outing — start at the shop (depot_id), go visit the listed locations in order, and come back to the shop (the final depot_id). The placeholders are just showing the shape I expect, not the actual route — so treat this as a template.

Please use the exact identifiers from the instance input — no renaming, no made-up labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [29, 0], [29, 10], [27, 10], [29, 15], [25, 21], [25, 33], [21, 36], [29, 41], [31, 44], [25, 46], [30, 49], [29, 49], [24, 49], [19, 49], [31, 54], [37, 54], [36, 56], [36, 67], [44, 74], [44, 82], [44, 85], [44, 87], [40, 100], [100, 39]], 'prizes': [0, 30, 33, 49, 98, 43, 39, 49, 22, 29, 81, 89, 37, 48, 90, 71, 46, 96, 89, 46, 19, 84, 90, 67, 81], 'penalties': [0, 17, 22, 8, 4, 24, 21, 10, 16, 6, 9, 19, 21, 24, 18, 22, 5, 19, 27, 25, 21, 24, 12, 9, 17], 'required_prize': 625.0, 'depot': 0, 'route_length': 234.1152752201579, 'route_prize': 1278.0, 'unvisited_penalty': 26.0, 'objective': 260.11526986600927}","[0, 1, 3, 2, 4, 5, 6, 8, 9, 16, 17, 19, 20, 21, 22, 18, 15, 11, 12, 10, 13, 14, 7, 0]",260.11526986600927,"{'problem_type': 'PCTSP', 'num_nodes': 25, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 29, 'y': 0, 'prize': 30, 'penalty': 17}, {'id': 3, 'x': 29, 'y': 10, 'prize': 33, 'penalty': 22}, {'id': 4, 'x': 27, 'y': 10, 'prize': 49, 'penalty': 8}, {'id': 5, 'x': 29, 'y': 15, 'prize': 98, 'penalty': 4}, {'id': 6, 'x': 25, 'y': 21, 'prize': 43, 'penalty': 24}, {'id': 7, 'x': 25, 'y': 33, 'prize': 39, 'penalty': 21}, {'id': 8, 'x': 21, 'y': 36, 'prize': 49, 'penalty': 10}, {'id': 9, 'x': 29, 'y': 41, 'prize': 22, 'penalty': 16}, {'id': 10, 'x': 31, 'y': 44, 'prize': 29, 'penalty': 6}, {'id': 11, 'x': 25, 'y': 46, 'prize': 81, 'penalty': 9}, {'id': 12, 'x': 30, 'y': 49, 'prize': 89, 'penalty': 19}, {'id': 13, 'x': 29, 'y': 49, 'prize': 37, 'penalty': 21}, {'id': 14, 'x': 24, 'y': 49, 'prize': 48, 'penalty': 24}, {'id': 15, 'x': 19, 'y': 49, 'prize': 90, 'penalty': 18}, {'id': 16, 'x': 31, 'y': 54, 'prize': 71, 'penalty': 22}, {'id': 17, 'x': 37, 'y': 54, 'prize': 46, 'penalty': 5}, {'id': 18, 'x': 36, 'y': 56, 'prize': 96, 'penalty': 19}, {'id': 19, 'x': 36, 'y': 67, 'prize': 89, 'penalty': 27}, {'id': 20, 'x': 44, 'y': 74, 'prize': 46, 'penalty': 25}, {'id': 21, 'x': 44, 'y': 82, 'prize': 19, 'penalty': 21}, {'id': 22, 'x': 44, 'y': 85, 'prize': 84, 'penalty': 24}, {'id': 23, 'x': 44, 'y': 87, 'prize': 90, 'penalty': 12}, {'id': 24, 'x': 40, 'y': 100, 'prize': 67, 'penalty': 9}, {'id': 25, 'x': 100, 'y': 39, 'prize': 81, 'penalty': 17}], 'depot': 1, 'required_prize': 625.0, 'route_prize': 1278.0, 'unvisited_penalty': 26.0, 'route_length': 234.1152752201579, 'objective': 260.11526986600927}","[1, 2, 4, 3, 5, 6, 7, 9, 10, 17, 18, 20, 21, 22, 23, 19, 16, 12, 13, 11, 14, 15, 8, 1]",13,csv,1
PCTSP,PCTSP,"There’s a need to map out a single round trip from the health center that stops at chosen neighborhoods until the expected donor count meets a preset minimum. To compare different route choices, total up how much it costs to drive the whole loop and then add a penalty cost for each neighborhood that wasn’t visited — the best route minimizes that total. The journey must start and end at the health center, avoid repeat visits, and the chosen stops must together reach the required donor total. The concrete details are provided below.

{
  ""total_locations_including_health_center"": 23,
  ""nodes"": [
    {
      ""neighborhood_node_id"": 1,
      ""x_coordinate_location"": 67,
      ""y_coordinate_location"": 42,
      ""expected_donors_at_location"": 0,
      ""penalty_cost_if_not_visited"": 0
    },
    {
      ""neighborhood_node_id"": 2,
      ""x_coordinate_location"": 61,
      ""y_coordinate_location"": 81,
      ""expected_donors_at_location"": 4,
      ""penalty_cost_if_not_visited"": 25
    },
    {
      ""neighborhood_node_id"": 3,
      ""x_coordinate_location"": 92,
      ""y_coordinate_location"": 61,
      ""expected_donors_at_location"": 27,
      ""penalty_cost_if_not_visited"": 24
    },
    {
      ""neighborhood_node_id"": 4,
      ""x_coordinate_location"": 65,
      ""y_coordinate_location"": 100,
      ""expected_donors_at_location"": 58,
      ""penalty_cost_if_not_visited"": 1
    },
    {
      ""neighborhood_node_id"": 5,
      ""x_coordinate_location"": 100,
      ""y_coordinate_location"": 33,
      ""expected_donors_at_location"": 6,
      ""penalty_cost_if_not_visited"": 5
    },
    {
      ""neighborhood_node_id"": 6,
      ""x_coordinate_location"": 5,
      ""y_coordinate_location"": 47,
      ""expected_donors_at_location"": 6,
      ""penalty_cost_if_not_visited"": 1
    },
    {
      ""neighborhood_node_id"": 7,
      ""x_coordinate_location"": 22,
      ""y_coordinate_location"": 81,
      ""expected_donors_at_location"": 38,
      ""penalty_cost_if_not_visited"": 0
    },
    {
      ""neighborhood_node_id"": 8,
      ""x_coordinate_location"": 60,
      ""y_coordinate_location"": 86,
      ""expected_donors_at_location"": 12,
      ""penalty_cost_if_not_visited"": 29
    },
    {
      ""neighborhood_node_id"": 9,
      ""x_coordinate_location"": 3,
      ""y_coordinate_location"": 84,
      ""expected_donors_at_location"": 41,
      ""penalty_cost_if_not_visited"": 29
    },
    {
      ""neighborhood_node_id"": 10,
      ""x_coordinate_location"": 58,
      ""y_coordinate_location"": 59,
      ""expected_donors_at_location"": 67,
      ""penalty_cost_if_not_visited"": 16
    },
    {
      ""neighborhood_node_id"": 11,
      ""x_coordinate_location"": 2,
      ""y_coordinate_location"": 28,
      ""expected_donors_at_location"": 47,
      ""penalty_cost_if_not_visited"": 4
    },
    {
      ""neighborhood_node_id"": 12,
      ""x_coordinate_location"": 0,
      ""y_coordinate_location"": 0,
      ""expected_donors_at_location"": 2,
      ""penalty_cost_if_not_visited"": 4
    },
    {
      ""neighborhood_node_id"": 13,
      ""x_coordinate_location"": 5,
      ""y_coordinate_location"": 11,
      ""expected_donors_at_location"": 93,
      ""penalty_cost_if_not_visited"": 27
    },
    {
      ""neighborhood_node_id"": 14,
      ""x_coordinate_location"": 69,
      ""y_coordinate_location"": 75,
      ""expected_donors_at_location"": 25,
      ""penalty_cost_if_not_visited"": 27
    },
    {
      ""neighborhood_node_id"": 15,
      ""x_coordinate_location"": 45,
      ""y_coordinate_location"": 90,
      ""expected_donors_at_location"": 1,
      ""penalty_cost_if_not_visited"": 17
    },
    {
      ""neighborhood_node_id"": 16,
      ""x_coordinate_location"": 68,
      ""y_coordinate_location"": 96,
      ""expected_donors_at_location"": 44,
      ""penalty_cost_if_not_visited"": 21
    },
    {
      ""neighborhood_node_id"": 17,
      ""x_coordinate_location"": 88,
      ""y_coordinate_location"": 43,
      ""expected_donors_at_location"": 85,
      ""penalty_cost_if_not_visited"": 18
    },
    {
      ""neighborhood_node_id"": 18,
      ""x_coordinate_location"": 87,
      ""y_coordinate_location"": 96,
      ""expected_donors_at_location"": 93,
      ""penalty_cost_if_not_visited"": 21
    },
    {
      ""neighborhood_node_id"": 19,
      ""x_coordinate_location"": 65,
      ""y_coordinate_location"": 16,
      ""expected_donors_at_location"": 13,
      ""penalty_cost_if_not_visited"": 29
    },
    {
      ""neighborhood_node_id"": 20,
      ""x_coordinate_location"": 5,
      ""y_coordinate_location"": 18,
      ""expected_donors_at_location"": 7,
      ""penalty_cost_if_not_visited"": 13
    },
    {
      ""neighborhood_node_id"": 21,
      ""x_coordinate_location"": 66,
      ""y_coordinate_location"": 47,
      ""expected_donors_at_location"": 83,
      ""penalty_cost_if_not_visited"": 2
    },
    {
      ""neighborhood_node_id"": 22,
      ""x_coordinate_location"": 87,
      ""y_coordinate_location"": 7,
      ""expected_donors_at_location"": 84,
      ""penalty_cost_if_not_visited"": 2
    },
    {
      ""neighborhood_node_id"": 23,
      ""x_coordinate_location"": 75,
      ""y_coordinate_location"": 84,
      ""expected_donors_at_location"": 91,
      ""penalty_cost_if_not_visited"": 19
    }
  ],
  ""health_center_node_id"": 1,
  ""required_minimum_expected_donors"": 575.0
}

Also, when you send back the chosen round trip, just put it in a tiny JSON snippet like this:

{
  ""solution"": [health_center_id, neighborhood_id, ..., health_center_id]
}

Think of that array as the form you fill out: start with the health center, then list the neighborhoods you plan to visit in order (no repeats), and finish by returning to the health center. This is just a sketch of the expected shape — not the actual route.

Please make sure to use the exact identifiers from the instance input — do not rename them or make up new labels.

For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[67, 42], [61, 81], [92, 61], [65, 100], [100, 33], [5, 47], [22, 81], [60, 86], [3, 84], [58, 59], [2, 28], [0, 0], [5, 11], [69, 75], [45, 90], [68, 96], [88, 43], [87, 96], [65, 16], [5, 18], [66, 47], [87, 7], [75, 84]], 'prizes': [0, 4, 27, 58, 6, 6, 38, 12, 41, 67, 47, 2, 93, 25, 1, 44, 85, 93, 13, 7, 83, 84, 91], 'penalties': [0, 25, 24, 1, 5, 1, 0, 29, 29, 16, 4, 4, 27, 27, 17, 21, 18, 21, 29, 13, 2, 2, 19], 'required_prize': 575.0, 'depot': 0, 'route_length': 177.93694771214936, 'route_prize': 589.0, 'unvisited_penalty': 131.0, 'objective': 308.9369477121494}","[0, 16, 2, 22, 17, 15, 3, 7, 1, 13, 9, 20, 0]",308.9369477121494,"{'problem_type': 'PCTSP', 'num_nodes': 23, 'nodes': [{'id': 1, 'x': 67, 'y': 42, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 61, 'y': 81, 'prize': 4, 'penalty': 25}, {'id': 3, 'x': 92, 'y': 61, 'prize': 27, 'penalty': 24}, {'id': 4, 'x': 65, 'y': 100, 'prize': 58, 'penalty': 1}, {'id': 5, 'x': 100, 'y': 33, 'prize': 6, 'penalty': 5}, {'id': 6, 'x': 5, 'y': 47, 'prize': 6, 'penalty': 1}, {'id': 7, 'x': 22, 'y': 81, 'prize': 38, 'penalty': 0}, {'id': 8, 'x': 60, 'y': 86, 'prize': 12, 'penalty': 29}, {'id': 9, 'x': 3, 'y': 84, 'prize': 41, 'penalty': 29}, {'id': 10, 'x': 58, 'y': 59, 'prize': 67, 'penalty': 16}, {'id': 11, 'x': 2, 'y': 28, 'prize': 47, 'penalty': 4}, {'id': 12, 'x': 0, 'y': 0, 'prize': 2, 'penalty': 4}, {'id': 13, 'x': 5, 'y': 11, 'prize': 93, 'penalty': 27}, {'id': 14, 'x': 69, 'y': 75, 'prize': 25, 'penalty': 27}, {'id': 15, 'x': 45, 'y': 90, 'prize': 1, 'penalty': 17}, {'id': 16, 'x': 68, 'y': 96, 'prize': 44, 'penalty': 21}, {'id': 17, 'x': 88, 'y': 43, 'prize': 85, 'penalty': 18}, {'id': 18, 'x': 87, 'y': 96, 'prize': 93, 'penalty': 21}, {'id': 19, 'x': 65, 'y': 16, 'prize': 13, 'penalty': 29}, {'id': 20, 'x': 5, 'y': 18, 'prize': 7, 'penalty': 13}, {'id': 21, 'x': 66, 'y': 47, 'prize': 83, 'penalty': 2}, {'id': 22, 'x': 87, 'y': 7, 'prize': 84, 'penalty': 2}, {'id': 23, 'x': 75, 'y': 84, 'prize': 91, 'penalty': 19}], 'depot': 1, 'required_prize': 575.0, 'route_prize': 589.0, 'unvisited_penalty': 131.0, 'route_length': 177.93694771214936, 'objective': 308.9369477121494}","[1, 17, 3, 23, 18, 16, 4, 8, 2, 14, 10, 21, 1]",14,json,1
PCTSP,PCTSP,"Imagine the admissions director sketching one continuous recruiting route that departs campus, visits a handful of schools, and returns to campus — the stops must bring the total prospective student contacts up to the required threshold. The task is to pick which schools to include and the order to visit them; a smarter choice keeps the combined bill low by minimizing the round-trip travel cost plus the outreach penalties for any schools left out. Concretely, you’d compute that combined score by summing the travel expense for the whole circuit and the penalties for skipped schools, and the tour has to be a single loop with no repeated stops while meeting the contact target. The full instance details are below.

Continuing that picture, the instance lists 17 locations, the campus depot is 0, and the required contact target is 425.0.

| school_id | location_x | location_y | contacts_at_school | outreach_penalty_if_skipped |
|---|---|---|---|---|
| 0 | 0 | 58 | 0 | 0 |
| 1 | 63 | 26 | 11 | 5 |
| 2 | 60 | 89 | 88 | 30 |
| 3 | 69 | 100 | 94 | 20 |
| 4 | 90 | 84 | 11 | 19 |
| 5 | 98 | 86 | 22 | 24 |
| 6 | 100 | 20 | 99 | 29 |
| 7 | 77 | 24 | 92 | 32 |
| 8 | 66 | 0 | 63 | 2 |
| 9 | 55 | 8 | 47 | 1 |
| 10 | 47 | 75 | 79 | 3 |
| 11 | 40 | 45 | 49 | 33 |
| 12 | 44 | 98 | 98 | 18 |
| 13 | 22 | 84 | 77 | 13 |
| 14 | 22 | 66 | 64 | 21 |
| 15 | 13 | 66 | 11 | 4 |
| 16 | 11 | 89 | 72 | 13 |

Plan a single-loop recruiting tour that meets at least 425.0 contacts, departs from and returns to campus 0, and balances travel cost against outreach penalties across the 17 locations.

Oh, and when you reply with the route, toss it into this simple JSON shape so it's easy to read and check:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of that as a little form: the solution field is the ordered list of stops on the single loop — it starts at the depot, lists each school or site you plan to visit in order, and ends back at the depot. This is just the expected shape, not the actual route — fill it in with the exact IDs from the instance when you submit.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 58], [63, 26], [60, 89], [69, 100], [90, 84], [98, 86], [100, 20], [77, 24], [66, 0], [55, 8], [47, 75], [40, 45], [44, 98], [22, 84], [22, 66], [13, 66], [11, 89]], 'prizes': [0, 11, 88, 94, 11, 22, 99, 92, 63, 47, 79, 49, 98, 77, 64, 11, 72], 'penalties': [0, 5, 30, 20, 19, 24, 29, 32, 2, 1, 3, 33, 18, 13, 21, 4, 13], 'required_prize': 425.0, 'depot': 0, 'route_length': 191.244971422282, 'route_prize': 538.0, 'unvisited_penalty': 132.0, 'objective': 323.244971422282}","[0, 16, 13, 12, 2, 10, 11, 14, 15, 0]",323.244971422282,"{'problem_type': 'PCTSP', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 0, 'y': 58, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 63, 'y': 26, 'prize': 11, 'penalty': 5}, {'id': 2, 'x': 60, 'y': 89, 'prize': 88, 'penalty': 30}, {'id': 3, 'x': 69, 'y': 100, 'prize': 94, 'penalty': 20}, {'id': 4, 'x': 90, 'y': 84, 'prize': 11, 'penalty': 19}, {'id': 5, 'x': 98, 'y': 86, 'prize': 22, 'penalty': 24}, {'id': 6, 'x': 100, 'y': 20, 'prize': 99, 'penalty': 29}, {'id': 7, 'x': 77, 'y': 24, 'prize': 92, 'penalty': 32}, {'id': 8, 'x': 66, 'y': 0, 'prize': 63, 'penalty': 2}, {'id': 9, 'x': 55, 'y': 8, 'prize': 47, 'penalty': 1}, {'id': 10, 'x': 47, 'y': 75, 'prize': 79, 'penalty': 3}, {'id': 11, 'x': 40, 'y': 45, 'prize': 49, 'penalty': 33}, {'id': 12, 'x': 44, 'y': 98, 'prize': 98, 'penalty': 18}, {'id': 13, 'x': 22, 'y': 84, 'prize': 77, 'penalty': 13}, {'id': 14, 'x': 22, 'y': 66, 'prize': 64, 'penalty': 21}, {'id': 15, 'x': 13, 'y': 66, 'prize': 11, 'penalty': 4}, {'id': 16, 'x': 11, 'y': 89, 'prize': 72, 'penalty': 13}], 'depot': 0, 'required_prize': 425.0, 'route_prize': 538.0, 'unvisited_penalty': 132.0, 'route_length': 191.244971422282, 'objective': 323.244971422282}","[0, 16, 13, 12, 2, 10, 11, 14, 15, 0]",15,markdown_table,0
PCTSP,PCTSP,"We’re imagining the pest control day as a round trip from headquarters: there’s a depot, a bunch of properties each worth a certain infestation-reduction score if treated and each carrying a penalty if skipped, and a minimum total score that must be achieved. The decision is which properties to include on one continuous circuit that starts and ends at the depot, never visiting the same property twice, so the chosen visits together reach that minimum score. The way to judge routes is to total the driving cost and then add the penalties for every untreated property — the route with the lower combined number is the preferable plan. The exact property details and the required score follow below.

# total_locations=16
# depot_id=1
# required_mitigation_score=400.0
property_id,x_coord,y_coord,mitigation_score,untreated_penalty
1,0,84,0,0
2,2,38,67,12
3,2,28,16,3
4,2,23,97,3
5,5,9,4,18
6,18,57,10,35
7,90,64,17,25
8,94,100,99,7
9,91,38,26,13
10,91,23,69,25
11,95,0,68,3
12,96,52,38,7
13,96,86,30,3
14,96,100,75,17
15,100,52,8,20
16,100,3,2,31

Also, when you send back the route, a simple JSON layout like this makes it easy for me to parse:

{
  ""solution"": [hq_id, property_id, ..., hq_id]
}

Think of that as a little form: ""solution"" is the ordered circuit — first entry is the depot (here H Q), then the properties you visit in order, and the final entry is the depot again. It's just a sketch of the shape I want, not the actual answer.

Please make sure you use the exact identifiers given in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 84], [2, 38], [2, 28], [2, 23], [5, 9], [18, 57], [90, 64], [94, 100], [91, 38], [91, 23], [95, 0], [96, 52], [96, 86], [96, 100], [100, 52], [100, 3]], 'prizes': [0, 67, 16, 97, 4, 10, 17, 99, 26, 69, 68, 38, 30, 75, 8, 2], 'penalties': [0, 12, 3, 3, 18, 35, 25, 7, 13, 25, 3, 7, 3, 17, 20, 31], 'required_prize': 400.0, 'depot': 0, 'route_length': 346.0739813386162, 'route_prize': 422.0, 'unvisited_penalty': 27.0, 'objective': 373.073869001488}","[0, 5, 1, 2, 3, 4, 10, 15, 9, 8, 14, 11, 6, 0]",373.073869001488,"{'problem_type': 'PCTSP', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 0, 'y': 84, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 2, 'y': 38, 'prize': 67, 'penalty': 12}, {'id': 3, 'x': 2, 'y': 28, 'prize': 16, 'penalty': 3}, {'id': 4, 'x': 2, 'y': 23, 'prize': 97, 'penalty': 3}, {'id': 5, 'x': 5, 'y': 9, 'prize': 4, 'penalty': 18}, {'id': 6, 'x': 18, 'y': 57, 'prize': 10, 'penalty': 35}, {'id': 7, 'x': 90, 'y': 64, 'prize': 17, 'penalty': 25}, {'id': 8, 'x': 94, 'y': 100, 'prize': 99, 'penalty': 7}, {'id': 9, 'x': 91, 'y': 38, 'prize': 26, 'penalty': 13}, {'id': 10, 'x': 91, 'y': 23, 'prize': 69, 'penalty': 25}, {'id': 11, 'x': 95, 'y': 0, 'prize': 68, 'penalty': 3}, {'id': 12, 'x': 96, 'y': 52, 'prize': 38, 'penalty': 7}, {'id': 13, 'x': 96, 'y': 86, 'prize': 30, 'penalty': 3}, {'id': 14, 'x': 96, 'y': 100, 'prize': 75, 'penalty': 17}, {'id': 15, 'x': 100, 'y': 52, 'prize': 8, 'penalty': 20}, {'id': 16, 'x': 100, 'y': 3, 'prize': 2, 'penalty': 31}], 'depot': 1, 'required_prize': 400.0, 'route_prize': 422.0, 'unvisited_penalty': 27.0, 'route_length': 346.0739813386162, 'objective': 373.073869001488}","[1, 6, 2, 3, 4, 5, 11, 16, 10, 9, 15, 12, 7, 1]",16,csv,1
PCTSP,PCTSP,"There’s a day when the lab has to send out one courier who makes a round-trip route from the lab, visiting a selection of clinics to pick up samples until the minimum sample requirement is met. The worthwhile routes are those with the smallest combined bill: total travel time for the whole loop plus the penalties charged for any clinics the courier didn’t stop at. The courier can’t visit the same clinic twice, the route must return to the lab, and the chosen stops must together supply at least the required samples. The exact clinic locations, prizes, penalties, and targets are listed below.

The instance lists 21 total locations (including the lab at node 0), and any feasible tour must collect at least 525.0 samples.

| location_id | x_coordinate | y_coordinate | samples_available | non_pickup_penalty |
|---|---|---|---|---|
| 0 | 74 | 0 | 0 | 0 |
| 1 | 88 | 3 | 14 | 17 |
| 2 | 91 | 43 | 28 | 23 |
| 3 | 92 | 44 | 41 | 1 |
| 4 | 78 | 40 | 30 | 15 |
| 5 | 87 | 51 | 99 | 12 |
| 6 | 100 | 56 | 35 | 2 |
| 7 | 90 | 80 | 91 | 19 |
| 8 | 52 | 100 | 99 | 2 |
| 9 | 68 | 98 | 29 | 22 |
| 10 | 71 | 95 | 15 | 16 |
| 11 | 71 | 87 | 85 | 28 |
| 12 | 57 | 22 | 1 | 15 |
| 13 | 29 | 19 | 13 | 27 |
| 14 | 30 | 15 | 20 | 12 |
| 15 | 39 | 44 | 2 | 15 |
| 16 | 26 | 43 | 64 | 19 |
| 17 | 26 | 77 | 2 | 22 |
| 18 | 13 | 78 | 27 | 10 |
| 19 | 0 | 42 | 56 | 2 |
| 20 | 4 | 22 | 67 | 23 |

The lines below enumerate each location’s coordinates, available samples, and omission penalties for comparing loop travel time plus missed-clinic penalties.

Also, when you send the chosen loop back, it'd be great if you used a tiny JSON snippet like this so it's easy to read and parse:

{
  ""solution"": [lab_id, clinic_id, ..., lab_id]
}

This is just a simple sketch: ""solution"" should be the ordered list of stops in the loop, starting and ending with the lab's identifier, and any clinic identifiers in between are the places the courier visits. Think of it like filling in a little route form — not the final answer itself, just the shape I expect.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[74, 0], [88, 3], [91, 43], [92, 44], [78, 40], [87, 51], [100, 56], [90, 80], [52, 100], [68, 98], [71, 95], [71, 87], [57, 22], [29, 19], [30, 15], [39, 44], [26, 43], [26, 77], [13, 78], [0, 42], [4, 22]], 'prizes': [0, 14, 28, 41, 30, 99, 35, 91, 99, 29, 15, 85, 1, 13, 20, 2, 64, 2, 27, 56, 67], 'penalties': [0, 17, 23, 1, 15, 12, 2, 19, 2, 22, 16, 28, 15, 27, 12, 15, 19, 22, 10, 2, 23], 'required_prize': 525.0, 'depot': 0, 'route_length': 317.1189524641834, 'route_prize': 534.0, 'unvisited_penalty': 39.0, 'objective': 356.1189524641834}","[0, 12, 14, 13, 16, 15, 17, 9, 10, 11, 7, 5, 3, 2, 4, 1, 0]",356.1189524641834,"{'problem_type': 'PCTSP', 'num_nodes': 21, 'nodes': [{'id': 0, 'x': 74, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 88, 'y': 3, 'prize': 14, 'penalty': 17}, {'id': 2, 'x': 91, 'y': 43, 'prize': 28, 'penalty': 23}, {'id': 3, 'x': 92, 'y': 44, 'prize': 41, 'penalty': 1}, {'id': 4, 'x': 78, 'y': 40, 'prize': 30, 'penalty': 15}, {'id': 5, 'x': 87, 'y': 51, 'prize': 99, 'penalty': 12}, {'id': 6, 'x': 100, 'y': 56, 'prize': 35, 'penalty': 2}, {'id': 7, 'x': 90, 'y': 80, 'prize': 91, 'penalty': 19}, {'id': 8, 'x': 52, 'y': 100, 'prize': 99, 'penalty': 2}, {'id': 9, 'x': 68, 'y': 98, 'prize': 29, 'penalty': 22}, {'id': 10, 'x': 71, 'y': 95, 'prize': 15, 'penalty': 16}, {'id': 11, 'x': 71, 'y': 87, 'prize': 85, 'penalty': 28}, {'id': 12, 'x': 57, 'y': 22, 'prize': 1, 'penalty': 15}, {'id': 13, 'x': 29, 'y': 19, 'prize': 13, 'penalty': 27}, {'id': 14, 'x': 30, 'y': 15, 'prize': 20, 'penalty': 12}, {'id': 15, 'x': 39, 'y': 44, 'prize': 2, 'penalty': 15}, {'id': 16, 'x': 26, 'y': 43, 'prize': 64, 'penalty': 19}, {'id': 17, 'x': 26, 'y': 77, 'prize': 2, 'penalty': 22}, {'id': 18, 'x': 13, 'y': 78, 'prize': 27, 'penalty': 10}, {'id': 19, 'x': 0, 'y': 42, 'prize': 56, 'penalty': 2}, {'id': 20, 'x': 4, 'y': 22, 'prize': 67, 'penalty': 23}], 'depot': 0, 'required_prize': 525.0, 'route_prize': 534.0, 'unvisited_penalty': 39.0, 'route_length': 317.1189524641834, 'objective': 356.1189524641834}","[0, 12, 14, 13, 16, 15, 17, 9, 10, 11, 7, 5, 3, 2, 4, 1, 0]",17,markdown_table,0
PCTSP,PCTSP,"Many people think route planning is just about shortest roads, but here it’s about striking a balance: plan one tour from HQ that visits selected booths and comes home, so the combined audience reach from the stops meets the campaign target. What makes one plan better than another is simple to tally — total miles traveled plus the penalty costs for any booths left out — and the goal is to keep that combined number as low as possible. The loop must be a single trip, no booth is visited more than once, and the chosen booths must together meet the exposure requirement. The concrete numbers and booth details are below.

{
  ""total_locations_including_hq"": 18,
  ""nodes"": [
    {
      ""booth_id"": ""A"",
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 54,
      ""audience_exposure"": 0,
      ""missed_opportunity_penalty"": 0
    },
    {
      ""booth_id"": ""B"",
      ""map_x_coordinate"": 7,
      ""map_y_coordinate"": 68,
      ""audience_exposure"": 88,
      ""missed_opportunity_penalty"": 9
    },
    {
      ""booth_id"": ""C"",
      ""map_x_coordinate"": 11,
      ""map_y_coordinate"": 54,
      ""audience_exposure"": 61,
      ""missed_opportunity_penalty"": 17
    },
    {
      ""booth_id"": ""D"",
      ""map_x_coordinate"": 43,
      ""map_y_coordinate"": 48,
      ""audience_exposure"": 80,
      ""missed_opportunity_penalty"": 22
    },
    {
      ""booth_id"": ""E"",
      ""map_x_coordinate"": 46,
      ""map_y_coordinate"": 48,
      ""audience_exposure"": 18,
      ""missed_opportunity_penalty"": 30
    },
    {
      ""booth_id"": ""F"",
      ""map_x_coordinate"": 48,
      ""map_y_coordinate"": 43,
      ""audience_exposure"": 34,
      ""missed_opportunity_penalty"": 5
    },
    {
      ""booth_id"": ""G"",
      ""map_x_coordinate"": 59,
      ""map_y_coordinate"": 54,
      ""audience_exposure"": 40,
      ""missed_opportunity_penalty"": 2
    },
    {
      ""booth_id"": ""H"",
      ""map_x_coordinate"": 76,
      ""map_y_coordinate"": 41,
      ""audience_exposure"": 34,
      ""missed_opportunity_penalty"": 20
    },
    {
      ""booth_id"": ""I"",
      ""map_x_coordinate"": 99,
      ""map_y_coordinate"": 68,
      ""audience_exposure"": 33,
      ""missed_opportunity_penalty"": 19
    },
    {
      ""booth_id"": ""J"",
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 37,
      ""audience_exposure"": 64,
      ""missed_opportunity_penalty"": 24
    },
    {
      ""booth_id"": ""K"",
      ""map_x_coordinate"": 12,
      ""map_y_coordinate"": 41,
      ""audience_exposure"": 83,
      ""missed_opportunity_penalty"": 6
    },
    {
      ""booth_id"": ""L"",
      ""map_x_coordinate"": 14,
      ""map_y_coordinate"": 73,
      ""audience_exposure"": 53,
      ""missed_opportunity_penalty"": 25
    },
    {
      ""booth_id"": ""M"",
      ""map_x_coordinate"": 37,
      ""map_y_coordinate"": 85,
      ""audience_exposure"": 73,
      ""missed_opportunity_penalty"": 2
    },
    {
      ""booth_id"": ""N"",
      ""map_x_coordinate"": 43,
      ""map_y_coordinate"": 77,
      ""audience_exposure"": 59,
      ""missed_opportunity_penalty"": 4
    },
    {
      ""booth_id"": ""O"",
      ""map_x_coordinate"": 59,
      ""map_y_coordinate"": 85,
      ""audience_exposure"": 71,
      ""missed_opportunity_penalty"": 6
    },
    {
      ""booth_id"": ""P"",
      ""map_x_coordinate"": 67,
      ""map_y_coordinate"": 100,
      ""audience_exposure"": 60,
      ""missed_opportunity_penalty"": 3
    },
    {
      ""booth_id"": ""Q"",
      ""map_x_coordinate"": 96,
      ""map_y_coordinate"": 71,
      ""audience_exposure"": 14,
      ""missed_opportunity_penalty"": 1
    },
    {
      ""booth_id"": ""R"",
      ""map_x_coordinate"": 44,
      ""map_y_coordinate"": 0,
      ""audience_exposure"": 86,
      ""missed_opportunity_penalty"": 21
    }
  ],
  ""hq_node_id"": ""A"",
  ""target_audience_exposure"": 450.0
}

Oh, and just to keep things tidy, please send the answer using this simple JSON shape when you’re ready:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of ""solution"" as the single loop: list the depot first, then the stops in order, and the depot again at the end. The placeholders in that example are just a sketch of the format — replace them with the actual location IDs from the instance when you submit the tour.

This JSON is only the expected shape, not the actual route — it’s a template to follow.

Please use the exact identifiers given in the instance input — don’t rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 54], [7, 68], [11, 54], [43, 48], [46, 48], [48, 43], [59, 54], [76, 41], [99, 68], [100, 37], [12, 41], [14, 73], [37, 85], [43, 77], [59, 85], [67, 100], [96, 71], [44, 0]], 'prizes': [0, 88, 61, 80, 18, 34, 40, 34, 33, 64, 83, 53, 73, 59, 71, 60, 14, 86], 'penalties': [0, 9, 17, 22, 30, 5, 2, 20, 19, 24, 6, 25, 2, 4, 6, 3, 1, 21], 'required_prize': 450.0, 'depot': 0, 'route_length': 145.36567793711276, 'route_prize': 466.0, 'unvisited_penalty': 102.0, 'objective': 247.36567793711274}","[0, 1, 11, 12, 13, 4, 5, 3, 2, 0]",247.36567793711274,"{'problem_type': 'PCTSP', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 0, 'y': 54, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 7, 'y': 68, 'prize': 88, 'penalty': 9}, {'id': 'C', 'x': 11, 'y': 54, 'prize': 61, 'penalty': 17}, {'id': 'D', 'x': 43, 'y': 48, 'prize': 80, 'penalty': 22}, {'id': 'E', 'x': 46, 'y': 48, 'prize': 18, 'penalty': 30}, {'id': 'F', 'x': 48, 'y': 43, 'prize': 34, 'penalty': 5}, {'id': 'G', 'x': 59, 'y': 54, 'prize': 40, 'penalty': 2}, {'id': 'H', 'x': 76, 'y': 41, 'prize': 34, 'penalty': 20}, {'id': 'I', 'x': 99, 'y': 68, 'prize': 33, 'penalty': 19}, {'id': 'J', 'x': 100, 'y': 37, 'prize': 64, 'penalty': 24}, {'id': 'K', 'x': 12, 'y': 41, 'prize': 83, 'penalty': 6}, {'id': 'L', 'x': 14, 'y': 73, 'prize': 53, 'penalty': 25}, {'id': 'M', 'x': 37, 'y': 85, 'prize': 73, 'penalty': 2}, {'id': 'N', 'x': 43, 'y': 77, 'prize': 59, 'penalty': 4}, {'id': 'O', 'x': 59, 'y': 85, 'prize': 71, 'penalty': 6}, {'id': 'P', 'x': 67, 'y': 100, 'prize': 60, 'penalty': 3}, {'id': 'Q', 'x': 96, 'y': 71, 'prize': 14, 'penalty': 1}, {'id': 'R', 'x': 44, 'y': 0, 'prize': 86, 'penalty': 21}], 'depot': 'A', 'required_prize': 450.0, 'route_prize': 466.0, 'unvisited_penalty': 102.0, 'route_length': 145.36567793711276, 'objective': 247.36567793711274}","['A', 'B', 'L', 'M', 'N', 'E', 'F', 'D', 'C', 'A']",18,json,names
PCTSP,PCTSP,"Many mornings the foreman sketches a single circular route from the yard and chooses which gardens to hit before returning to base. The choice is balancing which jobs to take so the total value of visited sites reaches the required minimum, while keeping the route short and avoiding big penalty charges for the ones skipped. To compare plans, add up the loop’s driving distance and then add every skipped client’s penalty to get the total cost — smaller totals are better — and the route has to be a single loop that starts and ends at the yard without visiting any place twice. The concrete data for this run are listed below.

For this run there are 20 locations, the yard is node 0, and the foreman must collect at least 500.0 in project value.
Garden 0 at (88, 78) yields prize 0 if visited and incurs penalty 0 if skipped.
Garden 1 at (8, 60) yields prize 42 if visited and incurs penalty 22 if skipped.
Garden 2 at (93, 77) yields prize 15 if visited and incurs penalty 3 if skipped.
Garden 3 at (9, 88) yields prize 30 if visited and incurs penalty 21 if skipped.
Garden 4 at (47, 28) yields prize 24 if visited and incurs penalty 22 if skipped.
Garden 5 at (78, 82) yields prize 72 if visited and incurs penalty 16 if skipped.
Garden 6 at (51, 43) yields prize 62 if visited and incurs penalty 16 if skipped.
Garden 7 at (100, 0) yields prize 61 if visited and incurs penalty 22 if skipped.
Garden 8 at (54, 68) yields prize 98 if visited and incurs penalty 16 if skipped.
Garden 9 at (79, 70) yields prize 28 if visited and incurs penalty 2 if skipped.
Garden 10 at (15, 38) yields prize 63 if visited and incurs penalty 2 if skipped.
Garden 11 at (15, 47) yields prize 40 if visited and incurs penalty 28 if skipped.
Garden 12 at (97, 85) yields prize 74 if visited and incurs penalty 14 if skipped.
Garden 13 at (11, 28) yields prize 36 if visited and incurs penalty 19 if skipped.
Garden 14 at (38, 63) yields prize 83 if visited and incurs penalty 11 if skipped.
Garden 15 at (0, 36) yields prize 28 if visited and incurs penalty 10 if skipped.
Garden 16 at (6, 100) yields prize 69 if visited and incurs penalty 20 if skipped.
Garden 17 at (17, 61) yields prize 21 if visited and incurs penalty 9 if skipped.
Garden 18 at (55, 70) yields prize 76 if visited and incurs penalty 3 if skipped.
Garden 19 at (7, 73) yields prize 52 if visited and incurs penalty 10 if skipped.
These entries list every location the foreman considers when drawing the single loop.

Oh, and when you send the route back, please use this simple JSON layout so it's easy to check automatically:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of it like a little form: ""solution"" is the ordered loop — start with the yard (depot_id), list each client you visit in order (location_id, etc.), and end back at the yard (depot_id). The ""..."" just means ""any other stops in between"" — keep it casual and readable, one identifier per stop, in travel order.

Please make sure every identifier you use matches exactly what's in the instance input — no renaming and no invented labels.
- ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[88, 78], [8, 60], [93, 77], [9, 88], [47, 28], [78, 82], [51, 43], [100, 0], [54, 68], [79, 70], [15, 38], [15, 47], [97, 85], [11, 28], [38, 63], [0, 36], [6, 100], [17, 61], [55, 70], [7, 73]], 'prizes': [0, 42, 15, 30, 24, 72, 62, 61, 98, 28, 63, 40, 74, 36, 83, 28, 69, 21, 76, 52], 'penalties': [0, 22, 3, 21, 22, 16, 16, 22, 16, 2, 2, 28, 14, 19, 11, 10, 20, 9, 3, 10], 'required_prize': 500.0, 'depot': 0, 'route_length': 222.86032662312925, 'route_prize': 645.0, 'unvisited_penalty': 100.0, 'objective': 322.86032662312925}","[0, 5, 18, 8, 14, 17, 1, 11, 10, 13, 4, 6, 9, 0]",322.86032662312925,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 88, 'y': 78, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 8, 'y': 60, 'prize': 42, 'penalty': 22}, {'id': 2, 'x': 93, 'y': 77, 'prize': 15, 'penalty': 3}, {'id': 3, 'x': 9, 'y': 88, 'prize': 30, 'penalty': 21}, {'id': 4, 'x': 47, 'y': 28, 'prize': 24, 'penalty': 22}, {'id': 5, 'x': 78, 'y': 82, 'prize': 72, 'penalty': 16}, {'id': 6, 'x': 51, 'y': 43, 'prize': 62, 'penalty': 16}, {'id': 7, 'x': 100, 'y': 0, 'prize': 61, 'penalty': 22}, {'id': 8, 'x': 54, 'y': 68, 'prize': 98, 'penalty': 16}, {'id': 9, 'x': 79, 'y': 70, 'prize': 28, 'penalty': 2}, {'id': 10, 'x': 15, 'y': 38, 'prize': 63, 'penalty': 2}, {'id': 11, 'x': 15, 'y': 47, 'prize': 40, 'penalty': 28}, {'id': 12, 'x': 97, 'y': 85, 'prize': 74, 'penalty': 14}, {'id': 13, 'x': 11, 'y': 28, 'prize': 36, 'penalty': 19}, {'id': 14, 'x': 38, 'y': 63, 'prize': 83, 'penalty': 11}, {'id': 15, 'x': 0, 'y': 36, 'prize': 28, 'penalty': 10}, {'id': 16, 'x': 6, 'y': 100, 'prize': 69, 'penalty': 20}, {'id': 17, 'x': 17, 'y': 61, 'prize': 21, 'penalty': 9}, {'id': 18, 'x': 55, 'y': 70, 'prize': 76, 'penalty': 3}, {'id': 19, 'x': 7, 'y': 73, 'prize': 52, 'penalty': 10}], 'depot': 0, 'required_prize': 500.0, 'route_prize': 645.0, 'unvisited_penalty': 100.0, 'route_length': 222.86032662312925, 'objective': 322.86032662312925}","[0, 5, 18, 8, 14, 17, 1, 11, 10, 13, 4, 6, 9, 0]",19,nl,0
PCTSP,PCTSP,"I’m a local courier trying to put together one neat loop that leaves from the central hub and comes back there at the end, hitting a handful of customer addresses so the total value of picked-up parcels reaches the required amount. The trade-off is obvious: shorter driving distance is better, but skipping a stop costs a money penalty, so the route is judged by adding up the miles driven plus the penalties for any addresses left out — the lower that total, the better. Everything has to fit into a single tour (no back-and-forth visits or visiting the same spot twice), and the exact addresses, pickup values, and penalties are listed below.

There are 20 locations including the central hub 1, and I need to collect at least 500.0 in pickup value.

| location_id | x_coordinate_miles_or_units | y_coordinate_miles_or_units | pickup_value | skip_penalty_cost |
|---|---|---|---|---|
| 1 | 15 | 22 | 0 | 0 |
| 2 | 17 | 54 | 98 | 12 |
| 3 | 23 | 67 | 85 | 1 |
| 4 | 28 | 81 | 64 | 7 |
| 5 | 15 | 89 | 7 | 18 |
| 6 | 27 | 95 | 44 | 20 |
| 7 | 33 | 88 | 89 | 10 |
| 8 | 33 | 54 | 62 | 6 |
| 9 | 36 | 22 | 39 | 22 |
| 10 | 46 | 55 | 37 | 3 |
| 11 | 39 | 57 | 18 | 12 |
| 12 | 52 | 81 | 0 | 18 |
| 13 | 51 | 95 | 54 | 15 |
| 14 | 71 | 43 | 67 | 2 |
| 15 | 76 | 55 | 21 | 6 |
| 16 | 75 | 95 | 59 | 5 |
| 17 | 85 | 89 | 41 | 15 |
| 18 | 85 | 22 | 12 | 6 |
| 19 | 100 | 100 | 53 | 22 |
| 20 | 0 | 0 | 83 | 2 |

I'll plan one neat loop starting and ending at 1 that balances driving distance and skip penalties to hit the required 500.0 if I can.

Oh, and just to keep things tidy, please format your route reply in this little JSON shape so it's easy for me to read:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

That ""solution"" array is just the hub first, then the stops you plan to visit in order, and the hub again at the end. Think of it as filling in a short checklist: start at the central hub, list each address you’ll hit (in the order you’ll drive to them), and then return to the hub. This block is just a sketch of the expected shape — don’t treat it as the final route.

One more thing: use the identifiers exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[15, 22], [17, 54], [23, 67], [28, 81], [15, 89], [27, 95], [33, 88], [33, 54], [36, 22], [46, 55], [39, 57], [52, 81], [51, 95], [71, 43], [76, 55], [75, 95], [85, 89], [85, 22], [100, 100], [0, 0]], 'prizes': [0, 98, 85, 64, 7, 44, 89, 62, 39, 37, 18, 0, 54, 67, 21, 59, 41, 12, 53, 83], 'penalties': [0, 12, 1, 7, 18, 20, 10, 6, 22, 3, 12, 18, 15, 2, 6, 5, 15, 6, 22, 2], 'required_prize': 500.0, 'depot': 0, 'route_length': 219.63870492295734, 'route_prize': 560.0, 'unvisited_penalty': 61.0, 'objective': 280.63870492295734}","[0, 1, 2, 3, 4, 5, 6, 12, 11, 10, 7, 8, 0]",280.63870492295734,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 1, 'x': 15, 'y': 22, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 17, 'y': 54, 'prize': 98, 'penalty': 12}, {'id': 3, 'x': 23, 'y': 67, 'prize': 85, 'penalty': 1}, {'id': 4, 'x': 28, 'y': 81, 'prize': 64, 'penalty': 7}, {'id': 5, 'x': 15, 'y': 89, 'prize': 7, 'penalty': 18}, {'id': 6, 'x': 27, 'y': 95, 'prize': 44, 'penalty': 20}, {'id': 7, 'x': 33, 'y': 88, 'prize': 89, 'penalty': 10}, {'id': 8, 'x': 33, 'y': 54, 'prize': 62, 'penalty': 6}, {'id': 9, 'x': 36, 'y': 22, 'prize': 39, 'penalty': 22}, {'id': 10, 'x': 46, 'y': 55, 'prize': 37, 'penalty': 3}, {'id': 11, 'x': 39, 'y': 57, 'prize': 18, 'penalty': 12}, {'id': 12, 'x': 52, 'y': 81, 'prize': 0, 'penalty': 18}, {'id': 13, 'x': 51, 'y': 95, 'prize': 54, 'penalty': 15}, {'id': 14, 'x': 71, 'y': 43, 'prize': 67, 'penalty': 2}, {'id': 15, 'x': 76, 'y': 55, 'prize': 21, 'penalty': 6}, {'id': 16, 'x': 75, 'y': 95, 'prize': 59, 'penalty': 5}, {'id': 17, 'x': 85, 'y': 89, 'prize': 41, 'penalty': 15}, {'id': 18, 'x': 85, 'y': 22, 'prize': 12, 'penalty': 6}, {'id': 19, 'x': 100, 'y': 100, 'prize': 53, 'penalty': 22}, {'id': 20, 'x': 0, 'y': 0, 'prize': 83, 'penalty': 2}], 'depot': 1, 'required_prize': 500.0, 'route_prize': 560.0, 'unvisited_penalty': 61.0, 'route_length': 219.63870492295734, 'objective': 280.63870492295734}","[1, 2, 3, 4, 5, 6, 7, 13, 12, 11, 8, 9, 1]",20,markdown_table,1
PCTSP,PCTSP,"Imagine the outreach coordinator with a cart, a list, and one chance to do a loop out of the storage room: visit a selection of galleries so the sum of their restocking values meets the target, then return. The choice is which stops to make on that single loop — the better plan saves on walking and moving stuff and avoids paying high penalties for skipped galleries. To see which plan comes out ahead, sum up the entire loop’s walking/transport effort and add the penalty costs for any galleries left unvisited; the lower that combined number, the better. The trip must start and finish at storage and can’t double back to the same gallery, and the concrete details are shown below.

Below are the 16 locations (storage room id A); the loop must collect at least 400.0 restocking value.
Gallery A at (0, 0) — restocking value 0, skip penalty 0.
Gallery B at (50, 45) — restocking value 88, skip penalty 23.
Gallery C at (32, 36) — restocking value 95, skip penalty 16.
Gallery D at (6, 19) — restocking value 31, skip penalty 1.
Gallery E at (44, 17) — restocking value 21, skip penalty 2.
Gallery F at (15, 7) — restocking value 2, skip penalty 2.
Gallery G at (38, 7) — restocking value 70, skip penalty 2.
Gallery H at (46, 7) — restocking value 7, skip penalty 11.
Gallery I at (6, 2) — restocking value 100, skip penalty 29.
Gallery J at (4, 73) — restocking value 30, skip penalty 34.
Gallery K at (34, 93) — restocking value 96, skip penalty 15.
Gallery L at (54, 100) — restocking value 72, skip penalty 28.
Gallery M at (71, 17) — restocking value 41, skip penalty 32.
Gallery N at (75, 53) — restocking value 32, skip penalty 9.
Gallery O at (84, 53) — restocking value 67, skip penalty 23.
Gallery P at (100, 33) — restocking value 93, skip penalty 35.
Execute a single loop starting and ending at A that reaches the 400.0 target while minimizing walking and skip penalties.

When you send me the chosen loop, just drop it into a tiny JSON snippet like this so it's easy to read and check:

{
  ""solution"": [storage_id, gallery_id, ..., storage_id]
}

That ""solution"" list is just the ordered stops on the one loop — start at storage, list each gallery you visit in order, and finish back at storage. Think of it like filling out a quick form; this block is only the sketch of the shape I expect, not the actual route.

Please make sure you use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[0, 0], [50, 45], [32, 36], [6, 19], [44, 17], [15, 7], [38, 7], [46, 7], [6, 2], [4, 73], [34, 93], [54, 100], [71, 17], [75, 53], [84, 53], [100, 33]], 'prizes': [0, 88, 95, 31, 21, 2, 70, 7, 100, 30, 96, 72, 41, 32, 67, 93], 'penalties': [0, 23, 16, 1, 2, 2, 2, 11, 29, 34, 15, 28, 32, 9, 23, 35], 'required_prize': 400.0, 'depot': 0, 'route_length': 236.81929637956674, 'route_prize': 595.0, 'unvisited_penalty': 80.0, 'objective': 316.8192963795667}","[0, 2, 1, 13, 14, 15, 12, 7, 6, 5, 8, 0]",316.8192963795667,"{'problem_type': 'PCTSP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 50, 'y': 45, 'prize': 88, 'penalty': 23}, {'id': 'C', 'x': 32, 'y': 36, 'prize': 95, 'penalty': 16}, {'id': 'D', 'x': 6, 'y': 19, 'prize': 31, 'penalty': 1}, {'id': 'E', 'x': 44, 'y': 17, 'prize': 21, 'penalty': 2}, {'id': 'F', 'x': 15, 'y': 7, 'prize': 2, 'penalty': 2}, {'id': 'G', 'x': 38, 'y': 7, 'prize': 70, 'penalty': 2}, {'id': 'H', 'x': 46, 'y': 7, 'prize': 7, 'penalty': 11}, {'id': 'I', 'x': 6, 'y': 2, 'prize': 100, 'penalty': 29}, {'id': 'J', 'x': 4, 'y': 73, 'prize': 30, 'penalty': 34}, {'id': 'K', 'x': 34, 'y': 93, 'prize': 96, 'penalty': 15}, {'id': 'L', 'x': 54, 'y': 100, 'prize': 72, 'penalty': 28}, {'id': 'M', 'x': 71, 'y': 17, 'prize': 41, 'penalty': 32}, {'id': 'N', 'x': 75, 'y': 53, 'prize': 32, 'penalty': 9}, {'id': 'O', 'x': 84, 'y': 53, 'prize': 67, 'penalty': 23}, {'id': 'P', 'x': 100, 'y': 33, 'prize': 93, 'penalty': 35}], 'depot': 'A', 'required_prize': 400.0, 'route_prize': 595.0, 'unvisited_penalty': 80.0, 'route_length': 236.81929637956674, 'objective': 316.8192963795667}","['A', 'C', 'B', 'N', 'O', 'P', 'M', 'H', 'G', 'F', 'I', 'A']",21,nl,names
PCTSP,PCTSP,"Recently the neighbors agreed to run a doorstep pledge drive that’s done as one continuous loop from the community center and back, visiting whichever houses make sense. The decision is which houses to include so that total collected pledges reach the fundraising target, but with an eye toward minimizing overall cost — measured by adding the walking distance of the loop and the total loss from any houses not visited; the lower that sum, the better. The route has to be a single, uninterrupted circuit and each house can only be visited as part of that loop. The concrete details for targets, house pledges, and skip-penalties appear below.

# total_locations=20
# community_center_id=0
# fundraising_target=500.0
location_id,x_coord,y_coord,pledge_amount,skip_penalty
0,45,0,0,0
1,70,11,72,21
2,2,70,12,8
3,10,85,41,26
4,48,11,36,15
5,80,30,78,26
6,82,17,14,26
7,85,23,77,29
8,68,49,55,22
9,32,68,64,18
10,42,21,93,14
11,45,26,77,25
12,15,40,54,14
13,100,53,27,28
14,90,32,39,22
15,98,21,23,16
16,80,0,26,8
17,100,21,65,10
18,88,91,38,5
19,0,100,97,22

If you want to return a proposed route, just use this simple JSON shape so I can read it easily:

{
  ""solution"": [community_center_id, house_id, ..., community_center_id]
}

Think of it like a short form: the list is the loop starting at the community center, then the houses you plan to hit in order, and finally back to the community center. It’s just a sketch of the shape I’m expecting, not the actual answer — fill in the real identifiers from the instance when you send the route.

Please make sure to use the exact identifiers from the instance input — don’t rename them or add new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[45, 0], [70, 11], [2, 70], [10, 85], [48, 11], [80, 30], [82, 17], [85, 23], [68, 49], [32, 68], [42, 21], [45, 26], [15, 40], [100, 53], [90, 32], [98, 21], [80, 0], [100, 21], [88, 91], [0, 100]], 'prizes': [0, 72, 12, 41, 36, 78, 14, 77, 55, 64, 93, 77, 54, 27, 39, 23, 26, 65, 38, 97], 'penalties': [0, 21, 8, 26, 15, 26, 26, 29, 22, 18, 14, 25, 14, 28, 22, 16, 8, 10, 5, 22], 'required_prize': 500.0, 'depot': 0, 'route_length': 171.54839350181612, 'route_prize': 629.0, 'unvisited_penalty': 129.0, 'objective': 300.5483935018161}","[0, 4, 10, 11, 8, 5, 14, 17, 15, 7, 6, 1, 0]",300.5483935018161,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 45, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 70, 'y': 11, 'prize': 72, 'penalty': 21}, {'id': 2, 'x': 2, 'y': 70, 'prize': 12, 'penalty': 8}, {'id': 3, 'x': 10, 'y': 85, 'prize': 41, 'penalty': 26}, {'id': 4, 'x': 48, 'y': 11, 'prize': 36, 'penalty': 15}, {'id': 5, 'x': 80, 'y': 30, 'prize': 78, 'penalty': 26}, {'id': 6, 'x': 82, 'y': 17, 'prize': 14, 'penalty': 26}, {'id': 7, 'x': 85, 'y': 23, 'prize': 77, 'penalty': 29}, {'id': 8, 'x': 68, 'y': 49, 'prize': 55, 'penalty': 22}, {'id': 9, 'x': 32, 'y': 68, 'prize': 64, 'penalty': 18}, {'id': 10, 'x': 42, 'y': 21, 'prize': 93, 'penalty': 14}, {'id': 11, 'x': 45, 'y': 26, 'prize': 77, 'penalty': 25}, {'id': 12, 'x': 15, 'y': 40, 'prize': 54, 'penalty': 14}, {'id': 13, 'x': 100, 'y': 53, 'prize': 27, 'penalty': 28}, {'id': 14, 'x': 90, 'y': 32, 'prize': 39, 'penalty': 22}, {'id': 15, 'x': 98, 'y': 21, 'prize': 23, 'penalty': 16}, {'id': 16, 'x': 80, 'y': 0, 'prize': 26, 'penalty': 8}, {'id': 17, 'x': 100, 'y': 21, 'prize': 65, 'penalty': 10}, {'id': 18, 'x': 88, 'y': 91, 'prize': 38, 'penalty': 5}, {'id': 19, 'x': 0, 'y': 100, 'prize': 97, 'penalty': 22}], 'depot': 0, 'required_prize': 500.0, 'route_prize': 629.0, 'unvisited_penalty': 129.0, 'route_length': 171.54839350181612, 'objective': 300.5483935018161}","[0, 4, 10, 11, 8, 5, 14, 17, 15, 7, 6, 1, 0]",22,csv,0
PCTSP,PCTSP,"On a typical day there’s one trip to plan: leave the office, hit selected client sites to clear priority items until the required total is met, and then come straight back. The plan is judged by its combined cost — what’s spent getting around plus what’s paid out to any clients who weren’t visited — and the better route is simply the one with the smaller combined cost. The tour can’t double-back to the same client and must begin and end at the office while achieving the needed number of fixes. The concrete numbers and locations are shown below.

{
  ""total_locations_including_office"": 17,
  ""nodes"": [
    {
      ""client_node_id"": 1,
      ""coord_x"": 42,
      ""coord_y"": 95,
      ""priority_issues_fixed"": 0,
      ""unvisited_compensation_cost"": 0
    },
    {
      ""client_node_id"": 2,
      ""coord_x"": 37,
      ""coord_y"": 95,
      ""priority_issues_fixed"": 74,
      ""unvisited_compensation_cost"": 3
    },
    {
      ""client_node_id"": 3,
      ""coord_x"": 54,
      ""coord_y"": 32,
      ""priority_issues_fixed"": 47,
      ""unvisited_compensation_cost"": 33
    },
    {
      ""client_node_id"": 4,
      ""coord_x"": 48,
      ""coord_y"": 31,
      ""priority_issues_fixed"": 96,
      ""unvisited_compensation_cost"": 16
    },
    {
      ""client_node_id"": 5,
      ""coord_x"": 76,
      ""coord_y"": 99,
      ""priority_issues_fixed"": 16,
      ""unvisited_compensation_cost"": 17
    },
    {
      ""client_node_id"": 6,
      ""coord_x"": 2,
      ""coord_y"": 99,
      ""priority_issues_fixed"": 32,
      ""unvisited_compensation_cost"": 18
    },
    {
      ""client_node_id"": 7,
      ""coord_x"": 2,
      ""coord_y"": 99,
      ""priority_issues_fixed"": 46,
      ""unvisited_compensation_cost"": 9
    },
    {
      ""client_node_id"": 8,
      ""coord_x"": 78,
      ""coord_y"": 1,
      ""priority_issues_fixed"": 4,
      ""unvisited_compensation_cost"": 22
    },
    {
      ""client_node_id"": 9,
      ""coord_x"": 73,
      ""coord_y"": 0,
      ""priority_issues_fixed"": 72,
      ""unvisited_compensation_cost"": 25
    },
    {
      ""client_node_id"": 10,
      ""coord_x"": 0,
      ""coord_y"": 0,
      ""priority_issues_fixed"": 28,
      ""unvisited_compensation_cost"": 21
    },
    {
      ""client_node_id"": 11,
      ""coord_x"": 5,
      ""coord_y"": 1,
      ""priority_issues_fixed"": 23,
      ""unvisited_compensation_cost"": 20
    },
    {
      ""client_node_id"": 12,
      ""coord_x"": 25,
      ""coord_y"": 100,
      ""priority_issues_fixed"": 62,
      ""unvisited_compensation_cost"": 14
    },
    {
      ""client_node_id"": 13,
      ""coord_x"": 27,
      ""coord_y"": 99,
      ""priority_issues_fixed"": 85,
      ""unvisited_compensation_cost"": 22
    },
    {
      ""client_node_id"": 14,
      ""coord_x"": 100,
      ""coord_y"": 1,
      ""priority_issues_fixed"": 3,
      ""unvisited_compensation_cost"": 2
    },
    {
      ""client_node_id"": 15,
      ""coord_x"": 96,
      ""coord_y"": 1,
      ""priority_issues_fixed"": 52,
      ""unvisited_compensation_cost"": 12
    },
    {
      ""client_node_id"": 16,
      ""coord_x"": 83,
      ""coord_y"": 1,
      ""priority_issues_fixed"": 44,
      ""unvisited_compensation_cost"": 1
    },
    {
      ""client_node_id"": 17,
      ""coord_x"": 18,
      ""coord_y"": 1,
      ""priority_issues_fixed"": 98,
      ""unvisited_compensation_cost"": 20
    }
  ],
  ""office_node_id"": 1,
  ""required_priority_fixes"": 425.0
}

If you want to return the plan in a tidy, machine-friendly way, just send a small JSON snippet like this — nothing fancy, just the tour in order.

{
  ""solution"": [office_id, client_id, ..., office_id]
}

Think of that as a simple form: ""solution"" is the tour — start at the office (depot), list the clients you visit in the order you visit them, and finish back at the office. The placeholders above are just examples of the shape; don’t treat them as real IDs.

Please use the exact identifiers from the instance input when you fill this in — do not rename or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[42, 95], [37, 95], [54, 32], [48, 31], [76, 99], [2, 99], [2, 99], [78, 1], [73, 0], [0, 0], [5, 1], [25, 100], [27, 99], [100, 1], [96, 1], [83, 1], [18, 1]], 'prizes': [0, 74, 47, 96, 16, 32, 46, 4, 72, 28, 23, 62, 85, 3, 52, 44, 98], 'penalties': [0, 3, 33, 16, 17, 18, 9, 22, 25, 21, 20, 14, 22, 2, 12, 1, 20], 'required_prize': 425.0, 'depot': 0, 'route_length': 193.34106697490074, 'route_prize': 442.0, 'unvisited_penalty': 140.0, 'objective': 333.34106697490074}","[0, 1, 12, 11, 5, 6, 3, 2, 0]",333.34106697490074,"{'problem_type': 'PCTSP', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 42, 'y': 95, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 37, 'y': 95, 'prize': 74, 'penalty': 3}, {'id': 3, 'x': 54, 'y': 32, 'prize': 47, 'penalty': 33}, {'id': 4, 'x': 48, 'y': 31, 'prize': 96, 'penalty': 16}, {'id': 5, 'x': 76, 'y': 99, 'prize': 16, 'penalty': 17}, {'id': 6, 'x': 2, 'y': 99, 'prize': 32, 'penalty': 18}, {'id': 7, 'x': 2, 'y': 99, 'prize': 46, 'penalty': 9}, {'id': 8, 'x': 78, 'y': 1, 'prize': 4, 'penalty': 22}, {'id': 9, 'x': 73, 'y': 0, 'prize': 72, 'penalty': 25}, {'id': 10, 'x': 0, 'y': 0, 'prize': 28, 'penalty': 21}, {'id': 11, 'x': 5, 'y': 1, 'prize': 23, 'penalty': 20}, {'id': 12, 'x': 25, 'y': 100, 'prize': 62, 'penalty': 14}, {'id': 13, 'x': 27, 'y': 99, 'prize': 85, 'penalty': 22}, {'id': 14, 'x': 100, 'y': 1, 'prize': 3, 'penalty': 2}, {'id': 15, 'x': 96, 'y': 1, 'prize': 52, 'penalty': 12}, {'id': 16, 'x': 83, 'y': 1, 'prize': 44, 'penalty': 1}, {'id': 17, 'x': 18, 'y': 1, 'prize': 98, 'penalty': 20}], 'depot': 1, 'required_prize': 425.0, 'route_prize': 442.0, 'unvisited_penalty': 140.0, 'route_length': 193.34106697490074, 'objective': 333.34106697490074}","[1, 2, 13, 12, 6, 7, 4, 3, 1]",23,json,1
PCTSP,PCTSP,"We have one mobile-library run to plan: start at the branch, hit some of the pickup lockers with requested holds, and return to the branch when done. The decision is which lockers to serve so the total delivered books meets the distribution target; stronger plans deliver enough books without making a long detour or leaving high-penalty lockers unserviced. The way to compare routes is straightforward — total driving distance plus the penalties for any lockers that were skipped — and the run must be a single loop with no duplicate visits. The concrete details will be shown below.

# total_locations=24
# branch_node=1
# target_books_to_deliver=600.0
location_id,x_coord,y_coord,books_requested,missed_service_penalty
1,22,40,0,0
2,31,100,93,26
3,22,5,71,21
4,66,52,53,0
5,49,78,78,16
6,86,78,23,3
7,64,31,29,24
8,68,0,34,13
9,15,12,45,0
10,0,71,88,10
11,59,41,80,23
12,17,29,51,23
13,37,88,52,26
14,80,7,18,18
15,80,60,37,20
16,86,62,69,3
17,100,78,88,9
18,92,52,61,3
19,90,81,71,17
20,20,52,79,13
21,24,26,67,5
22,27,29,83,20
23,41,34,68,23
24,29,24,87,5

I'll show the shape I want the route in as a tiny JSON example so it's clear how to give the run back.

{
  ""solution"": [branch_id, locker_id, ..., branch_id]
}

Just to be clear: ""solution"" is a list that describes the single loop — start at the branch, go to the listed lockers in order, and come back to the branch at the end. Each entry in the list is an identifier for a location from the instance (the branch and the lockers). This JSON is just a sketch of the shape I expect, not the actual answer — you'll fill it with the real identifiers from the instance.

Please use the identifiers exactly as they appear in the input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[22, 40], [31, 100], [22, 5], [66, 52], [49, 78], [86, 78], [64, 31], [68, 0], [15, 12], [0, 71], [59, 41], [17, 29], [37, 88], [80, 7], [80, 60], [86, 62], [100, 78], [92, 52], [90, 81], [20, 52], [24, 26], [27, 29], [41, 34], [29, 24]], 'prizes': [0, 93, 71, 53, 78, 23, 29, 34, 45, 88, 80, 51, 52, 18, 37, 69, 88, 61, 71, 79, 67, 83, 68, 87], 'penalties': [0, 26, 21, 0, 16, 3, 24, 13, 0, 10, 23, 23, 26, 18, 20, 3, 9, 3, 17, 13, 5, 20, 23, 5], 'required_prize': 600.0, 'depot': 0, 'route_length': 201.95695249074421, 'route_prize': 680.0, 'unvisited_penalty': 122.0, 'objective': 323.95695249074424}","[0, 19, 1, 12, 4, 10, 6, 22, 21, 20, 11, 0]",323.95695249074424,"{'problem_type': 'PCTSP', 'num_nodes': 24, 'nodes': [{'id': 1, 'x': 22, 'y': 40, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 31, 'y': 100, 'prize': 93, 'penalty': 26}, {'id': 3, 'x': 22, 'y': 5, 'prize': 71, 'penalty': 21}, {'id': 4, 'x': 66, 'y': 52, 'prize': 53, 'penalty': 0}, {'id': 5, 'x': 49, 'y': 78, 'prize': 78, 'penalty': 16}, {'id': 6, 'x': 86, 'y': 78, 'prize': 23, 'penalty': 3}, {'id': 7, 'x': 64, 'y': 31, 'prize': 29, 'penalty': 24}, {'id': 8, 'x': 68, 'y': 0, 'prize': 34, 'penalty': 13}, {'id': 9, 'x': 15, 'y': 12, 'prize': 45, 'penalty': 0}, {'id': 10, 'x': 0, 'y': 71, 'prize': 88, 'penalty': 10}, {'id': 11, 'x': 59, 'y': 41, 'prize': 80, 'penalty': 23}, {'id': 12, 'x': 17, 'y': 29, 'prize': 51, 'penalty': 23}, {'id': 13, 'x': 37, 'y': 88, 'prize': 52, 'penalty': 26}, {'id': 14, 'x': 80, 'y': 7, 'prize': 18, 'penalty': 18}, {'id': 15, 'x': 80, 'y': 60, 'prize': 37, 'penalty': 20}, {'id': 16, 'x': 86, 'y': 62, 'prize': 69, 'penalty': 3}, {'id': 17, 'x': 100, 'y': 78, 'prize': 88, 'penalty': 9}, {'id': 18, 'x': 92, 'y': 52, 'prize': 61, 'penalty': 3}, {'id': 19, 'x': 90, 'y': 81, 'prize': 71, 'penalty': 17}, {'id': 20, 'x': 20, 'y': 52, 'prize': 79, 'penalty': 13}, {'id': 21, 'x': 24, 'y': 26, 'prize': 67, 'penalty': 5}, {'id': 22, 'x': 27, 'y': 29, 'prize': 83, 'penalty': 20}, {'id': 23, 'x': 41, 'y': 34, 'prize': 68, 'penalty': 23}, {'id': 24, 'x': 29, 'y': 24, 'prize': 87, 'penalty': 5}], 'depot': 1, 'required_prize': 600.0, 'route_prize': 680.0, 'unvisited_penalty': 122.0, 'route_length': 201.95695249074421, 'objective': 323.95695249074424}","[1, 20, 2, 13, 5, 11, 7, 23, 22, 21, 12, 1]",24,csv,1
PCTSP,PCTSP,"On a typical Monday the garden supervisor lays out a single maintenance hop: the van leaves from the depot and must return there, each garden has an upkeep value and a cost if it’s skipped, and there’s a required total upkeep to hit. The decision is which plots to include in that one-loop route (each visited at most once) so the required upkeep is collected. A route is judged by how little is wasted — add up the miles driven and the fines for any plots left out, and the lower that total the better. The full list of plots, upkeep scores and penalties appears below.

{
  ""total_locations_including_depot"": 21,
  ""nodes"": [
    {
      ""plot_id"": ""A"",
      ""x_coordinate"": 54,
      ""y_coordinate"": 0,
      ""upkeep_score"": 0,
      ""skip_fine"": 0
    },
    {
      ""plot_id"": ""B"",
      ""x_coordinate"": 65,
      ""y_coordinate"": 1,
      ""upkeep_score"": 29,
      ""skip_fine"": 1
    },
    {
      ""plot_id"": ""C"",
      ""x_coordinate"": 5,
      ""y_coordinate"": 4,
      ""upkeep_score"": 82,
      ""skip_fine"": 5
    },
    {
      ""plot_id"": ""D"",
      ""x_coordinate"": 18,
      ""y_coordinate"": 7,
      ""upkeep_score"": 63,
      ""skip_fine"": 13
    },
    {
      ""plot_id"": ""E"",
      ""x_coordinate"": 62,
      ""y_coordinate"": 11,
      ""upkeep_score"": 52,
      ""skip_fine"": 6
    },
    {
      ""plot_id"": ""F"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 11,
      ""upkeep_score"": 44,
      ""skip_fine"": 1
    },
    {
      ""plot_id"": ""G"",
      ""x_coordinate"": 53,
      ""y_coordinate"": 17,
      ""upkeep_score"": 87,
      ""skip_fine"": 14
    },
    {
      ""plot_id"": ""H"",
      ""x_coordinate"": 81,
      ""y_coordinate"": 22,
      ""upkeep_score"": 59,
      ""skip_fine"": 25
    },
    {
      ""plot_id"": ""I"",
      ""x_coordinate"": 47,
      ""y_coordinate"": 33,
      ""upkeep_score"": 79,
      ""skip_fine"": 1
    },
    {
      ""plot_id"": ""J"",
      ""x_coordinate"": 35,
      ""y_coordinate"": 41,
      ""upkeep_score"": 96,
      ""skip_fine"": 20
    },
    {
      ""plot_id"": ""K"",
      ""x_coordinate"": 89,
      ""y_coordinate"": 35,
      ""upkeep_score"": 17,
      ""skip_fine"": 11
    },
    {
      ""plot_id"": ""L"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 65,
      ""upkeep_score"": 25,
      ""skip_fine"": 31
    },
    {
      ""plot_id"": ""M"",
      ""x_coordinate"": 16,
      ""y_coordinate"": 66,
      ""upkeep_score"": 64,
      ""skip_fine"": 24
    },
    {
      ""plot_id"": ""N"",
      ""x_coordinate"": 27,
      ""y_coordinate"": 69,
      ""upkeep_score"": 18,
      ""skip_fine"": 29
    },
    {
      ""plot_id"": ""O"",
      ""x_coordinate"": 42,
      ""y_coordinate"": 70,
      ""upkeep_score"": 15,
      ""skip_fine"": 25
    },
    {
      ""plot_id"": ""P"",
      ""x_coordinate"": 75,
      ""y_coordinate"": 68,
      ""upkeep_score"": 95,
      ""skip_fine"": 21
    },
    {
      ""plot_id"": ""Q"",
      ""x_coordinate"": 52,
      ""y_coordinate"": 78,
      ""upkeep_score"": 89,
      ""skip_fine"": 2
    },
    {
      ""plot_id"": ""R"",
      ""x_coordinate"": 61,
      ""y_coordinate"": 75,
      ""upkeep_score"": 88,
      ""skip_fine"": 14
    },
    {
      ""plot_id"": ""S"",
      ""x_coordinate"": 65,
      ""y_coordinate"": 89,
      ""upkeep_score"": 25,
      ""skip_fine"": 2
    },
    {
      ""plot_id"": ""T"",
      ""x_coordinate"": 98,
      ""y_coordinate"": 89,
      ""upkeep_score"": 53,
      ""skip_fine"": 30
    },
    {
      ""plot_id"": ""U"",
      ""x_coordinate"": 12,
      ""y_coordinate"": 100,
      ""upkeep_score"": 49,
      ""skip_fine"": 20
    }
  ],
  ""depot_site_id"": ""A"",
  ""required_upkeep_score"": 525.0
}

When you're ready to hand me the route, just drop it in this simple JSON shape so I can read it easily:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

This just means: ""solution"" is the one-loop route — start at the depot, list each plot you visit in order (each at most once), and end back at the depot. It's just a sketch of the shape I expect, not the actual answer itself.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[54, 0], [65, 1], [5, 4], [18, 7], [62, 11], [100, 11], [53, 17], [81, 22], [47, 33], [35, 41], [89, 35], [0, 65], [16, 66], [27, 69], [42, 70], [75, 68], [52, 78], [61, 75], [65, 89], [98, 89], [12, 100]], 'prizes': [0, 29, 82, 63, 52, 44, 87, 59, 79, 96, 17, 25, 64, 18, 15, 95, 89, 88, 25, 53, 49], 'penalties': [0, 1, 5, 13, 6, 1, 14, 25, 1, 20, 11, 31, 24, 29, 25, 21, 2, 14, 2, 30, 20], 'required_prize': 525.0, 'depot': 0, 'route_length': 253.9004085210842, 'route_prize': 616.0, 'unvisited_penalty': 75.0, 'objective': 328.90040852108416}","[0, 4, 7, 10, 15, 17, 14, 13, 12, 11, 9, 6, 0]",328.90040852108416,"{'problem_type': 'PCTSP', 'num_nodes': 21, 'nodes': [{'id': 'A', 'x': 54, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 65, 'y': 1, 'prize': 29, 'penalty': 1}, {'id': 'C', 'x': 5, 'y': 4, 'prize': 82, 'penalty': 5}, {'id': 'D', 'x': 18, 'y': 7, 'prize': 63, 'penalty': 13}, {'id': 'E', 'x': 62, 'y': 11, 'prize': 52, 'penalty': 6}, {'id': 'F', 'x': 100, 'y': 11, 'prize': 44, 'penalty': 1}, {'id': 'G', 'x': 53, 'y': 17, 'prize': 87, 'penalty': 14}, {'id': 'H', 'x': 81, 'y': 22, 'prize': 59, 'penalty': 25}, {'id': 'I', 'x': 47, 'y': 33, 'prize': 79, 'penalty': 1}, {'id': 'J', 'x': 35, 'y': 41, 'prize': 96, 'penalty': 20}, {'id': 'K', 'x': 89, 'y': 35, 'prize': 17, 'penalty': 11}, {'id': 'L', 'x': 0, 'y': 65, 'prize': 25, 'penalty': 31}, {'id': 'M', 'x': 16, 'y': 66, 'prize': 64, 'penalty': 24}, {'id': 'N', 'x': 27, 'y': 69, 'prize': 18, 'penalty': 29}, {'id': 'O', 'x': 42, 'y': 70, 'prize': 15, 'penalty': 25}, {'id': 'P', 'x': 75, 'y': 68, 'prize': 95, 'penalty': 21}, {'id': 'Q', 'x': 52, 'y': 78, 'prize': 89, 'penalty': 2}, {'id': 'R', 'x': 61, 'y': 75, 'prize': 88, 'penalty': 14}, {'id': 'S', 'x': 65, 'y': 89, 'prize': 25, 'penalty': 2}, {'id': 'T', 'x': 98, 'y': 89, 'prize': 53, 'penalty': 30}, {'id': 'U', 'x': 12, 'y': 100, 'prize': 49, 'penalty': 20}], 'depot': 'A', 'required_prize': 525.0, 'route_prize': 616.0, 'unvisited_penalty': 75.0, 'route_length': 253.9004085210842, 'objective': 328.90040852108416}","['A', 'E', 'H', 'K', 'P', 'R', 'O', 'N', 'M', 'L', 'J', 'G', 'A']",25,json,names
PCTSP,PCTSP,"There's an antiques buyer planning a single round-trip from their shop to several sellers, trying to pick stops so the purchases add up to at least a required appraisal sum. The task is picking which sellers to stop at and how to string them into one continuous tour that starts and ends at the shop, without repeating stops. The goal is to meet that appraisal threshold while keeping the overall price tag low — where the overall price tag is simply miles driven plus the total value of sellers passed over — so the best plan minimizes that combined amount. The full list of sellers, distances, values, and the required total follow below.

There are 16 locations including the shop at node A; the buyer must collect at least 400.0 in appraisal_value.
Location A at (4, 0) offers appraisal 0 and carries a skip penalty of 0.
Location B at (9, 0) offers appraisal 26 and carries a skip penalty of 18.
Location C at (18, 15) offers appraisal 34 and carries a skip penalty of 19.
Location D at (74, 15) offers appraisal 64 and carries a skip penalty of 32.
Location E at (85, 14) offers appraisal 28 and carries a skip penalty of 8.
Location F at (4, 64) offers appraisal 94 and carries a skip penalty of 15.
Location G at (19, 41) offers appraisal 28 and carries a skip penalty of 25.
Location H at (30, 49) offers appraisal 86 and carries a skip penalty of 22.
Location I at (44, 40) offers appraisal 55 and carries a skip penalty of 25.
Location J at (73, 41) offers appraisal 12 and carries a skip penalty of 35.
Location K at (75, 45) offers appraisal 35 and carries a skip penalty of 9.
Location L at (92, 66) offers appraisal 31 and carries a skip penalty of 10.
Location M at (100, 34) offers appraisal 99 and carries a skip penalty of 31.
Location N at (0, 69) offers appraisal 42 and carries a skip penalty of 17.
Location O at (28, 98) offers appraisal 63 and carries a skip penalty of 0.
Location P at (98, 100) offers appraisal 35 and carries a skip penalty of 33.
The buyer must choose a single non-repeating round-trip starting and ending at the shop that attains at least 400.0 while minimizing miles driven plus the appraisal value of skipped sellers.

Oh, and when you send your plan back, please use this simple JSON layout so it's easy to read and validate:

{
  ""solution"": [shop_id, seller_id, ..., shop_id]
}

Think of that array as the trip sheet: the first item is your shop, then the sellers you stop at in the order you visit them, and the last item is your shop again to show the round-trip. It's just a sketch of the shape I expect, not the final route.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new ones.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[4, 0], [9, 0], [18, 15], [74, 15], [85, 14], [4, 64], [19, 41], [30, 49], [44, 40], [73, 41], [75, 45], [92, 66], [100, 34], [0, 69], [28, 98], [98, 100]], 'prizes': [0, 26, 34, 64, 28, 94, 28, 86, 55, 12, 35, 31, 99, 42, 63, 35], 'penalties': [0, 18, 19, 32, 8, 15, 25, 22, 25, 35, 9, 10, 31, 17, 0, 33], 'required_prize': 400.0, 'depot': 0, 'route_length': 245.3383497944349, 'route_prize': 467.0, 'unvisited_penalty': 75.0, 'objective': 320.3383497944349}","[0, 1, 3, 4, 12, 10, 9, 8, 7, 6, 2, 0]",320.3383497944349,"{'problem_type': 'PCTSP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 4, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 9, 'y': 0, 'prize': 26, 'penalty': 18}, {'id': 'C', 'x': 18, 'y': 15, 'prize': 34, 'penalty': 19}, {'id': 'D', 'x': 74, 'y': 15, 'prize': 64, 'penalty': 32}, {'id': 'E', 'x': 85, 'y': 14, 'prize': 28, 'penalty': 8}, {'id': 'F', 'x': 4, 'y': 64, 'prize': 94, 'penalty': 15}, {'id': 'G', 'x': 19, 'y': 41, 'prize': 28, 'penalty': 25}, {'id': 'H', 'x': 30, 'y': 49, 'prize': 86, 'penalty': 22}, {'id': 'I', 'x': 44, 'y': 40, 'prize': 55, 'penalty': 25}, {'id': 'J', 'x': 73, 'y': 41, 'prize': 12, 'penalty': 35}, {'id': 'K', 'x': 75, 'y': 45, 'prize': 35, 'penalty': 9}, {'id': 'L', 'x': 92, 'y': 66, 'prize': 31, 'penalty': 10}, {'id': 'M', 'x': 100, 'y': 34, 'prize': 99, 'penalty': 31}, {'id': 'N', 'x': 0, 'y': 69, 'prize': 42, 'penalty': 17}, {'id': 'O', 'x': 28, 'y': 98, 'prize': 63, 'penalty': 0}, {'id': 'P', 'x': 98, 'y': 100, 'prize': 35, 'penalty': 33}], 'depot': 'A', 'required_prize': 400.0, 'route_prize': 467.0, 'unvisited_penalty': 75.0, 'route_length': 245.3383497944349, 'objective': 320.3383497944349}","['A', 'B', 'D', 'E', 'M', 'K', 'J', 'I', 'H', 'G', 'C', 'A']",26,nl,names
PCTSP,PCTSP,"There’s a small promotional team figuring out a tidy loop from the company van to several stores and back, trying to hit enough spots to meet a placements target without wasting time. The choice is which stores make the cut so the stops’ placement totals reach the required number; every shop skipped brings a penalty, and the whole run must be a single continuous circuit with no repeated stops. To compare plans, add the total driving time for the circuit to the penalties of all skipped stores — the lower that combined number, the smarter the route. The concrete store and target details follow below.

Here are the 23 map points (the company van is node 1) and the placements target of 575.0.

| store_node_id | map_x_coordinate | map_y_coordinate | placements_at_store | skip_penalty |
|---|---|---|---|---|
| 1 | 80 | 69 | 0 | 0 |
| 2 | 19 | 11 | 38 | 14 |
| 3 | 10 | 69 | 39 | 22 |
| 4 | 84 | 78 | 97 | 27 |
| 5 | 88 | 26 | 34 | 14 |
| 6 | 70 | 6 | 12 | 3 |
| 7 | 50 | 89 | 67 | 4 |
| 8 | 92 | 2 | 26 | 27 |
| 9 | 5 | 3 | 17 | 28 |
| 10 | 0 | 80 | 68 | 22 |
| 11 | 57 | 93 | 8 | 18 |
| 12 | 18 | 3 | 99 | 26 |
| 13 | 50 | 2 | 23 | 23 |
| 14 | 82 | 87 | 36 | 21 |
| 15 | 29 | 100 | 94 | 16 |
| 16 | 1 | 0 | 62 | 21 |
| 17 | 27 | 100 | 1 | 10 |
| 18 | 62 | 3 | 92 | 25 |
| 19 | 100 | 100 | 33 | 24 |
| 20 | 40 | 100 | 14 | 16 |
| 21 | 20 | 0 | 26 | 2 |
| 22 | 59 | 100 | 56 | 12 |
| 23 | 60 | 100 | 76 | 14 |

The team will use these entries to pick a single-loop circuit that meets the placements target while minimizing total drive time plus skipped-store penalties.

Oh, and when you send the plan back, please put it in this simple JSON shape so it's easy to read and check:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of that as a little form: ""solution"" is the van's loop — a single list that starts at the depot, lists each visited store in order, and ends back at the depot. The placeholders are where you'll put the actual IDs from the instance. This block is just a sketch of the expected shape, not the actual route.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""1"" or ""23"", ""A"" or ""B"", ""A1"" or ""X7""","{'coordinates': [[80, 69], [19, 11], [10, 69], [84, 78], [88, 26], [70, 6], [50, 89], [92, 2], [5, 3], [0, 80], [57, 93], [18, 3], [50, 2], [82, 87], [29, 100], [1, 0], [27, 100], [62, 3], [100, 100], [40, 100], [20, 0], [59, 100], [60, 100]], 'prizes': [0, 38, 39, 97, 34, 12, 67, 26, 17, 68, 8, 99, 23, 36, 94, 62, 1, 92, 33, 14, 26, 56, 76], 'penalties': [0, 14, 22, 27, 14, 3, 4, 27, 28, 22, 18, 26, 23, 21, 16, 21, 10, 25, 24, 16, 2, 12, 14], 'required_prize': 575.0, 'depot': 0, 'route_length': 371.6957643551768, 'route_prize': 892.0, 'unvisited_penalty': 30.0, 'objective': 401.69576435517683}","[0, 3, 13, 22, 21, 10, 19, 14, 16, 9, 2, 15, 8, 11, 1, 12, 17, 5, 7, 4, 0]",401.69576435517683,"{'problem_type': 'PCTSP', 'num_nodes': 23, 'nodes': [{'id': 1, 'x': 80, 'y': 69, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 19, 'y': 11, 'prize': 38, 'penalty': 14}, {'id': 3, 'x': 10, 'y': 69, 'prize': 39, 'penalty': 22}, {'id': 4, 'x': 84, 'y': 78, 'prize': 97, 'penalty': 27}, {'id': 5, 'x': 88, 'y': 26, 'prize': 34, 'penalty': 14}, {'id': 6, 'x': 70, 'y': 6, 'prize': 12, 'penalty': 3}, {'id': 7, 'x': 50, 'y': 89, 'prize': 67, 'penalty': 4}, {'id': 8, 'x': 92, 'y': 2, 'prize': 26, 'penalty': 27}, {'id': 9, 'x': 5, 'y': 3, 'prize': 17, 'penalty': 28}, {'id': 10, 'x': 0, 'y': 80, 'prize': 68, 'penalty': 22}, {'id': 11, 'x': 57, 'y': 93, 'prize': 8, 'penalty': 18}, {'id': 12, 'x': 18, 'y': 3, 'prize': 99, 'penalty': 26}, {'id': 13, 'x': 50, 'y': 2, 'prize': 23, 'penalty': 23}, {'id': 14, 'x': 82, 'y': 87, 'prize': 36, 'penalty': 21}, {'id': 15, 'x': 29, 'y': 100, 'prize': 94, 'penalty': 16}, {'id': 16, 'x': 1, 'y': 0, 'prize': 62, 'penalty': 21}, {'id': 17, 'x': 27, 'y': 100, 'prize': 1, 'penalty': 10}, {'id': 18, 'x': 62, 'y': 3, 'prize': 92, 'penalty': 25}, {'id': 19, 'x': 100, 'y': 100, 'prize': 33, 'penalty': 24}, {'id': 20, 'x': 40, 'y': 100, 'prize': 14, 'penalty': 16}, {'id': 21, 'x': 20, 'y': 0, 'prize': 26, 'penalty': 2}, {'id': 22, 'x': 59, 'y': 100, 'prize': 56, 'penalty': 12}, {'id': 23, 'x': 60, 'y': 100, 'prize': 76, 'penalty': 14}], 'depot': 1, 'required_prize': 575.0, 'route_prize': 892.0, 'unvisited_penalty': 30.0, 'route_length': 371.6957643551768, 'objective': 401.69576435517683}","[1, 4, 14, 23, 22, 11, 20, 15, 17, 10, 3, 16, 9, 12, 2, 13, 18, 6, 8, 5, 1]",27,markdown_table,1
PCTSP,PCTSP,"Someone in the field needs to lay out a single inspection loop that starts at the office, visits a selected group of properties, and returns, with the inspected properties’ weights adding up to at least the required amount. Each property brings either inspection weight or a penalty if left out, so a better plan is simply the one that results in the lowest combined cost: the loop’s travel distance plus the penalties for any unvisited properties. The circuit must be a single continuous trip with each chosen stop visited once, and the total inspected weight must meet the mandate. The concrete data for the scenario is shown below.

{
  ""total_locations_including_office"": 25,
  ""nodes"": [
    {
      ""property_node_id"": 1,
      ""map_x_coordinate"": 71,
      ""map_y_coordinate"": 95,
      ""inspection_weight"": 0,
      ""penalty_if_uninspected"": 0
    },
    {
      ""property_node_id"": 2,
      ""map_x_coordinate"": 50,
      ""map_y_coordinate"": 72,
      ""inspection_weight"": 60,
      ""penalty_if_uninspected"": 23
    },
    {
      ""property_node_id"": 3,
      ""map_x_coordinate"": 40,
      ""map_y_coordinate"": 72,
      ""inspection_weight"": 3,
      ""penalty_if_uninspected"": 24
    },
    {
      ""property_node_id"": 4,
      ""map_x_coordinate"": 37,
      ""map_y_coordinate"": 72,
      ""inspection_weight"": 29,
      ""penalty_if_uninspected"": 19
    },
    {
      ""property_node_id"": 5,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 72,
      ""inspection_weight"": 15,
      ""penalty_if_uninspected"": 2
    },
    {
      ""property_node_id"": 6,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 70,
      ""inspection_weight"": 55,
      ""penalty_if_uninspected"": 5
    },
    {
      ""property_node_id"": 7,
      ""map_x_coordinate"": 99,
      ""map_y_coordinate"": 70,
      ""inspection_weight"": 14,
      ""penalty_if_uninspected"": 15
    },
    {
      ""property_node_id"": 8,
      ""map_x_coordinate"": 93,
      ""map_y_coordinate"": 68,
      ""inspection_weight"": 18,
      ""penalty_if_uninspected"": 15
    },
    {
      ""property_node_id"": 9,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 67,
      ""inspection_weight"": 96,
      ""penalty_if_uninspected"": 26
    },
    {
      ""property_node_id"": 10,
      ""map_x_coordinate"": 72,
      ""map_y_coordinate"": 67,
      ""inspection_weight"": 26,
      ""penalty_if_uninspected"": 15
    },
    {
      ""property_node_id"": 11,
      ""map_x_coordinate"": 94,
      ""map_y_coordinate"": 66,
      ""inspection_weight"": 52,
      ""penalty_if_uninspected"": 22
    },
    {
      ""property_node_id"": 12,
      ""map_x_coordinate"": 95,
      ""map_y_coordinate"": 59,
      ""inspection_weight"": 23,
      ""penalty_if_uninspected"": 17
    },
    {
      ""property_node_id"": 13,
      ""map_x_coordinate"": 77,
      ""map_y_coordinate"": 58,
      ""inspection_weight"": 2,
      ""penalty_if_uninspected"": 2
    },
    {
      ""property_node_id"": 14,
      ""map_x_coordinate"": 98,
      ""map_y_coordinate"": 57,
      ""inspection_weight"": 72,
      ""penalty_if_uninspected"": 10
    },
    {
      ""property_node_id"": 15,
      ""map_x_coordinate"": 61,
      ""map_y_coordinate"": 45,
      ""inspection_weight"": 37,
      ""penalty_if_uninspected"": 13
    },
    {
      ""property_node_id"": 16,
      ""map_x_coordinate"": 48,
      ""map_y_coordinate"": 33,
      ""inspection_weight"": 47,
      ""penalty_if_uninspected"": 4
    },
    {
      ""property_node_id"": 17,
      ""map_x_coordinate"": 97,
      ""map_y_coordinate"": 24,
      ""inspection_weight"": 1,
      ""penalty_if_uninspected"": 13
    },
    {
      ""property_node_id"": 18,
      ""map_x_coordinate"": 12,
      ""map_y_coordinate"": 100,
      ""inspection_weight"": 19,
      ""penalty_if_uninspected"": 16
    },
    {
      ""property_node_id"": 19,
      ""map_x_coordinate"": 35,
      ""map_y_coordinate"": 100,
      ""inspection_weight"": 56,
      ""penalty_if_uninspected"": 22
    },
    {
      ""property_node_id"": 20,
      ""map_x_coordinate"": 82,
      ""map_y_coordinate"": 100,
      ""inspection_weight"": 68,
      ""penalty_if_uninspected"": 18
    },
    {
      ""property_node_id"": 21,
      ""map_x_coordinate"": 33,
      ""map_y_coordinate"": 100,
      ""inspection_weight"": 64,
      ""penalty_if_uninspected"": 23
    },
    {
      ""property_node_id"": 22,
      ""map_x_coordinate"": 89,
      ""map_y_coordinate"": 99,
      ""inspection_weight"": 95,
      ""penalty_if_uninspected"": 23
    },
    {
      ""property_node_id"": 23,
      ""map_x_coordinate"": 93,
      ""map_y_coordinate"": 1,
      ""inspection_weight"": 36,
      ""penalty_if_uninspected"": 2
    },
    {
      ""property_node_id"": 24,
      ""map_x_coordinate"": 15,
      ""map_y_coordinate"": 0,
      ""inspection_weight"": 86,
      ""penalty_if_uninspected"": 25
    },
    {
      ""property_node_id"": 25,
      ""map_x_coordinate"": 85,
      ""map_y_coordinate"": 0,
      ""inspection_weight"": 75,
      ""penalty_if_uninspected"": 12
    }
  ],
  ""office_node_id"": 1,
  ""mandated_inspection_weight"": 625.0
}

Also, when you're ready to hand back the route, just use this simple JSON layout so it's easy to read and plug in:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Here ""solution"" is an ordered list showing the inspection loop: start at the depot, visit each listed property once in the shown order, and come back to the depot. Think of each entry as the ID you see in the instance — it's just a quick form, not the final plan itself.

This JSON is only a sketch of the expected shape, not the actual answer you need to compute. Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. 

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[71, 95], [50, 72], [40, 72], [37, 72], [0, 72], [100, 70], [99, 70], [93, 68], [100, 67], [72, 67], [94, 66], [95, 59], [77, 58], [98, 57], [61, 45], [48, 33], [97, 24], [12, 100], [35, 100], [82, 100], [33, 100], [89, 99], [93, 1], [15, 0], [85, 0]], 'prizes': [0, 60, 3, 29, 15, 55, 14, 18, 96, 26, 52, 23, 2, 72, 37, 47, 1, 19, 56, 68, 64, 95, 36, 86, 75], 'penalties': [0, 23, 24, 19, 2, 5, 15, 15, 26, 15, 22, 17, 2, 10, 13, 4, 13, 16, 22, 18, 23, 23, 2, 25, 12], 'required_prize': 625.0, 'depot': 0, 'route_length': 200.1552225030508, 'route_prize': 731.0, 'unvisited_penalty': 89.0, 'objective': 289.1552225030508}","[0, 18, 20, 3, 2, 1, 9, 7, 10, 11, 13, 8, 5, 6, 21, 19, 0]",289.1552225030508,"{'problem_type': 'PCTSP', 'num_nodes': 25, 'nodes': [{'id': 1, 'x': 71, 'y': 95, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 50, 'y': 72, 'prize': 60, 'penalty': 23}, {'id': 3, 'x': 40, 'y': 72, 'prize': 3, 'penalty': 24}, {'id': 4, 'x': 37, 'y': 72, 'prize': 29, 'penalty': 19}, {'id': 5, 'x': 0, 'y': 72, 'prize': 15, 'penalty': 2}, {'id': 6, 'x': 100, 'y': 70, 'prize': 55, 'penalty': 5}, {'id': 7, 'x': 99, 'y': 70, 'prize': 14, 'penalty': 15}, {'id': 8, 'x': 93, 'y': 68, 'prize': 18, 'penalty': 15}, {'id': 9, 'x': 100, 'y': 67, 'prize': 96, 'penalty': 26}, {'id': 10, 'x': 72, 'y': 67, 'prize': 26, 'penalty': 15}, {'id': 11, 'x': 94, 'y': 66, 'prize': 52, 'penalty': 22}, {'id': 12, 'x': 95, 'y': 59, 'prize': 23, 'penalty': 17}, {'id': 13, 'x': 77, 'y': 58, 'prize': 2, 'penalty': 2}, {'id': 14, 'x': 98, 'y': 57, 'prize': 72, 'penalty': 10}, {'id': 15, 'x': 61, 'y': 45, 'prize': 37, 'penalty': 13}, {'id': 16, 'x': 48, 'y': 33, 'prize': 47, 'penalty': 4}, {'id': 17, 'x': 97, 'y': 24, 'prize': 1, 'penalty': 13}, {'id': 18, 'x': 12, 'y': 100, 'prize': 19, 'penalty': 16}, {'id': 19, 'x': 35, 'y': 100, 'prize': 56, 'penalty': 22}, {'id': 20, 'x': 82, 'y': 100, 'prize': 68, 'penalty': 18}, {'id': 21, 'x': 33, 'y': 100, 'prize': 64, 'penalty': 23}, {'id': 22, 'x': 89, 'y': 99, 'prize': 95, 'penalty': 23}, {'id': 23, 'x': 93, 'y': 1, 'prize': 36, 'penalty': 2}, {'id': 24, 'x': 15, 'y': 0, 'prize': 86, 'penalty': 25}, {'id': 25, 'x': 85, 'y': 0, 'prize': 75, 'penalty': 12}], 'depot': 1, 'required_prize': 625.0, 'route_prize': 731.0, 'unvisited_penalty': 89.0, 'route_length': 200.1552225030508, 'objective': 289.1552225030508}","[1, 19, 21, 4, 3, 2, 10, 8, 11, 12, 14, 9, 6, 7, 22, 20, 1]",28,json,1
PCTSP,PCTSP,"Many people on the team pitch ideas for a single photographer’s round trip: leave the newsroom, photograph selected events, and return, all in one go. The practical decision is which events to include and in what order so the photos add up to at least the minimum coverage the editors want, and the best plan keeps the combined cost low — travel distance for the loop plus the editorial price of anything missed. That means summing the miles on the circuit and the penalties for skipped events; lower sums are preferable. The tour must be a single loop starting and ending at the newsroom, with no repeated visits, and the concrete details will be shown below.

{
  ""total_locations_including_newsroom"": 24,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""x_coordinate"": 54,
      ""y_coordinate"": 94,
      ""coverage_value"": 0,
      ""missed_event_penalty"": 0
    },
    {
      ""location_id"": 1,
      ""x_coordinate"": 37,
      ""y_coordinate"": 93,
      ""coverage_value"": 28,
      ""missed_event_penalty"": 17
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 48,
      ""y_coordinate"": 79,
      ""coverage_value"": 29,
      ""missed_event_penalty"": 6
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 48,
      ""y_coordinate"": 33,
      ""coverage_value"": 49,
      ""missed_event_penalty"": 23
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 36,
      ""y_coordinate"": 32,
      ""coverage_value"": 94,
      ""missed_event_penalty"": 25
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 54,
      ""y_coordinate"": 31,
      ""coverage_value"": 43,
      ""missed_event_penalty"": 27
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 81,
      ""y_coordinate"": 100,
      ""coverage_value"": 96,
      ""missed_event_penalty"": 10
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 78,
      ""y_coordinate"": 99,
      ""coverage_value"": 94,
      ""missed_event_penalty"": 28
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 70,
      ""y_coordinate"": 100,
      ""coverage_value"": 78,
      ""missed_event_penalty"": 11
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 4,
      ""y_coordinate"": 100,
      ""coverage_value"": 42,
      ""missed_event_penalty"": 7
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 2,
      ""y_coordinate"": 99,
      ""coverage_value"": 39,
      ""missed_event_penalty"": 20
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 1,
      ""y_coordinate"": 99,
      ""coverage_value"": 78,
      ""missed_event_penalty"": 1
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 0,
      ""y_coordinate"": 0,
      ""coverage_value"": 40,
      ""missed_event_penalty"": 6
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 100,
      ""y_coordinate"": 100,
      ""coverage_value"": 7,
      ""missed_event_penalty"": 4
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 89,
      ""y_coordinate"": 100,
      ""coverage_value"": 87,
      ""missed_event_penalty"": 9
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 26,
      ""y_coordinate"": 100,
      ""coverage_value"": 31,
      ""missed_event_penalty"": 25
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 13,
      ""y_coordinate"": 99,
      ""coverage_value"": 67,
      ""missed_event_penalty"": 4
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 91,
      ""y_coordinate"": 99,
      ""coverage_value"": 77,
      ""missed_event_penalty"": 27
    },
    {
      ""location_id"": 18,
      ""x_coordinate"": 82,
      ""y_coordinate"": 1,
      ""coverage_value"": 69,
      ""missed_event_penalty"": 21
    },
    {
      ""location_id"": 19,
      ""x_coordinate"": 90,
      ""y_coordinate"": 1,
      ""coverage_value"": 97,
      ""missed_event_penalty"": 23
    },
    {
      ""location_id"": 20,
      ""x_coordinate"": 99,
      ""y_coordinate"": 0,
      ""coverage_value"": 51,
      ""missed_event_penalty"": 13
    },
    {
      ""location_id"": 21,
      ""x_coordinate"": 86,
      ""y_coordinate"": 0,
      ""coverage_value"": 94,
      ""missed_event_penalty"": 26
    },
    {
      ""location_id"": 22,
      ""x_coordinate"": 27,
      ""y_coordinate"": 0,
      ""coverage_value"": 5,
      ""missed_event_penalty"": 17
    },
    {
      ""location_id"": 23,
      ""x_coordinate"": 25,
      ""y_coordinate"": 0,
      ""coverage_value"": 46,
      ""missed_event_penalty"": 25
    }
  ],
  ""newsroom_node_id"": 0,
  ""required_coverage_value"": 600.0
}

Oh, and when you send the tour back, a simple JSON like this is perfect — just an ordered list showing the loop from the newsroom and back:

{
  ""solution"": [""newsroom_id"", ""event_id"", ""..."", ""newsroom_id""]
}

Think of ""solution"" as the short form of the trip: start at the newsroom, visit the events in the order listed, and return to the newsroom. The strings above are just placeholders to show the shape I expect — your real reply should replace them with the actual IDs from the instance.

One more thing: use the identifiers exactly as they appear in the problem input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[54, 94], [37, 93], [48, 79], [48, 33], [36, 32], [54, 31], [81, 100], [78, 99], [70, 100], [4, 100], [2, 99], [1, 99], [0, 0], [100, 100], [89, 100], [26, 100], [13, 99], [91, 99], [82, 1], [90, 1], [99, 0], [86, 0], [27, 0], [25, 0]], 'prizes': [0, 28, 29, 49, 94, 43, 96, 94, 78, 42, 39, 78, 40, 7, 87, 31, 67, 77, 69, 97, 51, 94, 5, 46], 'penalties': [0, 17, 6, 23, 25, 27, 10, 28, 11, 7, 20, 1, 6, 4, 9, 25, 4, 27, 21, 23, 13, 26, 17, 25], 'required_prize': 600.0, 'depot': 0, 'route_length': 179.62117542286066, 'route_prize': 639.0, 'unvisited_penalty': 217.0, 'objective': 396.62117542286063}","[0, 1, 10, 9, 16, 15, 8, 6, 14, 17, 7, 0]",396.62117542286063,"{'problem_type': 'PCTSP', 'num_nodes': 24, 'nodes': [{'id': 0, 'x': 54, 'y': 94, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 37, 'y': 93, 'prize': 28, 'penalty': 17}, {'id': 2, 'x': 48, 'y': 79, 'prize': 29, 'penalty': 6}, {'id': 3, 'x': 48, 'y': 33, 'prize': 49, 'penalty': 23}, {'id': 4, 'x': 36, 'y': 32, 'prize': 94, 'penalty': 25}, {'id': 5, 'x': 54, 'y': 31, 'prize': 43, 'penalty': 27}, {'id': 6, 'x': 81, 'y': 100, 'prize': 96, 'penalty': 10}, {'id': 7, 'x': 78, 'y': 99, 'prize': 94, 'penalty': 28}, {'id': 8, 'x': 70, 'y': 100, 'prize': 78, 'penalty': 11}, {'id': 9, 'x': 4, 'y': 100, 'prize': 42, 'penalty': 7}, {'id': 10, 'x': 2, 'y': 99, 'prize': 39, 'penalty': 20}, {'id': 11, 'x': 1, 'y': 99, 'prize': 78, 'penalty': 1}, {'id': 12, 'x': 0, 'y': 0, 'prize': 40, 'penalty': 6}, {'id': 13, 'x': 100, 'y': 100, 'prize': 7, 'penalty': 4}, {'id': 14, 'x': 89, 'y': 100, 'prize': 87, 'penalty': 9}, {'id': 15, 'x': 26, 'y': 100, 'prize': 31, 'penalty': 25}, {'id': 16, 'x': 13, 'y': 99, 'prize': 67, 'penalty': 4}, {'id': 17, 'x': 91, 'y': 99, 'prize': 77, 'penalty': 27}, {'id': 18, 'x': 82, 'y': 1, 'prize': 69, 'penalty': 21}, {'id': 19, 'x': 90, 'y': 1, 'prize': 97, 'penalty': 23}, {'id': 20, 'x': 99, 'y': 0, 'prize': 51, 'penalty': 13}, {'id': 21, 'x': 86, 'y': 0, 'prize': 94, 'penalty': 26}, {'id': 22, 'x': 27, 'y': 0, 'prize': 5, 'penalty': 17}, {'id': 23, 'x': 25, 'y': 0, 'prize': 46, 'penalty': 25}], 'depot': 0, 'required_prize': 600.0, 'route_prize': 639.0, 'unvisited_penalty': 217.0, 'route_length': 179.62117542286066, 'objective': 396.62117542286063}","[0, 1, 10, 9, 16, 15, 8, 6, 14, 17, 7, 0]",29,json,0
PCTSP,PCTSP,"We have to send a driver out on one tidy circuit from the flower shop and back, choosing which seasonal arrangements to deliver so the sum of delivered order values meets a target. A good choice balances short driving distance with small payouts to customers who don’t get deliveries; think of the final bill as total mileage plus the compensation paid to anyone skipped. Stops shouldn’t be duplicated and the trip begins and ends at the shop. The concrete addresses, order sizes, and compensation figures follow below.

We have 25 locations, the shop node is 1, and we must collect at least 625.0 in order value.

| location_id | x_coordinate | y_coordinate | order_value | compensation_if_unserved |
|---|---|---|---|---|
| 1 | 0 | 100 | 0 | 0 |
| 2 | 80 | 85 | 96 | 9 |
| 3 | 28 | 33 | 98 | 2 |
| 4 | 19 | 66 | 40 | 5 |
| 5 | 67 | 9 | 16 | 22 |
| 6 | 80 | 79 | 97 | 3 |
| 7 | 8 | 88 | 24 | 4 |
| 8 | 97 | 61 | 80 | 23 |
| 9 | 93 | 98 | 94 | 6 |
| 10 | 66 | 98 | 2 | 26 |
| 11 | 65 | 80 | 73 | 8 |
| 12 | 1 | 54 | 6 | 5 |
| 13 | 100 | 49 | 52 | 11 |
| 14 | 83 | 54 | 86 | 0 |
| 15 | 60 | 98 | 8 | 11 |
| 16 | 78 | 11 | 21 | 15 |
| 17 | 56 | 50 | 78 | 26 |
| 18 | 20 | 14 | 70 | 19 |
| 19 | 93 | 34 | 76 | 10 |
| 20 | 0 | 0 | 52 | 10 |
| 21 | 99 | 70 | 27 | 11 |
| 22 | 91 | 96 | 34 | 6 |
| 23 | 85 | 19 | 72 | 5 |
| 24 | 18 | 9 | 99 | 5 |
| 25 | 22 | 37 | 31 | 21 |

We must choose a single circuit that meets 625.0 while minimizing total mileage plus compensations.

Oh, and when you send the chosen route back, please use a tiny JSON sketch like this so I can read it easily:

{
  ""solution"": [shop_id, order_id, ..., shop_id]
}

This just shows the shape I expect: the array called ""solution"" lists the shop (depot) first, then the customer stops in the order they'll be visited, and the shop again at the end. Think of it like filling out a simple itinerary form — it's just the stop sequence, not the distances or payments.

This is only a sketch of the format, not your actual answer. Please be sure to use the exact identifiers from the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 100], [80, 85], [28, 33], [19, 66], [67, 9], [80, 79], [8, 88], [97, 61], [93, 98], [66, 98], [65, 80], [1, 54], [100, 49], [83, 54], [60, 98], [78, 11], [56, 50], [20, 14], [93, 34], [0, 0], [99, 70], [91, 96], [85, 19], [18, 9], [22, 37]], 'prizes': [0, 96, 98, 40, 16, 97, 24, 80, 94, 2, 73, 6, 52, 86, 8, 21, 78, 70, 76, 52, 27, 34, 72, 99, 31], 'penalties': [0, 9, 2, 5, 22, 3, 4, 23, 6, 26, 8, 5, 11, 0, 11, 15, 26, 19, 10, 10, 11, 6, 5, 5, 21], 'required_prize': 625.0, 'depot': 0, 'route_length': 310.89459783644094, 'route_prize': 689.0, 'unvisited_penalty': 82.0, 'objective': 392.89455693689575}","[0, 6, 3, 16, 4, 15, 22, 18, 12, 7, 20, 5, 1, 9, 14, 0]",392.89455693689575,"{'problem_type': 'PCTSP', 'num_nodes': 25, 'nodes': [{'id': 1, 'x': 0, 'y': 100, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 80, 'y': 85, 'prize': 96, 'penalty': 9}, {'id': 3, 'x': 28, 'y': 33, 'prize': 98, 'penalty': 2}, {'id': 4, 'x': 19, 'y': 66, 'prize': 40, 'penalty': 5}, {'id': 5, 'x': 67, 'y': 9, 'prize': 16, 'penalty': 22}, {'id': 6, 'x': 80, 'y': 79, 'prize': 97, 'penalty': 3}, {'id': 7, 'x': 8, 'y': 88, 'prize': 24, 'penalty': 4}, {'id': 8, 'x': 97, 'y': 61, 'prize': 80, 'penalty': 23}, {'id': 9, 'x': 93, 'y': 98, 'prize': 94, 'penalty': 6}, {'id': 10, 'x': 66, 'y': 98, 'prize': 2, 'penalty': 26}, {'id': 11, 'x': 65, 'y': 80, 'prize': 73, 'penalty': 8}, {'id': 12, 'x': 1, 'y': 54, 'prize': 6, 'penalty': 5}, {'id': 13, 'x': 100, 'y': 49, 'prize': 52, 'penalty': 11}, {'id': 14, 'x': 83, 'y': 54, 'prize': 86, 'penalty': 0}, {'id': 15, 'x': 60, 'y': 98, 'prize': 8, 'penalty': 11}, {'id': 16, 'x': 78, 'y': 11, 'prize': 21, 'penalty': 15}, {'id': 17, 'x': 56, 'y': 50, 'prize': 78, 'penalty': 26}, {'id': 18, 'x': 20, 'y': 14, 'prize': 70, 'penalty': 19}, {'id': 19, 'x': 93, 'y': 34, 'prize': 76, 'penalty': 10}, {'id': 20, 'x': 0, 'y': 0, 'prize': 52, 'penalty': 10}, {'id': 21, 'x': 99, 'y': 70, 'prize': 27, 'penalty': 11}, {'id': 22, 'x': 91, 'y': 96, 'prize': 34, 'penalty': 6}, {'id': 23, 'x': 85, 'y': 19, 'prize': 72, 'penalty': 5}, {'id': 24, 'x': 18, 'y': 9, 'prize': 99, 'penalty': 5}, {'id': 25, 'x': 22, 'y': 37, 'prize': 31, 'penalty': 21}], 'depot': 1, 'required_prize': 625.0, 'route_prize': 689.0, 'unvisited_penalty': 82.0, 'route_length': 310.89459783644094, 'objective': 392.89455693689575}","[1, 7, 4, 17, 5, 16, 23, 19, 13, 8, 21, 6, 2, 10, 15, 1]",30,markdown_table,1
PCTSP,PCTSP,"Someone on the team needs to draw up a single road trip that begins and ends at headquarters, stopping at a selection of venues to secure bookings until the total booking value crosses our minimum goal. What makes one trip preferable to another is the total damage to the bottom line: traveling expenses for the whole loop plus penalties for venues we skipped — that combined amount is what we try to minimize. Each venue only counts once, the tour must be continuous and return to the office, and the chosen stops must reach the target booking sum. The full instance details are below.

{
  ""total_locations_including_office"": 22,
  ""nodes"": [
    {
      ""venue_node_id"": ""A"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 74,
      ""booking_value"": 0,
      ""missed_booking_penalty"": 0
    },
    {
      ""venue_node_id"": ""B"",
      ""x_coordinate"": 15,
      ""y_coordinate"": 85,
      ""booking_value"": 51,
      ""missed_booking_penalty"": 10
    },
    {
      ""venue_node_id"": ""C"",
      ""x_coordinate"": 83,
      ""y_coordinate"": 85,
      ""booking_value"": 28,
      ""missed_booking_penalty"": 13
    },
    {
      ""venue_node_id"": ""D"",
      ""x_coordinate"": 51,
      ""y_coordinate"": 0,
      ""booking_value"": 59,
      ""missed_booking_penalty"": 0
    },
    {
      ""venue_node_id"": ""E"",
      ""x_coordinate"": 89,
      ""y_coordinate"": 50,
      ""booking_value"": 17,
      ""missed_booking_penalty"": 20
    },
    {
      ""venue_node_id"": ""F"",
      ""x_coordinate"": 82,
      ""y_coordinate"": 66,
      ""booking_value"": 56,
      ""missed_booking_penalty"": 2
    },
    {
      ""venue_node_id"": ""G"",
      ""x_coordinate"": 7,
      ""y_coordinate"": 68,
      ""booking_value"": 32,
      ""missed_booking_penalty"": 15
    },
    {
      ""venue_node_id"": ""H"",
      ""x_coordinate"": 48,
      ""y_coordinate"": 16,
      ""booking_value"": 76,
      ""missed_booking_penalty"": 5
    },
    {
      ""venue_node_id"": ""I"",
      ""x_coordinate"": 77,
      ""y_coordinate"": 100,
      ""booking_value"": 97,
      ""missed_booking_penalty"": 26
    },
    {
      ""venue_node_id"": ""J"",
      ""x_coordinate"": 70,
      ""y_coordinate"": 96,
      ""booking_value"": 98,
      ""missed_booking_penalty"": 6
    },
    {
      ""venue_node_id"": ""K"",
      ""x_coordinate"": 77,
      ""y_coordinate"": 13,
      ""booking_value"": 6,
      ""missed_booking_penalty"": 14
    },
    {
      ""venue_node_id"": ""L"",
      ""x_coordinate"": 72,
      ""y_coordinate"": 93,
      ""booking_value"": 20,
      ""missed_booking_penalty"": 17
    },
    {
      ""venue_node_id"": ""M"",
      ""x_coordinate"": 96,
      ""y_coordinate"": 27,
      ""booking_value"": 24,
      ""missed_booking_penalty"": 12
    },
    {
      ""venue_node_id"": ""N"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 77,
      ""booking_value"": 96,
      ""missed_booking_penalty"": 4
    },
    {
      ""venue_node_id"": ""O"",
      ""x_coordinate"": 19,
      ""y_coordinate"": 77,
      ""booking_value"": 75,
      ""missed_booking_penalty"": 6
    },
    {
      ""venue_node_id"": ""P"",
      ""x_coordinate"": 57,
      ""y_coordinate"": 72,
      ""booking_value"": 16,
      ""missed_booking_penalty"": 16
    },
    {
      ""venue_node_id"": ""Q"",
      ""x_coordinate"": 50,
      ""y_coordinate"": 65,
      ""booking_value"": 3,
      ""missed_booking_penalty"": 3
    },
    {
      ""venue_node_id"": ""R"",
      ""x_coordinate"": 18,
      ""y_coordinate"": 52,
      ""booking_value"": 34,
      ""missed_booking_penalty"": 27
    },
    {
      ""venue_node_id"": ""S"",
      ""x_coordinate"": 95,
      ""y_coordinate"": 90,
      ""booking_value"": 26,
      ""missed_booking_penalty"": 25
    },
    {
      ""venue_node_id"": ""T"",
      ""x_coordinate"": 35,
      ""y_coordinate"": 2,
      ""booking_value"": 84,
      ""missed_booking_penalty"": 3
    },
    {
      ""venue_node_id"": ""U"",
      ""x_coordinate"": 57,
      ""y_coordinate"": 60,
      ""booking_value"": 95,
      ""missed_booking_penalty"": 2
    },
    {
      ""venue_node_id"": ""V"",
      ""x_coordinate"": 50,
      ""y_coordinate"": 13,
      ""booking_value"": 26,
      ""missed_booking_penalty"": 15
    }
  ],
  ""office_node_id"": ""A"",
  ""required_booking_value"": 550.0
}

Oh, and when you send the planned route back, please use a simple JSON shape like this:

{
  ""solution"": [hq_id, venue_id, ..., hq_id]
}

Think of that array as the ordered checklist of stops: start at HQ, list the venues you’ll stop at in order, and finish back at HQ. This is just the sketch of the shape I want — not the actual answer.

Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[100, 74], [15, 85], [83, 85], [51, 0], [89, 50], [82, 66], [7, 68], [48, 16], [77, 100], [70, 96], [77, 13], [72, 93], [96, 27], [0, 77], [19, 77], [57, 72], [50, 65], [18, 52], [95, 90], [35, 2], [57, 60], [50, 13]], 'prizes': [0, 51, 28, 59, 17, 56, 32, 76, 97, 98, 6, 20, 24, 96, 75, 16, 3, 34, 26, 84, 95, 26], 'penalties': [0, 10, 13, 0, 20, 2, 15, 5, 26, 6, 14, 17, 12, 4, 6, 16, 3, 27, 25, 3, 2, 15], 'required_prize': 550.0, 'depot': 0, 'route_length': 255.71435108468907, 'route_prize': 585.0, 'unvisited_penalty': 68.0, 'objective': 323.71435108468904}","[0, 18, 2, 8, 9, 11, 15, 20, 7, 21, 10, 12, 4, 5, 0]",323.71435108468904,"{'problem_type': 'PCTSP', 'num_nodes': 22, 'nodes': [{'id': 'A', 'x': 100, 'y': 74, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 15, 'y': 85, 'prize': 51, 'penalty': 10}, {'id': 'C', 'x': 83, 'y': 85, 'prize': 28, 'penalty': 13}, {'id': 'D', 'x': 51, 'y': 0, 'prize': 59, 'penalty': 0}, {'id': 'E', 'x': 89, 'y': 50, 'prize': 17, 'penalty': 20}, {'id': 'F', 'x': 82, 'y': 66, 'prize': 56, 'penalty': 2}, {'id': 'G', 'x': 7, 'y': 68, 'prize': 32, 'penalty': 15}, {'id': 'H', 'x': 48, 'y': 16, 'prize': 76, 'penalty': 5}, {'id': 'I', 'x': 77, 'y': 100, 'prize': 97, 'penalty': 26}, {'id': 'J', 'x': 70, 'y': 96, 'prize': 98, 'penalty': 6}, {'id': 'K', 'x': 77, 'y': 13, 'prize': 6, 'penalty': 14}, {'id': 'L', 'x': 72, 'y': 93, 'prize': 20, 'penalty': 17}, {'id': 'M', 'x': 96, 'y': 27, 'prize': 24, 'penalty': 12}, {'id': 'N', 'x': 0, 'y': 77, 'prize': 96, 'penalty': 4}, {'id': 'O', 'x': 19, 'y': 77, 'prize': 75, 'penalty': 6}, {'id': 'P', 'x': 57, 'y': 72, 'prize': 16, 'penalty': 16}, {'id': 'Q', 'x': 50, 'y': 65, 'prize': 3, 'penalty': 3}, {'id': 'R', 'x': 18, 'y': 52, 'prize': 34, 'penalty': 27}, {'id': 'S', 'x': 95, 'y': 90, 'prize': 26, 'penalty': 25}, {'id': 'T', 'x': 35, 'y': 2, 'prize': 84, 'penalty': 3}, {'id': 'U', 'x': 57, 'y': 60, 'prize': 95, 'penalty': 2}, {'id': 'V', 'x': 50, 'y': 13, 'prize': 26, 'penalty': 15}], 'depot': 'A', 'required_prize': 550.0, 'route_prize': 585.0, 'unvisited_penalty': 68.0, 'route_length': 255.71435108468907, 'objective': 323.71435108468904}","['A', 'S', 'C', 'I', 'J', 'L', 'P', 'U', 'H', 'V', 'K', 'M', 'E', 'F', 'A']",31,json,names
PCTSP,PCTSP,"Imagine a dispatch plan where one technician leaves the depot, visits a hand-picked set of rooftops, and returns to the depot, making sure the total inspected capacity hits the mandated target. The decision is which roofs to book into that single round-trip; the score for any plan is simply drive time for the whole loop plus the sum of penalties for roofs not visited — smaller totals are preferred. The trip must be one continuous tour, each rooftop can only be inspected once, and omitted sites always incur their penalties. The concrete details are given below.

The instance lists 20 locations, with depot 0, and a required inspected capacity of 500.0.

| location_id | x_coord | y_coord | inspected_capacity | omission_penalty |
|---|---|---|---|---|
| 0 | 100 | 9 | 0 | 0 |
| 1 | 100 | 84 | 99 | 10 |
| 2 | 95 | 1 | 10 | 22 |
| 3 | 79 | 13 | 53 | 22 |
| 4 | 80 | 17 | 51 | 5 |
| 5 | 83 | 58 | 57 | 13 |
| 6 | 59 | 24 | 39 | 26 |
| 7 | 48 | 27 | 53 | 28 |
| 8 | 39 | 0 | 41 | 11 |
| 9 | 41 | 30 | 9 | 24 |
| 10 | 19 | 2 | 12 | 10 |
| 11 | 48 | 56 | 93 | 4 |
| 12 | 47 | 61 | 41 | 21 |
| 13 | 48 | 98 | 69 | 13 |
| 14 | 32 | 55 | 85 | 1 |
| 15 | 4 | 28 | 12 | 14 |
| 16 | 6 | 61 | 13 | 7 |
| 17 | 1 | 70 | 65 | 12 |
| 18 | 0 | 60 | 30 | 10 |
| 19 | 4 | 100 | 49 | 21 |

Plan a single continuous tour starting and ending at 0 that achieves at least 500.0 inspected capacity and minimizes drive time plus omitted-site penalties.

When you reply with the chosen tour, please stick to this simple JSON layout so it's straightforward to check:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

""solution"" is just the ordered list of stops — start at the depot, list each rooftop you visit in the order you drive them, and finish back at the depot. The depot_id and location_id bits are placeholders for the actual IDs from the instance. This is only a sketch of the shape I want, not the actual answer.

Please make sure to use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[100, 9], [100, 84], [95, 1], [79, 13], [80, 17], [83, 58], [59, 24], [48, 27], [39, 0], [41, 30], [19, 2], [48, 56], [47, 61], [48, 98], [32, 55], [4, 28], [6, 61], [1, 70], [0, 60], [4, 100]], 'prizes': [0, 99, 10, 53, 51, 57, 39, 53, 41, 9, 12, 93, 41, 69, 85, 12, 13, 65, 30, 49], 'penalties': [0, 10, 22, 22, 5, 13, 26, 28, 11, 24, 10, 4, 21, 13, 1, 14, 7, 12, 10, 21], 'required_prize': 500.0, 'depot': 0, 'route_length': 247.44048764116854, 'route_prize': 505.0, 'unvisited_penalty': 99.0, 'objective': 346.4404876411686}","[0, 2, 3, 4, 6, 7, 9, 11, 12, 1, 5, 0]",346.4404876411686,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 100, 'y': 9, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 100, 'y': 84, 'prize': 99, 'penalty': 10}, {'id': 2, 'x': 95, 'y': 1, 'prize': 10, 'penalty': 22}, {'id': 3, 'x': 79, 'y': 13, 'prize': 53, 'penalty': 22}, {'id': 4, 'x': 80, 'y': 17, 'prize': 51, 'penalty': 5}, {'id': 5, 'x': 83, 'y': 58, 'prize': 57, 'penalty': 13}, {'id': 6, 'x': 59, 'y': 24, 'prize': 39, 'penalty': 26}, {'id': 7, 'x': 48, 'y': 27, 'prize': 53, 'penalty': 28}, {'id': 8, 'x': 39, 'y': 0, 'prize': 41, 'penalty': 11}, {'id': 9, 'x': 41, 'y': 30, 'prize': 9, 'penalty': 24}, {'id': 10, 'x': 19, 'y': 2, 'prize': 12, 'penalty': 10}, {'id': 11, 'x': 48, 'y': 56, 'prize': 93, 'penalty': 4}, {'id': 12, 'x': 47, 'y': 61, 'prize': 41, 'penalty': 21}, {'id': 13, 'x': 48, 'y': 98, 'prize': 69, 'penalty': 13}, {'id': 14, 'x': 32, 'y': 55, 'prize': 85, 'penalty': 1}, {'id': 15, 'x': 4, 'y': 28, 'prize': 12, 'penalty': 14}, {'id': 16, 'x': 6, 'y': 61, 'prize': 13, 'penalty': 7}, {'id': 17, 'x': 1, 'y': 70, 'prize': 65, 'penalty': 12}, {'id': 18, 'x': 0, 'y': 60, 'prize': 30, 'penalty': 10}, {'id': 19, 'x': 4, 'y': 100, 'prize': 49, 'penalty': 21}], 'depot': 0, 'required_prize': 500.0, 'route_prize': 505.0, 'unvisited_penalty': 99.0, 'route_length': 247.44048764116854, 'objective': 346.4404876411686}","[0, 2, 3, 4, 6, 7, 9, 11, 12, 1, 5, 0]",32,markdown_table,0
PCTSP,PCTSP,"Many people on the planning team are faced with the same simple job: build one circular route from the clinic and back, choosing which neighborhoods to serve in order to reach the required service total. Plans are judged by adding the route’s travel cost to the penalties charged for any neighborhoods skipped; the plan with the lowest total is preferable. The route is a single circuit with no repeated neighborhood visits and it must start and finish at the depot. See the concrete neighborhood list, penalties, and required total below.

There are 22 locations in total, the clinic depot is node 1, and the route must collect at least 550.0 service units.

| neighborhood_id | x_coordinate | y_coordinate | services_provided_if_visited | penalty_for_not_serving |
|---|---|---|---|---|
| 1 | 57 | 94 | 0 | 0 |
| 2 | 51 | 94 | 55 | 1 |
| 3 | 47 | 92 | 38 | 19 |
| 4 | 39 | 91 | 45 | 21 |
| 5 | 4 | 72 | 65 | 7 |
| 6 | 53 | 32 | 51 | 30 |
| 7 | 59 | 31 | 55 | 7 |
| 8 | 80 | 100 | 71 | 16 |
| 9 | 77 | 100 | 37 | 17 |
| 10 | 2 | 100 | 73 | 15 |
| 11 | 2 | 99 | 69 | 25 |
| 12 | 0 | 100 | 32 | 19 |
| 13 | 78 | 0 | 64 | 15 |
| 14 | 0 | 1 | 46 | 11 |
| 15 | 3 | 1 | 36 | 26 |
| 16 | 95 | 100 | 67 | 13 |
| 17 | 92 | 100 | 17 | 2 |
| 18 | 90 | 100 | 17 | 5 |
| 19 | 19 | 100 | 31 | 22 |
| 20 | 15 | 99 | 87 | 8 |
| 21 | 100 | 99 | 22 | 16 |
| 22 | 27 | 1 | 49 | 27 |

Choose the single circuit that minimizes travel cost plus penalties while meeting the required service total.

When you’re ready to hand in a plan, just follow this little shape so it’s easy to check and use:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

This just means the ""solution"" is the ordered list of stops: start with the depot, list each neighborhood you’ll visit in order, and finish back at the depot. It’s just a sketch of the shape we expect, not your final answer.

Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[57, 94], [51, 94], [47, 92], [39, 91], [4, 72], [53, 32], [59, 31], [80, 100], [77, 100], [2, 100], [2, 99], [0, 100], [78, 0], [0, 1], [3, 1], [95, 100], [92, 100], [90, 100], [19, 100], [15, 99], [100, 99], [27, 1]], 'prizes': [0, 55, 38, 45, 65, 51, 55, 71, 37, 73, 69, 32, 64, 46, 36, 67, 17, 17, 31, 87, 22, 49], 'penalties': [0, 1, 19, 21, 7, 30, 7, 16, 17, 15, 25, 19, 15, 11, 26, 13, 2, 5, 22, 8, 16, 27], 'required_prize': 550.0, 'depot': 0, 'route_length': 202.17569973573578, 'route_prize': 661.0, 'unvisited_penalty': 123.0, 'objective': 325.17569973573575}","[0, 20, 15, 16, 17, 7, 8, 18, 19, 9, 11, 10, 3, 2, 1, 0]",325.17569973573575,"{'problem_type': 'PCTSP', 'num_nodes': 22, 'nodes': [{'id': 1, 'x': 57, 'y': 94, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 51, 'y': 94, 'prize': 55, 'penalty': 1}, {'id': 3, 'x': 47, 'y': 92, 'prize': 38, 'penalty': 19}, {'id': 4, 'x': 39, 'y': 91, 'prize': 45, 'penalty': 21}, {'id': 5, 'x': 4, 'y': 72, 'prize': 65, 'penalty': 7}, {'id': 6, 'x': 53, 'y': 32, 'prize': 51, 'penalty': 30}, {'id': 7, 'x': 59, 'y': 31, 'prize': 55, 'penalty': 7}, {'id': 8, 'x': 80, 'y': 100, 'prize': 71, 'penalty': 16}, {'id': 9, 'x': 77, 'y': 100, 'prize': 37, 'penalty': 17}, {'id': 10, 'x': 2, 'y': 100, 'prize': 73, 'penalty': 15}, {'id': 11, 'x': 2, 'y': 99, 'prize': 69, 'penalty': 25}, {'id': 12, 'x': 0, 'y': 100, 'prize': 32, 'penalty': 19}, {'id': 13, 'x': 78, 'y': 0, 'prize': 64, 'penalty': 15}, {'id': 14, 'x': 0, 'y': 1, 'prize': 46, 'penalty': 11}, {'id': 15, 'x': 3, 'y': 1, 'prize': 36, 'penalty': 26}, {'id': 16, 'x': 95, 'y': 100, 'prize': 67, 'penalty': 13}, {'id': 17, 'x': 92, 'y': 100, 'prize': 17, 'penalty': 2}, {'id': 18, 'x': 90, 'y': 100, 'prize': 17, 'penalty': 5}, {'id': 19, 'x': 19, 'y': 100, 'prize': 31, 'penalty': 22}, {'id': 20, 'x': 15, 'y': 99, 'prize': 87, 'penalty': 8}, {'id': 21, 'x': 100, 'y': 99, 'prize': 22, 'penalty': 16}, {'id': 22, 'x': 27, 'y': 1, 'prize': 49, 'penalty': 27}], 'depot': 1, 'required_prize': 550.0, 'route_prize': 661.0, 'unvisited_penalty': 123.0, 'route_length': 202.17569973573578, 'objective': 325.17569973573575}","[1, 21, 16, 17, 18, 8, 9, 19, 20, 10, 12, 11, 4, 3, 2, 1]",33,markdown_table,1
PCTSP,PCTSP,"Someone organizing errand runs on a bike has to plan one uninterrupted ride out of the depot, deciding which drop points to visit so the money earned reaches a set minimum while keeping time in the saddle and missed-stop fines as low as possible. The way to judge any plan is straightforward: add the total pedal time for the loop to the penalties charged for skipped stops — that sum is the score to keep down. The trip must start and end at the depot, be continuous, and not revisit the same stop or break into multiple trips. The detailed list of locations, their earnings and penalties is shown below.

There are 22 locations in total, the depot is 1, and the ride must secure at least 550.0 in earnings.

| stop_id | x_coordinate | y_coordinate | earnings_at_stop | missed_stop_penalty |
|---|---|---|---|---|
| 1 | 75 | 41 | 0 | 0 |
| 2 | 69 | 44 | 16 | 24 |
| 3 | 79 | 84 | 96 | 20 |
| 4 | 35 | 71 | 92 | 5 |
| 5 | 6 | 99 | 94 | 3 |
| 6 | 89 | 4 | 33 | 8 |
| 7 | 25 | 54 | 33 | 7 |
| 8 | 78 | 42 | 39 | 14 |
| 9 | 0 | 0 | 90 | 10 |
| 10 | 42 | 31 | 14 | 5 |
| 11 | 88 | 96 | 52 | 20 |
| 12 | 80 | 30 | 26 | 2 |
| 13 | 29 | 74 | 27 | 8 |
| 14 | 67 | 67 | 7 | 24 |
| 15 | 6 | 63 | 39 | 27 |
| 16 | 84 | 27 | 6 | 24 |
| 17 | 43 | 48 | 46 | 23 |
| 18 | 42 | 82 | 71 | 5 |
| 19 | 34 | 100 | 29 | 26 |
| 20 | 100 | 43 | 34 | 2 |
| 21 | 26 | 70 | 8 | 10 |
| 22 | 67 | 96 | 95 | 18 |

These lines enumerate each stop so the planner can assemble one continuous loop from 1 that meets the earnings requirement while minimizing total pedal time plus missed-stop penalties.

If you'd like to hand me a proposed route, a simple JSON list is the easiest way to do it — just one continuous array that starts and ends at the depot. Here’s the little template I expect:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of it like a form: ""solution"" is the ride, listed stop by stop in order (first and last entries are the depot). The placeholders above are just showing the shape I want, not a real route.

Please use the exact identifiers that appear in the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'coordinates': [[75, 41], [69, 44], [79, 84], [35, 71], [6, 99], [89, 4], [25, 54], [78, 42], [0, 0], [42, 31], [88, 96], [80, 30], [29, 74], [67, 67], [6, 63], [84, 27], [43, 48], [42, 82], [34, 100], [100, 43], [26, 70], [67, 96]], 'prizes': [0, 16, 96, 92, 94, 33, 33, 39, 90, 14, 52, 26, 27, 7, 39, 6, 46, 71, 29, 34, 8, 95], 'penalties': [0, 24, 20, 5, 3, 8, 7, 14, 10, 5, 20, 2, 8, 24, 27, 24, 23, 5, 26, 2, 10, 18], 'required_prize': 550.0, 'depot': 0, 'route_length': 259.1709738095219, 'route_prize': 650.0, 'unvisited_penalty': 54.0, 'objective': 313.1709738095219}","[0, 1, 16, 6, 14, 20, 12, 3, 17, 18, 21, 10, 2, 13, 7, 0]",313.1709738095219,"{'problem_type': 'PCTSP', 'num_nodes': 22, 'nodes': [{'id': 1, 'x': 75, 'y': 41, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 69, 'y': 44, 'prize': 16, 'penalty': 24}, {'id': 3, 'x': 79, 'y': 84, 'prize': 96, 'penalty': 20}, {'id': 4, 'x': 35, 'y': 71, 'prize': 92, 'penalty': 5}, {'id': 5, 'x': 6, 'y': 99, 'prize': 94, 'penalty': 3}, {'id': 6, 'x': 89, 'y': 4, 'prize': 33, 'penalty': 8}, {'id': 7, 'x': 25, 'y': 54, 'prize': 33, 'penalty': 7}, {'id': 8, 'x': 78, 'y': 42, 'prize': 39, 'penalty': 14}, {'id': 9, 'x': 0, 'y': 0, 'prize': 90, 'penalty': 10}, {'id': 10, 'x': 42, 'y': 31, 'prize': 14, 'penalty': 5}, {'id': 11, 'x': 88, 'y': 96, 'prize': 52, 'penalty': 20}, {'id': 12, 'x': 80, 'y': 30, 'prize': 26, 'penalty': 2}, {'id': 13, 'x': 29, 'y': 74, 'prize': 27, 'penalty': 8}, {'id': 14, 'x': 67, 'y': 67, 'prize': 7, 'penalty': 24}, {'id': 15, 'x': 6, 'y': 63, 'prize': 39, 'penalty': 27}, {'id': 16, 'x': 84, 'y': 27, 'prize': 6, 'penalty': 24}, {'id': 17, 'x': 43, 'y': 48, 'prize': 46, 'penalty': 23}, {'id': 18, 'x': 42, 'y': 82, 'prize': 71, 'penalty': 5}, {'id': 19, 'x': 34, 'y': 100, 'prize': 29, 'penalty': 26}, {'id': 20, 'x': 100, 'y': 43, 'prize': 34, 'penalty': 2}, {'id': 21, 'x': 26, 'y': 70, 'prize': 8, 'penalty': 10}, {'id': 22, 'x': 67, 'y': 96, 'prize': 95, 'penalty': 18}], 'depot': 1, 'required_prize': 550.0, 'route_prize': 650.0, 'unvisited_penalty': 54.0, 'route_length': 259.1709738095219, 'objective': 313.1709738095219}","[1, 2, 17, 7, 15, 21, 13, 4, 18, 19, 22, 11, 3, 14, 8, 1]",34,markdown_table,1
PCTSP,PCTSP,"Back at headquarters the dispatcher needs one single circular route: leave HQ, visit selected shelters once each, and return to HQ. The decision is which shelters to include so the team reaches the minimum total number of kits while keeping the plan as “light” as possible — light meaning low driving distance plus low expected harm from any shelters skipped. To judge any candidate route, add the route’s miles and the penalty amounts for skipped shelters; lower combined totals are better. The run must be one loop (no double-serving), it must start and end at the depot, and it must meet the required delivery total. Full details for the instance are shown below.

{
  ""total_locations_including_headquarters"": 25,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 21,
      ""kits_delivered_if_visited"": 0,
      ""expected_harm_cost_if_skipped"": 0
    },
    {
      ""location_id"": 1,
      ""map_x_coordinate"": 4,
      ""map_y_coordinate"": 84,
      ""kits_delivered_if_visited"": 84,
      ""expected_harm_cost_if_skipped"": 17
    },
    {
      ""location_id"": 2,
      ""map_x_coordinate"": 4,
      ""map_y_coordinate"": 0,
      ""kits_delivered_if_visited"": 21,
      ""expected_harm_cost_if_skipped"": 20
    },
    {
      ""location_id"": 3,
      ""map_x_coordinate"": 6,
      ""map_y_coordinate"": 5,
      ""kits_delivered_if_visited"": 4,
      ""expected_harm_cost_if_skipped"": 6
    },
    {
      ""location_id"": 4,
      ""map_x_coordinate"": 9,
      ""map_y_coordinate"": 17,
      ""kits_delivered_if_visited"": 24,
      ""expected_harm_cost_if_skipped"": 25
    },
    {
      ""location_id"": 5,
      ""map_x_coordinate"": 10,
      ""map_y_coordinate"": 38,
      ""kits_delivered_if_visited"": 54,
      ""expected_harm_cost_if_skipped"": 4
    },
    {
      ""location_id"": 6,
      ""map_x_coordinate"": 16,
      ""map_y_coordinate"": 52,
      ""kits_delivered_if_visited"": 93,
      ""expected_harm_cost_if_skipped"": 20
    },
    {
      ""location_id"": 7,
      ""map_x_coordinate"": 20,
      ""map_y_coordinate"": 30,
      ""kits_delivered_if_visited"": 78,
      ""expected_harm_cost_if_skipped"": 19
    },
    {
      ""location_id"": 8,
      ""map_x_coordinate"": 20,
      ""map_y_coordinate"": 87,
      ""kits_delivered_if_visited"": 41,
      ""expected_harm_cost_if_skipped"": 2
    },
    {
      ""location_id"": 9,
      ""map_x_coordinate"": 21,
      ""map_y_coordinate"": 95,
      ""kits_delivered_if_visited"": 89,
      ""expected_harm_cost_if_skipped"": 16
    },
    {
      ""location_id"": 10,
      ""map_x_coordinate"": 22,
      ""map_y_coordinate"": 66,
      ""kits_delivered_if_visited"": 32,
      ""expected_harm_cost_if_skipped"": 16
    },
    {
      ""location_id"": 11,
      ""map_x_coordinate"": 23,
      ""map_y_coordinate"": 100,
      ""kits_delivered_if_visited"": 40,
      ""expected_harm_cost_if_skipped"": 23
    },
    {
      ""location_id"": 12,
      ""map_x_coordinate"": 26,
      ""map_y_coordinate"": 77,
      ""kits_delivered_if_visited"": 93,
      ""expected_harm_cost_if_skipped"": 15
    },
    {
      ""location_id"": 13,
      ""map_x_coordinate"": 29,
      ""map_y_coordinate"": 52,
      ""kits_delivered_if_visited"": 5,
      ""expected_harm_cost_if_skipped"": 24
    },
    {
      ""location_id"": 14,
      ""map_x_coordinate"": 29,
      ""map_y_coordinate"": 49,
      ""kits_delivered_if_visited"": 21,
      ""expected_harm_cost_if_skipped"": 21
    },
    {
      ""location_id"": 15,
      ""map_x_coordinate"": 39,
      ""map_y_coordinate"": 83,
      ""kits_delivered_if_visited"": 88,
      ""expected_harm_cost_if_skipped"": 1
    },
    {
      ""location_id"": 16,
      ""map_x_coordinate"": 45,
      ""map_y_coordinate"": 5,
      ""kits_delivered_if_visited"": 62,
      ""expected_harm_cost_if_skipped"": 18
    },
    {
      ""location_id"": 17,
      ""map_x_coordinate"": 53,
      ""map_y_coordinate"": 7,
      ""kits_delivered_if_visited"": 39,
      ""expected_harm_cost_if_skipped"": 15
    },
    {
      ""location_id"": 18,
      ""map_x_coordinate"": 56,
      ""map_y_coordinate"": 20,
      ""kits_delivered_if_visited"": 62,
      ""expected_harm_cost_if_skipped"": 14
    },
    {
      ""location_id"": 19,
      ""map_x_coordinate"": 74,
      ""map_y_coordinate"": 11,
      ""kits_delivered_if_visited"": 23,
      ""expected_harm_cost_if_skipped"": 23
    },
    {
      ""location_id"": 20,
      ""map_x_coordinate"": 75,
      ""map_y_coordinate"": 32,
      ""kits_delivered_if_visited"": 41,
      ""expected_harm_cost_if_skipped"": 12
    },
    {
      ""location_id"": 21,
      ""map_x_coordinate"": 79,
      ""map_y_coordinate"": 68,
      ""kits_delivered_if_visited"": 14,
      ""expected_harm_cost_if_skipped"": 15
    },
    {
      ""location_id"": 22,
      ""map_x_coordinate"": 95,
      ""map_y_coordinate"": 19,
      ""kits_delivered_if_visited"": 29,
      ""expected_harm_cost_if_skipped"": 24
    },
    {
      ""location_id"": 23,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 28,
      ""kits_delivered_if_visited"": 89,
      ""expected_harm_cost_if_skipped"": 9
    },
    {
      ""location_id"": 24,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 21,
      ""kits_delivered_if_visited"": 48,
      ""expected_harm_cost_if_skipped"": 24
    }
  ],
  ""headquarters_node_id"": 0,
  ""required_total_kits"": 625.0
}

Also, when you reply with the planned route, please use this simple JSON layout so I can parse it easily:

{
  ""solution"": [hq_id, shelter_id, ..., hq_id]
}

Think of that as a little form: ""solution"" is the ordered list of location IDs for the loop — start at the depot (HQ), list every shelter you plan to visit in order (each at most once), and finish back at the depot. This is just a sketch of the shape I need, not the actual route answer.

Please be sure to use the exact identifiers given in the instance input — do not rename or invent labels. 
""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 21], [4, 84], [4, 0], [6, 5], [9, 17], [10, 38], [16, 52], [20, 30], [20, 87], [21, 95], [22, 66], [23, 100], [26, 77], [29, 52], [29, 49], [39, 83], [45, 5], [53, 7], [56, 20], [74, 11], [75, 32], [79, 68], [95, 19], [100, 28], [100, 21]], 'prizes': [0, 84, 21, 4, 24, 54, 93, 78, 41, 89, 32, 40, 93, 5, 21, 88, 62, 39, 62, 23, 41, 14, 29, 89, 48], 'penalties': [0, 17, 20, 6, 25, 4, 20, 19, 2, 16, 16, 23, 15, 24, 21, 1, 18, 15, 14, 23, 12, 15, 24, 9, 24], 'required_prize': 625.0, 'depot': 0, 'route_length': 197.33867112075532, 'route_prize': 654.0, 'unvisited_penalty': 181.0, 'objective': 378.33867112075535}","[0, 5, 6, 1, 11, 9, 8, 12, 10, 13, 14, 7, 4, 0]",378.33867112075535,"{'problem_type': 'PCTSP', 'num_nodes': 25, 'nodes': [{'id': 0, 'x': 0, 'y': 21, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 4, 'y': 84, 'prize': 84, 'penalty': 17}, {'id': 2, 'x': 4, 'y': 0, 'prize': 21, 'penalty': 20}, {'id': 3, 'x': 6, 'y': 5, 'prize': 4, 'penalty': 6}, {'id': 4, 'x': 9, 'y': 17, 'prize': 24, 'penalty': 25}, {'id': 5, 'x': 10, 'y': 38, 'prize': 54, 'penalty': 4}, {'id': 6, 'x': 16, 'y': 52, 'prize': 93, 'penalty': 20}, {'id': 7, 'x': 20, 'y': 30, 'prize': 78, 'penalty': 19}, {'id': 8, 'x': 20, 'y': 87, 'prize': 41, 'penalty': 2}, {'id': 9, 'x': 21, 'y': 95, 'prize': 89, 'penalty': 16}, {'id': 10, 'x': 22, 'y': 66, 'prize': 32, 'penalty': 16}, {'id': 11, 'x': 23, 'y': 100, 'prize': 40, 'penalty': 23}, {'id': 12, 'x': 26, 'y': 77, 'prize': 93, 'penalty': 15}, {'id': 13, 'x': 29, 'y': 52, 'prize': 5, 'penalty': 24}, {'id': 14, 'x': 29, 'y': 49, 'prize': 21, 'penalty': 21}, {'id': 15, 'x': 39, 'y': 83, 'prize': 88, 'penalty': 1}, {'id': 16, 'x': 45, 'y': 5, 'prize': 62, 'penalty': 18}, {'id': 17, 'x': 53, 'y': 7, 'prize': 39, 'penalty': 15}, {'id': 18, 'x': 56, 'y': 20, 'prize': 62, 'penalty': 14}, {'id': 19, 'x': 74, 'y': 11, 'prize': 23, 'penalty': 23}, {'id': 20, 'x': 75, 'y': 32, 'prize': 41, 'penalty': 12}, {'id': 21, 'x': 79, 'y': 68, 'prize': 14, 'penalty': 15}, {'id': 22, 'x': 95, 'y': 19, 'prize': 29, 'penalty': 24}, {'id': 23, 'x': 100, 'y': 28, 'prize': 89, 'penalty': 9}, {'id': 24, 'x': 100, 'y': 21, 'prize': 48, 'penalty': 24}], 'depot': 0, 'required_prize': 625.0, 'route_prize': 654.0, 'unvisited_penalty': 181.0, 'route_length': 197.33867112075532, 'objective': 378.33867112075535}","[0, 5, 6, 1, 11, 9, 8, 12, 10, 13, 14, 7, 4, 0]",35,json,0
PCTSP,PCTSP,"On a typical field day the goal is to head out from the office, run a single loop of interviews, and come back — picking which respondents to stop at so the cumulative survey value is at least the required target. What to prefer is clear: pick a loop that keeps driving to a minimum and keeps penalties for people not visited as small as possible — total that up by adding travel length and the penalties for skipped respondents. The route must be continuous and each person can only be counted once; the detailed locations and numbers are shown below.

There are 20 locations in total, the office (depot) is 1, and the required total survey value is 500.0.

| location_id | x_coordinate | y_coordinate | survey_value | skip_penalty |
|---|---|---|---|---|
| 1 | 0 | 18 | 0 | 0 |
| 2 | 3 | 100 | 21 | 9 |
| 3 | 14 | 54 | 78 | 8 |
| 4 | 8 | 26 | 54 | 13 |
| 5 | 16 | 1 | 51 | 21 |
| 6 | 25 | 0 | 76 | 22 |
| 7 | 50 | 52 | 17 | 8 |
| 8 | 56 | 74 | 47 | 2 |
| 9 | 70 | 31 | 29 | 27 |
| 10 | 67 | 42 | 84 | 17 |
| 11 | 69 | 47 | 20 | 4 |
| 12 | 71 | 40 | 0 | 13 |
| 13 | 92 | 72 | 63 | 1 |
| 14 | 93 | 67 | 10 | 11 |
| 15 | 91 | 56 | 19 | 12 |
| 16 | 100 | 42 | 50 | 8 |
| 17 | 91 | 82 | 36 | 15 |
| 18 | 35 | 55 | 60 | 4 |
| 19 | 24 | 23 | 78 | 1 |
| 20 | 14 | 32 | 98 | 28 |

Use these locations to pick a single continuous loop that minimizes travel plus skipped penalties while reaching at least 500.0 survey value.

If you want to hand me a proposed route, just pop it into this little JSON envelope and send it back — something simple like this works great:

{
  ""solution"": [office_id, respondent_id, ..., office_id]
}

Think of that as a form: ""solution"" is the ordered loop — the first entry is where you start (the office), then the respondents you plan to visit in order, and the last entry is the office again to close the loop. This is just a sketch of the shape I need, not the actual answer.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 18], [3, 100], [14, 54], [8, 26], [16, 1], [25, 0], [50, 52], [56, 74], [70, 31], [67, 42], [69, 47], [71, 40], [92, 72], [93, 67], [91, 56], [100, 42], [91, 82], [35, 55], [24, 23], [14, 32]], 'prizes': [0, 21, 78, 54, 51, 76, 17, 47, 29, 84, 20, 0, 63, 10, 19, 50, 36, 60, 78, 98], 'penalties': [0, 9, 8, 13, 21, 22, 8, 2, 27, 17, 4, 13, 1, 11, 12, 8, 15, 4, 1, 28], 'required_prize': 500.0, 'depot': 0, 'route_length': 198.41537303933526, 'route_prize': 547.0, 'unvisited_penalty': 63.0, 'objective': 261.41537303933524}","[0, 3, 19, 2, 17, 6, 9, 11, 8, 5, 4, 0]",261.41537303933524,"{'problem_type': 'PCTSP', 'num_nodes': 20, 'nodes': [{'id': 1, 'x': 0, 'y': 18, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 3, 'y': 100, 'prize': 21, 'penalty': 9}, {'id': 3, 'x': 14, 'y': 54, 'prize': 78, 'penalty': 8}, {'id': 4, 'x': 8, 'y': 26, 'prize': 54, 'penalty': 13}, {'id': 5, 'x': 16, 'y': 1, 'prize': 51, 'penalty': 21}, {'id': 6, 'x': 25, 'y': 0, 'prize': 76, 'penalty': 22}, {'id': 7, 'x': 50, 'y': 52, 'prize': 17, 'penalty': 8}, {'id': 8, 'x': 56, 'y': 74, 'prize': 47, 'penalty': 2}, {'id': 9, 'x': 70, 'y': 31, 'prize': 29, 'penalty': 27}, {'id': 10, 'x': 67, 'y': 42, 'prize': 84, 'penalty': 17}, {'id': 11, 'x': 69, 'y': 47, 'prize': 20, 'penalty': 4}, {'id': 12, 'x': 71, 'y': 40, 'prize': 0, 'penalty': 13}, {'id': 13, 'x': 92, 'y': 72, 'prize': 63, 'penalty': 1}, {'id': 14, 'x': 93, 'y': 67, 'prize': 10, 'penalty': 11}, {'id': 15, 'x': 91, 'y': 56, 'prize': 19, 'penalty': 12}, {'id': 16, 'x': 100, 'y': 42, 'prize': 50, 'penalty': 8}, {'id': 17, 'x': 91, 'y': 82, 'prize': 36, 'penalty': 15}, {'id': 18, 'x': 35, 'y': 55, 'prize': 60, 'penalty': 4}, {'id': 19, 'x': 24, 'y': 23, 'prize': 78, 'penalty': 1}, {'id': 20, 'x': 14, 'y': 32, 'prize': 98, 'penalty': 28}], 'depot': 1, 'required_prize': 500.0, 'route_prize': 547.0, 'unvisited_penalty': 63.0, 'route_length': 198.41537303933526, 'objective': 261.41537303933524}","[1, 4, 20, 3, 18, 7, 10, 12, 9, 6, 5, 1]",36,markdown_table,1
PCTSP,PCTSP,"Someone on the decorating crew is mapping out a holiday route: leave the storage yard, visit a selection of stores to put up displays, then return to the yard. The choice is which stops to make and how to string them together so the total display impact from visited stores reaches the required minimum. A smarter route is one that has less driving and fewer penalties for skipped stores — calculate its value by summing the total miles driven plus the skip-fees for any stores not visited. It’s got to be a single circuit and a store can’t be visited twice. All the specific store data and required totals are below.

{
  ""total_locations_including_yard"": 17,
  ""nodes"": [
    {
      ""store_node_id"": ""A"",
      ""store_x_coordinate"": 8,
      ""store_y_coordinate"": 39,
      ""display_impact_points"": 0,
      ""store_skip_fee"": 0
    },
    {
      ""store_node_id"": ""B"",
      ""store_x_coordinate"": 42,
      ""store_y_coordinate"": 51,
      ""display_impact_points"": 82,
      ""store_skip_fee"": 22
    },
    {
      ""store_node_id"": ""C"",
      ""store_x_coordinate"": 33,
      ""store_y_coordinate"": 47,
      ""display_impact_points"": 51,
      ""store_skip_fee"": 15
    },
    {
      ""store_node_id"": ""D"",
      ""store_x_coordinate"": 36,
      ""store_y_coordinate"": 48,
      ""display_impact_points"": 57,
      ""store_skip_fee"": 24
    },
    {
      ""store_node_id"": ""E"",
      ""store_x_coordinate"": 100,
      ""store_y_coordinate"": 44,
      ""display_impact_points"": 10,
      ""store_skip_fee"": 28
    },
    {
      ""store_node_id"": ""F"",
      ""store_x_coordinate"": 88,
      ""store_y_coordinate"": 0,
      ""display_impact_points"": 55,
      ""store_skip_fee"": 27
    },
    {
      ""store_node_id"": ""G"",
      ""store_x_coordinate"": 3,
      ""store_y_coordinate"": 70,
      ""display_impact_points"": 65,
      ""store_skip_fee"": 33
    },
    {
      ""store_node_id"": ""H"",
      ""store_x_coordinate"": 4,
      ""store_y_coordinate"": 40,
      ""display_impact_points"": 88,
      ""store_skip_fee"": 1
    },
    {
      ""store_node_id"": ""I"",
      ""store_x_coordinate"": 69,
      ""store_y_coordinate"": 21,
      ""display_impact_points"": 42,
      ""store_skip_fee"": 7
    },
    {
      ""store_node_id"": ""J"",
      ""store_x_coordinate"": 60,
      ""store_y_coordinate"": 100,
      ""display_impact_points"": 29,
      ""store_skip_fee"": 25
    },
    {
      ""store_node_id"": ""K"",
      ""store_x_coordinate"": 20,
      ""store_y_coordinate"": 40,
      ""display_impact_points"": 24,
      ""store_skip_fee"": 2
    },
    {
      ""store_node_id"": ""L"",
      ""store_x_coordinate"": 19,
      ""store_y_coordinate"": 43,
      ""display_impact_points"": 84,
      ""store_skip_fee"": 15
    },
    {
      ""store_node_id"": ""M"",
      ""store_x_coordinate"": 26,
      ""store_y_coordinate"": 43,
      ""display_impact_points"": 71,
      ""store_skip_fee"": 21
    },
    {
      ""store_node_id"": ""N"",
      ""store_x_coordinate"": 0,
      ""store_y_coordinate"": 79,
      ""display_impact_points"": 93,
      ""store_skip_fee"": 33
    },
    {
      ""store_node_id"": ""O"",
      ""store_x_coordinate"": 31,
      ""store_y_coordinate"": 43,
      ""display_impact_points"": 44,
      ""store_skip_fee"": 30
    },
    {
      ""store_node_id"": ""P"",
      ""store_x_coordinate"": 12,
      ""store_y_coordinate"": 44,
      ""display_impact_points"": 58,
      ""store_skip_fee"": 22
    },
    {
      ""store_node_id"": ""Q"",
      ""store_x_coordinate"": 11,
      ""store_y_coordinate"": 17,
      ""display_impact_points"": 19,
      ""store_skip_fee"": 23
    }
  ],
  ""storage_yard_node_id"": ""A"",
  ""required_display_impact"": 425.0
}

Also, when you send back the route, please use this simple JSON layout so it's easy to parse:

{
  ""solution"": [storage_yard_id, store_id, ..., storage_yard_id]
}

This just means: put the full circuit in the solution array — start with the storage yard (depot), list the stores you plan to visit in order, and end back at the storage yard. It’s just a sketch of the shape I expect, not the actual answer.

- For example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".

Please use the exact identifiers from the instance input — no renaming and no new labels.","{'coordinates': [[8, 39], [42, 51], [33, 47], [36, 48], [100, 44], [88, 0], [3, 70], [4, 40], [69, 21], [60, 100], [20, 40], [19, 43], [26, 43], [0, 79], [31, 43], [12, 44], [11, 17]], 'prizes': [0, 82, 51, 57, 10, 55, 65, 88, 42, 29, 24, 84, 71, 93, 44, 58, 19], 'penalties': [0, 22, 15, 24, 28, 27, 33, 1, 7, 25, 2, 15, 21, 33, 30, 22, 23], 'required_prize': 425.0, 'depot': 0, 'route_length': 131.18199737018182, 'route_prize': 605.0, 'unvisited_penalty': 113.0, 'objective': 244.1819973701818}","[0, 15, 11, 12, 14, 2, 3, 1, 13, 6, 0]",244.1819973701818,"{'problem_type': 'PCTSP', 'num_nodes': 17, 'nodes': [{'id': 'A', 'x': 8, 'y': 39, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 42, 'y': 51, 'prize': 82, 'penalty': 22}, {'id': 'C', 'x': 33, 'y': 47, 'prize': 51, 'penalty': 15}, {'id': 'D', 'x': 36, 'y': 48, 'prize': 57, 'penalty': 24}, {'id': 'E', 'x': 100, 'y': 44, 'prize': 10, 'penalty': 28}, {'id': 'F', 'x': 88, 'y': 0, 'prize': 55, 'penalty': 27}, {'id': 'G', 'x': 3, 'y': 70, 'prize': 65, 'penalty': 33}, {'id': 'H', 'x': 4, 'y': 40, 'prize': 88, 'penalty': 1}, {'id': 'I', 'x': 69, 'y': 21, 'prize': 42, 'penalty': 7}, {'id': 'J', 'x': 60, 'y': 100, 'prize': 29, 'penalty': 25}, {'id': 'K', 'x': 20, 'y': 40, 'prize': 24, 'penalty': 2}, {'id': 'L', 'x': 19, 'y': 43, 'prize': 84, 'penalty': 15}, {'id': 'M', 'x': 26, 'y': 43, 'prize': 71, 'penalty': 21}, {'id': 'N', 'x': 0, 'y': 79, 'prize': 93, 'penalty': 33}, {'id': 'O', 'x': 31, 'y': 43, 'prize': 44, 'penalty': 30}, {'id': 'P', 'x': 12, 'y': 44, 'prize': 58, 'penalty': 22}, {'id': 'Q', 'x': 11, 'y': 17, 'prize': 19, 'penalty': 23}], 'depot': 'A', 'required_prize': 425.0, 'route_prize': 605.0, 'unvisited_penalty': 113.0, 'route_length': 131.18199737018182, 'objective': 244.1819973701818}","['A', 'P', 'L', 'M', 'O', 'C', 'D', 'B', 'N', 'G', 'A']",37,json,names
PCTSP,PCTSP,"Recently the team had to plan one circular route out of the office to hit enough accounts to satisfy the campaign goal. It comes down to choosing which accounts to visit: each visit adds expected income, each skipped account has a penalty, and driving the route costs money. To compare plans, just total the driving cost and all penalties for skipped accounts — among the routes that reach the revenue threshold, pick the one with the lowest combined total. The trip must be a single loop from the office back to the office and only visit selected clients once. Concrete numbers and locations appear below.

There are 17 locations including the office 1, and the campaign must collect at least 425.0 in expected revenue.
Location 1 at (0, 75) gives expected revenue 0 and will incur penalty 0 if skipped.
Location 2 at (33, 4) gives expected revenue 13 and will incur penalty 18 if skipped.
Location 3 at (33, 21) gives expected revenue 60 and will incur penalty 31 if skipped.
Location 4 at (33, 38) gives expected revenue 11 and will incur penalty 10 if skipped.
Location 5 at (67, 83) gives expected revenue 54 and will incur penalty 27 if skipped.
Location 6 at (100, 33) gives expected revenue 6 and will incur penalty 13 if skipped.
Location 7 at (100, 46) gives expected revenue 63 and will incur penalty 28 if skipped.
Location 8 at (11, 25) gives expected revenue 88 and will incur penalty 33 if skipped.
Location 9 at (17, 25) gives expected revenue 65 and will incur penalty 11 if skipped.
Location 10 at (22, 100) gives expected revenue 75 and will incur penalty 19 if skipped.
Location 11 at (28, 100) gives expected revenue 54 and will incur penalty 17 if skipped.
Location 12 at (39, 0) gives expected revenue 39 and will incur penalty 4 if skipped.
Location 13 at (61, 0) gives expected revenue 46 and will incur penalty 0 if skipped.
Location 14 at (61, 25) gives expected revenue 48 and will incur penalty 3 if skipped.
Location 15 at (61, 50) gives expected revenue 11 and will incur penalty 26 if skipped.
Location 16 at (39, 100) gives expected revenue 26 and will incur penalty 2 if skipped.
Location 17 at (72, 100) gives expected revenue 56 and will incur penalty 6 if skipped.
These figures let the team compare single-loop routes that start and finish at 1 and meet the 425.0 threshold.

Also, when you send the chosen route back, please use this little JSON shape so it's easy to read and check:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Here that array is just the loop: start with the office/depot identifier, list each client you plan to visit once in order, and finish back at the office. Think of it like filling out a short form — not the final answer format, just the shape I need.

Please be sure to use the exact identifiers from the instance input — don't rename anything or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 75], [33, 4], [33, 21], [33, 38], [67, 83], [100, 33], [100, 46], [11, 25], [17, 25], [22, 100], [28, 100], [39, 0], [61, 0], [61, 25], [61, 50], [39, 100], [72, 100]], 'prizes': [0, 13, 60, 11, 54, 6, 63, 88, 65, 75, 54, 39, 46, 48, 11, 26, 56], 'penalties': [0, 18, 31, 10, 27, 13, 28, 33, 11, 19, 17, 4, 0, 3, 26, 2, 6], 'required_prize': 425.0, 'depot': 0, 'route_length': 237.75056785211575, 'route_prize': 444.0, 'unvisited_penalty': 72.0, 'objective': 309.75056785211575}","[0, 9, 10, 15, 4, 14, 3, 2, 8, 7, 0]",309.75056785211575,"{'problem_type': 'PCTSP', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 0, 'y': 75, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 33, 'y': 4, 'prize': 13, 'penalty': 18}, {'id': 3, 'x': 33, 'y': 21, 'prize': 60, 'penalty': 31}, {'id': 4, 'x': 33, 'y': 38, 'prize': 11, 'penalty': 10}, {'id': 5, 'x': 67, 'y': 83, 'prize': 54, 'penalty': 27}, {'id': 6, 'x': 100, 'y': 33, 'prize': 6, 'penalty': 13}, {'id': 7, 'x': 100, 'y': 46, 'prize': 63, 'penalty': 28}, {'id': 8, 'x': 11, 'y': 25, 'prize': 88, 'penalty': 33}, {'id': 9, 'x': 17, 'y': 25, 'prize': 65, 'penalty': 11}, {'id': 10, 'x': 22, 'y': 100, 'prize': 75, 'penalty': 19}, {'id': 11, 'x': 28, 'y': 100, 'prize': 54, 'penalty': 17}, {'id': 12, 'x': 39, 'y': 0, 'prize': 39, 'penalty': 4}, {'id': 13, 'x': 61, 'y': 0, 'prize': 46, 'penalty': 0}, {'id': 14, 'x': 61, 'y': 25, 'prize': 48, 'penalty': 3}, {'id': 15, 'x': 61, 'y': 50, 'prize': 11, 'penalty': 26}, {'id': 16, 'x': 39, 'y': 100, 'prize': 26, 'penalty': 2}, {'id': 17, 'x': 72, 'y': 100, 'prize': 56, 'penalty': 6}], 'depot': 1, 'required_prize': 425.0, 'route_prize': 444.0, 'unvisited_penalty': 72.0, 'route_length': 237.75056785211575, 'objective': 309.75056785211575}","[1, 10, 11, 16, 5, 15, 4, 3, 9, 8, 1]",38,nl,1
PCTSP,PCTSP,"On a typical route-planning morning the dispatcher needs one circuit from the garage that visits a selection of machines, accumulates at least the required repair value, and brings the van home. The way to pick between different circuits is practical: total driving time for the chosen loop plus the penalties for machines skipped — compute the total by summing drive time and skipped-machine penalties, and choose the plan with the smallest sum. Each machine can only be visited as part of that single loop (no duplicates), skipped machines count their penalty, and the visited ones must together reach the required repair total. Concrete instance details are listed below.

{
  ""total_locations_including_garage"": 16,
  ""nodes"": [
    {
      ""machine_node_id"": ""A"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 12,
      ""repair_value"": 0,
      ""skip_penalty"": 0
    },
    {
      ""machine_node_id"": ""B"",
      ""x_coordinate"": 16,
      ""y_coordinate"": 38,
      ""repair_value"": 20,
      ""skip_penalty"": 29
    },
    {
      ""machine_node_id"": ""C"",
      ""x_coordinate"": 7,
      ""y_coordinate"": 39,
      ""repair_value"": 96,
      ""skip_penalty"": 26
    },
    {
      ""machine_node_id"": ""D"",
      ""x_coordinate"": 16,
      ""y_coordinate"": 40,
      ""repair_value"": 49,
      ""skip_penalty"": 25
    },
    {
      ""machine_node_id"": ""E"",
      ""x_coordinate"": 19,
      ""y_coordinate"": 45,
      ""repair_value"": 42,
      ""skip_penalty"": 13
    },
    {
      ""machine_node_id"": ""F"",
      ""x_coordinate"": 16,
      ""y_coordinate"": 48,
      ""repair_value"": 23,
      ""skip_penalty"": 16
    },
    {
      ""machine_node_id"": ""G"",
      ""x_coordinate"": 27,
      ""y_coordinate"": 56,
      ""repair_value"": 54,
      ""skip_penalty"": 17
    },
    {
      ""machine_node_id"": ""H"",
      ""x_coordinate"": 23,
      ""y_coordinate"": 66,
      ""repair_value"": 70,
      ""skip_penalty"": 7
    },
    {
      ""machine_node_id"": ""I"",
      ""x_coordinate"": 34,
      ""y_coordinate"": 84,
      ""repair_value"": 2,
      ""skip_penalty"": 21
    },
    {
      ""machine_node_id"": ""J"",
      ""x_coordinate"": 29,
      ""y_coordinate"": 86,
      ""repair_value"": 57,
      ""skip_penalty"": 6
    },
    {
      ""machine_node_id"": ""K"",
      ""x_coordinate"": 33,
      ""y_coordinate"": 87,
      ""repair_value"": 83,
      ""skip_penalty"": 22
    },
    {
      ""machine_node_id"": ""L"",
      ""x_coordinate"": 34,
      ""y_coordinate"": 97,
      ""repair_value"": 13,
      ""skip_penalty"": 36
    },
    {
      ""machine_node_id"": ""M"",
      ""x_coordinate"": 31,
      ""y_coordinate"": 100,
      ""repair_value"": 63,
      ""skip_penalty"": 3
    },
    {
      ""machine_node_id"": ""N"",
      ""x_coordinate"": 43,
      ""y_coordinate"": 100,
      ""repair_value"": 63,
      ""skip_penalty"": 15
    },
    {
      ""machine_node_id"": ""O"",
      ""x_coordinate"": 97,
      ""y_coordinate"": 8,
      ""repair_value"": 17,
      ""skip_penalty"": 12
    },
    {
      ""machine_node_id"": ""P"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 0,
      ""repair_value"": 30,
      ""skip_penalty"": 20
    }
  ],
  ""garage_node_id"": ""A"",
  ""required_repair_value"": 400.0
}

Also, when you send the plan back, just use a small JSON object with the tour in order — nothing fancy. For example:

{
  ""solution"": [garage_id, machine_id, ..., garage_id]
}

This little snippet just shows the shape I want: ""solution"" is the circuit, starting and ending at the garage (garage_id), with the machines you visit listed in order (machine_id) in between. Think of it like filling out a form — the array is the sequence of stops. It's only a sketch of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 12], [16, 38], [7, 39], [16, 40], [19, 45], [16, 48], [27, 56], [23, 66], [34, 84], [29, 86], [33, 87], [34, 97], [31, 100], [43, 100], [97, 8], [100, 0]], 'prizes': [0, 20, 96, 49, 42, 23, 54, 70, 2, 57, 83, 13, 63, 63, 17, 30], 'penalties': [0, 29, 26, 25, 13, 16, 17, 7, 21, 6, 22, 36, 3, 15, 12, 20], 'required_prize': 400.0, 'depot': 0, 'route_length': 186.93243043970534, 'route_prize': 509.0, 'unvisited_penalty': 50.0, 'objective': 236.93243043970534}","[0, 1, 3, 4, 6, 8, 10, 11, 9, 7, 5, 2, 0]",236.93243043970534,"{'problem_type': 'PCTSP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 0, 'y': 12, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 16, 'y': 38, 'prize': 20, 'penalty': 29}, {'id': 'C', 'x': 7, 'y': 39, 'prize': 96, 'penalty': 26}, {'id': 'D', 'x': 16, 'y': 40, 'prize': 49, 'penalty': 25}, {'id': 'E', 'x': 19, 'y': 45, 'prize': 42, 'penalty': 13}, {'id': 'F', 'x': 16, 'y': 48, 'prize': 23, 'penalty': 16}, {'id': 'G', 'x': 27, 'y': 56, 'prize': 54, 'penalty': 17}, {'id': 'H', 'x': 23, 'y': 66, 'prize': 70, 'penalty': 7}, {'id': 'I', 'x': 34, 'y': 84, 'prize': 2, 'penalty': 21}, {'id': 'J', 'x': 29, 'y': 86, 'prize': 57, 'penalty': 6}, {'id': 'K', 'x': 33, 'y': 87, 'prize': 83, 'penalty': 22}, {'id': 'L', 'x': 34, 'y': 97, 'prize': 13, 'penalty': 36}, {'id': 'M', 'x': 31, 'y': 100, 'prize': 63, 'penalty': 3}, {'id': 'N', 'x': 43, 'y': 100, 'prize': 63, 'penalty': 15}, {'id': 'O', 'x': 97, 'y': 8, 'prize': 17, 'penalty': 12}, {'id': 'P', 'x': 100, 'y': 0, 'prize': 30, 'penalty': 20}], 'depot': 'A', 'required_prize': 400.0, 'route_prize': 509.0, 'unvisited_penalty': 50.0, 'route_length': 186.93243043970534, 'objective': 236.93243043970534}","['A', 'B', 'D', 'E', 'G', 'I', 'K', 'L', 'J', 'H', 'F', 'C', 'A']",39,json,names
PCTSP,PCTSP,"We’re putting together a single guided loop that starts and finishes at the ticket desk and stops at a handful of exhibits along the way. The decision is which exhibits to include so the collected interest points meet the museum’s minimum target. A “better” loop is simply one with a smaller final number, which is calculated by taking the total walking distance of the loop and adding the penalty values for exhibits not visited. The route should be one continuous circuit without repeating exhibits, must return to the ticket desk, and must reach the required interest total. Concrete details are shown below.

We have 23 distinct locations (the ticket desk is node 1) and must collect at least 575.0 interest points.
For exhibit 1 at (4, 44), we gain 0 interest points if we visit it; skipping it adds a penalty of 0.
For exhibit 2 at (57, 67), we gain 52 interest points if we visit it; skipping it adds a penalty of 12.
For exhibit 3 at (57, 59), we gain 50 interest points if we visit it; skipping it adds a penalty of 11.
For exhibit 4 at (71, 92), we gain 83 interest points if we visit it; skipping it adds a penalty of 15.
For exhibit 5 at (78, 69), we gain 88 interest points if we visit it; skipping it adds a penalty of 8.
For exhibit 6 at (94, 90), we gain 22 interest points if we visit it; skipping it adds a penalty of 18.
For exhibit 7 at (94, 67), we gain 75 interest points if we visit it; skipping it adds a penalty of 13.
For exhibit 8 at (100, 59), we gain 48 interest points if we visit it; skipping it adds a penalty of 25.
For exhibit 9 at (94, 38), we gain 19 interest points if we visit it; skipping it adds a penalty of 18.
For exhibit 10 at (94, 8), we gain 10 interest points if we visit it; skipping it adds a penalty of 21.
For exhibit 11 at (57, 31), we gain 36 interest points if we visit it; skipping it adds a penalty of 12.
For exhibit 12 at (25, 0), we gain 7 interest points if we visit it; skipping it adds a penalty of 29.
For exhibit 13 at (20, 5), we gain 64 interest points if we visit it; skipping it adds a penalty of 26.
For exhibit 14 at (22, 36), we gain 21 interest points if we visit it; skipping it adds a penalty of 25.
For exhibit 15 at (18, 41), we gain 60 interest points if we visit it; skipping it adds a penalty of 10.
For exhibit 16 at (14, 33), we gain 30 interest points if we visit it; skipping it adds a penalty of 26.
For exhibit 17 at (12, 23), we gain 22 interest points if we visit it; skipping it adds a penalty of 20.
For exhibit 18 at (14, 23), we gain 62 interest points if we visit it; skipping it adds a penalty of 9.
For exhibit 19 at (12, 5), we gain 24 interest points if we visit it; skipping it adds a penalty of 8.
For exhibit 20 at (0, 3), we gain 90 interest points if we visit it; skipping it adds a penalty of 2.
For exhibit 21 at (0, 82), we gain 24 interest points if we visit it; skipping it adds a penalty of 23.
For exhibit 22 at (12, 100), we gain 6 interest points if we visit it; skipping it adds a penalty of 20.
For exhibit 23 at (12, 85), we gain 23 interest points if we visit it; skipping it adds a penalty of 25.
We will form a single circuit starting and ending at node 1 that reaches the 575.0 target while minimizing walking distance plus skip penalties.

Also, when you send back the chosen loop, please stick to this simple JSON layout:

{
  ""solution"": [ticketdesk_id, exhibit_id, ..., ticketdesk_id]
}

Think of that as a quick form: the solution array is the loop you’ll take — start at the ticket desk, list the exhibits you visit in order, and finish back at the ticket desk. The placeholders (ticketdesk_id, exhibit_id) are just there to show the shape — don’t fill them in literally in the sketch above; they’re a template, not the final answer.

Please use the exact identifiers from the instance input when you give the real route — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[4, 44], [57, 67], [57, 59], [71, 92], [78, 69], [94, 90], [94, 67], [100, 59], [94, 38], [94, 8], [57, 31], [25, 0], [20, 5], [22, 36], [18, 41], [14, 33], [12, 23], [14, 23], [12, 5], [0, 3], [0, 82], [12, 100], [12, 85]], 'prizes': [0, 52, 50, 83, 88, 22, 75, 48, 19, 10, 36, 7, 64, 21, 60, 30, 22, 62, 24, 90, 24, 6, 23], 'penalties': [0, 12, 11, 15, 8, 18, 13, 25, 18, 21, 12, 29, 26, 25, 10, 26, 20, 9, 8, 2, 23, 20, 25], 'required_prize': 575.0, 'depot': 0, 'route_length': 281.8084129042211, 'route_prize': 658.0, 'unvisited_penalty': 124.0, 'objective': 405.8084129042211}","[0, 15, 17, 16, 18, 12, 11, 10, 8, 7, 6, 4, 1, 2, 13, 14, 0]",405.8084129042211,"{'problem_type': 'PCTSP', 'num_nodes': 23, 'nodes': [{'id': 1, 'x': 4, 'y': 44, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 57, 'y': 67, 'prize': 52, 'penalty': 12}, {'id': 3, 'x': 57, 'y': 59, 'prize': 50, 'penalty': 11}, {'id': 4, 'x': 71, 'y': 92, 'prize': 83, 'penalty': 15}, {'id': 5, 'x': 78, 'y': 69, 'prize': 88, 'penalty': 8}, {'id': 6, 'x': 94, 'y': 90, 'prize': 22, 'penalty': 18}, {'id': 7, 'x': 94, 'y': 67, 'prize': 75, 'penalty': 13}, {'id': 8, 'x': 100, 'y': 59, 'prize': 48, 'penalty': 25}, {'id': 9, 'x': 94, 'y': 38, 'prize': 19, 'penalty': 18}, {'id': 10, 'x': 94, 'y': 8, 'prize': 10, 'penalty': 21}, {'id': 11, 'x': 57, 'y': 31, 'prize': 36, 'penalty': 12}, {'id': 12, 'x': 25, 'y': 0, 'prize': 7, 'penalty': 29}, {'id': 13, 'x': 20, 'y': 5, 'prize': 64, 'penalty': 26}, {'id': 14, 'x': 22, 'y': 36, 'prize': 21, 'penalty': 25}, {'id': 15, 'x': 18, 'y': 41, 'prize': 60, 'penalty': 10}, {'id': 16, 'x': 14, 'y': 33, 'prize': 30, 'penalty': 26}, {'id': 17, 'x': 12, 'y': 23, 'prize': 22, 'penalty': 20}, {'id': 18, 'x': 14, 'y': 23, 'prize': 62, 'penalty': 9}, {'id': 19, 'x': 12, 'y': 5, 'prize': 24, 'penalty': 8}, {'id': 20, 'x': 0, 'y': 3, 'prize': 90, 'penalty': 2}, {'id': 21, 'x': 0, 'y': 82, 'prize': 24, 'penalty': 23}, {'id': 22, 'x': 12, 'y': 100, 'prize': 6, 'penalty': 20}, {'id': 23, 'x': 12, 'y': 85, 'prize': 23, 'penalty': 25}], 'depot': 1, 'required_prize': 575.0, 'route_prize': 658.0, 'unvisited_penalty': 124.0, 'route_length': 281.8084129042211, 'objective': 405.8084129042211}","[1, 16, 18, 17, 19, 13, 12, 11, 9, 8, 7, 5, 2, 3, 14, 15, 1]",40,nl,1
PCTSP,PCTSP,"Back at the hub the task is to build a single delivery tour that starts and finishes at the same place and visits a selection of subscribers whose payments add up to at least the required sum. The practical yardstick is simple — take the miles of the chosen tour and add the penalties for everyone who wasn’t visited; the smaller that sum, the better the choice. The tour is one continuous loop with no repeat visits, and the exact locations, subscription amounts and penalties are listed below.

There are 23 locations including the hub A; the tour must start and finish at A and collect at least 575.0 in subscriptions.
Location A at (2, 0) — subscription 0, missed-delivery penalty 0.
Location B at (7, 3) — subscription 18, missed-delivery penalty 21.
Location C at (5, 3) — subscription 80, missed-delivery penalty 12.
Location D at (2, 25) — subscription 20, missed-delivery penalty 8.
Location E at (0, 42) — subscription 5, missed-delivery penalty 3.
Location F at (7, 42) — subscription 77, missed-delivery penalty 1.
Location G at (2, 52) — subscription 5, missed-delivery penalty 27.
Location H at (7, 55) — subscription 57, missed-delivery penalty 26.
Location I at (5, 55) — subscription 98, missed-delivery penalty 9.
Location J at (0, 86) — subscription 19, missed-delivery penalty 13.
Location K at (7, 86) — subscription 47, missed-delivery penalty 1.
Location L at (2, 97) — subscription 53, missed-delivery penalty 9.
Location M at (5, 100) — subscription 6, missed-delivery penalty 13.
Location N at (93, 86) — subscription 25, missed-delivery penalty 19.
Location O at (98, 3) — subscription 87, missed-delivery penalty 13.
Location P at (100, 15) — subscription 93, missed-delivery penalty 20.
Location Q at (98, 42) — subscription 3, missed-delivery penalty 2.
Location R at (95, 52) — subscription 71, missed-delivery penalty 27.
Location S at (100, 52) — subscription 88, missed-delivery penalty 28.
Location T at (100, 55) — subscription 37, missed-delivery penalty 14.
Location U at (98, 71) — subscription 68, missed-delivery penalty 17.
Location V at (100, 86) — subscription 54, missed-delivery penalty 22.
Location W at (100, 100) — subscription 78, missed-delivery penalty 19.
Choose a single continuous loop (no repeat visits) starting and ending at A that minimizes tour miles plus penalties for unvisited subscribers.

Oh — and one more thing: when you send the route back, please stick to this simple JSON layout so it's easy to read and check:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

This ""solution"" array should list the hub where you start, then each subscriber you plan to visit in the order you’ll visit them, and finally the hub again to close the loop. Think of it as the form to fill out — a quick sketch of the tour, not the full write-up.

Please use the exact identifiers from the instance input — no renaming and no new labels. 
- For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[2, 0], [7, 3], [5, 3], [2, 25], [0, 42], [7, 42], [2, 52], [7, 55], [5, 55], [0, 86], [7, 86], [2, 97], [5, 100], [93, 86], [98, 3], [100, 15], [98, 42], [95, 52], [100, 52], [100, 55], [98, 71], [100, 86], [100, 100]], 'prizes': [0, 18, 80, 20, 5, 77, 5, 57, 98, 19, 47, 53, 6, 25, 87, 93, 3, 71, 88, 37, 68, 54, 78], 'penalties': [0, 21, 12, 8, 3, 1, 27, 26, 9, 13, 1, 9, 13, 19, 13, 20, 2, 27, 28, 14, 17, 22, 19], 'required_prize': 575.0, 'depot': 0, 'route_length': 303.1968440593131, 'route_prize': 626.0, 'unvisited_penalty': 91.0, 'objective': 394.1968440593131}","[0, 2, 1, 17, 18, 19, 20, 21, 13, 7, 8, 6, 4, 3, 0]",394.1968440593131,"{'problem_type': 'PCTSP', 'num_nodes': 23, 'nodes': [{'id': 'A', 'x': 2, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 7, 'y': 3, 'prize': 18, 'penalty': 21}, {'id': 'C', 'x': 5, 'y': 3, 'prize': 80, 'penalty': 12}, {'id': 'D', 'x': 2, 'y': 25, 'prize': 20, 'penalty': 8}, {'id': 'E', 'x': 0, 'y': 42, 'prize': 5, 'penalty': 3}, {'id': 'F', 'x': 7, 'y': 42, 'prize': 77, 'penalty': 1}, {'id': 'G', 'x': 2, 'y': 52, 'prize': 5, 'penalty': 27}, {'id': 'H', 'x': 7, 'y': 55, 'prize': 57, 'penalty': 26}, {'id': 'I', 'x': 5, 'y': 55, 'prize': 98, 'penalty': 9}, {'id': 'J', 'x': 0, 'y': 86, 'prize': 19, 'penalty': 13}, {'id': 'K', 'x': 7, 'y': 86, 'prize': 47, 'penalty': 1}, {'id': 'L', 'x': 2, 'y': 97, 'prize': 53, 'penalty': 9}, {'id': 'M', 'x': 5, 'y': 100, 'prize': 6, 'penalty': 13}, {'id': 'N', 'x': 93, 'y': 86, 'prize': 25, 'penalty': 19}, {'id': 'O', 'x': 98, 'y': 3, 'prize': 87, 'penalty': 13}, {'id': 'P', 'x': 100, 'y': 15, 'prize': 93, 'penalty': 20}, {'id': 'Q', 'x': 98, 'y': 42, 'prize': 3, 'penalty': 2}, {'id': 'R', 'x': 95, 'y': 52, 'prize': 71, 'penalty': 27}, {'id': 'S', 'x': 100, 'y': 52, 'prize': 88, 'penalty': 28}, {'id': 'T', 'x': 100, 'y': 55, 'prize': 37, 'penalty': 14}, {'id': 'U', 'x': 98, 'y': 71, 'prize': 68, 'penalty': 17}, {'id': 'V', 'x': 100, 'y': 86, 'prize': 54, 'penalty': 22}, {'id': 'W', 'x': 100, 'y': 100, 'prize': 78, 'penalty': 19}], 'depot': 'A', 'required_prize': 575.0, 'route_prize': 626.0, 'unvisited_penalty': 91.0, 'route_length': 303.1968440593131, 'objective': 394.1968440593131}","['A', 'C', 'B', 'R', 'S', 'T', 'U', 'V', 'N', 'H', 'I', 'G', 'E', 'D', 'A']",41,nl,names
PCTSP,PCTSP,"There’s a simple routing problem at play: start at the courier locker, make a single loop picking up parcels at chosen stops until the sum of picked-up parcel values reaches the required target, and return to the locker. The choice is which stops to include — each has a pickup value and a skip-penalty — and the best plan keeps the riding time down while avoiding big penalties for skipped spots. To compare plans, add the full riding time and the penalties for any skipped stops; lower totals are better. The trip must be a single loop and can’t double back to visit a spot twice. Concrete details will be shown below.

{
  ""total_locations_including_locker"": 19,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""x_coordinate"": 92,
      ""y_coordinate"": 100,
      ""parcel_value"": 0,
      ""skip_penalty"": 0
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 40,
      ""y_coordinate"": 99,
      ""parcel_value"": 39,
      ""skip_penalty"": 26
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 0,
      ""y_coordinate"": 1,
      ""parcel_value"": 27,
      ""skip_penalty"": 9
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 100,
      ""y_coordinate"": 18,
      ""parcel_value"": 67,
      ""skip_penalty"": 30
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 52,
      ""y_coordinate"": 4,
      ""parcel_value"": 99,
      ""skip_penalty"": 19
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 11,
      ""y_coordinate"": 7,
      ""parcel_value"": 11,
      ""skip_penalty"": 16
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 7,
      ""y_coordinate"": 0,
      ""parcel_value"": 16,
      ""skip_penalty"": 24
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 34,
      ""y_coordinate"": 98,
      ""parcel_value"": 52,
      ""skip_penalty"": 22
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 52,
      ""y_coordinate"": 15,
      ""parcel_value"": 51,
      ""skip_penalty"": 7
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 95,
      ""y_coordinate"": 57,
      ""parcel_value"": 52,
      ""skip_penalty"": 16
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 97,
      ""y_coordinate"": 11,
      ""parcel_value"": 5,
      ""skip_penalty"": 4
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 42,
      ""y_coordinate"": 60,
      ""parcel_value"": 51,
      ""skip_penalty"": 10
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 67,
      ""y_coordinate"": 89,
      ""parcel_value"": 18,
      ""skip_penalty"": 15
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 30,
      ""y_coordinate"": 63,
      ""parcel_value"": 63,
      ""skip_penalty"": 11
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 91,
      ""y_coordinate"": 64,
      ""parcel_value"": 15,
      ""skip_penalty"": 9
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 68,
      ""y_coordinate"": 62,
      ""parcel_value"": 42,
      ""skip_penalty"": 20
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 86,
      ""y_coordinate"": 79,
      ""parcel_value"": 90,
      ""skip_penalty"": 0
    },
    {
      ""location_id"": 18,
      ""x_coordinate"": 88,
      ""y_coordinate"": 22,
      ""parcel_value"": 25,
      ""skip_penalty"": 27
    },
    {
      ""location_id"": 19,
      ""x_coordinate"": 37,
      ""y_coordinate"": 31,
      ""parcel_value"": 89,
      ""skip_penalty"": 20
    }
  ],
  ""locker_node_id"": 1,
  ""required_pickup_value"": 475.0
}

When you’re ready to send back the route, just use this little JSON layout so it’s easy to read and check:

{
  ""solution"": [locker_id, stop_id, ..., locker_id]
}

Think of it like a simple form: ""solution"" is the ordered loop — start at the locker, list the stops you’ll visit in order, and finish back at the locker. The words in the array are placeholders showing the shape of what I need; replace them with the actual identifiers from the instance when you give your real answer.

This JSON is only a sketch of the expected shape, not the actual answer — don’t submit it as-is.

Please be sure to use the exact identifiers from the instance input with no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[92, 100], [40, 99], [0, 1], [100, 18], [52, 4], [11, 7], [7, 0], [34, 98], [52, 15], [95, 57], [97, 11], [42, 60], [67, 89], [30, 63], [91, 64], [68, 62], [86, 79], [88, 22], [37, 31]], 'prizes': [0, 39, 27, 67, 99, 11, 16, 52, 51, 52, 5, 51, 18, 63, 15, 42, 90, 25, 89], 'penalties': [0, 26, 9, 30, 19, 16, 24, 22, 7, 16, 4, 10, 15, 11, 9, 20, 0, 27, 20], 'required_prize': 475.0, 'depot': 0, 'route_length': 278.26573201117645, 'route_prize': 514.0, 'unvisited_penalty': 99.0, 'objective': 377.26573201117645}","[0, 12, 1, 7, 13, 11, 15, 17, 3, 9, 14, 16, 0]",377.26573201117645,"{'problem_type': 'PCTSP', 'num_nodes': 19, 'nodes': [{'id': 1, 'x': 92, 'y': 100, 'prize': 0, 'penalty': 0}, {'id': 2, 'x': 40, 'y': 99, 'prize': 39, 'penalty': 26}, {'id': 3, 'x': 0, 'y': 1, 'prize': 27, 'penalty': 9}, {'id': 4, 'x': 100, 'y': 18, 'prize': 67, 'penalty': 30}, {'id': 5, 'x': 52, 'y': 4, 'prize': 99, 'penalty': 19}, {'id': 6, 'x': 11, 'y': 7, 'prize': 11, 'penalty': 16}, {'id': 7, 'x': 7, 'y': 0, 'prize': 16, 'penalty': 24}, {'id': 8, 'x': 34, 'y': 98, 'prize': 52, 'penalty': 22}, {'id': 9, 'x': 52, 'y': 15, 'prize': 51, 'penalty': 7}, {'id': 10, 'x': 95, 'y': 57, 'prize': 52, 'penalty': 16}, {'id': 11, 'x': 97, 'y': 11, 'prize': 5, 'penalty': 4}, {'id': 12, 'x': 42, 'y': 60, 'prize': 51, 'penalty': 10}, {'id': 13, 'x': 67, 'y': 89, 'prize': 18, 'penalty': 15}, {'id': 14, 'x': 30, 'y': 63, 'prize': 63, 'penalty': 11}, {'id': 15, 'x': 91, 'y': 64, 'prize': 15, 'penalty': 9}, {'id': 16, 'x': 68, 'y': 62, 'prize': 42, 'penalty': 20}, {'id': 17, 'x': 86, 'y': 79, 'prize': 90, 'penalty': 0}, {'id': 18, 'x': 88, 'y': 22, 'prize': 25, 'penalty': 27}, {'id': 19, 'x': 37, 'y': 31, 'prize': 89, 'penalty': 20}], 'depot': 1, 'required_prize': 475.0, 'route_prize': 514.0, 'unvisited_penalty': 99.0, 'route_length': 278.26573201117645, 'objective': 377.26573201117645}","[1, 13, 2, 8, 14, 12, 16, 18, 4, 10, 15, 17, 1]",42,json,1
PCTSP,PCTSP,"Recently the team needed a single-run plan: leave the depot, treat selected properties until the required treatment total is reached, and then return home without revisiting spots. To compare plans, simply add the total driving cost for the route to the penalties for the properties not treated — smaller totals are preferable. The route has to start and end at the depot and each chosen property is visited only once. The concrete details are shown below.

{
  ""total_locations_including_depot"": 16,
  ""nodes"": [
    {
      ""property_id"": ""A"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 0,
      ""treatment_value"": 0,
      ""untreated_penalty"": 0
    },
    {
      ""property_id"": ""B"",
      ""x_coordinate"": 5,
      ""y_coordinate"": 15,
      ""treatment_value"": 50,
      ""untreated_penalty"": 2
    },
    {
      ""property_id"": ""C"",
      ""x_coordinate"": 31,
      ""y_coordinate"": 16,
      ""treatment_value"": 29,
      ""untreated_penalty"": 12
    },
    {
      ""property_id"": ""D"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 21,
      ""treatment_value"": 61,
      ""untreated_penalty"": 25
    },
    {
      ""property_id"": ""E"",
      ""x_coordinate"": 60,
      ""y_coordinate"": 37,
      ""treatment_value"": 20,
      ""untreated_penalty"": 25
    },
    {
      ""property_id"": ""F"",
      ""x_coordinate"": 30,
      ""y_coordinate"": 63,
      ""treatment_value"": 69,
      ""untreated_penalty"": 28
    },
    {
      ""property_id"": ""G"",
      ""x_coordinate"": 44,
      ""y_coordinate"": 61,
      ""treatment_value"": 36,
      ""untreated_penalty"": 30
    },
    {
      ""property_id"": ""H"",
      ""x_coordinate"": 59,
      ""y_coordinate"": 61,
      ""treatment_value"": 11,
      ""untreated_penalty"": 15
    },
    {
      ""property_id"": ""I"",
      ""x_coordinate"": 77,
      ""y_coordinate"": 63,
      ""treatment_value"": 85,
      ""untreated_penalty"": 31
    },
    {
      ""property_id"": ""J"",
      ""x_coordinate"": 20,
      ""y_coordinate"": 67,
      ""treatment_value"": 98,
      ""untreated_penalty"": 26
    },
    {
      ""property_id"": ""K"",
      ""x_coordinate"": 97,
      ""y_coordinate"": 67,
      ""treatment_value"": 89,
      ""untreated_penalty"": 18
    },
    {
      ""property_id"": ""L"",
      ""x_coordinate"": 53,
      ""y_coordinate"": 72,
      ""treatment_value"": 22,
      ""untreated_penalty"": 28
    },
    {
      ""property_id"": ""M"",
      ""x_coordinate"": 31,
      ""y_coordinate"": 79,
      ""treatment_value"": 76,
      ""untreated_penalty"": 14
    },
    {
      ""property_id"": ""N"",
      ""x_coordinate"": 89,
      ""y_coordinate"": 89,
      ""treatment_value"": 68,
      ""untreated_penalty"": 6
    },
    {
      ""property_id"": ""O"",
      ""x_coordinate"": 72,
      ""y_coordinate"": 91,
      ""treatment_value"": 82,
      ""untreated_penalty"": 25
    },
    {
      ""property_id"": ""P"",
      ""x_coordinate"": 70,
      ""y_coordinate"": 100,
      ""treatment_value"": 6,
      ""untreated_penalty"": 11
    }
  ],
  ""depot_node_id"": ""A"",
  ""required_treatment_total"": 400.0
}

Also, when you reply with a plan, just paste a small JSON snippet like this — super simple.

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Here ""solution"" is just the ordered list of places visited: start at the depot, visit each chosen property once in the order you want, and finish back at the depot. Think of it like filling out a short form with the route order — that’s all the JSON needs to show. This is just a sketch of the shape I expect, not the actual answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [5, 15], [31, 16], [100, 21], [60, 37], [30, 63], [44, 61], [59, 61], [77, 63], [20, 67], [97, 67], [53, 72], [31, 79], [89, 89], [72, 91], [70, 100]], 'prizes': [0, 50, 29, 61, 20, 69, 36, 11, 85, 98, 89, 22, 76, 68, 82, 6], 'penalties': [0, 2, 12, 25, 25, 28, 30, 15, 31, 26, 18, 28, 14, 6, 25, 11], 'required_prize': 400.0, 'depot': 0, 'route_length': 241.45249861472874, 'route_prize': 420.0, 'unvisited_penalty': 99.0, 'objective': 340.45249861472877}","[0, 2, 4, 8, 7, 11, 6, 5, 9, 1, 0]",340.45249861472877,"{'problem_type': 'PCTSP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 5, 'y': 15, 'prize': 50, 'penalty': 2}, {'id': 'C', 'x': 31, 'y': 16, 'prize': 29, 'penalty': 12}, {'id': 'D', 'x': 100, 'y': 21, 'prize': 61, 'penalty': 25}, {'id': 'E', 'x': 60, 'y': 37, 'prize': 20, 'penalty': 25}, {'id': 'F', 'x': 30, 'y': 63, 'prize': 69, 'penalty': 28}, {'id': 'G', 'x': 44, 'y': 61, 'prize': 36, 'penalty': 30}, {'id': 'H', 'x': 59, 'y': 61, 'prize': 11, 'penalty': 15}, {'id': 'I', 'x': 77, 'y': 63, 'prize': 85, 'penalty': 31}, {'id': 'J', 'x': 20, 'y': 67, 'prize': 98, 'penalty': 26}, {'id': 'K', 'x': 97, 'y': 67, 'prize': 89, 'penalty': 18}, {'id': 'L', 'x': 53, 'y': 72, 'prize': 22, 'penalty': 28}, {'id': 'M', 'x': 31, 'y': 79, 'prize': 76, 'penalty': 14}, {'id': 'N', 'x': 89, 'y': 89, 'prize': 68, 'penalty': 6}, {'id': 'O', 'x': 72, 'y': 91, 'prize': 82, 'penalty': 25}, {'id': 'P', 'x': 70, 'y': 100, 'prize': 6, 'penalty': 11}], 'depot': 'A', 'required_prize': 400.0, 'route_prize': 420.0, 'unvisited_penalty': 99.0, 'route_length': 241.45249861472874, 'objective': 340.45249861472877}","['A', 'C', 'E', 'I', 'H', 'L', 'G', 'F', 'J', 'B', 'A']",43,json,names
PCTSP,PCTSP,"Many people depend on a single outreach run: the clinic van will head out, visit chosen community sites, and return to base in one circuit. The job is to pick which sites to visit so the total vaccinations collected reaches the required threshold; a smarter pick keeps the sum of travel hours and the penalties for any skipped sites as small as possible. In other words, add up the total drive time for the loop and the penalties for missed sites to get the plan’s score — visits can’t be repeated and the loop must end where it started. The specific site-by-site figures are shown below.

There are 18 locations (clinic depot is A); the single circuit must collect at least 450.0 vaccinations. The specific sites are listed below:

| site_id | x_coordinate | y_coordinate | expected_vaccinations_at_site | penalty_hours_for_not_visiting |
|---|---|---|---|---|
| A | 4 | 33 | 0 | 0 |
| B | 0 | 86 | 20 | 11 |
| C | 0 | 100 | 79 | 13 |
| D | 4 | 98 | 33 | 5 |
| E | 35 | 71 | 4 | 6 |
| F | 87 | 81 | 27 | 9 |
| G | 87 | 55 | 89 | 27 |
| H | 100 | 40 | 65 | 23 |
| I | 100 | 36 | 0 | 21 |
| J | 90 | 21 | 84 | 15 |
| K | 83 | 26 | 9 | 31 |
| L | 100 | 12 | 63 | 26 |
| M | 100 | 7 | 89 | 8 |
| N | 100 | 5 | 15 | 16 |
| O | 100 | 0 | 2 | 7 |
| P | 50 | 0 | 99 | 20 |
| Q | 62 | 14 | 72 | 24 |
| R | 35 | 45 | 33 | 3 |

Select visits so the circuit meets 450.0 while keeping total drive time plus penalties as low as possible.

When you're ready to give the selected route, just send it back in this simple JSON shape so it's easy to read and check:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

This ""solution"" list is just the van's loop: start with the depot, list each site in the order you'll visit them, and finish back at the same depot. It's just a compact way of saying ""follow these labels in this sequence.""

This is only a sketch of the expected shape, not the actual answer—fill in the real site labels from the instance input. Please use the identifiers exactly as they appear in the instance (no renaming, no new labels). 
- For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[4, 33], [0, 86], [0, 100], [4, 98], [35, 71], [87, 81], [87, 55], [100, 40], [100, 36], [90, 21], [83, 26], [100, 12], [100, 7], [100, 5], [100, 0], [50, 0], [62, 14], [35, 45]], 'prizes': [0, 20, 79, 33, 4, 27, 89, 65, 0, 84, 9, 63, 89, 15, 2, 99, 72, 33], 'penalties': [0, 11, 13, 5, 6, 9, 27, 23, 21, 15, 31, 26, 8, 16, 7, 20, 24, 3], 'required_prize': 450.0, 'depot': 0, 'route_length': 267.7526518074733, 'route_prize': 618.0, 'unvisited_penalty': 51.0, 'objective': 318.75265180747334}","[0, 17, 6, 7, 8, 11, 12, 13, 9, 10, 16, 15, 0]",318.75265180747334,"{'problem_type': 'PCTSP', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 4, 'y': 33, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 0, 'y': 86, 'prize': 20, 'penalty': 11}, {'id': 'C', 'x': 0, 'y': 100, 'prize': 79, 'penalty': 13}, {'id': 'D', 'x': 4, 'y': 98, 'prize': 33, 'penalty': 5}, {'id': 'E', 'x': 35, 'y': 71, 'prize': 4, 'penalty': 6}, {'id': 'F', 'x': 87, 'y': 81, 'prize': 27, 'penalty': 9}, {'id': 'G', 'x': 87, 'y': 55, 'prize': 89, 'penalty': 27}, {'id': 'H', 'x': 100, 'y': 40, 'prize': 65, 'penalty': 23}, {'id': 'I', 'x': 100, 'y': 36, 'prize': 0, 'penalty': 21}, {'id': 'J', 'x': 90, 'y': 21, 'prize': 84, 'penalty': 15}, {'id': 'K', 'x': 83, 'y': 26, 'prize': 9, 'penalty': 31}, {'id': 'L', 'x': 100, 'y': 12, 'prize': 63, 'penalty': 26}, {'id': 'M', 'x': 100, 'y': 7, 'prize': 89, 'penalty': 8}, {'id': 'N', 'x': 100, 'y': 5, 'prize': 15, 'penalty': 16}, {'id': 'O', 'x': 100, 'y': 0, 'prize': 2, 'penalty': 7}, {'id': 'P', 'x': 50, 'y': 0, 'prize': 99, 'penalty': 20}, {'id': 'Q', 'x': 62, 'y': 14, 'prize': 72, 'penalty': 24}, {'id': 'R', 'x': 35, 'y': 45, 'prize': 33, 'penalty': 3}], 'depot': 'A', 'required_prize': 450.0, 'route_prize': 618.0, 'unvisited_penalty': 51.0, 'route_length': 267.7526518074733, 'objective': 318.75265180747334}","['A', 'R', 'G', 'H', 'I', 'L', 'M', 'N', 'J', 'K', 'Q', 'P', 'A']",44,markdown_table,names
PCTSP,PCTSP,"We’ve got one busker who wants to plan a single circuit from a favorite corner and back, choosing a handful of performance stops so the day’s donation goal is met. The choice is about balancing two things: how much walking is involved and how much potential income is given up by skipping other spots. To compare plans, simply sum the walking distance and the money forgone from omitted stops — the plan with the smaller sum wins, as long as the selected stops together reach the donation target. Nothing gets visited twice, the run must loop back to the starting corner, and the exact locations, expected donations, and distances are shown below.

{
  ""total_spot_count"": 22,
  ""nodes"": [
    {
      ""spot_id"": 0,
      ""street_x_coord"": 0,
      ""street_y_coord"": 53,
      ""expected_donation"": 0,
      ""forgone_donation"": 0
    },
    {
      ""spot_id"": 1,
      ""street_x_coord"": 19,
      ""street_y_coord"": 11,
      ""expected_donation"": 80,
      ""forgone_donation"": 23
    },
    {
      ""spot_id"": 2,
      ""street_x_coord"": 61,
      ""street_y_coord"": 14,
      ""expected_donation"": 75,
      ""forgone_donation"": 5
    },
    {
      ""spot_id"": 3,
      ""street_x_coord"": 73,
      ""street_y_coord"": 82,
      ""expected_donation"": 35,
      ""forgone_donation"": 20
    },
    {
      ""spot_id"": 4,
      ""street_x_coord"": 79,
      ""street_y_coord"": 82,
      ""expected_donation"": 82,
      ""forgone_donation"": 11
    },
    {
      ""spot_id"": 5,
      ""street_x_coord"": 83,
      ""street_y_coord"": 58,
      ""expected_donation"": 56,
      ""forgone_donation"": 10
    },
    {
      ""spot_id"": 6,
      ""street_x_coord"": 92,
      ""street_y_coord"": 65,
      ""expected_donation"": 50,
      ""forgone_donation"": 20
    },
    {
      ""spot_id"": 7,
      ""street_x_coord"": 100,
      ""street_y_coord"": 8,
      ""expected_donation"": 83,
      ""forgone_donation"": 8
    },
    {
      ""spot_id"": 8,
      ""street_x_coord"": 97,
      ""street_y_coord"": 8,
      ""expected_donation"": 0,
      ""forgone_donation"": 9
    },
    {
      ""spot_id"": 9,
      ""street_x_coord"": 65,
      ""street_y_coord"": 0,
      ""expected_donation"": 86,
      ""forgone_donation"": 18
    },
    {
      ""spot_id"": 10,
      ""street_x_coord"": 49,
      ""street_y_coord"": 23,
      ""expected_donation"": 77,
      ""forgone_donation"": 10
    },
    {
      ""spot_id"": 11,
      ""street_x_coord"": 32,
      ""street_y_coord"": 45,
      ""expected_donation"": 22,
      ""forgone_donation"": 2
    },
    {
      ""spot_id"": 12,
      ""street_x_coord"": 36,
      ""street_y_coord"": 45,
      ""expected_donation"": 12,
      ""forgone_donation"": 11
    },
    {
      ""spot_id"": 13,
      ""street_x_coord"": 36,
      ""street_y_coord"": 36,
      ""expected_donation"": 94,
      ""forgone_donation"": 4
    },
    {
      ""spot_id"": 14,
      ""street_x_coord"": 47,
      ""street_y_coord"": 36,
      ""expected_donation"": 10,
      ""forgone_donation"": 10
    },
    {
      ""spot_id"": 15,
      ""street_x_coord"": 51,
      ""street_y_coord"": 53,
      ""expected_donation"": 80,
      ""forgone_donation"": 5
    },
    {
      ""spot_id"": 16,
      ""street_x_coord"": 50,
      ""street_y_coord"": 100,
      ""expected_donation"": 9,
      ""forgone_donation"": 30
    },
    {
      ""spot_id"": 17,
      ""street_x_coord"": 39,
      ""street_y_coord"": 78,
      ""expected_donation"": 56,
      ""forgone_donation"": 13
    },
    {
      ""spot_id"": 18,
      ""street_x_coord"": 28,
      ""street_y_coord"": 18,
      ""expected_donation"": 33,
      ""forgone_donation"": 23
    },
    {
      ""spot_id"": 19,
      ""street_x_coord"": 17,
      ""street_y_coord"": 73,
      ""expected_donation"": 18,
      ""forgone_donation"": 6
    },
    {
      ""spot_id"": 20,
      ""street_x_coord"": 7,
      ""street_y_coord"": 87,
      ""expected_donation"": 6,
      ""forgone_donation"": 10
    },
    {
      ""spot_id"": 21,
      ""street_x_coord"": 7,
      ""street_y_coord"": 90,
      ""expected_donation"": 69,
      ""forgone_donation"": 4
    }
  ],
  ""starting_corner_id"": 0,
  ""donation_target"": 550.0
}

Oh, and one more thing — when you send back the planned loop, please use this simple JSON layout so it's easy to check:

{
  ""solution"": [corner_id, stop_id, ..., corner_id]
}

Think of that as a little form: ""solution"" is the ordered loop — start at your favorite corner, hit each stop in order, and return to the corner at the end. The corner_id and stop_id bits are just placeholders showing where the actual spot identifiers go; this block is only a sketch of the shape I expect, not the real route.

Please use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[0, 53], [19, 11], [61, 14], [73, 82], [79, 82], [83, 58], [92, 65], [100, 8], [97, 8], [65, 0], [49, 23], [32, 45], [36, 45], [36, 36], [47, 36], [51, 53], [50, 100], [39, 78], [28, 18], [17, 73], [7, 87], [7, 90]], 'prizes': [0, 80, 75, 35, 82, 56, 50, 83, 0, 86, 77, 22, 12, 94, 10, 80, 9, 56, 33, 18, 6, 69], 'penalties': [0, 23, 5, 20, 11, 10, 20, 8, 9, 18, 10, 2, 11, 4, 10, 5, 30, 13, 23, 6, 10, 4], 'required_prize': 550.0, 'depot': 0, 'route_length': 277.00089976016386, 'route_prize': 605.0, 'unvisited_penalty': 76.0, 'objective': 353.00089976016386}","[0, 1, 18, 13, 12, 15, 5, 6, 4, 3, 16, 17, 19, 0]",353.00089976016386,"{'problem_type': 'PCTSP', 'num_nodes': 22, 'nodes': [{'id': 0, 'x': 0, 'y': 53, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 19, 'y': 11, 'prize': 80, 'penalty': 23}, {'id': 2, 'x': 61, 'y': 14, 'prize': 75, 'penalty': 5}, {'id': 3, 'x': 73, 'y': 82, 'prize': 35, 'penalty': 20}, {'id': 4, 'x': 79, 'y': 82, 'prize': 82, 'penalty': 11}, {'id': 5, 'x': 83, 'y': 58, 'prize': 56, 'penalty': 10}, {'id': 6, 'x': 92, 'y': 65, 'prize': 50, 'penalty': 20}, {'id': 7, 'x': 100, 'y': 8, 'prize': 83, 'penalty': 8}, {'id': 8, 'x': 97, 'y': 8, 'prize': 0, 'penalty': 9}, {'id': 9, 'x': 65, 'y': 0, 'prize': 86, 'penalty': 18}, {'id': 10, 'x': 49, 'y': 23, 'prize': 77, 'penalty': 10}, {'id': 11, 'x': 32, 'y': 45, 'prize': 22, 'penalty': 2}, {'id': 12, 'x': 36, 'y': 45, 'prize': 12, 'penalty': 11}, {'id': 13, 'x': 36, 'y': 36, 'prize': 94, 'penalty': 4}, {'id': 14, 'x': 47, 'y': 36, 'prize': 10, 'penalty': 10}, {'id': 15, 'x': 51, 'y': 53, 'prize': 80, 'penalty': 5}, {'id': 16, 'x': 50, 'y': 100, 'prize': 9, 'penalty': 30}, {'id': 17, 'x': 39, 'y': 78, 'prize': 56, 'penalty': 13}, {'id': 18, 'x': 28, 'y': 18, 'prize': 33, 'penalty': 23}, {'id': 19, 'x': 17, 'y': 73, 'prize': 18, 'penalty': 6}, {'id': 20, 'x': 7, 'y': 87, 'prize': 6, 'penalty': 10}, {'id': 21, 'x': 7, 'y': 90, 'prize': 69, 'penalty': 4}], 'depot': 0, 'required_prize': 550.0, 'route_prize': 605.0, 'unvisited_penalty': 76.0, 'route_length': 277.00089976016386, 'objective': 353.00089976016386}","[0, 1, 18, 13, 12, 15, 5, 6, 4, 3, 16, 17, 19, 0]",45,json,0
PCTSP,PCTSP,"Picture this: a crew needs a single circular route starting and ending at base camp that stops at some sites to gather samples until the mission’s minimum is met, then returns home. The choice is which sites to include and in what order, making sure not to visit any site more than once and to reach the required sample total. A plan is better if it keeps driving to a minimum and limits the penalties for skipped sites — the overall measure is just travel distance plus the sum of penalties for any unsampled locations. The detailed numbers and site list are below.

# total_locations_including_base=19
# base_camp_id=A
# required_sample_total=475.0
site_id,x_coord,y_coord,sample_value,unsampled_penalty
A,13,60,0,0
B,30,53,6,23
C,57,51,12,21
D,78,81,40,10
E,96,100,14,28
F,96,65,72,23
G,100,12,68,5
H,93,2,40,25
I,93,9,68,25
J,74,7,99,8
K,74,16,18,5
L,57,19,11,13
M,78,30,12,23
N,41,2,24,15
O,41,47,49,29
P,24,28,37,17
Q,26,0,43,9
R,0,91,77,29
S,11,77,88,0

Oh, and when you send back the actual route, please use this simple JSON shape so it's easy to read and import:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of ""solution"" as the tour: start with the depot, list each site you plan to stop at in order, and finish back at the depot. The items in the array are placeholders — when you give the real answer, replace them with the exact site IDs from the instance. This is just a sketch of the expected shape, not the real route.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[13, 60], [30, 53], [57, 51], [78, 81], [96, 100], [96, 65], [100, 12], [93, 2], [93, 9], [74, 7], [74, 16], [57, 19], [78, 30], [41, 2], [41, 47], [24, 28], [26, 0], [0, 91], [11, 77]], 'prizes': [0, 6, 12, 40, 14, 72, 68, 40, 68, 99, 18, 11, 12, 24, 49, 37, 43, 77, 88], 'penalties': [0, 23, 21, 10, 28, 23, 5, 25, 25, 8, 5, 13, 23, 15, 29, 17, 9, 29, 0], 'required_prize': 475.0, 'depot': 0, 'route_length': 266.44348816517856, 'route_prize': 487.0, 'unvisited_penalty': 90.0, 'objective': 356.4434881651785}","[0, 15, 16, 13, 11, 10, 9, 7, 8, 6, 12, 2, 14, 1, 0]",356.4434881651785,"{'problem_type': 'PCTSP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 13, 'y': 60, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 30, 'y': 53, 'prize': 6, 'penalty': 23}, {'id': 'C', 'x': 57, 'y': 51, 'prize': 12, 'penalty': 21}, {'id': 'D', 'x': 78, 'y': 81, 'prize': 40, 'penalty': 10}, {'id': 'E', 'x': 96, 'y': 100, 'prize': 14, 'penalty': 28}, {'id': 'F', 'x': 96, 'y': 65, 'prize': 72, 'penalty': 23}, {'id': 'G', 'x': 100, 'y': 12, 'prize': 68, 'penalty': 5}, {'id': 'H', 'x': 93, 'y': 2, 'prize': 40, 'penalty': 25}, {'id': 'I', 'x': 93, 'y': 9, 'prize': 68, 'penalty': 25}, {'id': 'J', 'x': 74, 'y': 7, 'prize': 99, 'penalty': 8}, {'id': 'K', 'x': 74, 'y': 16, 'prize': 18, 'penalty': 5}, {'id': 'L', 'x': 57, 'y': 19, 'prize': 11, 'penalty': 13}, {'id': 'M', 'x': 78, 'y': 30, 'prize': 12, 'penalty': 23}, {'id': 'N', 'x': 41, 'y': 2, 'prize': 24, 'penalty': 15}, {'id': 'O', 'x': 41, 'y': 47, 'prize': 49, 'penalty': 29}, {'id': 'P', 'x': 24, 'y': 28, 'prize': 37, 'penalty': 17}, {'id': 'Q', 'x': 26, 'y': 0, 'prize': 43, 'penalty': 9}, {'id': 'R', 'x': 0, 'y': 91, 'prize': 77, 'penalty': 29}, {'id': 'S', 'x': 11, 'y': 77, 'prize': 88, 'penalty': 0}], 'depot': 'A', 'required_prize': 475.0, 'route_prize': 487.0, 'unvisited_penalty': 90.0, 'route_length': 266.44348816517856, 'objective': 356.4434881651785}","['A', 'P', 'Q', 'N', 'L', 'K', 'J', 'H', 'I', 'G', 'M', 'C', 'O', 'B', 'A']",46,csv,names
PCTSP,PCTSP,"Many people on the scheduling team have faced this: one depot, a pile of houses with values and skip-penalties, and one circuit to plan that has to meet a target amount of installed value. The decision is which homes to visit on that single loop—each candidate route’s final score is simply driving cost plus the penalties for the homes not visited, and the route with the lowest combined score wins. Visits aren’t repeated, the trip must start and finish at the depot, and the chosen stops must reach the required total value. See the exact numbers and locations below.

# total_locations_count=21
# depot_location_id=0
# required_installation_value=525.0
location_id,x_coordinate,y_coordinate,installation_value,skip_penalty
0,15,22,0,0
1,28,55,39,13
2,22,81,13,12
3,36,89,28,13
4,42,13,99,5
5,42,54,2,13
6,51,67,73,20
7,46,81,100,7
8,60,57,33,23
9,60,22,4,20
10,57,13,20,25
11,75,43,15,30
12,71,67,88,31
13,75,67,9,15
14,76,81,54,23
15,75,95,88,25
16,81,88,54,24
17,81,54,94,12
18,100,0,19,1
19,100,100,77,3
20,0,100,38,5

Oh, and when you reply, please use this simple JSON layout for the route so it's easy to parse:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

""solution"" is just the tour: start at the depot, list the stops you plan to visit in the order you’ll hit them, and end back at the depot. Think of it as filling out a little itinerary form — just the sequence, nothing else. This is only a sketch of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[15, 22], [28, 55], [22, 81], [36, 89], [42, 13], [42, 54], [51, 67], [46, 81], [60, 57], [60, 22], [57, 13], [75, 43], [71, 67], [75, 67], [76, 81], [75, 95], [81, 88], [81, 54], [100, 0], [100, 100], [0, 100]], 'prizes': [0, 39, 13, 28, 99, 2, 73, 100, 33, 4, 20, 15, 88, 9, 54, 88, 54, 94, 19, 77, 38], 'penalties': [0, 13, 12, 13, 5, 13, 20, 7, 23, 20, 25, 30, 31, 15, 23, 25, 24, 12, 1, 3, 5], 'required_prize': 525.0, 'depot': 0, 'route_length': 259.1987502374263, 'route_prize': 672.0, 'unvisited_penalty': 41.0, 'objective': 300.19875023742634}","[0, 1, 5, 6, 8, 12, 14, 15, 16, 13, 17, 11, 9, 10, 4, 0]",300.19875023742634,"{'problem_type': 'PCTSP', 'num_nodes': 21, 'nodes': [{'id': 0, 'x': 15, 'y': 22, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 28, 'y': 55, 'prize': 39, 'penalty': 13}, {'id': 2, 'x': 22, 'y': 81, 'prize': 13, 'penalty': 12}, {'id': 3, 'x': 36, 'y': 89, 'prize': 28, 'penalty': 13}, {'id': 4, 'x': 42, 'y': 13, 'prize': 99, 'penalty': 5}, {'id': 5, 'x': 42, 'y': 54, 'prize': 2, 'penalty': 13}, {'id': 6, 'x': 51, 'y': 67, 'prize': 73, 'penalty': 20}, {'id': 7, 'x': 46, 'y': 81, 'prize': 100, 'penalty': 7}, {'id': 8, 'x': 60, 'y': 57, 'prize': 33, 'penalty': 23}, {'id': 9, 'x': 60, 'y': 22, 'prize': 4, 'penalty': 20}, {'id': 10, 'x': 57, 'y': 13, 'prize': 20, 'penalty': 25}, {'id': 11, 'x': 75, 'y': 43, 'prize': 15, 'penalty': 30}, {'id': 12, 'x': 71, 'y': 67, 'prize': 88, 'penalty': 31}, {'id': 13, 'x': 75, 'y': 67, 'prize': 9, 'penalty': 15}, {'id': 14, 'x': 76, 'y': 81, 'prize': 54, 'penalty': 23}, {'id': 15, 'x': 75, 'y': 95, 'prize': 88, 'penalty': 25}, {'id': 16, 'x': 81, 'y': 88, 'prize': 54, 'penalty': 24}, {'id': 17, 'x': 81, 'y': 54, 'prize': 94, 'penalty': 12}, {'id': 18, 'x': 100, 'y': 0, 'prize': 19, 'penalty': 1}, {'id': 19, 'x': 100, 'y': 100, 'prize': 77, 'penalty': 3}, {'id': 20, 'x': 0, 'y': 100, 'prize': 38, 'penalty': 5}], 'depot': 0, 'required_prize': 525.0, 'route_prize': 672.0, 'unvisited_penalty': 41.0, 'route_length': 259.1987502374263, 'objective': 300.19875023742634}","[0, 1, 5, 6, 8, 12, 14, 15, 16, 13, 17, 11, 9, 10, 4, 0]",47,csv,0
PCTSP,PCTSP,"I was putting together a one-day photo run that leaves from and comes back to the hotel, picking which sights to shoot so the collection of photos reaches the magazine’s minimum value. The choice is about which stops to include on that single loop — each landmark has a photo value and a penalty if it’s skipped — and the score for any plan is the total travel cost for the whole circuit plus the sum of penalties for unvisited spots. The trip can’t be split into two separate trips or hit the same place twice; it has to be one continuous loop that satisfies the minimum photo value while keeping travel plus skipped-spot penalties as small as possible. The concrete details for the route, values, and penalties are shown below.

{
  ""total_locations_including_hotel"": 25,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""x_coord"": 52,
      ""y_coord"": 96,
      ""photo_value"": 0,
      ""skip_penalty"": 0
    },
    {
      ""location_id"": 1,
      ""x_coord"": 54,
      ""y_coord"": 93,
      ""photo_value"": 8,
      ""skip_penalty"": 5
    },
    {
      ""location_id"": 2,
      ""x_coord"": 54,
      ""y_coord"": 92,
      ""photo_value"": 21,
      ""skip_penalty"": 15
    },
    {
      ""location_id"": 3,
      ""x_coord"": 51,
      ""y_coord"": 91,
      ""photo_value"": 26,
      ""skip_penalty"": 23
    },
    {
      ""location_id"": 4,
      ""x_coord"": 52,
      ""y_coord"": 91,
      ""photo_value"": 22,
      ""skip_penalty"": 7
    },
    {
      ""location_id"": 5,
      ""x_coord"": 0,
      ""y_coord"": 72,
      ""photo_value"": 35,
      ""skip_penalty"": 25
    },
    {
      ""location_id"": 6,
      ""x_coord"": 100,
      ""y_coord"": 70,
      ""photo_value"": 3,
      ""skip_penalty"": 5
    },
    {
      ""location_id"": 7,
      ""x_coord"": 68,
      ""y_coord"": 67,
      ""photo_value"": 85,
      ""skip_penalty"": 11
    },
    {
      ""location_id"": 8,
      ""x_coord"": 78,
      ""y_coord"": 67,
      ""photo_value"": 42,
      ""skip_penalty"": 19
    },
    {
      ""location_id"": 9,
      ""x_coord"": 81,
      ""y_coord"": 67,
      ""photo_value"": 92,
      ""skip_penalty"": 6
    },
    {
      ""location_id"": 10,
      ""x_coord"": 80,
      ""y_coord"": 66,
      ""photo_value"": 49,
      ""skip_penalty"": 23
    },
    {
      ""location_id"": 11,
      ""x_coord"": 46,
      ""y_coord"": 58,
      ""photo_value"": 10,
      ""skip_penalty"": 5
    },
    {
      ""location_id"": 12,
      ""x_coord"": 59,
      ""y_coord"": 58,
      ""photo_value"": 10,
      ""skip_penalty"": 10
    },
    {
      ""location_id"": 13,
      ""x_coord"": 61,
      ""y_coord"": 57,
      ""photo_value"": 75,
      ""skip_penalty"": 9
    },
    {
      ""location_id"": 14,
      ""x_coord"": 81,
      ""y_coord"": 57,
      ""photo_value"": 5,
      ""skip_penalty"": 14
    },
    {
      ""location_id"": 15,
      ""x_coord"": 64,
      ""y_coord"": 53,
      ""photo_value"": 0,
      ""skip_penalty"": 17
    },
    {
      ""location_id"": 16,
      ""x_coord"": 77,
      ""y_coord"": 53,
      ""photo_value"": 8,
      ""skip_penalty"": 25
    },
    {
      ""location_id"": 17,
      ""x_coord"": 47,
      ""y_coord"": 34,
      ""photo_value"": 17,
      ""skip_penalty"": 4
    },
    {
      ""location_id"": 18,
      ""x_coord"": 42,
      ""y_coord"": 31,
      ""photo_value"": 98,
      ""skip_penalty"": 23
    },
    {
      ""location_id"": 19,
      ""x_coord"": 30,
      ""y_coord"": 21,
      ""photo_value"": 75,
      ""skip_penalty"": 10
    },
    {
      ""location_id"": 20,
      ""x_coord"": 88,
      ""y_coord"": 24,
      ""photo_value"": 39,
      ""skip_penalty"": 11
    },
    {
      ""location_id"": 21,
      ""x_coord"": 81,
      ""y_coord"": 100,
      ""photo_value"": 87,
      ""skip_penalty"": 26
    },
    {
      ""location_id"": 22,
      ""x_coord"": 72,
      ""y_coord"": 100,
      ""photo_value"": 66,
      ""skip_penalty"": 15
    },
    {
      ""location_id"": 23,
      ""x_coord"": 75,
      ""y_coord"": 0,
      ""photo_value"": 51,
      ""skip_penalty"": 3
    },
    {
      ""location_id"": 24,
      ""x_coord"": 7,
      ""y_coord"": 0,
      ""photo_value"": 49,
      ""skip_penalty"": 15
    }
  ],
  ""hotel_location_id"": 0,
  ""required_total_photo_value"": 625.0
}

Oh — one more thing: when you give the route back, just drop it into a tiny JSON snippet like this so it's easy to read and parse.

{
  ""solution"": [hotel_id, sight_id, ..., hotel_id]
}

Think of that as a simple form: ""hotel_id"" is where the day starts and ends, the things in the middle are the sights in the order you’ll visit them, and the trailing ""hotel_id"" just closes the loop. This is just a sketch of the shape I need, not the actual route.

Please make sure to use the exact identifiers from the instance input — no renaming and no made-up labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[52, 96], [54, 93], [54, 92], [51, 91], [52, 91], [0, 72], [100, 70], [68, 67], [78, 67], [81, 67], [80, 66], [46, 58], [59, 58], [61, 57], [81, 57], [64, 53], [77, 53], [47, 34], [42, 31], [30, 21], [88, 24], [81, 100], [72, 100], [75, 0], [7, 0]], 'prizes': [0, 8, 21, 26, 22, 35, 3, 85, 42, 92, 49, 10, 10, 75, 5, 0, 8, 17, 98, 75, 39, 87, 66, 51, 49], 'penalties': [0, 5, 15, 23, 7, 25, 5, 11, 19, 6, 23, 5, 10, 9, 14, 17, 25, 4, 23, 10, 11, 26, 15, 3, 15], 'required_prize': 625.0, 'depot': 0, 'route_length': 203.07139557571182, 'route_prize': 636.0, 'unvisited_penalty': 80.0, 'objective': 283.0713955757118}","[0, 1, 2, 4, 3, 11, 18, 17, 12, 13, 15, 16, 14, 10, 9, 8, 21, 22, 0]",283.0713955757118,"{'problem_type': 'PCTSP', 'num_nodes': 25, 'nodes': [{'id': 0, 'x': 52, 'y': 96, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 54, 'y': 93, 'prize': 8, 'penalty': 5}, {'id': 2, 'x': 54, 'y': 92, 'prize': 21, 'penalty': 15}, {'id': 3, 'x': 51, 'y': 91, 'prize': 26, 'penalty': 23}, {'id': 4, 'x': 52, 'y': 91, 'prize': 22, 'penalty': 7}, {'id': 5, 'x': 0, 'y': 72, 'prize': 35, 'penalty': 25}, {'id': 6, 'x': 100, 'y': 70, 'prize': 3, 'penalty': 5}, {'id': 7, 'x': 68, 'y': 67, 'prize': 85, 'penalty': 11}, {'id': 8, 'x': 78, 'y': 67, 'prize': 42, 'penalty': 19}, {'id': 9, 'x': 81, 'y': 67, 'prize': 92, 'penalty': 6}, {'id': 10, 'x': 80, 'y': 66, 'prize': 49, 'penalty': 23}, {'id': 11, 'x': 46, 'y': 58, 'prize': 10, 'penalty': 5}, {'id': 12, 'x': 59, 'y': 58, 'prize': 10, 'penalty': 10}, {'id': 13, 'x': 61, 'y': 57, 'prize': 75, 'penalty': 9}, {'id': 14, 'x': 81, 'y': 57, 'prize': 5, 'penalty': 14}, {'id': 15, 'x': 64, 'y': 53, 'prize': 0, 'penalty': 17}, {'id': 16, 'x': 77, 'y': 53, 'prize': 8, 'penalty': 25}, {'id': 17, 'x': 47, 'y': 34, 'prize': 17, 'penalty': 4}, {'id': 18, 'x': 42, 'y': 31, 'prize': 98, 'penalty': 23}, {'id': 19, 'x': 30, 'y': 21, 'prize': 75, 'penalty': 10}, {'id': 20, 'x': 88, 'y': 24, 'prize': 39, 'penalty': 11}, {'id': 21, 'x': 81, 'y': 100, 'prize': 87, 'penalty': 26}, {'id': 22, 'x': 72, 'y': 100, 'prize': 66, 'penalty': 15}, {'id': 23, 'x': 75, 'y': 0, 'prize': 51, 'penalty': 3}, {'id': 24, 'x': 7, 'y': 0, 'prize': 49, 'penalty': 15}], 'depot': 0, 'required_prize': 625.0, 'route_prize': 636.0, 'unvisited_penalty': 80.0, 'route_length': 203.07139557571182, 'objective': 283.0713955757118}","[0, 1, 2, 4, 3, 11, 18, 17, 12, 13, 15, 16, 14, 10, 9, 8, 21, 22, 0]",48,json,0
PCTSP,PCTSP,"Recently the team had to plan a single trip from the store that hits enough customers to reach a target sales amount and then returns — not every stop needs to be made, but skipping one carries a penalty. For each possible route, take the miles driven and add the penalties for every skipped order to get that route’s score; routes with smaller scores are better. The tour must be a single outbound-and-back loop, each address can be visited only once, and the sum of delivered orders must at least meet the target. Concrete details are listed below.

There are 25 locations total, the store is node A, and the target sales amount is 625.0.
Location A at (91, 54) has order value 0 and skip penalty 0.
Location B at (1, 100) has order value 94 and skip penalty 26.
Location C at (57, 43) has order value 21 and skip penalty 15.
Location D at (26, 77) has order value 96 and skip penalty 14.
Location E at (85, 17) has order value 61 and skip penalty 26.
Location F at (73, 84) has order value 54 and skip penalty 16.
Location G at (66, 67) has order value 16 and skip penalty 7.
Location H at (93, 0) has order value 34 and skip penalty 20.
Location I at (0, 7) has order value 97 and skip penalty 14.
Location J at (42, 13) has order value 17 and skip penalty 24.
Location K at (9, 49) has order value 72 and skip penalty 2.
Location L at (45, 40) has order value 45 and skip penalty 27.
Location M at (72, 14) has order value 29 and skip penalty 24.
Location N at (68, 74) has order value 17 and skip penalty 10.
Location O at (73, 23) has order value 88 and skip penalty 22.
Location P at (81, 92) has order value 95 and skip penalty 26.
Location Q at (54, 57) has order value 9 and skip penalty 24.
Location R at (36, 63) has order value 25 and skip penalty 4.
Location S at (92, 58) has order value 25 and skip penalty 17.
Location T at (90, 2) has order value 84 and skip penalty 12.
Location U at (14, 99) has order value 54 and skip penalty 23.
Location V at (74, 85) has order value 16 and skip penalty 11.
Location W at (80, 69) has order value 69 and skip penalty 12.
Location X at (78, 0) has order value 50 and skip penalty 4.
Location Y at (100, 80) has order value 63 and skip penalty 24.
The team will evaluate each outbound-and-back loop by adding miles driven to the skip penalties for unvisited customers to identify the lowest-scoring route.

When you send the actual route back, just drop it into this simple JSON shape so I can read it easily:

{
  ""solution"": [depot_id, location_id, ..., depot_id]
}

Think of ""solution"" as the ordered list for the trip: start at the depot, follow the listed stops (each at most once), and finish back at the depot. This is just the sketch of the shape I expect — not your final answer yet.

Please use the exact identifiers from the instance input — do not rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[91, 54], [1, 100], [57, 43], [26, 77], [85, 17], [73, 84], [66, 67], [93, 0], [0, 7], [42, 13], [9, 49], [45, 40], [72, 14], [68, 74], [73, 23], [81, 92], [54, 57], [36, 63], [92, 58], [90, 2], [14, 99], [74, 85], [80, 69], [78, 0], [100, 80]], 'prizes': [0, 94, 21, 96, 61, 54, 16, 34, 97, 17, 72, 45, 29, 17, 88, 95, 9, 25, 25, 84, 54, 16, 69, 50, 63], 'penalties': [0, 26, 15, 14, 26, 16, 7, 20, 14, 24, 2, 27, 24, 10, 22, 26, 24, 4, 17, 12, 23, 11, 12, 4, 24], 'required_prize': 625.0, 'depot': 0, 'route_length': 243.18243393955834, 'route_prize': 657.0, 'unvisited_penalty': 123.0, 'objective': 366.1823928191615}","[0, 18, 24, 15, 21, 5, 13, 6, 16, 11, 2, 14, 12, 19, 7, 4, 0]",366.1823928191615,"{'problem_type': 'PCTSP', 'num_nodes': 25, 'nodes': [{'id': 'A', 'x': 91, 'y': 54, 'prize': 0, 'penalty': 0}, {'id': 'B', 'x': 1, 'y': 100, 'prize': 94, 'penalty': 26}, {'id': 'C', 'x': 57, 'y': 43, 'prize': 21, 'penalty': 15}, {'id': 'D', 'x': 26, 'y': 77, 'prize': 96, 'penalty': 14}, {'id': 'E', 'x': 85, 'y': 17, 'prize': 61, 'penalty': 26}, {'id': 'F', 'x': 73, 'y': 84, 'prize': 54, 'penalty': 16}, {'id': 'G', 'x': 66, 'y': 67, 'prize': 16, 'penalty': 7}, {'id': 'H', 'x': 93, 'y': 0, 'prize': 34, 'penalty': 20}, {'id': 'I', 'x': 0, 'y': 7, 'prize': 97, 'penalty': 14}, {'id': 'J', 'x': 42, 'y': 13, 'prize': 17, 'penalty': 24}, {'id': 'K', 'x': 9, 'y': 49, 'prize': 72, 'penalty': 2}, {'id': 'L', 'x': 45, 'y': 40, 'prize': 45, 'penalty': 27}, {'id': 'M', 'x': 72, 'y': 14, 'prize': 29, 'penalty': 24}, {'id': 'N', 'x': 68, 'y': 74, 'prize': 17, 'penalty': 10}, {'id': 'O', 'x': 73, 'y': 23, 'prize': 88, 'penalty': 22}, {'id': 'P', 'x': 81, 'y': 92, 'prize': 95, 'penalty': 26}, {'id': 'Q', 'x': 54, 'y': 57, 'prize': 9, 'penalty': 24}, {'id': 'R', 'x': 36, 'y': 63, 'prize': 25, 'penalty': 4}, {'id': 'S', 'x': 92, 'y': 58, 'prize': 25, 'penalty': 17}, {'id': 'T', 'x': 90, 'y': 2, 'prize': 84, 'penalty': 12}, {'id': 'U', 'x': 14, 'y': 99, 'prize': 54, 'penalty': 23}, {'id': 'V', 'x': 74, 'y': 85, 'prize': 16, 'penalty': 11}, {'id': 'W', 'x': 80, 'y': 69, 'prize': 69, 'penalty': 12}, {'id': 'X', 'x': 78, 'y': 0, 'prize': 50, 'penalty': 4}, {'id': 'Y', 'x': 100, 'y': 80, 'prize': 63, 'penalty': 24}], 'depot': 'A', 'required_prize': 625.0, 'route_prize': 657.0, 'unvisited_penalty': 123.0, 'route_length': 243.18243393955834, 'objective': 366.1823928191615}","['A', 'S', 'Y', 'P', 'V', 'F', 'N', 'G', 'Q', 'L', 'C', 'O', 'M', 'T', 'H', 'E', 'A']",49,nl,names
PCTSP,PCTSP,"There’s a yard crew trying to decide on one neat route that departs the yard, visits selected streetlights, and returns, making sure the sum of the service value from visited lights meets the required threshold while keeping the overall expense — driving cost plus the costs of leaving lights unserviced — as low as it can be. The trip must be a single loop with no double-counting of the same light, and the concrete details follow below.

They consider 16 locations including yard 0, and they must collect at least 400.0 service value on that single loop:

| light_id | x_coord | y_coord | service_value | unserviced_penalty |
|---|---|---|---|---|
| 0 | 7 | 50 | 0 | 0 |
| 1 | 0 | 67 | 81 | 20 |
| 2 | 2 | 80 | 60 | 28 |
| 3 | 3 | 100 | 46 | 21 |
| 4 | 53 | 0 | 73 | 9 |
| 5 | 21 | 1 | 41 | 13 |
| 6 | 90 | 3 | 63 | 13 |
| 7 | 79 | 17 | 9 | 11 |
| 8 | 28 | 29 | 11 | 24 |
| 9 | 46 | 54 | 99 | 31 |
| 10 | 100 | 56 | 65 | 23 |
| 11 | 51 | 60 | 46 | 13 |
| 12 | 21 | 70 | 60 | 25 |
| 13 | 57 | 74 | 87 | 1 |
| 14 | 18 | 86 | 68 | 32 |
| 15 | 47 | 97 | 95 | 10 |

These entries describe each of the 16 locations around yard 0 so the crew can plan a single closed loop reaching 400.0 service value.

Oh, and when you send the route back, just stick to this little JSON shape so it's easy to check:

{
  ""solution"": [yard_id, light_id, ..., yard_id]
}

Think of that as a simple form: ""solution"" holds the ordered loop — first the yard, then the streetlights you plan to visit in order, and then the yard again to close the loop. The placeholders like yard_id and light_id are just showing the shape; they're not the actual IDs you should use.

Please use the exact identifiers from the instance input — do not rename them or invent new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'coordinates': [[7, 50], [0, 67], [2, 80], [3, 100], [53, 0], [21, 1], [90, 3], [79, 17], [28, 29], [46, 54], [100, 56], [51, 60], [21, 70], [57, 74], [18, 86], [47, 97]], 'prizes': [0, 81, 60, 46, 73, 41, 63, 9, 11, 99, 65, 46, 60, 87, 68, 95], 'penalties': [0, 20, 28, 21, 9, 13, 13, 11, 24, 31, 23, 13, 25, 1, 32, 10], 'required_prize': 400.0, 'depot': 0, 'route_length': 164.84190552447507, 'route_prize': 425.0, 'unvisited_penalty': 101.0, 'objective': 265.84190552447507}","[0, 8, 9, 11, 12, 14, 2, 1, 0]",265.84190552447507,"{'problem_type': 'PCTSP', 'num_nodes': 16, 'nodes': [{'id': 0, 'x': 7, 'y': 50, 'prize': 0, 'penalty': 0}, {'id': 1, 'x': 0, 'y': 67, 'prize': 81, 'penalty': 20}, {'id': 2, 'x': 2, 'y': 80, 'prize': 60, 'penalty': 28}, {'id': 3, 'x': 3, 'y': 100, 'prize': 46, 'penalty': 21}, {'id': 4, 'x': 53, 'y': 0, 'prize': 73, 'penalty': 9}, {'id': 5, 'x': 21, 'y': 1, 'prize': 41, 'penalty': 13}, {'id': 6, 'x': 90, 'y': 3, 'prize': 63, 'penalty': 13}, {'id': 7, 'x': 79, 'y': 17, 'prize': 9, 'penalty': 11}, {'id': 8, 'x': 28, 'y': 29, 'prize': 11, 'penalty': 24}, {'id': 9, 'x': 46, 'y': 54, 'prize': 99, 'penalty': 31}, {'id': 10, 'x': 100, 'y': 56, 'prize': 65, 'penalty': 23}, {'id': 11, 'x': 51, 'y': 60, 'prize': 46, 'penalty': 13}, {'id': 12, 'x': 21, 'y': 70, 'prize': 60, 'penalty': 25}, {'id': 13, 'x': 57, 'y': 74, 'prize': 87, 'penalty': 1}, {'id': 14, 'x': 18, 'y': 86, 'prize': 68, 'penalty': 32}, {'id': 15, 'x': 47, 'y': 97, 'prize': 95, 'penalty': 10}], 'depot': 0, 'required_prize': 400.0, 'route_prize': 425.0, 'unvisited_penalty': 101.0, 'route_length': 164.84190552447507, 'objective': 265.84190552447507}","[0, 8, 9, 11, 12, 14, 2, 1, 0]",50,markdown_table,0