TOP/TOP_M_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
TOP,TOP,"I run the delivery planning side of things, figuring out which stops each van should make so every vehicle leaves from and comes back to the central depot. The job is to pick a single loop for each vehicle that stays within that vehicle’s allowed distance, make sure no customer gets visited more than once, and try to collect as much order value as possible — the better plan is simply the one that adds up to the highest total of the order values at the stops we actually visit. The exact stops, distances and order values are shown below.

{
  ""total_locations_including_depot"": 11,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coord"": 90,
      ""y_coord"": 90,
      ""order_value"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coord"": 98,
      ""y_coord"": 0,
      ""order_value"": 61
    },
    {
      ""location_id"": ""C"",
      ""x_coord"": 100,
      ""y_coord"": 69,
      ""order_value"": 13
    },
    {
      ""location_id"": ""D"",
      ""x_coord"": 18,
      ""y_coord"": 100,
      ""order_value"": 24
    },
    {
      ""location_id"": ""E"",
      ""x_coord"": 52,
      ""y_coord"": 98,
      ""order_value"": 33
    },
    {
      ""location_id"": ""F"",
      ""x_coord"": 65,
      ""y_coord"": 8,
      ""order_value"": 86
    },
    {
      ""location_id"": ""G"",
      ""x_coord"": 0,
      ""y_coord"": 10,
      ""order_value"": 67
    },
    {
      ""location_id"": ""H"",
      ""x_coord"": 53,
      ""y_coord"": 86,
      ""order_value"": 54
    },
    {
      ""location_id"": ""I"",
      ""x_coord"": 99,
      ""y_coord"": 44,
      ""order_value"": 3
    },
    {
      ""location_id"": ""J"",
      ""x_coord"": 65,
      ""y_coord"": 99,
      ""order_value"": 73
    },
    {
      ""location_id"": ""K"",
      ""x_coord"": 14,
      ""y_coord"": 51,
      ""order_value"": 39
    }
  ],
  ""depot_node_id"": ""A"",
  ""max_route_length_per_vehicle"": 194.0,
  ""fleet_size"": 2
}

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

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

This just means: ""solution"" holds a list of loops (one per vehicle), each loop is a list of stop identifiers that starts and ends with the depot. It's just a sketch of the shape I need — not the real answer yet, just the format to follow.

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': [[90, 90], [98, 0], [100, 69], [18, 100], [52, 98], [65, 8], [0, 10], [53, 86], [99, 44], [65, 99], [14, 51]], 'prizes': [0, 61, 13, 24, 33, 86, 67, 54, 3, 73, 39], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 8, 5, 2, 0], [0, 7, 10, 4, 9, 0]], 'total_route_length': 379.6440472076635, 'collected_prize': 301.0, 'objective': 301.0}","[[0, 8, 5, 2, 0], [0, 7, 10, 4, 9, 0]]",301.0,"{'problem_type': 'TOP', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 90, 'y': 90, 'prize': 0}, {'id': 'B', 'x': 98, 'y': 0, 'prize': 61}, {'id': 'C', 'x': 100, 'y': 69, 'prize': 13}, {'id': 'D', 'x': 18, 'y': 100, 'prize': 24}, {'id': 'E', 'x': 52, 'y': 98, 'prize': 33}, {'id': 'F', 'x': 65, 'y': 8, 'prize': 86}, {'id': 'G', 'x': 0, 'y': 10, 'prize': 67}, {'id': 'H', 'x': 53, 'y': 86, 'prize': 54}, {'id': 'I', 'x': 99, 'y': 44, 'prize': 3}, {'id': 'J', 'x': 65, 'y': 99, 'prize': 73}, {'id': 'K', 'x': 14, 'y': 51, 'prize': 39}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 379.6440472076635, 'collected_prize': 301.0, 'objective': 301.0}","[['A', 'I', 'F', 'C', 'A'], ['A', 'H', 'K', 'E', 'J', 'A']]",1,json,names
TOP,TOP,"There’s this neat little operation where museum teams head out from the storage to bring mini-exhibits to neighborhood spots, then head back at the end of their shift. The job is to assign exhibits to each team and plan each team’s path so they don’t exceed their travel allowance. A plan is judged by how many satisfaction points it racks up in total — just add the point values of every stop all teams make — and every exhibit stop can only be used once across the whole set of tours. The exact numbers and stops are shown below.

# total_locations_including_storage=17
# museum_storage_node=1
# max_travel_budget_per_team=194.0
# n_teams=2
site_id,x_coord,y_coord,satisfaction_points
1,0,58,0
2,0,100,25
3,25,8,6
4,25,25,87
5,25,29,22
6,25,58,40
7,25,67,32
8,25,83,8
9,75,88,84
10,75,100,85
11,100,0,97
12,8,0,39
13,8,25,95
14,62,100,45
15,96,25,67
16,92,50,8
17,88,75,90

Oh — and if you want to hand the plan over in a tidy, machine-friendly way, you can use a small JSON snippet like this to show the routes:

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

This just means ""solution"" is a list of team routes; each inner list is one team's trip, starting at the storage (storage_id), visiting some neighborhood stops (spot_id) and coming back to the storage (storage_id). The dots are just standing in for ""and so on"" — it's a sketch of the shape I expect, not the actual plan.

Please be 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': [[0, 58], [0, 100], [25, 8], [25, 25], [25, 29], [25, 58], [25, 67], [25, 83], [75, 88], [75, 100], [100, 0], [8, 0], [8, 25], [62, 100], [96, 25], [92, 50], [88, 75]], 'prizes': [0, 25, 6, 87, 22, 40, 32, 8, 84, 85, 97, 39, 95, 45, 67, 8, 90], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 13, 9, 8, 7, 6, 0], [0, 5, 11, 2, 4, 3, 12, 0]], 'total_route_length': 372.89082038997503, 'collected_prize': 543.0, 'objective': 543.0}","[[0, 13, 9, 8, 7, 6, 0], [0, 5, 11, 2, 4, 3, 12, 0]]",543.0,"{'problem_type': 'TOP', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 0, 'y': 58, 'prize': 0}, {'id': 2, 'x': 0, 'y': 100, 'prize': 25}, {'id': 3, 'x': 25, 'y': 8, 'prize': 6}, {'id': 4, 'x': 25, 'y': 25, 'prize': 87}, {'id': 5, 'x': 25, 'y': 29, 'prize': 22}, {'id': 6, 'x': 25, 'y': 58, 'prize': 40}, {'id': 7, 'x': 25, 'y': 67, 'prize': 32}, {'id': 8, 'x': 25, 'y': 83, 'prize': 8}, {'id': 9, 'x': 75, 'y': 88, 'prize': 84}, {'id': 10, 'x': 75, 'y': 100, 'prize': 85}, {'id': 11, 'x': 100, 'y': 0, 'prize': 97}, {'id': 12, 'x': 8, 'y': 0, 'prize': 39}, {'id': 13, 'x': 8, 'y': 25, 'prize': 95}, {'id': 14, 'x': 62, 'y': 100, 'prize': 45}, {'id': 15, 'x': 96, 'y': 25, 'prize': 67}, {'id': 16, 'x': 92, 'y': 50, 'prize': 8}, {'id': 17, 'x': 88, 'y': 75, 'prize': 90}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 372.89082038997503, 'collected_prize': 543.0, 'objective': 543.0}","[[1, 14, 10, 9, 8, 7, 1], [1, 6, 12, 3, 5, 4, 13, 1]]",2,csv,1
TOP,TOP,"Someone needs to plan the crews’ daily runs so each team does one loop starting and ending at the maintenance yard and stays inside its allowed miles. No feature should be covered more than once, and the “best” set of runs is the one that collects the most importance points overall — just add up the importance numbers for every feature visited across all crews. The exact locations, mileage caps, and importance scores follow below.

# total_locations_including_yard=20
# maintenance_yard_id=A
# mileage_cap_per_run=194.0
# number_of_crews=2
feature_id,map_x_coordinate,map_y_coordinate,importance_score
A,97,8,0
B,0,44,26
C,29,100,1
D,65,86,54
E,21,87,48
F,65,48,64
G,67,94,98
H,100,9,91
I,88,94,91
J,99,68,53
K,100,86,10
L,99,5,18
M,79,45,95
N,17,20,41
O,24,69,87
P,7,0,67
Q,7,45,63
R,93,90,28
S,74,89,90
T,61,93,21

Oh, and a quick thing about how to send back the planned runs: keep it simple and use this JSON shape so I can read it automatically.

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

Think of this as a short form: ""solution"" is a list of loops (one per crew). Each inner list is the ordered sequence of identifiers visited on that loop, starting and ending with the maintenance yard (yard_id). The placeholders there are just showing the shape — replace them with the actual location IDs from the instance when you reply.

This JSON is only a sketch of the expected shape, not the real answer — please fill in the real identifiers from the instance exactly as given. 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': [[97, 8], [0, 44], [29, 100], [65, 86], [21, 87], [65, 48], [67, 94], [100, 9], [88, 94], [99, 68], [100, 86], [99, 5], [79, 45], [17, 20], [24, 69], [7, 0], [7, 45], [93, 90], [74, 89], [61, 93]], 'prizes': [0, 26, 1, 54, 48, 64, 98, 91, 91, 53, 10, 18, 95, 41, 87, 67, 63, 28, 90, 21], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 11, 7, 9, 10, 8, 17, 12, 0], [0, 18, 6, 3, 5, 0]], 'total_route_length': 384.1394526379171, 'collected_prize': 692.0, 'objective': 692.0}","[[0, 11, 7, 9, 10, 8, 17, 12, 0], [0, 18, 6, 3, 5, 0]]",692.0,"{'problem_type': 'TOP', 'num_nodes': 20, 'nodes': [{'id': 'A', 'x': 97, 'y': 8, 'prize': 0}, {'id': 'B', 'x': 0, 'y': 44, 'prize': 26}, {'id': 'C', 'x': 29, 'y': 100, 'prize': 1}, {'id': 'D', 'x': 65, 'y': 86, 'prize': 54}, {'id': 'E', 'x': 21, 'y': 87, 'prize': 48}, {'id': 'F', 'x': 65, 'y': 48, 'prize': 64}, {'id': 'G', 'x': 67, 'y': 94, 'prize': 98}, {'id': 'H', 'x': 100, 'y': 9, 'prize': 91}, {'id': 'I', 'x': 88, 'y': 94, 'prize': 91}, {'id': 'J', 'x': 99, 'y': 68, 'prize': 53}, {'id': 'K', 'x': 100, 'y': 86, 'prize': 10}, {'id': 'L', 'x': 99, 'y': 5, 'prize': 18}, {'id': 'M', 'x': 79, 'y': 45, 'prize': 95}, {'id': 'N', 'x': 17, 'y': 20, 'prize': 41}, {'id': 'O', 'x': 24, 'y': 69, 'prize': 87}, {'id': 'P', 'x': 7, 'y': 0, 'prize': 67}, {'id': 'Q', 'x': 7, 'y': 45, 'prize': 63}, {'id': 'R', 'x': 93, 'y': 90, 'prize': 28}, {'id': 'S', 'x': 74, 'y': 89, 'prize': 90}, {'id': 'T', 'x': 61, 'y': 93, 'prize': 21}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 384.1394526379171, 'collected_prize': 692.0, 'objective': 692.0}","[['A', 'L', 'H', 'J', 'K', 'I', 'R', 'M', 'A'], ['A', 'S', 'G', 'D', 'F', 'A']]",3,csv,names
TOP,TOP,"We’ve got a clinic and several vans to send out into town; every route must start and finish at the clinic, each driver gets one route that can’t be longer than the set limit, and no neighborhood site should be visited by more than one van. The goal is to pick which stops go on each van’s run so that the combined outreach — simply the sum of the impact numbers for all stops the vans cover — is as large as possible. The concrete details (sites, distances, van limits and impact values) are listed below.

# total_sites_including_clinic=16
# clinic_node_id=A
# max_route_distance_per_van=194.0
# num_vans_available=2
site_id,x_coordinate,y_coordinate,outreach_impact
A,2,3,0
B,2,15,99
C,0,28,74
D,2,42,45
E,0,85,56
F,5,99,41
G,2,99,73
H,93,100,40
I,95,0,67
J,98,15,70
K,100,28,61
L,100,52,54
M,98,55,21
N,98,70,20
O,95,82,80
P,100,96,29

Also, when you send back your plan, just use this simple JSON shape so I can read the routes programmatically:

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

Pretty straightforward: ""solution"" is a list of van routes; each route is an ordered list that starts and ends with the clinic (clinic_id) and lists the neighborhood stops (site_id) visited on that run. Think of it like filling out a form: one array per van, locations in the order you’ll visit them. This is just a sketch of the expected shape, not the actual answer — fill in the real IDs from the instance when you submit the routes.

Please use the identifiers exactly as they appear in 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': [[2, 3], [2, 15], [0, 28], [2, 42], [0, 85], [5, 99], [2, 99], [93, 100], [95, 0], [98, 15], [100, 28], [100, 52], [98, 55], [98, 70], [95, 82], [100, 96]], 'prizes': [0, 99, 74, 45, 56, 41, 73, 40, 67, 70, 61, 54, 21, 20, 80, 29], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 1, 4, 6, 3, 2, 0], [0, 9, 0]], 'total_route_length': 385.8868952146424, 'collected_prize': 417.0, 'objective': 417.0}","[[0, 1, 4, 6, 3, 2, 0], [0, 9, 0]]",417.0,"{'problem_type': 'TOP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 2, 'y': 3, 'prize': 0}, {'id': 'B', 'x': 2, 'y': 15, 'prize': 99}, {'id': 'C', 'x': 0, 'y': 28, 'prize': 74}, {'id': 'D', 'x': 2, 'y': 42, 'prize': 45}, {'id': 'E', 'x': 0, 'y': 85, 'prize': 56}, {'id': 'F', 'x': 5, 'y': 99, 'prize': 41}, {'id': 'G', 'x': 2, 'y': 99, 'prize': 73}, {'id': 'H', 'x': 93, 'y': 100, 'prize': 40}, {'id': 'I', 'x': 95, 'y': 0, 'prize': 67}, {'id': 'J', 'x': 98, 'y': 15, 'prize': 70}, {'id': 'K', 'x': 100, 'y': 28, 'prize': 61}, {'id': 'L', 'x': 100, 'y': 52, 'prize': 54}, {'id': 'M', 'x': 98, 'y': 55, 'prize': 21}, {'id': 'N', 'x': 98, 'y': 70, 'prize': 20}, {'id': 'O', 'x': 95, 'y': 82, 'prize': 80}, {'id': 'P', 'x': 100, 'y': 96, 'prize': 29}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 385.8868952146424, 'collected_prize': 417.0, 'objective': 417.0}","[['A', 'B', 'E', 'G', 'D', 'C', 'A'], ['A', 'J', 'A']]",4,csv,names
TOP,TOP,"Many people at the utility company are juggling repair calls; the idea is to send each team on a single loop from the depot, keep each loop within its travel cap, and cover the most urgent fixes. That means deciding which stops go on which team’s route so that, after adding up the urgency scores for all stops actually visited, the grand total is as large as possible. Each trip must return to the depot, no team gets a second run, and a repair site can’t be on more than one route. The specific instance details are below.

Instance details follow: 18 total locations (including depot 1); 2 repair teams available; each has a travel allowance of 194.0.
Location 1 at coordinates (0, 0) with urgency score 0.
Location 2 at coordinates (63, 60) with urgency score 30.
Location 3 at coordinates (56, 51) with urgency score 14.
Location 4 at coordinates (62, 34) with urgency score 40.
Location 5 at coordinates (46, 25) with urgency score 31.
Location 6 at coordinates (63, 25) with urgency score 24.
Location 7 at coordinates (57, 22) with urgency score 59.
Location 8 at coordinates (19, 16) with urgency score 25.
Location 9 at coordinates (28, 16) with urgency score 75.
Location 10 at coordinates (33, 16) with urgency score 72.
Location 11 at coordinates (5, 10) with urgency score 70.
Location 12 at coordinates (42, 7) with urgency score 10.
Location 13 at coordinates (15, 100) with urgency score 94.
Location 14 at coordinates (80, 5) with urgency score 50.
Location 15 at coordinates (100, 14) with urgency score 90.
Location 16 at coordinates (77, 58) with urgency score 20.
Location 17 at coordinates (90, 67) with urgency score 59.
Location 18 at coordinates (83, 100) with urgency score 97.
Assign stops to single-team loops so no route exceeds the travel allowance and each site is visited at most once.

Also, when you send the routes back, just toss them into this simple JSON layout so I can read them easily:

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

Think of ""solution"" as a list of loops one per team; each inner list is the ordered stops that loop back to the depot (so the first and last entry in each route should be the depot). This is just the shape I expect, not your final answer — fill it in with the actual stops from the instance.

Please use the exact identifiers given in the instance input — don't 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': [[0, 0], [63, 60], [56, 51], [62, 34], [46, 25], [63, 25], [57, 22], [19, 16], [28, 16], [33, 16], [5, 10], [42, 7], [15, 100], [80, 5], [100, 14], [77, 58], [90, 67], [83, 100]], 'prizes': [0, 30, 14, 40, 31, 24, 59, 25, 75, 72, 70, 10, 94, 50, 90, 20, 59, 97], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 7, 9, 4, 6, 1, 2, 0], [0, 8, 3, 5, 13, 11, 10, 0]], 'total_route_length': 384.0464873033209, 'collected_prize': 500.0, 'objective': 500.0}","[[0, 7, 9, 4, 6, 1, 2, 0], [0, 8, 3, 5, 13, 11, 10, 0]]",500.0,"{'problem_type': 'TOP', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'prize': 0}, {'id': 2, 'x': 63, 'y': 60, 'prize': 30}, {'id': 3, 'x': 56, 'y': 51, 'prize': 14}, {'id': 4, 'x': 62, 'y': 34, 'prize': 40}, {'id': 5, 'x': 46, 'y': 25, 'prize': 31}, {'id': 6, 'x': 63, 'y': 25, 'prize': 24}, {'id': 7, 'x': 57, 'y': 22, 'prize': 59}, {'id': 8, 'x': 19, 'y': 16, 'prize': 25}, {'id': 9, 'x': 28, 'y': 16, 'prize': 75}, {'id': 10, 'x': 33, 'y': 16, 'prize': 72}, {'id': 11, 'x': 5, 'y': 10, 'prize': 70}, {'id': 12, 'x': 42, 'y': 7, 'prize': 10}, {'id': 13, 'x': 15, 'y': 100, 'prize': 94}, {'id': 14, 'x': 80, 'y': 5, 'prize': 50}, {'id': 15, 'x': 100, 'y': 14, 'prize': 90}, {'id': 16, 'x': 77, 'y': 58, 'prize': 20}, {'id': 17, 'x': 90, 'y': 67, 'prize': 59}, {'id': 18, 'x': 83, 'y': 100, 'prize': 97}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 384.0464873033209, 'collected_prize': 500.0, 'objective': 500.0}","[[1, 8, 10, 5, 7, 2, 3, 1], [1, 9, 4, 6, 14, 12, 11, 1]]",5,nl,1
TOP,TOP,"Someone in charge is sketching shuttle routes so each volunteer drives a single loop out from and back to the festival hub without exceeding their allotted range. Each booth can only be visited once by the whole shuttle team, and the goal is to pick which booths to include on each loop so that the total sponsorship funds brought in — calculated by adding the sponsorship amounts of every visited booth — is as large as possible. The full breakdown of booths, values, and route limits appears below.

{
  ""total_locations_including_hub"": 15,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""map_x"": 9,
      ""map_y"": 2,
      ""sponsorship_amount"": 0
    },
    {
      ""location_id"": 1,
      ""map_x"": 0,
      ""map_y"": 31,
      ""sponsorship_amount"": 2
    },
    {
      ""location_id"": 2,
      ""map_x"": 0,
      ""map_y"": 35,
      ""sponsorship_amount"": 48
    },
    {
      ""location_id"": 3,
      ""map_x"": 16,
      ""map_y"": 100,
      ""sponsorship_amount"": 29
    },
    {
      ""location_id"": 4,
      ""map_x"": 23,
      ""map_y"": 94,
      ""sponsorship_amount"": 6
    },
    {
      ""location_id"": 5,
      ""map_x"": 38,
      ""map_y"": 5,
      ""sponsorship_amount"": 57
    },
    {
      ""location_id"": 6,
      ""map_x"": 41,
      ""map_y"": 28,
      ""sponsorship_amount"": 1
    },
    {
      ""location_id"": 7,
      ""map_x"": 84,
      ""map_y"": 0,
      ""sponsorship_amount"": 61
    },
    {
      ""location_id"": 8,
      ""map_x"": 89,
      ""map_y"": 20,
      ""sponsorship_amount"": 87
    },
    {
      ""location_id"": 9,
      ""map_x"": 70,
      ""map_y"": 20,
      ""sponsorship_amount"": 88
    },
    {
      ""location_id"": 10,
      ""map_x"": 75,
      ""map_y"": 25,
      ""sponsorship_amount"": 95
    },
    {
      ""location_id"": 11,
      ""map_x"": 100,
      ""map_y"": 94,
      ""sponsorship_amount"": 74
    },
    {
      ""location_id"": 12,
      ""map_x"": 100,
      ""map_y"": 85,
      ""sponsorship_amount"": 18
    },
    {
      ""location_id"": 13,
      ""map_x"": 92,
      ""map_y"": 35,
      ""sponsorship_amount"": 43
    },
    {
      ""location_id"": 14,
      ""map_x"": 93,
      ""map_y"": 12,
      ""sponsorship_amount"": 89
    }
  ],
  ""hub_node_id"": 0,
  ""max_route_length_per_shuttle"": 194.0,
  ""n_shuttles"": 2
}

When you're ready to hand me the chosen loops, just drop them into a little JSON sketch like this so it's easy to read and check.

{
  ""solution"": [[hub_id, booth_id, ... , hub_id], [hub_id, booth_id, ... , hub_id], ...]
}

Pretty simple: ""solution"" is a list of loops (one loop per shuttle driver), each loop is a list of IDs that starts and ends at the festival hub. hub_id is the placeholder for the depot/hub, booth_id stands for the booths visited along that loop, and the ""..."" just means ""any number of booths in between."" This is only the shape I need — not the actual routes.

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': [[9, 2], [0, 31], [0, 35], [16, 100], [23, 94], [38, 5], [41, 28], [84, 0], [89, 20], [70, 20], [75, 25], [100, 94], [100, 85], [92, 35], [93, 12]], 'prizes': [0, 2, 48, 29, 6, 57, 1, 61, 87, 88, 95, 74, 18, 43, 89], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 4, 2, 1, 0], [0, 5, 7, 14, 8, 10, 9, 6, 0]], 'total_route_length': 383.3695180079889, 'collected_prize': 534.0, 'objective': 534.0}","[[0, 4, 2, 1, 0], [0, 5, 7, 14, 8, 10, 9, 6, 0]]",534.0,"{'problem_type': 'TOP', 'num_nodes': 15, 'nodes': [{'id': 0, 'x': 9, 'y': 2, 'prize': 0}, {'id': 1, 'x': 0, 'y': 31, 'prize': 2}, {'id': 2, 'x': 0, 'y': 35, 'prize': 48}, {'id': 3, 'x': 16, 'y': 100, 'prize': 29}, {'id': 4, 'x': 23, 'y': 94, 'prize': 6}, {'id': 5, 'x': 38, 'y': 5, 'prize': 57}, {'id': 6, 'x': 41, 'y': 28, 'prize': 1}, {'id': 7, 'x': 84, 'y': 0, 'prize': 61}, {'id': 8, 'x': 89, 'y': 20, 'prize': 87}, {'id': 9, 'x': 70, 'y': 20, 'prize': 88}, {'id': 10, 'x': 75, 'y': 25, 'prize': 95}, {'id': 11, 'x': 100, 'y': 94, 'prize': 74}, {'id': 12, 'x': 100, 'y': 85, 'prize': 18}, {'id': 13, 'x': 92, 'y': 35, 'prize': 43}, {'id': 14, 'x': 93, 'y': 12, 'prize': 89}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 383.3695180079889, 'collected_prize': 534.0, 'objective': 534.0}","[[0, 4, 2, 1, 0], [0, 5, 7, 14, 8, 10, 9, 6, 0]]",6,json,0
TOP,TOP,"Someone on the operations team has to lay out inspection circuits so every drone flies a single, safe loop from the port and back and stays inside its allowed distance. The decision is which assets go on which drone’s circuit and the order to visit them, with the rule that a given inspection point can’t be checked by two different circuits. The better arrangement is the one that inspects assets whose condition scores add up to the largest number — that total is just the sum of the scores for the visited sites — all while keeping each loop within its flight range. The detailed instance information follows below.

The instance has 20 locations including the drone port 0; assign routes for 2 drones so each loop stays within 194.0.

| location_id | x_coordinate | y_coordinate | condition_score |
|---|---|---|---|
| 0 | 17 | 57 | 0 |
| 1 | 17 | 92 | 44 |
| 2 | 15 | 94 | 62 |
| 3 | 23 | 100 | 10 |
| 4 | 27 | 7 | 49 |
| 5 | 42 | 14 | 4 |
| 6 | 39 | 23 | 31 |
| 7 | 42 | 57 | 75 |
| 8 | 51 | 100 | 72 |
| 9 | 60 | 59 | 94 |
| 10 | 57 | 14 | 78 |
| 11 | 75 | 46 | 22 |
| 12 | 76 | 58 | 90 |
| 13 | 66 | 57 | 55 |
| 14 | 85 | 23 | 84 |
| 15 | 81 | 14 | 92 |
| 16 | 75 | 7 | 83 |
| 17 | 100 | 85 | 39 |
| 18 | 0 | 3 | 60 |
| 19 | 0 | 0 | 43 |

Ensure each inspection point is assigned to at most one circuit and maximize the total condition score of visited sites while keeping every loop within the drone range.

Also, when you send the answer back, just give the chosen loops in a little JSON object shaped like this:

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

Think of it like a simple form: ""solution"" holds a list of circuits, each circuit is a list that starts at the port (the depot), lists the inspection points in the order the drone will visit them, and ends back at the port. This snippet is only a sketch of the expected shape — not the actual routes.

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': [[17, 57], [17, 92], [15, 94], [23, 100], [27, 7], [42, 14], [39, 23], [42, 57], [51, 100], [60, 59], [57, 14], [75, 46], [76, 58], [66, 57], [85, 23], [81, 14], [75, 7], [100, 85], [0, 3], [0, 0]], 'prizes': [0, 44, 62, 10, 49, 4, 31, 75, 72, 94, 78, 22, 90, 55, 84, 92, 83, 39, 60, 43], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 1, 2, 3, 8, 12, 13, 0], [0, 7, 9, 11, 14, 15, 16, 10, 5, 6, 0]], 'total_route_length': 375.16113292884506, 'collected_prize': 896.0, 'objective': 896.0}","[[0, 1, 2, 3, 8, 12, 13, 0], [0, 7, 9, 11, 14, 15, 16, 10, 5, 6, 0]]",896.0,"{'problem_type': 'TOP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 17, 'y': 57, 'prize': 0}, {'id': 1, 'x': 17, 'y': 92, 'prize': 44}, {'id': 2, 'x': 15, 'y': 94, 'prize': 62}, {'id': 3, 'x': 23, 'y': 100, 'prize': 10}, {'id': 4, 'x': 27, 'y': 7, 'prize': 49}, {'id': 5, 'x': 42, 'y': 14, 'prize': 4}, {'id': 6, 'x': 39, 'y': 23, 'prize': 31}, {'id': 7, 'x': 42, 'y': 57, 'prize': 75}, {'id': 8, 'x': 51, 'y': 100, 'prize': 72}, {'id': 9, 'x': 60, 'y': 59, 'prize': 94}, {'id': 10, 'x': 57, 'y': 14, 'prize': 78}, {'id': 11, 'x': 75, 'y': 46, 'prize': 22}, {'id': 12, 'x': 76, 'y': 58, 'prize': 90}, {'id': 13, 'x': 66, 'y': 57, 'prize': 55}, {'id': 14, 'x': 85, 'y': 23, 'prize': 84}, {'id': 15, 'x': 81, 'y': 14, 'prize': 92}, {'id': 16, 'x': 75, 'y': 7, 'prize': 83}, {'id': 17, 'x': 100, 'y': 85, 'prize': 39}, {'id': 18, 'x': 0, 'y': 3, 'prize': 60}, {'id': 19, 'x': 0, 'y': 0, 'prize': 43}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 375.16113292884506, 'collected_prize': 896.0, 'objective': 896.0}","[[0, 1, 2, 3, 8, 12, 13, 0], [0, 7, 9, 11, 14, 15, 16, 10, 5, 6, 0]]",7,markdown_table,0
TOP,TOP,"Someone needs to put together the daily rounds: every worker gets a single route that begins and ends at the community center, must stay within their assigned distance cap, and no household can be on more than one worker’s list. The decision is which homes each worker will visit and in what sequence, aiming to collect as many engagement points as the team can. To check a plan, simply total the engagement points from every unique household visited; the plan with the highest total is preferred. The full, concrete details are shown below.

There are 17 mapped locations including the community center (id 0); 2 workers are available and each route must not exceed 194.0.
Location 0 is at (12, 5) and is worth 0 engagement points.
Location 1 is at (28, 8) and is worth 48 engagement points.
Location 2 is at (42, 21) and is worth 13 engagement points.
Location 3 is at (15, 34) and is worth 64 engagement points.
Location 4 is at (20, 37) and is worth 20 engagement points.
Location 5 is at (63, 40) and is worth 74 engagement points.
Location 6 is at (41, 68) and is worth 11 engagement points.
Location 7 is at (0, 78) and is worth 1 engagement points.
Location 8 is at (60, 100) and is worth 33 engagement points.
Location 9 is at (34, 10) and is worth 97 engagement points.
Location 10 is at (67, 21) and is worth 70 engagement points.
Location 11 is at (61, 14) and is worth 41 engagement points.
Location 12 is at (65, 13) and is worth 12 engagement points.
Location 13 is at (72, 0) and is worth 6 engagement points.
Location 14 is at (84, 34) and is worth 73 engagement points.
Location 15 is at (76, 84) and is worth 91 engagement points.
Location 16 is at (100, 39) and is worth 2 engagement points.
Total the engagement points from every unique household visited; the plan with the highest total is preferred.

Also, when you're ready to hand in a candidate plan, just drop it in this simple JSON shape so it's easy to read and check:

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

Think of it like a little form: ""solution"" is the whole day's schedule, each inner list is one worker's route, and every route should start and finish with the community center identifier (with the households visited in between). This is only a sketch of the shape I expect — fill it with the actual ids from the instance when you submit the real plan.

Please be sure to 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': [[12, 5], [28, 8], [42, 21], [15, 34], [20, 37], [63, 40], [41, 68], [0, 78], [60, 100], [34, 10], [67, 21], [61, 14], [65, 13], [72, 0], [84, 34], [76, 84], [100, 39]], 'prizes': [0, 48, 13, 64, 20, 74, 11, 1, 33, 97, 70, 41, 12, 6, 73, 91, 2], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 4, 3, 6, 5, 2, 9, 1, 0], [0, 10, 14, 12, 13, 11, 0]], 'total_route_length': 371.14064933541306, 'collected_prize': 529.0, 'objective': 529.0}","[[0, 4, 3, 6, 5, 2, 9, 1, 0], [0, 10, 14, 12, 13, 11, 0]]",529.0,"{'problem_type': 'TOP', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 12, 'y': 5, 'prize': 0}, {'id': 1, 'x': 28, 'y': 8, 'prize': 48}, {'id': 2, 'x': 42, 'y': 21, 'prize': 13}, {'id': 3, 'x': 15, 'y': 34, 'prize': 64}, {'id': 4, 'x': 20, 'y': 37, 'prize': 20}, {'id': 5, 'x': 63, 'y': 40, 'prize': 74}, {'id': 6, 'x': 41, 'y': 68, 'prize': 11}, {'id': 7, 'x': 0, 'y': 78, 'prize': 1}, {'id': 8, 'x': 60, 'y': 100, 'prize': 33}, {'id': 9, 'x': 34, 'y': 10, 'prize': 97}, {'id': 10, 'x': 67, 'y': 21, 'prize': 70}, {'id': 11, 'x': 61, 'y': 14, 'prize': 41}, {'id': 12, 'x': 65, 'y': 13, 'prize': 12}, {'id': 13, 'x': 72, 'y': 0, 'prize': 6}, {'id': 14, 'x': 84, 'y': 34, 'prize': 73}, {'id': 15, 'x': 76, 'y': 84, 'prize': 91}, {'id': 16, 'x': 100, 'y': 39, 'prize': 2}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 371.14064933541306, 'collected_prize': 529.0, 'objective': 529.0}","[[0, 4, 3, 6, 5, 2, 9, 1, 0], [0, 10, 14, 12, 13, 11, 0]]",8,nl,0
TOP,TOP,"Recently the region’s field schedule got reorganized: each salesperson gets exactly one route leaving from and coming back to the regional office, each route must respect that rep’s travel cap, and no prospect should be called on by more than one person. The plans that work best are the ones that collect the most potential revenue—just sum the revenue amounts for the prospects covered. The full list of prospects, their revenue estimates, and travel constraints is shown below.

There are 18 locations listed, with regional office id A; assign 2 single-return itineraries, each limited to 194.0 in travel.

| location_id | x_coord | y_coord | potential_revenue |
|---|---|---|---|
| A | 79 | 69 | 0 |
| B | 10 | 49 | 73 |
| C | 18 | 67 | 29 |
| D | 14 | 100 | 52 |
| E | 15 | 41 | 81 |
| F | 18 | 18 | 60 |
| G | 79 | 0 | 38 |
| H | 87 | 93 | 8 |
| I | 82 | 94 | 49 |
| J | 57 | 62 | 47 |
| K | 0 | 17 | 18 |
| L | 35 | 53 | 7 |
| M | 78 | 31 | 51 |
| N | 44 | 35 | 33 |
| O | 30 | 19 | 21 |
| P | 100 | 51 | 9 |
| Q | 70 | 26 | 84 |
| R | 77 | 62 | 36 |

Use these entries to choose stops that maximize summed potential revenue while keeping each route within 194.0 and returning to A.

Oh, and when you send the actual routes back, please use this simple JSON shape so I can read it easily:

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

""solution"" is a list of routes. Each inner list is one rep's route: it starts and ends with the office_id and the prospect_id entries are the prospects visited along the way (the ""..."" just means more stops if needed). This is just a sketch of the expected shape, 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': [[79, 69], [10, 49], [18, 67], [14, 100], [15, 41], [18, 18], [79, 0], [87, 93], [82, 94], [57, 62], [0, 17], [35, 53], [78, 31], [44, 35], [30, 19], [100, 51], [70, 26], [77, 62]], 'prizes': [0, 73, 29, 52, 81, 60, 38, 8, 49, 47, 18, 7, 51, 33, 21, 9, 84, 36], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 14, 5, 4, 1, 11, 9, 17, 0], [0, 8, 7, 15, 12, 16, 13, 0]], 'total_route_length': 380.7648767704127, 'collected_prize': 559.0, 'objective': 559.0}","[[0, 14, 5, 4, 1, 11, 9, 17, 0], [0, 8, 7, 15, 12, 16, 13, 0]]",559.0,"{'problem_type': 'TOP', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 79, 'y': 69, 'prize': 0}, {'id': 'B', 'x': 10, 'y': 49, 'prize': 73}, {'id': 'C', 'x': 18, 'y': 67, 'prize': 29}, {'id': 'D', 'x': 14, 'y': 100, 'prize': 52}, {'id': 'E', 'x': 15, 'y': 41, 'prize': 81}, {'id': 'F', 'x': 18, 'y': 18, 'prize': 60}, {'id': 'G', 'x': 79, 'y': 0, 'prize': 38}, {'id': 'H', 'x': 87, 'y': 93, 'prize': 8}, {'id': 'I', 'x': 82, 'y': 94, 'prize': 49}, {'id': 'J', 'x': 57, 'y': 62, 'prize': 47}, {'id': 'K', 'x': 0, 'y': 17, 'prize': 18}, {'id': 'L', 'x': 35, 'y': 53, 'prize': 7}, {'id': 'M', 'x': 78, 'y': 31, 'prize': 51}, {'id': 'N', 'x': 44, 'y': 35, 'prize': 33}, {'id': 'O', 'x': 30, 'y': 19, 'prize': 21}, {'id': 'P', 'x': 100, 'y': 51, 'prize': 9}, {'id': 'Q', 'x': 70, 'y': 26, 'prize': 84}, {'id': 'R', 'x': 77, 'y': 62, 'prize': 36}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 380.7648767704127, 'collected_prize': 559.0, 'objective': 559.0}","[['A', 'O', 'F', 'E', 'B', 'L', 'J', 'R', 'A'], ['A', 'I', 'H', 'P', 'M', 'Q', 'N', 'A']]",9,markdown_table,names
TOP,TOP,"In this neighborhood the recycling trucks must each run one trip out of the depot and back, keeping within their allowed travel budget, and each house or drop-off can only be served by a single truck. The job is to figure out which stops go on which truck’s path so that the combined weight of all collected material is maximized — just add up the weights from every stop that gets visited to see the total. The detailed data for the instance (locations, weights, and truck limits) are shown below.

There are 19 locations including the depot 0; each of the 2 trucks must run one route from and back to the depot that does not exceed 194.0.

| location_id | x_coordinate | y_coordinate | material_weight |
|---|---|---|---|
| 0 | 96 | 0 | 0 |
| 1 | 100 | 71 | 3 |
| 2 | 93 | 20 | 0 |
| 3 | 80 | 28 | 92 |
| 4 | 82 | 40 | 67 |
| 5 | 72 | 21 | 99 |
| 6 | 70 | 5 | 48 |
| 7 | 68 | 31 | 16 |
| 8 | 63 | 48 | 95 |
| 9 | 66 | 71 | 17 |
| 10 | 52 | 84 | 37 |
| 11 | 44 | 5 | 93 |
| 12 | 36 | 69 | 8 |
| 13 | 40 | 86 | 45 |
| 14 | 14 | 11 | 89 |
| 15 | 13 | 75 | 32 |
| 16 | 4 | 100 | 96 |
| 17 | 2 | 74 | 100 |
| 18 | 0 | 63 | 49 |

Plan routes for the 2 trucks to maximize total collected weight without exceeding 194.0 per route.

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

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

This little sketch means: ""solution"" is a list of trips (one per truck). Each trip is a list that starts and ends at the depot and has the visited stop identifiers in between. Treat depot_id and location_id as placeholders for the actual IDs from the instance — this is just the shape I want, not the final filled-in answer.

Please make sure you use the exact identifiers given in the instance input, with 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': [[96, 0], [100, 71], [93, 20], [80, 28], [82, 40], [72, 21], [70, 5], [68, 31], [63, 48], [66, 71], [52, 84], [44, 5], [36, 69], [40, 86], [14, 11], [13, 75], [4, 100], [2, 74], [0, 63]], 'prizes': [0, 3, 0, 92, 67, 99, 48, 16, 95, 17, 37, 93, 8, 45, 89, 32, 96, 100, 49], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 8, 9, 4, 5, 6, 0], [0, 3, 7, 14, 11, 0]], 'total_route_length': 365.4386649448741, 'collected_prize': 616.0, 'objective': 616.0}","[[0, 8, 9, 4, 5, 6, 0], [0, 3, 7, 14, 11, 0]]",616.0,"{'problem_type': 'TOP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 96, 'y': 0, 'prize': 0}, {'id': 1, 'x': 100, 'y': 71, 'prize': 3}, {'id': 2, 'x': 93, 'y': 20, 'prize': 0}, {'id': 3, 'x': 80, 'y': 28, 'prize': 92}, {'id': 4, 'x': 82, 'y': 40, 'prize': 67}, {'id': 5, 'x': 72, 'y': 21, 'prize': 99}, {'id': 6, 'x': 70, 'y': 5, 'prize': 48}, {'id': 7, 'x': 68, 'y': 31, 'prize': 16}, {'id': 8, 'x': 63, 'y': 48, 'prize': 95}, {'id': 9, 'x': 66, 'y': 71, 'prize': 17}, {'id': 10, 'x': 52, 'y': 84, 'prize': 37}, {'id': 11, 'x': 44, 'y': 5, 'prize': 93}, {'id': 12, 'x': 36, 'y': 69, 'prize': 8}, {'id': 13, 'x': 40, 'y': 86, 'prize': 45}, {'id': 14, 'x': 14, 'y': 11, 'prize': 89}, {'id': 15, 'x': 13, 'y': 75, 'prize': 32}, {'id': 16, 'x': 4, 'y': 100, 'prize': 96}, {'id': 17, 'x': 2, 'y': 74, 'prize': 100}, {'id': 18, 'x': 0, 'y': 63, 'prize': 49}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 365.4386649448741, 'collected_prize': 616.0, 'objective': 616.0}","[[0, 8, 9, 4, 5, 6, 0], [0, 3, 7, 14, 11, 0]]",10,markdown_table,0
TOP,TOP,"Someone at the parks department is mapping out single runs for each landscaping team, all leaving from and coming back to the equipment shed. The task: pick which gardens each team will hit on that one run, make sure each run stays within that team’s mileage cap, and don’t send two teams to the same garden. Plans are judged by how much overall quality they add to the gardens — add up the quality-improvement numbers for every garden visited to get the total, and higher totals are better. The concrete details are given below.

# num_locations_including_shed=14
# equipment_shed_id=1
# max_miles_per_run=194.0
# n_teams=2
location_id,x_coordinate,y_coordinate,quality_score_gain
1,98,18,0
2,42,80,97
3,18,29,100
4,65,0,45
5,38,87,4
6,100,58,45
7,64,9,71
8,57,11,63
9,68,52,67
10,31,38,97
11,58,100,66
12,40,63,9
13,0,24,59
14,28,3,21

Oh, and when you send back the actual routes, a little JSON snippet like this is easiest for me to read:

{
  ""solution"": [[shed_id, garden_id, ... , shed_id], [shed_id, garden_id, ... , shed_id], ...]
}

Each inner list is one team's run — a sequence of IDs starting and ending at the equipment shed, with the gardens visited in order. Think of it like filling in a simple form: one array per team, each array listing the shed, the gardens they'll hit, and the shed again at the end. This block is just a sketch of the shape I expect, not the final answer.

Please be 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': [[98, 18], [42, 80], [18, 29], [65, 0], [38, 87], [100, 58], [64, 9], [57, 11], [68, 52], [31, 38], [58, 100], [40, 63], [0, 24], [28, 3]], 'prizes': [0, 97, 100, 45, 4, 45, 71, 63, 67, 97, 66, 9, 59, 21], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 8, 1, 5, 0], [0, 6, 3, 7, 2, 9, 0]], 'total_route_length': 372.14940336352413, 'collected_prize': 585.0, 'objective': 585.0}","[[0, 8, 1, 5, 0], [0, 6, 3, 7, 2, 9, 0]]",585.0,"{'problem_type': 'TOP', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 98, 'y': 18, 'prize': 0}, {'id': 2, 'x': 42, 'y': 80, 'prize': 97}, {'id': 3, 'x': 18, 'y': 29, 'prize': 100}, {'id': 4, 'x': 65, 'y': 0, 'prize': 45}, {'id': 5, 'x': 38, 'y': 87, 'prize': 4}, {'id': 6, 'x': 100, 'y': 58, 'prize': 45}, {'id': 7, 'x': 64, 'y': 9, 'prize': 71}, {'id': 8, 'x': 57, 'y': 11, 'prize': 63}, {'id': 9, 'x': 68, 'y': 52, 'prize': 67}, {'id': 10, 'x': 31, 'y': 38, 'prize': 97}, {'id': 11, 'x': 58, 'y': 100, 'prize': 66}, {'id': 12, 'x': 40, 'y': 63, 'prize': 9}, {'id': 13, 'x': 0, 'y': 24, 'prize': 59}, {'id': 14, 'x': 28, 'y': 3, 'prize': 21}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 372.14940336352413, 'collected_prize': 585.0, 'objective': 585.0}","[[1, 9, 2, 6, 1], [1, 7, 4, 8, 3, 10, 1]]",11,csv,1
TOP,TOP,"A festival planner needs to draw routes for a fleet of tasting guides so each loop begins and ends at the starting kitchen and stays within the allowed travel distance. The question is which restaurants each guide should include to maximize the total tasting haul — that total is calculated by adding together the tasting values of all visited restaurants across the whole set of routes. Practical constraints to respect: each guide leads only one route, every route must return to the kitchen and not exceed its distance limit, and no restaurant may be visited more than once. The concrete details (locations, distances, tasting values) are shown below.

Instance summary: 18 locations including the starting kitchen (1); each route must stay within 194.0 distance and there are 2 guides available.
Location 1 at (0, 25) with tasting value 0.
Location 2 at (0, 75) with tasting value 35.
Location 3 at (0, 92) with tasting value 50.
Location 4 at (26, 8) with tasting value 70.
Location 5 at (26, 58) with tasting value 17.
Location 6 at (52, 17) with tasting value 60.
Location 7 at (13, 25) with tasting value 16.
Location 8 at (13, 100) with tasting value 83.
Location 9 at (30, 25) with tasting value 33.
Location 10 at (39, 25) with tasting value 55.
Location 11 at (43, 50) with tasting value 83.
Location 12 at (30, 75) with tasting value 97.
Location 13 at (74, 0) with tasting value 33.
Location 14 at (57, 50) with tasting value 9.
Location 15 at (57, 75) with tasting value 96.
Location 16 at (100, 0) with tasting value 99.
Location 17 at (96, 25) with tasting value 92.
Location 18 at (100, 25) with tasting value 85.
Use these records to assign each restaurant to at most one guide while respecting route limits and maximizing the total tasting value.

Also, when you send the routes back, a simple JSON layout like this works best — nothing fancy, just a list of loops for each guide:

{
  ""solution"": [[""kitchen_id"", ""restaurant_id"", ..., ""kitchen_id""], [""kitchen_id"", ""restaurant_id"", ..., ""kitchen_id""], ...]
}

This is just a sketch of the shape I expect: ""solution"" holds a list of routes, each route is an ordered list that starts and ends at the kitchen and has the restaurants visited in between. Treat ""kitchen_id"" and ""restaurant_id"" as placeholders for whatever exact identifiers the instance uses — don't fill in new labels here in the template.

Please make sure to 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': [[0, 25], [0, 75], [0, 92], [26, 8], [26, 58], [52, 17], [13, 25], [13, 100], [30, 25], [39, 25], [43, 50], [30, 75], [74, 0], [57, 50], [57, 75], [100, 0], [96, 25], [100, 25]], 'prizes': [0, 35, 50, 70, 17, 60, 16, 83, 33, 55, 83, 97, 33, 9, 96, 99, 92, 85], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 10, 14, 13, 9, 8, 3, 0], [0, 1, 7, 2, 11, 4, 6, 0]], 'total_route_length': 385.5837272849894, 'collected_prize': 644.0, 'objective': 644.0}","[[0, 10, 14, 13, 9, 8, 3, 0], [0, 1, 7, 2, 11, 4, 6, 0]]",644.0,"{'problem_type': 'TOP', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 0, 'y': 25, 'prize': 0}, {'id': 2, 'x': 0, 'y': 75, 'prize': 35}, {'id': 3, 'x': 0, 'y': 92, 'prize': 50}, {'id': 4, 'x': 26, 'y': 8, 'prize': 70}, {'id': 5, 'x': 26, 'y': 58, 'prize': 17}, {'id': 6, 'x': 52, 'y': 17, 'prize': 60}, {'id': 7, 'x': 13, 'y': 25, 'prize': 16}, {'id': 8, 'x': 13, 'y': 100, 'prize': 83}, {'id': 9, 'x': 30, 'y': 25, 'prize': 33}, {'id': 10, 'x': 39, 'y': 25, 'prize': 55}, {'id': 11, 'x': 43, 'y': 50, 'prize': 83}, {'id': 12, 'x': 30, 'y': 75, 'prize': 97}, {'id': 13, 'x': 74, 'y': 0, 'prize': 33}, {'id': 14, 'x': 57, 'y': 50, 'prize': 9}, {'id': 15, 'x': 57, 'y': 75, 'prize': 96}, {'id': 16, 'x': 100, 'y': 0, 'prize': 99}, {'id': 17, 'x': 96, 'y': 25, 'prize': 92}, {'id': 18, 'x': 100, 'y': 25, 'prize': 85}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 385.5837272849894, 'collected_prize': 644.0, 'objective': 644.0}","[[1, 11, 15, 14, 10, 9, 4, 1], [1, 2, 8, 3, 12, 5, 7, 1]]",12,nl,1
TOP,TOP,"There’s a daily juggling act at the exchange: assemble one closed circuit per technician, make sure it begins and ends at the exchange, and keep every circuit under that tech’s travel limit. Don’t send two crews to the same tower. The whole point is to visit towers whose priority numbers add up to the biggest total possible — the total service priority is just the sum of the priorities of all towers that actually get visited. The concrete instance data are listed below.

{
  ""total_sites_including_exchange"": 14,
  ""nodes"": [
    {
      ""site_id"": 0,
      ""x_coordinate"": 0,
      ""y_coordinate"": 55,
      ""service_priority_score"": 0
    },
    {
      ""site_id"": 1,
      ""x_coordinate"": 84,
      ""y_coordinate"": 100,
      ""service_priority_score"": 47
    },
    {
      ""site_id"": 2,
      ""x_coordinate"": 0,
      ""y_coordinate"": 42,
      ""service_priority_score"": 56
    },
    {
      ""site_id"": 3,
      ""x_coordinate"": 5,
      ""y_coordinate"": 38,
      ""service_priority_score"": 11
    },
    {
      ""site_id"": 4,
      ""x_coordinate"": 53,
      ""y_coordinate"": 47,
      ""service_priority_score"": 90
    },
    {
      ""site_id"": 5,
      ""x_coordinate"": 97,
      ""y_coordinate"": 70,
      ""service_priority_score"": 62
    },
    {
      ""site_id"": 6,
      ""x_coordinate"": 29,
      ""y_coordinate"": 20,
      ""service_priority_score"": 99
    },
    {
      ""site_id"": 7,
      ""x_coordinate"": 94,
      ""y_coordinate"": 79,
      ""service_priority_score"": 69
    },
    {
      ""site_id"": 8,
      ""x_coordinate"": 1,
      ""y_coordinate"": 62,
      ""service_priority_score"": 35
    },
    {
      ""site_id"": 9,
      ""x_coordinate"": 11,
      ""y_coordinate"": 28,
      ""service_priority_score"": 17
    },
    {
      ""site_id"": 10,
      ""x_coordinate"": 64,
      ""y_coordinate"": 45,
      ""service_priority_score"": 5
    },
    {
      ""site_id"": 11,
      ""x_coordinate"": 100,
      ""y_coordinate"": 0,
      ""service_priority_score"": 33
    },
    {
      ""site_id"": 12,
      ""x_coordinate"": 65,
      ""y_coordinate"": 76,
      ""service_priority_score"": 36
    },
    {
      ""site_id"": 13,
      ""x_coordinate"": 64,
      ""y_coordinate"": 65,
      ""service_priority_score"": 48
    }
  ],
  ""central_exchange_id"": 0,
  ""max_route_distance_per_technician"": 194.0,
  ""n_technicians"": 2
}

Also, when you send the actual routes back, just stick to this simple JSON shape so it’s easy to check:

{
  ""solution"": [[exchange_id, tower_id, ... , exchange_id], [exchange_id, tower_id, ... , exchange_id], ...]
}

Think of it like a little form: ""solution"" is a list of circuits, each circuit is the exchange identifier, then the towers you visit in order, and then the exchange identifier again to close the loop. It’s only a sketch of the shape I want, not the real answer — replace those placeholders with the actual routes for each technician.

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, 55], [84, 100], [0, 42], [5, 38], [53, 47], [97, 70], [29, 20], [94, 79], [1, 62], [11, 28], [64, 45], [100, 0], [65, 76], [64, 65]], 'prizes': [0, 47, 56, 11, 90, 62, 99, 69, 35, 17, 5, 33, 36, 48], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 2, 3, 9, 6, 4, 13, 12, 0], [0, 1, 8, 0]], 'total_route_length': 380.9866529406496, 'collected_prize': 439.0, 'objective': 439.0}","[[0, 2, 3, 9, 6, 4, 13, 12, 0], [0, 1, 8, 0]]",439.0,"{'problem_type': 'TOP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 0, 'y': 55, 'prize': 0}, {'id': 1, 'x': 84, 'y': 100, 'prize': 47}, {'id': 2, 'x': 0, 'y': 42, 'prize': 56}, {'id': 3, 'x': 5, 'y': 38, 'prize': 11}, {'id': 4, 'x': 53, 'y': 47, 'prize': 90}, {'id': 5, 'x': 97, 'y': 70, 'prize': 62}, {'id': 6, 'x': 29, 'y': 20, 'prize': 99}, {'id': 7, 'x': 94, 'y': 79, 'prize': 69}, {'id': 8, 'x': 1, 'y': 62, 'prize': 35}, {'id': 9, 'x': 11, 'y': 28, 'prize': 17}, {'id': 10, 'x': 64, 'y': 45, 'prize': 5}, {'id': 11, 'x': 100, 'y': 0, 'prize': 33}, {'id': 12, 'x': 65, 'y': 76, 'prize': 36}, {'id': 13, 'x': 64, 'y': 65, 'prize': 48}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 380.9866529406496, 'collected_prize': 439.0, 'objective': 439.0}","[[0, 2, 3, 9, 6, 4, 13, 12, 0], [0, 1, 8, 0]]",13,json,0
TOP,TOP,"Someone at the charity has to map out where each canvassing team will go: each team should head out from headquarters, do one loop and return, keep within that team’s travel cap, and make sure no house gets visited twice. The goal is to maximize the total money pledged by the households they actually reach — just sum the pledge numbers from every visited house to compare different plans. Remember, only one route per team, every route stays under its distance cap, and no household is duplicated. The specific team sizes, distance limits, and house pledge values appear below.

There are 15 locations including the headquarters (1); 2 teams are available and each must keep its route under 194.0.
Location 1 at (58, 67) with pledge 0.
Location 2 at (65, 72) with pledge 9.
Location 3 at (87, 0) with pledge 30.
Location 4 at (16, 2) with pledge 20.
Location 5 at (39, 76) with pledge 65.
Location 6 at (100, 93) with pledge 58.
Location 7 at (63, 53) with pledge 68.
Location 8 at (52, 100) with pledge 22.
Location 9 at (66, 67) with pledge 2.
Location 10 at (72, 4) with pledge 4.
Location 11 at (82, 23) with pledge 46.
Location 12 at (71, 6) with pledge 88.
Location 13 at (63, 35) with pledge 54.
Location 14 at (0, 83) with pledge 53.
Location 15 at (28, 97) with pledge 54.
Give each team exactly one loop from 1, respect the 194.0 cap, and maximize the sum of visited pledges.

Also, when you hand me the route plan, just pop it into this simple JSON layout so it's easy to parse:

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

Think of ""solution"" as a list of loops — each inner list is one team's route, starting and ending at the depot and listing the houses visited in between. It's just a sketch of the shape I want, not the actual answer.

Please use the exact identifiers from the instance input — don't rename anything 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': [[58, 67], [65, 72], [87, 0], [16, 2], [39, 76], [100, 93], [63, 53], [52, 100], [66, 67], [72, 4], [82, 23], [71, 6], [63, 35], [0, 83], [28, 97]], 'prizes': [0, 9, 30, 20, 65, 58, 68, 22, 2, 4, 46, 88, 54, 53, 54], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 5, 7, 14, 4, 0], [0, 8, 0]], 'total_route_length': 182.82119595223716, 'collected_prize': 500.0, 'objective': 500.0}","[[0, 5, 7, 14, 4, 0], [0, 8, 0]]",500.0,"{'problem_type': 'TOP', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 58, 'y': 67, 'prize': 0}, {'id': 2, 'x': 65, 'y': 72, 'prize': 9}, {'id': 3, 'x': 87, 'y': 0, 'prize': 30}, {'id': 4, 'x': 16, 'y': 2, 'prize': 20}, {'id': 5, 'x': 39, 'y': 76, 'prize': 65}, {'id': 6, 'x': 100, 'y': 93, 'prize': 58}, {'id': 7, 'x': 63, 'y': 53, 'prize': 68}, {'id': 8, 'x': 52, 'y': 100, 'prize': 22}, {'id': 9, 'x': 66, 'y': 67, 'prize': 2}, {'id': 10, 'x': 72, 'y': 4, 'prize': 4}, {'id': 11, 'x': 82, 'y': 23, 'prize': 46}, {'id': 12, 'x': 71, 'y': 6, 'prize': 88}, {'id': 13, 'x': 63, 'y': 35, 'prize': 54}, {'id': 14, 'x': 0, 'y': 83, 'prize': 53}, {'id': 15, 'x': 28, 'y': 97, 'prize': 54}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 182.82119595223716, 'collected_prize': 500.0, 'objective': 500.0}","[[1, 6, 8, 15, 5, 1], [1, 9, 1]]",14,nl,1
TOP,TOP,"I’m in charge of putting together the weekly rounds for the book vans: every route has to start and finish at the main library, each van gets just one route, and none of the pickup points can be visited more than once across all the vans. The goal is to pick which stops each van will make so the vans, together, bring in as many readership points as possible — the total is just the sum of the points assigned to every stop the vans actually visit. Each van’s route can’t run past its allowed travel distance, and the exact stops, distances and point values will be shown below.

Below I list 15 locations (including the main library at node 1), with coordinates and readership points; assign them among the 2 vans so each van's round trip stays within 194.0.
I list stop 1 at (69, 51) with 0 readership points.
I list stop 2 at (1, 22) with 89 readership points.
I list stop 3 at (0, 24) with 41 readership points.
I list stop 4 at (0, 26) with 82 readership points.
I list stop 5 at (0, 28) with 83 readership points.
I list stop 6 at (1, 28) with 59 readership points.
I list stop 7 at (0, 30) with 20 readership points.
I list stop 8 at (0, 100) with 78 readership points.
I list stop 9 at (100, 19) with 1 readership points.
I list stop 10 at (99, 21) with 5 readership points.
I list stop 11 at (0, 96) with 58 readership points.
I list stop 12 at (1, 16) with 25 readership points.
I list stop 13 at (99, 0) with 26 readership points.
I list stop 14 at (99, 14) with 4 readership points.
I list stop 15 at (100, 91) with 90 readership points.
I'll assign stops to the 2 vans to maximize total readership while keeping each route within 194.0.

Oh, and when you send the routes back, please use this simple JSON layout so I can pick them up programmatically:

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

The idea here is straightforward: ""solution"" is a list of routes (one list per van). Each inner list is the sequence of spot IDs that van will visit, starting and ending with the main library ID. The placeholders are just that — placeholders showing the expected shape, not the actual stops.

Quick reminder: 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': [[69, 51], [1, 22], [0, 24], [0, 26], [0, 28], [1, 28], [0, 30], [0, 100], [100, 19], [99, 21], [0, 96], [1, 16], [99, 0], [99, 14], [100, 91]], 'prizes': [0, 89, 41, 82, 83, 59, 20, 78, 1, 5, 58, 25, 26, 4, 90], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 3, 5, 4, 2, 6, 1, 11, 0], [0, 7, 10, 0]], 'total_route_length': 348.17223514644763, 'collected_prize': 535.0, 'objective': 535.0}","[[0, 3, 5, 4, 2, 6, 1, 11, 0], [0, 7, 10, 0]]",535.0,"{'problem_type': 'TOP', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 69, 'y': 51, 'prize': 0}, {'id': 2, 'x': 1, 'y': 22, 'prize': 89}, {'id': 3, 'x': 0, 'y': 24, 'prize': 41}, {'id': 4, 'x': 0, 'y': 26, 'prize': 82}, {'id': 5, 'x': 0, 'y': 28, 'prize': 83}, {'id': 6, 'x': 1, 'y': 28, 'prize': 59}, {'id': 7, 'x': 0, 'y': 30, 'prize': 20}, {'id': 8, 'x': 0, 'y': 100, 'prize': 78}, {'id': 9, 'x': 100, 'y': 19, 'prize': 1}, {'id': 10, 'x': 99, 'y': 21, 'prize': 5}, {'id': 11, 'x': 0, 'y': 96, 'prize': 58}, {'id': 12, 'x': 1, 'y': 16, 'prize': 25}, {'id': 13, 'x': 99, 'y': 0, 'prize': 26}, {'id': 14, 'x': 99, 'y': 14, 'prize': 4}, {'id': 15, 'x': 100, 'y': 91, 'prize': 90}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 348.17223514644763, 'collected_prize': 535.0, 'objective': 535.0}","[[1, 4, 6, 5, 3, 7, 2, 12, 1], [1, 8, 11, 1]]",15,nl,1
TOP,TOP,"We’ve got a neighborhood watch doing regular rounds from the local station, and the job is to map out who walks which loop. Each volunteer gets exactly one round, every round has to begin and finish at the station and stay under the distance limit, and streets shouldn’t be patrolled by more than one round. Plans are judged by the total safety coverage they achieve — add up the coverage scores of all the different blocks visited (count each block only once) — and the higher that sum, the better the plan. Concrete details are shown below.

# total_locations_including_station=15
# station_id=0
# max_patrol_distance_per_volunteer=194.0
# n_volunteers=2
block_id,x_coord,y_coord,safety_coverage_score
0,40,78,0
1,45,100,2
2,15,97,57
3,75,91,70
4,1,12,71
5,74,79,45
6,18,10,43
7,63,52,28
8,100,76,94
9,12,56,79
10,91,35,99
11,0,72,91
12,76,93,41
13,40,0,44
14,35,86,62

Also, when you send the patrol plan back, just put it in a little JSON snippet like this so it's easy to read and parse:

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

Think of it like a simple form: each inner list is one volunteer’s round (start at the station, visit a few blocks, and come back to the station). The placeholders here are just examples showing the shape I need — replace them with the actual IDs from the instance when you reply.

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': [[40, 78], [45, 100], [15, 97], [75, 91], [1, 12], [74, 79], [18, 10], [63, 52], [100, 76], [12, 56], [91, 35], [0, 72], [76, 93], [40, 0], [35, 86]], 'prizes': [0, 2, 57, 70, 71, 45, 43, 28, 94, 79, 99, 91, 41, 44, 62], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 4, 9, 11, 14, 0], [0, 5, 3, 12, 8, 10, 7, 0]], 'total_route_length': 376.29511064563235, 'collected_prize': 680.0, 'objective': 680.0}","[[0, 4, 9, 11, 14, 0], [0, 5, 3, 12, 8, 10, 7, 0]]",680.0,"{'problem_type': 'TOP', 'num_nodes': 15, 'nodes': [{'id': 0, 'x': 40, 'y': 78, 'prize': 0}, {'id': 1, 'x': 45, 'y': 100, 'prize': 2}, {'id': 2, 'x': 15, 'y': 97, 'prize': 57}, {'id': 3, 'x': 75, 'y': 91, 'prize': 70}, {'id': 4, 'x': 1, 'y': 12, 'prize': 71}, {'id': 5, 'x': 74, 'y': 79, 'prize': 45}, {'id': 6, 'x': 18, 'y': 10, 'prize': 43}, {'id': 7, 'x': 63, 'y': 52, 'prize': 28}, {'id': 8, 'x': 100, 'y': 76, 'prize': 94}, {'id': 9, 'x': 12, 'y': 56, 'prize': 79}, {'id': 10, 'x': 91, 'y': 35, 'prize': 99}, {'id': 11, 'x': 0, 'y': 72, 'prize': 91}, {'id': 12, 'x': 76, 'y': 93, 'prize': 41}, {'id': 13, 'x': 40, 'y': 0, 'prize': 44}, {'id': 14, 'x': 35, 'y': 86, 'prize': 62}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 376.29511064563235, 'collected_prize': 680.0, 'objective': 680.0}","[[0, 4, 9, 11, 14, 0], [0, 5, 3, 12, 8, 10, 7, 0]]",16,csv,0
TOP,TOP,"Someone needs to organize the inspection rounds: give each picker a single loop out from and back to the barn, keep every loop short enough so no one wanders too far, don’t send two pickers to the same tree group, and try to collect the most expected fruit value by choosing which groups to inspect. That “most” is measured by summing the expected harvests of all the tree groups that get visited. The detailed map and values are shown below.

The map lists 19 locations including the barn at node 0; assign 2 pickers and ensure each loop stays within 194.0 distance.
Tree group 0 is at (0, 62) with expected harvest 0.
Tree group 1 is at (25, 9) with expected harvest 3.
Tree group 2 is at (37, 100) with expected harvest 16.
Tree group 3 is at (74, 96) with expected harvest 56.
Tree group 4 is at (98, 66) with expected harvest 54.
Tree group 5 is at (59, 46) with expected harvest 97.
Tree group 6 is at (74, 42) with expected harvest 53.
Tree group 7 is at (84, 38) with expected harvest 67.
Tree group 8 is at (89, 38) with expected harvest 27.
Tree group 9 is at (93, 38) with expected harvest 39.
Tree group 10 is at (81, 30) with expected harvest 7.
Tree group 11 is at (100, 28) with expected harvest 44.
Tree group 12 is at (93, 28) with expected harvest 20.
Tree group 13 is at (96, 22) with expected harvest 6.
Tree group 14 is at (100, 20) with expected harvest 79.
Tree group 15 is at (85, 18) with expected harvest 14.
Tree group 16 is at (82, 13) with expected harvest 89.
Tree group 17 is at (94, 5) with expected harvest 18.
Tree group 18 is at (100, 0) with expected harvest 81.
Organize the picker loops accordingly.

Oh, and when you send back the chosen loops, please use a tiny JSON layout like this so it's easy to read and check:

{
  ""solution"": [[barn_id, tree_group_id, ... , barn_id], [barn_id, tree_group_id, ... , barn_id], ...]
}

This just means ""solution"" is a list of loops. Each inner list is one picker’s loop: it starts at the barn (barn_id), visits some tree groups (tree_group_id placeholders), and comes back to the barn. It’s just a sketch of the shape I need, not the actual answer.

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': [[0, 62], [25, 9], [37, 100], [74, 96], [98, 66], [59, 46], [74, 42], [84, 38], [89, 38], [93, 38], [81, 30], [100, 28], [93, 28], [96, 22], [100, 20], [85, 18], [82, 13], [94, 5], [100, 0]], 'prizes': [0, 3, 16, 56, 54, 97, 53, 67, 27, 39, 7, 44, 20, 6, 79, 14, 89, 18, 81], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 16, 0], [0, 5, 9, 8, 7, 6, 0]], 'total_route_length': 383.53463820210186, 'collected_prize': 372.0, 'objective': 372.0}","[[0, 16, 0], [0, 5, 9, 8, 7, 6, 0]]",372.0,"{'problem_type': 'TOP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 0, 'y': 62, 'prize': 0}, {'id': 1, 'x': 25, 'y': 9, 'prize': 3}, {'id': 2, 'x': 37, 'y': 100, 'prize': 16}, {'id': 3, 'x': 74, 'y': 96, 'prize': 56}, {'id': 4, 'x': 98, 'y': 66, 'prize': 54}, {'id': 5, 'x': 59, 'y': 46, 'prize': 97}, {'id': 6, 'x': 74, 'y': 42, 'prize': 53}, {'id': 7, 'x': 84, 'y': 38, 'prize': 67}, {'id': 8, 'x': 89, 'y': 38, 'prize': 27}, {'id': 9, 'x': 93, 'y': 38, 'prize': 39}, {'id': 10, 'x': 81, 'y': 30, 'prize': 7}, {'id': 11, 'x': 100, 'y': 28, 'prize': 44}, {'id': 12, 'x': 93, 'y': 28, 'prize': 20}, {'id': 13, 'x': 96, 'y': 22, 'prize': 6}, {'id': 14, 'x': 100, 'y': 20, 'prize': 79}, {'id': 15, 'x': 85, 'y': 18, 'prize': 14}, {'id': 16, 'x': 82, 'y': 13, 'prize': 89}, {'id': 17, 'x': 94, 'y': 5, 'prize': 18}, {'id': 18, 'x': 100, 'y': 0, 'prize': 81}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 383.53463820210186, 'collected_prize': 372.0, 'objective': 372.0}","[[0, 16, 0], [0, 5, 9, 8, 7, 6, 0]]",17,nl,0
TOP,TOP,"I picture a small crew of vending-machine attendants who all set out from the same supply warehouse, each doing one round trip that begins and ends at that warehouse. The job is to decide which attendant visits which machines so the combined resale cash they bring back is as big as possible — that total is simply the sum of the resale value of every machine that gets visited by any attendant. Every attendant only gets a single run, each run has to stay under a given distance/time limit, and no machine can be assigned to more than one attendant. The exact list of machines, their resale values, how many attendants there are, and the route length limit are shown below.

Below are the 12 locations (warehouse at node 1); there are 2 attendants and each attendant's round trip must not exceed 194.0.

| location_id | x_coord | y_coord | resale_value |
|---|---|---|---|
| 1 | 0 | 18 | 0 |
| 2 | 0 | 59 | 1 |
| 3 | 0 | 97 | 62 |
| 4 | 0 | 100 | 81 |
| 5 | 34 | 65 | 93 |
| 6 | 68 | 53 | 58 |
| 7 | 100 | 76 | 78 |
| 8 | 100 | 35 | 50 |
| 9 | 76 | 21 | 58 |
| 10 | 60 | 0 | 24 |
| 11 | 48 | 35 | 43 |
| 12 | 16 | 68 | 65 |

Assign each of the 2 attendants a single round trip so the sum of visited machines' resale values is maximized while no route exceeds 194.0.

Oh — and when you send back the actual routes, please follow a simple JSON layout like this:

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

This just means ""solution"" holds a list of routes; each route is a list that starts and ends at the warehouse and has the machines visited in order in between. It's just a sketch of the shape I expect, not the actual answer.

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': [[0, 18], [0, 59], [0, 97], [0, 100], [34, 65], [68, 53], [100, 76], [100, 35], [76, 21], [60, 0], [48, 35], [16, 68]], 'prizes': [0, 1, 62, 81, 93, 58, 78, 50, 58, 24, 43, 65], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 10, 5, 11, 0], [0, 1, 3, 2, 4, 0]], 'total_route_length': 374.1457019934172, 'collected_prize': 403.0, 'objective': 403.0}","[[0, 10, 5, 11, 0], [0, 1, 3, 2, 4, 0]]",403.0,"{'problem_type': 'TOP', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 0, 'y': 18, 'prize': 0}, {'id': 2, 'x': 0, 'y': 59, 'prize': 1}, {'id': 3, 'x': 0, 'y': 97, 'prize': 62}, {'id': 4, 'x': 0, 'y': 100, 'prize': 81}, {'id': 5, 'x': 34, 'y': 65, 'prize': 93}, {'id': 6, 'x': 68, 'y': 53, 'prize': 58}, {'id': 7, 'x': 100, 'y': 76, 'prize': 78}, {'id': 8, 'x': 100, 'y': 35, 'prize': 50}, {'id': 9, 'x': 76, 'y': 21, 'prize': 58}, {'id': 10, 'x': 60, 'y': 0, 'prize': 24}, {'id': 11, 'x': 48, 'y': 35, 'prize': 43}, {'id': 12, 'x': 16, 'y': 68, 'prize': 65}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 374.1457019934172, 'collected_prize': 403.0, 'objective': 403.0}","[[1, 11, 6, 12, 1], [1, 2, 4, 3, 5, 1]]",18,markdown_table,1
TOP,TOP,"Many people on the logistics team were focused on one thing: send each mobile unit out from the hub on a single loop, keep them within their travel caps, and make sure no testing site is checked by more than one crew. The aim is to pick stops so the total high-priority tests completed (just add the tests from every visited site) is maximized. Every team starts and finishes at the hub and only runs that one permitted route. The specifics for locations, team ranges, and priorities are listed below.

There are 12 total locations including the hub A; 2 mobile teams are available and each must run a single loop no longer than 194.0.
Site A at coordinates (100, 91) yields 0 high-priority tests if visited.
Site B at coordinates (27, 49) yields 44 high-priority tests if visited.
Site C at coordinates (2, 43) yields 94 high-priority tests if visited.
Site D at coordinates (0, 42) yields 11 high-priority tests if visited.
Site E at coordinates (76, 100) yields 40 high-priority tests if visited.
Site F at coordinates (40, 94) yields 79 high-priority tests if visited.
Site G at coordinates (9, 40) yields 10 high-priority tests if visited.
Site H at coordinates (74, 79) yields 55 high-priority tests if visited.
Site I at coordinates (16, 74) yields 35 high-priority tests if visited.
Site J at coordinates (33, 33) yields 53 high-priority tests if visited.
Site K at coordinates (98, 56) yields 33 high-priority tests if visited.
Site L at coordinates (20, 0) yields 8 high-priority tests if visited.
Assign each team a single hub-based loop, keeping every route within 194.0 and ensuring no site is visited more than once.

Also, when you send the routes back, just put them in this little JSON shape so it's easy to read and process:

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

Think of that as a simple form: ""solution"" holds a list of routes, each route is the sequence of stops (start at the depot, visit some sites, and return to the depot). This is just a sketch of the expected shape — not the actual answer.

Please make sure to use the exact identifiers from the instance input, without renaming or inventing new labels. To be clear: 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, 91], [27, 49], [2, 43], [0, 42], [76, 100], [40, 94], [9, 40], [74, 79], [16, 74], [33, 33], [98, 56], [20, 0]], 'prizes': [0, 44, 94, 11, 40, 79, 10, 55, 35, 53, 33, 8], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 9, 1, 0], [0, 7, 8, 5, 4, 0]], 'total_route_length': 370.1454572760447, 'collected_prize': 306.0, 'objective': 306.0}","[[0, 9, 1, 0], [0, 7, 8, 5, 4, 0]]",306.0,"{'problem_type': 'TOP', 'num_nodes': 12, 'nodes': [{'id': 'A', 'x': 100, 'y': 91, 'prize': 0}, {'id': 'B', 'x': 27, 'y': 49, 'prize': 44}, {'id': 'C', 'x': 2, 'y': 43, 'prize': 94}, {'id': 'D', 'x': 0, 'y': 42, 'prize': 11}, {'id': 'E', 'x': 76, 'y': 100, 'prize': 40}, {'id': 'F', 'x': 40, 'y': 94, 'prize': 79}, {'id': 'G', 'x': 9, 'y': 40, 'prize': 10}, {'id': 'H', 'x': 74, 'y': 79, 'prize': 55}, {'id': 'I', 'x': 16, 'y': 74, 'prize': 35}, {'id': 'J', 'x': 33, 'y': 33, 'prize': 53}, {'id': 'K', 'x': 98, 'y': 56, 'prize': 33}, {'id': 'L', 'x': 20, 'y': 0, 'prize': 8}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 370.1454572760447, 'collected_prize': 306.0, 'objective': 306.0}","[['A', 'J', 'B', 'A'], ['A', 'H', 'I', 'F', 'E', 'A']]",19,nl,names
TOP,TOP,"On the day of the fair the outreach coordinator wants tidy loops that all start and finish at the information tent so staff know exactly where they’ll go and how far they’ll walk. The choice is which booths to put on each of those single routes, keeping every route within its assigned distance cap and ensuring each booth is visited by at most one route. The aim is to maximize the total number of contacts collected across all routes, which is simply the sum of contacts from each visited booth. The concrete details — booths, contact estimates, and each staffer’s distance limit — are shown below.

{
  ""total_locations_including_tent"": 14,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""x_coordinate"": 0,
      ""y_coordinate"": 36,
      ""expected_contacts"": 0
    },
    {
      ""location_id"": 1,
      ""x_coordinate"": 0,
      ""y_coordinate"": 61,
      ""expected_contacts"": 98
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 0,
      ""y_coordinate"": 64,
      ""expected_contacts"": 43
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 4,
      ""y_coordinate"": 0,
      ""expected_contacts"": 71
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 4,
      ""y_coordinate"": 50,
      ""expected_contacts"": 42
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 4,
      ""y_coordinate"": 71,
      ""expected_contacts"": 76
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 33,
      ""y_coordinate"": 61,
      ""expected_contacts"": 80
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 48,
      ""y_coordinate"": 61,
      ""expected_contacts"": 31
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 67,
      ""y_coordinate"": 61,
      ""expected_contacts"": 4
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 93,
      ""y_coordinate"": 29,
      ""expected_contacts"": 100
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 100,
      ""y_coordinate"": 25,
      ""expected_contacts"": 70
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 43,
      ""y_coordinate"": 36,
      ""expected_contacts"": 72
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 60,
      ""y_coordinate"": 98,
      ""expected_contacts"": 65
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 78,
      ""y_coordinate"": 100,
      ""expected_contacts"": 7
    }
  ],
  ""info_tent_id"": 0,
  ""max_distance_per_staff"": 194.0,
  ""num_staffers"": 2
}

If you want to hand the routes over in a tidy, machine-friendly way, a simple JSON like this is perfect — one key called ""solution"" whose value is a list of routes (each route is a list that starts and ends at the info tent). For the story I'm using placeholders that match the same shape you should follow:

{
  ""solution"": [[tent_id, booth_id, ... , tent_id], [tent_id, booth_id, ... , tent_id], ...]
}

Each inner list is one staffer’s loop: the first and last entry are the information tent, and the things in between are the booths they’ll visit. 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 anything 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, 36], [0, 61], [0, 64], [4, 0], [4, 50], [4, 71], [33, 61], [48, 61], [67, 61], [93, 29], [100, 25], [43, 36], [60, 98], [78, 100]], 'prizes': [0, 98, 43, 71, 42, 76, 80, 31, 4, 100, 70, 72, 65, 7], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 6, 5, 2, 1, 4, 0], [0, 9, 11, 0]], 'total_route_length': 296.15407486167373, 'collected_prize': 582.0, 'objective': 582.0}","[[0, 6, 5, 2, 1, 4, 0], [0, 9, 11, 0]]",582.0,"{'problem_type': 'TOP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 0, 'y': 36, 'prize': 0}, {'id': 1, 'x': 0, 'y': 61, 'prize': 98}, {'id': 2, 'x': 0, 'y': 64, 'prize': 43}, {'id': 3, 'x': 4, 'y': 0, 'prize': 71}, {'id': 4, 'x': 4, 'y': 50, 'prize': 42}, {'id': 5, 'x': 4, 'y': 71, 'prize': 76}, {'id': 6, 'x': 33, 'y': 61, 'prize': 80}, {'id': 7, 'x': 48, 'y': 61, 'prize': 31}, {'id': 8, 'x': 67, 'y': 61, 'prize': 4}, {'id': 9, 'x': 93, 'y': 29, 'prize': 100}, {'id': 10, 'x': 100, 'y': 25, 'prize': 70}, {'id': 11, 'x': 43, 'y': 36, 'prize': 72}, {'id': 12, 'x': 60, 'y': 98, 'prize': 65}, {'id': 13, 'x': 78, 'y': 100, 'prize': 7}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 296.15407486167373, 'collected_prize': 582.0, 'objective': 582.0}","[[0, 6, 5, 2, 1, 4, 0], [0, 9, 11, 0]]",20,json,0
TOP,TOP,"In this role the planner must give every technician a route that leaves and returns to the shop within the given time cap, with the rule that each worksite can only be handled once that day. The objective is to collect as many importance points as possible across the whole crew — add up the importance numbers of the visited sites to get the total — while respecting the per‑route time limits and the one‑visit rule. The concrete details for the scenario (sites, their scores, number of techs, and route time limits) are shown below.

# total_locations_including_garage=14
# garage_node_id=0
# max_route_time_per_technician=194.0
# num_technicians=2
site_node_id,x_coordinate_meters,y_coordinate_meters,importance_points
0,0,52,0
1,3,58,49
2,13,37,81
3,11,0,98
4,23,20,58
5,44,100,9
6,60,100,35
7,69,100,94
8,68,85,66
9,86,44,43
10,75,100,96
11,94,30,75
12,90,21,16
13,100,95,14

Also, when you reply with the routes, just slip them into this JSON shape so it's easy to read and validate:

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

Here ""solution"" is a list of routes. Each route is a list of location identifiers in visit order that starts and ends at the shop (the depot). Think of it like a simple form: one array per technician, each array listing the sites they visit beginning and ending with the depot. This is only a sketch of the expected shape — not the actual answer.

Please make sure to use the exact identifiers from the instance input, with 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': [[0, 52], [3, 58], [13, 37], [11, 0], [23, 20], [44, 100], [60, 100], [69, 100], [68, 85], [86, 44], [75, 100], [94, 30], [90, 21], [100, 95]], 'prizes': [0, 49, 81, 98, 58, 9, 35, 94, 66, 43, 96, 75, 16, 14], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 3, 4, 0], [0, 8, 10, 7, 6, 5, 0]], 'total_route_length': 304.1352752979638, 'collected_prize': 586.0, 'objective': 586.0}","[[0, 3, 4, 0], [0, 8, 10, 7, 6, 5, 0]]",586.0,"{'problem_type': 'TOP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 0, 'y': 52, 'prize': 0}, {'id': 1, 'x': 3, 'y': 58, 'prize': 49}, {'id': 2, 'x': 13, 'y': 37, 'prize': 81}, {'id': 3, 'x': 11, 'y': 0, 'prize': 98}, {'id': 4, 'x': 23, 'y': 20, 'prize': 58}, {'id': 5, 'x': 44, 'y': 100, 'prize': 9}, {'id': 6, 'x': 60, 'y': 100, 'prize': 35}, {'id': 7, 'x': 69, 'y': 100, 'prize': 94}, {'id': 8, 'x': 68, 'y': 85, 'prize': 66}, {'id': 9, 'x': 86, 'y': 44, 'prize': 43}, {'id': 10, 'x': 75, 'y': 100, 'prize': 96}, {'id': 11, 'x': 94, 'y': 30, 'prize': 75}, {'id': 12, 'x': 90, 'y': 21, 'prize': 16}, {'id': 13, 'x': 100, 'y': 95, 'prize': 14}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 304.1352752979638, 'collected_prize': 586.0, 'objective': 586.0}","[[0, 3, 4, 0], [0, 8, 10, 7, 6, 5, 0]]",21,csv,0
TOP,TOP,"We’ve got several food trucks based at the commissary, and the task is to lay out a route for each truck that leaves from the commissary and comes back without going past that truck’s allowed driving range. The trick is to assign stops so every chosen stop is visited by exactly one truck at most, and the combined income from all visited stops is maximized — compute that combined income by adding up the revenue from each stop the trucks visit. Each truck gets one route, each route must meet its distance limit, and no stop can be doubled-up. The concrete details follow below.

We have 17 locations (commissary is A), 2 trucks in total, and each truck's round trip must not exceed 194.0.

| location_id | x_coordinate | y_coordinate | stop_revenue |
|---|---|---|---|
| A | 34 | 47 | 0 |
| B | 24 | 47 | 98 |
| C | 0 | 75 | 81 |
| D | 6 | 55 | 72 |
| E | 15 | 79 | 77 |
| F | 2 | 94 | 16 |
| G | 27 | 100 | 49 |
| H | 54 | 92 | 61 |
| I | 53 | 81 | 19 |
| J | 100 | 92 | 5 |
| K | 97 | 32 | 26 |
| L | 92 | 29 | 89 |
| M | 89 | 24 | 4 |
| N | 90 | 26 | 29 |
| O | 76 | 28 | 9 |
| P | 70 | 0 | 68 |
| Q | 40 | 18 | 25 |

We'll assign each stop to at most one truck and plan one route per truck so we maximize the total collected revenue.

Also, when you send the routes back, please use this simple JSON layout so it's clear and easy to read:

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

Think of it like a little form: ""solution"" is a list of routes, each inner list is one truck's path. The first and last entry in a route should be the commissary (that's the starting and ending placeholder), and the stops you visit go in the middle in the order the truck will visit them. The ""..."" just means you can have as many stops as fit the route. This JSON is just a sketch of the shape I want back — not the actual answer.

Please make sure every identifier you use is exactly the same as it appears in 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': [[34, 47], [24, 47], [0, 75], [6, 55], [15, 79], [2, 94], [27, 100], [54, 92], [53, 81], [100, 92], [97, 32], [92, 29], [89, 24], [90, 26], [76, 28], [70, 0], [40, 18]], 'prizes': [0, 98, 81, 72, 77, 16, 49, 61, 19, 5, 26, 89, 4, 29, 9, 68, 25], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 16, 15, 14, 13, 11, 10, 12, 0], [0, 1, 3, 4, 2, 5, 6, 7, 8, 0]], 'total_route_length': 381.5664166825849, 'collected_prize': 723.0, 'objective': 723.0}","[[0, 16, 15, 14, 13, 11, 10, 12, 0], [0, 1, 3, 4, 2, 5, 6, 7, 8, 0]]",723.0,"{'problem_type': 'TOP', 'num_nodes': 17, 'nodes': [{'id': 'A', 'x': 34, 'y': 47, 'prize': 0}, {'id': 'B', 'x': 24, 'y': 47, 'prize': 98}, {'id': 'C', 'x': 0, 'y': 75, 'prize': 81}, {'id': 'D', 'x': 6, 'y': 55, 'prize': 72}, {'id': 'E', 'x': 15, 'y': 79, 'prize': 77}, {'id': 'F', 'x': 2, 'y': 94, 'prize': 16}, {'id': 'G', 'x': 27, 'y': 100, 'prize': 49}, {'id': 'H', 'x': 54, 'y': 92, 'prize': 61}, {'id': 'I', 'x': 53, 'y': 81, 'prize': 19}, {'id': 'J', 'x': 100, 'y': 92, 'prize': 5}, {'id': 'K', 'x': 97, 'y': 32, 'prize': 26}, {'id': 'L', 'x': 92, 'y': 29, 'prize': 89}, {'id': 'M', 'x': 89, 'y': 24, 'prize': 4}, {'id': 'N', 'x': 90, 'y': 26, 'prize': 29}, {'id': 'O', 'x': 76, 'y': 28, 'prize': 9}, {'id': 'P', 'x': 70, 'y': 0, 'prize': 68}, {'id': 'Q', 'x': 40, 'y': 18, 'prize': 25}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 381.5664166825849, 'collected_prize': 723.0, 'objective': 723.0}","[['A', 'Q', 'P', 'O', 'N', 'L', 'K', 'M', 'A'], ['A', 'B', 'D', 'E', 'C', 'F', 'G', 'H', 'I', 'A']]",22,markdown_table,names
TOP,TOP,"I’m the regional sales manager juggling a crew of reps and a stack of client leads, and the daily job is to draw up routes so each rep leaves from and returns to the branch. The decision is which clients each rep should visit today, remembering that each rep has a fixed time allowance for their route and no client should get visited by more than one rep. A better plan is simply the one that brings in the biggest total expected sales — add up the expected sales from every client that actually gets visited across all routes — while still having every route start and end at the office and never exceed the time limit. The concrete details (who the reps are, their time limits, and each client’s expected sales and location) are shown below.

{
  ""total_locations_including_branch"": 12,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""coord_x"": 100,
      ""coord_y"": 16,
      ""expected_sales"": 0
    },
    {
      ""location_id"": 2,
      ""coord_x"": 68,
      ""coord_y"": 0,
      ""expected_sales"": 30
    },
    {
      ""location_id"": 3,
      ""coord_x"": 28,
      ""coord_y"": 3,
      ""expected_sales"": 88
    },
    {
      ""location_id"": 4,
      ""coord_x"": 50,
      ""coord_y"": 32,
      ""expected_sales"": 72
    },
    {
      ""location_id"": 5,
      ""coord_x"": 42,
      ""coord_y"": 43,
      ""expected_sales"": 20
    },
    {
      ""location_id"": 6,
      ""coord_x"": 84,
      ""coord_y"": 89,
      ""expected_sales"": 62
    },
    {
      ""location_id"": 7,
      ""coord_x"": 70,
      ""coord_y"": 92,
      ""expected_sales"": 14
    },
    {
      ""location_id"": 8,
      ""coord_x"": 49,
      ""coord_y"": 91,
      ""expected_sales"": 30
    },
    {
      ""location_id"": 9,
      ""coord_x"": 49,
      ""coord_y"": 100,
      ""expected_sales"": 36
    },
    {
      ""location_id"": 10,
      ""coord_x"": 8,
      ""coord_y"": 81,
      ""expected_sales"": 41
    },
    {
      ""location_id"": 11,
      ""coord_x"": 0,
      ""coord_y"": 81,
      ""expected_sales"": 94
    },
    {
      ""location_id"": 12,
      ""coord_x"": 11,
      ""coord_y"": 88,
      ""expected_sales"": 5
    }
  ],
  ""branch_office_id"": 1,
  ""time_allowance_per_rep"": 194.0,
  ""n_reps"": 2
}

Also, when you send the routes back, please use a simple JSON shape like this (just showing the structure so it's easy to copy):

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

Here ""solution"" is a list of routes; each inner list is one rep's route starting and ending at the office (office_id) and listing the clients visited in order (client_id). It's just a sketch of the expected shape — replace the placeholders with the actual route you choose.

Please be sure to use the exact identifiers from the instance input — no renaming, no made-up 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, 16], [68, 0], [28, 3], [50, 32], [42, 43], [84, 89], [70, 92], [49, 91], [49, 100], [8, 81], [0, 81], [11, 88]], 'prizes': [0, 30, 88, 72, 20, 62, 14, 30, 36, 41, 94, 5], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 3, 4, 2, 1, 0], [0, 5, 6, 0]], 'total_route_length': 355.12523107612805, 'collected_prize': 286.0, 'objective': 286.0}","[[0, 3, 4, 2, 1, 0], [0, 5, 6, 0]]",286.0,"{'problem_type': 'TOP', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 100, 'y': 16, 'prize': 0}, {'id': 2, 'x': 68, 'y': 0, 'prize': 30}, {'id': 3, 'x': 28, 'y': 3, 'prize': 88}, {'id': 4, 'x': 50, 'y': 32, 'prize': 72}, {'id': 5, 'x': 42, 'y': 43, 'prize': 20}, {'id': 6, 'x': 84, 'y': 89, 'prize': 62}, {'id': 7, 'x': 70, 'y': 92, 'prize': 14}, {'id': 8, 'x': 49, 'y': 91, 'prize': 30}, {'id': 9, 'x': 49, 'y': 100, 'prize': 36}, {'id': 10, 'x': 8, 'y': 81, 'prize': 41}, {'id': 11, 'x': 0, 'y': 81, 'prize': 94}, {'id': 12, 'x': 11, 'y': 88, 'prize': 5}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 355.12523107612805, 'collected_prize': 286.0, 'objective': 286.0}","[[1, 4, 5, 3, 2, 1], [1, 6, 7, 1]]",23,json,1
TOP,TOP,"Recently the security team decided to map out routes for multiple patrols: every run must originate and end at headquarters, and every vehicle has a maximum distance it can cover on its round. The choice at hand is which checkpoints each patrol should visit, making sure to avoid duplicate coverage of the same checkpoint. A plan is judged by how much security importance it collects overall — you calculate that by summing the importance scores of all checkpoints the patrols visit, and the higher that sum, the better the outcome. The detailed instance information follows below.

{
  ""total_locations_including_headquarters"": 13,
  ""nodes"": [
    {
      ""checkpoint_id"": 0,
      ""coord_x"": 64,
      ""coord_y"": 84,
      ""security_importance"": 0
    },
    {
      ""checkpoint_id"": 1,
      ""coord_x"": 5,
      ""coord_y"": 5,
      ""security_importance"": 63
    },
    {
      ""checkpoint_id"": 2,
      ""coord_x"": 0,
      ""coord_y"": 64,
      ""security_importance"": 82
    },
    {
      ""checkpoint_id"": 3,
      ""coord_x"": 51,
      ""coord_y"": 82,
      ""security_importance"": 26
    },
    {
      ""checkpoint_id"": 4,
      ""coord_x"": 95,
      ""coord_y"": 94,
      ""security_importance"": 2
    },
    {
      ""checkpoint_id"": 5,
      ""coord_x"": 89,
      ""coord_y"": 37,
      ""security_importance"": 8
    },
    {
      ""checkpoint_id"": 6,
      ""coord_x"": 62,
      ""coord_y"": 19,
      ""security_importance"": 8
    },
    {
      ""checkpoint_id"": 7,
      ""coord_x"": 42,
      ""coord_y"": 100,
      ""security_importance"": 17
    },
    {
      ""checkpoint_id"": 8,
      ""coord_x"": 42,
      ""coord_y"": 0,
      ""security_importance"": 17
    },
    {
      ""checkpoint_id"": 9,
      ""coord_x"": 100,
      ""coord_y"": 98,
      ""security_importance"": 69
    },
    {
      ""checkpoint_id"": 10,
      ""coord_x"": 92,
      ""coord_y"": 98,
      ""security_importance"": 67
    },
    {
      ""checkpoint_id"": 11,
      ""coord_x"": 50,
      ""coord_y"": 0,
      ""security_importance"": 3
    },
    {
      ""checkpoint_id"": 12,
      ""coord_x"": 20,
      ""coord_y"": 0,
      ""security_importance"": 56
    }
  ],
  ""headquarters_id"": 0,
  ""max_patrol_distance_per_vehicle"": 194.0,
  ""n_patrol_vehicles"": 2
}

Oh, and one more thing — when you send the patrol plan back, it's handy to follow a simple JSON shape so it's easy to read and check. For example:

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

This just means ""solution"" is a list of routes. Each inner list is one patrol's round: start at headquarters (hq_id), list the checkpoints to visit in order, and finish back at headquarters (hq_id). The ""..."" just shows you can have more stops; treat this as a form to fill in, not the final answers.

Please use the exact identifiers from the instance input — 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': [[64, 84], [5, 5], [0, 64], [51, 82], [95, 94], [89, 37], [62, 19], [42, 100], [42, 0], [100, 98], [92, 98], [50, 0], [20, 0]], 'prizes': [0, 63, 82, 26, 2, 8, 8, 17, 17, 69, 67, 3, 56], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 9, 4, 10, 5, 0], [0, 3, 0]], 'total_route_length': 190.64448550025514, 'collected_prize': 271.0, 'objective': 271.0}","[[0, 9, 4, 10, 5, 0], [0, 3, 0]]",271.0,"{'problem_type': 'TOP', 'num_nodes': 13, 'nodes': [{'id': 0, 'x': 64, 'y': 84, 'prize': 0}, {'id': 1, 'x': 5, 'y': 5, 'prize': 63}, {'id': 2, 'x': 0, 'y': 64, 'prize': 82}, {'id': 3, 'x': 51, 'y': 82, 'prize': 26}, {'id': 4, 'x': 95, 'y': 94, 'prize': 2}, {'id': 5, 'x': 89, 'y': 37, 'prize': 8}, {'id': 6, 'x': 62, 'y': 19, 'prize': 8}, {'id': 7, 'x': 42, 'y': 100, 'prize': 17}, {'id': 8, 'x': 42, 'y': 0, 'prize': 17}, {'id': 9, 'x': 100, 'y': 98, 'prize': 69}, {'id': 10, 'x': 92, 'y': 98, 'prize': 67}, {'id': 11, 'x': 50, 'y': 0, 'prize': 3}, {'id': 12, 'x': 20, 'y': 0, 'prize': 56}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 190.64448550025514, 'collected_prize': 271.0, 'objective': 271.0}","[[0, 9, 4, 10, 5, 0], [0, 3, 0]]",24,json,0
TOP,TOP,"Many couriers juggle several pickups in a day, so the conservation lab needs to assign who goes where: every courier will do a loop that begins and ends at the lab, and each loop must respect that courier’s travel allowance. The better the assignment, the higher the total insured value the team brings back — that total is just the sum of insured values for all collected artifacts. Also, each lending institution gets visited at most once across the whole plan, and no loop can exceed its allotted travel. Concrete details are provided below.

{
  ""total_locations_including_lab"": 19,
  ""nodes"": [
    {
      ""location_node_id"": 0,
      ""x_coordinate_map"": 61,
      ""y_coordinate_map"": 13,
      ""insured_value"": 0
    },
    {
      ""location_node_id"": 1,
      ""x_coordinate_map"": 82,
      ""y_coordinate_map"": 74,
      ""insured_value"": 57
    },
    {
      ""location_node_id"": 2,
      ""x_coordinate_map"": 3,
      ""y_coordinate_map"": 25,
      ""insured_value"": 43
    },
    {
      ""location_node_id"": 3,
      ""x_coordinate_map"": 9,
      ""y_coordinate_map"": 74,
      ""insured_value"": 15
    },
    {
      ""location_node_id"": 4,
      ""x_coordinate_map"": 0,
      ""y_coordinate_map"": 95,
      ""insured_value"": 64
    },
    {
      ""location_node_id"": 5,
      ""x_coordinate_map"": 12,
      ""y_coordinate_map"": 6,
      ""insured_value"": 39
    },
    {
      ""location_node_id"": 6,
      ""x_coordinate_map"": 48,
      ""y_coordinate_map"": 3,
      ""insured_value"": 30
    },
    {
      ""location_node_id"": 7,
      ""x_coordinate_map"": 93,
      ""y_coordinate_map"": 84,
      ""insured_value"": 12
    },
    {
      ""location_node_id"": 8,
      ""x_coordinate_map"": 39,
      ""y_coordinate_map"": 27,
      ""insured_value"": 30
    },
    {
      ""location_node_id"": 9,
      ""x_coordinate_map"": 2,
      ""y_coordinate_map"": 98,
      ""insured_value"": 17
    },
    {
      ""location_node_id"": 10,
      ""x_coordinate_map"": 16,
      ""y_coordinate_map"": 3,
      ""insured_value"": 35
    },
    {
      ""location_node_id"": 11,
      ""x_coordinate_map"": 47,
      ""y_coordinate_map"": 2,
      ""insured_value"": 19
    },
    {
      ""location_node_id"": 12,
      ""x_coordinate_map"": 70,
      ""y_coordinate_map"": 74,
      ""insured_value"": 66
    },
    {
      ""location_node_id"": 13,
      ""x_coordinate_map"": 43,
      ""y_coordinate_map"": 100,
      ""insured_value"": 82
    },
    {
      ""location_node_id"": 14,
      ""x_coordinate_map"": 45,
      ""y_coordinate_map"": 0,
      ""insured_value"": 76
    },
    {
      ""location_node_id"": 15,
      ""x_coordinate_map"": 34,
      ""y_coordinate_map"": 0,
      ""insured_value"": 42
    },
    {
      ""location_node_id"": 16,
      ""x_coordinate_map"": 100,
      ""y_coordinate_map"": 0,
      ""insured_value"": 24
    },
    {
      ""location_node_id"": 17,
      ""x_coordinate_map"": 76,
      ""y_coordinate_map"": 3,
      ""insured_value"": 57
    },
    {
      ""location_node_id"": 18,
      ""x_coordinate_map"": 26,
      ""y_coordinate_map"": 0,
      ""insured_value"": 90
    }
  ],
  ""lab_node_id"": 0,
  ""max_travel_allowance_per_courier"": 194.0,
  ""n_couriers"": 2
}

Also, when you send the plan back, just put it in this simple JSON shape so I can read it automatically:

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

This just means: ""solution"" is a list of loops (one per courier). Each inner list shows the loop in visit order, starting and ending at the lab (lab_id) with the institutions visited in between (institution_id). The little placeholders are just examples of the shape I expect — replace them with the actual IDs from the instance.

The JSON above is only a sketch of the shape I want, not the final answer.

Please make sure to use the exact identifiers from the problem instance — 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': [[61, 13], [82, 74], [3, 25], [9, 74], [0, 95], [12, 6], [48, 3], [93, 84], [39, 27], [2, 98], [16, 3], [47, 2], [70, 74], [43, 100], [45, 0], [34, 0], [100, 0], [76, 3], [26, 0]], 'prizes': [0, 57, 43, 15, 64, 39, 30, 12, 30, 17, 35, 19, 66, 82, 76, 42, 24, 57, 90], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 13, 12, 0], [0, 17, 0]], 'total_route_length': 224.0417597902596, 'collected_prize': 609.0, 'objective': 609.0}","[[0, 13, 12, 0], [0, 17, 0]]",609.0,"{'problem_type': 'TOP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 61, 'y': 13, 'prize': 0}, {'id': 1, 'x': 82, 'y': 74, 'prize': 57}, {'id': 2, 'x': 3, 'y': 25, 'prize': 43}, {'id': 3, 'x': 9, 'y': 74, 'prize': 15}, {'id': 4, 'x': 0, 'y': 95, 'prize': 64}, {'id': 5, 'x': 12, 'y': 6, 'prize': 39}, {'id': 6, 'x': 48, 'y': 3, 'prize': 30}, {'id': 7, 'x': 93, 'y': 84, 'prize': 12}, {'id': 8, 'x': 39, 'y': 27, 'prize': 30}, {'id': 9, 'x': 2, 'y': 98, 'prize': 17}, {'id': 10, 'x': 16, 'y': 3, 'prize': 35}, {'id': 11, 'x': 47, 'y': 2, 'prize': 19}, {'id': 12, 'x': 70, 'y': 74, 'prize': 66}, {'id': 13, 'x': 43, 'y': 100, 'prize': 82}, {'id': 14, 'x': 45, 'y': 0, 'prize': 76}, {'id': 15, 'x': 34, 'y': 0, 'prize': 42}, {'id': 16, 'x': 100, 'y': 0, 'prize': 24}, {'id': 17, 'x': 76, 'y': 3, 'prize': 57}, {'id': 18, 'x': 26, 'y': 0, 'prize': 90}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 224.0417597902596, 'collected_prize': 609.0, 'objective': 609.0}","[[0, 13, 12, 0], [0, 17, 0]]",25,json,0
TOP,TOP,"Many people rely on the bookmobiles, so the challenge is to assign one loop per vehicle that starts and finishes at headquarters, stays within that vehicle’s limit, and never duplicates a neighborhood across two routes. The goal is to maximize how many potential patrons are served, counting neighborhoods with greater need as worth more; calculate that by summing the patron counts at every stop after applying each neighborhood’s need weight. The full set of specifics is shown below.

# total_locations_including_depot=18
# headquarters_node=1
# max_route_length=194.0
# num_bookmobiles=2
location_id,x_coordinate,y_coordinate,weighted_patron_count
1,84,39,0
2,19,31,69
3,90,75,37
4,62,34,18
5,52,72,17
6,91,86,99
7,0,64,16
8,32,37,84
9,83,71,78
10,61,100,56
11,11,0,91
12,32,66,92
13,100,87,85
14,13,91,16
15,12,20,33
16,96,30,49
17,93,52,39
18,45,75,10

Also, when you give the routes back, just stick to this little JSON layout so it's easy to read and check:

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

This just means ""solution"" contains a list of loops — each loop is the sequence of stops for one vehicle, starting and ending at headquarters and listing the neighborhood identifiers in visit order. It's just a sketch of the shape I expect, not the actual route plan.

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': [[84, 39], [19, 31], [90, 75], [62, 34], [52, 72], [91, 86], [0, 64], [32, 37], [83, 71], [61, 100], [11, 0], [32, 66], [100, 87], [13, 91], [12, 20], [96, 30], [93, 52], [45, 75]], 'prizes': [0, 69, 37, 18, 17, 99, 16, 84, 78, 56, 91, 92, 85, 16, 33, 49, 39, 10], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 11, 17, 4, 5, 12, 2, 8, 16, 0], [0, 3, 14, 10, 1, 7, 0]], 'total_route_length': 386.35703176906094, 'collected_prize': 752.0, 'objective': 752.0}","[[0, 11, 17, 4, 5, 12, 2, 8, 16, 0], [0, 3, 14, 10, 1, 7, 0]]",752.0,"{'problem_type': 'TOP', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 84, 'y': 39, 'prize': 0}, {'id': 2, 'x': 19, 'y': 31, 'prize': 69}, {'id': 3, 'x': 90, 'y': 75, 'prize': 37}, {'id': 4, 'x': 62, 'y': 34, 'prize': 18}, {'id': 5, 'x': 52, 'y': 72, 'prize': 17}, {'id': 6, 'x': 91, 'y': 86, 'prize': 99}, {'id': 7, 'x': 0, 'y': 64, 'prize': 16}, {'id': 8, 'x': 32, 'y': 37, 'prize': 84}, {'id': 9, 'x': 83, 'y': 71, 'prize': 78}, {'id': 10, 'x': 61, 'y': 100, 'prize': 56}, {'id': 11, 'x': 11, 'y': 0, 'prize': 91}, {'id': 12, 'x': 32, 'y': 66, 'prize': 92}, {'id': 13, 'x': 100, 'y': 87, 'prize': 85}, {'id': 14, 'x': 13, 'y': 91, 'prize': 16}, {'id': 15, 'x': 12, 'y': 20, 'prize': 33}, {'id': 16, 'x': 96, 'y': 30, 'prize': 49}, {'id': 17, 'x': 93, 'y': 52, 'prize': 39}, {'id': 18, 'x': 45, 'y': 75, 'prize': 10}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 386.35703176906094, 'collected_prize': 752.0, 'objective': 752.0}","[[1, 12, 18, 5, 6, 13, 3, 9, 17, 1], [1, 4, 15, 11, 2, 8, 1]]",26,csv,1
TOP,TOP,"Many of the photographers need concise shooting plans: each route must begin and return to the media center, must fit into the photographer’s allowed time, and no venue should be duplicated across routes. What we’re after is the biggest total editorial return possible — simply add up the editorial values for all venues that get visited by anyone. See the concrete details below.

{
  ""total_locations_including_media_center"": 16,
  ""nodes"": [
    {
      ""venue_id"": 1,
      ""x_coordinate_on_event_map"": 18,
      ""y_coordinate_on_event_map"": 7,
      ""editorial_value"": 0
    },
    {
      ""venue_id"": 2,
      ""x_coordinate_on_event_map"": 84,
      ""y_coordinate_on_event_map"": 0,
      ""editorial_value"": 29
    },
    {
      ""venue_id"": 3,
      ""x_coordinate_on_event_map"": 98,
      ""y_coordinate_on_event_map"": 51,
      ""editorial_value"": 32
    },
    {
      ""venue_id"": 4,
      ""x_coordinate_on_event_map"": 100,
      ""y_coordinate_on_event_map"": 69,
      ""editorial_value"": 78
    },
    {
      ""venue_id"": 5,
      ""x_coordinate_on_event_map"": 97,
      ""y_coordinate_on_event_map"": 83,
      ""editorial_value"": 34
    },
    {
      ""venue_id"": 6,
      ""x_coordinate_on_event_map"": 62,
      ""y_coordinate_on_event_map"": 3,
      ""editorial_value"": 81
    },
    {
      ""venue_id"": 7,
      ""x_coordinate_on_event_map"": 54,
      ""y_coordinate_on_event_map"": 36,
      ""editorial_value"": 12
    },
    {
      ""venue_id"": 8,
      ""x_coordinate_on_event_map"": 97,
      ""y_coordinate_on_event_map"": 25,
      ""editorial_value"": 77
    },
    {
      ""venue_id"": 9,
      ""x_coordinate_on_event_map"": 80,
      ""y_coordinate_on_event_map"": 10,
      ""editorial_value"": 36
    },
    {
      ""venue_id"": 10,
      ""x_coordinate_on_event_map"": 46,
      ""y_coordinate_on_event_map"": 10,
      ""editorial_value"": 27
    },
    {
      ""venue_id"": 11,
      ""x_coordinate_on_event_map"": 33,
      ""y_coordinate_on_event_map"": 74,
      ""editorial_value"": 59
    },
    {
      ""venue_id"": 12,
      ""x_coordinate_on_event_map"": 18,
      ""y_coordinate_on_event_map"": 100,
      ""editorial_value"": 31
    },
    {
      ""venue_id"": 13,
      ""x_coordinate_on_event_map"": 80,
      ""y_coordinate_on_event_map"": 53,
      ""editorial_value"": 64
    },
    {
      ""venue_id"": 14,
      ""x_coordinate_on_event_map"": 84,
      ""y_coordinate_on_event_map"": 68,
      ""editorial_value"": 72
    },
    {
      ""venue_id"": 15,
      ""x_coordinate_on_event_map"": 0,
      ""y_coordinate_on_event_map"": 18,
      ""editorial_value"": 89
    },
    {
      ""venue_id"": 16,
      ""x_coordinate_on_event_map"": 23,
      ""y_coordinate_on_event_map"": 26,
      ""editorial_value"": 32
    }
  ],
  ""media_center_id"": 1,
  ""max_shift_time_per_photographer"": 194.0,
  ""n_photographers"": 2
}

If you want to hand me the routes, the easiest is a tiny JSON snippet like this — just a simple list of routes, each route being a list that starts and ends at the media center:

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

Pretty straightforward: ""solution"" is the list of photographer routes; each inner list is the order of stops for one photographer, starting and finishing at the media center (those placeholders are just examples). This is only a sketch of the shape I expect, not the actual answer — you'll replace the placeholders with the real IDs from the instance.

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': [[18, 7], [84, 0], [98, 51], [100, 69], [97, 83], [62, 3], [54, 36], [97, 25], [80, 10], [46, 10], [33, 74], [18, 100], [80, 53], [84, 68], [0, 18], [23, 26]], 'prizes': [0, 29, 32, 78, 34, 81, 12, 77, 36, 27, 59, 31, 64, 72, 89, 32], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 6, 12, 7, 0], [0, 14, 15, 9, 5, 1, 8, 0]], 'total_route_length': 377.0486989825751, 'collected_prize': 447.0, 'objective': 447.0}","[[0, 6, 12, 7, 0], [0, 14, 15, 9, 5, 1, 8, 0]]",447.0,"{'problem_type': 'TOP', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 18, 'y': 7, 'prize': 0}, {'id': 2, 'x': 84, 'y': 0, 'prize': 29}, {'id': 3, 'x': 98, 'y': 51, 'prize': 32}, {'id': 4, 'x': 100, 'y': 69, 'prize': 78}, {'id': 5, 'x': 97, 'y': 83, 'prize': 34}, {'id': 6, 'x': 62, 'y': 3, 'prize': 81}, {'id': 7, 'x': 54, 'y': 36, 'prize': 12}, {'id': 8, 'x': 97, 'y': 25, 'prize': 77}, {'id': 9, 'x': 80, 'y': 10, 'prize': 36}, {'id': 10, 'x': 46, 'y': 10, 'prize': 27}, {'id': 11, 'x': 33, 'y': 74, 'prize': 59}, {'id': 12, 'x': 18, 'y': 100, 'prize': 31}, {'id': 13, 'x': 80, 'y': 53, 'prize': 64}, {'id': 14, 'x': 84, 'y': 68, 'prize': 72}, {'id': 15, 'x': 0, 'y': 18, 'prize': 89}, {'id': 16, 'x': 23, 'y': 26, 'prize': 32}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 377.0486989825751, 'collected_prize': 447.0, 'objective': 447.0}","[[1, 7, 13, 8, 1], [1, 15, 16, 10, 6, 2, 9, 1]]",27,json,1
TOP,TOP,"I manage a small bike messenger crew and I’m trying to line up everyone’s rounds: each rider leaves from the hub, rides a route and comes back, and each stop on the map pays a delivery fee. The decision is which stops each messenger should hit so that no delivery gets handed off twice and no rider goes farther than their allowed distance. The better plan is the one that collects the biggest total of all those delivery fees — just add up the fees for every visited stop. Concrete details for the actual run will be shown below.

The run has 16 locations (hub A), 2 riders available, and each rider's round is limited to 194.0.
Stop A at (95, 54) pays 0.
Stop B at (0, 30) pays 99.
Stop C at (90, 66) pays 57.
Stop D at (76, 57) pays 37.
Stop E at (29, 51) pays 96.
Stop F at (40, 0) pays 81.
Stop G at (21, 75) pays 56.
Stop H at (81, 100) pays 68.
Stop I at (100, 92) pays 84.
Stop J at (98, 41) pays 29.
Stop K at (95, 69) pays 12.
Stop L at (2, 16) pays 52.
Stop M at (0, 11) pays 45.
Stop N at (26, 25) pays 19.
Stop O at (24, 15) pays 41.
Stop P at (7, 10) pays 50.
I'll use these details to choose which stops each rider should hit.

If you want to send me the plan, just use a simple JSON layout like this so I can read each rider’s route easily:

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

This just means ""solution"" is a list of routes. Each route is a list that starts at the hub (hub_id), goes through zero or more stops (stop_id) and comes back to the hub. Think of it like filling out a little form for each rider: the sequence is the order they’ll visit the stops and must begin and end at the hub. This block is only a sketch of the shape I need — not the actual plan itself.

Please make 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': [[95, 54], [0, 30], [90, 66], [76, 57], [29, 51], [40, 0], [21, 75], [81, 100], [100, 92], [98, 41], [95, 69], [2, 16], [0, 11], [26, 25], [24, 15], [7, 10]], 'prizes': [0, 99, 57, 37, 96, 81, 56, 68, 84, 29, 12, 52, 45, 19, 41, 50], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 9, 0], [0, 14, 13, 4, 0]], 'total_route_length': 210.1281910529933, 'collected_prize': 443.0, 'objective': 443.0}","[[0, 9, 0], [0, 14, 13, 4, 0]]",443.0,"{'problem_type': 'TOP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 95, 'y': 54, 'prize': 0}, {'id': 'B', 'x': 0, 'y': 30, 'prize': 99}, {'id': 'C', 'x': 90, 'y': 66, 'prize': 57}, {'id': 'D', 'x': 76, 'y': 57, 'prize': 37}, {'id': 'E', 'x': 29, 'y': 51, 'prize': 96}, {'id': 'F', 'x': 40, 'y': 0, 'prize': 81}, {'id': 'G', 'x': 21, 'y': 75, 'prize': 56}, {'id': 'H', 'x': 81, 'y': 100, 'prize': 68}, {'id': 'I', 'x': 100, 'y': 92, 'prize': 84}, {'id': 'J', 'x': 98, 'y': 41, 'prize': 29}, {'id': 'K', 'x': 95, 'y': 69, 'prize': 12}, {'id': 'L', 'x': 2, 'y': 16, 'prize': 52}, {'id': 'M', 'x': 0, 'y': 11, 'prize': 45}, {'id': 'N', 'x': 26, 'y': 25, 'prize': 19}, {'id': 'O', 'x': 24, 'y': 15, 'prize': 41}, {'id': 'P', 'x': 7, 'y': 10, 'prize': 50}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 210.1281910529933, 'collected_prize': 443.0, 'objective': 443.0}","[['A', 'J', 'A'], ['A', 'O', 'N', 'E', 'A']]",28,nl,names
TOP,TOP,"We need to plan a set of patrol routes that all leave from and return to the ranger station, keep each route under the maximum allowed distance, and make sure no survey site gets visited twice by different teams; the point is to choose which sites each team covers so the sum of the conservation priority points from every distinct site visited is as large as it can be. The specific site locations, distances, team numbers, and priority scores are listed below.

We have 11 locations in total, the ranger station is node A, there are 2 ranger teams, and each team's route must not exceed 194.0.

| site_id | x_coord | y_coord | conservation_priority_score |
|---|---|---|---|
| A | 0 | 30 | 0 |
| B | 13 | 74 | 56 |
| C | 40 | 11 | 51 |
| D | 40 | 85 | 83 |
| E | 40 | 94 | 5 |
| F | 61 | 35 | 96 |
| G | 70 | 100 | 12 |
| H | 74 | 38 | 4 |
| I | 76 | 0 | 96 |
| J | 99 | 50 | 86 |
| K | 100 | 50 | 96 |

We list each survey site below so we can assign them to teams under the constraints above.

When you send back the routes, just use a tiny JSON object in this shape so it's easy to parse and check. Something like:

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

This means ""solution"" is a list of routes; each route is a list of place identifiers that starts and ends at the ranger station, with the intermediate entries being the survey sites visited on that route. Think of it like filling in a simple form: one array per team, each array listing the station, the sites that team visits in order, and then back to the station.

This JSON is just a sketch of the expected shape, not the actual answer — replace the placeholders with the exact IDs from the instance.

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, 30], [13, 74], [40, 11], [40, 85], [40, 94], [61, 35], [70, 100], [74, 38], [76, 0], [99, 50], [100, 50]], 'prizes': [0, 56, 51, 83, 5, 96, 12, 4, 96, 86, 96], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 2, 8, 5, 0], [0, 4, 3, 1, 0]], 'total_route_length': 340.71656814062067, 'collected_prize': 387.0, 'objective': 387.0}","[[0, 2, 8, 5, 0], [0, 4, 3, 1, 0]]",387.0,"{'problem_type': 'TOP', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 0, 'y': 30, 'prize': 0}, {'id': 'B', 'x': 13, 'y': 74, 'prize': 56}, {'id': 'C', 'x': 40, 'y': 11, 'prize': 51}, {'id': 'D', 'x': 40, 'y': 85, 'prize': 83}, {'id': 'E', 'x': 40, 'y': 94, 'prize': 5}, {'id': 'F', 'x': 61, 'y': 35, 'prize': 96}, {'id': 'G', 'x': 70, 'y': 100, 'prize': 12}, {'id': 'H', 'x': 74, 'y': 38, 'prize': 4}, {'id': 'I', 'x': 76, 'y': 0, 'prize': 96}, {'id': 'J', 'x': 99, 'y': 50, 'prize': 86}, {'id': 'K', 'x': 100, 'y': 50, 'prize': 96}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 340.71656814062067, 'collected_prize': 387.0, 'objective': 387.0}","[['A', 'C', 'I', 'F', 'A'], ['A', 'E', 'D', 'B', 'A']]",29,markdown_table,names
TOP,TOP,"There's a distribution center sending out a handful of vans to hit neighborhood markets, and someone has to plan which stops go on which van’s itinerary. Every trip must start and end at the distribution center, stay within that van’s travel allowance, and a market can’t be on two different itineraries; each market visit contributes its projected sales. The overall goal is to collect as much projected sales as possible — measure that by summing the projected sales of all markets included in the day’s runs. The concrete specifics are listed below.

Instance specifics: 19 total locations (including distribution center 1), 2 vans available, and a maximum round-trip length of 194.0 per van.
Market 1 at (0, 24) offers projected sales 0.
Market 2 at (0, 100) offers projected sales 59.
Market 3 at (2, 0) offers projected sales 55.
Market 4 at (4, 62) offers projected sales 26.
Market 5 at (4, 27) offers projected sales 12.
Market 6 at (4, 0) offers projected sales 81.
Market 7 at (5, 39) offers projected sales 69.
Market 8 at (46, 32) offers projected sales 20.
Market 9 at (47, 86) offers projected sales 89.
Market 10 at (48, 57) offers projected sales 52.
Market 11 at (48, 55) offers projected sales 20.
Market 12 at (48, 29) offers projected sales 50.
Market 13 at (52, 24) offers projected sales 12.
Market 14 at (54, 76) offers projected sales 60.
Market 15 at (57, 43) offers projected sales 82.
Market 16 at (57, 8) offers projected sales 24.
Market 17 at (99, 24) offers projected sales 56.
Market 18 at (100, 56) offers projected sales 17.
Market 19 at (100, 27) offers projected sales 79.
Plan up to 2 routes that start and end at 1 and do not exceed 194.0, to maximize the summed projected sales from the visited markets.

Oh, and when you send back the plan, please follow this simple JSON layout so I can read it easily. Something like:

{
  ""solution"": [[distribution_center_id, market_id, ... , distribution_center_id], [distribution_center_id, market_id, ... , distribution_center_id], ...]
}

This is just a sketch of the shape I expect: ""solution"" is a list of routes, each route is a list that starts and ends with the distribution center, and the market placeholders in the middle are the stops on that van’s trip. Think of it like filling out a quick form — one row per van, stop IDs in order, and the depot ID at both ends. Again, it’s just the expected shape, 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': [[0, 24], [0, 100], [2, 0], [4, 62], [4, 27], [4, 0], [5, 39], [46, 32], [47, 86], [48, 57], [48, 55], [48, 29], [52, 24], [54, 76], [57, 43], [57, 8], [99, 24], [100, 56], [100, 27]], 'prizes': [0, 59, 55, 26, 12, 81, 69, 20, 89, 52, 20, 50, 12, 60, 82, 24, 56, 17, 79], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 7, 11, 14, 10, 9, 13, 8, 0], [0, 6, 3, 12, 2, 5, 4, 0]], 'total_route_length': 383.38750822680555, 'collected_prize': 628.0, 'objective': 628.0}","[[0, 7, 11, 14, 10, 9, 13, 8, 0], [0, 6, 3, 12, 2, 5, 4, 0]]",628.0,"{'problem_type': 'TOP', 'num_nodes': 19, 'nodes': [{'id': 1, 'x': 0, 'y': 24, 'prize': 0}, {'id': 2, 'x': 0, 'y': 100, 'prize': 59}, {'id': 3, 'x': 2, 'y': 0, 'prize': 55}, {'id': 4, 'x': 4, 'y': 62, 'prize': 26}, {'id': 5, 'x': 4, 'y': 27, 'prize': 12}, {'id': 6, 'x': 4, 'y': 0, 'prize': 81}, {'id': 7, 'x': 5, 'y': 39, 'prize': 69}, {'id': 8, 'x': 46, 'y': 32, 'prize': 20}, {'id': 9, 'x': 47, 'y': 86, 'prize': 89}, {'id': 10, 'x': 48, 'y': 57, 'prize': 52}, {'id': 11, 'x': 48, 'y': 55, 'prize': 20}, {'id': 12, 'x': 48, 'y': 29, 'prize': 50}, {'id': 13, 'x': 52, 'y': 24, 'prize': 12}, {'id': 14, 'x': 54, 'y': 76, 'prize': 60}, {'id': 15, 'x': 57, 'y': 43, 'prize': 82}, {'id': 16, 'x': 57, 'y': 8, 'prize': 24}, {'id': 17, 'x': 99, 'y': 24, 'prize': 56}, {'id': 18, 'x': 100, 'y': 56, 'prize': 17}, {'id': 19, 'x': 100, 'y': 27, 'prize': 79}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 383.38750822680555, 'collected_prize': 628.0, 'objective': 628.0}","[[1, 8, 12, 15, 11, 10, 14, 9, 1], [1, 7, 4, 13, 3, 6, 5, 1]]",30,nl,1
TOP,TOP,"There’s a busy drone hub in town and the morning puzzle is picking flight paths: one sortie per drone that takes off from the hub, visits some customers, then returns before hitting the range cap. No delivery should be duplicated across drones, and each drone’s trip must stay within its allowed distance. The aim is to collect as much total reward as possible — simply add up the reward numbers for every visited location — and the exact hub, the drones’ ranges, and the rewards for each stop appear below.

Below are the 19 locations — hub 0, drone range 194.0, and 2 drones available.

| location_id | x_coord | y_coord | delivery_reward |
|---|---|---|---|
| 0 | 13 | 54 | 0 |
| 1 | 88 | 28 | 97 |
| 2 | 13 | 100 | 57 |
| 3 | 27 | 58 | 40 |
| 4 | 46 | 18 | 58 |
| 5 | 13 | 88 | 1 |
| 6 | 0 | 13 | 80 |
| 7 | 100 | 23 | 61 |
| 8 | 97 | 80 | 91 |
| 9 | 41 | 87 | 95 |
| 10 | 98 | 31 | 81 |
| 11 | 40 | 31 | 8 |
| 12 | 65 | 0 | 98 |
| 13 | 27 | 77 | 74 |
| 14 | 42 | 63 | 73 |
| 15 | 5 | 50 | 38 |
| 16 | 91 | 21 | 8 |
| 17 | 5 | 27 | 48 |
| 18 | 96 | 2 | 6 |

Plan each sortie from hub 0 so it stays within 194.0 and use at most 2 drones.

Oh, and when you send back the chosen routes, please use this little JSON sketch so everything stays neat and machine-readable:

{
  ""solution"": [[""hub_id"", ""customer_id"", ..., ""hub_id""], [""hub_id"", ""customer_id"", ..., ""hub_id""], ...]
}

Pretty simple: ""solution"" holds a list of sorties (one per drone). Each inner list is the sequence of stops for that drone, starting and ending at the hub. Keep the placeholders as shown — it's just a shape example, not the real routes.

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': [[13, 54], [88, 28], [13, 100], [27, 58], [46, 18], [13, 88], [0, 13], [100, 23], [97, 80], [41, 87], [98, 31], [40, 31], [65, 0], [27, 77], [42, 63], [5, 50], [91, 21], [5, 27], [96, 2]], 'prizes': [0, 97, 57, 40, 58, 1, 80, 61, 91, 95, 81, 8, 98, 74, 73, 38, 8, 48, 6], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 13, 9, 8, 14, 3, 0], [0, 11, 4, 12, 6, 17, 15, 0]], 'total_route_length': 377.56145450158897, 'collected_prize': 703.0, 'objective': 703.0}","[[0, 13, 9, 8, 14, 3, 0], [0, 11, 4, 12, 6, 17, 15, 0]]",703.0,"{'problem_type': 'TOP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 13, 'y': 54, 'prize': 0}, {'id': 1, 'x': 88, 'y': 28, 'prize': 97}, {'id': 2, 'x': 13, 'y': 100, 'prize': 57}, {'id': 3, 'x': 27, 'y': 58, 'prize': 40}, {'id': 4, 'x': 46, 'y': 18, 'prize': 58}, {'id': 5, 'x': 13, 'y': 88, 'prize': 1}, {'id': 6, 'x': 0, 'y': 13, 'prize': 80}, {'id': 7, 'x': 100, 'y': 23, 'prize': 61}, {'id': 8, 'x': 97, 'y': 80, 'prize': 91}, {'id': 9, 'x': 41, 'y': 87, 'prize': 95}, {'id': 10, 'x': 98, 'y': 31, 'prize': 81}, {'id': 11, 'x': 40, 'y': 31, 'prize': 8}, {'id': 12, 'x': 65, 'y': 0, 'prize': 98}, {'id': 13, 'x': 27, 'y': 77, 'prize': 74}, {'id': 14, 'x': 42, 'y': 63, 'prize': 73}, {'id': 15, 'x': 5, 'y': 50, 'prize': 38}, {'id': 16, 'x': 91, 'y': 21, 'prize': 8}, {'id': 17, 'x': 5, 'y': 27, 'prize': 48}, {'id': 18, 'x': 96, 'y': 2, 'prize': 6}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 377.56145450158897, 'collected_prize': 703.0, 'objective': 703.0}","[[0, 13, 9, 8, 14, 3, 0], [0, 11, 4, 12, 6, 17, 15, 0]]",31,markdown_table,0
TOP,TOP,"We need to map out a set of sampling routes for the field crews that all start and end at the lab, with each route staying under that crew’s maximum allowable travel time. The choice to be made is how to split up the available sampling sites among the teams so that no site is visited more than once and no route goes over its time allowance. A better schedule is the one that brings back the highest total research value, computed by summing the values of every sampled site across every trip. The specific site locations, values, and time limits are listed below.

We have 18 locations in total, with the lab at node A; each team's round trip must not exceed 194.0, and we have 2 teams.

| site_node_id | site_x_coordinate | site_y_coordinate | research_value_of_site |
|---|---|---|---|
| A | 35 | 91 | 0 |
| B | 44 | 34 | 78 |
| C | 51 | 33 | 48 |
| D | 40 | 33 | 51 |
| E | 76 | 100 | 30 |
| F | 73 | 100 | 1 |
| G | 7 | 99 | 47 |
| H | 81 | 0 | 74 |
| I | 76 | 0 | 6 |
| J | 77 | 0 | 85 |
| K | 70 | 0 | 26 |
| L | 0 | 1 | 45 |
| M | 92 | 100 | 49 |
| N | 88 | 100 | 19 |
| O | 93 | 100 | 4 |
| P | 20 | 99 | 44 |
| Q | 100 | 1 | 23 |
| R | 26 | 0 | 99 |

We will assign sites to the 2 teams to maximize total research value while keeping each route under 194.0.

Also, when you send back the planned routes, please use this simple JSON layout so it's easy to read and load:

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

This just means ""solution"" is a list of routes. Each route is a list of place identifiers starting and ending at the lab, with the sampled sites in the middle. Think of it like filling out a form: each inner list is one crew's trip, and the IDs are exactly the site labels from the instance (replace the placeholders here with the real IDs).

This JSON is only a sketch of the expected shape — not your actual answer. Please use the exact identifiers given in 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': [[35, 91], [44, 34], [51, 33], [40, 33], [76, 100], [73, 100], [7, 99], [81, 0], [76, 0], [77, 0], [70, 0], [0, 1], [92, 100], [88, 100], [93, 100], [20, 99], [100, 1], [26, 0]], 'prizes': [0, 78, 48, 51, 30, 1, 47, 74, 6, 85, 26, 45, 49, 19, 4, 44, 23, 99], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 3, 17, 1, 0], [0, 6, 15, 0]], 'total_route_length': 249.35937483466014, 'collected_prize': 422.0, 'objective': 422.0}","[[0, 3, 17, 1, 0], [0, 6, 15, 0]]",422.0,"{'problem_type': 'TOP', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 35, 'y': 91, 'prize': 0}, {'id': 'B', 'x': 44, 'y': 34, 'prize': 78}, {'id': 'C', 'x': 51, 'y': 33, 'prize': 48}, {'id': 'D', 'x': 40, 'y': 33, 'prize': 51}, {'id': 'E', 'x': 76, 'y': 100, 'prize': 30}, {'id': 'F', 'x': 73, 'y': 100, 'prize': 1}, {'id': 'G', 'x': 7, 'y': 99, 'prize': 47}, {'id': 'H', 'x': 81, 'y': 0, 'prize': 74}, {'id': 'I', 'x': 76, 'y': 0, 'prize': 6}, {'id': 'J', 'x': 77, 'y': 0, 'prize': 85}, {'id': 'K', 'x': 70, 'y': 0, 'prize': 26}, {'id': 'L', 'x': 0, 'y': 1, 'prize': 45}, {'id': 'M', 'x': 92, 'y': 100, 'prize': 49}, {'id': 'N', 'x': 88, 'y': 100, 'prize': 19}, {'id': 'O', 'x': 93, 'y': 100, 'prize': 4}, {'id': 'P', 'x': 20, 'y': 99, 'prize': 44}, {'id': 'Q', 'x': 100, 'y': 1, 'prize': 23}, {'id': 'R', 'x': 26, 'y': 0, 'prize': 99}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 249.35937483466014, 'collected_prize': 422.0, 'objective': 422.0}","[['A', 'D', 'R', 'B', 'A'], ['A', 'G', 'P', 'A']]",32,markdown_table,names
TOP,TOP,"We have a handful of vehicles that all leave from and return to the charity headquarters, and the job is to assign which beneficiary sites each vehicle will visit so every route stays within its distance limit and no site is visited twice. A better plan is the one that results in a larger total amount of help given, which you figure out by summing the assistance value of each distinct site that gets visited. Specifics about locations, vehicle limits, and values are listed below.

{
  ""total_locations_including_office"": 16,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coord"": 50,
      ""y_coord"": 89,
      ""assistance_value"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coord"": 55,
      ""y_coord"": 70,
      ""assistance_value"": 70
    },
    {
      ""location_id"": ""C"",
      ""x_coord"": 65,
      ""y_coord"": 73,
      ""assistance_value"": 82
    },
    {
      ""location_id"": ""D"",
      ""x_coord"": 69,
      ""y_coord"": 77,
      ""assistance_value"": 54
    },
    {
      ""location_id"": ""E"",
      ""x_coord"": 38,
      ""y_coord"": 36,
      ""assistance_value"": 36
    },
    {
      ""location_id"": ""F"",
      ""x_coord"": 31,
      ""y_coord"": 90,
      ""assistance_value"": 4
    },
    {
      ""location_id"": ""G"",
      ""x_coord"": 42,
      ""y_coord"": 97,
      ""assistance_value"": 59
    },
    {
      ""location_id"": ""H"",
      ""x_coord"": 100,
      ""y_coord"": 53,
      ""assistance_value"": 82
    },
    {
      ""location_id"": ""I"",
      ""x_coord"": 74,
      ""y_coord"": 1,
      ""assistance_value"": 22
    },
    {
      ""location_id"": ""J"",
      ""x_coord"": 69,
      ""y_coord"": 0,
      ""assistance_value"": 14
    },
    {
      ""location_id"": ""K"",
      ""x_coord"": 82,
      ""y_coord"": 100,
      ""assistance_value"": 61
    },
    {
      ""location_id"": ""L"",
      ""x_coord"": 0,
      ""y_coord"": 89,
      ""assistance_value"": 54
    },
    {
      ""location_id"": ""M"",
      ""x_coord"": 62,
      ""y_coord"": 81,
      ""assistance_value"": 13
    },
    {
      ""location_id"": ""N"",
      ""x_coord"": 65,
      ""y_coord"": 79,
      ""assistance_value"": 58
    },
    {
      ""location_id"": ""O"",
      ""x_coord"": 59,
      ""y_coord"": 96,
      ""assistance_value"": 64
    },
    {
      ""location_id"": ""P"",
      ""x_coord"": 47,
      ""y_coord"": 100,
      ""assistance_value"": 20
    }
  ],
  ""charity_office_id"": ""A"",
  ""max_route_distance_per_vehicle"": 194.0,
  ""num_vehicles"": 2
}

And just so we're on the same page, when you send the routes back please follow this little JSON layout — nothing fancy, just a simple list of routes in a single field.

{
  ""solution"": [[headquarters_id, beneficiary_id, ... , headquarters_id], [headquarters_id, beneficiary_id, ... , headquarters_id], ...]
}

This is just a sketch of the shape I need: ""solution"" holds a list of routes, each route is a list that starts and ends with the headquarters placeholder and has one or more beneficiary placeholders in between. Think of each inner list as the stops one vehicle will make on its round trip.

This is only the expected format, not the actual answer — fill in the real identifiers from the instance when you provide your routes.

Please be 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': [[50, 89], [55, 70], [65, 73], [69, 77], [38, 36], [31, 90], [42, 97], [100, 53], [74, 1], [69, 0], [82, 100], [0, 89], [62, 81], [65, 79], [59, 96], [47, 100]], 'prizes': [0, 70, 82, 54, 36, 4, 59, 82, 22, 14, 61, 54, 13, 58, 64, 20], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 5, 11, 4, 1, 0], [0, 6, 15, 0]], 'total_route_length': 201.46390433840992, 'collected_prize': 657.0, 'objective': 657.0}","[[0, 5, 11, 4, 1, 0], [0, 6, 15, 0]]",657.0,"{'problem_type': 'TOP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 50, 'y': 89, 'prize': 0}, {'id': 'B', 'x': 55, 'y': 70, 'prize': 70}, {'id': 'C', 'x': 65, 'y': 73, 'prize': 82}, {'id': 'D', 'x': 69, 'y': 77, 'prize': 54}, {'id': 'E', 'x': 38, 'y': 36, 'prize': 36}, {'id': 'F', 'x': 31, 'y': 90, 'prize': 4}, {'id': 'G', 'x': 42, 'y': 97, 'prize': 59}, {'id': 'H', 'x': 100, 'y': 53, 'prize': 82}, {'id': 'I', 'x': 74, 'y': 1, 'prize': 22}, {'id': 'J', 'x': 69, 'y': 0, 'prize': 14}, {'id': 'K', 'x': 82, 'y': 100, 'prize': 61}, {'id': 'L', 'x': 0, 'y': 89, 'prize': 54}, {'id': 'M', 'x': 62, 'y': 81, 'prize': 13}, {'id': 'N', 'x': 65, 'y': 79, 'prize': 58}, {'id': 'O', 'x': 59, 'y': 96, 'prize': 64}, {'id': 'P', 'x': 47, 'y': 100, 'prize': 20}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 201.46390433840992, 'collected_prize': 657.0, 'objective': 657.0}","[['A', 'F', 'L', 'E', 'B', 'A'], ['A', 'G', 'P', 'A']]",33,json,names
TOP,TOP,"Someone on the campaign team sketched a map and now the task is to turn it into routes — every marketing van must leave from the campaign base and return there, staying inside its personal driving allowance. The challenge is to assign billboards to vans so that the combined advertising reach (just add up the reach score for every billboard that actually gets visited) is as big as possible. No billboard gets assigned to more than one van, and no route can exceed its driving limit. The full set of locations, reach values, vehicle counts, and route limits is shown below.

# total_locations_including_depot=17
# campaign_base_id=A
# max_route_distance_per_van=194.0
# num_marketing_vans=2
location_id,x_coordinate,y_coordinate,reach_score
A,0,46,0
B,6,18,74
C,7,100,21
D,36,0,24
E,34,39,75
F,36,72,9
G,57,100,42
H,57,23,81
I,59,18,32
J,64,18,12
K,69,97,38
L,70,18,47
M,100,80,21
N,100,79,1
O,99,39,36
P,100,12,13
Q,100,0,16

Also—when you send back the routes, please use a simple JSON shape so it's easy to check automatically. Something like this:

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

Here the idea is straightforward: ""solution"" holds a list of routes, each route is a list that starts and ends at the depot and contains the visited location IDs in order. Think of it as filling out a little form: each inner list is one van's trip, and the whole thing is the plan for all vans. This is just the shape I need — not your final picks.

Please make sure you 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, 46], [6, 18], [7, 100], [36, 0], [34, 39], [36, 72], [57, 100], [57, 23], [59, 18], [64, 18], [69, 97], [70, 18], [100, 80], [100, 79], [99, 39], [100, 12], [100, 0]], 'prizes': [0, 74, 21, 24, 75, 9, 42, 81, 32, 12, 38, 47, 21, 1, 36, 13, 16], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 4, 9, 11, 8, 7, 3, 1, 0], [0, 6, 10, 5, 0]], 'total_route_length': 365.1786386281599, 'collected_prize': 434.0, 'objective': 434.0}","[[0, 4, 9, 11, 8, 7, 3, 1, 0], [0, 6, 10, 5, 0]]",434.0,"{'problem_type': 'TOP', 'num_nodes': 17, 'nodes': [{'id': 'A', 'x': 0, 'y': 46, 'prize': 0}, {'id': 'B', 'x': 6, 'y': 18, 'prize': 74}, {'id': 'C', 'x': 7, 'y': 100, 'prize': 21}, {'id': 'D', 'x': 36, 'y': 0, 'prize': 24}, {'id': 'E', 'x': 34, 'y': 39, 'prize': 75}, {'id': 'F', 'x': 36, 'y': 72, 'prize': 9}, {'id': 'G', 'x': 57, 'y': 100, 'prize': 42}, {'id': 'H', 'x': 57, 'y': 23, 'prize': 81}, {'id': 'I', 'x': 59, 'y': 18, 'prize': 32}, {'id': 'J', 'x': 64, 'y': 18, 'prize': 12}, {'id': 'K', 'x': 69, 'y': 97, 'prize': 38}, {'id': 'L', 'x': 70, 'y': 18, 'prize': 47}, {'id': 'M', 'x': 100, 'y': 80, 'prize': 21}, {'id': 'N', 'x': 100, 'y': 79, 'prize': 1}, {'id': 'O', 'x': 99, 'y': 39, 'prize': 36}, {'id': 'P', 'x': 100, 'y': 12, 'prize': 13}, {'id': 'Q', 'x': 100, 'y': 0, 'prize': 16}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 365.1786386281599, 'collected_prize': 434.0, 'objective': 434.0}","[['A', 'E', 'J', 'L', 'I', 'H', 'D', 'B', 'A'], ['A', 'G', 'K', 'F', 'A']]",34,csv,names
TOP,TOP,"Someone has to map out daily service loops for a fleet of repair vans: each loop must begin and finish at the maintenance yard, each van can only travel up to its allotted distance, and a repair site shouldn’t be assigned to more than one van. What counts as a better assignment is the one that brings in the highest combined urgency score — add up the urgency ratings of all the sites the vans visit — and the precise data for the scenario follows below.

{
  ""total_locations_including_yard"": 12,
  ""nodes"": [
    {
      ""site_id"": ""A"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 0,
      ""urgency_score"": 0
    },
    {
      ""site_id"": ""B"",
      ""x_coordinate"": 8,
      ""y_coordinate"": 38,
      ""urgency_score"": 44
    },
    {
      ""site_id"": ""C"",
      ""x_coordinate"": 11,
      ""y_coordinate"": 38,
      ""urgency_score"": 25
    },
    {
      ""site_id"": ""D"",
      ""x_coordinate"": 24,
      ""y_coordinate"": 35,
      ""urgency_score"": 28
    },
    {
      ""site_id"": ""E"",
      ""x_coordinate"": 24,
      ""y_coordinate"": 43,
      ""urgency_score"": 65
    },
    {
      ""site_id"": ""F"",
      ""x_coordinate"": 28,
      ""y_coordinate"": 43,
      ""urgency_score"": 92
    },
    {
      ""site_id"": ""G"",
      ""x_coordinate"": 27,
      ""y_coordinate"": 46,
      ""urgency_score"": 100
    },
    {
      ""site_id"": ""H"",
      ""x_coordinate"": 24,
      ""y_coordinate"": 46,
      ""urgency_score"": 48
    },
    {
      ""site_id"": ""I"",
      ""x_coordinate"": 21,
      ""y_coordinate"": 51,
      ""urgency_score"": 58
    },
    {
      ""site_id"": ""J"",
      ""x_coordinate"": 49,
      ""y_coordinate"": 97,
      ""urgency_score"": 3
    },
    {
      ""site_id"": ""K"",
      ""x_coordinate"": 51,
      ""y_coordinate"": 100,
      ""urgency_score"": 98
    },
    {
      ""site_id"": ""L"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 42,
      ""urgency_score"": 99
    }
  ],
  ""maintenance_yard_id"": ""A"",
  ""max_travel_distance_per_van"": 194.0,
  ""num_repair_vans"": 2
}

Also, when you send the routes back, a tiny bit of JSON like this is all I need — nothing fancy, just the structure below.

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

This sketch means: ""solution"" is a list of routes; each inner list is one van's loop, starting and ending at the maintenance yard (that's the yard_id) and listing the sites visited in order (site_id). Treat it like a simple form: one array per van, each array begins and ends with the yard identifier.

The JSON above is only the expected shape, not the actual answer — fill it in with the exact identifiers from the instance input (no renaming, no extra labels). To be clear, 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], [8, 38], [11, 38], [24, 35], [24, 43], [28, 43], [27, 46], [24, 46], [21, 51], [49, 97], [51, 100], [100, 42]], 'prizes': [0, 44, 25, 28, 65, 92, 100, 48, 58, 3, 98, 99], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 4, 8, 5, 7, 2, 1, 3, 0], [0, 6, 0]], 'total_route_length': 257.07686985820874, 'collected_prize': 460.0, 'objective': 460.0}","[[0, 4, 8, 5, 7, 2, 1, 3, 0], [0, 6, 0]]",460.0,"{'problem_type': 'TOP', 'num_nodes': 12, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'prize': 0}, {'id': 'B', 'x': 8, 'y': 38, 'prize': 44}, {'id': 'C', 'x': 11, 'y': 38, 'prize': 25}, {'id': 'D', 'x': 24, 'y': 35, 'prize': 28}, {'id': 'E', 'x': 24, 'y': 43, 'prize': 65}, {'id': 'F', 'x': 28, 'y': 43, 'prize': 92}, {'id': 'G', 'x': 27, 'y': 46, 'prize': 100}, {'id': 'H', 'x': 24, 'y': 46, 'prize': 48}, {'id': 'I', 'x': 21, 'y': 51, 'prize': 58}, {'id': 'J', 'x': 49, 'y': 97, 'prize': 3}, {'id': 'K', 'x': 51, 'y': 100, 'prize': 98}, {'id': 'L', 'x': 100, 'y': 42, 'prize': 99}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 257.07686985820874, 'collected_prize': 460.0, 'objective': 460.0}","[['A', 'E', 'I', 'F', 'H', 'C', 'B', 'D', 'A'], ['A', 'G', 'A']]",35,json,names
TOP,TOP,"Recently the warehouse team decided to plan daily runs for the vans: each outing must begin and end at the warehouse, stay within that van’s mileage limit, and avoid duplicating service to the same pickup spot. The goal is to collect the most donation value overall — you figure that by adding up the stated donation amounts for every stop the fleet actually reaches. The full set of numbers and distances for this run is shown below.

It lists 11 locations in total, with the warehouse at node 0; each van may travel up to 194.0 and we have 2 vans.

| location_id | x_coordinate | y_coordinate | donation_value |
|---|---|---|---|
| 0 | 0 | 36 | 0 |
| 1 | 17 | 0 | 68 |
| 2 | 36 | 68 | 74 |
| 3 | 39 | 48 | 70 |
| 4 | 44 | 16 | 56 |
| 5 | 60 | 65 | 49 |
| 6 | 59 | 100 | 43 |
| 7 | 83 | 75 | 57 |
| 8 | 100 | 26 | 70 |
| 9 | 34 | 90 | 77 |
| 10 | 12 | 18 | 65 |

Use these rows to plan routes that maximize the donations you can collect while keeping each van within the 194.0 limit.

Oh — and when you send the planned runs back, please stick to this JSON layout:

{
  ""solution"": [[warehouse_id, pickup_spot_id, ... , warehouse_id], [warehouse_id, pickup_spot_id, ... , warehouse_id], ...]
}

This just means ""solution"" is a list of van routes, and each route is written as the sequence of IDs the van visits, starting and ending at the warehouse. Treat the block above like a simple form: each inner list is one outing, each name is an ID for the warehouse or a pickup spot. It's only a sketch of the shape I need — not the actual routes.

Please make sure to use the exact identifiers given in 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': [[0, 36], [17, 0], [36, 68], [39, 48], [44, 16], [60, 65], [59, 100], [83, 75], [100, 26], [34, 90], [12, 18]], 'prizes': [0, 68, 74, 70, 56, 49, 43, 57, 70, 77, 65], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 10, 1, 4, 2, 3, 0], [0, 9, 6, 5, 0]], 'total_route_length': 377.73266438828597, 'collected_prize': 502.0, 'objective': 502.0}","[[0, 10, 1, 4, 2, 3, 0], [0, 9, 6, 5, 0]]",502.0,"{'problem_type': 'TOP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 0, 'y': 36, 'prize': 0}, {'id': 1, 'x': 17, 'y': 0, 'prize': 68}, {'id': 2, 'x': 36, 'y': 68, 'prize': 74}, {'id': 3, 'x': 39, 'y': 48, 'prize': 70}, {'id': 4, 'x': 44, 'y': 16, 'prize': 56}, {'id': 5, 'x': 60, 'y': 65, 'prize': 49}, {'id': 6, 'x': 59, 'y': 100, 'prize': 43}, {'id': 7, 'x': 83, 'y': 75, 'prize': 57}, {'id': 8, 'x': 100, 'y': 26, 'prize': 70}, {'id': 9, 'x': 34, 'y': 90, 'prize': 77}, {'id': 10, 'x': 12, 'y': 18, 'prize': 65}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 377.73266438828597, 'collected_prize': 502.0, 'objective': 502.0}","[[0, 10, 1, 4, 2, 3, 0], [0, 9, 6, 5, 0]]",36,markdown_table,0
TOP,TOP,"We have a crew of inspectors who must each head out from the depot, do a loop of checks, and return without going over their individual distance allowance, and we can’t have a site inspected twice. The decision to make is how to split and order the visits among the inspectors; what makes one plan better than another is how many priority points it collects — the total is simply the sum of the priority values of the sites that get visited. Each site can only be visited once and every route must begin and end at the depot within the permitted length. The exact instance details follow below.

# total_locations_including_depot=11
# depot_id=A
# max_route_length_per_inspector=194.0
# n_inspectors=2
site_id,x_coord,y_coord,priority_points
A,48,65,0
B,61,30,84
C,41,100,32
D,39,63,28
E,15,13,28
F,74,52,50
G,69,23,70
H,100,51,76
I,0,28,71
J,23,35,5
K,87,0,36

And when you send the chosen routes back, just pop them into this simple JSON shape so it's easy to read and validate:

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

This means ""solution"" is a list of routes; each route is itself a list that starts at the depot, lists the sites visited in order, and returns to the depot. Think of it like filling out a short form for each inspector: the sequence of IDs they visit (with the depot repeated at the ends). It’s only a sketch of the expected shape — don’t treat it as the final filled-in plan here.

Important: 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': [[48, 65], [61, 30], [41, 100], [39, 63], [15, 13], [74, 52], [69, 23], [100, 51], [0, 28], [23, 35], [87, 0]], 'prizes': [0, 84, 32, 28, 28, 50, 70, 76, 71, 5, 36], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 2, 9, 8, 3, 0], [0, 1, 6, 10, 7, 5, 0]], 'total_route_length': 373.6943923434694, 'collected_prize': 452.0, 'objective': 452.0}","[[0, 2, 9, 8, 3, 0], [0, 1, 6, 10, 7, 5, 0]]",452.0,"{'problem_type': 'TOP', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 48, 'y': 65, 'prize': 0}, {'id': 'B', 'x': 61, 'y': 30, 'prize': 84}, {'id': 'C', 'x': 41, 'y': 100, 'prize': 32}, {'id': 'D', 'x': 39, 'y': 63, 'prize': 28}, {'id': 'E', 'x': 15, 'y': 13, 'prize': 28}, {'id': 'F', 'x': 74, 'y': 52, 'prize': 50}, {'id': 'G', 'x': 69, 'y': 23, 'prize': 70}, {'id': 'H', 'x': 100, 'y': 51, 'prize': 76}, {'id': 'I', 'x': 0, 'y': 28, 'prize': 71}, {'id': 'J', 'x': 23, 'y': 35, 'prize': 5}, {'id': 'K', 'x': 87, 'y': 0, 'prize': 36}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 373.6943923434694, 'collected_prize': 452.0, 'objective': 452.0}","[['A', 'C', 'J', 'I', 'D', 'A'], ['A', 'B', 'G', 'K', 'H', 'F', 'A']]",37,csv,names
TOP,TOP,"Picture this: a row of shuttles at the festival hub, each ready to run exactly one loop out and back that can’t be longer than its allowed distance. The tricky part is divvying up attractions so that each one is visited by at most one shuttle, and the overall aim is to rack up the most enjoyment — done by adding together the enjoyment points of every visited attraction across all loops. Concrete details are coming up below.

{
  ""total_locations_including_depot"": 16,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coordinate"": 5,
      ""y_coordinate"": 69,
      ""enjoyment_points"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coordinate"": 14,
      ""y_coordinate"": 38,
      ""enjoyment_points"": 56
    },
    {
      ""location_id"": ""C"",
      ""x_coordinate"": 31,
      ""y_coordinate"": 0,
      ""enjoyment_points"": 95
    },
    {
      ""location_id"": ""D"",
      ""x_coordinate"": 31,
      ""y_coordinate"": 3,
      ""enjoyment_points"": 66
    },
    {
      ""location_id"": ""E"",
      ""x_coordinate"": 37,
      ""y_coordinate"": 3,
      ""enjoyment_points"": 93
    },
    {
      ""location_id"": ""F"",
      ""x_coordinate"": 48,
      ""y_coordinate"": 84,
      ""enjoyment_points"": 28
    },
    {
      ""location_id"": ""G"",
      ""x_coordinate"": 48,
      ""y_coordinate"": 85,
      ""enjoyment_points"": 77
    },
    {
      ""location_id"": ""H"",
      ""x_coordinate"": 60,
      ""y_coordinate"": 27,
      ""enjoyment_points"": 14
    },
    {
      ""location_id"": ""I"",
      ""x_coordinate"": 67,
      ""y_coordinate"": 35,
      ""enjoyment_points"": 69
    },
    {
      ""location_id"": ""J"",
      ""x_coordinate"": 73,
      ""y_coordinate"": 20,
      ""enjoyment_points"": 63
    },
    {
      ""location_id"": ""K"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 9,
      ""enjoyment_points"": 67
    },
    {
      ""location_id"": ""L"",
      ""x_coordinate"": 58,
      ""y_coordinate"": 100,
      ""enjoyment_points"": 84
    },
    {
      ""location_id"": ""M"",
      ""x_coordinate"": 21,
      ""y_coordinate"": 28,
      ""enjoyment_points"": 49
    },
    {
      ""location_id"": ""N"",
      ""x_coordinate"": 25,
      ""y_coordinate"": 66,
      ""enjoyment_points"": 69
    },
    {
      ""location_id"": ""O"",
      ""x_coordinate"": 25,
      ""y_coordinate"": 72,
      ""enjoyment_points"": 28
    },
    {
      ""location_id"": ""P"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 48,
      ""enjoyment_points"": 48
    }
  ],
  ""hub_node_id"": ""A"",
  ""max_loop_distance_per_shuttle"": 194.0,
  ""number_of_shuttles"": 2
}

If you'd like to return a candidate set of shuttle loops, you can just drop it in as a tiny JSON snippet like this:

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

Think of ""solution"" as a list of loops — one list per shuttle — and each loop is an ordered list that starts and ends at the depot and contains the attractions visited along the way. This is just a sketch of the shape I expect, not the actual routes.

Please make sure to 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': [[5, 69], [14, 38], [31, 0], [31, 3], [37, 3], [48, 84], [48, 85], [60, 27], [67, 35], [73, 20], [100, 9], [58, 100], [21, 28], [25, 66], [25, 72], [0, 48]], 'prizes': [0, 56, 95, 66, 93, 28, 77, 14, 69, 63, 67, 84, 49, 69, 28, 48], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 7, 4, 2, 3, 12, 1, 15, 0], [0, 14, 0]], 'total_route_length': 230.52390547960027, 'collected_prize': 707.0, 'objective': 707.0}","[[0, 7, 4, 2, 3, 12, 1, 15, 0], [0, 14, 0]]",707.0,"{'problem_type': 'TOP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 5, 'y': 69, 'prize': 0}, {'id': 'B', 'x': 14, 'y': 38, 'prize': 56}, {'id': 'C', 'x': 31, 'y': 0, 'prize': 95}, {'id': 'D', 'x': 31, 'y': 3, 'prize': 66}, {'id': 'E', 'x': 37, 'y': 3, 'prize': 93}, {'id': 'F', 'x': 48, 'y': 84, 'prize': 28}, {'id': 'G', 'x': 48, 'y': 85, 'prize': 77}, {'id': 'H', 'x': 60, 'y': 27, 'prize': 14}, {'id': 'I', 'x': 67, 'y': 35, 'prize': 69}, {'id': 'J', 'x': 73, 'y': 20, 'prize': 63}, {'id': 'K', 'x': 100, 'y': 9, 'prize': 67}, {'id': 'L', 'x': 58, 'y': 100, 'prize': 84}, {'id': 'M', 'x': 21, 'y': 28, 'prize': 49}, {'id': 'N', 'x': 25, 'y': 66, 'prize': 69}, {'id': 'O', 'x': 25, 'y': 72, 'prize': 28}, {'id': 'P', 'x': 0, 'y': 48, 'prize': 48}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 230.52390547960027, 'collected_prize': 707.0, 'objective': 707.0}","[['A', 'H', 'E', 'C', 'D', 'M', 'B', 'P', 'A'], ['A', 'O', 'A']]",38,json,names
TOP,TOP,"Out in town the kitchen has to assign deliveries so every bike leaves from and returns to the same spot, each rider keeps within a fixed distance for their shift, and no address gets duplicated on different riders’ lists. The plans are sorted by total tip potential, which is found by summing the tip amounts of all visited addresses — higher sums are preferred. The instance specifics appear below.

{
  ""total_locations_including_kitchen"": 14,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 4,
      ""tip_potential"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coordinate"": 49,
      ""y_coordinate"": 0,
      ""tip_potential"": 69
    },
    {
      ""location_id"": ""C"",
      ""x_coordinate"": 60,
      ""y_coordinate"": 0,
      ""tip_potential"": 10
    },
    {
      ""location_id"": ""D"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 24,
      ""tip_potential"": 10
    },
    {
      ""location_id"": ""E"",
      ""x_coordinate"": 30,
      ""y_coordinate"": 16,
      ""tip_potential"": 47
    },
    {
      ""location_id"": ""F"",
      ""x_coordinate"": 32,
      ""y_coordinate"": 24,
      ""tip_potential"": 86
    },
    {
      ""location_id"": ""G"",
      ""x_coordinate"": 73,
      ""y_coordinate"": 62,
      ""tip_potential"": 54
    },
    {
      ""location_id"": ""H"",
      ""x_coordinate"": 39,
      ""y_coordinate"": 77,
      ""tip_potential"": 60
    },
    {
      ""location_id"": ""I"",
      ""x_coordinate"": 32,
      ""y_coordinate"": 81,
      ""tip_potential"": 63
    },
    {
      ""location_id"": ""J"",
      ""x_coordinate"": 13,
      ""y_coordinate"": 77,
      ""tip_potential"": 16
    },
    {
      ""location_id"": ""K"",
      ""x_coordinate"": 57,
      ""y_coordinate"": 93,
      ""tip_potential"": 82
    },
    {
      ""location_id"": ""L"",
      ""x_coordinate"": 87,
      ""y_coordinate"": 83,
      ""tip_potential"": 50
    },
    {
      ""location_id"": ""M"",
      ""x_coordinate"": 98,
      ""y_coordinate"": 93,
      ""tip_potential"": 8
    },
    {
      ""location_id"": ""N"",
      ""x_coordinate"": 45,
      ""y_coordinate"": 100,
      ""tip_potential"": 53
    }
  ],
  ""central_kitchen_id"": ""A"",
  ""max_distance_per_rider"": 194.0,
  ""number_of_bikers"": 2
}

Also, when you send the plan back, keep it in a nice, simple JSON shape so it’s easy to read by the system. Something like this is perfect:

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

This just sketches the shape I need: ""solution"" is a list of routes, each route is an ordered list that starts and ends at the depot and lists the addresses visited in between. Treat it like a little delivery form rather than a file format — one array per rider, with the depot repeated at the start and end. It’s just an example of the shape, not the actual routes.

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': [[0, 4], [49, 0], [60, 0], [100, 24], [30, 16], [32, 24], [73, 62], [39, 77], [32, 81], [13, 77], [57, 93], [87, 83], [98, 93], [45, 100]], 'prizes': [0, 69, 10, 10, 47, 86, 54, 60, 63, 16, 82, 50, 8, 53], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 1, 2, 4, 5, 0], [0, 9, 8, 7, 0]], 'total_route_length': 324.53710201373605, 'collected_prize': 351.0, 'objective': 351.0}","[[0, 1, 2, 4, 5, 0], [0, 9, 8, 7, 0]]",351.0,"{'problem_type': 'TOP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 0, 'y': 4, 'prize': 0}, {'id': 'B', 'x': 49, 'y': 0, 'prize': 69}, {'id': 'C', 'x': 60, 'y': 0, 'prize': 10}, {'id': 'D', 'x': 100, 'y': 24, 'prize': 10}, {'id': 'E', 'x': 30, 'y': 16, 'prize': 47}, {'id': 'F', 'x': 32, 'y': 24, 'prize': 86}, {'id': 'G', 'x': 73, 'y': 62, 'prize': 54}, {'id': 'H', 'x': 39, 'y': 77, 'prize': 60}, {'id': 'I', 'x': 32, 'y': 81, 'prize': 63}, {'id': 'J', 'x': 13, 'y': 77, 'prize': 16}, {'id': 'K', 'x': 57, 'y': 93, 'prize': 82}, {'id': 'L', 'x': 87, 'y': 83, 'prize': 50}, {'id': 'M', 'x': 98, 'y': 93, 'prize': 8}, {'id': 'N', 'x': 45, 'y': 100, 'prize': 53}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 324.53710201373605, 'collected_prize': 351.0, 'objective': 351.0}","[['A', 'B', 'C', 'E', 'F', 'A'], ['A', 'J', 'I', 'H', 'A']]",39,json,names
TOP,TOP,"Recently the clinic asked us to plan clinician rounds so we reach as many high-need patients as possible. The plan is to assign homes to each clinician so that when you add up all the patient-need scores for the visited homes, that grand total is maximized. Each clinician’s route must be a round trip back to the clinic, must stay under their permitted travel distance, and no household can be visited by more than one clinician. The exact households, distances, clinician limits, and scores are shown below.

{
  ""total_locations_including_clinic"": 15,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""location_x_coordinate"": 0,
      ""location_y_coordinate"": 20,
      ""patient_need_score"": 0
    },
    {
      ""location_id"": ""B"",
      ""location_x_coordinate"": 2,
      ""location_y_coordinate"": 23,
      ""patient_need_score"": 74
    },
    {
      ""location_id"": ""C"",
      ""location_x_coordinate"": 2,
      ""location_y_coordinate"": 48,
      ""patient_need_score"": 42
    },
    {
      ""location_id"": ""D"",
      ""location_x_coordinate"": 0,
      ""location_y_coordinate"": 62,
      ""patient_need_score"": 32
    },
    {
      ""location_id"": ""E"",
      ""location_x_coordinate"": 0,
      ""location_y_coordinate"": 88,
      ""patient_need_score"": 14
    },
    {
      ""location_id"": ""F"",
      ""location_x_coordinate"": 5,
      ""location_y_coordinate"": 90,
      ""patient_need_score"": 87
    },
    {
      ""location_id"": ""G"",
      ""location_x_coordinate"": 5,
      ""location_y_coordinate"": 100,
      ""patient_need_score"": 6
    },
    {
      ""location_id"": ""H"",
      ""location_x_coordinate"": 100,
      ""location_y_coordinate"": 0,
      ""patient_need_score"": 63
    },
    {
      ""location_id"": ""I"",
      ""location_x_coordinate"": 98,
      ""location_y_coordinate"": 11,
      ""patient_need_score"": 69
    },
    {
      ""location_id"": ""J"",
      ""location_x_coordinate"": 95,
      ""location_y_coordinate"": 20,
      ""patient_need_score"": 97
    },
    {
      ""location_id"": ""K"",
      ""location_x_coordinate"": 100,
      ""location_y_coordinate"": 23,
      ""patient_need_score"": 35
    },
    {
      ""location_id"": ""L"",
      ""location_x_coordinate"": 95,
      ""location_y_coordinate"": 33,
      ""patient_need_score"": 65
    },
    {
      ""location_id"": ""M"",
      ""location_x_coordinate"": 100,
      ""location_y_coordinate"": 62,
      ""patient_need_score"": 23
    },
    {
      ""location_id"": ""N"",
      ""location_x_coordinate"": 95,
      ""location_y_coordinate"": 73,
      ""patient_need_score"": 29
    },
    {
      ""location_id"": ""O"",
      ""location_x_coordinate"": 100,
      ""location_y_coordinate"": 90,
      ""patient_need_score"": 80
    }
  ],
  ""clinic_node_id"": ""A"",
  ""max_travel_distance_per_clinician"": 194.0,
  ""n_clinicians"": 2
}

Also, when you send back your planned rounds, it'd be great if you used a simple JSON layout like this — just a casual list of each clinician's roundtrip, starting and ending at the clinic:

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

Think of that as a form: each inner list is one clinician's route, beginning at the clinic (clinic_id), listing the homes they visit in order (household_id values), and finishing back at the clinic (clinic_id again). This is just the shape I expect, not the actual routes — you'll fill in the real identifiers from the instance.

Important: use the exact identifiers 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, 20], [2, 23], [2, 48], [0, 62], [0, 88], [5, 90], [5, 100], [100, 0], [98, 11], [95, 20], [100, 23], [95, 33], [100, 62], [95, 73], [100, 90]], 'prizes': [0, 74, 42, 32, 14, 87, 6, 63, 69, 97, 35, 65, 23, 29, 80], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 9, 0], [0, 3, 2, 6, 5, 4, 1, 0]], 'total_route_length': 382.25008023030756, 'collected_prize': 352.0, 'objective': 352.0}","[[0, 9, 0], [0, 3, 2, 6, 5, 4, 1, 0]]",352.0,"{'problem_type': 'TOP', 'num_nodes': 15, 'nodes': [{'id': 'A', 'x': 0, 'y': 20, 'prize': 0}, {'id': 'B', 'x': 2, 'y': 23, 'prize': 74}, {'id': 'C', 'x': 2, 'y': 48, 'prize': 42}, {'id': 'D', 'x': 0, 'y': 62, 'prize': 32}, {'id': 'E', 'x': 0, 'y': 88, 'prize': 14}, {'id': 'F', 'x': 5, 'y': 90, 'prize': 87}, {'id': 'G', 'x': 5, 'y': 100, 'prize': 6}, {'id': 'H', 'x': 100, 'y': 0, 'prize': 63}, {'id': 'I', 'x': 98, 'y': 11, 'prize': 69}, {'id': 'J', 'x': 95, 'y': 20, 'prize': 97}, {'id': 'K', 'x': 100, 'y': 23, 'prize': 35}, {'id': 'L', 'x': 95, 'y': 33, 'prize': 65}, {'id': 'M', 'x': 100, 'y': 62, 'prize': 23}, {'id': 'N', 'x': 95, 'y': 73, 'prize': 29}, {'id': 'O', 'x': 100, 'y': 90, 'prize': 80}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 382.25008023030756, 'collected_prize': 352.0, 'objective': 352.0}","[['A', 'J', 'A'], ['A', 'D', 'C', 'G', 'F', 'E', 'B', 'A']]",40,json,names
TOP,TOP,"Someone needs to route our photographers so that everyone leaves and returns to HQ, nobody exceeds their personal distance cap, and no landmark ends up being shot by more than one person. The choice is the set of routes — which landmarks each photographer will cover — and the better choices are those that collect more artistic value overall (sum up the value ratings of each landmark photographed). All practical rules — return to HQ, stay within the distance limit, and avoid duplicate shots — must be respected. The full list of sites, their scores, and the distance constraints are shown below.

There are 16 sites including HQ 1; dispatch 2 photographers and ensure each route's round-trip length does not exceed 194.0.

| site_id | x_coord | y_coord | artistic_value |
|---|---|---|---|
| 1 | 17 | 2 | 0 |
| 2 | 41 | 0 | 1 |
| 3 | 100 | 14 | 56 |
| 4 | 34 | 21 | 58 |
| 5 | 30 | 45 | 54 |
| 6 | 20 | 62 | 23 |
| 7 | 28 | 59 | 6 |
| 8 | 67 | 56 | 31 |
| 9 | 18 | 68 | 54 |
| 10 | 72 | 72 | 63 |
| 11 | 93 | 70 | 21 |
| 12 | 4 | 83 | 71 |
| 13 | 68 | 78 | 5 |
| 14 | 0 | 92 | 35 |
| 15 | 80 | 89 | 53 |
| 16 | 100 | 100 | 83 |

Respect return to HQ 1, the per-photographer distance cap , and no duplicate shots when choosing routes.

Also, when you send back the routes, tuck them into this simple JSON layout so it's easy to check programmatically — nothing fancy, just one key with a list of routes.

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

Each inner list is one photographer's route: start at HQ, visit the listed landmarks in order, and come back to HQ. Think of hq_id and landmark_id as placeholders for whatever exact location labels your instance uses. This JSON is just a sketch of the shape I need, not the actual routes.

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': [[17, 2], [41, 0], [100, 14], [34, 21], [30, 45], [20, 62], [28, 59], [67, 56], [18, 68], [72, 72], [93, 70], [4, 83], [68, 78], [0, 92], [80, 89], [100, 100]], 'prizes': [0, 1, 56, 58, 54, 23, 6, 31, 54, 63, 21, 71, 5, 35, 53, 83], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 13, 11, 8, 5, 4, 0], [0, 3, 9, 12, 7, 0]], 'total_route_length': 384.8511278858525, 'collected_prize': 394.0, 'objective': 394.0}","[[0, 13, 11, 8, 5, 4, 0], [0, 3, 9, 12, 7, 0]]",394.0,"{'problem_type': 'TOP', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 17, 'y': 2, 'prize': 0}, {'id': 2, 'x': 41, 'y': 0, 'prize': 1}, {'id': 3, 'x': 100, 'y': 14, 'prize': 56}, {'id': 4, 'x': 34, 'y': 21, 'prize': 58}, {'id': 5, 'x': 30, 'y': 45, 'prize': 54}, {'id': 6, 'x': 20, 'y': 62, 'prize': 23}, {'id': 7, 'x': 28, 'y': 59, 'prize': 6}, {'id': 8, 'x': 67, 'y': 56, 'prize': 31}, {'id': 9, 'x': 18, 'y': 68, 'prize': 54}, {'id': 10, 'x': 72, 'y': 72, 'prize': 63}, {'id': 11, 'x': 93, 'y': 70, 'prize': 21}, {'id': 12, 'x': 4, 'y': 83, 'prize': 71}, {'id': 13, 'x': 68, 'y': 78, 'prize': 5}, {'id': 14, 'x': 0, 'y': 92, 'prize': 35}, {'id': 15, 'x': 80, 'y': 89, 'prize': 53}, {'id': 16, 'x': 100, 'y': 100, 'prize': 83}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 384.8511278858525, 'collected_prize': 394.0, 'objective': 394.0}","[[1, 14, 12, 9, 6, 5, 1], [1, 4, 10, 13, 8, 1]]",41,markdown_table,1
TOP,TOP,"I’m putting together collection runs for our charity volunteers: each person leaves from and returns to the distribution center, and has to keep their trip short enough so they’re not out too long. The choice to make is which donor stops each volunteer should visit — a better plan is simply the one that brings in more money overall, which is just the sum of all the donations picked up at the visited houses. Practical rules are that every run must start and end at the center, nobody’s trip can go over the distance/time cap, and no donor house gets visited more than once. The concrete addresses, donation amounts, number of volunteers and the maximum run lengths are shown below.

I'm listing the 11 mapped locations (distribution center 0 included); I'm scheduling 2 volunteers and each round trip must not exceed 194.0.

| location_id | coord_x | coord_y | donation_amount |
|---|---|---|---|
| 0 | 0 | 100 | 0 |
| 1 | 2 | 9 | 63 |
| 2 | 4 | 55 | 40 |
| 3 | 45 | 74 | 95 |
| 4 | 47 | 37 | 12 |
| 5 | 56 | 5 | 94 |
| 6 | 56 | 43 | 64 |
| 7 | 57 | 23 | 71 |
| 8 | 99 | 84 | 43 |
| 9 | 100 | 0 | 51 |
| 10 | 100 | 37 | 62 |

I'll make sure every run starts and ends at 0, stays within the 194.0 limit, and no donor house is visited more than once.

Oh, and when you send back the actual plan, just paste it in this little JSON shape so it's easy to read and check:

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

Think of that ""solution"" list as a set of routes: each inner list is one volunteer's trip, starting and ending at the distribution center (the depot), and listing the donor stops in the order they'll be visited. It's just a quick form so we all know which routes belong to which person.

This is only the sketch of the expected shape — not the final answer itself. Please make sure to use the exact identifiers from the instance input, with no renaming or invented 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], [2, 9], [4, 55], [45, 74], [47, 37], [56, 5], [56, 43], [57, 23], [99, 84], [100, 0], [100, 37]], 'prizes': [0, 63, 40, 95, 12, 94, 64, 71, 43, 51, 62], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 3, 6, 2, 0], [0, 7, 4, 0]], 'total_route_length': 375.01578237893307, 'collected_prize': 282.0, 'objective': 282.0}","[[0, 3, 6, 2, 0], [0, 7, 4, 0]]",282.0,"{'problem_type': 'TOP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 0, 'y': 100, 'prize': 0}, {'id': 1, 'x': 2, 'y': 9, 'prize': 63}, {'id': 2, 'x': 4, 'y': 55, 'prize': 40}, {'id': 3, 'x': 45, 'y': 74, 'prize': 95}, {'id': 4, 'x': 47, 'y': 37, 'prize': 12}, {'id': 5, 'x': 56, 'y': 5, 'prize': 94}, {'id': 6, 'x': 56, 'y': 43, 'prize': 64}, {'id': 7, 'x': 57, 'y': 23, 'prize': 71}, {'id': 8, 'x': 99, 'y': 84, 'prize': 43}, {'id': 9, 'x': 100, 'y': 0, 'prize': 51}, {'id': 10, 'x': 100, 'y': 37, 'prize': 62}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 375.01578237893307, 'collected_prize': 282.0, 'objective': 282.0}","[[0, 3, 6, 2, 0], [0, 7, 4, 0]]",42,markdown_table,0
TOP,TOP,"There’s a dispatcher trying to draw up routes so crews can check meters, always looping back to the depot and staying within the company’s travel cap for each tour. What matters is the total critical-issue score collected by the checked meters — you compute that by summing the scores of every meter that gets inspected — and the better the selection, the higher that sum. Rules are simple: each meter can only be visited once and each crew’s tour must start/end at the depot and stay under the travel limit. Concrete details are shown below.

# total_nodes_including_depot=19
# depot_node_id=0
# max_travel_distance_per_crew=194.0
# num_crews_available=2
meter_node_id,x_coord,y_coord,critical_issue_score
0,53,69,0
1,80,91,67
2,58,28,10
3,24,59,53
4,42,87,10
5,42,31,43
6,80,48,97
7,35,15,13
8,89,80,91
9,15,78,34
10,0,69,39
11,91,22,36
12,55,57,87
13,96,33,27
14,100,100,46
15,40,0,72
16,31,31,3
17,31,74,46
18,40,46,62

Also, when you send the routes back, please use the little JSON sketch below — it's just the shape I expect.

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

Pretty simple: ""solution"" is a list of crew tours, each tour is the sequence of stops (starting and ending at the depot), and the interior strings are the meter IDs in the order they'll be checked. This is just an example of the shape I want — not the actual answer.

One more thing: 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': [[53, 69], [80, 91], [58, 28], [24, 59], [42, 87], [42, 31], [80, 48], [35, 15], [89, 80], [15, 78], [0, 69], [91, 22], [55, 57], [96, 33], [100, 100], [40, 0], [31, 31], [31, 74], [40, 46]], 'prizes': [0, 67, 10, 53, 10, 43, 97, 13, 91, 34, 39, 36, 87, 27, 46, 72, 3, 46, 62], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 17, 3, 18, 5, 16, 7, 15, 2, 12, 0], [0, 6, 13, 8, 14, 1, 0]], 'total_route_length': 376.0136556629619, 'collected_prize': 717.0, 'objective': 717.0}","[[0, 17, 3, 18, 5, 16, 7, 15, 2, 12, 0], [0, 6, 13, 8, 14, 1, 0]]",717.0,"{'problem_type': 'TOP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 53, 'y': 69, 'prize': 0}, {'id': 1, 'x': 80, 'y': 91, 'prize': 67}, {'id': 2, 'x': 58, 'y': 28, 'prize': 10}, {'id': 3, 'x': 24, 'y': 59, 'prize': 53}, {'id': 4, 'x': 42, 'y': 87, 'prize': 10}, {'id': 5, 'x': 42, 'y': 31, 'prize': 43}, {'id': 6, 'x': 80, 'y': 48, 'prize': 97}, {'id': 7, 'x': 35, 'y': 15, 'prize': 13}, {'id': 8, 'x': 89, 'y': 80, 'prize': 91}, {'id': 9, 'x': 15, 'y': 78, 'prize': 34}, {'id': 10, 'x': 0, 'y': 69, 'prize': 39}, {'id': 11, 'x': 91, 'y': 22, 'prize': 36}, {'id': 12, 'x': 55, 'y': 57, 'prize': 87}, {'id': 13, 'x': 96, 'y': 33, 'prize': 27}, {'id': 14, 'x': 100, 'y': 100, 'prize': 46}, {'id': 15, 'x': 40, 'y': 0, 'prize': 72}, {'id': 16, 'x': 31, 'y': 31, 'prize': 3}, {'id': 17, 'x': 31, 'y': 74, 'prize': 46}, {'id': 18, 'x': 40, 'y': 46, 'prize': 62}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 376.0136556629619, 'collected_prize': 717.0, 'objective': 717.0}","[[0, 17, 3, 18, 5, 16, 7, 15, 2, 12, 0], [0, 6, 13, 8, 14, 1, 0]]",43,csv,0
TOP,TOP,"We’ve got a garage, a bunch of customers with different maintenance priorities, and a small crew of technicians who need to head out and return by the end of their run. The decision is which customers each technician should visit so the combined priority of all visited customers is as large as possible — success is measured by adding up the priority values of every customer that gets a visit. Every route must loop back to the garage, can’t be longer than the allowed distance for that technician, and each customer can only be assigned once. The specific locations, priorities, number of technicians, and distance caps appear below.

{
  ""total_locations_including_garage"": 11,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coord"": 67,
      ""y_coord"": 63,
      ""maintenance_priority"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coord"": 13,
      ""y_coord"": 53,
      ""maintenance_priority"": 85
    },
    {
      ""location_id"": ""C"",
      ""x_coord"": 0,
      ""y_coord"": 13,
      ""maintenance_priority"": 30
    },
    {
      ""location_id"": ""D"",
      ""x_coord"": 22,
      ""y_coord"": 71,
      ""maintenance_priority"": 93
    },
    {
      ""location_id"": ""E"",
      ""x_coord"": 9,
      ""y_coord"": 73,
      ""maintenance_priority"": 37
    },
    {
      ""location_id"": ""F"",
      ""x_coord"": 3,
      ""y_coord"": 75,
      ""maintenance_priority"": 68
    },
    {
      ""location_id"": ""G"",
      ""x_coord"": 72,
      ""y_coord"": 91,
      ""maintenance_priority"": 76
    },
    {
      ""location_id"": ""H"",
      ""x_coord"": 4,
      ""y_coord"": 100,
      ""maintenance_priority"": 72
    },
    {
      ""location_id"": ""I"",
      ""x_coord"": 100,
      ""y_coord"": 0,
      ""maintenance_priority"": 15
    },
    {
      ""location_id"": ""J"",
      ""x_coord"": 100,
      ""y_coord"": 51,
      ""maintenance_priority"": 39
    },
    {
      ""location_id"": ""K"",
      ""x_coord"": 96,
      ""y_coord"": 81,
      ""maintenance_priority"": 92
    }
  ],
  ""garage_node_id"": ""A"",
  ""max_route_distance_per_technician"": 194.0,
  ""num_technicians"": 2
}

Oh — and when you send back the routes, please use a simple JSON layout like this:

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

Here ""solution"" is just a list of routes. Each route is a list that starts and ends at the garage (garage_id) and has the customers visited in order (customer_id). The ""..."" just means you can have more than one customer on a route. This block is only a sketch of the shape I expect, not the actual answer.

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': [[67, 63], [13, 53], [0, 13], [22, 71], [9, 73], [3, 75], [72, 91], [4, 100], [100, 0], [100, 51], [96, 81]], 'prizes': [0, 85, 30, 93, 37, 68, 76, 72, 15, 39, 92], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 6, 9, 10, 0], [0, 1, 5, 7, 4, 3, 0]], 'total_route_length': 332.088527228316, 'collected_prize': 562.0, 'objective': 562.0}","[[0, 6, 9, 10, 0], [0, 1, 5, 7, 4, 3, 0]]",562.0,"{'problem_type': 'TOP', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 67, 'y': 63, 'prize': 0}, {'id': 'B', 'x': 13, 'y': 53, 'prize': 85}, {'id': 'C', 'x': 0, 'y': 13, 'prize': 30}, {'id': 'D', 'x': 22, 'y': 71, 'prize': 93}, {'id': 'E', 'x': 9, 'y': 73, 'prize': 37}, {'id': 'F', 'x': 3, 'y': 75, 'prize': 68}, {'id': 'G', 'x': 72, 'y': 91, 'prize': 76}, {'id': 'H', 'x': 4, 'y': 100, 'prize': 72}, {'id': 'I', 'x': 100, 'y': 0, 'prize': 15}, {'id': 'J', 'x': 100, 'y': 51, 'prize': 39}, {'id': 'K', 'x': 96, 'y': 81, 'prize': 92}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 332.088527228316, 'collected_prize': 562.0, 'objective': 562.0}","[['A', 'G', 'J', 'K', 'A'], ['A', 'B', 'F', 'H', 'E', 'D', 'A']]",44,json,names
TOP,TOP,"Back at the yard the crew leads are figuring routes: each team needs a loop that leaves from the municipal yard and returns there, and each loop has to stay under an allowed mileage. The challenge is divvying up the blocks so none are swept twice and the crews together pick up as much litter-reduction score as they can. Compare route sets by summing the scores of each unique cleaned block across all crews — the higher that total, the better the routing. The precise block scores, mileage limits, and other details are shown below.

# total_locations_including_yard=14
# municipal_yard_id=0
# max_mileage_per_crew=194.0
# n_crews=2
block_id,map_x_coordinate,map_y_coordinate,litter_reduction_score
0,6,100,0
1,64,97,100
2,0,98,81
3,44,77,90
4,91,80,47
5,73,74,78
6,54,76,17
7,97,66,23
8,91,65,90
9,100,51,66
10,89,49,75
11,45,41,100
12,1,4,87
13,8,0,43

Oh, and when you send the actual routes back, please use a small JSON snippet like this so it's easy to read and check:

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

Think of it as a simple form: ""solution"" holds a list of loops, each loop is the sequence of stops starting and ending at the yard, and each stop in the middle is a block you want that crew to clean. The ellipses just mean you can have as many blocks as fit the mileage limit — it's a shape sketch, not the final plan.

Quick note: this JSON example is just the expected shape — don't treat the placeholders as actual answers. Use the exact identifiers from the instance input when you fill it in — no renaming, no made-up labels. Be careful: 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': [[6, 100], [64, 97], [0, 98], [44, 77], [91, 80], [73, 74], [54, 76], [97, 66], [91, 65], [100, 51], [89, 49], [45, 41], [1, 4], [8, 0]], 'prizes': [0, 100, 81, 90, 47, 78, 17, 23, 90, 66, 75, 100, 87, 43], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 3, 6, 5, 8, 1, 0], [0, 11, 0]], 'total_route_length': 335.0939401167259, 'collected_prize': 556.0, 'objective': 556.0}","[[0, 3, 6, 5, 8, 1, 0], [0, 11, 0]]",556.0,"{'problem_type': 'TOP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 6, 'y': 100, 'prize': 0}, {'id': 1, 'x': 64, 'y': 97, 'prize': 100}, {'id': 2, 'x': 0, 'y': 98, 'prize': 81}, {'id': 3, 'x': 44, 'y': 77, 'prize': 90}, {'id': 4, 'x': 91, 'y': 80, 'prize': 47}, {'id': 5, 'x': 73, 'y': 74, 'prize': 78}, {'id': 6, 'x': 54, 'y': 76, 'prize': 17}, {'id': 7, 'x': 97, 'y': 66, 'prize': 23}, {'id': 8, 'x': 91, 'y': 65, 'prize': 90}, {'id': 9, 'x': 100, 'y': 51, 'prize': 66}, {'id': 10, 'x': 89, 'y': 49, 'prize': 75}, {'id': 11, 'x': 45, 'y': 41, 'prize': 100}, {'id': 12, 'x': 1, 'y': 4, 'prize': 87}, {'id': 13, 'x': 8, 'y': 0, 'prize': 43}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 335.0939401167259, 'collected_prize': 556.0, 'objective': 556.0}","[[0, 3, 6, 5, 8, 1, 0], [0, 11, 0]]",45,csv,0
TOP,TOP,"Someone in logistics is trying to sketch out daily rounds for the subscription callers: each rep must head out from headquarters and then return, and their path can’t be longer than the allowed limit. The choice is how to divvy up the houses so that each household is contacted at most once and the whole team’s subscription haul — the sum of the values of visited houses — is as big as it can be. Routes have to obey the distance cap and loop back to HQ. The specific instance details are shown below.

# total_locations_including_hq=17
# headquarters_location_id=A
# max_route_distance_per_representative=194.0
# n_representatives=2
location_id,x_coordinate,y_coordinate,subscription_revenue_potential
A,44,48,0
B,72,8,65
C,64,7,74
D,100,22,62
E,87,58,21
F,8,3,37
G,48,32,90
H,97,77,19
I,11,100,75
J,0,19,86
K,16,98,77
L,98,72,18
M,48,55,32
N,92,34,95
O,10,0,32
P,55,15,91
Q,6,40,77

If you want to send back a candidate plan, just use a tiny JSON shape like this:

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

Think of it like a form: ""solution"" holds a list of routes, each route is a list of stops that starts and ends at HQ (that's the hq_id), and the intermediate entries are the houses (house_id) the rep will visit. It's just an example of the shape I expect, not the real answer — fill in the actual identifiers from the instance when you return the plan.

Please 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': [[44, 48], [72, 8], [64, 7], [100, 22], [87, 58], [8, 3], [48, 32], [97, 77], [11, 100], [0, 19], [16, 98], [98, 72], [48, 55], [92, 34], [10, 0], [55, 15], [6, 40]], 'prizes': [0, 65, 74, 62, 21, 37, 90, 19, 75, 86, 77, 18, 32, 95, 32, 91, 77], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 10, 16, 9, 0], [0, 12, 6, 15, 2, 1, 3, 13, 4, 0]], 'total_route_length': 374.6403538053328, 'collected_prize': 770.0, 'objective': 770.0}","[[0, 10, 16, 9, 0], [0, 12, 6, 15, 2, 1, 3, 13, 4, 0]]",770.0,"{'problem_type': 'TOP', 'num_nodes': 17, 'nodes': [{'id': 'A', 'x': 44, 'y': 48, 'prize': 0}, {'id': 'B', 'x': 72, 'y': 8, 'prize': 65}, {'id': 'C', 'x': 64, 'y': 7, 'prize': 74}, {'id': 'D', 'x': 100, 'y': 22, 'prize': 62}, {'id': 'E', 'x': 87, 'y': 58, 'prize': 21}, {'id': 'F', 'x': 8, 'y': 3, 'prize': 37}, {'id': 'G', 'x': 48, 'y': 32, 'prize': 90}, {'id': 'H', 'x': 97, 'y': 77, 'prize': 19}, {'id': 'I', 'x': 11, 'y': 100, 'prize': 75}, {'id': 'J', 'x': 0, 'y': 19, 'prize': 86}, {'id': 'K', 'x': 16, 'y': 98, 'prize': 77}, {'id': 'L', 'x': 98, 'y': 72, 'prize': 18}, {'id': 'M', 'x': 48, 'y': 55, 'prize': 32}, {'id': 'N', 'x': 92, 'y': 34, 'prize': 95}, {'id': 'O', 'x': 10, 'y': 0, 'prize': 32}, {'id': 'P', 'x': 55, 'y': 15, 'prize': 91}, {'id': 'Q', 'x': 6, 'y': 40, 'prize': 77}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 374.6403538053328, 'collected_prize': 770.0, 'objective': 770.0}","[['A', 'K', 'Q', 'J', 'A'], ['A', 'M', 'G', 'P', 'C', 'B', 'D', 'N', 'E', 'A']]",46,csv,names
TOP,TOP,"On a busy morning the challenge is to send technicians from the service hub on round trips that don’t go over the company travel limit and that, together, cover the most important installs. Effectiveness is measured by totaling the priority scores of all addresses that get visited — the higher that sum, the better the schedule. Practical requirements: everyone must return to the hub, each trip must respect the travel cap, and no address gets visited twice. The concrete specifics are provided below.

{
  ""total_locations_including_hub"": 17,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""x_coordinate"": 0,
      ""y_coordinate"": 89,
      ""installation_priority_score"": 0
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 3,
      ""y_coordinate"": 84,
      ""installation_priority_score"": 41
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 90,
      ""y_coordinate"": 54,
      ""installation_priority_score"": 52
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 55,
      ""y_coordinate"": 82,
      ""installation_priority_score"": 3
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 81,
      ""y_coordinate"": 100,
      ""installation_priority_score"": 15
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 18,
      ""y_coordinate"": 2,
      ""installation_priority_score"": 58
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 36,
      ""y_coordinate"": 42,
      ""installation_priority_score"": 3
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 45,
      ""y_coordinate"": 25,
      ""installation_priority_score"": 4
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 76,
      ""y_coordinate"": 89,
      ""installation_priority_score"": 20
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 97,
      ""y_coordinate"": 83,
      ""installation_priority_score"": 42
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 90,
      ""y_coordinate"": 62,
      ""installation_priority_score"": 15
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 80,
      ""y_coordinate"": 60,
      ""installation_priority_score"": 54
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 16,
      ""y_coordinate"": 82,
      ""installation_priority_score"": 5
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 15,
      ""y_coordinate"": 0,
      ""installation_priority_score"": 35
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 93,
      ""y_coordinate"": 86,
      ""installation_priority_score"": 35
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 58,
      ""y_coordinate"": 67,
      ""installation_priority_score"": 31
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 100,
      ""y_coordinate"": 71,
      ""installation_priority_score"": 29
    }
  ],
  ""service_hub_id"": 1,
  ""max_trip_distance_per_technician"": 194.0,
  ""n_technicians_available"": 2
}

Oh, and when you send the schedule back, please use this simple JSON layout so I can read it easily:

{
  ""solution"": [[""hub_id"", ""address_id"", ... , ""hub_id""], [""hub_id"", ""address_id"", ... , ""hub_id""], ...]
}

The idea is straightforward: ""solution"" holds a list of routes. Each route is a little list that starts and ends at the hub (hub_id) and has the addresses visited in between (address_id). Think of it like filling out a route form for each technician — this block just shows the shape I need, not the actual plan.

Please make sure to 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, 89], [3, 84], [90, 54], [55, 82], [81, 100], [18, 2], [36, 42], [45, 25], [76, 89], [97, 83], [90, 62], [80, 60], [16, 82], [15, 0], [93, 86], [58, 67], [100, 71]], 'prizes': [0, 41, 52, 3, 15, 58, 3, 4, 20, 42, 15, 54, 5, 35, 35, 31, 29], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 15, 2, 11, 12, 0], [0, 5, 13, 1, 0]], 'total_route_length': 376.50580628690255, 'collected_prize': 276.0, 'objective': 276.0}","[[0, 15, 2, 11, 12, 0], [0, 5, 13, 1, 0]]",276.0,"{'problem_type': 'TOP', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 0, 'y': 89, 'prize': 0}, {'id': 2, 'x': 3, 'y': 84, 'prize': 41}, {'id': 3, 'x': 90, 'y': 54, 'prize': 52}, {'id': 4, 'x': 55, 'y': 82, 'prize': 3}, {'id': 5, 'x': 81, 'y': 100, 'prize': 15}, {'id': 6, 'x': 18, 'y': 2, 'prize': 58}, {'id': 7, 'x': 36, 'y': 42, 'prize': 3}, {'id': 8, 'x': 45, 'y': 25, 'prize': 4}, {'id': 9, 'x': 76, 'y': 89, 'prize': 20}, {'id': 10, 'x': 97, 'y': 83, 'prize': 42}, {'id': 11, 'x': 90, 'y': 62, 'prize': 15}, {'id': 12, 'x': 80, 'y': 60, 'prize': 54}, {'id': 13, 'x': 16, 'y': 82, 'prize': 5}, {'id': 14, 'x': 15, 'y': 0, 'prize': 35}, {'id': 15, 'x': 93, 'y': 86, 'prize': 35}, {'id': 16, 'x': 58, 'y': 67, 'prize': 31}, {'id': 17, 'x': 100, 'y': 71, 'prize': 29}], 'depot': 1, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 376.50580628690255, 'collected_prize': 276.0, 'objective': 276.0}","[[1, 16, 3, 12, 13, 1], [1, 6, 14, 2, 1]]",47,json,1
TOP,TOP,"Many people think of it as a scavenger run for good food: several volunteers leave the shelter, stop at different donors, and come back, all while sticking to a distance limit. The choice to make is how to split and order those stops so the total number of meals collected — simply the sum of the meal estimates at each donor actually visited, with no repeats — ends up highest. Each route must begin and end at the shelter and cannot go over the set distance allowance, and each donor can only be visited once. The concrete location and estimate details are provided below.

Here are the 14 distinct map locations (the shelter is node 0); 2 volunteers will run routes that must each stay within 194.0 round-trip distance.

| location_node_id | x_coord | y_coord | estimated_meals |
|---|---|---|---|
| 0 | 65 | 32 | 0 |
| 1 | 63 | 93 | 14 |
| 2 | 67 | 34 | 57 |
| 3 | 89 | 100 | 66 |
| 4 | 94 | 100 | 61 |
| 5 | 9 | 100 | 36 |
| 6 | 8 | 99 | 42 |
| 7 | 0 | 100 | 94 |
| 8 | 89 | 0 | 66 |
| 9 | 100 | 0 | 39 |
| 10 | 93 | 0 | 38 |
| 11 | 28 | 0 | 14 |
| 12 | 26 | 99 | 86 |
| 13 | 22 | 99 | 90 |

Plan routes to maximize the total estimated meals while keeping every volunteer's round trip at or below 194.0 and visiting each donor at most once.

Also, when you send the routes back, a handy, simple layout to follow is this JSON sketch:

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

This just means: ""solution"" is a list of routes; each route is a list that starts and ends with the shelter identifier and has donor identifiers for the stops in between. It's just the shape I expect, not the actual answer — a quick form to fill in with the real route IDs.

Please make 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': [[65, 32], [63, 93], [67, 34], [89, 100], [94, 100], [9, 100], [8, 99], [0, 100], [89, 0], [100, 0], [93, 0], [28, 0], [26, 99], [22, 99]], 'prizes': [0, 14, 57, 66, 61, 36, 42, 94, 66, 39, 38, 14, 86, 90], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 9, 10, 8, 11, 0], [0, 13, 5, 6, 12, 0]], 'total_route_length': 357.93028713607373, 'collected_prize': 468.0, 'objective': 468.0}","[[0, 9, 10, 8, 11, 0], [0, 13, 5, 6, 12, 0]]",468.0,"{'problem_type': 'TOP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 65, 'y': 32, 'prize': 0}, {'id': 1, 'x': 63, 'y': 93, 'prize': 14}, {'id': 2, 'x': 67, 'y': 34, 'prize': 57}, {'id': 3, 'x': 89, 'y': 100, 'prize': 66}, {'id': 4, 'x': 94, 'y': 100, 'prize': 61}, {'id': 5, 'x': 9, 'y': 100, 'prize': 36}, {'id': 6, 'x': 8, 'y': 99, 'prize': 42}, {'id': 7, 'x': 0, 'y': 100, 'prize': 94}, {'id': 8, 'x': 89, 'y': 0, 'prize': 66}, {'id': 9, 'x': 100, 'y': 0, 'prize': 39}, {'id': 10, 'x': 93, 'y': 0, 'prize': 38}, {'id': 11, 'x': 28, 'y': 0, 'prize': 14}, {'id': 12, 'x': 26, 'y': 99, 'prize': 86}, {'id': 13, 'x': 22, 'y': 99, 'prize': 90}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 357.93028713607373, 'collected_prize': 468.0, 'objective': 468.0}","[[0, 9, 10, 8, 11, 0], [0, 13, 5, 6, 12, 0]]",48,markdown_table,0
TOP,TOP,"Recently the outreach coordinator was sketching routes on a whiteboard: volunteers leave from the office, spend a limited amount of time visiting voters, then come back, and the coordinator needs to assign who hits which houses. The goal is to cover a set of locations whose persuasion scores, when added together, give the biggest total, while making sure no one’s route is too long and no house gets visited more than once. All volunteers must begin and end at the office. The exact list of stops, their persuasion values, and each volunteer’s limit are provided below.

There are 11 total locations (the office is node 0); the coordinator has 2 volunteers, and no volunteer's round-trip may exceed 194.0.

| location_id | coord_x | coord_y | persuasion_score |
|---|---|---|---|
| 0 | 7 | 0 | 0 |
| 1 | 2 | 29 | 74 |
| 2 | 2 | 53 | 80 |
| 3 | 0 | 57 | 91 |
| 4 | 7 | 88 | 50 |
| 5 | 2 | 100 | 94 |
| 6 | 93 | 72 | 82 |
| 7 | 93 | 29 | 12 |
| 8 | 98 | 16 | 51 |
| 9 | 100 | 26 | 82 |
| 10 | 95 | 57 | 100 |

Each house may be visited at most once, and every volunteer route must begin and end at node 0.

Oh — and when you send the routes back, a simple JSON layout like this is easiest to read:

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

Think of ""solution"" as a list of volunteer routes. Each inner list is one route: start at the office, visit the houses in order, then come back to the office. The little ""..."" just means you can put as many stops as fit on that route. This is just the shape I’m expecting, not the actual routes.

Please make sure to 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': [[7, 0], [2, 29], [2, 53], [0, 57], [7, 88], [2, 100], [93, 72], [93, 29], [98, 16], [100, 26], [95, 57]], 'prizes': [0, 74, 80, 91, 50, 94, 82, 12, 51, 82, 100], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 9, 0], [0, 4, 3, 2, 1, 0]], 'total_route_length': 370.812590216545, 'collected_prize': 377.0, 'objective': 377.0}","[[0, 9, 0], [0, 4, 3, 2, 1, 0]]",377.0,"{'problem_type': 'TOP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 7, 'y': 0, 'prize': 0}, {'id': 1, 'x': 2, 'y': 29, 'prize': 74}, {'id': 2, 'x': 2, 'y': 53, 'prize': 80}, {'id': 3, 'x': 0, 'y': 57, 'prize': 91}, {'id': 4, 'x': 7, 'y': 88, 'prize': 50}, {'id': 5, 'x': 2, 'y': 100, 'prize': 94}, {'id': 6, 'x': 93, 'y': 72, 'prize': 82}, {'id': 7, 'x': 93, 'y': 29, 'prize': 12}, {'id': 8, 'x': 98, 'y': 16, 'prize': 51}, {'id': 9, 'x': 100, 'y': 26, 'prize': 82}, {'id': 10, 'x': 95, 'y': 57, 'prize': 100}], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 370.812590216545, 'collected_prize': 377.0, 'objective': 377.0}","[[0, 9, 0], [0, 4, 3, 2, 1, 0]]",49,markdown_table,0
TOP,TOP,"Back at the depot early, the coordinator laid out cards for each crew: each squad must head out and return within a fixed mileage limit. The decision is which bike-share parking spots to include on each crew’s route so that, when the crew visits a spot, its congestion-relief value gets added to the day’s total — the bigger that summed total, the better. To avoid waste, any single parking spot can only be done once by the whole team, and no route can go past its distance allowance. The concrete stops, distances, and benefit numbers appear below.

{
  ""total_locations_including_depot"": 20,
  ""nodes"": [
    {
      ""spot_id"": ""A"",
      ""x_coord"": 36,
      ""y_coord"": 0,
      ""congestion_relief_value"": 0
    },
    {
      ""spot_id"": ""B"",
      ""x_coord"": 57,
      ""y_coord"": 12,
      ""congestion_relief_value"": 24
    },
    {
      ""spot_id"": ""C"",
      ""x_coord"": 14,
      ""y_coord"": 100,
      ""congestion_relief_value"": 64
    },
    {
      ""spot_id"": ""D"",
      ""x_coord"": 14,
      ""y_coord"": 88,
      ""congestion_relief_value"": 3
    },
    {
      ""spot_id"": ""E"",
      ""x_coord"": 7,
      ""y_coord"": 77,
      ""congestion_relief_value"": 7
    },
    {
      ""spot_id"": ""F"",
      ""x_coord"": 0,
      ""y_coord"": 33,
      ""congestion_relief_value"": 76
    },
    {
      ""spot_id"": ""G"",
      ""x_coord"": 34,
      ""y_coord"": 53,
      ""congestion_relief_value"": 87
    },
    {
      ""spot_id"": ""H"",
      ""x_coord"": 20,
      ""y_coord"": 74,
      ""congestion_relief_value"": 84
    },
    {
      ""spot_id"": ""I"",
      ""x_coord"": 23,
      ""y_coord"": 37,
      ""congestion_relief_value"": 54
    },
    {
      ""spot_id"": ""J"",
      ""x_coord"": 34,
      ""y_coord"": 26,
      ""congestion_relief_value"": 91
    },
    {
      ""spot_id"": ""K"",
      ""x_coord"": 43,
      ""y_coord"": 81,
      ""congestion_relief_value"": 96
    },
    {
      ""spot_id"": ""L"",
      ""x_coord"": 77,
      ""y_coord"": 91,
      ""congestion_relief_value"": 62
    },
    {
      ""spot_id"": ""M"",
      ""x_coord"": 82,
      ""y_coord"": 49,
      ""congestion_relief_value"": 67
    },
    {
      ""spot_id"": ""N"",
      ""x_coord"": 98,
      ""y_coord"": 53,
      ""congestion_relief_value"": 90
    },
    {
      ""spot_id"": ""O"",
      ""x_coord"": 95,
      ""y_coord"": 16,
      ""congestion_relief_value"": 78
    },
    {
      ""spot_id"": ""P"",
      ""x_coord"": 100,
      ""y_coord"": 86,
      ""congestion_relief_value"": 88
    },
    {
      ""spot_id"": ""Q"",
      ""x_coord"": 98,
      ""y_coord"": 86,
      ""congestion_relief_value"": 60
    },
    {
      ""spot_id"": ""R"",
      ""x_coord"": 89,
      ""y_coord"": 60,
      ""congestion_relief_value"": 33
    },
    {
      ""spot_id"": ""S"",
      ""x_coord"": 89,
      ""y_coord"": 70,
      ""congestion_relief_value"": 39
    },
    {
      ""spot_id"": ""T"",
      ""x_coord"": 89,
      ""y_coord"": 95,
      ""congestion_relief_value"": 23
    }
  ],
  ""depot_location_id"": ""A"",
  ""max_mileage_per_crew"": 194.0,
  ""n_crews"": 2
}

Oh, and when you give me the chosen routes, please follow this simple JSON shape:

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

Think of ""solution"" as a list of each crew's path — each inner list is that crew's route, starting and ending at the depot and listing the bike‑share parking spots visited in order. This snippet is just the sketch of the shape I need, not the actual answer.

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': [[36, 0], [57, 12], [14, 100], [14, 88], [7, 77], [0, 33], [34, 53], [20, 74], [23, 37], [34, 26], [43, 81], [77, 91], [82, 49], [98, 53], [95, 16], [100, 86], [98, 86], [89, 60], [89, 70], [89, 95]], 'prizes': [0, 24, 64, 3, 7, 76, 87, 84, 54, 91, 96, 62, 67, 90, 78, 88, 60, 33, 39, 23], 'depot': 0, 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'routes': [[0, 9, 8, 6, 7, 10, 0], [0, 12, 17, 13, 14, 1, 0]], 'total_route_length': 382.7989740712694, 'collected_prize': 704.0, 'objective': 704.0}","[[0, 9, 8, 6, 7, 10, 0], [0, 12, 17, 13, 14, 1, 0]]",704.0,"{'problem_type': 'TOP', 'num_nodes': 20, 'nodes': [{'id': 'A', 'x': 36, 'y': 0, 'prize': 0}, {'id': 'B', 'x': 57, 'y': 12, 'prize': 24}, {'id': 'C', 'x': 14, 'y': 100, 'prize': 64}, {'id': 'D', 'x': 14, 'y': 88, 'prize': 3}, {'id': 'E', 'x': 7, 'y': 77, 'prize': 7}, {'id': 'F', 'x': 0, 'y': 33, 'prize': 76}, {'id': 'G', 'x': 34, 'y': 53, 'prize': 87}, {'id': 'H', 'x': 20, 'y': 74, 'prize': 84}, {'id': 'I', 'x': 23, 'y': 37, 'prize': 54}, {'id': 'J', 'x': 34, 'y': 26, 'prize': 91}, {'id': 'K', 'x': 43, 'y': 81, 'prize': 96}, {'id': 'L', 'x': 77, 'y': 91, 'prize': 62}, {'id': 'M', 'x': 82, 'y': 49, 'prize': 67}, {'id': 'N', 'x': 98, 'y': 53, 'prize': 90}, {'id': 'O', 'x': 95, 'y': 16, 'prize': 78}, {'id': 'P', 'x': 100, 'y': 86, 'prize': 88}, {'id': 'Q', 'x': 98, 'y': 86, 'prize': 60}, {'id': 'R', 'x': 89, 'y': 60, 'prize': 33}, {'id': 'S', 'x': 89, 'y': 70, 'prize': 39}, {'id': 'T', 'x': 89, 'y': 95, 'prize': 23}], 'depot': 'A', 'max_length_per_vehicle': 194.0, 'n_vehicles': 2, 'total_route_length': 382.7989740712694, 'collected_prize': 704.0, 'objective': 704.0}","[['A', 'J', 'I', 'G', 'H', 'K', 'A'], ['A', 'M', 'R', 'N', 'O', 'B', 'A']]",50,json,names