CVRP/CVRP_L_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
CVRP,CVRP,"Someone from the store is lining up the drivers and thinking about how to split the work: every driver should start at the shop, cover a set of houses with their requested groceries exactly once, and return to the shop without exceeding the van’s load limit. To pick the best way, add up the distance each van travels and choose the arrangement with the smallest total distance. The concrete list of stops, quantities, and van capacities follows below.

# total_locations_including_shop=19
# shop_node_id=A
# van_capacity_units=150
location_id,location_x_coordinate,location_y_coordinate,grocery_demand_units
A,43,54,0
B,76,68,30
C,26,32,9
D,60,38,21
E,28,65,15
F,21,90,19
G,81,43,11
H,79,24,5
I,53,16,10
J,14,11,9
K,5,73,10
L,3,51,28
M,38,98,7
N,43,67,15
O,55,100,11
P,97,43,26
Q,100,100,6
R,0,0,7
S,0,92,11

Also, to keep things tidy, when you send back the routes just stick to a simple JSON shape like this so I can read it straight away:

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

Pretty much: ""solution"" is a list of routes; each route is an array that starts and ends with the shop_id and lists the houses (house_id) visited in order. It's just an example of the shape I expect—don't treat these placeholders as real answers.

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': [[43, 54], [76, 68], [26, 32], [60, 38], [28, 65], [21, 90], [81, 43], [79, 24], [53, 16], [14, 11], [5, 73], [3, 51], [38, 98], [43, 67], [55, 100], [97, 43], [100, 100], [0, 0], [0, 92]], 'depot': 0, 'demands': [0, 30, 9, 21, 15, 19, 11, 5, 10, 9, 10, 28, 7, 15, 11, 26, 6, 7, 11], 'capacity': 150, 'num_vehicles': 2, 'total_distance': 516.0979675320464, 'objective': 516.0979675320464}","[[0, 2, 9, 17, 11, 10, 18, 5, 4, 0], [0, 13, 12, 14, 16, 1, 6, 15, 7, 8, 3, 0]]",516.0979675320464,"{'problem_type': 'CVRP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 43, 'y': 54, 'demand': 0}, {'id': 'B', 'x': 76, 'y': 68, 'demand': 30}, {'id': 'C', 'x': 26, 'y': 32, 'demand': 9}, {'id': 'D', 'x': 60, 'y': 38, 'demand': 21}, {'id': 'E', 'x': 28, 'y': 65, 'demand': 15}, {'id': 'F', 'x': 21, 'y': 90, 'demand': 19}, {'id': 'G', 'x': 81, 'y': 43, 'demand': 11}, {'id': 'H', 'x': 79, 'y': 24, 'demand': 5}, {'id': 'I', 'x': 53, 'y': 16, 'demand': 10}, {'id': 'J', 'x': 14, 'y': 11, 'demand': 9}, {'id': 'K', 'x': 5, 'y': 73, 'demand': 10}, {'id': 'L', 'x': 3, 'y': 51, 'demand': 28}, {'id': 'M', 'x': 38, 'y': 98, 'demand': 7}, {'id': 'N', 'x': 43, 'y': 67, 'demand': 15}, {'id': 'O', 'x': 55, 'y': 100, 'demand': 11}, {'id': 'P', 'x': 97, 'y': 43, 'demand': 26}, {'id': 'Q', 'x': 100, 'y': 100, 'demand': 6}, {'id': 'R', 'x': 0, 'y': 0, 'demand': 7}, {'id': 'S', 'x': 0, 'y': 92, 'demand': 11}], 'depot': 'A', 'capacity': 150, 'num_vehicles': 2, 'total_distance': 516.0979675320464, 'objective': 516.0979675320464}","[['A', 'C', 'J', 'R', 'L', 'K', 'S', 'F', 'E', 'A'], ['A', 'N', 'M', 'O', 'Q', 'B', 'G', 'P', 'H', 'I', 'D', 'A']]",1,csv,names
CVRP,CVRP,"We’re coordinating the day’s routes so a handful of carriers can hand over every piece of mail one time and then return to the post office. The choice is which streets and houses each carrier covers, keeping each route’s total mail within the capacity of that carrier’s bag. The goal is to keep the overall driving low: take each carrier’s route length, add them up, and the plan with the lowest total miles is best. The concrete stop-by-stop details appear below.

There are 20 stops in total, including the post office 0, and each carrier's bag can hold up to 160 mail items.
We must visit stop 0 at (44, 51) and deliver 0 mail items.
We must visit stop 1 at (77, 66) and deliver 30 mail items.
We must visit stop 2 at (28, 63) and deliver 15 mail items.
We must visit stop 3 at (65, 53) and deliver 19 mail items.
We must visit stop 4 at (46, 37) and deliver 29 mail items.
We must visit stop 5 at (0, 25) and deliver 23 mail items.
We must visit stop 6 at (82, 53) and deliver 15 mail items.
We must visit stop 7 at (39, 22) and deliver 3 mail items.
We must visit stop 8 at (21, 39) and deliver 41 mail items.
We must visit stop 9 at (14, 5) and deliver 9 mail items.
We must visit stop 10 at (91, 81) and deliver 28 mail items.
We must visit stop 11 at (65, 80) and deliver 8 mail items.
We must visit stop 12 at (5, 71) and deliver 10 mail items.
We must visit stop 13 at (4, 47) and deliver 28 mail items.
We must visit stop 14 at (56, 100) and deliver 11 mail items.
We must visit stop 15 at (72, 0) and deliver 23 mail items.
We must visit stop 16 at (100, 90) and deliver 17 mail items.
We must visit stop 17 at (95, 8) and deliver 14 mail items.
We must visit stop 18 at (9, 12) and deliver 27 mail items.
We must visit stop 19 at (28, 0) and deliver 13 mail items.
Keep each route within 160 items, visit all 20 stops, and return every carrier to 0.

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

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

This shows the general layout: ""solution"" is a list of routes, each inner list is the sequence of stops a single carrier will follow (starting and ending at the post office). It's 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. 
- 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, 51], [77, 66], [28, 63], [65, 53], [46, 37], [0, 25], [82, 53], [39, 22], [21, 39], [14, 5], [91, 81], [65, 80], [5, 71], [4, 47], [56, 100], [72, 0], [100, 90], [95, 8], [9, 12], [28, 0]], 'depot': 0, 'demands': [0, 30, 15, 19, 29, 23, 15, 3, 41, 9, 28, 8, 10, 28, 11, 23, 17, 14, 27, 13], 'capacity': 160, 'num_vehicles': 3, 'total_distance': 545.381357211768, 'objective': 545.381357211768}","[[0, 17, 15, 19, 9, 18, 5, 7, 4, 0], [0, 11, 14, 16, 10, 1, 6, 3, 0], [0, 2, 12, 13, 8, 0]]",545.381357211768,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 44, 'y': 51, 'demand': 0}, {'id': 1, 'x': 77, 'y': 66, 'demand': 30}, {'id': 2, 'x': 28, 'y': 63, 'demand': 15}, {'id': 3, 'x': 65, 'y': 53, 'demand': 19}, {'id': 4, 'x': 46, 'y': 37, 'demand': 29}, {'id': 5, 'x': 0, 'y': 25, 'demand': 23}, {'id': 6, 'x': 82, 'y': 53, 'demand': 15}, {'id': 7, 'x': 39, 'y': 22, 'demand': 3}, {'id': 8, 'x': 21, 'y': 39, 'demand': 41}, {'id': 9, 'x': 14, 'y': 5, 'demand': 9}, {'id': 10, 'x': 91, 'y': 81, 'demand': 28}, {'id': 11, 'x': 65, 'y': 80, 'demand': 8}, {'id': 12, 'x': 5, 'y': 71, 'demand': 10}, {'id': 13, 'x': 4, 'y': 47, 'demand': 28}, {'id': 14, 'x': 56, 'y': 100, 'demand': 11}, {'id': 15, 'x': 72, 'y': 0, 'demand': 23}, {'id': 16, 'x': 100, 'y': 90, 'demand': 17}, {'id': 17, 'x': 95, 'y': 8, 'demand': 14}, {'id': 18, 'x': 9, 'y': 12, 'demand': 27}, {'id': 19, 'x': 28, 'y': 0, 'demand': 13}], 'depot': 0, 'capacity': 160, 'num_vehicles': 3, 'total_distance': 545.381357211768, 'objective': 545.381357211768}","[[0, 17, 15, 19, 9, 18, 5, 7, 4, 0], [0, 11, 14, 16, 10, 1, 6, 3, 0], [0, 2, 12, 13, 8, 0]]",2,nl,0
CVRP,CVRP,"A small school district wants to set up bus runs that begin and end at the district garage, pick up every child exactly once, and never put more kids on a bus than it can seat. The task is to figure out which students go on which bus and the order of stops for each run so nobody is missed or picked up more than once. The measure of a good plan is simple: the less the entire fleet has to drive, the better — add together the distances of all the bus routes to get that total, and try to reduce it. The concrete list of stops, student counts, and vehicle capacities appears below.

There are 20 total stops including the garage; the garage stop id is 1; each bus has a seating capacity of 100 students.
Stop 1 at (76, 75) has 0 students waiting to be picked up.
Stop 2 at (60, 4) has 11 students waiting to be picked up.
Stop 3 at (60, 98) has 25 students waiting to be picked up.
Stop 4 at (100, 18) has 5 students waiting to be picked up.
Stop 5 at (65, 87) has 11 students waiting to be picked up.
Stop 6 at (18, 0) has 21 students waiting to be picked up.
Stop 7 at (51, 94) has 12 students waiting to be picked up.
Stop 8 at (0, 34) has 26 students waiting to be picked up.
Stop 9 at (79, 82) has 16 students waiting to be picked up.
Stop 10 at (33, 29) has 21 students waiting to be picked up.
Stop 11 at (75, 4) has 2 students waiting to be picked up.
Stop 12 at (29, 40) has 63 students waiting to be picked up.
Stop 13 at (71, 28) has 7 students waiting to be picked up.
Stop 14 at (60, 27) has 17 students waiting to be picked up.
Stop 15 at (40, 39) has 10 students waiting to be picked up.
Stop 16 at (60, 51) has 25 students waiting to be picked up.
Stop 17 at (39, 100) has 25 students waiting to be picked up.
Stop 18 at (94, 40) has 5 students waiting to be picked up.
Stop 19 at (30, 35) has 22 students waiting to be picked up.
Stop 20 at (39, 45) has 17 students waiting to be picked up.
All routes must start and end at garage 1, visit every one of the 20 stops exactly once, and never carry more than 100 students on a run.

Also, when you reply, it'd be great if you follow a simple JSON layout so it's easy to read and check. Something like this:

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

This is just a sketch of the shape I expect: ""solution"" is a list of bus runs, each run is an ordered list of stop identifiers that starts and ends at the garage. Use the actual stop IDs from the instance for the garage and each stop — don't invent new names. The JSON above is only the shape, not the real plan.

Please use the exact identifiers given in the problem 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': [[76, 75], [60, 4], [60, 98], [100, 18], [65, 87], [18, 0], [51, 94], [0, 34], [79, 82], [33, 29], [75, 4], [29, 40], [71, 28], [60, 27], [40, 39], [60, 51], [39, 100], [94, 40], [30, 35], [39, 45]], 'depot': 0, 'demands': [0, 11, 25, 5, 11, 21, 12, 26, 16, 21, 2, 63, 7, 17, 10, 25, 25, 5, 22, 17], 'capacity': 100, 'num_vehicles': 4, 'total_distance': 635.7258320928303, 'objective': 635.7258320928303}","[[0, 17, 3, 10, 1, 13, 12, 15, 0], [0, 11, 19, 0], [0, 14, 9, 5, 7, 18, 0], [0, 4, 6, 16, 2, 8, 0]]",635.7258320928303,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 1, 'x': 76, 'y': 75, 'demand': 0}, {'id': 2, 'x': 60, 'y': 4, 'demand': 11}, {'id': 3, 'x': 60, 'y': 98, 'demand': 25}, {'id': 4, 'x': 100, 'y': 18, 'demand': 5}, {'id': 5, 'x': 65, 'y': 87, 'demand': 11}, {'id': 6, 'x': 18, 'y': 0, 'demand': 21}, {'id': 7, 'x': 51, 'y': 94, 'demand': 12}, {'id': 8, 'x': 0, 'y': 34, 'demand': 26}, {'id': 9, 'x': 79, 'y': 82, 'demand': 16}, {'id': 10, 'x': 33, 'y': 29, 'demand': 21}, {'id': 11, 'x': 75, 'y': 4, 'demand': 2}, {'id': 12, 'x': 29, 'y': 40, 'demand': 63}, {'id': 13, 'x': 71, 'y': 28, 'demand': 7}, {'id': 14, 'x': 60, 'y': 27, 'demand': 17}, {'id': 15, 'x': 40, 'y': 39, 'demand': 10}, {'id': 16, 'x': 60, 'y': 51, 'demand': 25}, {'id': 17, 'x': 39, 'y': 100, 'demand': 25}, {'id': 18, 'x': 94, 'y': 40, 'demand': 5}, {'id': 19, 'x': 30, 'y': 35, 'demand': 22}, {'id': 20, 'x': 39, 'y': 45, 'demand': 17}], 'depot': 1, 'capacity': 100, 'num_vehicles': 4, 'total_distance': 635.7258320928303, 'objective': 635.7258320928303}","[[1, 18, 4, 11, 2, 14, 13, 16, 1], [1, 12, 20, 1], [1, 15, 10, 6, 8, 19, 1], [1, 5, 7, 17, 3, 9, 1]]",3,nl,1
CVRP,CVRP,"Recently the kitchen had a full day of events and had to split up deliveries: the decision was how to group stops for each van so every event gets its drop exactly once, all routes begin and end at the kitchen, and loads stay within each vehicle’s limit. The clearer winner was the plan with the least total driving — just add up the distance of each round trip to see which plan wins. The concrete details follow below.

{
  ""total_locations_including_kitchen"": 22,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""location_x"": 0,
      ""location_y"": 0,
      ""order_quantity"": 0
    },
    {
      ""location_id"": 2,
      ""location_x"": 2,
      ""location_y"": 100,
      ""order_quantity"": 5
    },
    {
      ""location_id"": 3,
      ""location_x"": 32,
      ""location_y"": 0,
      ""order_quantity"": 6
    },
    {
      ""location_id"": 4,
      ""location_x"": 31,
      ""location_y"": 35,
      ""order_quantity"": 5
    },
    {
      ""location_id"": 5,
      ""location_x"": 37,
      ""location_y"": 26,
      ""order_quantity"": 9
    },
    {
      ""location_id"": 6,
      ""location_x"": 67,
      ""location_y"": 37,
      ""order_quantity"": 9
    },
    {
      ""location_id"": 7,
      ""location_x"": 36,
      ""location_y"": 76,
      ""order_quantity"": 5
    },
    {
      ""location_id"": 8,
      ""location_x"": 8,
      ""location_y"": 75,
      ""order_quantity"": 6
    },
    {
      ""location_id"": 9,
      ""location_x"": 76,
      ""location_y"": 63,
      ""order_quantity"": 6
    },
    {
      ""location_id"": 10,
      ""location_x"": 54,
      ""location_y"": 25,
      ""order_quantity"": 6
    },
    {
      ""location_id"": 11,
      ""location_x"": 37,
      ""location_y"": 52,
      ""order_quantity"": 7
    },
    {
      ""location_id"": 12,
      ""location_x"": 37,
      ""location_y"": 18,
      ""order_quantity"": 5
    },
    {
      ""location_id"": 13,
      ""location_x"": 100,
      ""location_y"": 19,
      ""order_quantity"": 7
    },
    {
      ""location_id"": 14,
      ""location_x"": 55,
      ""location_y"": 0,
      ""order_quantity"": 7
    },
    {
      ""location_id"": 15,
      ""location_x"": 19,
      ""location_y"": 51,
      ""order_quantity"": 7
    },
    {
      ""location_id"": 16,
      ""location_x"": 28,
      ""location_y"": 49,
      ""order_quantity"": 5
    },
    {
      ""location_id"": 17,
      ""location_x"": 37,
      ""location_y"": 53,
      ""order_quantity"": 9
    },
    {
      ""location_id"": 18,
      ""location_x"": 45,
      ""location_y"": 22,
      ""order_quantity"": 6
    },
    {
      ""location_id"": 19,
      ""location_x"": 93,
      ""location_y"": 72,
      ""order_quantity"": 8
    },
    {
      ""location_id"": 20,
      ""location_x"": 52,
      ""location_y"": 37,
      ""order_quantity"": 7
    },
    {
      ""location_id"": 21,
      ""location_x"": 22,
      ""location_y"": 43,
      ""order_quantity"": 7
    },
    {
      ""location_id"": 22,
      ""location_x"": 69,
      ""location_y"": 35,
      ""order_quantity"": 5
    }
  ],
  ""kitchen_node_id"": 1,
  ""van_capacity"": 101
}

If you want to hand me the route plan, a nice compact way is this JSON shape — just a top-level ""solution"" with a list of round trips:

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

Think of it like a little form: each inner list is one van's round trip (start at the kitchen, visit the listed stops in order, then return to the kitchen), and the outer list is the whole set of vans/routes. This is just a sketch of the shape I expect, not the actual answer.

Please use the exact identifiers from the instance input — no renaming and no extra labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[0, 0], [2, 100], [32, 0], [31, 35], [37, 26], [67, 37], [36, 76], [8, 75], [76, 63], [54, 25], [37, 52], [37, 18], [100, 19], [55, 0], [19, 51], [28, 49], [37, 53], [45, 22], [93, 72], [52, 37], [22, 43], [69, 35]], 'depot': 0, 'demands': [0, 5, 6, 5, 9, 9, 5, 6, 6, 6, 7, 5, 7, 7, 7, 5, 9, 6, 8, 7, 7, 5], 'capacity': 101, 'num_vehicles': 2, 'total_distance': 548.1294125168394, 'objective': 548.1294125168394}","[[0, 2, 13, 12, 18, 8, 21, 5, 19, 9, 17, 4, 11, 0], [0, 20, 14, 7, 1, 6, 16, 10, 15, 3, 0]]",548.1294125168394,"{'problem_type': 'CVRP', 'num_nodes': 22, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'demand': 0}, {'id': 2, 'x': 2, 'y': 100, 'demand': 5}, {'id': 3, 'x': 32, 'y': 0, 'demand': 6}, {'id': 4, 'x': 31, 'y': 35, 'demand': 5}, {'id': 5, 'x': 37, 'y': 26, 'demand': 9}, {'id': 6, 'x': 67, 'y': 37, 'demand': 9}, {'id': 7, 'x': 36, 'y': 76, 'demand': 5}, {'id': 8, 'x': 8, 'y': 75, 'demand': 6}, {'id': 9, 'x': 76, 'y': 63, 'demand': 6}, {'id': 10, 'x': 54, 'y': 25, 'demand': 6}, {'id': 11, 'x': 37, 'y': 52, 'demand': 7}, {'id': 12, 'x': 37, 'y': 18, 'demand': 5}, {'id': 13, 'x': 100, 'y': 19, 'demand': 7}, {'id': 14, 'x': 55, 'y': 0, 'demand': 7}, {'id': 15, 'x': 19, 'y': 51, 'demand': 7}, {'id': 16, 'x': 28, 'y': 49, 'demand': 5}, {'id': 17, 'x': 37, 'y': 53, 'demand': 9}, {'id': 18, 'x': 45, 'y': 22, 'demand': 6}, {'id': 19, 'x': 93, 'y': 72, 'demand': 8}, {'id': 20, 'x': 52, 'y': 37, 'demand': 7}, {'id': 21, 'x': 22, 'y': 43, 'demand': 7}, {'id': 22, 'x': 69, 'y': 35, 'demand': 5}], 'depot': 1, 'capacity': 101, 'num_vehicles': 2, 'total_distance': 548.1294125168394, 'objective': 548.1294125168394}","[[1, 3, 14, 13, 19, 9, 22, 6, 20, 10, 18, 5, 12, 1], [1, 21, 15, 8, 2, 7, 17, 11, 16, 4, 1]]",4,json,1
CVRP,CVRP,"There’s a routine to organize: nurses head out from the clinic, call on a list of patients, and then end the day back at the same clinic, with no patient getting more than one visit. Vehicles carry limited equipment, so each tour must fit within that load limit. The winning setup is the one that produces the fewest total miles driven (just add up the distance of every tour), and the concrete details — who’s where and how much they need, plus vehicle limits — appear below.

There are 19 locations including the clinic; nurses start and end every tour at clinic node A, and each vehicle can carry up to 125 units of equipment.
Patient at location A (x=75, y=79) requires 0 units of equipment.
Patient at location B (x=78, y=100) requires 66 units of equipment.
Patient at location C (x=23, y=43) requires 57 units of equipment.
Patient at location D (x=0, y=74) requires 61 units of equipment.
Patient at location E (x=30, y=0) requires 69 units of equipment.
Patient at location F (x=100, y=3) requires 60 units of equipment.
Patient at location G (x=98, y=69) requires 71 units of equipment.
Patient at location H (x=42, y=66) requires 10 units of equipment.
Patient at location I (x=69, y=58) requires 2 units of equipment.
Patient at location J (x=50, y=94) requires 4 units of equipment.
Patient at location K (x=34, y=90) requires 8 units of equipment.
Patient at location L (x=56, y=59) requires 4 units of equipment.
Patient at location M (x=20, y=42) requires 7 units of equipment.
Patient at location N (x=64, y=57) requires 9 units of equipment.
Patient at location O (x=17, y=12) requires 2 units of equipment.
Patient at location P (x=85, y=54) requires 4 units of equipment.
Patient at location Q (x=59, y=42) requires 9 units of equipment.
Patient at location R (x=84, y=46) requires 2 units of equipment.
Patient at location S (x=84, y=43) requires 2 units of equipment.
Ensure each nurse returns to clinic A and that no route exceeds the vehicle equipment capacity of 125 across the 19 locations.

When you send the routes back, just use a little JSON sketch like this so it's easy to read and parse:

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

Each inner list is one nurse's round: start at the clinic, visit the listed patients in order, then finish back at the clinic. Think of it like filling out a simple route sheet — it's just the order of stops for each vehicle. The block above is only an example of the shape I need, not the actual routes.

Please use the exact identifiers from the instance input — don't rename them or make up new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'coordinates': [[75, 79], [78, 100], [23, 43], [0, 74], [30, 0], [100, 3], [98, 69], [42, 66], [69, 58], [50, 94], [34, 90], [56, 59], [20, 42], [64, 57], [17, 12], [85, 54], [59, 42], [84, 46], [84, 43]], 'depot': 0, 'demands': [0, 66, 57, 61, 69, 60, 71, 10, 2, 4, 8, 4, 7, 9, 2, 4, 9, 2, 2], 'capacity': 125, 'num_vehicles': 4, 'total_distance': 768.449204417348, 'objective': 768.449204417348}","[[0, 15, 6, 0], [0, 3, 5, 18, 17, 0], [0, 9, 10, 7, 12, 14, 4, 16, 11, 13, 8, 0], [0, 2, 1, 0]]",768.449204417348,"{'problem_type': 'CVRP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 75, 'y': 79, 'demand': 0}, {'id': 'B', 'x': 78, 'y': 100, 'demand': 66}, {'id': 'C', 'x': 23, 'y': 43, 'demand': 57}, {'id': 'D', 'x': 0, 'y': 74, 'demand': 61}, {'id': 'E', 'x': 30, 'y': 0, 'demand': 69}, {'id': 'F', 'x': 100, 'y': 3, 'demand': 60}, {'id': 'G', 'x': 98, 'y': 69, 'demand': 71}, {'id': 'H', 'x': 42, 'y': 66, 'demand': 10}, {'id': 'I', 'x': 69, 'y': 58, 'demand': 2}, {'id': 'J', 'x': 50, 'y': 94, 'demand': 4}, {'id': 'K', 'x': 34, 'y': 90, 'demand': 8}, {'id': 'L', 'x': 56, 'y': 59, 'demand': 4}, {'id': 'M', 'x': 20, 'y': 42, 'demand': 7}, {'id': 'N', 'x': 64, 'y': 57, 'demand': 9}, {'id': 'O', 'x': 17, 'y': 12, 'demand': 2}, {'id': 'P', 'x': 85, 'y': 54, 'demand': 4}, {'id': 'Q', 'x': 59, 'y': 42, 'demand': 9}, {'id': 'R', 'x': 84, 'y': 46, 'demand': 2}, {'id': 'S', 'x': 84, 'y': 43, 'demand': 2}], 'depot': 'A', 'capacity': 125, 'num_vehicles': 4, 'total_distance': 768.449204417348, 'objective': 768.449204417348}","[['A', 'P', 'G', 'A'], ['A', 'D', 'F', 'S', 'R', 'A'], ['A', 'J', 'K', 'H', 'M', 'O', 'E', 'Q', 'L', 'N', 'I', 'A'], ['A', 'C', 'B', 'A']]",5,nl,names
CVRP,CVRP,"Someone from the shop is mapping out routes so the delivery vans can drop off all the orders — each address visited only once — then head back to base, making sure no van carries more bouquets than it’s supposed to. The decision is which stops to bundle on each van and in what sequence; the winning plan is the one with the smallest total driving distance, computed by totalling every van’s round-trip kilometres. The full list of addresses, demands and vehicle limits is shown below.

{
  ""total_locations_including_shop"": 16,
  ""nodes"": [
    {
      ""address_node_id"": 0,
      ""x_coordinate_km"": 9,
      ""y_coordinate_km"": 60,
      ""bouquets_required"": 0
    },
    {
      ""address_node_id"": 1,
      ""x_coordinate_km"": 8,
      ""y_coordinate_km"": 32,
      ""bouquets_required"": 24
    },
    {
      ""address_node_id"": 2,
      ""x_coordinate_km"": 64,
      ""y_coordinate_km"": 100,
      ""bouquets_required"": 9
    },
    {
      ""address_node_id"": 3,
      ""x_coordinate_km"": 32,
      ""y_coordinate_km"": 25,
      ""bouquets_required"": 18
    },
    {
      ""address_node_id"": 4,
      ""x_coordinate_km"": 14,
      ""y_coordinate_km"": 100,
      ""bouquets_required"": 9
    },
    {
      ""address_node_id"": 5,
      ""x_coordinate_km"": 81,
      ""y_coordinate_km"": 59,
      ""bouquets_required"": 14
    },
    {
      ""address_node_id"": 6,
      ""x_coordinate_km"": 44,
      ""y_coordinate_km"": 72,
      ""bouquets_required"": 18
    },
    {
      ""address_node_id"": 7,
      ""x_coordinate_km"": 95,
      ""y_coordinate_km"": 5,
      ""bouquets_required"": 13
    },
    {
      ""address_node_id"": 8,
      ""x_coordinate_km"": 90,
      ""y_coordinate_km"": 92,
      ""bouquets_required"": 2
    },
    {
      ""address_node_id"": 9,
      ""x_coordinate_km"": 64,
      ""y_coordinate_km"": 12,
      ""bouquets_required"": 18
    },
    {
      ""address_node_id"": 10,
      ""x_coordinate_km"": 44,
      ""y_coordinate_km"": 87,
      ""bouquets_required"": 24
    },
    {
      ""address_node_id"": 11,
      ""x_coordinate_km"": 39,
      ""y_coordinate_km"": 0,
      ""bouquets_required"": 13
    },
    {
      ""address_node_id"": 12,
      ""x_coordinate_km"": 100,
      ""y_coordinate_km"": 75,
      ""bouquets_required"": 24
    },
    {
      ""address_node_id"": 13,
      ""x_coordinate_km"": 6,
      ""y_coordinate_km"": 1,
      ""bouquets_required"": 4
    },
    {
      ""address_node_id"": 14,
      ""x_coordinate_km"": 51,
      ""y_coordinate_km"": 0,
      ""bouquets_required"": 13
    },
    {
      ""address_node_id"": 15,
      ""x_coordinate_km"": 0,
      ""y_coordinate_km"": 19,
      ""bouquets_required"": 4
    }
  ],
  ""shop_node_id"": 0,
  ""van_capacity_bouquets"": 100
}

You can just send back the routes in a little JSON shape like this — nothing fancy, just a quick sketch of the layout I expect:

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

Here ""solution"" is a list of van routes, each route itself is a list that starts and ends at the shop (the depot) and has the stops in the visiting order. Think of it like filling out a form: one inner list per van, each inner list showing the sequence of IDs the van will visit, returning to the shop at the end. This is only the expected shape — not the actual answer.

Please make sure every identifier you use matches the instance input exactly — do not rename any IDs 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': [[9, 60], [8, 32], [64, 100], [32, 25], [14, 100], [81, 59], [44, 72], [95, 5], [90, 92], [64, 12], [44, 87], [39, 0], [100, 75], [6, 1], [51, 0], [0, 19]], 'depot': 0, 'demands': [0, 24, 9, 18, 9, 14, 18, 13, 2, 18, 24, 13, 24, 4, 13, 4], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 559.3284195173424, 'objective': 559.3284195173424}","[[0, 6, 5, 12, 8, 2, 10, 4, 0], [0, 1, 0], [0, 15, 13, 11, 14, 7, 9, 3, 0]]",559.3284195173424,"{'problem_type': 'CVRP', 'num_nodes': 16, 'nodes': [{'id': 0, 'x': 9, 'y': 60, 'demand': 0}, {'id': 1, 'x': 8, 'y': 32, 'demand': 24}, {'id': 2, 'x': 64, 'y': 100, 'demand': 9}, {'id': 3, 'x': 32, 'y': 25, 'demand': 18}, {'id': 4, 'x': 14, 'y': 100, 'demand': 9}, {'id': 5, 'x': 81, 'y': 59, 'demand': 14}, {'id': 6, 'x': 44, 'y': 72, 'demand': 18}, {'id': 7, 'x': 95, 'y': 5, 'demand': 13}, {'id': 8, 'x': 90, 'y': 92, 'demand': 2}, {'id': 9, 'x': 64, 'y': 12, 'demand': 18}, {'id': 10, 'x': 44, 'y': 87, 'demand': 24}, {'id': 11, 'x': 39, 'y': 0, 'demand': 13}, {'id': 12, 'x': 100, 'y': 75, 'demand': 24}, {'id': 13, 'x': 6, 'y': 1, 'demand': 4}, {'id': 14, 'x': 51, 'y': 0, 'demand': 13}, {'id': 15, 'x': 0, 'y': 19, 'demand': 4}], 'depot': 0, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 559.3284195173424, 'objective': 559.3284195173424}","[[0, 6, 5, 12, 8, 2, 10, 4, 0], [0, 1, 0], [0, 15, 13, 11, 14, 7, 9, 3, 0]]",6,json,0
CVRP,CVRP,"Recently the city wanted to tidy up its collection plan: every truck departs from the depot, empties a selection of pickup points, and returns at the end of the run. Planners must decide how to group stops into circuits so every pickup gets emptied once and no truck is overloaded. The simplest way to compare plans is to look at the fleet’s total miles — sum the distance of each truck’s route and pick the plan with the smallest total. The concrete route details are shown below.

There are 18 locations including depot 1; vehicle capacity is 200.
Location 1 at (45, 54) with pickup demand 0.
Location 2 at (51, 85) with pickup demand 30.
Location 3 at (45, 83) with pickup demand 20.
Location 4 at (43, 82) with pickup demand 20.
Location 5 at (25, 92) with pickup demand 30.
Location 6 at (23, 100) with pickup demand 40.
Location 7 at (34, 57) with pickup demand 20.
Location 8 at (32, 57) with pickup demand 20.
Location 9 at (26, 57) with pickup demand 10.
Location 10 at (0, 38) with pickup demand 30.
Location 11 at (38, 31) with pickup demand 10.
Location 12 at (34, 31) with pickup demand 10.
Location 13 at (32, 31) with pickup demand 10.
Location 14 at (48, 0) with pickup demand 10.
Location 15 at (45, 0) with pickup demand 40.
Location 16 at (43, 0) with pickup demand 10.
Location 17 at (60, 31) with pickup demand 50.
Location 18 at (100, 23) with pickup demand 10.
Group stops into circuits so each pickup is emptied once and no circuit exceeds capacity 200.

You can just send the routes in a little JSON shape like this:

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

Each inner list is one truck’s circuit — start at the depot, list the pickup points in visit order, and come back to the depot at the end. Think of it like filling in a form: the outer array is the fleet, each inner array is a route.

This is just a sketch of the expected shape, not the actual answer. Please use the exact identifiers from the problem 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': [[45, 54], [51, 85], [45, 83], [43, 82], [25, 92], [23, 100], [34, 57], [32, 57], [26, 57], [0, 38], [38, 31], [34, 31], [32, 31], [48, 0], [45, 0], [43, 0], [60, 31], [100, 23]], 'depot': 0, 'demands': [0, 30, 20, 20, 30, 40, 20, 20, 10, 30, 10, 10, 10, 10, 40, 10, 50, 10], 'capacity': 200, 'num_vehicles': 2, 'total_distance': 376.09015682702034, 'objective': 376.09015682702034}","[[0, 8, 9, 12, 11, 10, 15, 14, 13, 17, 16, 0], [0, 1, 2, 3, 5, 4, 7, 6, 0]]",376.09015682702034,"{'problem_type': 'CVRP', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 45, 'y': 54, 'demand': 0}, {'id': 2, 'x': 51, 'y': 85, 'demand': 30}, {'id': 3, 'x': 45, 'y': 83, 'demand': 20}, {'id': 4, 'x': 43, 'y': 82, 'demand': 20}, {'id': 5, 'x': 25, 'y': 92, 'demand': 30}, {'id': 6, 'x': 23, 'y': 100, 'demand': 40}, {'id': 7, 'x': 34, 'y': 57, 'demand': 20}, {'id': 8, 'x': 32, 'y': 57, 'demand': 20}, {'id': 9, 'x': 26, 'y': 57, 'demand': 10}, {'id': 10, 'x': 0, 'y': 38, 'demand': 30}, {'id': 11, 'x': 38, 'y': 31, 'demand': 10}, {'id': 12, 'x': 34, 'y': 31, 'demand': 10}, {'id': 13, 'x': 32, 'y': 31, 'demand': 10}, {'id': 14, 'x': 48, 'y': 0, 'demand': 10}, {'id': 15, 'x': 45, 'y': 0, 'demand': 40}, {'id': 16, 'x': 43, 'y': 0, 'demand': 10}, {'id': 17, 'x': 60, 'y': 31, 'demand': 50}, {'id': 18, 'x': 100, 'y': 23, 'demand': 10}], 'depot': 1, 'capacity': 200, 'num_vehicles': 2, 'total_distance': 376.09015682702034, 'objective': 376.09015682702034}","[[1, 9, 10, 13, 12, 11, 16, 15, 14, 18, 17, 1], [1, 2, 3, 4, 6, 5, 8, 7, 1]]",7,nl,1
CVRP,CVRP,"On a busy morning the dispatch team must assign each truck a set of retailers to visit, with every truck leaving from and coming back to the warehouse and carrying only up to its allowed load. The decision is which shops go on which truck runs so no store is skipped or double-served and no vehicle is overloaded. The preferred plan is the one with the lowest total distance traveled by the whole fleet — you figure that by summing the distance of each round-trip — and the specific instance details are listed below.

There are 16 locations in total; the warehouse is node A; each truck may carry up to 100 units.
Location A is at (40, 0) and requires 0 units.
Location B is at (12, 79) and requires 5 units.
Location C is at (45, 87) and requires 18 units.
Location D is at (90, 43) and requires 26 units.
Location E is at (69, 100) and requires 14 units.
Location F is at (69, 30) and requires 24 units.
Location G is at (0, 57) and requires 16 units.
Location H is at (88, 72) and requires 8 units.
Location I is at (17, 34) and requires 3 units.
Location J is at (60, 62) and requires 3 units.
Location K is at (29, 17) and requires 13 units.
Location L is at (0, 53) and requires 8 units.
Location M is at (40, 94) and requires 16 units.
Location N is at (67, 91) and requires 4 units.
Location O is at (29, 11) and requires 7 units.
Location P is at (100, 83) and requires 18 units.
Routes must start and end at node A, serve each location exactly once, and never exceed the 100-unit truck limit.

Oh, and when you send back the planned runs, please follow this simple JSON shape so I can read it automatically:

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

Think of it like a form: ""solution"" holds a list of truck routes, each route is the round-trip sequence starting and ending at the warehouse (warehouse_id) and listing the shops (retailer_id) in the order they're visited. The ellipses just mean you can have as many stops as needed. This is only a sketch of the expected shape — not the actual answer.

Please be sure to use the exact identifiers from the instance input — don't rename them or add 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, 0], [12, 79], [45, 87], [90, 43], [69, 100], [69, 30], [0, 57], [88, 72], [17, 34], [60, 62], [29, 17], [0, 53], [40, 94], [67, 91], [29, 11], [100, 83]], 'depot': 0, 'demands': [0, 5, 18, 26, 14, 24, 16, 8, 3, 3, 13, 8, 16, 4, 7, 18], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 475.7555879654396, 'objective': 475.7555879654396}","[[0, 14, 10, 8, 11, 6, 1, 12, 2, 0], [0, 5, 3, 7, 15, 4, 13, 9, 0]]",475.7555879654396,"{'problem_type': 'CVRP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 40, 'y': 0, 'demand': 0}, {'id': 'B', 'x': 12, 'y': 79, 'demand': 5}, {'id': 'C', 'x': 45, 'y': 87, 'demand': 18}, {'id': 'D', 'x': 90, 'y': 43, 'demand': 26}, {'id': 'E', 'x': 69, 'y': 100, 'demand': 14}, {'id': 'F', 'x': 69, 'y': 30, 'demand': 24}, {'id': 'G', 'x': 0, 'y': 57, 'demand': 16}, {'id': 'H', 'x': 88, 'y': 72, 'demand': 8}, {'id': 'I', 'x': 17, 'y': 34, 'demand': 3}, {'id': 'J', 'x': 60, 'y': 62, 'demand': 3}, {'id': 'K', 'x': 29, 'y': 17, 'demand': 13}, {'id': 'L', 'x': 0, 'y': 53, 'demand': 8}, {'id': 'M', 'x': 40, 'y': 94, 'demand': 16}, {'id': 'N', 'x': 67, 'y': 91, 'demand': 4}, {'id': 'O', 'x': 29, 'y': 11, 'demand': 7}, {'id': 'P', 'x': 100, 'y': 83, 'demand': 18}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 2, 'total_distance': 475.7555879654396, 'objective': 475.7555879654396}","[['A', 'O', 'K', 'I', 'L', 'G', 'B', 'M', 'C', 'A'], ['A', 'F', 'D', 'H', 'P', 'E', 'N', 'J', 'A']]",8,nl,names
CVRP,CVRP,"I run the bookmobile for a small branch and need to plan the day so each neighborhood stop gets a visit exactly once. The job is to pick which vans go to which stops, making sure no van takes more books than its shelves can hold, and every route starts and ends back at the branch. The better plan is simply the one that keeps the overall driving down — add up the distance of each van’s loop and aim for the smallest total. The exact stops, distances, and vehicle shelving limits are shown below.

I have 22 locations including the branch 0, and each van can carry up to 210 books.
I have stop 0 at (0, 0) requiring 0 books.
I have stop 1 at (79, 52) requiring 64 books.
I have stop 2 at (100, 38) requiring 95 books.
I have stop 3 at (96, 40) requiring 10 books.
I have stop 4 at (80, 46) requiring 2 books.
I have stop 5 at (55, 28) requiring 5 books.
I have stop 6 at (78, 41) requiring 2 books.
I have stop 7 at (66, 100) requiring 7 books.
I have stop 8 at (79, 58) requiring 9 books.
I have stop 9 at (70, 2) requiring 8 books.
I have stop 10 at (80, 56) requiring 3 books.
I have stop 11 at (71, 12) requiring 1 books.
I have stop 12 at (69, 50) requiring 7 books.
I have stop 13 at (64, 83) requiring 7 books.
I have stop 14 at (74, 8) requiring 8 books.
I have stop 15 at (99, 46) requiring 5 books.
I have stop 16 at (81, 59) requiring 9 books.
I have stop 17 at (58, 48) requiring 3 books.
I have stop 18 at (85, 29) requiring 8 books.
I have stop 19 at (64, 5) requiring 9 books.
I have stop 20 at (72, 43) requiring 2 books.
I have stop 21 at (68, 67) requiring 4 books.
I'll use these details to assign vans and minimize total driving while respecting the van shelving capacity of 210.

Also, when you send me the plan, keep it in this simple JSON layout so it's easy to read and plug in:

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

Here ""solution"" is a list of routes. Each route is a list of place identifiers starting and ending at the branch (the first and last entry in each inner list). Think of each inner list as one van's loop: branch → stop → stop → … → branch. This snippet is just a sketch of the shape I expect — not the actual plan.

Please make sure you use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [79, 52], [100, 38], [96, 40], [80, 46], [55, 28], [78, 41], [66, 100], [79, 58], [70, 2], [80, 56], [71, 12], [69, 50], [64, 83], [74, 8], [99, 46], [81, 59], [58, 48], [85, 29], [64, 5], [72, 43], [68, 67]], 'depot': 0, 'demands': [0, 64, 95, 10, 2, 5, 2, 7, 9, 8, 3, 1, 7, 7, 8, 5, 9, 3, 8, 9, 2, 4], 'capacity': 210, 'num_vehicles': 2, 'total_distance': 522.150978180502, 'objective': 522.150978180502}","[[0, 19, 9, 14, 11, 18, 3, 2, 15, 4, 6, 20, 5, 0], [0, 17, 12, 1, 10, 16, 8, 21, 13, 7, 0]]",522.150978180502,"{'problem_type': 'CVRP', 'num_nodes': 22, 'nodes': [{'id': 0, 'x': 0, 'y': 0, 'demand': 0}, {'id': 1, 'x': 79, 'y': 52, 'demand': 64}, {'id': 2, 'x': 100, 'y': 38, 'demand': 95}, {'id': 3, 'x': 96, 'y': 40, 'demand': 10}, {'id': 4, 'x': 80, 'y': 46, 'demand': 2}, {'id': 5, 'x': 55, 'y': 28, 'demand': 5}, {'id': 6, 'x': 78, 'y': 41, 'demand': 2}, {'id': 7, 'x': 66, 'y': 100, 'demand': 7}, {'id': 8, 'x': 79, 'y': 58, 'demand': 9}, {'id': 9, 'x': 70, 'y': 2, 'demand': 8}, {'id': 10, 'x': 80, 'y': 56, 'demand': 3}, {'id': 11, 'x': 71, 'y': 12, 'demand': 1}, {'id': 12, 'x': 69, 'y': 50, 'demand': 7}, {'id': 13, 'x': 64, 'y': 83, 'demand': 7}, {'id': 14, 'x': 74, 'y': 8, 'demand': 8}, {'id': 15, 'x': 99, 'y': 46, 'demand': 5}, {'id': 16, 'x': 81, 'y': 59, 'demand': 9}, {'id': 17, 'x': 58, 'y': 48, 'demand': 3}, {'id': 18, 'x': 85, 'y': 29, 'demand': 8}, {'id': 19, 'x': 64, 'y': 5, 'demand': 9}, {'id': 20, 'x': 72, 'y': 43, 'demand': 2}, {'id': 21, 'x': 68, 'y': 67, 'demand': 4}], 'depot': 0, 'capacity': 210, 'num_vehicles': 2, 'total_distance': 522.150978180502, 'objective': 522.150978180502}","[[0, 19, 9, 14, 11, 18, 3, 2, 15, 4, 6, 20, 5, 0], [0, 17, 12, 1, 10, 16, 8, 21, 13, 7, 0]]",9,nl,0
CVRP,CVRP,"We need to lay out pickup runs from the lab for several couriers: each run starts at the lab, visits some clinics, then returns to the lab, and every clinic must be visited once and only once. Each courier’s cooler has a maximum load, so the number of specimens per run has to fit, and the better plan is the one where the sum of all route distances is lowest — simply total the miles of every courier’s circuit to compare plans. The specific clinics, sample counts, cooler capacities, and route distances are listed below.

We list 19 total locations including the lab A, and each courier's cooler capacity is 200 specimens.
We must pick up 0 specimens at location A located at (44, 42).
We must pick up 3 specimens at location B located at (26, 35).
We must pick up 5 specimens at location C located at (17, 62).
We must pick up 19 specimens at location D located at (72, 42).
We must pick up 8 specimens at location E located at (35, 0).
We must pick up 17 specimens at location F located at (7, 76).
We must pick up 16 specimens at location G located at (44, 49).
We must pick up 14 specimens at location H located at (100, 69).
We must pick up 5 specimens at location I located at (57, 3).
We must pick up 5 specimens at location J located at (24, 10).
We must pick up 13 specimens at location K located at (67, 58).
We must pick up 9 specimens at location L located at (30, 53).
We must pick up 18 specimens at location M located at (85, 33).
We must pick up 6 specimens at location N located at (78, 10).
We must pick up 9 specimens at location O located at (7, 100).
We must pick up 9 specimens at location P located at (61, 17).
We must pick up 7 specimens at location Q located at (0, 36).
We must pick up 2 specimens at location R located at (20, 24).
We must pick up 11 specimens at location S located at (20, 31).
We will total the miles of every courier's circuit to compare plans.

Also, when you send back the plan, please stick to this simple JSON layout so it's easy for the system to pick up:

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

Pretty straightforward: ""solution"" is a list of runs, each inner list is one courier's circuit that starts and ends at the lab (lab_id), with the clinic ids visited in between — the ... just means you can have more clinic ids in that spot. This is just the shape I expect, not the actual answer.

One more thing: use the exact identifiers from the instance input — don't rename them or invent new ones. 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”. Use those exact labels when you give the real routes.","{'coordinates': [[44, 42], [26, 35], [17, 62], [72, 42], [35, 0], [7, 76], [44, 49], [100, 69], [57, 3], [24, 10], [67, 58], [30, 53], [85, 33], [78, 10], [7, 100], [61, 17], [0, 36], [20, 24], [20, 31]], 'depot': 0, 'demands': [0, 3, 5, 19, 8, 17, 16, 14, 5, 5, 13, 9, 18, 6, 9, 9, 7, 2, 11], 'capacity': 200, 'num_vehicles': 1, 'total_distance': 407.6316938894165, 'objective': 407.6316938894165}","[[0, 6, 11, 2, 14, 5, 16, 1, 18, 17, 9, 4, 8, 15, 13, 12, 3, 7, 10, 0]]",407.6316938894165,"{'problem_type': 'CVRP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 44, 'y': 42, 'demand': 0}, {'id': 'B', 'x': 26, 'y': 35, 'demand': 3}, {'id': 'C', 'x': 17, 'y': 62, 'demand': 5}, {'id': 'D', 'x': 72, 'y': 42, 'demand': 19}, {'id': 'E', 'x': 35, 'y': 0, 'demand': 8}, {'id': 'F', 'x': 7, 'y': 76, 'demand': 17}, {'id': 'G', 'x': 44, 'y': 49, 'demand': 16}, {'id': 'H', 'x': 100, 'y': 69, 'demand': 14}, {'id': 'I', 'x': 57, 'y': 3, 'demand': 5}, {'id': 'J', 'x': 24, 'y': 10, 'demand': 5}, {'id': 'K', 'x': 67, 'y': 58, 'demand': 13}, {'id': 'L', 'x': 30, 'y': 53, 'demand': 9}, {'id': 'M', 'x': 85, 'y': 33, 'demand': 18}, {'id': 'N', 'x': 78, 'y': 10, 'demand': 6}, {'id': 'O', 'x': 7, 'y': 100, 'demand': 9}, {'id': 'P', 'x': 61, 'y': 17, 'demand': 9}, {'id': 'Q', 'x': 0, 'y': 36, 'demand': 7}, {'id': 'R', 'x': 20, 'y': 24, 'demand': 2}, {'id': 'S', 'x': 20, 'y': 31, 'demand': 11}], 'depot': 'A', 'capacity': 200, 'num_vehicles': 1, 'total_distance': 407.6316938894165, 'objective': 407.6316938894165}","[['A', 'G', 'L', 'C', 'O', 'F', 'Q', 'B', 'S', 'R', 'J', 'E', 'I', 'P', 'N', 'M', 'D', 'H', 'K', 'A']]",10,nl,names
CVRP,CVRP,"We’ve got a press, a stack of bundles, and a bunch of newsstands scattered around town; the challenge is figuring the runs for each carrier so each stand gets a single bundle and every runner comes back to the press. Every round has to respect what a carrier’s bag can hold, and nothing can be handed out twice or left out. The best way to judge two different sets of rounds is by how short their combined travel is — add up the distance of every round and the smaller total wins. The specific addresses, demands, and capacities are shown below.

# total_locations_including_press=25
# press_node_id=0
# carrier_bag_capacity=100
location_id,x_coordinate,y_coordinate,bundles_required
0,10,84,0
1,34,19,3
2,0,95,9
3,20,38,13
4,4,0,10
5,23,39,10
6,84,83,23
7,7,12,6
8,9,7,15
9,37,22,15
10,78,83,10
11,9,9,18
12,25,43,7
13,62,5,60
14,96,100,12
15,9,5,9
16,84,87,17
17,78,83,1
18,100,98,20
19,35,24,14
20,43,26,6
21,21,45,9
22,9,1,3
23,76,85,1
24,9,14,13

Oh — and when you hand me the routes back, please use this easy JSON shape so I can parse the runs without guessing:

{
  ""solution"": [[press_id, stand_id, ... , press_id], [press_id, stand_id, ... , press_id], ...]
}

Each inner list is one carrier’s run: it starts at the press (press_id), visits the stands in the order listed (stand_id placeholders), and returns to the press. The outer list collects all the runs. This is just a sketch of the shape I expect, not the actual answer.

Please be sure to use the exact identifiers from the instance input — don’t rename them or add 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': [[10, 84], [34, 19], [0, 95], [20, 38], [4, 0], [23, 39], [84, 83], [7, 12], [9, 7], [37, 22], [78, 83], [9, 9], [25, 43], [62, 5], [96, 100], [9, 5], [84, 87], [78, 83], [100, 98], [35, 24], [43, 26], [21, 45], [9, 1], [76, 85], [9, 14]], 'depot': 0, 'demands': [0, 3, 9, 13, 10, 10, 23, 6, 15, 15, 10, 18, 7, 60, 12, 9, 17, 1, 20, 14, 6, 9, 3, 1, 13], 'capacity': 100, 'num_vehicles': 4, 'total_distance': 642.3472058216876, 'objective': 642.3472058216876}","[[0, 7, 4, 22, 15, 8, 11, 24, 3, 5, 0], [0, 20, 13, 1, 9, 19, 0], [0, 2, 0], [0, 14, 18, 16, 6, 17, 10, 23, 12, 21, 0]]",642.3472058216876,"{'problem_type': 'CVRP', 'num_nodes': 25, 'nodes': [{'id': 0, 'x': 10, 'y': 84, 'demand': 0}, {'id': 1, 'x': 34, 'y': 19, 'demand': 3}, {'id': 2, 'x': 0, 'y': 95, 'demand': 9}, {'id': 3, 'x': 20, 'y': 38, 'demand': 13}, {'id': 4, 'x': 4, 'y': 0, 'demand': 10}, {'id': 5, 'x': 23, 'y': 39, 'demand': 10}, {'id': 6, 'x': 84, 'y': 83, 'demand': 23}, {'id': 7, 'x': 7, 'y': 12, 'demand': 6}, {'id': 8, 'x': 9, 'y': 7, 'demand': 15}, {'id': 9, 'x': 37, 'y': 22, 'demand': 15}, {'id': 10, 'x': 78, 'y': 83, 'demand': 10}, {'id': 11, 'x': 9, 'y': 9, 'demand': 18}, {'id': 12, 'x': 25, 'y': 43, 'demand': 7}, {'id': 13, 'x': 62, 'y': 5, 'demand': 60}, {'id': 14, 'x': 96, 'y': 100, 'demand': 12}, {'id': 15, 'x': 9, 'y': 5, 'demand': 9}, {'id': 16, 'x': 84, 'y': 87, 'demand': 17}, {'id': 17, 'x': 78, 'y': 83, 'demand': 1}, {'id': 18, 'x': 100, 'y': 98, 'demand': 20}, {'id': 19, 'x': 35, 'y': 24, 'demand': 14}, {'id': 20, 'x': 43, 'y': 26, 'demand': 6}, {'id': 21, 'x': 21, 'y': 45, 'demand': 9}, {'id': 22, 'x': 9, 'y': 1, 'demand': 3}, {'id': 23, 'x': 76, 'y': 85, 'demand': 1}, {'id': 24, 'x': 9, 'y': 14, 'demand': 13}], 'depot': 0, 'capacity': 100, 'num_vehicles': 4, 'total_distance': 642.3472058216876, 'objective': 642.3472058216876}","[[0, 7, 4, 22, 15, 8, 11, 24, 3, 5, 0], [0, 20, 13, 1, 9, 19, 0], [0, 2, 0], [0, 14, 18, 16, 6, 17, 10, 23, 12, 21, 0]]",11,csv,0
CVRP,CVRP,"At the warehouse the crew lays out routes so every truck leaves, performs one delivery at each assigned house, and comes back to base. The decision makers need to decide which addresses go on which truck and in what sequence so nobody gets skipped or double-served and vehicle load limits aren’t exceeded. The better routing is simply the one with the lowest total distance — add up the distance for every truck’s round trip and the smallest total wins. The concrete details for the loads and addresses are shown below.

There are 18 locations including the warehouse 1, and each truck may carry up to 1007 units.

| address_node_id | map_x_coordinate | map_y_coordinate | delivery_load_demand |
|---|---|---|---|
| 1 | 0 | 8 | 0 |
| 2 | 85 | 61 | 37 |
| 3 | 4 | 10 | 91 |
| 4 | 31 | 18 | 38 |
| 5 | 100 | 52 | 4 |
| 6 | 93 | 69 | 39 |
| 7 | 87 | 53 | 46 |
| 8 | 78 | 63 | 29 |
| 9 | 4 | 12 | 73 |
| 10 | 35 | 86 | 15 |
| 11 | 49 | 56 | 90 |
| 12 | 28 | 6 | 11 |
| 13 | 39 | 88 | 49 |
| 14 | 54 | 100 | 29 |
| 15 | 73 | 81 | 53 |
| 16 | 15 | 9 | 24 |
| 17 | 41 | 0 | 5 |
| 18 | 20 | 5 | 71 |

Assign each address to truck routes that start and end at 1, respect the 1007 limit, and cover all 18 locations without duplication.

Oh, and when you hand in the routes, please follow this simple JSON layout so it's easy to read by the system:

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

This is just a sketch of the shape I expect: ""solution"" is a list of the trucks' round-trip routes, each route is a list of stop IDs that starts and ends at the depot (here labeled as ""warehouse_id"" in the example), and each inner list shows the sequence of addresses visited on that truck's trip. It's informal — think of it as filling out a short form that says which stops go on which truck and in what order.

Please be sure to use the exact identifiers from the instance input — don't rename them and don't 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, 8], [85, 61], [4, 10], [31, 18], [100, 52], [93, 69], [87, 53], [78, 63], [4, 12], [35, 86], [49, 56], [28, 6], [39, 88], [54, 100], [73, 81], [15, 9], [41, 0], [20, 5]], 'depot': 0, 'demands': [0, 37, 91, 38, 4, 39, 46, 29, 73, 15, 90, 11, 49, 29, 53, 24, 5, 71], 'capacity': 1007, 'num_vehicles': 1, 'total_distance': 342.1981222325848, 'objective': 342.1981222325848}","[[0, 8, 3, 10, 9, 12, 13, 14, 7, 1, 5, 4, 6, 16, 11, 17, 15, 2, 0]]",342.1981222325848,"{'problem_type': 'CVRP', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 0, 'y': 8, 'demand': 0}, {'id': 2, 'x': 85, 'y': 61, 'demand': 37}, {'id': 3, 'x': 4, 'y': 10, 'demand': 91}, {'id': 4, 'x': 31, 'y': 18, 'demand': 38}, {'id': 5, 'x': 100, 'y': 52, 'demand': 4}, {'id': 6, 'x': 93, 'y': 69, 'demand': 39}, {'id': 7, 'x': 87, 'y': 53, 'demand': 46}, {'id': 8, 'x': 78, 'y': 63, 'demand': 29}, {'id': 9, 'x': 4, 'y': 12, 'demand': 73}, {'id': 10, 'x': 35, 'y': 86, 'demand': 15}, {'id': 11, 'x': 49, 'y': 56, 'demand': 90}, {'id': 12, 'x': 28, 'y': 6, 'demand': 11}, {'id': 13, 'x': 39, 'y': 88, 'demand': 49}, {'id': 14, 'x': 54, 'y': 100, 'demand': 29}, {'id': 15, 'x': 73, 'y': 81, 'demand': 53}, {'id': 16, 'x': 15, 'y': 9, 'demand': 24}, {'id': 17, 'x': 41, 'y': 0, 'demand': 5}, {'id': 18, 'x': 20, 'y': 5, 'demand': 71}], 'depot': 1, 'capacity': 1007, 'num_vehicles': 1, 'total_distance': 342.1981222325848, 'objective': 342.1981222325848}","[[1, 9, 4, 11, 10, 13, 14, 15, 8, 2, 6, 5, 7, 17, 12, 18, 16, 3, 1]]",12,markdown_table,1
CVRP,CVRP,"Many stores depend on a single pet supply hub, so the practical job is to split them into truck routes and choose the visit order so each shop is visited exactly once. Every trip must begin at the hub and return there, and no truck can carry more than its allowed load. The winner among possible plans is the one with the smallest combined mileage for all trucks — total distance equals the sum of each route’s length — and the detailed store and vehicle info is provided below.

{
  ""total_locations_including_hub"": 24,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""coord_x"": 78,
      ""coord_y"": 56,
      ""store_demand_units"": 0
    },
    {
      ""location_id"": ""B"",
      ""coord_x"": 80,
      ""coord_y"": 0,
      ""store_demand_units"": 26
    },
    {
      ""location_id"": ""C"",
      ""coord_x"": 52,
      ""coord_y"": 25,
      ""store_demand_units"": 1
    },
    {
      ""location_id"": ""D"",
      ""coord_x"": 61,
      ""coord_y"": 38,
      ""store_demand_units"": 2
    },
    {
      ""location_id"": ""E"",
      ""coord_x"": 98,
      ""coord_y"": 46,
      ""store_demand_units"": 13
    },
    {
      ""location_id"": ""F"",
      ""coord_x"": 35,
      ""coord_y"": 54,
      ""store_demand_units"": 7
    },
    {
      ""location_id"": ""G"",
      ""coord_x"": 80,
      ""coord_y"": 65,
      ""store_demand_units"": 10
    },
    {
      ""location_id"": ""H"",
      ""coord_x"": 37,
      ""coord_y"": 52,
      ""store_demand_units"": 7
    },
    {
      ""location_id"": ""I"",
      ""coord_x"": 26,
      ""coord_y"": 31,
      ""store_demand_units"": 24
    },
    {
      ""location_id"": ""J"",
      ""coord_x"": 100,
      ""coord_y"": 31,
      ""store_demand_units"": 10
    },
    {
      ""location_id"": ""K"",
      ""coord_x"": 0,
      ""coord_y"": 0,
      ""store_demand_units"": 9
    },
    {
      ""location_id"": ""L"",
      ""coord_x"": 28,
      ""coord_y"": 83,
      ""store_demand_units"": 6
    },
    {
      ""location_id"": ""M"",
      ""coord_x"": 50,
      ""coord_y"": 25,
      ""store_demand_units"": 22
    },
    {
      ""location_id"": ""N"",
      ""coord_x"": 20,
      ""coord_y"": 4,
      ""store_demand_units"": 20
    },
    {
      ""location_id"": ""O"",
      ""coord_x"": 63,
      ""coord_y"": 71,
      ""store_demand_units"": 4
    },
    {
      ""location_id"": ""P"",
      ""coord_x"": 26,
      ""coord_y"": 100,
      ""store_demand_units"": 20
    },
    {
      ""location_id"": ""Q"",
      ""coord_x"": 20,
      ""coord_y"": 96,
      ""store_demand_units"": 13
    },
    {
      ""location_id"": ""R"",
      ""coord_x"": 61,
      ""coord_y"": 31,
      ""store_demand_units"": 12
    },
    {
      ""location_id"": ""S"",
      ""coord_x"": 7,
      ""coord_y"": 94,
      ""store_demand_units"": 7
    },
    {
      ""location_id"": ""T"",
      ""coord_x"": 61,
      ""coord_y"": 42,
      ""store_demand_units"": 3
    },
    {
      ""location_id"": ""U"",
      ""coord_x"": 80,
      ""coord_y"": 40,
      ""store_demand_units"": 1
    },
    {
      ""location_id"": ""V"",
      ""coord_x"": 48,
      ""coord_y"": 29,
      ""store_demand_units"": 17
    },
    {
      ""location_id"": ""W"",
      ""coord_x"": 0,
      ""coord_y"": 92,
      ""store_demand_units"": 13
    },
    {
      ""location_id"": ""X"",
      ""coord_x"": 96,
      ""coord_y"": 42,
      ""store_demand_units"": 20
    }
  ],
  ""hub_node_id"": ""A"",
  ""truck_capacity_units"": 100
}

Also, when you send the plan back, just follow this simple JSON layout so I can read the routes programmatically:

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

This means ""solution"" is a list of truck trips. Each inner list is one trip: it starts at the hub, lists the stores in the order they’ll be visited, and ends back at the hub. Think of the JSON above as just the shape I want — a sketch, not the actual routing.

Please make sure to use the exact identifiers from the instance input — don’t rename anything and don’t 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': [[78, 56], [80, 0], [52, 25], [61, 38], [98, 46], [35, 54], [80, 65], [37, 52], [26, 31], [100, 31], [0, 0], [28, 83], [50, 25], [20, 4], [63, 71], [26, 100], [20, 96], [61, 31], [7, 94], [61, 42], [80, 40], [48, 29], [0, 92], [96, 42]], 'depot': 0, 'demands': [0, 26, 1, 2, 13, 7, 10, 7, 24, 10, 9, 6, 22, 20, 4, 20, 13, 12, 7, 3, 1, 17, 13, 20], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 556.6498530433398, 'objective': 556.6498530433398}","[[0, 7, 5, 11, 22, 18, 16, 15, 14, 6, 0], [0, 4, 23, 9, 1, 17, 20, 0], [0, 19, 21, 8, 10, 13, 12, 2, 3, 0]]",556.6498530433398,"{'problem_type': 'CVRP', 'num_nodes': 24, 'nodes': [{'id': 'A', 'x': 78, 'y': 56, 'demand': 0}, {'id': 'B', 'x': 80, 'y': 0, 'demand': 26}, {'id': 'C', 'x': 52, 'y': 25, 'demand': 1}, {'id': 'D', 'x': 61, 'y': 38, 'demand': 2}, {'id': 'E', 'x': 98, 'y': 46, 'demand': 13}, {'id': 'F', 'x': 35, 'y': 54, 'demand': 7}, {'id': 'G', 'x': 80, 'y': 65, 'demand': 10}, {'id': 'H', 'x': 37, 'y': 52, 'demand': 7}, {'id': 'I', 'x': 26, 'y': 31, 'demand': 24}, {'id': 'J', 'x': 100, 'y': 31, 'demand': 10}, {'id': 'K', 'x': 0, 'y': 0, 'demand': 9}, {'id': 'L', 'x': 28, 'y': 83, 'demand': 6}, {'id': 'M', 'x': 50, 'y': 25, 'demand': 22}, {'id': 'N', 'x': 20, 'y': 4, 'demand': 20}, {'id': 'O', 'x': 63, 'y': 71, 'demand': 4}, {'id': 'P', 'x': 26, 'y': 100, 'demand': 20}, {'id': 'Q', 'x': 20, 'y': 96, 'demand': 13}, {'id': 'R', 'x': 61, 'y': 31, 'demand': 12}, {'id': 'S', 'x': 7, 'y': 94, 'demand': 7}, {'id': 'T', 'x': 61, 'y': 42, 'demand': 3}, {'id': 'U', 'x': 80, 'y': 40, 'demand': 1}, {'id': 'V', 'x': 48, 'y': 29, 'demand': 17}, {'id': 'W', 'x': 0, 'y': 92, 'demand': 13}, {'id': 'X', 'x': 96, 'y': 42, 'demand': 20}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 3, 'total_distance': 556.6498530433398, 'objective': 556.6498530433398}","[['A', 'H', 'F', 'L', 'W', 'S', 'Q', 'P', 'O', 'G', 'A'], ['A', 'E', 'X', 'J', 'B', 'R', 'U', 'A'], ['A', 'T', 'V', 'I', 'K', 'N', 'M', 'C', 'D', 'A']]",13,json,names
CVRP,CVRP,"I’m picturing the maintenance yard dispatching trucks each morning to drop off tool kits to work crews around town. The task is to pick which crews each truck will visit so that every crew gets their delivery exactly once, every truck leaves from and returns to the yard, and no truck carries more weight than it can handle. The “best” way here is the one that keeps the fleet’s total miles driven as small as possible — you measure that by adding up the round-trip distance for every truck. The concrete details for the route plan and loads are shown below.

I have 24 total locations including the maintenance yard at node 1, and each truck can carry up to 100 weight.

| location_id | location_x | location_y | tool_kit_weight |
|---|---|---|---|
| 1 | 37 | 33 | 0 |
| 2 | 78 | 84 | 17 |
| 3 | 90 | 74 | 6 |
| 4 | 94 | 64 | 15 |
| 5 | 49 | 63 | 5 |
| 6 | 55 | 67 | 15 |
| 7 | 89 | 67 | 16 |
| 8 | 83 | 95 | 17 |
| 9 | 27 | 42 | 1 |
| 10 | 0 | 46 | 66 |
| 11 | 55 | 57 | 25 |
| 12 | 79 | 88 | 11 |
| 13 | 0 | 9 | 7 |
| 14 | 49 | 62 | 17 |
| 15 | 73 | 88 | 10 |
| 16 | 11 | 37 | 25 |
| 17 | 90 | 48 | 16 |
| 18 | 94 | 11 | 7 |
| 19 | 83 | 21 | 21 |
| 20 | 100 | 47 | 21 |
| 21 | 16 | 0 | 11 |
| 22 | 34 | 27 | 21 |
| 23 | 10 | 100 | 22 |
| 24 | 56 | 5 | 2 |

That lets me plan routes that start and end at the yard and never exceed 100 per truck.

Also, to keep things simple when you send the routes back, use this little JSON shape for the plan:

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

""solution"" is a list of routes. Each inner list is one truck’s round trip: it starts at the yard (yard_id), lists the crews to visit (crew_id) in the order they’ll be visited, and comes back to the yard. The ""..."" just means any number of stops can go there. This is just a sketch of the shape I expect — not the filled-in answer.

Please make sure you use the exact identifiers from the instance input — don’t rename things 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': [[37, 33], [78, 84], [90, 74], [94, 64], [49, 63], [55, 67], [89, 67], [83, 95], [27, 42], [0, 46], [55, 57], [79, 88], [0, 9], [49, 62], [73, 88], [11, 37], [90, 48], [94, 11], [83, 21], [100, 47], [16, 0], [34, 27], [10, 100], [56, 5]], 'depot': 0, 'demands': [0, 17, 6, 15, 5, 15, 16, 17, 1, 66, 25, 11, 7, 17, 10, 25, 16, 7, 21, 21, 11, 21, 22, 2], 'capacity': 100, 'num_vehicles': 4, 'total_distance': 695.6781375044837, 'objective': 695.6781375044837}","[[0, 22, 14, 1, 11, 7, 2, 6, 0], [0, 10, 5, 4, 13, 21, 0], [0, 12, 20, 23, 18, 17, 19, 3, 16, 0], [0, 8, 9, 15, 0]]",695.6781375044837,"{'problem_type': 'CVRP', 'num_nodes': 24, 'nodes': [{'id': 1, 'x': 37, 'y': 33, 'demand': 0}, {'id': 2, 'x': 78, 'y': 84, 'demand': 17}, {'id': 3, 'x': 90, 'y': 74, 'demand': 6}, {'id': 4, 'x': 94, 'y': 64, 'demand': 15}, {'id': 5, 'x': 49, 'y': 63, 'demand': 5}, {'id': 6, 'x': 55, 'y': 67, 'demand': 15}, {'id': 7, 'x': 89, 'y': 67, 'demand': 16}, {'id': 8, 'x': 83, 'y': 95, 'demand': 17}, {'id': 9, 'x': 27, 'y': 42, 'demand': 1}, {'id': 10, 'x': 0, 'y': 46, 'demand': 66}, {'id': 11, 'x': 55, 'y': 57, 'demand': 25}, {'id': 12, 'x': 79, 'y': 88, 'demand': 11}, {'id': 13, 'x': 0, 'y': 9, 'demand': 7}, {'id': 14, 'x': 49, 'y': 62, 'demand': 17}, {'id': 15, 'x': 73, 'y': 88, 'demand': 10}, {'id': 16, 'x': 11, 'y': 37, 'demand': 25}, {'id': 17, 'x': 90, 'y': 48, 'demand': 16}, {'id': 18, 'x': 94, 'y': 11, 'demand': 7}, {'id': 19, 'x': 83, 'y': 21, 'demand': 21}, {'id': 20, 'x': 100, 'y': 47, 'demand': 21}, {'id': 21, 'x': 16, 'y': 0, 'demand': 11}, {'id': 22, 'x': 34, 'y': 27, 'demand': 21}, {'id': 23, 'x': 10, 'y': 100, 'demand': 22}, {'id': 24, 'x': 56, 'y': 5, 'demand': 2}], 'depot': 1, 'capacity': 100, 'num_vehicles': 4, 'total_distance': 695.6781375044837, 'objective': 695.6781375044837}","[[1, 23, 15, 2, 12, 8, 3, 7, 1], [1, 11, 6, 5, 14, 22, 1], [1, 13, 21, 24, 19, 18, 20, 4, 17, 1], [1, 9, 10, 16, 1]]",14,markdown_table,1
CVRP,CVRP,"Out at the yard, the vans get loaded, each with a limit on how many parts they can carry, and they’ll each head out and later return to the same service center to cover a list of repair calls. The planning question is which calls each van should take and in what order so every single call is handled once and no van leaves overloaded. The simple aim is to cut down the fleet’s total driving — the total is just the sum of the distances of every van’s circuit, and the smaller that sum, the better the plan. The concrete stops, part requirements, and vehicle limits are shown below.

Here are the instance details: 22 stops including the service center, service center id 0, each van has a limit of 358 parts.

| stop_id | x_coordinate_meters | y_coordinate_meters | parts_required |
|---|---|---|---|
| 0 | 63 | 50 | 0 |
| 1 | 18 | 33 | 59 |
| 2 | 85 | 91 | 89 |
| 3 | 99 | 100 | 80 |
| 4 | 65 | 86 | 67 |
| 5 | 16 | 4 | 88 |
| 6 | 0 | 91 | 94 |
| 7 | 1 | 88 | 61 |
| 8 | 65 | 78 | 76 |
| 9 | 72 | 1 | 73 |
| 10 | 28 | 44 | 82 |
| 11 | 68 | 0 | 74 |
| 12 | 88 | 93 | 79 |
| 13 | 57 | 4 | 65 |
| 14 | 21 | 76 | 63 |
| 15 | 18 | 41 | 80 |
| 16 | 28 | 24 | 79 |
| 17 | 17 | 24 | 90 |
| 18 | 100 | 79 | 76 |
| 19 | 74 | 83 | 72 |
| 20 | 67 | 94 | 81 |
| 21 | 85 | 88 | 68 |

Make routes so every stop is visited once, no van carries more than 358 parts, and the fleet’s total driving is kept as small as possible.

Also, when you hand the plan back, keep it in a tiny, predictable JSON shape so I can read it easily. Something like this:

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

Here ""solution"" is a list of van circuits. Each inner list is the sequence of stops for one van, starting and ending at the depot (so the first and last entry in each route are the depot_id). The placeholders depot_id and location_id stand for the identifiers used in the instance — think of them like the names on the schedule rather than actual addresses. This is just the skeleton of the format I need, not the real plan.

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': [[63, 50], [18, 33], [85, 91], [99, 100], [65, 86], [16, 4], [0, 91], [1, 88], [65, 78], [72, 1], [28, 44], [68, 0], [88, 93], [57, 4], [21, 76], [18, 41], [28, 24], [17, 24], [100, 79], [74, 83], [67, 94], [85, 88]], 'depot': 0, 'demands': [0, 59, 89, 80, 67, 88, 94, 61, 76, 73, 82, 74, 79, 65, 63, 80, 79, 90, 76, 72, 81, 68], 'capacity': 358, 'num_vehicles': 5, 'total_distance': 722.7954321438083, 'objective': 722.7954321438083}","[[0, 10, 15, 17, 5, 0], [0, 1, 16, 13, 11, 9, 0], [0, 18, 3, 12, 2, 0], [0, 19, 21, 20, 4, 0], [0, 8, 6, 7, 14, 0]]",722.7954321438083,"{'problem_type': 'CVRP', 'num_nodes': 22, 'nodes': [{'id': 0, 'x': 63, 'y': 50, 'demand': 0}, {'id': 1, 'x': 18, 'y': 33, 'demand': 59}, {'id': 2, 'x': 85, 'y': 91, 'demand': 89}, {'id': 3, 'x': 99, 'y': 100, 'demand': 80}, {'id': 4, 'x': 65, 'y': 86, 'demand': 67}, {'id': 5, 'x': 16, 'y': 4, 'demand': 88}, {'id': 6, 'x': 0, 'y': 91, 'demand': 94}, {'id': 7, 'x': 1, 'y': 88, 'demand': 61}, {'id': 8, 'x': 65, 'y': 78, 'demand': 76}, {'id': 9, 'x': 72, 'y': 1, 'demand': 73}, {'id': 10, 'x': 28, 'y': 44, 'demand': 82}, {'id': 11, 'x': 68, 'y': 0, 'demand': 74}, {'id': 12, 'x': 88, 'y': 93, 'demand': 79}, {'id': 13, 'x': 57, 'y': 4, 'demand': 65}, {'id': 14, 'x': 21, 'y': 76, 'demand': 63}, {'id': 15, 'x': 18, 'y': 41, 'demand': 80}, {'id': 16, 'x': 28, 'y': 24, 'demand': 79}, {'id': 17, 'x': 17, 'y': 24, 'demand': 90}, {'id': 18, 'x': 100, 'y': 79, 'demand': 76}, {'id': 19, 'x': 74, 'y': 83, 'demand': 72}, {'id': 20, 'x': 67, 'y': 94, 'demand': 81}, {'id': 21, 'x': 85, 'y': 88, 'demand': 68}], 'depot': 0, 'capacity': 358, 'num_vehicles': 5, 'total_distance': 722.7954321438083, 'objective': 722.7954321438083}","[[0, 10, 15, 17, 5, 0], [0, 1, 16, 13, 11, 9, 0], [0, 18, 3, 12, 2, 0], [0, 19, 21, 20, 4, 0], [0, 8, 6, 7, 14, 0]]",15,markdown_table,0
CVRP,CVRP,"Recently the freezer team had to plan a set of runs to refill trucks across the city: each restock vehicle departs the cold storage, visits a selection of ice cream trucks once apiece, and then comes back. The constraint is that no vehicle can carry more ice cream than its freezer holds, and success is measured by how little total distance all the vans cover — the total is the sum of every route’s distance. The full list of truck demands and vehicle capacities is listed below.

{
  ""total_locations_including_depot"": 20,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 0,
      ""ice_cream_demand_units"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 61,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""C"",
      ""x_coordinate"": 27,
      ""y_coordinate"": 0,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""D"",
      ""x_coordinate"": 99,
      ""y_coordinate"": 57,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""E"",
      ""x_coordinate"": 39,
      ""y_coordinate"": 14,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""F"",
      ""x_coordinate"": 61,
      ""y_coordinate"": 19,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""G"",
      ""x_coordinate"": 5,
      ""y_coordinate"": 8,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""H"",
      ""x_coordinate"": 23,
      ""y_coordinate"": 14,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""I"",
      ""x_coordinate"": 25,
      ""y_coordinate"": 1,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""J"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 76,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""K"",
      ""x_coordinate"": 55,
      ""y_coordinate"": 100,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""L"",
      ""x_coordinate"": 61,
      ""y_coordinate"": 17,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""M"",
      ""x_coordinate"": 42,
      ""y_coordinate"": 3,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""N"",
      ""x_coordinate"": 25,
      ""y_coordinate"": 7,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""O"",
      ""x_coordinate"": 32,
      ""y_coordinate"": 8,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""P"",
      ""x_coordinate"": 85,
      ""y_coordinate"": 44,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""Q"",
      ""x_coordinate"": 89,
      ""y_coordinate"": 72,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""R"",
      ""x_coordinate"": 18,
      ""y_coordinate"": 1,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""S"",
      ""x_coordinate"": 49,
      ""y_coordinate"": 22,
      ""ice_cream_demand_units"": 1
    },
    {
      ""location_id"": ""T"",
      ""x_coordinate"": 27,
      ""y_coordinate"": 7,
      ""ice_cream_demand_units"": 1
    }
  ],
  ""cold_storage_node_id"": ""A"",
  ""vehicle_freezer_capacity"": 6
}

Also, when you give me the planned runs, a simple JSON reply in this shape works best — something casual like the example below.

{
  ""solution"": [[cold_storage_id, truck_id, ... , cold_storage_id], [cold_storage_id, truck_id, ... , cold_storage_id], ...]
}

Each inner list is one van’s route: it starts at the cold storage, lists the trucks visited in order, and returns to the cold storage. This JSON 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 when you fill it in (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], [100, 61], [27, 0], [99, 57], [39, 14], [61, 19], [5, 8], [23, 14], [25, 1], [100, 76], [55, 100], [61, 17], [42, 3], [25, 7], [32, 8], [85, 44], [89, 72], [18, 1], [49, 22], [27, 7]], 'depot': 0, 'demands': [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'capacity': 6, 'num_vehicles': 4, 'total_distance': 528.2439742494215, 'objective': 528.2439742494215}","[[0, 14, 4, 18, 5, 11, 12, 0], [0, 15, 3, 1, 9, 16, 10, 0], [0, 17, 8, 2, 19, 13, 7, 0], [0, 6, 0]]",528.2439742494215,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'demand': 0}, {'id': 'B', 'x': 100, 'y': 61, 'demand': 1}, {'id': 'C', 'x': 27, 'y': 0, 'demand': 1}, {'id': 'D', 'x': 99, 'y': 57, 'demand': 1}, {'id': 'E', 'x': 39, 'y': 14, 'demand': 1}, {'id': 'F', 'x': 61, 'y': 19, 'demand': 1}, {'id': 'G', 'x': 5, 'y': 8, 'demand': 1}, {'id': 'H', 'x': 23, 'y': 14, 'demand': 1}, {'id': 'I', 'x': 25, 'y': 1, 'demand': 1}, {'id': 'J', 'x': 100, 'y': 76, 'demand': 1}, {'id': 'K', 'x': 55, 'y': 100, 'demand': 1}, {'id': 'L', 'x': 61, 'y': 17, 'demand': 1}, {'id': 'M', 'x': 42, 'y': 3, 'demand': 1}, {'id': 'N', 'x': 25, 'y': 7, 'demand': 1}, {'id': 'O', 'x': 32, 'y': 8, 'demand': 1}, {'id': 'P', 'x': 85, 'y': 44, 'demand': 1}, {'id': 'Q', 'x': 89, 'y': 72, 'demand': 1}, {'id': 'R', 'x': 18, 'y': 1, 'demand': 1}, {'id': 'S', 'x': 49, 'y': 22, 'demand': 1}, {'id': 'T', 'x': 27, 'y': 7, 'demand': 1}], 'depot': 'A', 'capacity': 6, 'num_vehicles': 4, 'total_distance': 528.2439742494215, 'objective': 528.2439742494215}","[['A', 'O', 'E', 'S', 'F', 'L', 'M', 'A'], ['A', 'P', 'D', 'B', 'J', 'Q', 'K', 'A'], ['A', 'R', 'I', 'C', 'T', 'N', 'H', 'A'], ['A', 'G', 'A']]",16,json,names
CVRP,CVRP,"Back at the kitchen the morning routine is to send vans out, have each driver leave and return to base, drop a single meal kit at each subscriber’s address, and never exceed the vehicle’s carrying limit. The practical question is who goes where and in which order so each home is visited once and only once and no van is overloaded. To compare options, simply total up the distance driven by every van — the plan with the smallest total kilometers is the one to use. The concrete details are listed below.

There are 16 locations in total, with the fulfillment kitchen at 1; each van may carry up to 1106 kits.

| location_id | coord_x | coord_y | kits_required |
|---|---|---|---|
| 1 | 33 | 48 | 0 |
| 2 | 100 | 95 | 78 |
| 3 | 96 | 56 | 91 |
| 4 | 2 | 44 | 55 |
| 5 | 17 | 0 | 98 |
| 6 | 72 | 67 | 90 |
| 7 | 71 | 52 | 58 |
| 8 | 98 | 100 | 92 |
| 9 | 38 | 38 | 16 |
| 10 | 88 | 65 | 81 |
| 11 | 70 | 45 | 48 |
| 12 | 54 | 37 | 35 |
| 13 | 66 | 8 | 9 |
| 14 | 74 | 67 | 97 |
| 15 | 0 | 16 | 100 |
| 16 | 44 | 56 | 89 |

Routes must be arranged so every location is visited once, each route returns to 1, and no van exceeds 1106 kits.

Also, to keep things machine-friendly, please lay out your proposed plan in this simple JSON shape so I can parse it easily:

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

Think of ""solution"" as a list of van routes. Each inner list is one van's trip: start at the kitchen_id, visit the subscriber_id placeholders in order, and come back to the kitchen_id. This is just a sketch of the expected shape — don't treat the placeholders as the real labels.

Please use the exact identifiers given in the instance input when you fill this out — 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': [[33, 48], [100, 95], [96, 56], [2, 44], [17, 0], [72, 67], [71, 52], [98, 100], [38, 38], [88, 65], [70, 45], [54, 37], [66, 8], [74, 67], [0, 16], [44, 56]], 'depot': 0, 'demands': [0, 78, 91, 55, 98, 90, 58, 92, 16, 81, 48, 35, 9, 97, 100, 89], 'capacity': 1106, 'num_vehicles': 1, 'total_distance': 366.7640209240857, 'objective': 366.7640209240857}","[[0, 3, 14, 4, 12, 11, 10, 6, 2, 9, 1, 7, 13, 5, 15, 8, 0]]",366.7640209240857,"{'problem_type': 'CVRP', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 33, 'y': 48, 'demand': 0}, {'id': 2, 'x': 100, 'y': 95, 'demand': 78}, {'id': 3, 'x': 96, 'y': 56, 'demand': 91}, {'id': 4, 'x': 2, 'y': 44, 'demand': 55}, {'id': 5, 'x': 17, 'y': 0, 'demand': 98}, {'id': 6, 'x': 72, 'y': 67, 'demand': 90}, {'id': 7, 'x': 71, 'y': 52, 'demand': 58}, {'id': 8, 'x': 98, 'y': 100, 'demand': 92}, {'id': 9, 'x': 38, 'y': 38, 'demand': 16}, {'id': 10, 'x': 88, 'y': 65, 'demand': 81}, {'id': 11, 'x': 70, 'y': 45, 'demand': 48}, {'id': 12, 'x': 54, 'y': 37, 'demand': 35}, {'id': 13, 'x': 66, 'y': 8, 'demand': 9}, {'id': 14, 'x': 74, 'y': 67, 'demand': 97}, {'id': 15, 'x': 0, 'y': 16, 'demand': 100}, {'id': 16, 'x': 44, 'y': 56, 'demand': 89}], 'depot': 1, 'capacity': 1106, 'num_vehicles': 1, 'total_distance': 366.7640209240857, 'objective': 366.7640209240857}","[[1, 4, 15, 5, 13, 12, 11, 7, 3, 10, 2, 8, 14, 6, 16, 9, 1]]",17,markdown_table,1
CVRP,CVRP,"In our town the plan is to dispatch the blood vans from the hospital, have each one serve a sequence of community sites (no site repeated), return to base, and keep every van’s refrigerator within its capacity. What needs deciding is which sites go together on which trip so that the overall driving — computed by adding up the distance of every route — is as low as it can be. The exact details about stops, demand at each site, and fridge capacities are provided below.

{
  ""total_locations_count"": 20,
  ""nodes"": [
    {
      ""site_id"": 1,
      ""x_coordinate"": 46,
      ""y_coordinate"": 51,
      ""blood_units_required"": 0
    },
    {
      ""site_id"": 2,
      ""x_coordinate"": 77,
      ""y_coordinate"": 66,
      ""blood_units_required"": 2
    },
    {
      ""site_id"": 3,
      ""x_coordinate"": 80,
      ""y_coordinate"": 100,
      ""blood_units_required"": 9
    },
    {
      ""site_id"": 4,
      ""x_coordinate"": 54,
      ""y_coordinate"": 76,
      ""blood_units_required"": 1
    },
    {
      ""site_id"": 5,
      ""x_coordinate"": 56,
      ""y_coordinate"": 15,
      ""blood_units_required"": 10
    },
    {
      ""site_id"": 6,
      ""x_coordinate"": 41,
      ""y_coordinate"": 71,
      ""blood_units_required"": 4
    },
    {
      ""site_id"": 7,
      ""x_coordinate"": 43,
      ""y_coordinate"": 57,
      ""blood_units_required"": 3
    },
    {
      ""site_id"": 8,
      ""x_coordinate"": 37,
      ""y_coordinate"": 68,
      ""blood_units_required"": 4
    },
    {
      ""site_id"": 9,
      ""x_coordinate"": 91,
      ""y_coordinate"": 0,
      ""blood_units_required"": 8
    },
    {
      ""site_id"": 10,
      ""x_coordinate"": 0,
      ""y_coordinate"": 52,
      ""blood_units_required"": 8
    },
    {
      ""site_id"": 11,
      ""x_coordinate"": 19,
      ""y_coordinate"": 23,
      ""blood_units_required"": 10
    },
    {
      ""site_id"": 12,
      ""x_coordinate"": 95,
      ""y_coordinate"": 49,
      ""blood_units_required"": 6
    },
    {
      ""site_id"": 13,
      ""x_coordinate"": 78,
      ""y_coordinate"": 3,
      ""blood_units_required"": 2
    },
    {
      ""site_id"": 14,
      ""x_coordinate"": 87,
      ""y_coordinate"": 60,
      ""blood_units_required"": 7
    },
    {
      ""site_id"": 15,
      ""x_coordinate"": 95,
      ""y_coordinate"": 65,
      ""blood_units_required"": 4
    },
    {
      ""site_id"": 16,
      ""x_coordinate"": 90,
      ""y_coordinate"": 31,
      ""blood_units_required"": 4
    },
    {
      ""site_id"": 17,
      ""x_coordinate"": 54,
      ""y_coordinate"": 23,
      ""blood_units_required"": 4
    },
    {
      ""site_id"": 18,
      ""x_coordinate"": 95,
      ""y_coordinate"": 63,
      ""blood_units_required"": 5
    },
    {
      ""site_id"": 19,
      ""x_coordinate"": 100,
      ""y_coordinate"": 37,
      ""blood_units_required"": 10
    },
    {
      ""site_id"": 20,
      ""x_coordinate"": 89,
      ""y_coordinate"": 36,
      ""blood_units_required"": 3
    }
  ],
  ""hospital_node"": 1,
  ""van_refrigerator_capacity"": 18
}

Also, when you send the actual routes back, a simple JSON layout like this works best — just a list of trips, each trip an ordered list that starts and ends at the hospital:

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

Think of it like a little form: ""solution"" is the whole set of drives; each inner array is one van’s trip (it should start and end with the hospital ID and list the community site IDs in the order they’re visited). This is just a sketch of the shape I’m expecting, not the real routes.

Please use the exact identifiers from the instance input — don’t rename them or make up 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': [[46, 51], [77, 66], [80, 100], [54, 76], [56, 15], [41, 71], [43, 57], [37, 68], [91, 0], [0, 52], [19, 23], [95, 49], [78, 3], [87, 60], [95, 65], [90, 31], [54, 23], [95, 63], [100, 37], [89, 36]], 'depot': 0, 'demands': [0, 2, 9, 1, 10, 4, 3, 4, 8, 8, 10, 6, 2, 7, 4, 4, 4, 5, 10, 3], 'capacity': 18, 'num_vehicles': 6, 'total_distance': 716.3059813873808, 'objective': 716.3059813873808}","[[0, 10, 9, 0], [0, 7, 5, 3, 2, 0], [0, 19, 15, 8, 12, 0], [0, 18, 11, 0], [0, 13, 17, 14, 1, 0], [0, 6, 4, 16, 0]]",716.3059813873808,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 1, 'x': 46, 'y': 51, 'demand': 0}, {'id': 2, 'x': 77, 'y': 66, 'demand': 2}, {'id': 3, 'x': 80, 'y': 100, 'demand': 9}, {'id': 4, 'x': 54, 'y': 76, 'demand': 1}, {'id': 5, 'x': 56, 'y': 15, 'demand': 10}, {'id': 6, 'x': 41, 'y': 71, 'demand': 4}, {'id': 7, 'x': 43, 'y': 57, 'demand': 3}, {'id': 8, 'x': 37, 'y': 68, 'demand': 4}, {'id': 9, 'x': 91, 'y': 0, 'demand': 8}, {'id': 10, 'x': 0, 'y': 52, 'demand': 8}, {'id': 11, 'x': 19, 'y': 23, 'demand': 10}, {'id': 12, 'x': 95, 'y': 49, 'demand': 6}, {'id': 13, 'x': 78, 'y': 3, 'demand': 2}, {'id': 14, 'x': 87, 'y': 60, 'demand': 7}, {'id': 15, 'x': 95, 'y': 65, 'demand': 4}, {'id': 16, 'x': 90, 'y': 31, 'demand': 4}, {'id': 17, 'x': 54, 'y': 23, 'demand': 4}, {'id': 18, 'x': 95, 'y': 63, 'demand': 5}, {'id': 19, 'x': 100, 'y': 37, 'demand': 10}, {'id': 20, 'x': 89, 'y': 36, 'demand': 3}], 'depot': 1, 'capacity': 18, 'num_vehicles': 6, 'total_distance': 716.3059813873808, 'objective': 716.3059813873808}","[[1, 11, 10, 1], [1, 8, 6, 4, 3, 1], [1, 20, 16, 9, 13, 1], [1, 19, 12, 1], [1, 14, 18, 15, 2, 1], [1, 7, 5, 17, 1]]",18,json,1
CVRP,CVRP,"I run the parts delivery team and my job is to send vans out from the central warehouse so every technician gets the parts they need—once and only once—before the vans return to base. The tricky part is deciding which technicians each van should visit and in what order so that no vehicle leaves with more parts than it can carry and the whole crew drives as few miles as possible; total distance is just the sum of the miles for all of the vans’ round trips. The exact list of technician stops, their part requirements, and the vehicle capacities are shown below.

{
  ""total_locations_including_warehouse"": 17,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""x_coordinate_map"": 63,
      ""y_coordinate_map"": 35,
      ""parts_required"": 0
    },
    {
      ""location_id"": 1,
      ""x_coordinate_map"": 3,
      ""y_coordinate_map"": 67,
      ""parts_required"": 17
    },
    {
      ""location_id"": 2,
      ""x_coordinate_map"": 21,
      ""y_coordinate_map"": 73,
      ""parts_required"": 3
    },
    {
      ""location_id"": 3,
      ""x_coordinate_map"": 71,
      ""y_coordinate_map"": 10,
      ""parts_required"": 8
    },
    {
      ""location_id"": 4,
      ""x_coordinate_map"": 24,
      ""y_coordinate_map"": 75,
      ""parts_required"": 14
    },
    {
      ""location_id"": 5,
      ""x_coordinate_map"": 47,
      ""y_coordinate_map"": 100,
      ""parts_required"": 10
    },
    {
      ""location_id"": 6,
      ""x_coordinate_map"": 66,
      ""y_coordinate_map"": 6,
      ""parts_required"": 19
    },
    {
      ""location_id"": 7,
      ""x_coordinate_map"": 45,
      ""y_coordinate_map"": 35,
      ""parts_required"": 22
    },
    {
      ""location_id"": 8,
      ""x_coordinate_map"": 26,
      ""y_coordinate_map"": 46,
      ""parts_required"": 19
    },
    {
      ""location_id"": 9,
      ""x_coordinate_map"": 47,
      ""y_coordinate_map"": 0,
      ""parts_required"": 18
    },
    {
      ""location_id"": 10,
      ""x_coordinate_map"": 87,
      ""y_coordinate_map"": 60,
      ""parts_required"": 12
    },
    {
      ""location_id"": 11,
      ""x_coordinate_map"": 76,
      ""y_coordinate_map"": 38,
      ""parts_required"": 2
    },
    {
      ""location_id"": 12,
      ""x_coordinate_map"": 24,
      ""y_coordinate_map"": 19,
      ""parts_required"": 11
    },
    {
      ""location_id"": 13,
      ""x_coordinate_map"": 68,
      ""y_coordinate_map"": 21,
      ""parts_required"": 7
    },
    {
      ""location_id"": 14,
      ""x_coordinate_map"": 100,
      ""y_coordinate_map"": 21,
      ""parts_required"": 12
    },
    {
      ""location_id"": 15,
      ""x_coordinate_map"": 50,
      ""y_coordinate_map"": 65,
      ""parts_required"": 27
    },
    {
      ""location_id"": 16,
      ""x_coordinate_map"": 0,
      ""y_coordinate_map"": 48,
      ""parts_required"": 9
    }
  ],
  ""warehouse_location_id"": 0,
  ""vehicle_capacity_parts"": 100
}

Also, when you send the routes back, just stick to this simple 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 van routes; each route is written as a list that starts and ends with the depot_id and has the technician stops (location_id) in visit order — the ""..."" just shows there can be more stops. It's only a sketch of the expected shape, not the actual answer.

Please make sure you 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': [[63, 35], [3, 67], [21, 73], [71, 10], [24, 75], [47, 100], [66, 6], [45, 35], [26, 46], [47, 0], [87, 60], [76, 38], [24, 19], [68, 21], [100, 21], [50, 65], [0, 48]], 'depot': 0, 'demands': [0, 17, 3, 8, 14, 10, 19, 22, 19, 18, 12, 2, 11, 7, 12, 27, 9], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 453.63344045666656, 'objective': 453.63344045666656}","[[0, 11, 14, 10, 0], [0, 7, 12, 9, 6, 3, 13, 0], [0, 15, 5, 4, 2, 1, 16, 8, 0]]",453.63344045666656,"{'problem_type': 'CVRP', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 63, 'y': 35, 'demand': 0}, {'id': 1, 'x': 3, 'y': 67, 'demand': 17}, {'id': 2, 'x': 21, 'y': 73, 'demand': 3}, {'id': 3, 'x': 71, 'y': 10, 'demand': 8}, {'id': 4, 'x': 24, 'y': 75, 'demand': 14}, {'id': 5, 'x': 47, 'y': 100, 'demand': 10}, {'id': 6, 'x': 66, 'y': 6, 'demand': 19}, {'id': 7, 'x': 45, 'y': 35, 'demand': 22}, {'id': 8, 'x': 26, 'y': 46, 'demand': 19}, {'id': 9, 'x': 47, 'y': 0, 'demand': 18}, {'id': 10, 'x': 87, 'y': 60, 'demand': 12}, {'id': 11, 'x': 76, 'y': 38, 'demand': 2}, {'id': 12, 'x': 24, 'y': 19, 'demand': 11}, {'id': 13, 'x': 68, 'y': 21, 'demand': 7}, {'id': 14, 'x': 100, 'y': 21, 'demand': 12}, {'id': 15, 'x': 50, 'y': 65, 'demand': 27}, {'id': 16, 'x': 0, 'y': 48, 'demand': 9}], 'depot': 0, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 453.63344045666656, 'objective': 453.63344045666656}","[[0, 11, 14, 10, 0], [0, 7, 12, 9, 6, 3, 13, 0], [0, 15, 5, 4, 2, 1, 16, 8, 0]]",19,json,0
CVRP,CVRP,"I run a little bakery that sends out a few vans every morning to drop off bread and pastries. The job is to plan which stops each van will make so that every customer gets their delivery exactly once, every driver leaves from the bakery and comes back to the bakery at the end of their run, and no van carries more than it can hold. A better plan is the one that keeps the total driving as low as possible — you figure that total by adding up the miles (or minutes) of all the individual runs. The specific addresses, order sizes, and van limits are shown below.

There are 17 locations in total (the bakery is node 0), and each van can carry up to 100 units.
Location 0 is at coordinates (29, 20) and has an order size of 0.
Location 1 is at coordinates (5, 4) and has an order size of 10.
Location 2 is at coordinates (7, 5) and has an order size of 13.
Location 3 is at coordinates (65, 92) and has an order size of 6.
Location 4 is at coordinates (49, 100) and has an order size of 4.
Location 5 is at coordinates (41, 89) and has an order size of 13.
Location 6 is at coordinates (48, 0) and has an order size of 22.
Location 7 is at coordinates (49, 93) and has an order size of 26.
Location 8 is at coordinates (100, 14) and has an order size of 8.
Location 9 is at coordinates (45, 98) and has an order size of 16.
Location 10 is at coordinates (15, 9) and has an order size of 15.
Location 11 is at coordinates (37, 89) and has an order size of 2.
Location 12 is at coordinates (37, 14) and has an order size of 7.
Location 13 is at coordinates (43, 2) and has an order size of 22.
Location 14 is at coordinates (0, 40) and has an order size of 22.
Location 15 is at coordinates (49, 98) and has an order size of 10.
Location 16 is at coordinates (7, 9) and has an order size of 14.
Use these details to plan routes that serve every customer exactly once and bring each van back to node 0 without exceeding the 100-unit limit.

Also, when you send back a proposed plan, just stick to this simple JSON shape so I can read it easily:

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

This is just a quick sketch of the shape I expect — each inner list is one van’s route: it starts at the bakery, lists the stops that van makes, and returns to the bakery at the end. bakery_id is the placeholder for the bakery/depot identifier from the instance, and stop_id stands in for each customer location identifier. Don’t worry about extra fields or anything fancy — just the routes in that list-of-lists form.

Please make sure every identifier you use matches exactly the ones 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': [[29, 20], [5, 4], [7, 5], [65, 92], [49, 100], [41, 89], [48, 0], [49, 93], [100, 14], [45, 98], [15, 9], [37, 89], [37, 14], [43, 2], [0, 40], [49, 98], [7, 9]], 'depot': 0, 'demands': [0, 10, 13, 6, 4, 13, 22, 26, 8, 16, 15, 2, 7, 22, 22, 10, 14], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 425.3263198027438, 'objective': 425.3263198027438}","[[0, 8, 3, 7, 15, 4, 9, 5, 11, 0], [0, 14, 16, 1, 2, 10, 0], [0, 6, 13, 12, 0]]",425.3263198027438,"{'problem_type': 'CVRP', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 29, 'y': 20, 'demand': 0}, {'id': 1, 'x': 5, 'y': 4, 'demand': 10}, {'id': 2, 'x': 7, 'y': 5, 'demand': 13}, {'id': 3, 'x': 65, 'y': 92, 'demand': 6}, {'id': 4, 'x': 49, 'y': 100, 'demand': 4}, {'id': 5, 'x': 41, 'y': 89, 'demand': 13}, {'id': 6, 'x': 48, 'y': 0, 'demand': 22}, {'id': 7, 'x': 49, 'y': 93, 'demand': 26}, {'id': 8, 'x': 100, 'y': 14, 'demand': 8}, {'id': 9, 'x': 45, 'y': 98, 'demand': 16}, {'id': 10, 'x': 15, 'y': 9, 'demand': 15}, {'id': 11, 'x': 37, 'y': 89, 'demand': 2}, {'id': 12, 'x': 37, 'y': 14, 'demand': 7}, {'id': 13, 'x': 43, 'y': 2, 'demand': 22}, {'id': 14, 'x': 0, 'y': 40, 'demand': 22}, {'id': 15, 'x': 49, 'y': 98, 'demand': 10}, {'id': 16, 'x': 7, 'y': 9, 'demand': 14}], 'depot': 0, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 425.3263198027438, 'objective': 425.3263198027438}","[[0, 8, 3, 7, 15, 4, 9, 5, 11, 0], [0, 14, 16, 1, 2, 10, 0], [0, 6, 13, 12, 0]]",20,nl,0
CVRP,CVRP,"Out on the dairy route, the problem is deciding which farms to group into each haul and in what sequence so the truck can head out from the silo, visit every farm one time, and come back for the next load without ever taking on more milk than it can handle. The better the plan, the less total driving across all those runs — total driving is computed by adding up the length of each trip. The exact farm list, their milk amounts, and truck capacity are shown below.

{
  ""total_locations_including_silo"": 19,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""map_x_coordinate"": 60,
      ""map_y_coordinate"": 71,
      ""milk_volume_demand"": 0
    },
    {
      ""location_id"": ""B"",
      ""map_x_coordinate"": 27,
      ""map_y_coordinate"": 24,
      ""milk_volume_demand"": 18
    },
    {
      ""location_id"": ""C"",
      ""map_x_coordinate"": 51,
      ""map_y_coordinate"": 100,
      ""milk_volume_demand"": 16
    },
    {
      ""location_id"": ""D"",
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 29,
      ""milk_volume_demand"": 8
    },
    {
      ""location_id"": ""E"",
      ""map_x_coordinate"": 47,
      ""map_y_coordinate"": 82,
      ""milk_volume_demand"": 20
    },
    {
      ""location_id"": ""F"",
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 92,
      ""milk_volume_demand"": 15
    },
    {
      ""location_id"": ""G"",
      ""map_x_coordinate"": 67,
      ""map_y_coordinate"": 0,
      ""milk_volume_demand"": 28
    },
    {
      ""location_id"": ""H"",
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 79,
      ""milk_volume_demand"": 27
    },
    {
      ""location_id"": ""I"",
      ""map_x_coordinate"": 62,
      ""map_y_coordinate"": 87,
      ""milk_volume_demand"": 18
    },
    {
      ""location_id"": ""J"",
      ""map_x_coordinate"": 87,
      ""map_y_coordinate"": 55,
      ""milk_volume_demand"": 17
    },
    {
      ""location_id"": ""K"",
      ""map_x_coordinate"": 82,
      ""map_y_coordinate"": 34,
      ""milk_volume_demand"": 13
    },
    {
      ""location_id"": ""L"",
      ""map_x_coordinate"": 65,
      ""map_y_coordinate"": 34,
      ""milk_volume_demand"": 22
    },
    {
      ""location_id"": ""M"",
      ""map_x_coordinate"": 35,
      ""map_y_coordinate"": 42,
      ""milk_volume_demand"": 27
    },
    {
      ""location_id"": ""N"",
      ""map_x_coordinate"": 78,
      ""map_y_coordinate"": 71,
      ""milk_volume_demand"": 19
    },
    {
      ""location_id"": ""O"",
      ""map_x_coordinate"": 87,
      ""map_y_coordinate"": 97,
      ""milk_volume_demand"": 10
    },
    {
      ""location_id"": ""P"",
      ""map_x_coordinate"": 9,
      ""map_y_coordinate"": 11,
      ""milk_volume_demand"": 15
    },
    {
      ""location_id"": ""Q"",
      ""map_x_coordinate"": 15,
      ""map_y_coordinate"": 3,
      ""milk_volume_demand"": 11
    },
    {
      ""location_id"": ""R"",
      ""map_x_coordinate"": 16,
      ""map_y_coordinate"": 16,
      ""milk_volume_demand"": 18
    },
    {
      ""location_id"": ""S"",
      ""map_x_coordinate"": 78,
      ""map_y_coordinate"": 5,
      ""milk_volume_demand"": 19
    }
  ],
  ""silo_node_id"": ""A"",
  ""truck_capacity_volume"": 120
}

Oh, and when you send the plan back, just use this simple JSON layout so I can read the routes easily:

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

Think of ""solution"" as a list of runs. Each inner list is one truck trip: start at the depot, visit the farms in order (each shown by its identifier), and come back to the depot. This block is just a sketch of the shape I expect—not the actual answer.

Please use the exact identifiers from the instance input — don’t rename them or make up new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”. ""","{'coordinates': [[60, 71], [27, 24], [51, 100], [100, 29], [47, 82], [100, 92], [67, 0], [0, 79], [62, 87], [87, 55], [82, 34], [65, 34], [35, 42], [78, 71], [87, 97], [9, 11], [15, 3], [16, 16], [78, 5]], 'depot': 0, 'demands': [0, 18, 16, 8, 20, 15, 28, 27, 18, 17, 13, 22, 27, 19, 10, 15, 11, 18, 19], 'capacity': 120, 'num_vehicles': 3, 'total_distance': 553.2048971249073, 'objective': 553.2048971249073}","[[0, 7, 15, 16, 17, 1, 12, 0], [0, 9, 10, 3, 18, 6, 11, 0], [0, 4, 2, 8, 14, 5, 13, 0]]",553.2048971249073,"{'problem_type': 'CVRP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 60, 'y': 71, 'demand': 0}, {'id': 'B', 'x': 27, 'y': 24, 'demand': 18}, {'id': 'C', 'x': 51, 'y': 100, 'demand': 16}, {'id': 'D', 'x': 100, 'y': 29, 'demand': 8}, {'id': 'E', 'x': 47, 'y': 82, 'demand': 20}, {'id': 'F', 'x': 100, 'y': 92, 'demand': 15}, {'id': 'G', 'x': 67, 'y': 0, 'demand': 28}, {'id': 'H', 'x': 0, 'y': 79, 'demand': 27}, {'id': 'I', 'x': 62, 'y': 87, 'demand': 18}, {'id': 'J', 'x': 87, 'y': 55, 'demand': 17}, {'id': 'K', 'x': 82, 'y': 34, 'demand': 13}, {'id': 'L', 'x': 65, 'y': 34, 'demand': 22}, {'id': 'M', 'x': 35, 'y': 42, 'demand': 27}, {'id': 'N', 'x': 78, 'y': 71, 'demand': 19}, {'id': 'O', 'x': 87, 'y': 97, 'demand': 10}, {'id': 'P', 'x': 9, 'y': 11, 'demand': 15}, {'id': 'Q', 'x': 15, 'y': 3, 'demand': 11}, {'id': 'R', 'x': 16, 'y': 16, 'demand': 18}, {'id': 'S', 'x': 78, 'y': 5, 'demand': 19}], 'depot': 'A', 'capacity': 120, 'num_vehicles': 3, 'total_distance': 553.2048971249073, 'objective': 553.2048971249073}","[['A', 'H', 'P', 'Q', 'R', 'B', 'M', 'A'], ['A', 'J', 'K', 'D', 'S', 'G', 'L', 'A'], ['A', 'E', 'C', 'I', 'O', 'F', 'N', 'A']]",21,json,names
CVRP,CVRP,"Back at the warehouse the morning plan is simple to explain: make a collection of round trips that start and end at the distribution center and make sure every vending machine gets one visit and only one. The decisions are grouping the stops into trips and loading each trip within the vehicle’s capacity so nothing is missed or doubled up. The winning plan is the one that results in the least overall driving — total distance is computed by summing every trip’s length. The concrete instance details follow below.

{
  ""num_locations"": 24,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""x_coordinate"": 0,
      ""y_coordinate"": 0,
      ""restock_quantity"": 0
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 28,
      ""y_coordinate"": 57,
      ""restock_quantity"": 65
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 64,
      ""y_coordinate"": 56,
      ""restock_quantity"": 69
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 3,
      ""y_coordinate"": 7,
      ""restock_quantity"": 60
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 45,
      ""y_coordinate"": 52,
      ""restock_quantity"": 54
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 39,
      ""y_coordinate"": 76,
      ""restock_quantity"": 92
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 46,
      ""y_coordinate"": 40,
      ""restock_quantity"": 74
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 60,
      ""y_coordinate"": 86,
      ""restock_quantity"": 55
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 30,
      ""y_coordinate"": 29,
      ""restock_quantity"": 53
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 39,
      ""y_coordinate"": 51,
      ""restock_quantity"": 92
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 85,
      ""y_coordinate"": 70,
      ""restock_quantity"": 57
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 53,
      ""y_coordinate"": 78,
      ""restock_quantity"": 63
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 4,
      ""y_coordinate"": 38,
      ""restock_quantity"": 79
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 46,
      ""y_coordinate"": 67,
      ""restock_quantity"": 86
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 95,
      ""y_coordinate"": 100,
      ""restock_quantity"": 50
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 91,
      ""y_coordinate"": 16,
      ""restock_quantity"": 77
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 30,
      ""y_coordinate"": 70,
      ""restock_quantity"": 68
    },
    {
      ""location_id"": 18,
      ""x_coordinate"": 69,
      ""y_coordinate"": 85,
      ""restock_quantity"": 77
    },
    {
      ""location_id"": 19,
      ""x_coordinate"": 46,
      ""y_coordinate"": 52,
      ""restock_quantity"": 97
    },
    {
      ""location_id"": 20,
      ""x_coordinate"": 70,
      ""y_coordinate"": 3,
      ""restock_quantity"": 97
    },
    {
      ""location_id"": 21,
      ""x_coordinate"": 100,
      ""y_coordinate"": 37,
      ""restock_quantity"": 81
    },
    {
      ""location_id"": 22,
      ""x_coordinate"": 88,
      ""y_coordinate"": 40,
      ""restock_quantity"": 91
    },
    {
      ""location_id"": 23,
      ""x_coordinate"": 70,
      ""y_coordinate"": 35,
      ""restock_quantity"": 93
    },
    {
      ""location_id"": 24,
      ""x_coordinate"": 56,
      ""y_coordinate"": 67,
      ""restock_quantity"": 90
    }
  ],
  ""distribution_center_id"": 1,
  ""vehicle_capacity_units"": 256
}

Also, when you hand over the plan, a short JSON snippet like this makes it easy to read and check:

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

This just means ""solution"" contains a list of round trips. Each inner list is one trip that starts and ends at the distribution center (here shown as warehouse_id) and lists the stops you visit in order (machine_id placeholders). It's just a sketch of the shape I expect — not the real 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': [[0, 0], [28, 57], [64, 56], [3, 7], [45, 52], [39, 76], [46, 40], [60, 86], [30, 29], [39, 51], [85, 70], [53, 78], [4, 38], [46, 67], [95, 100], [91, 16], [30, 70], [69, 85], [46, 52], [70, 3], [100, 37], [88, 40], [70, 35], [56, 67]], 'depot': 0, 'demands': [0, 65, 69, 60, 54, 92, 74, 55, 53, 92, 57, 63, 79, 86, 50, 77, 68, 77, 97, 97, 81, 91, 93, 90], 'capacity': 256, 'num_vehicles': 7, 'total_distance': 1379.5775468166548, 'objective': 1379.5775468166548}","[[0, 10, 14, 17, 7, 0], [0, 8, 6, 1, 3, 0], [0, 13, 11, 23, 0], [0, 18, 4, 9, 0], [0, 19, 15, 20, 0], [0, 22, 21, 2, 0], [0, 5, 16, 12, 0]]",1379.5775468166548,"{'problem_type': 'CVRP', 'num_nodes': 24, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'demand': 0}, {'id': 2, 'x': 28, 'y': 57, 'demand': 65}, {'id': 3, 'x': 64, 'y': 56, 'demand': 69}, {'id': 4, 'x': 3, 'y': 7, 'demand': 60}, {'id': 5, 'x': 45, 'y': 52, 'demand': 54}, {'id': 6, 'x': 39, 'y': 76, 'demand': 92}, {'id': 7, 'x': 46, 'y': 40, 'demand': 74}, {'id': 8, 'x': 60, 'y': 86, 'demand': 55}, {'id': 9, 'x': 30, 'y': 29, 'demand': 53}, {'id': 10, 'x': 39, 'y': 51, 'demand': 92}, {'id': 11, 'x': 85, 'y': 70, 'demand': 57}, {'id': 12, 'x': 53, 'y': 78, 'demand': 63}, {'id': 13, 'x': 4, 'y': 38, 'demand': 79}, {'id': 14, 'x': 46, 'y': 67, 'demand': 86}, {'id': 15, 'x': 95, 'y': 100, 'demand': 50}, {'id': 16, 'x': 91, 'y': 16, 'demand': 77}, {'id': 17, 'x': 30, 'y': 70, 'demand': 68}, {'id': 18, 'x': 69, 'y': 85, 'demand': 77}, {'id': 19, 'x': 46, 'y': 52, 'demand': 97}, {'id': 20, 'x': 70, 'y': 3, 'demand': 97}, {'id': 21, 'x': 100, 'y': 37, 'demand': 81}, {'id': 22, 'x': 88, 'y': 40, 'demand': 91}, {'id': 23, 'x': 70, 'y': 35, 'demand': 93}, {'id': 24, 'x': 56, 'y': 67, 'demand': 90}], 'depot': 1, 'capacity': 256, 'num_vehicles': 7, 'total_distance': 1379.5775468166548, 'objective': 1379.5775468166548}","[[1, 11, 15, 18, 8, 1], [1, 9, 7, 2, 4, 1], [1, 14, 12, 24, 1], [1, 19, 5, 10, 1], [1, 20, 16, 21, 1], [1, 23, 22, 3, 1], [1, 6, 17, 13, 1]]",22,json,1
CVRP,CVRP,"On a busy morning the dispatch desk needs to parcel out deliveries: bundle clinic stops into routes so each clinic gets exactly one delivery, every driver departs from and returns to the pharmacy, and each vehicle stays within its load allowance. The clear measure of success is the least amount of driving across the fleet — total mileage equals the sum of the distances of all routes. The full list of locations, demands, and vehicle capacities is given below.

Below are 25 locations: the pharmacy is node 0 and vehicle capacity is 100.
Location 0 at (67, 0) has demand 0.
Location 1 at (18, 58) has demand 9.
Location 2 at (53, 98) has demand 15.
Location 3 at (76, 7) has demand 17.
Location 4 at (96, 11) has demand 2.
Location 5 at (96, 20) has demand 10.
Location 6 at (76, 91) has demand 20.
Location 7 at (76, 42) has demand 16.
Location 8 at (53, 69) has demand 8.
Location 9 at (22, 53) has demand 23.
Location 10 at (58, 20) has demand 23.
Location 11 at (84, 64) has demand 20.
Location 12 at (84, 22) has demand 2.
Location 13 at (93, 100) has demand 23.
Location 14 at (89, 71) has demand 9.
Location 15 at (78, 96) has demand 8.
Location 16 at (33, 9) has demand 2.
Location 17 at (76, 31) has demand 2.
Location 18 at (100, 47) has demand 4.
Location 19 at (71, 78) has demand 18.
Location 20 at (9, 89) has demand 19.
Location 21 at (64, 87) has demand 21.
Location 22 at (0, 9) has demand 22.
Location 23 at (0, 87) has demand 13.
Location 24 at (56, 7) has demand 9.
Assign each clinic exactly once, start and end every route at the pharmacy 0, respect the capacity 100, and minimize total fleet mileage.

When you send the routes back, just stick to this simple JSON layout so it's easy to plug into the dispatcher:

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

Think of it like a form: ""solution"" holds a list of routes; each route is an ordered list that starts and ends at the pharmacy and lists the clinic stops in the order the driver will visit them. This block is just a sketch of the expected shape — not the actual answer.

Please make sure to use the exact identifiers given in 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': [[67, 0], [18, 58], [53, 98], [76, 7], [96, 11], [96, 20], [76, 91], [76, 42], [53, 69], [22, 53], [58, 20], [84, 64], [84, 22], [93, 100], [89, 71], [78, 96], [33, 9], [76, 31], [100, 47], [71, 78], [9, 89], [64, 87], [0, 9], [0, 87], [56, 7]], 'depot': 0, 'demands': [0, 9, 15, 17, 2, 10, 20, 16, 8, 23, 23, 20, 2, 23, 9, 8, 2, 2, 4, 18, 19, 21, 22, 13, 9], 'capacity': 100, 'num_vehicles': 4, 'total_distance': 759.1469246977358, 'objective': 759.1469246977358}","[[0, 8, 2, 21, 19, 7, 17, 3, 0], [0, 12, 11, 6, 15, 13, 14, 18, 5, 4, 0], [0, 24, 9, 1, 20, 23, 22, 16, 0], [0, 10, 0]]",759.1469246977358,"{'problem_type': 'CVRP', 'num_nodes': 25, 'nodes': [{'id': 0, 'x': 67, 'y': 0, 'demand': 0}, {'id': 1, 'x': 18, 'y': 58, 'demand': 9}, {'id': 2, 'x': 53, 'y': 98, 'demand': 15}, {'id': 3, 'x': 76, 'y': 7, 'demand': 17}, {'id': 4, 'x': 96, 'y': 11, 'demand': 2}, {'id': 5, 'x': 96, 'y': 20, 'demand': 10}, {'id': 6, 'x': 76, 'y': 91, 'demand': 20}, {'id': 7, 'x': 76, 'y': 42, 'demand': 16}, {'id': 8, 'x': 53, 'y': 69, 'demand': 8}, {'id': 9, 'x': 22, 'y': 53, 'demand': 23}, {'id': 10, 'x': 58, 'y': 20, 'demand': 23}, {'id': 11, 'x': 84, 'y': 64, 'demand': 20}, {'id': 12, 'x': 84, 'y': 22, 'demand': 2}, {'id': 13, 'x': 93, 'y': 100, 'demand': 23}, {'id': 14, 'x': 89, 'y': 71, 'demand': 9}, {'id': 15, 'x': 78, 'y': 96, 'demand': 8}, {'id': 16, 'x': 33, 'y': 9, 'demand': 2}, {'id': 17, 'x': 76, 'y': 31, 'demand': 2}, {'id': 18, 'x': 100, 'y': 47, 'demand': 4}, {'id': 19, 'x': 71, 'y': 78, 'demand': 18}, {'id': 20, 'x': 9, 'y': 89, 'demand': 19}, {'id': 21, 'x': 64, 'y': 87, 'demand': 21}, {'id': 22, 'x': 0, 'y': 9, 'demand': 22}, {'id': 23, 'x': 0, 'y': 87, 'demand': 13}, {'id': 24, 'x': 56, 'y': 7, 'demand': 9}], 'depot': 0, 'capacity': 100, 'num_vehicles': 4, 'total_distance': 759.1469246977358, 'objective': 759.1469246977358}","[[0, 8, 2, 21, 19, 7, 17, 3, 0], [0, 12, 11, 6, 15, 13, 14, 18, 5, 4, 0], [0, 24, 9, 1, 20, 23, 22, 16, 0], [0, 10, 0]]",23,nl,0
CVRP,CVRP,"I run the logistics side of a grocery wholesaler and the job is to plan pickup-and-delivery loops from our central depot to a bunch of stores. The choice to make is which stores go on which truck and in what order, making sure every store gets its delivery once and only once, each truck leaves the depot and comes back to it, and no truck is loaded beyond what it can safely carry. A better plan is the one where all the trucks together drive the fewest miles — you figure that by adding up the distance each truck travels on its route. The exact list of stores, how much they need, and the truck capacities are shown below.

{
  ""total_locations_including_depot"": 20,
  ""nodes"": [
    {
      ""location_node_id"": 0,
      ""map_x_coordinate"": 23,
      ""map_y_coordinate"": 65,
      ""store_demand_units"": 0
    },
    {
      ""location_node_id"": 1,
      ""map_x_coordinate"": 34,
      ""map_y_coordinate"": 62,
      ""store_demand_units"": 2
    },
    {
      ""location_node_id"": 2,
      ""map_x_coordinate"": 28,
      ""map_y_coordinate"": 100,
      ""store_demand_units"": 20
    },
    {
      ""location_node_id"": 3,
      ""map_x_coordinate"": 35,
      ""map_y_coordinate"": 31,
      ""store_demand_units"": 7
    },
    {
      ""location_node_id"": 4,
      ""map_x_coordinate"": 86,
      ""map_y_coordinate"": 89,
      ""store_demand_units"": 24
    },
    {
      ""location_node_id"": 5,
      ""map_x_coordinate"": 56,
      ""map_y_coordinate"": 29,
      ""store_demand_units"": 13
    },
    {
      ""location_node_id"": 6,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 8,
      ""store_demand_units"": 2
    },
    {
      ""location_node_id"": 7,
      ""map_x_coordinate"": 29,
      ""map_y_coordinate"": 5,
      ""store_demand_units"": 7
    },
    {
      ""location_node_id"": 8,
      ""map_x_coordinate"": 51,
      ""map_y_coordinate"": 82,
      ""store_demand_units"": 18
    },
    {
      ""location_node_id"": 9,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 80,
      ""store_demand_units"": 30
    },
    {
      ""location_node_id"": 10,
      ""map_x_coordinate"": 91,
      ""map_y_coordinate"": 53,
      ""store_demand_units"": 2
    },
    {
      ""location_node_id"": 11,
      ""map_x_coordinate"": 80,
      ""map_y_coordinate"": 53,
      ""store_demand_units"": 18
    },
    {
      ""location_node_id"": 12,
      ""map_x_coordinate"": 72,
      ""map_y_coordinate"": 92,
      ""store_demand_units"": 8
    },
    {
      ""location_node_id"": 13,
      ""map_x_coordinate"": 35,
      ""map_y_coordinate"": 17,
      ""store_demand_units"": 4
    },
    {
      ""location_node_id"": 14,
      ""map_x_coordinate"": 88,
      ""map_y_coordinate"": 23,
      ""store_demand_units"": 26
    },
    {
      ""location_node_id"": 15,
      ""map_x_coordinate"": 70,
      ""map_y_coordinate"": 69,
      ""store_demand_units"": 2
    },
    {
      ""location_node_id"": 16,
      ""map_x_coordinate"": 73,
      ""map_y_coordinate"": 35,
      ""store_demand_units"": 15
    },
    {
      ""location_node_id"": 17,
      ""map_x_coordinate"": 57,
      ""map_y_coordinate"": 76,
      ""store_demand_units"": 25
    },
    {
      ""location_node_id"": 18,
      ""map_x_coordinate"": 91,
      ""map_y_coordinate"": 72,
      ""store_demand_units"": 3
    },
    {
      ""location_node_id"": 19,
      ""map_x_coordinate"": 16,
      ""map_y_coordinate"": 0,
      ""store_demand_units"": 13
    }
  ],
  ""central_depot_id"": 0,
  ""truck_capacity_units"": 100
}

Also, I'll hand the plan back in a simple JSON shape so it's easy to plug into other tools or maps. It follows this layout:

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

Think of ""solution"" as just a list of routes. Each route is a list that starts at the depot, lists the store locations visited in order, and ends back at the depot. This little JSON is just a sketch of the shape I’ll deliver in — it’s not the actual routes yet.

Please use the exact identifiers from the problem input when we fill this in — don't rename any locations 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': [[23, 65], [34, 62], [28, 100], [35, 31], [86, 89], [56, 29], [100, 8], [29, 5], [51, 82], [0, 80], [91, 53], [80, 53], [72, 92], [35, 17], [88, 23], [70, 69], [73, 35], [57, 76], [91, 72], [16, 0]], 'depot': 0, 'demands': [0, 2, 20, 7, 24, 13, 2, 7, 18, 30, 2, 18, 8, 4, 26, 2, 15, 25, 3, 13], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 552.6972449757975, 'objective': 552.6972449757975}","[[0, 17, 15, 11, 10, 18, 4, 12, 8, 0], [0, 2, 9, 0], [0, 1, 5, 16, 14, 6, 7, 19, 13, 3, 0]]",552.6972449757975,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 23, 'y': 65, 'demand': 0}, {'id': 1, 'x': 34, 'y': 62, 'demand': 2}, {'id': 2, 'x': 28, 'y': 100, 'demand': 20}, {'id': 3, 'x': 35, 'y': 31, 'demand': 7}, {'id': 4, 'x': 86, 'y': 89, 'demand': 24}, {'id': 5, 'x': 56, 'y': 29, 'demand': 13}, {'id': 6, 'x': 100, 'y': 8, 'demand': 2}, {'id': 7, 'x': 29, 'y': 5, 'demand': 7}, {'id': 8, 'x': 51, 'y': 82, 'demand': 18}, {'id': 9, 'x': 0, 'y': 80, 'demand': 30}, {'id': 10, 'x': 91, 'y': 53, 'demand': 2}, {'id': 11, 'x': 80, 'y': 53, 'demand': 18}, {'id': 12, 'x': 72, 'y': 92, 'demand': 8}, {'id': 13, 'x': 35, 'y': 17, 'demand': 4}, {'id': 14, 'x': 88, 'y': 23, 'demand': 26}, {'id': 15, 'x': 70, 'y': 69, 'demand': 2}, {'id': 16, 'x': 73, 'y': 35, 'demand': 15}, {'id': 17, 'x': 57, 'y': 76, 'demand': 25}, {'id': 18, 'x': 91, 'y': 72, 'demand': 3}, {'id': 19, 'x': 16, 'y': 0, 'demand': 13}], 'depot': 0, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 552.6972449757975, 'objective': 552.6972449757975}","[[0, 17, 15, 11, 10, 18, 4, 12, 8, 0], [0, 2, 9, 0], [0, 1, 5, 16, 14, 6, 7, 19, 13, 3, 0]]",24,json,0
CVRP,CVRP,"We need to map out routes for a recycling crew leaving from the central depot so each collection spot is collected exactly one time and every route loops back to the depot. The teams must be assigned so that the load picked up on any single loop never exceeds that truck’s capacity, and the whole day's travel should be as short as possible — the total distance is just the sum of all individual trip distances. Nothing can be skipped or doubled up. The exact addresses, quantities, and vehicle sizes are listed below.

There are 19 locations in total (including headquarters node 0), and each truck's capacity is 140.

| location_node_id | x_coordinate | y_coordinate | recyclables_amount |
|---|---|---|---|
| 0 | 44 | 51 | 0 |
| 1 | 77 | 66 | 30 |
| 2 | 61 | 34 | 21 |
| 3 | 28 | 63 | 15 |
| 4 | 81 | 19 | 5 |
| 5 | 65 | 53 | 19 |
| 6 | 0 | 25 | 23 |
| 7 | 12 | 54 | 21 |
| 8 | 39 | 22 | 3 |
| 9 | 21 | 39 | 41 |
| 10 | 65 | 80 | 8 |
| 11 | 4 | 47 | 28 |
| 12 | 39 | 98 | 7 |
| 13 | 44 | 64 | 15 |
| 14 | 67 | 97 | 14 |
| 15 | 56 | 100 | 11 |
| 16 | 72 | 0 | 23 |
| 17 | 98 | 39 | 26 |
| 18 | 100 | 90 | 17 |

We will assign routes so each spot is visited exactly once, every route starts and ends at node 0, and no route's load exceeds 140.

Also, when you hand me the routes, just stick to this simple JSON layout so it's easy to read and validate:

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

This shows a ""solution"" as a list of routes. Each route is itself a list of stops that starts and ends with the depot_id; the middle entries are the collection locations on that loop. Think of it like filling out a little route card for each truck — nothing fancy, just the order of stops.

This JSON is just a sketch of the shape I expect, 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': [[44, 51], [77, 66], [61, 34], [28, 63], [81, 19], [65, 53], [0, 25], [12, 54], [39, 22], [21, 39], [65, 80], [4, 47], [39, 98], [44, 64], [67, 97], [56, 100], [72, 0], [98, 39], [100, 90]], 'depot': 0, 'demands': [0, 30, 21, 15, 5, 19, 23, 21, 3, 41, 8, 28, 7, 15, 14, 11, 23, 26, 17], 'capacity': 140, 'num_vehicles': 3, 'total_distance': 501.6998144714068, 'objective': 501.6998144714068}","[[0, 13, 12, 15, 14, 10, 18, 1, 5, 0], [0, 8, 16, 4, 17, 2, 0], [0, 9, 6, 11, 7, 3, 0]]",501.6998144714068,"{'problem_type': 'CVRP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 44, 'y': 51, 'demand': 0}, {'id': 1, 'x': 77, 'y': 66, 'demand': 30}, {'id': 2, 'x': 61, 'y': 34, 'demand': 21}, {'id': 3, 'x': 28, 'y': 63, 'demand': 15}, {'id': 4, 'x': 81, 'y': 19, 'demand': 5}, {'id': 5, 'x': 65, 'y': 53, 'demand': 19}, {'id': 6, 'x': 0, 'y': 25, 'demand': 23}, {'id': 7, 'x': 12, 'y': 54, 'demand': 21}, {'id': 8, 'x': 39, 'y': 22, 'demand': 3}, {'id': 9, 'x': 21, 'y': 39, 'demand': 41}, {'id': 10, 'x': 65, 'y': 80, 'demand': 8}, {'id': 11, 'x': 4, 'y': 47, 'demand': 28}, {'id': 12, 'x': 39, 'y': 98, 'demand': 7}, {'id': 13, 'x': 44, 'y': 64, 'demand': 15}, {'id': 14, 'x': 67, 'y': 97, 'demand': 14}, {'id': 15, 'x': 56, 'y': 100, 'demand': 11}, {'id': 16, 'x': 72, 'y': 0, 'demand': 23}, {'id': 17, 'x': 98, 'y': 39, 'demand': 26}, {'id': 18, 'x': 100, 'y': 90, 'demand': 17}], 'depot': 0, 'capacity': 140, 'num_vehicles': 3, 'total_distance': 501.6998144714068, 'objective': 501.6998144714068}","[[0, 13, 12, 15, 14, 10, 18, 1, 5, 0], [0, 8, 16, 4, 17, 2, 0], [0, 9, 6, 11, 7, 3, 0]]",25,markdown_table,0
CVRP,CVRP,"Recently the outreach team asked for a clean way to schedule mobile donation visits: split the community stops into runs that start and end at the clinic, make sure each stop gets one visit only, and don’t overload any van beyond its seating or storage. The winning schedule is the one with the smallest total driving distance — just add together all the route lengths to see which is shortest. The detailed list of stops and capacities is shown below.

{
  ""total_locations"": 16,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coord"": 8,
      ""y_coord"": 19,
      ""expected_donors"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coord"": 28,
      ""y_coord"": 53,
      ""expected_donors"": 19
    },
    {
      ""location_id"": ""C"",
      ""x_coord"": 61,
      ""y_coord"": 44,
      ""expected_donors"": 30
    },
    {
      ""location_id"": ""D"",
      ""x_coord"": 69,
      ""y_coord"": 86,
      ""expected_donors"": 16
    },
    {
      ""location_id"": ""E"",
      ""x_coord"": 11,
      ""y_coord"": 81,
      ""expected_donors"": 23
    },
    {
      ""location_id"": ""F"",
      ""x_coord"": 69,
      ""y_coord"": 0,
      ""expected_donors"": 11
    },
    {
      ""location_id"": ""G"",
      ""x_coord"": 42,
      ""y_coord"": 22,
      ""expected_donors"": 31
    },
    {
      ""location_id"": ""H"",
      ""x_coord"": 97,
      ""y_coord"": 25,
      ""expected_donors"": 8
    },
    {
      ""location_id"": ""I"",
      ""x_coord"": 42,
      ""y_coord"": 67,
      ""expected_donors"": 8
    },
    {
      ""location_id"": ""J"",
      ""x_coord"": 0,
      ""y_coord"": 97,
      ""expected_donors"": 7
    },
    {
      ""location_id"": ""K"",
      ""x_coord"": 44,
      ""y_coord"": 94,
      ""expected_donors"": 14
    },
    {
      ""location_id"": ""L"",
      ""x_coord"": 86,
      ""y_coord"": 42,
      ""expected_donors"": 6
    },
    {
      ""location_id"": ""M"",
      ""x_coord"": 94,
      ""y_coord"": 0,
      ""expected_donors"": 26
    },
    {
      ""location_id"": ""N"",
      ""x_coord"": 97,
      ""y_coord"": 83,
      ""expected_donors"": 17
    },
    {
      ""location_id"": ""O"",
      ""x_coord"": 100,
      ""y_coord"": 100,
      ""expected_donors"": 6
    },
    {
      ""location_id"": ""P"",
      ""x_coord"": 50,
      ""y_coord"": 6,
      ""expected_donors"": 15
    }
  ],
  ""clinic_id"": ""A"",
  ""van_capacity"": 160
}

Oh, and when you hand the schedule back, please use this simple JSON shape so it's easy to parse:

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

""solution"" is just a list of runs. Each inner list is one run that starts and ends at the clinic (that's the first and last placeholder), with the stops visited in between. It's just a quick sketch of the format I need — not the actual answer.

Please use the exact identifiers from the instance input when filling this in — do not rename them or add 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': [[8, 19], [28, 53], [61, 44], [69, 86], [11, 81], [69, 0], [42, 22], [97, 25], [42, 67], [0, 97], [44, 94], [86, 42], [94, 0], [97, 83], [100, 100], [50, 6]], 'depot': 0, 'demands': [0, 19, 30, 16, 23, 11, 31, 8, 8, 7, 14, 6, 26, 17, 6, 15], 'capacity': 160, 'num_vehicles': 2, 'total_distance': 532.1649110620538, 'objective': 532.1649110620538}","[[0, 15, 5, 12, 7, 11, 13, 14, 3, 10, 9, 4, 0], [0, 1, 8, 2, 6, 0]]",532.1649110620538,"{'problem_type': 'CVRP', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 8, 'y': 19, 'demand': 0}, {'id': 'B', 'x': 28, 'y': 53, 'demand': 19}, {'id': 'C', 'x': 61, 'y': 44, 'demand': 30}, {'id': 'D', 'x': 69, 'y': 86, 'demand': 16}, {'id': 'E', 'x': 11, 'y': 81, 'demand': 23}, {'id': 'F', 'x': 69, 'y': 0, 'demand': 11}, {'id': 'G', 'x': 42, 'y': 22, 'demand': 31}, {'id': 'H', 'x': 97, 'y': 25, 'demand': 8}, {'id': 'I', 'x': 42, 'y': 67, 'demand': 8}, {'id': 'J', 'x': 0, 'y': 97, 'demand': 7}, {'id': 'K', 'x': 44, 'y': 94, 'demand': 14}, {'id': 'L', 'x': 86, 'y': 42, 'demand': 6}, {'id': 'M', 'x': 94, 'y': 0, 'demand': 26}, {'id': 'N', 'x': 97, 'y': 83, 'demand': 17}, {'id': 'O', 'x': 100, 'y': 100, 'demand': 6}, {'id': 'P', 'x': 50, 'y': 6, 'demand': 15}], 'depot': 'A', 'capacity': 160, 'num_vehicles': 2, 'total_distance': 532.1649110620538, 'objective': 532.1649110620538}","[['A', 'P', 'F', 'M', 'H', 'L', 'N', 'O', 'D', 'K', 'J', 'E', 'A'], ['A', 'B', 'I', 'C', 'G', 'A']]",26,json,names
CVRP,CVRP,"We need a straightforward pickup schedule: assign which truck goes to which compost sites so every site is covered once, every run starts and ends at the yard, and no truck is overloaded. The winning schedule is the one with the least total driving distance — you get that by summing the length of every truck’s route from the yard out through its stops and back again. Concrete details about the locations, their amounts, and the truck limits follow below.

# total_locations_including_yard=18
# yard_node_id=0
# truck_capacity=101
site_id,site_x_coordinate,site_y_coordinate,pickup_amount
0,0,0,0
1,96,90,8
2,26,9,9
3,79,37,7
4,37,51,7
5,39,42,5
6,9,94,7
7,66,26,9
8,100,19,7
9,95,17,5
10,63,16,8
11,8,49,8
12,0,1,9
13,93,71,8
14,29,18,8
15,87,100,9
16,96,18,10
17,90,17,5

Also, when you send the actual plan back, keep it in this simple JSON layout so it's easy to read and check:

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

Think of ""solution"" as a list of runs. Each run is a list that starts and ends at the yard, with the compost sites visited in between — those placeholders just show the shape, not the real IDs or the final routes. This is only a sketch of the expected format, not the finished answer.

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, 0], [96, 90], [26, 9], [79, 37], [37, 51], [39, 42], [9, 94], [66, 26], [100, 19], [95, 17], [63, 16], [8, 49], [0, 1], [93, 71], [29, 18], [87, 100], [96, 18], [90, 17]], 'depot': 0, 'demands': [0, 8, 9, 7, 7, 5, 7, 9, 7, 5, 8, 8, 9, 8, 8, 9, 10, 5], 'capacity': 101, 'num_vehicles': 2, 'total_distance': 514.3400366878448, 'objective': 514.3400366878448}","[[0, 14, 5, 4, 12, 0], [0, 11, 6, 15, 1, 13, 3, 8, 16, 9, 17, 7, 10, 2, 0]]",514.3400366878448,"{'problem_type': 'CVRP', 'num_nodes': 18, 'nodes': [{'id': 0, 'x': 0, 'y': 0, 'demand': 0}, {'id': 1, 'x': 96, 'y': 90, 'demand': 8}, {'id': 2, 'x': 26, 'y': 9, 'demand': 9}, {'id': 3, 'x': 79, 'y': 37, 'demand': 7}, {'id': 4, 'x': 37, 'y': 51, 'demand': 7}, {'id': 5, 'x': 39, 'y': 42, 'demand': 5}, {'id': 6, 'x': 9, 'y': 94, 'demand': 7}, {'id': 7, 'x': 66, 'y': 26, 'demand': 9}, {'id': 8, 'x': 100, 'y': 19, 'demand': 7}, {'id': 9, 'x': 95, 'y': 17, 'demand': 5}, {'id': 10, 'x': 63, 'y': 16, 'demand': 8}, {'id': 11, 'x': 8, 'y': 49, 'demand': 8}, {'id': 12, 'x': 0, 'y': 1, 'demand': 9}, {'id': 13, 'x': 93, 'y': 71, 'demand': 8}, {'id': 14, 'x': 29, 'y': 18, 'demand': 8}, {'id': 15, 'x': 87, 'y': 100, 'demand': 9}, {'id': 16, 'x': 96, 'y': 18, 'demand': 10}, {'id': 17, 'x': 90, 'y': 17, 'demand': 5}], 'depot': 0, 'capacity': 101, 'num_vehicles': 2, 'total_distance': 514.3400366878448, 'objective': 514.3400366878448}","[[0, 14, 5, 4, 12, 0], [0, 11, 6, 15, 1, 13, 3, 8, 16, 9, 17, 7, 10, 2, 0]]",27,csv,0
CVRP,CVRP,"Someone on the logistics team needs to assign which truck goes to which gigs this weekend. The plan must make sure every venue gets its gear exactly once, every truck starts out from the depot and returns there when it’s done, and loads never exceed a truck’s weight limit. The simplest way to judge a plan is by total driving distance — total it up by summing each truck’s route, and the lower the total the better. The exact orders, weights, and truck capacities are detailed below.

# total_locations_including_depot=25
# depot_location_id=0
# vehicle_capacity_weight=138
location_id,x_coordinate,y_coordinate,order_weight
0,50,53,0
1,91,45,90
2,52,0,55
3,0,64,51
4,43,20,7
5,73,8,6
6,52,21,2
7,97,12,5
8,92,41,2
9,15,89,8
10,75,78,4
11,100,14,6
12,90,37,10
13,67,28,9
14,17,46,6
15,12,72,1
16,8,36,1
17,82,39,3
18,99,5,8
19,48,100,3
20,62,65,7
21,100,35,2
22,67,89,7
23,7,26,8
24,90,32,3

Oh, and one more thing — when you send the plan back, please use 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], ...]
}

Think of it like a form: each inner list is one truck's trip (start at the depot, visit the venues in order, come back to the depot), and the outer list is the set of all trucks/routes. The placeholders (like depot_id and location_id) stand for the actual identifiers you'll use for the depot and the venues.

This is just a sketch of the shape I want, not the actual answers — fill it with the real IDs from the instance when you reply. Please make sure all identifiers are used exactly as they appear in 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': [[50, 53], [91, 45], [52, 0], [0, 64], [43, 20], [73, 8], [52, 21], [97, 12], [92, 41], [15, 89], [75, 78], [100, 14], [90, 37], [67, 28], [17, 46], [12, 72], [8, 36], [82, 39], [99, 5], [48, 100], [62, 65], [100, 35], [67, 89], [7, 26], [90, 32]], 'depot': 0, 'demands': [0, 90, 55, 51, 7, 6, 2, 5, 2, 8, 4, 6, 10, 9, 6, 1, 1, 3, 8, 3, 7, 2, 7, 8, 3], 'capacity': 138, 'num_vehicles': 3, 'total_distance': 531.8774093289436, 'objective': 531.8774093289436}","[[0, 20, 10, 22, 19, 9, 15, 3, 16, 23, 14, 0], [0, 1, 8, 21, 11, 18, 7, 24, 12, 17, 0], [0, 13, 5, 2, 4, 6, 0]]",531.8774093289436,"{'problem_type': 'CVRP', 'num_nodes': 25, 'nodes': [{'id': 0, 'x': 50, 'y': 53, 'demand': 0}, {'id': 1, 'x': 91, 'y': 45, 'demand': 90}, {'id': 2, 'x': 52, 'y': 0, 'demand': 55}, {'id': 3, 'x': 0, 'y': 64, 'demand': 51}, {'id': 4, 'x': 43, 'y': 20, 'demand': 7}, {'id': 5, 'x': 73, 'y': 8, 'demand': 6}, {'id': 6, 'x': 52, 'y': 21, 'demand': 2}, {'id': 7, 'x': 97, 'y': 12, 'demand': 5}, {'id': 8, 'x': 92, 'y': 41, 'demand': 2}, {'id': 9, 'x': 15, 'y': 89, 'demand': 8}, {'id': 10, 'x': 75, 'y': 78, 'demand': 4}, {'id': 11, 'x': 100, 'y': 14, 'demand': 6}, {'id': 12, 'x': 90, 'y': 37, 'demand': 10}, {'id': 13, 'x': 67, 'y': 28, 'demand': 9}, {'id': 14, 'x': 17, 'y': 46, 'demand': 6}, {'id': 15, 'x': 12, 'y': 72, 'demand': 1}, {'id': 16, 'x': 8, 'y': 36, 'demand': 1}, {'id': 17, 'x': 82, 'y': 39, 'demand': 3}, {'id': 18, 'x': 99, 'y': 5, 'demand': 8}, {'id': 19, 'x': 48, 'y': 100, 'demand': 3}, {'id': 20, 'x': 62, 'y': 65, 'demand': 7}, {'id': 21, 'x': 100, 'y': 35, 'demand': 2}, {'id': 22, 'x': 67, 'y': 89, 'demand': 7}, {'id': 23, 'x': 7, 'y': 26, 'demand': 8}, {'id': 24, 'x': 90, 'y': 32, 'demand': 3}], 'depot': 0, 'capacity': 138, 'num_vehicles': 3, 'total_distance': 531.8774093289436, 'objective': 531.8774093289436}","[[0, 20, 10, 22, 19, 9, 15, 3, 16, 23, 14, 0], [0, 1, 8, 21, 11, 18, 7, 24, 12, 17, 0], [0, 13, 5, 2, 4, 6, 0]]",28,csv,0
CVRP,CVRP,"There’s a courier team that runs morning drops out of the sorting office and the challenge is to draw up routes so every mailbox is covered exactly once. Each trip has to leave and return to the sorting office, a vehicle can’t be packed beyond its carrying limit, and the whole set of trips should rack up as few miles as possible — that is checked by summing the distance of every route. The specific stops and mail loads are shown below.

{
  ""total_locations"": 17,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coordinate_miles"": 17,
      ""y_coordinate_miles"": 4,
      ""mail_demand"": 0
    },
    {
      ""location_id"": ""B"",
      ""x_coordinate_miles"": 78,
      ""y_coordinate_miles"": 24,
      ""mail_demand"": 83
    },
    {
      ""location_id"": ""C"",
      ""x_coordinate_miles"": 63,
      ""y_coordinate_miles"": 46,
      ""mail_demand"": 55
    },
    {
      ""location_id"": ""D"",
      ""x_coordinate_miles"": 22,
      ""y_coordinate_miles"": 49,
      ""mail_demand"": 86
    },
    {
      ""location_id"": ""E"",
      ""x_coordinate_miles"": 82,
      ""y_coordinate_miles"": 51,
      ""mail_demand"": 64
    },
    {
      ""location_id"": ""F"",
      ""x_coordinate_miles"": 54,
      ""y_coordinate_miles"": 30,
      ""mail_demand"": 96
    },
    {
      ""location_id"": ""G"",
      ""x_coordinate_miles"": 0,
      ""y_coordinate_miles"": 5,
      ""mail_demand"": 66
    },
    {
      ""location_id"": ""H"",
      ""x_coordinate_miles"": 17,
      ""y_coordinate_miles"": 86,
      ""mail_demand"": 59
    },
    {
      ""location_id"": ""I"",
      ""x_coordinate_miles"": 94,
      ""y_coordinate_miles"": 36,
      ""mail_demand"": 88
    },
    {
      ""location_id"": ""J"",
      ""x_coordinate_miles"": 0,
      ""y_coordinate_miles"": 100,
      ""mail_demand"": 88
    },
    {
      ""location_id"": ""K"",
      ""x_coordinate_miles"": 13,
      ""y_coordinate_miles"": 53,
      ""mail_demand"": 52
    },
    {
      ""location_id"": ""L"",
      ""x_coordinate_miles"": 100,
      ""y_coordinate_miles"": 42,
      ""mail_demand"": 95
    },
    {
      ""location_id"": ""M"",
      ""x_coordinate_miles"": 34,
      ""y_coordinate_miles"": 59,
      ""mail_demand"": 54
    },
    {
      ""location_id"": ""N"",
      ""x_coordinate_miles"": 2,
      ""y_coordinate_miles"": 65,
      ""mail_demand"": 65
    },
    {
      ""location_id"": ""O"",
      ""x_coordinate_miles"": 90,
      ""y_coordinate_miles"": 93,
      ""mail_demand"": 65
    },
    {
      ""location_id"": ""P"",
      ""x_coordinate_miles"": 69,
      ""y_coordinate_miles"": 0,
      ""mail_demand"": 71
    },
    {
      ""location_id"": ""Q"",
      ""x_coordinate_miles"": 11,
      ""y_coordinate_miles"": 57,
      ""mail_demand"": 90
    }
  ],
  ""sorting_office_id"": ""A"",
  ""vehicle_capacity_mail_units"": 487
}

When you send the routes back, just use this simple JSON layout so it's easy to read and plug into the system:

{
  ""solution"": [[sorting_office_id, mailbox_id, ... , sorting_office_id], [sorting_office_id, mailbox_id, ... , sorting_office_id], ...]
}

This is just a sketch of the shape I expect: ""solution"" is the list of trips, each inner list is one round trip that starts and ends at the sorting office, and the placeholders (like sorting_office_id and mailbox_id) show where you'll drop in the actual stop IDs from the instance. It's an example, not the real answer — plug in the real identifiers for each stop.

Please make sure to use the identifiers exactly as they appear in the instance input — don't rename them and don't 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': [[17, 4], [78, 24], [63, 46], [22, 49], [82, 51], [54, 30], [0, 5], [17, 86], [94, 36], [0, 100], [13, 53], [100, 42], [34, 59], [2, 65], [90, 93], [69, 0], [11, 57]], 'depot': 0, 'demands': [0, 83, 55, 86, 64, 96, 66, 59, 88, 88, 52, 95, 54, 65, 65, 71, 90], 'capacity': 487, 'num_vehicles': 3, 'total_distance': 654.858389276402, 'objective': 654.858389276402}","[[0, 10, 16, 7, 9, 13, 6, 0], [0, 5, 2, 12, 3, 0], [0, 4, 14, 11, 8, 1, 15, 0]]",654.858389276402,"{'problem_type': 'CVRP', 'num_nodes': 17, 'nodes': [{'id': 'A', 'x': 17, 'y': 4, 'demand': 0}, {'id': 'B', 'x': 78, 'y': 24, 'demand': 83}, {'id': 'C', 'x': 63, 'y': 46, 'demand': 55}, {'id': 'D', 'x': 22, 'y': 49, 'demand': 86}, {'id': 'E', 'x': 82, 'y': 51, 'demand': 64}, {'id': 'F', 'x': 54, 'y': 30, 'demand': 96}, {'id': 'G', 'x': 0, 'y': 5, 'demand': 66}, {'id': 'H', 'x': 17, 'y': 86, 'demand': 59}, {'id': 'I', 'x': 94, 'y': 36, 'demand': 88}, {'id': 'J', 'x': 0, 'y': 100, 'demand': 88}, {'id': 'K', 'x': 13, 'y': 53, 'demand': 52}, {'id': 'L', 'x': 100, 'y': 42, 'demand': 95}, {'id': 'M', 'x': 34, 'y': 59, 'demand': 54}, {'id': 'N', 'x': 2, 'y': 65, 'demand': 65}, {'id': 'O', 'x': 90, 'y': 93, 'demand': 65}, {'id': 'P', 'x': 69, 'y': 0, 'demand': 71}, {'id': 'Q', 'x': 11, 'y': 57, 'demand': 90}], 'depot': 'A', 'capacity': 487, 'num_vehicles': 3, 'total_distance': 654.858389276402, 'objective': 654.858389276402}","[['A', 'K', 'Q', 'H', 'J', 'N', 'G', 'A'], ['A', 'F', 'C', 'M', 'D', 'A'], ['A', 'E', 'O', 'L', 'I', 'B', 'P', 'A']]",29,json,names
CVRP,CVRP,"Back at the office the crew needs to map out supply runs so each build site gets a single delivery, with every trip launching from the yard and finishing there, and no vehicle carrying more than it’s rated for. The key comparison between different plans is how much driving they cause: take each route’s distance, add them up, and the lower that grand total the better the plan. The full instance details — which sites, how much material, and vehicle capacities — are listed below.

There are 20 locations in total, the yard is 1, and each vehicle can carry up to 100 units.
The crew records location 1 at (76, 99) requiring 0 units.
The crew records location 2 at (90, 42) requiring 12 units.
The crew records location 3 at (55, 0) requiring 3 units.
The crew records location 4 at (2, 83) requiring 2 units.
The crew records location 5 at (30, 4) requiring 17 units.
The crew records location 6 at (94, 50) requiring 1 units.
The crew records location 7 at (16, 97) requiring 26 units.
The crew records location 8 at (95, 48) requiring 13 units.
The crew records location 9 at (97, 51) requiring 20 units.
The crew records location 10 at (99, 47) requiring 25 units.
The crew records location 11 at (10, 85) requiring 15 units.
The crew records location 12 at (94, 52) requiring 2 units.
The crew records location 13 at (11, 18) requiring 13 units.
The crew records location 14 at (15, 100) requiring 9 units.
The crew records location 15 at (0, 4) requiring 17 units.
The crew records location 16 at (100, 60) requiring 26 units.
The crew records location 17 at (32, 8) requiring 9 units.
The crew records location 18 at (61, 1) requiring 9 units.
The crew records location 19 at (3, 90) requiring 25 units.
The crew records location 20 at (14, 23) requiring 13 units.
Use these entries so the crew can confirm all 20 locations are served once and no route exceeds 100.

Also, when you send the plan back, just use this simple JSON layout so I can read the routes programmatically — nothing fancy needed:

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

This just means: ""solution"" is a list of routes, each route is a list that starts and ends at the yard and lists the sites visited in order. Think of it like filling out a form where each row is one round-trip from the yard to a few sites and back.

This JSON is only a sketch of the expected shape — not the actual answer.

Please make sure you use the exact identifiers from the instance input, 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': [[76, 99], [90, 42], [55, 0], [2, 83], [30, 4], [94, 50], [16, 97], [95, 48], [97, 51], [99, 47], [10, 85], [94, 52], [11, 18], [15, 100], [0, 4], [100, 60], [32, 8], [61, 1], [3, 90], [14, 23]], 'depot': 0, 'demands': [0, 12, 3, 2, 17, 1, 26, 13, 20, 25, 15, 2, 13, 9, 17, 26, 9, 9, 25, 13], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 575.5791392445882, 'objective': 575.5791392445882}","[[0, 6, 13, 18, 3, 10, 0], [0, 11, 5, 7, 9, 8, 15, 0], [0, 19, 12, 14, 4, 16, 2, 17, 1, 0]]",575.5791392445882,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 1, 'x': 76, 'y': 99, 'demand': 0}, {'id': 2, 'x': 90, 'y': 42, 'demand': 12}, {'id': 3, 'x': 55, 'y': 0, 'demand': 3}, {'id': 4, 'x': 2, 'y': 83, 'demand': 2}, {'id': 5, 'x': 30, 'y': 4, 'demand': 17}, {'id': 6, 'x': 94, 'y': 50, 'demand': 1}, {'id': 7, 'x': 16, 'y': 97, 'demand': 26}, {'id': 8, 'x': 95, 'y': 48, 'demand': 13}, {'id': 9, 'x': 97, 'y': 51, 'demand': 20}, {'id': 10, 'x': 99, 'y': 47, 'demand': 25}, {'id': 11, 'x': 10, 'y': 85, 'demand': 15}, {'id': 12, 'x': 94, 'y': 52, 'demand': 2}, {'id': 13, 'x': 11, 'y': 18, 'demand': 13}, {'id': 14, 'x': 15, 'y': 100, 'demand': 9}, {'id': 15, 'x': 0, 'y': 4, 'demand': 17}, {'id': 16, 'x': 100, 'y': 60, 'demand': 26}, {'id': 17, 'x': 32, 'y': 8, 'demand': 9}, {'id': 18, 'x': 61, 'y': 1, 'demand': 9}, {'id': 19, 'x': 3, 'y': 90, 'demand': 25}, {'id': 20, 'x': 14, 'y': 23, 'demand': 13}], 'depot': 1, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 575.5791392445882, 'objective': 575.5791392445882}","[[1, 7, 14, 19, 4, 11, 1], [1, 12, 6, 8, 10, 9, 16, 1], [1, 20, 13, 15, 5, 17, 3, 18, 2, 1]]",30,nl,1
CVRP,CVRP,"There’s a bottling plant that fills trucks and sends them out to a list of bars, and the goal is to plan the runs so every bar gets served exactly once and each driver returns to the plant at the end of the day. The decisions are about grouping nearby bars into routes without overstuffing any truck — each route can only carry so much product. Better plans are the ones that reduce overall driving: compute the sum of the distances of all routes and aim for the smallest possible total. The concrete details are shown below.

Instance details: the instance has 20 locations including the plant, the plant is node 1, and each truck can carry up to 643 units.
Location 1 at (0, 46) requires 0 units.
Location 2 at (63, 26) requires 23 units.
Location 3 at (34, 7) requires 84 units.
Location 4 at (23, 66) requires 95 units.
Location 5 at (50, 79) requires 78 units.
Location 6 at (27, 98) requires 73 units.
Location 7 at (100, 0) requires 45 units.
Location 8 at (61, 44) requires 7 units.
Location 9 at (39, 59) requires 52 units.
Location 10 at (40, 5) requires 84 units.
Location 11 at (66, 33) requires 42 units.
Location 12 at (9, 59) requires 73 units.
Location 13 at (34, 67) requires 69 units.
Location 14 at (44, 65) requires 73 units.
Location 15 at (33, 20) requires 93 units.
Location 16 at (39, 72) requires 59 units.
Location 17 at (37, 50) requires 90 units.
Location 18 at (22, 100) requires 77 units.
Location 19 at (28, 50) requires 57 units.
Location 20 at (29, 41) requires 72 units.
Plan routes that serve every bar once, return each driver to the plant 1, and do not exceed truck capacity 643 while minimizing total driving distance.

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

{
  ""solution"": [[plant_id, bar_id, ... , plant_id], [plant_id, bar_id, ... , plant_id], ...]
}

Think of it like a little form: ""solution"" is a list of routes, each route is the sequence of stops starting and ending at the plant (plant_id) with the bars (bar_id) visited in order. The ""..."" just means there can be more stops in between. This is only a sketch of the shape I expect, not the actual routes.

Please use the exact identifiers from the instance input — don't rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 46], [63, 26], [34, 7], [23, 66], [50, 79], [27, 98], [100, 0], [61, 44], [39, 59], [40, 5], [66, 33], [9, 59], [34, 67], [44, 65], [33, 20], [39, 72], [37, 50], [22, 100], [28, 50], [29, 41]], 'depot': 0, 'demands': [0, 23, 84, 95, 78, 73, 45, 7, 52, 84, 42, 73, 69, 73, 93, 59, 90, 77, 57, 72], 'capacity': 643, 'num_vehicles': 2, 'total_distance': 439.4144310392674, 'objective': 439.4144310392674}","[[0, 14, 2, 9, 6, 1, 10, 7, 4, 5, 17, 0], [0, 19, 18, 16, 8, 13, 15, 12, 3, 11, 0]]",439.4144310392674,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 1, 'x': 0, 'y': 46, 'demand': 0}, {'id': 2, 'x': 63, 'y': 26, 'demand': 23}, {'id': 3, 'x': 34, 'y': 7, 'demand': 84}, {'id': 4, 'x': 23, 'y': 66, 'demand': 95}, {'id': 5, 'x': 50, 'y': 79, 'demand': 78}, {'id': 6, 'x': 27, 'y': 98, 'demand': 73}, {'id': 7, 'x': 100, 'y': 0, 'demand': 45}, {'id': 8, 'x': 61, 'y': 44, 'demand': 7}, {'id': 9, 'x': 39, 'y': 59, 'demand': 52}, {'id': 10, 'x': 40, 'y': 5, 'demand': 84}, {'id': 11, 'x': 66, 'y': 33, 'demand': 42}, {'id': 12, 'x': 9, 'y': 59, 'demand': 73}, {'id': 13, 'x': 34, 'y': 67, 'demand': 69}, {'id': 14, 'x': 44, 'y': 65, 'demand': 73}, {'id': 15, 'x': 33, 'y': 20, 'demand': 93}, {'id': 16, 'x': 39, 'y': 72, 'demand': 59}, {'id': 17, 'x': 37, 'y': 50, 'demand': 90}, {'id': 18, 'x': 22, 'y': 100, 'demand': 77}, {'id': 19, 'x': 28, 'y': 50, 'demand': 57}, {'id': 20, 'x': 29, 'y': 41, 'demand': 72}], 'depot': 1, 'capacity': 643, 'num_vehicles': 2, 'total_distance': 439.4144310392674, 'objective': 439.4144310392674}","[[1, 15, 3, 10, 7, 2, 11, 8, 5, 6, 18, 1], [1, 20, 19, 17, 9, 14, 16, 13, 4, 12, 1]]",31,nl,1
CVRP,CVRP,"I help organize the creamery’s pickup runs: there’s a set of farms that need milk picked up, and the job is to group them into truck trips so every farm gets visited exactly once. Each truck leaves the creamery, visits the farms on its list, and then returns to the creamery, and no trip can carry more milk than the tanker holds. A better plan is one that cuts down on total driving — measured by adding up the miles for every trip — so the goal is to pick routes that keep that total as small as possible. Concrete details are shown below.

I list the concrete details for the 20 locations; the creamery is 1 and the tanker capacity is 192.

| location_id | x_coordinate | y_coordinate | milk_amount |
|---|---|---|---|
| 1 | 0 | 0 | 0 |
| 2 | 97 | 16 | 73 |
| 3 | 11 | 79 | 58 |
| 4 | 75 | 43 | 7 |
| 5 | 93 | 70 | 1 |
| 6 | 100 | 50 | 4 |
| 7 | 14 | 55 | 4 |
| 8 | 20 | 100 | 6 |
| 9 | 74 | 6 | 8 |
| 10 | 12 | 65 | 6 |
| 11 | 30 | 78 | 5 |
| 12 | 47 | 53 | 10 |
| 13 | 13 | 67 | 8 |
| 14 | 56 | 40 | 10 |
| 15 | 23 | 32 | 4 |
| 16 | 5 | 68 | 9 |
| 17 | 38 | 44 | 9 |
| 18 | 17 | 91 | 7 |
| 19 | 81 | 56 | 6 |
| 20 | 79 | 75 | 7 |

I’ll use these details to plan routes that respect the tanker capacity 192 and visit each farm once.

When you’re ready to send me a plan, just put it in this simple JSON layout so I can read the routes cleanly:

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

This is just a quick sketch of the shape I’m expecting: ""solution"" is a list of routes, each route is a list that starts and ends at the creamery and lists the farms visited in between. Think of it like filling out a little itinerary form for each truck.

This JSON is only an outline of the format — not the actual routes. Please use the exact identifiers from the instance input when you fill it in: 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, 0], [97, 16], [11, 79], [75, 43], [93, 70], [100, 50], [14, 55], [20, 100], [74, 6], [12, 65], [30, 78], [47, 53], [13, 67], [56, 40], [23, 32], [5, 68], [38, 44], [17, 91], [81, 56], [79, 75]], 'depot': 0, 'demands': [0, 73, 58, 7, 1, 4, 4, 6, 8, 6, 5, 10, 8, 10, 4, 9, 9, 7, 6, 7], 'capacity': 192, 'num_vehicles': 2, 'total_distance': 526.5447755694142, 'objective': 526.5447755694142}","[[0, 8, 1, 5, 4, 19, 18, 3, 13, 11, 16, 14, 0], [0, 15, 2, 17, 7, 10, 12, 9, 6, 0]]",526.5447755694142,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'demand': 0}, {'id': 2, 'x': 97, 'y': 16, 'demand': 73}, {'id': 3, 'x': 11, 'y': 79, 'demand': 58}, {'id': 4, 'x': 75, 'y': 43, 'demand': 7}, {'id': 5, 'x': 93, 'y': 70, 'demand': 1}, {'id': 6, 'x': 100, 'y': 50, 'demand': 4}, {'id': 7, 'x': 14, 'y': 55, 'demand': 4}, {'id': 8, 'x': 20, 'y': 100, 'demand': 6}, {'id': 9, 'x': 74, 'y': 6, 'demand': 8}, {'id': 10, 'x': 12, 'y': 65, 'demand': 6}, {'id': 11, 'x': 30, 'y': 78, 'demand': 5}, {'id': 12, 'x': 47, 'y': 53, 'demand': 10}, {'id': 13, 'x': 13, 'y': 67, 'demand': 8}, {'id': 14, 'x': 56, 'y': 40, 'demand': 10}, {'id': 15, 'x': 23, 'y': 32, 'demand': 4}, {'id': 16, 'x': 5, 'y': 68, 'demand': 9}, {'id': 17, 'x': 38, 'y': 44, 'demand': 9}, {'id': 18, 'x': 17, 'y': 91, 'demand': 7}, {'id': 19, 'x': 81, 'y': 56, 'demand': 6}, {'id': 20, 'x': 79, 'y': 75, 'demand': 7}], 'depot': 1, 'capacity': 192, 'num_vehicles': 2, 'total_distance': 526.5447755694142, 'objective': 526.5447755694142}","[[1, 9, 2, 6, 5, 20, 19, 4, 14, 12, 17, 15, 1], [1, 16, 3, 18, 8, 11, 13, 10, 7, 1]]",32,markdown_table,1
CVRP,CVRP,"Recently the office asked for a simpler way to send crews out: every technician should start and finish at the central hub, visit each service location only once, and only carry what fits in their van. The trick is picking which stops go on each technician’s run and the order they’ll be visited, while never exceeding any van’s load and never leaving a site unvisited or visited twice. The scoring is straightforward — total miles driven by the whole team, calculated by adding up each route’s distance — and the exact instance details follow below.

{
  ""num_locations"": 17,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""x_coord"": 87,
      ""y_coord"": 40,
      ""service_demand"": 0
    },
    {
      ""location_id"": 2,
      ""x_coord"": 22,
      ""y_coord"": 28,
      ""service_demand"": 51
    },
    {
      ""location_id"": 3,
      ""x_coord"": 57,
      ""y_coord"": 0,
      ""service_demand"": 1135
    },
    {
      ""location_id"": 4,
      ""x_coord"": 26,
      ""y_coord"": 19,
      ""service_demand"": 57
    },
    {
      ""location_id"": 5,
      ""x_coord"": 26,
      ""y_coord"": 21,
      ""service_demand"": 51
    },
    {
      ""location_id"": 6,
      ""x_coord"": 26,
      ""y_coord"": 28,
      ""service_demand"": 179
    },
    {
      ""location_id"": 7,
      ""x_coord"": 100,
      ""y_coord"": 53,
      ""service_demand"": 889
    },
    {
      ""location_id"": 8,
      ""x_coord"": 96,
      ""y_coord"": 58,
      ""service_demand"": 1810
    },
    {
      ""location_id"": 9,
      ""x_coord"": 0,
      ""y_coord"": 70,
      ""service_demand"": 207
    },
    {
      ""location_id"": 10,
      ""x_coord"": 61,
      ""y_coord"": 58,
      ""service_demand"": 117
    },
    {
      ""location_id"": 11,
      ""x_coord"": 91,
      ""y_coord"": 91,
      ""service_demand"": 1877
    },
    {
      ""location_id"": 12,
      ""x_coord"": 78,
      ""y_coord"": 88,
      ""service_demand"": 801
    },
    {
      ""location_id"": 13,
      ""x_coord"": 70,
      ""y_coord"": 81,
      ""service_demand"": 967
    },
    {
      ""location_id"": 14,
      ""x_coord"": 70,
      ""y_coord"": 84,
      ""service_demand"": 62
    },
    {
      ""location_id"": 15,
      ""x_coord"": 65,
      ""y_coord"": 100,
      ""service_demand"": 230
    },
    {
      ""location_id"": 16,
      ""x_coord"": 35,
      ""y_coord"": 51,
      ""service_demand"": 383
    },
    {
      ""location_id"": 17,
      ""x_coord"": 17,
      ""y_coord"": 58,
      ""service_demand"": 754
    }
  ],
  ""hub_id"": 1,
  ""van_capacity"": 30000
}

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

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

Think of it like a little form: the outer list is the whole day's set of runs, each inner list is one technician's trip that starts and ends at the hub and lists the service sites in visit order. This block is just a sketch of the shape I want — fill it with the actual route lists for the instance.

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': [[87, 40], [22, 28], [57, 0], [26, 19], [26, 21], [26, 28], [100, 53], [96, 58], [0, 70], [61, 58], [91, 91], [78, 88], [70, 81], [70, 84], [65, 100], [35, 51], [17, 58]], 'depot': 0, 'demands': [0, 51, 1135, 57, 51, 179, 889, 1810, 207, 117, 1877, 801, 967, 62, 230, 383, 754], 'capacity': 30000, 'num_vehicles': 1, 'total_distance': 347.47932213471773, 'objective': 347.47932213471773}","[[0, 2, 3, 4, 5, 1, 8, 16, 15, 9, 12, 13, 14, 11, 10, 7, 6, 0]]",347.47932213471773,"{'problem_type': 'CVRP', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 87, 'y': 40, 'demand': 0}, {'id': 2, 'x': 22, 'y': 28, 'demand': 51}, {'id': 3, 'x': 57, 'y': 0, 'demand': 1135}, {'id': 4, 'x': 26, 'y': 19, 'demand': 57}, {'id': 5, 'x': 26, 'y': 21, 'demand': 51}, {'id': 6, 'x': 26, 'y': 28, 'demand': 179}, {'id': 7, 'x': 100, 'y': 53, 'demand': 889}, {'id': 8, 'x': 96, 'y': 58, 'demand': 1810}, {'id': 9, 'x': 0, 'y': 70, 'demand': 207}, {'id': 10, 'x': 61, 'y': 58, 'demand': 117}, {'id': 11, 'x': 91, 'y': 91, 'demand': 1877}, {'id': 12, 'x': 78, 'y': 88, 'demand': 801}, {'id': 13, 'x': 70, 'y': 81, 'demand': 967}, {'id': 14, 'x': 70, 'y': 84, 'demand': 62}, {'id': 15, 'x': 65, 'y': 100, 'demand': 230}, {'id': 16, 'x': 35, 'y': 51, 'demand': 383}, {'id': 17, 'x': 17, 'y': 58, 'demand': 754}], 'depot': 1, 'capacity': 30000, 'num_vehicles': 1, 'total_distance': 347.47932213471773, 'objective': 347.47932213471773}","[[1, 3, 4, 5, 6, 2, 9, 17, 16, 10, 13, 14, 15, 12, 11, 8, 7, 1]]",33,json,1
CVRP,CVRP,"Picture this: a fleet of vans leaves and returns to the same downtown hub, and the challenge is to bundle customer stops into those loops so everyone gets one delivery, no one gets served twice, and each loop only carries as many parcels as the van can handle. The plan that’s preferred is the one with the least total mileage — just sum the lengths of all the loops and aim for the smallest number. The concrete numbers and locations follow below.

{
  ""total_locations_including_hub"": 19,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""x_coordinate"": 55,
      ""y_coordinate"": 55,
      ""parcels_required"": 0
    },
    {
      ""location_id"": 1,
      ""x_coordinate"": 100,
      ""y_coordinate"": 100,
      ""parcels_required"": 16
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 43,
      ""y_coordinate"": 36,
      ""parcels_required"": 23
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 9,
      ""y_coordinate"": 9,
      ""parcels_required"": 20
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 43,
      ""y_coordinate"": 0,
      ""parcels_required"": 8
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 30,
      ""y_coordinate"": 13,
      ""parcels_required"": 5
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 0,
      ""y_coordinate"": 16,
      ""parcels_required"": 18
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 95,
      ""y_coordinate"": 13,
      ""parcels_required"": 6
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 0,
      ""y_coordinate"": 47,
      ""parcels_required"": 7
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 11,
      ""y_coordinate"": 31,
      ""parcels_required"": 41
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 34,
      ""y_coordinate"": 40,
      ""parcels_required"": 27
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 57,
      ""y_coordinate"": 38,
      ""parcels_required"": 26
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 50,
      ""y_coordinate"": 53,
      ""parcels_required"": 19
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 55,
      ""y_coordinate"": 84,
      ""parcels_required"": 16
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 0,
      ""y_coordinate"": 42,
      ""parcels_required"": 6
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 68,
      ""y_coordinate"": 75,
      ""parcels_required"": 18
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 43,
      ""y_coordinate"": 100,
      ""parcels_required"": 16
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 23,
      ""y_coordinate"": 78,
      ""parcels_required"": 17
    },
    {
      ""location_id"": 18,
      ""x_coordinate"": 84,
      ""y_coordinate"": 29,
      ""parcels_required"": 20
    }
  ],
  ""hub_node_id"": 0,
  ""van_capacity_parcels"": 200
}

Oh, and when you send the route plan back, just use this simple JSON shape:

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

Here ""solution"" is a list of routes; each route is a loop that starts and ends at the depot_id, and the location_id entries in between are the stops in visit order. Think of it like filling out a little route form — it's only a sketch of the shape I need, not the actual routes for this instance.

Please make sure to use the exact identifiers that 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': [[55, 55], [100, 100], [43, 36], [9, 9], [43, 0], [30, 13], [0, 16], [95, 13], [0, 47], [11, 31], [34, 40], [57, 38], [50, 53], [55, 84], [0, 42], [68, 75], [43, 100], [23, 78], [84, 29]], 'depot': 0, 'demands': [0, 16, 23, 20, 8, 5, 18, 6, 7, 41, 27, 26, 19, 16, 6, 18, 16, 17, 20], 'capacity': 200, 'num_vehicles': 2, 'total_distance': 498.4946929270909, 'objective': 498.4946929270909}","[[0, 12, 8, 14, 9, 6, 3, 5, 4, 7, 18, 11, 0], [0, 2, 10, 17, 16, 13, 1, 15, 0]]",498.4946929270909,"{'problem_type': 'CVRP', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 55, 'y': 55, 'demand': 0}, {'id': 1, 'x': 100, 'y': 100, 'demand': 16}, {'id': 2, 'x': 43, 'y': 36, 'demand': 23}, {'id': 3, 'x': 9, 'y': 9, 'demand': 20}, {'id': 4, 'x': 43, 'y': 0, 'demand': 8}, {'id': 5, 'x': 30, 'y': 13, 'demand': 5}, {'id': 6, 'x': 0, 'y': 16, 'demand': 18}, {'id': 7, 'x': 95, 'y': 13, 'demand': 6}, {'id': 8, 'x': 0, 'y': 47, 'demand': 7}, {'id': 9, 'x': 11, 'y': 31, 'demand': 41}, {'id': 10, 'x': 34, 'y': 40, 'demand': 27}, {'id': 11, 'x': 57, 'y': 38, 'demand': 26}, {'id': 12, 'x': 50, 'y': 53, 'demand': 19}, {'id': 13, 'x': 55, 'y': 84, 'demand': 16}, {'id': 14, 'x': 0, 'y': 42, 'demand': 6}, {'id': 15, 'x': 68, 'y': 75, 'demand': 18}, {'id': 16, 'x': 43, 'y': 100, 'demand': 16}, {'id': 17, 'x': 23, 'y': 78, 'demand': 17}, {'id': 18, 'x': 84, 'y': 29, 'demand': 20}], 'depot': 0, 'capacity': 200, 'num_vehicles': 2, 'total_distance': 498.4946929270909, 'objective': 498.4946929270909}","[[0, 12, 8, 14, 9, 6, 3, 5, 4, 7, 18, 11, 0], [0, 2, 10, 17, 16, 13, 1, 15, 0]]",34,json,0
CVRP,CVRP,"Many teachers asked for deliveries, so the logistics team is setting up a handful of runs from the main store where each route departs from and returns to the store and stops at each classroom exactly once. The practical choice is grouping stops per run so each vehicle stays under its load limit, and the goal is to keep the combined driving distance — just the total of all the trip distances — as low as possible. Concrete details are provided below.

The logistics team will plan routes for 20 locations, with the central store at 0 and a vehicle capacity of 832.
Location 0 at (100, 100) requests 0 supply units.
Location 1 at (53, 86) requests 60 supply units.
Location 2 at (20, 35) requests 86 supply units.
Location 3 at (98, 0) requests 29 supply units.
Location 4 at (56, 9) requests 2 supply units.
Location 5 at (11, 74) requests 15 supply units.
Location 6 at (18, 13) requests 84 supply units.
Location 7 at (22, 99) requests 46 supply units.
Location 8 at (99, 11) requests 3 supply units.
Location 9 at (64, 40) requests 3 supply units.
Location 10 at (8, 32) requests 96 supply units.
Location 11 at (3, 92) requests 45 supply units.
Location 12 at (52, 30) requests 64 supply units.
Location 13 at (12, 56) requests 26 supply units.
Location 14 at (61, 29) requests 20 supply units.
Location 15 at (10, 66) requests 32 supply units.
Location 16 at (33, 79) requests 36 supply units.
Location 17 at (81, 8) requests 43 supply units.
Location 18 at (0, 47) requests 54 supply units.
Location 19 at (36, 29) requests 74 supply units.
These details let the logistics team form feasible routes from 0 for 20 locations under capacity 832.

Oh, and one quick thing — when you send back the set of runs, please use this simple JSON layout so it's easy to read and parse:

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

This just shows the shape I need: ""solution"" is a list of routes, each route is a list that starts and ends with the store and has the classrooms visited in order. Think of it like filling out a short form for each run. It's just a sketch of the format, not the actual routes.

Please use the exact identifiers from the instance input — no renaming and no new labels.

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[100, 100], [53, 86], [20, 35], [98, 0], [56, 9], [11, 74], [18, 13], [22, 99], [99, 11], [64, 40], [8, 32], [3, 92], [52, 30], [12, 56], [61, 29], [10, 66], [33, 79], [81, 8], [0, 47], [36, 29]], 'depot': 0, 'demands': [0, 60, 86, 29, 2, 15, 84, 46, 3, 3, 96, 45, 64, 26, 20, 32, 36, 43, 54, 74], 'capacity': 832, 'num_vehicles': 1, 'total_distance': 449.3338073662434, 'objective': 449.3338073662434}","[[0, 8, 3, 17, 4, 14, 9, 12, 19, 6, 2, 10, 18, 13, 15, 5, 11, 7, 16, 1, 0]]",449.3338073662434,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 100, 'y': 100, 'demand': 0}, {'id': 1, 'x': 53, 'y': 86, 'demand': 60}, {'id': 2, 'x': 20, 'y': 35, 'demand': 86}, {'id': 3, 'x': 98, 'y': 0, 'demand': 29}, {'id': 4, 'x': 56, 'y': 9, 'demand': 2}, {'id': 5, 'x': 11, 'y': 74, 'demand': 15}, {'id': 6, 'x': 18, 'y': 13, 'demand': 84}, {'id': 7, 'x': 22, 'y': 99, 'demand': 46}, {'id': 8, 'x': 99, 'y': 11, 'demand': 3}, {'id': 9, 'x': 64, 'y': 40, 'demand': 3}, {'id': 10, 'x': 8, 'y': 32, 'demand': 96}, {'id': 11, 'x': 3, 'y': 92, 'demand': 45}, {'id': 12, 'x': 52, 'y': 30, 'demand': 64}, {'id': 13, 'x': 12, 'y': 56, 'demand': 26}, {'id': 14, 'x': 61, 'y': 29, 'demand': 20}, {'id': 15, 'x': 10, 'y': 66, 'demand': 32}, {'id': 16, 'x': 33, 'y': 79, 'demand': 36}, {'id': 17, 'x': 81, 'y': 8, 'demand': 43}, {'id': 18, 'x': 0, 'y': 47, 'demand': 54}, {'id': 19, 'x': 36, 'y': 29, 'demand': 74}], 'depot': 0, 'capacity': 832, 'num_vehicles': 1, 'total_distance': 449.3338073662434, 'objective': 449.3338073662434}","[[0, 8, 3, 17, 4, 14, 9, 12, 19, 6, 2, 10, 18, 13, 15, 5, 11, 7, 16, 1, 0]]",35,nl,0
CVRP,CVRP,"We have a dry-cleaning shop that needs a few pickup routes: each route starts at the shop, goes to several customers, and returns to the shop when done. Every address needs a single pickup (no skipping or double-picking), and the bags collected on any route must fit inside the van. The idea is to arrange the stops so the total driving distance — the sum of all the round-trip miles for every route — is as small as possible. Concrete details like customer addresses, bag counts, and the van limit are shown below.

We list 16 locations including the shop (node 1); the van capacity is 100 bags.
We list location 1 at (43, 98) with 0 bags to pick up.
We list location 2 at (94, 79) with 4 bags to pick up.
We list location 3 at (29, 1) with 4 bags to pick up.
We list location 4 at (94, 35) with 10 bags to pick up.
We list location 5 at (93, 73) with 1 bags to pick up.
We list location 6 at (60, 100) with 23 bags to pick up.
We list location 7 at (66, 95) with 22 bags to pick up.
We list location 8 at (74, 34) with 15 bags to pick up.
We list location 9 at (96, 35) with 4 bags to pick up.
We list location 10 at (95, 71) with 6 bags to pick up.
We list location 11 at (96, 36) with 15 bags to pick up.
We list location 12 at (0, 33) with 22 bags to pick up.
We list location 13 at (100, 35) with 20 bags to pick up.
We list location 14 at (99, 31) with 15 bags to pick up.
We list location 15 at (95, 76) with 16 bags to pick up.
We list location 16 at (29, 0) with 3 bags to pick up.
We will use these details so every address is visited once and no route exceeds 100 bags.

Also, when you send the actual routes back, please use this little JSON layout so I can read it easily:

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

Think of ""solution"" as a list of routes. Each inner list is one round-trip that starts and ends at the shop (shop_id) and lists the customers visited (customer_id) in order. This block is just a sketch of the shape I expect, not the actual answer.

Please make sure to use the exact identifiers from the instance input — no renaming, no extra labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[43, 98], [94, 79], [29, 1], [94, 35], [93, 73], [60, 100], [66, 95], [74, 34], [96, 35], [95, 71], [96, 36], [0, 33], [100, 35], [99, 31], [95, 76], [29, 0]], 'depot': 0, 'demands': [0, 4, 4, 10, 1, 23, 22, 15, 4, 6, 15, 22, 20, 15, 16, 3], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 458.7525067190634, 'objective': 458.7525067190634}","[[0, 11, 2, 15, 7, 6, 5, 0], [0, 3, 10, 8, 13, 12, 9, 4, 14, 1, 0]]",458.7525067190634,"{'problem_type': 'CVRP', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 43, 'y': 98, 'demand': 0}, {'id': 2, 'x': 94, 'y': 79, 'demand': 4}, {'id': 3, 'x': 29, 'y': 1, 'demand': 4}, {'id': 4, 'x': 94, 'y': 35, 'demand': 10}, {'id': 5, 'x': 93, 'y': 73, 'demand': 1}, {'id': 6, 'x': 60, 'y': 100, 'demand': 23}, {'id': 7, 'x': 66, 'y': 95, 'demand': 22}, {'id': 8, 'x': 74, 'y': 34, 'demand': 15}, {'id': 9, 'x': 96, 'y': 35, 'demand': 4}, {'id': 10, 'x': 95, 'y': 71, 'demand': 6}, {'id': 11, 'x': 96, 'y': 36, 'demand': 15}, {'id': 12, 'x': 0, 'y': 33, 'demand': 22}, {'id': 13, 'x': 100, 'y': 35, 'demand': 20}, {'id': 14, 'x': 99, 'y': 31, 'demand': 15}, {'id': 15, 'x': 95, 'y': 76, 'demand': 16}, {'id': 16, 'x': 29, 'y': 0, 'demand': 3}], 'depot': 1, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 458.7525067190634, 'objective': 458.7525067190634}","[[1, 12, 3, 16, 8, 7, 6, 1], [1, 4, 11, 9, 14, 13, 10, 5, 15, 2, 1]]",36,nl,1
CVRP,CVRP,"We need to sort out routes from the farm yard so the spreader trucks leave the yard, visit a bunch of fields (each field just once), and return to the yard without overfilling any spreader. The decision is which fields to group on each outing and the order to visit them, with the trade-off being keeping every trip within load limits while driving as few miles as possible. To compare plans, simply total the miles for every trip — the lower that sum, the better the plan. The concrete list of fields, their fertilizer needs, and the spreader capacity will be shown below.

Here are the 17 locations, with the farm yard at node 0, and the spreader capacity 140 that we must respect.
We have location 0 at (56, 58) that requires 0 units of fertilizer.
We have location 1 at (24, 66) that requires 11 units of fertilizer.
We have location 2 at (64, 50) that requires 30 units of fertilizer.
We have location 3 at (24, 52) that requires 19 units of fertilizer.
We have location 4 at (100, 16) that requires 22 units of fertilizer.
We have location 5 at (0, 63) that requires 27 units of fertilizer.
We have location 6 at (17, 97) that requires 14 units of fertilizer.
We have location 7 at (47, 19) that requires 29 units of fertilizer.
We have location 8 at (68, 100) that requires 24 units of fertilizer.
We have location 9 at (14, 16) that requires 11 units of fertilizer.
We have location 10 at (73, 42) that requires 21 units of fertilizer.
We have location 11 at (49, 3) that requires 15 units of fertilizer.
We have location 12 at (22, 42) that requires 11 units of fertilizer.
We have location 13 at (14, 2) that requires 28 units of fertilizer.
We have location 14 at (73, 0) that requires 8 units of fertilizer.
We have location 15 at (100, 6) that requires 11 units of fertilizer.
We have location 16 at (56, 53) that requires 20 units of fertilizer.
Use this list to plan outings that keep every trip within the 140 limit while minimizing total miles.

Also, when you send the plan back, just put the routes into a little JSON object like this:

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

This just shows the shape I want: ""solution"" is a list of trips, and each trip is an ordered list that starts and ends at the yard and lists the fields visited in between. Treat the placeholders as examples — you'll replace them with the real IDs from the instance when you give the actual plan. The JSON above is only a sketch of the shape I expect, not the final answer.

Please be careful 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': [[56, 58], [24, 66], [64, 50], [24, 52], [100, 16], [0, 63], [17, 97], [47, 19], [68, 100], [14, 16], [73, 42], [49, 3], [22, 42], [14, 2], [73, 0], [100, 6], [56, 53]], 'depot': 0, 'demands': [0, 11, 30, 19, 22, 27, 14, 29, 24, 11, 21, 15, 11, 28, 8, 11, 20], 'capacity': 140, 'num_vehicles': 3, 'total_distance': 506.8286475736249, 'objective': 506.8286475736249}","[[0, 16, 10, 2, 0], [0, 3, 1, 5, 6, 8, 0], [0, 12, 9, 13, 7, 11, 14, 15, 4, 0]]",506.8286475736249,"{'problem_type': 'CVRP', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 56, 'y': 58, 'demand': 0}, {'id': 1, 'x': 24, 'y': 66, 'demand': 11}, {'id': 2, 'x': 64, 'y': 50, 'demand': 30}, {'id': 3, 'x': 24, 'y': 52, 'demand': 19}, {'id': 4, 'x': 100, 'y': 16, 'demand': 22}, {'id': 5, 'x': 0, 'y': 63, 'demand': 27}, {'id': 6, 'x': 17, 'y': 97, 'demand': 14}, {'id': 7, 'x': 47, 'y': 19, 'demand': 29}, {'id': 8, 'x': 68, 'y': 100, 'demand': 24}, {'id': 9, 'x': 14, 'y': 16, 'demand': 11}, {'id': 10, 'x': 73, 'y': 42, 'demand': 21}, {'id': 11, 'x': 49, 'y': 3, 'demand': 15}, {'id': 12, 'x': 22, 'y': 42, 'demand': 11}, {'id': 13, 'x': 14, 'y': 2, 'demand': 28}, {'id': 14, 'x': 73, 'y': 0, 'demand': 8}, {'id': 15, 'x': 100, 'y': 6, 'demand': 11}, {'id': 16, 'x': 56, 'y': 53, 'demand': 20}], 'depot': 0, 'capacity': 140, 'num_vehicles': 3, 'total_distance': 506.8286475736249, 'objective': 506.8286475736249}","[[0, 16, 10, 2, 0], [0, 3, 1, 5, 6, 8, 0], [0, 12, 9, 13, 7, 11, 14, 15, 4, 0]]",37,nl,0
CVRP,CVRP,"On a busy morning the mobile grooming van has to be scheduled so each customer gets visited once and the van always goes out from and back to the shop, with each outing carrying only as much equipment as the van can hold. The decision is which customers to put together on each trip and in what sequence. The best-looking schedule is the one with the fewest total miles driven — just total the distance of every route to see that — and the detailed stops and supply needs appear below.

{
  ""total_locations_including_depot"": 22,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""location_x"": 92,
      ""location_y"": 41,
      ""required_equipment_units"": 0
    },
    {
      ""location_id"": ""B"",
      ""location_x"": 99,
      ""location_y"": 37,
      ""required_equipment_units"": 10
    },
    {
      ""location_id"": ""C"",
      ""location_x"": 79,
      ""location_y"": 93,
      ""required_equipment_units"": 15
    },
    {
      ""location_id"": ""D"",
      ""location_x"": 94,
      ""location_y"": 14,
      ""required_equipment_units"": 25
    },
    {
      ""location_id"": ""E"",
      ""location_x"": 85,
      ""location_y"": 27,
      ""required_equipment_units"": 8
    },
    {
      ""location_id"": ""F"",
      ""location_x"": 28,
      ""location_y"": 13,
      ""required_equipment_units"": 23
    },
    {
      ""location_id"": ""G"",
      ""location_x"": 0,
      ""location_y"": 0,
      ""required_equipment_units"": 8
    },
    {
      ""location_id"": ""H"",
      ""location_x"": 21,
      ""location_y"": 11,
      ""required_equipment_units"": 14
    },
    {
      ""location_id"": ""I"",
      ""location_x"": 38,
      ""location_y"": 23,
      ""required_equipment_units"": 6
    },
    {
      ""location_id"": ""J"",
      ""location_x"": 3,
      ""location_y"": 7,
      ""required_equipment_units"": 26
    },
    {
      ""location_id"": ""K"",
      ""location_x"": 6,
      ""location_y"": 7,
      ""required_equipment_units"": 5
    },
    {
      ""location_id"": ""L"",
      ""location_x"": 87,
      ""location_y"": 34,
      ""required_equipment_units"": 18
    },
    {
      ""location_id"": ""M"",
      ""location_x"": 100,
      ""location_y"": 40,
      ""required_equipment_units"": 10
    },
    {
      ""location_id"": ""N"",
      ""location_x"": 89,
      ""location_y"": 24,
      ""required_equipment_units"": 2
    },
    {
      ""location_id"": ""O"",
      ""location_x"": 80,
      ""location_y"": 94,
      ""required_equipment_units"": 12
    },
    {
      ""location_id"": ""P"",
      ""location_x"": 80,
      ""location_y"": 100,
      ""required_equipment_units"": 6
    },
    {
      ""location_id"": ""Q"",
      ""location_x"": 100,
      ""location_y"": 53,
      ""required_equipment_units"": 12
    },
    {
      ""location_id"": ""R"",
      ""location_x"": 24,
      ""location_y"": 7,
      ""required_equipment_units"": 5
    },
    {
      ""location_id"": ""S"",
      ""location_x"": 89,
      ""location_y"": 26,
      ""required_equipment_units"": 23
    },
    {
      ""location_id"": ""T"",
      ""location_x"": 100,
      ""location_y"": 46,
      ""required_equipment_units"": 24
    },
    {
      ""location_id"": ""U"",
      ""location_x"": 21,
      ""location_y"": 11,
      ""required_equipment_units"": 5
    },
    {
      ""location_id"": ""V"",
      ""location_x"": 84,
      ""location_y"": 98,
      ""required_equipment_units"": 5
    }
  ],
  ""groomer_base_id"": ""A"",
  ""van_equipment_capacity"": 100
}

And just so we're on the same page about how I'd like the final reply formatted, please follow this simple JSON shape when you give the routes — nothing fancy, just a list of routes where each route is a list of stops that starts and ends at the shop.

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

Think of ""solution"" as the whole schedule, each inner list as one trip the van takes (first item is the shop, then the customers in visit order, then back to the shop). 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 — 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': [[92, 41], [99, 37], [79, 93], [94, 14], [85, 27], [28, 13], [0, 0], [21, 11], [38, 23], [3, 7], [6, 7], [87, 34], [100, 40], [89, 24], [80, 94], [80, 100], [100, 53], [24, 7], [89, 26], [100, 46], [21, 11], [84, 98]], 'depot': 0, 'demands': [0, 10, 15, 25, 8, 23, 8, 14, 6, 26, 5, 18, 10, 2, 12, 6, 12, 5, 23, 24, 5, 5], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 403.24042964786804, 'objective': 403.24042964786804}","[[0, 8, 5, 7, 20, 10, 9, 6, 17, 0], [0, 3, 13, 18, 4, 11, 0], [0, 1, 12, 19, 16, 21, 15, 14, 2, 0]]",403.24042964786804,"{'problem_type': 'CVRP', 'num_nodes': 22, 'nodes': [{'id': 'A', 'x': 92, 'y': 41, 'demand': 0}, {'id': 'B', 'x': 99, 'y': 37, 'demand': 10}, {'id': 'C', 'x': 79, 'y': 93, 'demand': 15}, {'id': 'D', 'x': 94, 'y': 14, 'demand': 25}, {'id': 'E', 'x': 85, 'y': 27, 'demand': 8}, {'id': 'F', 'x': 28, 'y': 13, 'demand': 23}, {'id': 'G', 'x': 0, 'y': 0, 'demand': 8}, {'id': 'H', 'x': 21, 'y': 11, 'demand': 14}, {'id': 'I', 'x': 38, 'y': 23, 'demand': 6}, {'id': 'J', 'x': 3, 'y': 7, 'demand': 26}, {'id': 'K', 'x': 6, 'y': 7, 'demand': 5}, {'id': 'L', 'x': 87, 'y': 34, 'demand': 18}, {'id': 'M', 'x': 100, 'y': 40, 'demand': 10}, {'id': 'N', 'x': 89, 'y': 24, 'demand': 2}, {'id': 'O', 'x': 80, 'y': 94, 'demand': 12}, {'id': 'P', 'x': 80, 'y': 100, 'demand': 6}, {'id': 'Q', 'x': 100, 'y': 53, 'demand': 12}, {'id': 'R', 'x': 24, 'y': 7, 'demand': 5}, {'id': 'S', 'x': 89, 'y': 26, 'demand': 23}, {'id': 'T', 'x': 100, 'y': 46, 'demand': 24}, {'id': 'U', 'x': 21, 'y': 11, 'demand': 5}, {'id': 'V', 'x': 84, 'y': 98, 'demand': 5}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 3, 'total_distance': 403.24042964786804, 'objective': 403.24042964786804}","[['A', 'I', 'F', 'H', 'U', 'K', 'J', 'G', 'R', 'A'], ['A', 'D', 'N', 'S', 'E', 'L', 'A'], ['A', 'B', 'M', 'T', 'Q', 'V', 'P', 'O', 'C', 'A']]",38,json,names
CVRP,CVRP,"Someone has to schedule the refill deliveries so every department is visited one time, each route starts and ends at the central office, and no single trip carries more than the truck’s capacity. The decision is about which departments to group together on each run to make the total distance as small as possible — the total distance is just the sum of all individual trip distances. Details for the specific case are shown below.

For this instance there are 18 locations in total, the central office is 1, and the truck's capacity is 5.
Location 1 at (57, 0) has demand 0.
Location 2 at (26, 62) has demand 1.
Location 3 at (11, 33) has demand 1.
Location 4 at (39, 28) has demand 1.
Location 5 at (84, 77) has demand 1.
Location 6 at (56, 25) has demand 1.
Location 7 at (42, 39) has demand 1.
Location 8 at (11, 9) has demand 1.
Location 9 at (81, 61) has demand 1.
Location 10 at (29, 23) has demand 1.
Location 11 at (32, 81) has demand 1.
Location 12 at (100, 96) has demand 1.
Location 13 at (81, 100) has demand 1.
Location 14 at (0, 42) has demand 1.
Location 15 at (85, 100) has demand 1.
Location 16 at (24, 59) has demand 1.
Location 17 at (24, 31) has demand 1.
Location 18 at (100, 100) has demand 1.
Assign every department exactly once so each route starts and ends at 1 and no route's total demand exceeds 5.

Oh, and one more thing — when you give the planned trips back, please follow this simple JSON layout so it's easy to read and use:

{
  ""solution"": [[central_office_id, department_id, ... , central_office_id], [central_office_id, department_id, ... , central_office_id], ...]
}

Think of each inner list as one run for the truck: it starts at the central office, lists the departments visited in order, and ends back at the central office. This is just a sketch of the shape I need, not the actual set of stops.

Please make sure to use the exact identifiers from the problem input — don't rename them or invent new ones.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[57, 0], [26, 62], [11, 33], [39, 28], [84, 77], [56, 25], [42, 39], [11, 9], [81, 61], [29, 23], [32, 81], [100, 96], [81, 100], [0, 42], [85, 100], [24, 59], [24, 31], [100, 100]], 'depot': 0, 'demands': [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'capacity': 5, 'num_vehicles': 4, 'total_distance': 673.941966445325, 'objective': 673.941966445325}","[[0, 7, 13, 2, 16, 9, 0], [0, 8, 10, 1, 15, 6, 0], [0, 5, 3, 0], [0, 4, 12, 14, 17, 11, 0]]",673.941966445325,"{'problem_type': 'CVRP', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 57, 'y': 0, 'demand': 0}, {'id': 2, 'x': 26, 'y': 62, 'demand': 1}, {'id': 3, 'x': 11, 'y': 33, 'demand': 1}, {'id': 4, 'x': 39, 'y': 28, 'demand': 1}, {'id': 5, 'x': 84, 'y': 77, 'demand': 1}, {'id': 6, 'x': 56, 'y': 25, 'demand': 1}, {'id': 7, 'x': 42, 'y': 39, 'demand': 1}, {'id': 8, 'x': 11, 'y': 9, 'demand': 1}, {'id': 9, 'x': 81, 'y': 61, 'demand': 1}, {'id': 10, 'x': 29, 'y': 23, 'demand': 1}, {'id': 11, 'x': 32, 'y': 81, 'demand': 1}, {'id': 12, 'x': 100, 'y': 96, 'demand': 1}, {'id': 13, 'x': 81, 'y': 100, 'demand': 1}, {'id': 14, 'x': 0, 'y': 42, 'demand': 1}, {'id': 15, 'x': 85, 'y': 100, 'demand': 1}, {'id': 16, 'x': 24, 'y': 59, 'demand': 1}, {'id': 17, 'x': 24, 'y': 31, 'demand': 1}, {'id': 18, 'x': 100, 'y': 100, 'demand': 1}], 'depot': 1, 'capacity': 5, 'num_vehicles': 4, 'total_distance': 673.941966445325, 'objective': 673.941966445325}","[[1, 8, 14, 3, 17, 10, 1], [1, 9, 11, 2, 16, 7, 1], [1, 6, 4, 1], [1, 5, 13, 15, 18, 12, 1]]",39,nl,1
CVRP,CVRP,"Recently the town asked for a cleaner schedule of tanker runs to top up community water points. The task is to pick which taps go together on each roundtrip out of the municipal yard so that each tap is served exactly once, each trip stays within the tanker’s carrying limit, and the total amount of driving across all trips is as small as it can be. To compare options, simply total the distance driven on every trip — the one with the lowest total is preferred. Concrete details about stops, demand amounts, and tanker capacity follow below.

# total_locations_including_yard=18
# municipal_yard_id=A
# tanker_capacity=100
location_id,map_x_coordinate,map_y_coordinate,tap_refill_volume
A,32,99,0
B,86,78,15
C,53,99,16
D,48,0,19
E,59,97,22
F,68,38,15
G,89,40,22
H,92,46,2
I,94,73,6
J,95,40,15
K,48,100,13
L,95,82,13
M,100,39,20
N,91,42,22
O,95,39,11
P,57,94,21
Q,15,6,3
R,0,36,15

When you send back the proposed rounds, just stick to a simple JSON shape like this:

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

This little sketch means: ""solution"" is a list of trips, each trip is an ordered list of stop identifiers that starts and ends at the municipal yard. The placeholders here (yard_id, tap_id) just show the shape — replace them with the actual stop IDs from the instance. This is only an example of the format, not the actual plan.

Please make sure to use the exact identifiers given in the instance input — do not rename them or invent new ones.
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[32, 99], [86, 78], [53, 99], [48, 0], [59, 97], [68, 38], [89, 40], [92, 46], [94, 73], [95, 40], [48, 100], [95, 82], [100, 39], [91, 42], [95, 39], [57, 94], [15, 6], [0, 36]], 'depot': 0, 'demands': [0, 15, 16, 19, 22, 15, 22, 2, 6, 15, 13, 13, 20, 22, 11, 21, 3, 15], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 543.708308698676, 'objective': 543.708308698676}","[[0, 17, 16, 3, 5, 8, 11, 1, 0], [0, 10, 2, 4, 15, 0], [0, 7, 12, 14, 9, 13, 6, 0]]",543.708308698676,"{'problem_type': 'CVRP', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 32, 'y': 99, 'demand': 0}, {'id': 'B', 'x': 86, 'y': 78, 'demand': 15}, {'id': 'C', 'x': 53, 'y': 99, 'demand': 16}, {'id': 'D', 'x': 48, 'y': 0, 'demand': 19}, {'id': 'E', 'x': 59, 'y': 97, 'demand': 22}, {'id': 'F', 'x': 68, 'y': 38, 'demand': 15}, {'id': 'G', 'x': 89, 'y': 40, 'demand': 22}, {'id': 'H', 'x': 92, 'y': 46, 'demand': 2}, {'id': 'I', 'x': 94, 'y': 73, 'demand': 6}, {'id': 'J', 'x': 95, 'y': 40, 'demand': 15}, {'id': 'K', 'x': 48, 'y': 100, 'demand': 13}, {'id': 'L', 'x': 95, 'y': 82, 'demand': 13}, {'id': 'M', 'x': 100, 'y': 39, 'demand': 20}, {'id': 'N', 'x': 91, 'y': 42, 'demand': 22}, {'id': 'O', 'x': 95, 'y': 39, 'demand': 11}, {'id': 'P', 'x': 57, 'y': 94, 'demand': 21}, {'id': 'Q', 'x': 15, 'y': 6, 'demand': 3}, {'id': 'R', 'x': 0, 'y': 36, 'demand': 15}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 3, 'total_distance': 543.708308698676, 'objective': 543.708308698676}","[['A', 'R', 'Q', 'D', 'F', 'I', 'L', 'B', 'A'], ['A', 'K', 'C', 'E', 'P', 'A'], ['A', 'H', 'M', 'O', 'J', 'N', 'G', 'A']]",40,csv,names
CVRP,CVRP,"Recently the dispatchers had to put together a set of patrol runs: vans leaving and returning to the same garage, each one equipped for certain calls. They need to decide who goes where so every reported vehicle gets serviced exactly once, no van’s equipment load exceeds what it can hold, and the whole day has the fewest miles possible — compute that by summing every route’s distance and choosing the smallest total. Concrete details will be shown below.

The instance had 25 total locations (including the garage), with garage node 0 and van equipment capacity 120.

| location_node_id | x_map_coordinate | y_map_coordinate | equipment_load_required |
|---|---|---|---|
| 0 | 58 | 50 | 0 |
| 1 | 25 | 57 | 11 |
| 2 | 66 | 43 | 30 |
| 3 | 83 | 22 | 21 |
| 4 | 46 | 42 | 19 |
| 5 | 83 | 57 | 16 |
| 6 | 34 | 76 | 29 |
| 7 | 58 | 86 | 26 |
| 8 | 83 | 85 | 37 |
| 9 | 95 | 43 | 12 |
| 10 | 8 | 33 | 6 |
| 11 | 2 | 54 | 27 |
| 12 | 42 | 100 | 25 |
| 13 | 27 | 68 | 28 |
| 14 | 83 | 64 | 10 |
| 15 | 81 | 8 | 12 |
| 16 | 92 | 15 | 14 |
| 17 | 41 | 78 | 16 |
| 18 | 41 | 64 | 33 |
| 19 | 10 | 18 | 15 |
| 20 | 75 | 15 | 19 |
| 21 | 83 | 74 | 22 |
| 22 | 0 | 29 | 26 |
| 23 | 100 | 32 | 14 |
| 24 | 75 | 0 | 24 |

These entries list every location so the dispatchers can assign vans within capacity and minimize total miles.

Also, when you send the routes back, just use this little JSON layout so everything is easy to read and machine-friendly:

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

Think of ""solution"" as the form field: it holds a list of runs. Each inner list is one van’s trip — it starts at the garage, lists the service calls in visit order, and finishes back at the garage. The placeholders above are just showing the shape, not the actual IDs you should use.

This JSON is only a sketch of the expected shape, not the final answer. Make sure to use the exact identifiers from the instance input — do not rename them or make up new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[58, 50], [25, 57], [66, 43], [83, 22], [46, 42], [83, 57], [34, 76], [58, 86], [83, 85], [95, 43], [8, 33], [2, 54], [42, 100], [27, 68], [83, 64], [81, 8], [92, 15], [41, 78], [41, 64], [10, 18], [75, 15], [83, 74], [0, 29], [100, 32], [75, 0]], 'depot': 0, 'demands': [0, 11, 30, 21, 19, 16, 29, 26, 37, 12, 6, 27, 25, 28, 10, 12, 14, 16, 33, 15, 19, 22, 26, 14, 24], 'capacity': 120, 'num_vehicles': 5, 'total_distance': 594.3284072641183, 'objective': 594.3284072641183}","[[0, 4, 13, 6, 12, 17, 0], [0, 3, 20, 24, 15, 16, 23, 9, 0], [0, 19, 22, 10, 11, 1, 18, 0], [0, 7, 8, 21, 14, 5, 0], [0, 2, 0]]",594.3284072641183,"{'problem_type': 'CVRP', 'num_nodes': 25, 'nodes': [{'id': 0, 'x': 58, 'y': 50, 'demand': 0}, {'id': 1, 'x': 25, 'y': 57, 'demand': 11}, {'id': 2, 'x': 66, 'y': 43, 'demand': 30}, {'id': 3, 'x': 83, 'y': 22, 'demand': 21}, {'id': 4, 'x': 46, 'y': 42, 'demand': 19}, {'id': 5, 'x': 83, 'y': 57, 'demand': 16}, {'id': 6, 'x': 34, 'y': 76, 'demand': 29}, {'id': 7, 'x': 58, 'y': 86, 'demand': 26}, {'id': 8, 'x': 83, 'y': 85, 'demand': 37}, {'id': 9, 'x': 95, 'y': 43, 'demand': 12}, {'id': 10, 'x': 8, 'y': 33, 'demand': 6}, {'id': 11, 'x': 2, 'y': 54, 'demand': 27}, {'id': 12, 'x': 42, 'y': 100, 'demand': 25}, {'id': 13, 'x': 27, 'y': 68, 'demand': 28}, {'id': 14, 'x': 83, 'y': 64, 'demand': 10}, {'id': 15, 'x': 81, 'y': 8, 'demand': 12}, {'id': 16, 'x': 92, 'y': 15, 'demand': 14}, {'id': 17, 'x': 41, 'y': 78, 'demand': 16}, {'id': 18, 'x': 41, 'y': 64, 'demand': 33}, {'id': 19, 'x': 10, 'y': 18, 'demand': 15}, {'id': 20, 'x': 75, 'y': 15, 'demand': 19}, {'id': 21, 'x': 83, 'y': 74, 'demand': 22}, {'id': 22, 'x': 0, 'y': 29, 'demand': 26}, {'id': 23, 'x': 100, 'y': 32, 'demand': 14}, {'id': 24, 'x': 75, 'y': 0, 'demand': 24}], 'depot': 0, 'capacity': 120, 'num_vehicles': 5, 'total_distance': 594.3284072641183, 'objective': 594.3284072641183}","[[0, 4, 13, 6, 12, 17, 0], [0, 3, 20, 24, 15, 16, 23, 9, 0], [0, 19, 22, 10, 11, 1, 18, 0], [0, 7, 8, 21, 14, 5, 0], [0, 2, 0]]",41,markdown_table,0
CVRP,CVRP,"Someone needs to assign the daily delivery runs from the DC so no house is missed or receives two parcels. The decision is about which addresses each van will cover and the order they’re visited, with each run starting and ending at the center and no van overloaded beyond what it can hold. The quality of a plan is judged by total travel distance: sum the distances of all runs and aim for the smallest total. The concrete details follow below.

There are 25 locations including the distribution center A; each van can carry up to 100 parcels.
Location A at (0, 12) requires 0 parcels.
Location B at (57, 79) requires 14 parcels.
Location C at (32, 50) requires 5 parcels.
Location D at (80, 5) requires 9 parcels.
Location E at (42, 21) requires 12 parcels.
Location F at (40, 22) requires 2 parcels.
Location G at (37, 35) requires 15 parcels.
Location H at (54, 100) requires 12 parcels.
Location I at (98, 0) requires 12 parcels.
Location J at (100, 71) requires 26 parcels.
Location K at (38, 26) requires 10 parcels.
Location L at (39, 22) requires 24 parcels.
Location M at (93, 76) requires 12 parcels.
Location N at (32, 31) requires 19 parcels.
Location O at (42, 22) requires 7 parcels.
Location P at (14, 13) requires 15 parcels.
Location Q at (37, 59) requires 14 parcels.
Location R at (44, 67) requires 18 parcels.
Location S at (21, 12) requires 2 parcels.
Location T at (45, 26) requires 3 parcels.
Location U at (13, 16) requires 5 parcels.
Location V at (44, 62) requires 20 parcels.
Location W at (39, 52) requires 16 parcels.
Location X at (86, 13) requires 25 parcels.
Location Y at (18, 13) requires 3 parcels.
Routes must start and end at A, visit all 25 locations without exceeding 100 parcels per van, and minimize the total travel distance.

Oh, and when you send the actual plan back, please put it in a little JSON sketch like this so it's easy to read and use:

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

This just shows the shape I want: ""solution"" is a list of runs, each inner list is one van's route starting and ending at the depot_id, with the customer location_ids in visit order in between. It's an easy form — think of each inner list as the sequence a driver will follow. Note this is only an example of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input — don't rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 12], [57, 79], [32, 50], [80, 5], [42, 21], [40, 22], [37, 35], [54, 100], [98, 0], [100, 71], [38, 26], [39, 22], [93, 76], [32, 31], [42, 22], [14, 13], [37, 59], [44, 67], [21, 12], [45, 26], [13, 16], [44, 62], [39, 52], [86, 13], [18, 13]], 'depot': 0, 'demands': [0, 14, 5, 9, 12, 2, 15, 12, 12, 26, 10, 24, 12, 19, 7, 15, 14, 18, 2, 3, 5, 20, 16, 25, 3], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 625.580573324397, 'objective': 625.580573324397}","[[0, 16, 12, 9, 23, 8, 3, 18, 0], [0, 15, 24, 11, 5, 4, 14, 19, 10, 13, 20, 0], [0, 6, 22, 21, 1, 7, 17, 2, 0]]",625.580573324397,"{'problem_type': 'CVRP', 'num_nodes': 25, 'nodes': [{'id': 'A', 'x': 0, 'y': 12, 'demand': 0}, {'id': 'B', 'x': 57, 'y': 79, 'demand': 14}, {'id': 'C', 'x': 32, 'y': 50, 'demand': 5}, {'id': 'D', 'x': 80, 'y': 5, 'demand': 9}, {'id': 'E', 'x': 42, 'y': 21, 'demand': 12}, {'id': 'F', 'x': 40, 'y': 22, 'demand': 2}, {'id': 'G', 'x': 37, 'y': 35, 'demand': 15}, {'id': 'H', 'x': 54, 'y': 100, 'demand': 12}, {'id': 'I', 'x': 98, 'y': 0, 'demand': 12}, {'id': 'J', 'x': 100, 'y': 71, 'demand': 26}, {'id': 'K', 'x': 38, 'y': 26, 'demand': 10}, {'id': 'L', 'x': 39, 'y': 22, 'demand': 24}, {'id': 'M', 'x': 93, 'y': 76, 'demand': 12}, {'id': 'N', 'x': 32, 'y': 31, 'demand': 19}, {'id': 'O', 'x': 42, 'y': 22, 'demand': 7}, {'id': 'P', 'x': 14, 'y': 13, 'demand': 15}, {'id': 'Q', 'x': 37, 'y': 59, 'demand': 14}, {'id': 'R', 'x': 44, 'y': 67, 'demand': 18}, {'id': 'S', 'x': 21, 'y': 12, 'demand': 2}, {'id': 'T', 'x': 45, 'y': 26, 'demand': 3}, {'id': 'U', 'x': 13, 'y': 16, 'demand': 5}, {'id': 'V', 'x': 44, 'y': 62, 'demand': 20}, {'id': 'W', 'x': 39, 'y': 52, 'demand': 16}, {'id': 'X', 'x': 86, 'y': 13, 'demand': 25}, {'id': 'Y', 'x': 18, 'y': 13, 'demand': 3}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 3, 'total_distance': 625.580573324397, 'objective': 625.580573324397}","[['A', 'Q', 'M', 'J', 'X', 'I', 'D', 'S', 'A'], ['A', 'P', 'Y', 'L', 'F', 'E', 'O', 'T', 'K', 'N', 'U', 'A'], ['A', 'G', 'W', 'V', 'B', 'H', 'R', 'C', 'A']]",42,nl,names
CVRP,CVRP,"Someone in the transportation office needs to sketch the bus schedules: choose which stops go together on each trip and the order to visit them so no stop is missed or visited twice, each trip starts and finishes at the depot, and no bus is overloaded beyond its seats. The win here is fewer miles on the road — add up the route distances for all buses and try to make that sum as small as possible. Exact stop locations and numbers are shown below.

Total locations 19, depot A, bus seating capacity 974.

| location_id | x_coord | y_coord | student_demand |
|---|---|---|---|
| A | 14 | 97 | 0 |
| B | 68 | 21 | 74 |
| C | 95 | 9 | 80 |
| D | 47 | 100 | 74 |
| E | 100 | 6 | 89 |
| F | 12 | 0 | 53 |
| G | 0 | 83 | 65 |
| H | 77 | 69 | 81 |
| I | 85 | 46 | 97 |
| J | 78 | 35 | 93 |
| K | 11 | 74 | 60 |
| L | 100 | 34 | 94 |
| M | 64 | 6 | 74 |
| N | 52 | 8 | 68 |
| O | 86 | 43 | 72 |
| P | 79 | 99 | 60 |
| Q | 50 | 63 | 51 |
| R | 71 | 31 | 92 |
| S | 67 | 95 | 56 |

Use these 19 locations and depot A with bus seating capacity 974 to sketch routes that visit each stop exactly once, start and end at the depot, and respect capacity while minimizing total miles.

Also, when you send the planned trips back, just use this simple JSON shape 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 bus trips. Each inner list is one trip: the first item is the depot, then the stops in the order the bus will visit them, and then the depot again at the end. It's just a sketch of the shape I need, not the actual answer.

Please make sure to use the exact stop and depot identifiers from the instance input — don't rename them or invent new ones. 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': [[14, 97], [68, 21], [95, 9], [47, 100], [100, 6], [12, 0], [0, 83], [77, 69], [85, 46], [78, 35], [11, 74], [100, 34], [64, 6], [52, 8], [86, 43], [79, 99], [50, 63], [71, 31], [67, 95]], 'depot': 0, 'demands': [0, 74, 80, 74, 89, 53, 65, 81, 97, 93, 60, 94, 74, 68, 72, 60, 51, 92, 56], 'capacity': 974, 'num_vehicles': 2, 'total_distance': 549.1613066921923, 'objective': 549.1613066921923}","[[0, 7, 8, 14, 11, 4, 2, 9, 17, 1, 12, 13, 5, 0], [0, 3, 18, 15, 16, 10, 6, 0]]",549.1613066921923,"{'problem_type': 'CVRP', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 14, 'y': 97, 'demand': 0}, {'id': 'B', 'x': 68, 'y': 21, 'demand': 74}, {'id': 'C', 'x': 95, 'y': 9, 'demand': 80}, {'id': 'D', 'x': 47, 'y': 100, 'demand': 74}, {'id': 'E', 'x': 100, 'y': 6, 'demand': 89}, {'id': 'F', 'x': 12, 'y': 0, 'demand': 53}, {'id': 'G', 'x': 0, 'y': 83, 'demand': 65}, {'id': 'H', 'x': 77, 'y': 69, 'demand': 81}, {'id': 'I', 'x': 85, 'y': 46, 'demand': 97}, {'id': 'J', 'x': 78, 'y': 35, 'demand': 93}, {'id': 'K', 'x': 11, 'y': 74, 'demand': 60}, {'id': 'L', 'x': 100, 'y': 34, 'demand': 94}, {'id': 'M', 'x': 64, 'y': 6, 'demand': 74}, {'id': 'N', 'x': 52, 'y': 8, 'demand': 68}, {'id': 'O', 'x': 86, 'y': 43, 'demand': 72}, {'id': 'P', 'x': 79, 'y': 99, 'demand': 60}, {'id': 'Q', 'x': 50, 'y': 63, 'demand': 51}, {'id': 'R', 'x': 71, 'y': 31, 'demand': 92}, {'id': 'S', 'x': 67, 'y': 95, 'demand': 56}], 'depot': 'A', 'capacity': 974, 'num_vehicles': 2, 'total_distance': 549.1613066921923, 'objective': 549.1613066921923}","[['A', 'H', 'I', 'O', 'L', 'E', 'C', 'J', 'R', 'B', 'M', 'N', 'F', 'A'], ['A', 'D', 'S', 'P', 'Q', 'K', 'G', 'A']]",43,markdown_table,names
CVRP,CVRP,"There’s a simple challenge on the table: route our fleet from the central hub to drop off each clinic’s vaccine allocation once, make sure each truck returns to the hub and never carries more than its safe load. One delivery plan beats another if it results in less total driving — compute that by adding the distance of every truck’s loop and comparing totals. The specific clinic addresses, demand numbers and truck capacities are shown below.

We have 21 locations including the hub 1, and each truck's safe load is 110.

| location_id | x_coordinate_km | y_coordinate_km | vaccine_units_required |
|---|---|---|---|
| 1 | 0 | 0 | 0 |
| 2 | 92 | 100 | 7 |
| 3 | 94 | 13 | 10 |
| 4 | 46 | 52 | 7 |
| 5 | 17 | 16 | 10 |
| 6 | 12 | 17 | 10 |
| 7 | 47 | 46 | 10 |
| 8 | 40 | 33 | 5 |
| 9 | 99 | 3 | 10 |
| 10 | 59 | 29 | 10 |
| 11 | 38 | 38 | 7 |
| 12 | 48 | 26 | 6 |
| 13 | 68 | 99 | 10 |
| 14 | 16 | 21 | 8 |
| 15 | 100 | 7 | 5 |
| 16 | 41 | 37 | 7 |
| 17 | 78 | 81 | 10 |
| 18 | 37 | 20 | 10 |
| 19 | 62 | 52 | 7 |
| 20 | 10 | 7 | 5 |
| 21 | 93 | 83 | 9 |

Assign routes so every truck starts and ends at 1 and never exceeds 110 in delivered units.

Oh, and when you send the delivery plan back, it'd be easiest if you stick to a simple JSON shape like this:

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

This just means ""solution"" holds a list of routes. Each route is a list that starts and ends at the hub_id and has the clinic_id values in the order they should be visited. Think of it as a quick form — it shows the layout we expect, not the actual route choices.

Important: 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': [[0, 0], [92, 100], [94, 13], [46, 52], [17, 16], [12, 17], [47, 46], [40, 33], [99, 3], [59, 29], [38, 38], [48, 26], [68, 99], [16, 21], [100, 7], [41, 37], [78, 81], [37, 20], [62, 52], [10, 7], [93, 83]], 'depot': 0, 'demands': [0, 7, 10, 7, 10, 10, 10, 5, 10, 10, 7, 6, 10, 8, 5, 7, 10, 10, 7, 5, 9], 'capacity': 110, 'num_vehicles': 2, 'total_distance': 495.98830979235305, 'objective': 495.98830979235305}","[[0, 5, 13, 10, 7, 17, 4, 19, 0], [0, 15, 6, 3, 18, 16, 12, 1, 20, 14, 8, 2, 9, 11, 0]]",495.98830979235305,"{'problem_type': 'CVRP', 'num_nodes': 21, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'demand': 0}, {'id': 2, 'x': 92, 'y': 100, 'demand': 7}, {'id': 3, 'x': 94, 'y': 13, 'demand': 10}, {'id': 4, 'x': 46, 'y': 52, 'demand': 7}, {'id': 5, 'x': 17, 'y': 16, 'demand': 10}, {'id': 6, 'x': 12, 'y': 17, 'demand': 10}, {'id': 7, 'x': 47, 'y': 46, 'demand': 10}, {'id': 8, 'x': 40, 'y': 33, 'demand': 5}, {'id': 9, 'x': 99, 'y': 3, 'demand': 10}, {'id': 10, 'x': 59, 'y': 29, 'demand': 10}, {'id': 11, 'x': 38, 'y': 38, 'demand': 7}, {'id': 12, 'x': 48, 'y': 26, 'demand': 6}, {'id': 13, 'x': 68, 'y': 99, 'demand': 10}, {'id': 14, 'x': 16, 'y': 21, 'demand': 8}, {'id': 15, 'x': 100, 'y': 7, 'demand': 5}, {'id': 16, 'x': 41, 'y': 37, 'demand': 7}, {'id': 17, 'x': 78, 'y': 81, 'demand': 10}, {'id': 18, 'x': 37, 'y': 20, 'demand': 10}, {'id': 19, 'x': 62, 'y': 52, 'demand': 7}, {'id': 20, 'x': 10, 'y': 7, 'demand': 5}, {'id': 21, 'x': 93, 'y': 83, 'demand': 9}], 'depot': 1, 'capacity': 110, 'num_vehicles': 2, 'total_distance': 495.98830979235305, 'objective': 495.98830979235305}","[[1, 6, 14, 11, 8, 18, 5, 20, 1], [1, 16, 7, 4, 19, 17, 13, 2, 21, 15, 9, 3, 10, 12, 1]]",44,markdown_table,1
CVRP,CVRP,"Someone needs to sequence the pickup runs for several household moves starting from the yard: assign each pickup to a run so it’s visited one time only, make sure every run begins and ends at the yard, and don’t put more cargo on a truck than it can hold. The better plan is the one with the lowest combined driving distance — just total the distance of all runs and try to shrink that number. Details about the pickups and loads are given below.

{
  ""total_locations_including_yard"": 25,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""location_x"": 30,
      ""location_y"": 95,
      ""pickup_demand"": 0
    },
    {
      ""location_id"": 2,
      ""location_x"": 36,
      ""location_y"": 20,
      ""pickup_demand"": 16
    },
    {
      ""location_id"": 3,
      ""location_x"": 7,
      ""location_y"": 82,
      ""pickup_demand"": 7
    },
    {
      ""location_id"": 4,
      ""location_x"": 50,
      ""location_y"": 0,
      ""pickup_demand"": 6
    },
    {
      ""location_id"": 5,
      ""location_x"": 7,
      ""location_y"": 64,
      ""pickup_demand"": 19
    },
    {
      ""location_id"": 6,
      ""location_x"": 16,
      ""location_y"": 98,
      ""pickup_demand"": 11
    },
    {
      ""location_id"": 7,
      ""location_x"": 36,
      ""location_y"": 95,
      ""pickup_demand"": 2
    },
    {
      ""location_id"": 8,
      ""location_x"": 11,
      ""location_y"": 98,
      ""pickup_demand"": 1
    },
    {
      ""location_id"": 9,
      ""location_x"": 48,
      ""location_y"": 59,
      ""pickup_demand"": 23
    },
    {
      ""location_id"": 10,
      ""location_x"": 39,
      ""location_y"": 39,
      ""pickup_demand"": 24
    },
    {
      ""location_id"": 11,
      ""location_x"": 20,
      ""location_y"": 34,
      ""pickup_demand"": 17
    },
    {
      ""location_id"": 12,
      ""location_x"": 93,
      ""location_y"": 89,
      ""pickup_demand"": 17
    },
    {
      ""location_id"": 13,
      ""location_x"": 0,
      ""location_y"": 5,
      ""pickup_demand"": 9
    },
    {
      ""location_id"": 14,
      ""location_x"": 16,
      ""location_y"": 34,
      ""pickup_demand"": 11
    },
    {
      ""location_id"": 15,
      ""location_x"": 34,
      ""location_y"": 59,
      ""pickup_demand"": 9
    },
    {
      ""location_id"": 16,
      ""location_x"": 66,
      ""location_y"": 68,
      ""pickup_demand"": 5
    },
    {
      ""location_id"": 17,
      ""location_x"": 70,
      ""location_y"": 100,
      ""pickup_demand"": 14
    },
    {
      ""location_id"": 18,
      ""location_x"": 73,
      ""location_y"": 55,
      ""pickup_demand"": 19
    },
    {
      ""location_id"": 19,
      ""location_x"": 16,
      ""location_y"": 68,
      ""pickup_demand"": 11
    },
    {
      ""location_id"": 20,
      ""location_x"": 64,
      ""location_y"": 0,
      ""pickup_demand"": 20
    },
    {
      ""location_id"": 21,
      ""location_x"": 95,
      ""location_y"": 32,
      ""pickup_demand"": 21
    },
    {
      ""location_id"": 22,
      ""location_x"": 70,
      ""location_y"": 55,
      ""pickup_demand"": 4
    },
    {
      ""location_id"": 23,
      ""location_x"": 2,
      ""location_y"": 25,
      ""pickup_demand"": 21
    },
    {
      ""location_id"": 24,
      ""location_x"": 68,
      ""location_y"": 68,
      ""pickup_demand"": 9
    },
    {
      ""location_id"": 25,
      ""location_x"": 100,
      ""location_y"": 82,
      ""pickup_demand"": 22
    }
  ],
  ""yard_node_id"": 1,
  ""truck_payload_capacity"": 100
}

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

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

Think of it like a short form: ""solution"" is the list of runs, each inner list is one run that starts at the yard, visits the pickups in order, and returns to the yard. The placeholders (yard_id, pickup_id) just stand in for the actual labels you'll use — this block is just a sketch of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input when you fill this in — 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': [[30, 95], [36, 20], [7, 82], [50, 0], [7, 64], [16, 98], [36, 95], [11, 98], [48, 59], [39, 39], [20, 34], [93, 89], [0, 5], [16, 34], [34, 59], [66, 68], [70, 100], [73, 55], [16, 68], [64, 0], [95, 32], [70, 55], [2, 25], [68, 68], [100, 82]], 'depot': 0, 'demands': [0, 16, 7, 6, 19, 11, 2, 1, 23, 24, 17, 17, 9, 11, 9, 5, 14, 19, 11, 20, 21, 4, 21, 9, 22], 'capacity': 100, 'num_vehicles': 4, 'total_distance': 711.4288757029508, 'objective': 711.4288757029508}","[[0, 5, 7, 2, 0], [0, 8, 15, 17, 24, 11, 16, 0], [0, 9, 1, 3, 19, 20, 21, 23, 0], [0, 18, 4, 22, 12, 13, 10, 14, 6, 0]]",711.4288757029508,"{'problem_type': 'CVRP', 'num_nodes': 25, 'nodes': [{'id': 1, 'x': 30, 'y': 95, 'demand': 0}, {'id': 2, 'x': 36, 'y': 20, 'demand': 16}, {'id': 3, 'x': 7, 'y': 82, 'demand': 7}, {'id': 4, 'x': 50, 'y': 0, 'demand': 6}, {'id': 5, 'x': 7, 'y': 64, 'demand': 19}, {'id': 6, 'x': 16, 'y': 98, 'demand': 11}, {'id': 7, 'x': 36, 'y': 95, 'demand': 2}, {'id': 8, 'x': 11, 'y': 98, 'demand': 1}, {'id': 9, 'x': 48, 'y': 59, 'demand': 23}, {'id': 10, 'x': 39, 'y': 39, 'demand': 24}, {'id': 11, 'x': 20, 'y': 34, 'demand': 17}, {'id': 12, 'x': 93, 'y': 89, 'demand': 17}, {'id': 13, 'x': 0, 'y': 5, 'demand': 9}, {'id': 14, 'x': 16, 'y': 34, 'demand': 11}, {'id': 15, 'x': 34, 'y': 59, 'demand': 9}, {'id': 16, 'x': 66, 'y': 68, 'demand': 5}, {'id': 17, 'x': 70, 'y': 100, 'demand': 14}, {'id': 18, 'x': 73, 'y': 55, 'demand': 19}, {'id': 19, 'x': 16, 'y': 68, 'demand': 11}, {'id': 20, 'x': 64, 'y': 0, 'demand': 20}, {'id': 21, 'x': 95, 'y': 32, 'demand': 21}, {'id': 22, 'x': 70, 'y': 55, 'demand': 4}, {'id': 23, 'x': 2, 'y': 25, 'demand': 21}, {'id': 24, 'x': 68, 'y': 68, 'demand': 9}, {'id': 25, 'x': 100, 'y': 82, 'demand': 22}], 'depot': 1, 'capacity': 100, 'num_vehicles': 4, 'total_distance': 711.4288757029508, 'objective': 711.4288757029508}","[[1, 6, 8, 3, 1], [1, 9, 16, 18, 25, 12, 17, 1], [1, 10, 2, 4, 20, 21, 22, 24, 1], [1, 19, 5, 23, 13, 14, 11, 15, 7, 1]]",45,json,1
CVRP,CVRP,"I picture a day where a fleet of trucks fills up jerrycans at the reservoir and makes rounds to deliver water to every farm — each farm gets served one time only, and every truck drives out from the reservoir and comes back empty or with whatever’s left. The trick is to decide which farms each truck should visit so the total distance driven by all trucks is as small as possible; that total is just the sum of the miles each truck covers. Nothing can be skipped or visited twice, and no truck carries more water than it can hold. The specific farm stops, demands, and truck capacities are listed below.

# total_locations_including_reservoir=16
# reservoir_node_id=1
# truck_capacity_jerrycans=564
location_id,location_x,location_y,water_demand_jerrycans
1,0,57,0
2,100,100,59
3,86,75,65
4,12,35,96
5,38,7,58
6,65,0,80
7,76,9,89
8,73,33,90
9,26,71,95
10,20,14,89
11,75,40,99
12,24,71,78
13,31,75,100
14,45,60,57
15,67,95,83
16,52,24,100

If you want the answer in a neat, machine-friendly form, just return the routes in this simple JSON shape — nothing fancy, just a list of runs for the trucks.

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

Think of ""solution"" as a list of truck trips. Each inner list is one trip: it starts at the reservoir (reservoir_id), then lists the farms visited (farm_id) in order, and finishes back at the reservoir. This is just the expected shape — a sketch of how I want the answer formatted, not the actual routes.

Please make sure to use the exact identifiers given in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 57], [100, 100], [86, 75], [12, 35], [38, 7], [65, 0], [76, 9], [73, 33], [26, 71], [20, 14], [75, 40], [24, 71], [31, 75], [45, 60], [67, 95], [52, 24]], 'depot': 0, 'demands': [0, 59, 65, 96, 58, 80, 89, 90, 95, 89, 99, 78, 100, 57, 83, 100], 'capacity': 564, 'num_vehicles': 3, 'total_distance': 525.1788024438625, 'objective': 525.1788024438625}","[[0, 13, 7, 10, 2, 1, 14, 12, 0], [0, 15, 6, 5, 4, 9, 3, 0], [0, 11, 8, 0]]",525.1788024438625,"{'problem_type': 'CVRP', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 0, 'y': 57, 'demand': 0}, {'id': 2, 'x': 100, 'y': 100, 'demand': 59}, {'id': 3, 'x': 86, 'y': 75, 'demand': 65}, {'id': 4, 'x': 12, 'y': 35, 'demand': 96}, {'id': 5, 'x': 38, 'y': 7, 'demand': 58}, {'id': 6, 'x': 65, 'y': 0, 'demand': 80}, {'id': 7, 'x': 76, 'y': 9, 'demand': 89}, {'id': 8, 'x': 73, 'y': 33, 'demand': 90}, {'id': 9, 'x': 26, 'y': 71, 'demand': 95}, {'id': 10, 'x': 20, 'y': 14, 'demand': 89}, {'id': 11, 'x': 75, 'y': 40, 'demand': 99}, {'id': 12, 'x': 24, 'y': 71, 'demand': 78}, {'id': 13, 'x': 31, 'y': 75, 'demand': 100}, {'id': 14, 'x': 45, 'y': 60, 'demand': 57}, {'id': 15, 'x': 67, 'y': 95, 'demand': 83}, {'id': 16, 'x': 52, 'y': 24, 'demand': 100}], 'depot': 1, 'capacity': 564, 'num_vehicles': 3, 'total_distance': 525.1788024438625, 'objective': 525.1788024438625}","[[1, 14, 8, 11, 3, 2, 15, 13, 1], [1, 16, 7, 6, 5, 10, 4, 1], [1, 12, 9, 1]]",46,csv,1
CVRP,CVRP,"There’s a neighborhood vendor who stages the freezer van in a garage and needs to lay out routes so every customer gets served once and only once. Each circuit has to leave from and return to the garage, and the van can only hold a limited amount on any single outing, so no run can go over that capacity. The better routing setup is the one that results in less overall driving; you can check that by totaling the distance of every circuit and picking the smallest sum. The concrete stop list, demands, and capacity details are shown below.

The instance has 20 locations, the garage is 0, and the van can carry up to 100 on any outing.
Location 0 at (56, 43) requires 0 ice cream units.
Location 1 at (49, 21) requires 26 ice cream units.
Location 2 at (73, 59) requires 15 ice cream units.
Location 3 at (81, 83) requires 37 ice cream units.
Location 4 at (47, 60) requires 16 ice cream units.
Location 5 at (93, 35) requires 12 ice cream units.
Location 6 at (93, 70) requires 31 ice cream units.
Location 7 at (93, 17) requires 8 ice cream units.
Location 8 at (3, 68) requires 13 ice cream units.
Location 9 at (93, 56) requires 15 ice cream units.
Location 10 at (100, 2) requires 22 ice cream units.
Location 11 at (63, 0) requires 28 ice cream units.
Location 12 at (32, 0) requires 12 ice cream units.
Location 13 at (0, 48) requires 27 ice cream units.
Location 14 at (76, 21) requires 13 ice cream units.
Location 15 at (41, 100) requires 25 ice cream units.
Location 16 at (81, 59) requires 10 ice cream units.
Location 17 at (39, 75) requires 16 ice cream units.
Location 18 at (39, 59) requires 33 ice cream units.
Location 19 at (75, 46) requires 27 ice cream units.
Routes must start and end at 0, respect the 100 limit, and together serve all 20 listed locations with minimal total driving.

Also, when you send the actual routes back, please use a simple JSON shape like this so it's easy to parse.

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

This just shows the shape I expect: ""solution"" is a list of trips (each trip is an ordered list of stops that starts and ends at the garage). The placeholder names (garage_id, customer_id) are just examples to show the pattern — it's a sketch of the format, not the real answer.

Please be sure to use the exact identifiers from the instance input when you list stops — 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': [[56, 43], [49, 21], [73, 59], [81, 83], [47, 60], [93, 35], [93, 70], [93, 17], [3, 68], [93, 56], [100, 2], [63, 0], [32, 0], [0, 48], [76, 21], [41, 100], [81, 59], [39, 75], [39, 59], [75, 46]], 'depot': 0, 'demands': [0, 26, 15, 37, 16, 12, 31, 8, 13, 15, 22, 28, 12, 27, 13, 25, 10, 16, 33, 27], 'capacity': 100, 'num_vehicles': 4, 'total_distance': 616.7147215780357, 'objective': 616.7147215780357}","[[0, 2, 16, 6, 9, 19, 0], [0, 14, 5, 7, 10, 11, 12, 0], [0, 3, 15, 17, 4, 0], [0, 18, 8, 13, 1, 0]]",616.7147215780357,"{'problem_type': 'CVRP', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 56, 'y': 43, 'demand': 0}, {'id': 1, 'x': 49, 'y': 21, 'demand': 26}, {'id': 2, 'x': 73, 'y': 59, 'demand': 15}, {'id': 3, 'x': 81, 'y': 83, 'demand': 37}, {'id': 4, 'x': 47, 'y': 60, 'demand': 16}, {'id': 5, 'x': 93, 'y': 35, 'demand': 12}, {'id': 6, 'x': 93, 'y': 70, 'demand': 31}, {'id': 7, 'x': 93, 'y': 17, 'demand': 8}, {'id': 8, 'x': 3, 'y': 68, 'demand': 13}, {'id': 9, 'x': 93, 'y': 56, 'demand': 15}, {'id': 10, 'x': 100, 'y': 2, 'demand': 22}, {'id': 11, 'x': 63, 'y': 0, 'demand': 28}, {'id': 12, 'x': 32, 'y': 0, 'demand': 12}, {'id': 13, 'x': 0, 'y': 48, 'demand': 27}, {'id': 14, 'x': 76, 'y': 21, 'demand': 13}, {'id': 15, 'x': 41, 'y': 100, 'demand': 25}, {'id': 16, 'x': 81, 'y': 59, 'demand': 10}, {'id': 17, 'x': 39, 'y': 75, 'demand': 16}, {'id': 18, 'x': 39, 'y': 59, 'demand': 33}, {'id': 19, 'x': 75, 'y': 46, 'demand': 27}], 'depot': 0, 'capacity': 100, 'num_vehicles': 4, 'total_distance': 616.7147215780357, 'objective': 616.7147215780357}","[[0, 2, 16, 6, 9, 19, 0], [0, 14, 5, 7, 10, 11, 12, 0], [0, 3, 15, 17, 4, 0], [0, 18, 8, 13, 1, 0]]",47,nl,0
CVRP,CVRP,"There’s a parts manager trying to plan the day: assign which truck visits which repair sites so nobody gets missed or gets two deliveries. Each run needs to leave from the depot and return there, and no truck should be packed beyond its limit. The measure of a good plan is simple — total miles driven across all runs — so the trick is to make that total as low as it can be by choosing smart routes. The concrete details are shown below.

{
  ""total_locations"": 24,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""location_x"": 47,
      ""location_y"": 67,
      ""parts_required"": 0
    },
    {
      ""location_id"": 2,
      ""location_x"": 93,
      ""location_y"": 99,
      ""parts_required"": 5
    },
    {
      ""location_id"": 3,
      ""location_x"": 28,
      ""location_y"": 63,
      ""parts_required"": 23
    },
    {
      ""location_id"": 4,
      ""location_x"": 93,
      ""location_y"": 35,
      ""parts_required"": 14
    },
    {
      ""location_id"": 5,
      ""location_x"": 33,
      ""location_y"": 1,
      ""parts_required"": 8
    },
    {
      ""location_id"": 6,
      ""location_x"": 47,
      ""location_y"": 93,
      ""parts_required"": 18
    },
    {
      ""location_id"": 7,
      ""location_x"": 0,
      ""location_y"": 8,
      ""parts_required"": 10
    },
    {
      ""location_id"": 8,
      ""location_x"": 100,
      ""location_y"": 11,
      ""parts_required"": 18
    },
    {
      ""location_id"": 9,
      ""location_x"": 43,
      ""location_y"": 22,
      ""parts_required"": 9
    },
    {
      ""location_id"": 10,
      ""location_x"": 0,
      ""location_y"": 19,
      ""parts_required"": 23
    },
    {
      ""location_id"": 11,
      ""location_x"": 80,
      ""location_y"": 100,
      ""parts_required"": 9
    },
    {
      ""location_id"": 12,
      ""location_x"": 63,
      ""location_y"": 49,
      ""parts_required"": 18
    },
    {
      ""location_id"": 13,
      ""location_x"": 69,
      ""location_y"": 77,
      ""parts_required"": 13
    },
    {
      ""location_id"": 14,
      ""location_x"": 68,
      ""location_y"": 99,
      ""parts_required"": 14
    },
    {
      ""location_id"": 15,
      ""location_x"": 21,
      ""location_y"": 40,
      ""parts_required"": 8
    },
    {
      ""location_id"": 16,
      ""location_x"": 81,
      ""location_y"": 100,
      ""parts_required"": 10
    },
    {
      ""location_id"": 17,
      ""location_x"": 53,
      ""location_y"": 60,
      ""parts_required"": 19
    },
    {
      ""location_id"": 18,
      ""location_x"": 60,
      ""location_y"": 71,
      ""parts_required"": 14
    },
    {
      ""location_id"": 19,
      ""location_x"": 33,
      ""location_y"": 89,
      ""parts_required"": 13
    },
    {
      ""location_id"": 20,
      ""location_x"": 43,
      ""location_y"": 0,
      ""parts_required"": 14
    },
    {
      ""location_id"": 21,
      ""location_x"": 68,
      ""location_y"": 74,
      ""parts_required"": 15
    },
    {
      ""location_id"": 22,
      ""location_x"": 100,
      ""location_y"": 66,
      ""parts_required"": 8
    },
    {
      ""location_id"": 23,
      ""location_x"": 47,
      ""location_y"": 0,
      ""parts_required"": 20
    },
    {
      ""location_id"": 24,
      ""location_x"": 81,
      ""location_y"": 82,
      ""parts_required"": 24
    }
  ],
  ""depot_id"": 1,
  ""vehicle_capacity"": 100
}

Also, when you send the plan back, please follow this simple JSON layout so I can parse it easily:

{
  ""solution"": [[""depot_id"", ""site_id"", ""depot_id""], [""depot_id"", ""site_id"", ""site_id"", ""depot_id""]]
}

This is just a quick sketch of the shape I expect: ""solution"" is a list of truck runs, each run is an ordered list that starts and ends at the depot (the first and last entry), and the names in the middle are the repair sites the truck will visit that day. Think of it like filling out a form — each inner list is one truck’s trip, in order.

This JSON is only the shape I want, not the actual answer — replace those placeholders with the exact identifiers from the instance when you submit your plan. Please do not rename or invent labels: 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': [[47, 67], [93, 99], [28, 63], [93, 35], [33, 1], [47, 93], [0, 8], [100, 11], [43, 22], [0, 19], [80, 100], [63, 49], [69, 77], [68, 99], [21, 40], [81, 100], [53, 60], [60, 71], [33, 89], [43, 0], [68, 74], [100, 66], [47, 0], [81, 82]], 'depot': 0, 'demands': [0, 5, 23, 14, 8, 18, 10, 18, 9, 23, 9, 18, 13, 14, 8, 10, 19, 14, 13, 14, 15, 8, 20, 24], 'capacity': 100, 'num_vehicles': 4, 'total_distance': 584.953380024433, 'objective': 584.953380024433}","[[0, 17, 20, 12, 21, 3, 7, 11, 0], [0, 23, 1, 15, 10, 13, 5, 18, 0], [0, 16, 2, 0], [0, 14, 9, 6, 4, 19, 22, 8, 0]]",584.953380024433,"{'problem_type': 'CVRP', 'num_nodes': 24, 'nodes': [{'id': 1, 'x': 47, 'y': 67, 'demand': 0}, {'id': 2, 'x': 93, 'y': 99, 'demand': 5}, {'id': 3, 'x': 28, 'y': 63, 'demand': 23}, {'id': 4, 'x': 93, 'y': 35, 'demand': 14}, {'id': 5, 'x': 33, 'y': 1, 'demand': 8}, {'id': 6, 'x': 47, 'y': 93, 'demand': 18}, {'id': 7, 'x': 0, 'y': 8, 'demand': 10}, {'id': 8, 'x': 100, 'y': 11, 'demand': 18}, {'id': 9, 'x': 43, 'y': 22, 'demand': 9}, {'id': 10, 'x': 0, 'y': 19, 'demand': 23}, {'id': 11, 'x': 80, 'y': 100, 'demand': 9}, {'id': 12, 'x': 63, 'y': 49, 'demand': 18}, {'id': 13, 'x': 69, 'y': 77, 'demand': 13}, {'id': 14, 'x': 68, 'y': 99, 'demand': 14}, {'id': 15, 'x': 21, 'y': 40, 'demand': 8}, {'id': 16, 'x': 81, 'y': 100, 'demand': 10}, {'id': 17, 'x': 53, 'y': 60, 'demand': 19}, {'id': 18, 'x': 60, 'y': 71, 'demand': 14}, {'id': 19, 'x': 33, 'y': 89, 'demand': 13}, {'id': 20, 'x': 43, 'y': 0, 'demand': 14}, {'id': 21, 'x': 68, 'y': 74, 'demand': 15}, {'id': 22, 'x': 100, 'y': 66, 'demand': 8}, {'id': 23, 'x': 47, 'y': 0, 'demand': 20}, {'id': 24, 'x': 81, 'y': 82, 'demand': 24}], 'depot': 1, 'capacity': 100, 'num_vehicles': 4, 'total_distance': 584.953380024433, 'objective': 584.953380024433}","[[1, 18, 21, 13, 22, 4, 8, 12, 1], [1, 24, 2, 16, 11, 14, 6, 19, 1], [1, 17, 3, 1], [1, 15, 10, 7, 5, 20, 23, 9, 1]]",48,json,1
CVRP,CVRP,"Someone at the blood bank has to lay out the routes for the day, deciding which hospitals each vehicle should visit so nobody gets left out or served twice, every route begins and ends at the bank, and each cooler stays within its load limit. The practical aim is to keep the whole operation as short as possible in terms of driving: add up the miles of every route, and the plan with the lowest total is the preferred one. The exact run details and quantities appear below.

{
  ""total_locations"": 18,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""x_coordinate"": 48,
      ""y_coordinate"": 0,
      ""blood_units_required"": 0
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 0,
      ""y_coordinate"": 15,
      ""blood_units_required"": 20
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 23,
      ""y_coordinate"": 79,
      ""blood_units_required"": 5
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 79,
      ""y_coordinate"": 87,
      ""blood_units_required"": 11
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 69,
      ""y_coordinate"": 72,
      ""blood_units_required"": 10
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 73,
      ""y_coordinate"": 100,
      ""blood_units_required"": 14
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 58,
      ""y_coordinate"": 85,
      ""blood_units_required"": 18
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 10,
      ""y_coordinate"": 34,
      ""blood_units_required"": 5
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 21,
      ""y_coordinate"": 6,
      ""blood_units_required"": 12
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 79,
      ""y_coordinate"": 81,
      ""blood_units_required"": 8
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 48,
      ""y_coordinate"": 96,
      ""blood_units_required"": 12
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 54,
      ""y_coordinate"": 74,
      ""blood_units_required"": 15
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 75,
      ""y_coordinate"": 53,
      ""blood_units_required"": 9
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 98,
      ""y_coordinate"": 57,
      ""blood_units_required"": 20
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 33,
      ""y_coordinate"": 45,
      ""blood_units_required"": 25
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 48,
      ""y_coordinate"": 94,
      ""blood_units_required"": 16
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 85,
      ""y_coordinate"": 2,
      ""blood_units_required"": 14
    },
    {
      ""location_id"": 18,
      ""x_coordinate"": 100,
      ""y_coordinate"": 83,
      ""blood_units_required"": 18
    }
  ],
  ""blood_bank_id"": 1,
  ""vehicle_capacity"": 100
}

I'll just lay out the shape I want the answer to take in case it helps — a simple JSON sketch showing the routes.

{
  ""solution"": [[bank_id, hospital_id, ... , bank_id], [bank_id, hospital_id, ... , bank_id], ...]
}

This means ""solution"" is a list of vehicle routes. Each inner list is one route: it starts at the bank (bank_id), lists the hospitals visited (hospital_id placeholders) in the order they are driven to, and then returns to the bank (bank_id). The ""..."" just indicates any number of stops on a route. It's just a plain sketch of the expected shape, not the actual plan.

Please use the exact identifiers from the instance input when you give the real routes — 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': [[48, 0], [0, 15], [23, 79], [79, 87], [69, 72], [73, 100], [58, 85], [10, 34], [21, 6], [79, 81], [48, 96], [54, 74], [75, 53], [98, 57], [33, 45], [48, 94], [85, 2], [100, 83]], 'depot': 0, 'demands': [0, 20, 5, 11, 10, 14, 18, 5, 12, 8, 12, 15, 9, 20, 25, 16, 14, 18], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 612.7355109193143, 'objective': 612.7355109193143}","[[0, 8, 1, 7, 0], [0, 14, 2, 10, 15, 6, 11, 12, 0], [0, 16, 13, 17, 5, 3, 9, 4, 0]]",612.7355109193143,"{'problem_type': 'CVRP', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 48, 'y': 0, 'demand': 0}, {'id': 2, 'x': 0, 'y': 15, 'demand': 20}, {'id': 3, 'x': 23, 'y': 79, 'demand': 5}, {'id': 4, 'x': 79, 'y': 87, 'demand': 11}, {'id': 5, 'x': 69, 'y': 72, 'demand': 10}, {'id': 6, 'x': 73, 'y': 100, 'demand': 14}, {'id': 7, 'x': 58, 'y': 85, 'demand': 18}, {'id': 8, 'x': 10, 'y': 34, 'demand': 5}, {'id': 9, 'x': 21, 'y': 6, 'demand': 12}, {'id': 10, 'x': 79, 'y': 81, 'demand': 8}, {'id': 11, 'x': 48, 'y': 96, 'demand': 12}, {'id': 12, 'x': 54, 'y': 74, 'demand': 15}, {'id': 13, 'x': 75, 'y': 53, 'demand': 9}, {'id': 14, 'x': 98, 'y': 57, 'demand': 20}, {'id': 15, 'x': 33, 'y': 45, 'demand': 25}, {'id': 16, 'x': 48, 'y': 94, 'demand': 16}, {'id': 17, 'x': 85, 'y': 2, 'demand': 14}, {'id': 18, 'x': 100, 'y': 83, 'demand': 18}], 'depot': 1, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 612.7355109193143, 'objective': 612.7355109193143}","[[1, 9, 2, 8, 1], [1, 15, 3, 11, 16, 7, 12, 13, 1], [1, 17, 14, 18, 6, 4, 10, 5, 1]]",49,json,1
CVRP,CVRP,"In the neighborhood the collection center coordinates a handful of pickup runs: each run must start and end at the center, and every residence must be visited one time only. The question is how to assign houses to runs so each run’s bag total fits under the van’s capacity and no house is served more than once or missed. The preferred arrangement is the one that keeps total driving to a minimum — you get that number by adding the lengths of all the routes together. The specific list of stops, their bag demands and the van capacity are shown below.

# total_stops_including_center=22
# collection_center_id=A
# van_capacity_bags=218
location_id,location_x,location_y,bags_demand
A,93,29,0
B,22,51,83
C,72,79,5
D,80,58,5
E,12,56,9
F,34,20,3
G,0,38,10
H,75,67,5
I,40,0,2
J,47,95,6
K,75,96,5
L,22,52,4
M,31,54,4
N,100,65,2
O,25,47,3
P,96,69,2
Q,45,41,5
R,43,26,7
S,20,59,9
T,76,100,7
U,15,46,8
V,85,62,4

Also, when you send back the plan, please stick to this simple JSON layout so I can easily pick apart each pickup run:

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

This little sketch means ""solution"" is a list of runs. Each inner list is one run that starts and ends at the collection center (center_id) and lists the houses visited in order (house_id, ...). Think of it like filling in a form: one array per van trip, with the center shown first and last.

This is just the shape I need, not the actual answer — please use it to return the real runs for the instance.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[93, 29], [22, 51], [72, 79], [80, 58], [12, 56], [34, 20], [0, 38], [75, 67], [40, 0], [47, 95], [75, 96], [22, 52], [31, 54], [100, 65], [25, 47], [96, 69], [45, 41], [43, 26], [20, 59], [76, 100], [15, 46], [85, 62]], 'depot': 0, 'demands': [0, 83, 5, 5, 9, 3, 10, 5, 2, 6, 5, 4, 4, 2, 3, 2, 5, 7, 9, 7, 8, 4], 'capacity': 218, 'num_vehicles': 1, 'total_distance': 378.2178481731666, 'objective': 378.2178481731666}","[[0, 13, 15, 21, 3, 7, 2, 10, 19, 9, 18, 4, 6, 20, 11, 1, 14, 12, 16, 17, 5, 8, 0]]",378.2178481731666,"{'problem_type': 'CVRP', 'num_nodes': 22, 'nodes': [{'id': 'A', 'x': 93, 'y': 29, 'demand': 0}, {'id': 'B', 'x': 22, 'y': 51, 'demand': 83}, {'id': 'C', 'x': 72, 'y': 79, 'demand': 5}, {'id': 'D', 'x': 80, 'y': 58, 'demand': 5}, {'id': 'E', 'x': 12, 'y': 56, 'demand': 9}, {'id': 'F', 'x': 34, 'y': 20, 'demand': 3}, {'id': 'G', 'x': 0, 'y': 38, 'demand': 10}, {'id': 'H', 'x': 75, 'y': 67, 'demand': 5}, {'id': 'I', 'x': 40, 'y': 0, 'demand': 2}, {'id': 'J', 'x': 47, 'y': 95, 'demand': 6}, {'id': 'K', 'x': 75, 'y': 96, 'demand': 5}, {'id': 'L', 'x': 22, 'y': 52, 'demand': 4}, {'id': 'M', 'x': 31, 'y': 54, 'demand': 4}, {'id': 'N', 'x': 100, 'y': 65, 'demand': 2}, {'id': 'O', 'x': 25, 'y': 47, 'demand': 3}, {'id': 'P', 'x': 96, 'y': 69, 'demand': 2}, {'id': 'Q', 'x': 45, 'y': 41, 'demand': 5}, {'id': 'R', 'x': 43, 'y': 26, 'demand': 7}, {'id': 'S', 'x': 20, 'y': 59, 'demand': 9}, {'id': 'T', 'x': 76, 'y': 100, 'demand': 7}, {'id': 'U', 'x': 15, 'y': 46, 'demand': 8}, {'id': 'V', 'x': 85, 'y': 62, 'demand': 4}], 'depot': 'A', 'capacity': 218, 'num_vehicles': 1, 'total_distance': 378.2178481731666, 'objective': 378.2178481731666}","[['A', 'N', 'P', 'V', 'D', 'H', 'C', 'K', 'T', 'J', 'S', 'E', 'G', 'U', 'L', 'B', 'O', 'M', 'Q', 'R', 'F', 'I', 'A']]",50,csv,names