TSPTW/TSPTW_L_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
TSPTW,TSPTW,"Someone on the morning shift needs to draw up a delivery route that leaves from the depot, goes to every customer exactly one time during that customer’s allowed delivery window, and comes back to the depot; it’s okay to pause and wait if a place isn’t open yet. The deciding factor is how few miles the whole circuit uses — simply add up the distances between consecutive stops to see which plan uses less driving. Every customer must be visited once, and the exact stops and time windows are shown below.

There are 17 locations (including depot 0); list each stop with coordinates and its allowed arrival window:

| location_id | coord_x | coord_y | tw_earliest_arrival | tw_latest_arrival |
|---|---|---|---|---|
| 0 | 0 | 83 | 0 | 1067 |
| 1 | 11 | 92 | 145 | 431 |
| 2 | 10 | 0 | 284 | 536 |
| 3 | 17 | 3 | 60 | 269 |
| 4 | 22 | 28 | 22 | 300 |
| 5 | 18 | 72 | 233 | 495 |
| 6 | 21 | 72 | 7 | 296 |
| 7 | 21 | 84 | 322 | 537 |
| 8 | 14 | 84 | 70 | 282 |
| 9 | 36 | 59 | 118 | 362 |
| 10 | 55 | 90 | 167 | 389 |
| 11 | 61 | 100 | 237 | 444 |
| 12 | 71 | 100 | 113 | 342 |
| 13 | 74 | 100 | 176 | 447 |
| 14 | 72 | 27 | 77 | 321 |
| 15 | 85 | 100 | 229 | 428 |
| 16 | 100 | 82 | 235 | 446 |

The route must start and end at 0 and visit every location within its time window.

Oh, and when you reply with a candidate route, please use this simple JSON shape so it's easy to read and check:

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

Here ""solution"" is just the ordered list of stops: start at the depot, visit every customer once (in the order shown in the array), and finish back at the depot. Think of the bits in brackets as a form where you list the stop identifiers in travel order — it's just a sketch of the shape I need, not the actual route.

Please be sure to use the exact identifiers from the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 83], [11, 92], [10, 0], [17, 3], [22, 28], [18, 72], [21, 72], [21, 84], [14, 84], [36, 59], [55, 90], [61, 100], [71, 100], [74, 100], [72, 27], [85, 100], [100, 82]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [145, 431], [284, 536], [60, 269], [22, 300], [233, 495], [7, 296], [322, 537], [70, 282], [118, 362], [167, 389], [237, 444], [113, 342], [176, 447], [77, 321], [229, 428], [235, 446]], 'tour_length': 512.6699703364131, 'objective': 512.6699703364131}","[0, 8, 6, 9, 4, 3, 14, 16, 15, 13, 12, 11, 10, 7, 1, 5, 2, 0]",512.6699703364131,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 0, 'y': 83, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 11, 'y': 92, 'tw_start': 145, 'tw_end': 431}, {'id': 2, 'x': 10, 'y': 0, 'tw_start': 284, 'tw_end': 536}, {'id': 3, 'x': 17, 'y': 3, 'tw_start': 60, 'tw_end': 269}, {'id': 4, 'x': 22, 'y': 28, 'tw_start': 22, 'tw_end': 300}, {'id': 5, 'x': 18, 'y': 72, 'tw_start': 233, 'tw_end': 495}, {'id': 6, 'x': 21, 'y': 72, 'tw_start': 7, 'tw_end': 296}, {'id': 7, 'x': 21, 'y': 84, 'tw_start': 322, 'tw_end': 537}, {'id': 8, 'x': 14, 'y': 84, 'tw_start': 70, 'tw_end': 282}, {'id': 9, 'x': 36, 'y': 59, 'tw_start': 118, 'tw_end': 362}, {'id': 10, 'x': 55, 'y': 90, 'tw_start': 167, 'tw_end': 389}, {'id': 11, 'x': 61, 'y': 100, 'tw_start': 237, 'tw_end': 444}, {'id': 12, 'x': 71, 'y': 100, 'tw_start': 113, 'tw_end': 342}, {'id': 13, 'x': 74, 'y': 100, 'tw_start': 176, 'tw_end': 447}, {'id': 14, 'x': 72, 'y': 27, 'tw_start': 77, 'tw_end': 321}, {'id': 15, 'x': 85, 'y': 100, 'tw_start': 229, 'tw_end': 428}, {'id': 16, 'x': 100, 'y': 82, 'tw_start': 235, 'tw_end': 446}], 'depot': 0, 'objective': 512.6699703364131}","[0, 8, 6, 9, 4, 3, 14, 16, 15, 13, 12, 11, 10, 7, 1, 5, 2, 0]",1,markdown_table,0
TSPTW,TSPTW,"We have a supervisor who needs one round trip from the depot that hits every piece of equipment exactly once, arriving to each site only during its allowed arrival period, and then returns to the depot. The decision is which route and sequence to follow so those arrival intervals are met. What makes one route better than another is simple: the one with the smallest total travel distance wins — calculate that by summing the distances between each stop in the trip (including leaving from and returning to the garage). Waiting at a site until its window opens is allowed, but it doesn’t reduce the miles driven. The concrete details are listed below.

These 16 locations (including the garage A) are listed below, one per line:
Site A at (100, 19) — allowed arrival window: 0 to 1067.
Site B at (84, 38) — allowed arrival window: 25 to 311.
Site C at (85, 49) — allowed arrival window: 374 to 647.
Site D at (77, 69) — allowed arrival window: 118 to 321.
Site E at (79, 68) — allowed arrival window: 265 to 502.
Site F at (72, 83) — allowed arrival window: 47 to 289.
Site G at (72, 100) — allowed arrival window: 13 to 295.
Site H at (61, 94) — allowed arrival window: 100 to 358.
Site I at (65, 99) — allowed arrival window: 120 to 365.
Site J at (49, 0) — allowed arrival window: 212 to 424.
Site K at (46, 16) — allowed arrival window: 376 to 645.
Site L at (62, 54) — allowed arrival window: 364 to 645.
Site M at (54, 53) — allowed arrival window: 231 to 515.
Site N at (47, 80) — allowed arrival window: 34 to 247.
Site O at (0, 23) — allowed arrival window: 17 to 243.
Site P at (9, 83) — allowed arrival window: 150 to 371.
We must plan a single round trip starting and ending at A that visits all 16 sites within their arrival windows; the route with the smallest total travel distance is preferred.

Oh, and when you send the route back, please put it in this simple JSON shape so I can read it easily:

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

This just means ""solution"" should be an ordered list showing the trip: start at the garage_id, visit each site_id once in the order you choose, and finish back at the garage_id. It's just a sketch of the shape I need, not your actual answer.

Please be careful 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': [[100, 19], [84, 38], [85, 49], [77, 69], [79, 68], [72, 83], [72, 100], [61, 94], [65, 99], [49, 0], [46, 16], [62, 54], [54, 53], [47, 80], [0, 23], [9, 83]], 'depot': 0, 'num_nodes': 16, 'time_windows': [[0, 1067], [25, 311], [374, 647], [118, 321], [265, 502], [47, 289], [13, 295], [100, 358], [120, 365], [212, 424], [376, 645], [364, 645], [231, 515], [34, 247], [17, 243], [150, 371]], 'tour_length': 465.40393580915685, 'objective': 465.40393580915685}","[0, 1, 14, 15, 13, 7, 8, 6, 5, 3, 4, 12, 11, 10, 9, 2, 0]",465.40393580915685,"{'problem_type': 'TSPTW', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 100, 'y': 19, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 84, 'y': 38, 'tw_start': 25, 'tw_end': 311}, {'id': 'C', 'x': 85, 'y': 49, 'tw_start': 374, 'tw_end': 647}, {'id': 'D', 'x': 77, 'y': 69, 'tw_start': 118, 'tw_end': 321}, {'id': 'E', 'x': 79, 'y': 68, 'tw_start': 265, 'tw_end': 502}, {'id': 'F', 'x': 72, 'y': 83, 'tw_start': 47, 'tw_end': 289}, {'id': 'G', 'x': 72, 'y': 100, 'tw_start': 13, 'tw_end': 295}, {'id': 'H', 'x': 61, 'y': 94, 'tw_start': 100, 'tw_end': 358}, {'id': 'I', 'x': 65, 'y': 99, 'tw_start': 120, 'tw_end': 365}, {'id': 'J', 'x': 49, 'y': 0, 'tw_start': 212, 'tw_end': 424}, {'id': 'K', 'x': 46, 'y': 16, 'tw_start': 376, 'tw_end': 645}, {'id': 'L', 'x': 62, 'y': 54, 'tw_start': 364, 'tw_end': 645}, {'id': 'M', 'x': 54, 'y': 53, 'tw_start': 231, 'tw_end': 515}, {'id': 'N', 'x': 47, 'y': 80, 'tw_start': 34, 'tw_end': 247}, {'id': 'O', 'x': 0, 'y': 23, 'tw_start': 17, 'tw_end': 243}, {'id': 'P', 'x': 9, 'y': 83, 'tw_start': 150, 'tw_end': 371}], 'depot': 'A', 'objective': 465.40393580915685}","['A', 'B', 'O', 'P', 'N', 'H', 'I', 'G', 'F', 'D', 'E', 'M', 'L', 'K', 'J', 'C', 'A']",2,nl,names
TSPTW,TSPTW,"Early on weekday mornings a routine takes shape: start at the house, drop off at school, stop at scheduled activities, and end back at the house, making sure each stop is visited once and only during its permitted time range. The choice is the order of stops — different orders change arrival times and miles driven, and the best order is the one that produces the smallest total miles driven. To get that number, add up the miles between each successive stop in the plan and include the final leg home; pausing to wait for a place to open is allowed. The concrete schedule and locations are shown below.

# total_stops_including_home=18
# home_node_id=0
# time windows are listed per node in the table
stop_id,map_x_coordinate,map_y_coordinate,earliest_allowed_arrival,latest_allowed_arrival
0,35,0,0,1067
1,30,4,373,591
2,60,6,192,416
3,45,27,110,308
4,49,28,236,479
5,0,29,19,241
6,63,34,352,569
7,9,35,56,297
8,26,42,382,599
9,88,42,260,528
10,46,43,92,356
11,54,53,142,398
12,70,76,245,491
13,80,78,35,310
14,100,89,124,336
15,83,95,15,267
16,15,95,262,458
17,20,100,198,414

If you want the plan in a simple machine-friendly form, just give it in this little JSON shape so it's easy to read and check:

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

Here ""solution"" is the ordered list of place IDs — start at home, list each stop once in the order you'll visit them, and finish back at home. Think of it like filling in the blanks on a form: the first and last entry are your home/depot, and the items in between are the stops in visit order. This is just a sketch of the shape I expect, not the actual route.

Please make 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': [[35, 0], [30, 4], [60, 6], [45, 27], [49, 28], [0, 29], [63, 34], [9, 35], [26, 42], [88, 42], [46, 43], [54, 53], [70, 76], [80, 78], [100, 89], [83, 95], [15, 95], [20, 100]], 'depot': 0, 'num_nodes': 18, 'time_windows': [[0, 1067], [373, 591], [192, 416], [110, 308], [236, 479], [19, 241], [352, 569], [56, 297], [382, 599], [260, 528], [92, 356], [142, 398], [245, 491], [35, 310], [124, 336], [15, 267], [262, 458], [198, 414]], 'tour_length': 538.5164722739481, 'objective': 538.5164722739481}","[0, 5, 7, 3, 10, 11, 13, 14, 15, 12, 17, 16, 4, 2, 9, 6, 8, 1, 0]",538.5164722739481,"{'problem_type': 'TSPTW', 'num_nodes': 18, 'nodes': [{'id': 0, 'x': 35, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 30, 'y': 4, 'tw_start': 373, 'tw_end': 591}, {'id': 2, 'x': 60, 'y': 6, 'tw_start': 192, 'tw_end': 416}, {'id': 3, 'x': 45, 'y': 27, 'tw_start': 110, 'tw_end': 308}, {'id': 4, 'x': 49, 'y': 28, 'tw_start': 236, 'tw_end': 479}, {'id': 5, 'x': 0, 'y': 29, 'tw_start': 19, 'tw_end': 241}, {'id': 6, 'x': 63, 'y': 34, 'tw_start': 352, 'tw_end': 569}, {'id': 7, 'x': 9, 'y': 35, 'tw_start': 56, 'tw_end': 297}, {'id': 8, 'x': 26, 'y': 42, 'tw_start': 382, 'tw_end': 599}, {'id': 9, 'x': 88, 'y': 42, 'tw_start': 260, 'tw_end': 528}, {'id': 10, 'x': 46, 'y': 43, 'tw_start': 92, 'tw_end': 356}, {'id': 11, 'x': 54, 'y': 53, 'tw_start': 142, 'tw_end': 398}, {'id': 12, 'x': 70, 'y': 76, 'tw_start': 245, 'tw_end': 491}, {'id': 13, 'x': 80, 'y': 78, 'tw_start': 35, 'tw_end': 310}, {'id': 14, 'x': 100, 'y': 89, 'tw_start': 124, 'tw_end': 336}, {'id': 15, 'x': 83, 'y': 95, 'tw_start': 15, 'tw_end': 267}, {'id': 16, 'x': 15, 'y': 95, 'tw_start': 262, 'tw_end': 458}, {'id': 17, 'x': 20, 'y': 100, 'tw_start': 198, 'tw_end': 414}], 'depot': 0, 'objective': 538.5164722739481}","[0, 5, 7, 3, 10, 11, 13, 14, 15, 12, 17, 16, 4, 2, 9, 6, 8, 1, 0]",3,csv,0
TSPTW,TSPTW,"At the flower shop the planner’s job is to arrange the same-day delivery run: start and finish at the shop, visit each address one time only, arrive within each recipient’s specified time period (it’s okay to pause and wait if arriving early), and keep the overall driving down. A wiser choice of order is the one that produces the smallest total kilometers driven — you work that out by summing the distances between each leg of the trip, including coming back to the shop. Nothing can be skipped or repeated, and every delivery must fit its time window. The specific stops, distances and time windows are listed below.

There are 23 stops including the shop 1; each stop's coordinates and allowed arrival window are listed one per line below.
Stop 1: coordinates (0, 45), arrival window 0 - 1240.
Stop 2: coordinates (37, 12), arrival window 247 - 550.
Stop 3: coordinates (30, 66), arrival window 294 - 544.
Stop 4: coordinates (37, 69), arrival window 321 - 573.
Stop 5: coordinates (44, 100), arrival window 146 - 456.
Stop 6: coordinates (36, 95), arrival window 292 - 614.
Stop 7: coordinates (62, 70), arrival window 296 - 586.
Stop 8: coordinates (100, 41), arrival window 42 - 309.
Stop 9: coordinates (71, 41), arrival window 119 - 372.
Stop 10: coordinates (83, 34), arrival window 438 - 708.
Stop 11: coordinates (62, 27), arrival window 402 - 698.
Stop 12: coordinates (79, 23), arrival window 358 - 640.
Stop 13: coordinates (97, 21), arrival window 260 - 541.
Stop 14: coordinates (90, 21), arrival window 88 - 395.
Stop 15: coordinates (83, 18), arrival window 126 - 354.
Stop 16: coordinates (86, 17), arrival window 291 - 536.
Stop 17: coordinates (78, 14), arrival window 424 - 757.
Stop 18: coordinates (79, 14), arrival window 412 - 679.
Stop 19: coordinates (74, 11), arrival window 6 - 337.
Stop 20: coordinates (88, 8), arrival window 193 - 527.
Stop 21: coordinates (92, 3), arrival window 434 - 756.
Stop 22: coordinates (93, 2), arrival window 132 - 401.
Stop 23: coordinates (89, 0), arrival window 383 - 645.
Visit every stop once, start and finish at 1, and make the route for all 23 stops fit their time windows while keeping total kilometers minimal.

When you hand over the final delivery order, just pop it into this simple JSON layout so it's easy to read and process:

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

Think of ""solution"" as the ordered list of stops — start at the shop (depot), visit every address once, and come back to the shop at the end. The placeholders in the array are where you put the exact stop identifiers from the instance. This JSON is only a sketch of the shape I expect, not the actual route.

Please make sure you use the identifiers exactly as they appear in the instance input — no renaming and no new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 45], [37, 12], [30, 66], [37, 69], [44, 100], [36, 95], [62, 70], [100, 41], [71, 41], [83, 34], [62, 27], [79, 23], [97, 21], [90, 21], [83, 18], [86, 17], [78, 14], [79, 14], [74, 11], [88, 8], [92, 3], [93, 2], [89, 0]], 'depot': 0, 'num_nodes': 23, 'time_windows': [[0, 1240], [247, 550], [294, 544], [321, 573], [146, 456], [292, 614], [296, 586], [42, 309], [119, 372], [438, 708], [402, 698], [358, 640], [260, 541], [88, 395], [126, 354], [291, 536], [424, 757], [412, 679], [6, 337], [193, 527], [434, 756], [132, 401], [383, 645]], 'tour_length': 547.5407920262489, 'objective': 547.5407920262489}","[0, 18, 21, 14, 13, 7, 8, 4, 5, 2, 3, 6, 12, 20, 22, 19, 15, 17, 16, 11, 9, 10, 1, 0]",547.5407920262489,"{'problem_type': 'TSPTW', 'num_nodes': 23, 'nodes': [{'id': 1, 'x': 0, 'y': 45, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 37, 'y': 12, 'tw_start': 247, 'tw_end': 550}, {'id': 3, 'x': 30, 'y': 66, 'tw_start': 294, 'tw_end': 544}, {'id': 4, 'x': 37, 'y': 69, 'tw_start': 321, 'tw_end': 573}, {'id': 5, 'x': 44, 'y': 100, 'tw_start': 146, 'tw_end': 456}, {'id': 6, 'x': 36, 'y': 95, 'tw_start': 292, 'tw_end': 614}, {'id': 7, 'x': 62, 'y': 70, 'tw_start': 296, 'tw_end': 586}, {'id': 8, 'x': 100, 'y': 41, 'tw_start': 42, 'tw_end': 309}, {'id': 9, 'x': 71, 'y': 41, 'tw_start': 119, 'tw_end': 372}, {'id': 10, 'x': 83, 'y': 34, 'tw_start': 438, 'tw_end': 708}, {'id': 11, 'x': 62, 'y': 27, 'tw_start': 402, 'tw_end': 698}, {'id': 12, 'x': 79, 'y': 23, 'tw_start': 358, 'tw_end': 640}, {'id': 13, 'x': 97, 'y': 21, 'tw_start': 260, 'tw_end': 541}, {'id': 14, 'x': 90, 'y': 21, 'tw_start': 88, 'tw_end': 395}, {'id': 15, 'x': 83, 'y': 18, 'tw_start': 126, 'tw_end': 354}, {'id': 16, 'x': 86, 'y': 17, 'tw_start': 291, 'tw_end': 536}, {'id': 17, 'x': 78, 'y': 14, 'tw_start': 424, 'tw_end': 757}, {'id': 18, 'x': 79, 'y': 14, 'tw_start': 412, 'tw_end': 679}, {'id': 19, 'x': 74, 'y': 11, 'tw_start': 6, 'tw_end': 337}, {'id': 20, 'x': 88, 'y': 8, 'tw_start': 193, 'tw_end': 527}, {'id': 21, 'x': 92, 'y': 3, 'tw_start': 434, 'tw_end': 756}, {'id': 22, 'x': 93, 'y': 2, 'tw_start': 132, 'tw_end': 401}, {'id': 23, 'x': 89, 'y': 0, 'tw_start': 383, 'tw_end': 645}], 'depot': 1, 'objective': 547.5407920262489}","[1, 19, 22, 15, 14, 8, 9, 5, 6, 3, 4, 7, 13, 21, 23, 20, 16, 18, 17, 12, 10, 11, 2, 1]",4,nl,1
TSPTW,TSPTW,"There’s an inspector route to plan: leave the office, visit every property one time, respect each property’s allowed inspection period, and return to the same office at the end. The only leeway is waiting until a property’s window opens, and the better route is the one with the smallest total travel distance — calculated by summing the distances between all the successive stops on the loop — and the specific stops and windows are shown below.

The plan covers 18 locations, with the office as 1:
Visit location 1 at (3, 1) and begin inspection between 0 and 1067.
Visit location 2 at (59, 0) and begin inspection between 319 and 548.
Visit location 3 at (72, 0) and begin inspection between 49 and 293.
Visit location 4 at (81, 0) and begin inspection between 298 and 513.
Visit location 5 at (87, 5) and begin inspection between 241 and 443.
Visit location 6 at (85, 18) and begin inspection between 20 and 265.
Visit location 7 at (70, 23) and begin inspection between 209 and 465.
Visit location 8 at (64, 16) and begin inspection between 281 and 570.
Visit location 9 at (89, 41) and begin inspection between 200 and 425.
Visit location 10 at (94, 43) and begin inspection between 308 and 528.
Visit location 11 at (8, 61) and begin inspection between 170 and 371.
Visit location 12 at (100, 76) and begin inspection between 9 and 297.
Visit location 13 at (83, 90) and begin inspection between 324 and 585.
Visit location 14 at (85, 90) and begin inspection between 158 and 369.
Visit location 15 at (85, 83) and begin inspection between 60 and 278.
Visit location 16 at (59, 100) and begin inspection between 213 and 476.
Visit location 17 at (31, 97) and begin inspection between 256 and 477.
Visit location 18 at (0, 100) and begin inspection between 370 and 636.
Return to the office 1 after visiting all 18 locations; wait if necessary until windows open, and prefer the route with the smallest total travel distance.

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

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

This just says: ""solution"" is the ordered loop — start at the office_id, list each property_id in the order you visit them, and come back to the same office_id at the end. The ""..."" means all the other stops go in between. It's just a sketch of the shape I need, not the actual route.

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': [[3, 1], [59, 0], [72, 0], [81, 0], [87, 5], [85, 18], [70, 23], [64, 16], [89, 41], [94, 43], [8, 61], [100, 76], [83, 90], [85, 90], [85, 83], [59, 100], [31, 97], [0, 100]], 'depot': 0, 'num_nodes': 18, 'time_windows': [[0, 1067], [319, 548], [49, 293], [298, 513], [241, 443], [20, 265], [209, 465], [281, 570], [200, 425], [308, 528], [170, 371], [9, 297], [324, 585], [158, 369], [60, 278], [213, 476], [256, 477], [370, 636]], 'tour_length': 729.593626438245, 'objective': 729.593626438245}","[0, 2, 5, 11, 14, 10, 16, 15, 12, 13, 9, 8, 4, 6, 3, 1, 7, 17, 0]",729.593626438245,"{'problem_type': 'TSPTW', 'num_nodes': 18, 'nodes': [{'id': 1, 'x': 3, 'y': 1, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 59, 'y': 0, 'tw_start': 319, 'tw_end': 548}, {'id': 3, 'x': 72, 'y': 0, 'tw_start': 49, 'tw_end': 293}, {'id': 4, 'x': 81, 'y': 0, 'tw_start': 298, 'tw_end': 513}, {'id': 5, 'x': 87, 'y': 5, 'tw_start': 241, 'tw_end': 443}, {'id': 6, 'x': 85, 'y': 18, 'tw_start': 20, 'tw_end': 265}, {'id': 7, 'x': 70, 'y': 23, 'tw_start': 209, 'tw_end': 465}, {'id': 8, 'x': 64, 'y': 16, 'tw_start': 281, 'tw_end': 570}, {'id': 9, 'x': 89, 'y': 41, 'tw_start': 200, 'tw_end': 425}, {'id': 10, 'x': 94, 'y': 43, 'tw_start': 308, 'tw_end': 528}, {'id': 11, 'x': 8, 'y': 61, 'tw_start': 170, 'tw_end': 371}, {'id': 12, 'x': 100, 'y': 76, 'tw_start': 9, 'tw_end': 297}, {'id': 13, 'x': 83, 'y': 90, 'tw_start': 324, 'tw_end': 585}, {'id': 14, 'x': 85, 'y': 90, 'tw_start': 158, 'tw_end': 369}, {'id': 15, 'x': 85, 'y': 83, 'tw_start': 60, 'tw_end': 278}, {'id': 16, 'x': 59, 'y': 100, 'tw_start': 213, 'tw_end': 476}, {'id': 17, 'x': 31, 'y': 97, 'tw_start': 256, 'tw_end': 477}, {'id': 18, 'x': 0, 'y': 100, 'tw_start': 370, 'tw_end': 636}], 'depot': 1, 'objective': 729.593626438245}","[1, 3, 6, 12, 15, 11, 17, 16, 13, 14, 10, 9, 5, 7, 4, 2, 8, 18, 1]",5,nl,1
TSPTW,TSPTW,"There’s a vaccination team leader sketching out a route that leaves the clinic, goes to each community stop once within its assigned access window, and then comes back to base — arriving early and waiting for a site to open is okay. What makes a route preferable is how short the total drive is: add up the distance between each pair of consecutive stops (and the return to the clinic) and the smallest total wins. No site can be skipped or revisited, and the specific locations and windows are listed below.

They number 17, with clinic 1 as the tour start and end.

| location_id | x_coordinate | y_coordinate | earliest_allowed_arrival | latest_allowed_arrival |
|---|---|---|---|---|
| 1 | 82 | 58 | 0 | 1067 |
| 2 | 57 | 100 | 174 | 381 |
| 3 | 48 | 53 | 370 | 622 |
| 4 | 4 | 5 | 88 | 347 |
| 5 | 100 | 9 | 239 | 468 |
| 6 | 44 | 50 | 44 | 303 |
| 7 | 72 | 39 | 201 | 470 |
| 8 | 69 | 34 | 201 | 478 |
| 9 | 69 | 94 | 214 | 462 |
| 10 | 21 | 0 | 340 | 573 |
| 11 | 50 | 29 | 51 | 248 |
| 12 | 76 | 19 | 292 | 547 |
| 13 | 9 | 22 | 273 | 487 |
| 14 | 34 | 54 | 52 | 248 |
| 15 | 37 | 96 | 136 | 387 |
| 16 | 0 | 6 | 152 | 388 |
| 17 | 28 | 0 | 350 | 578 |

The leader will plan a loop visiting all 17 sites and returning to 1.

Oh, and when you send back the planned route, a casual little JSON shape like this is perfect — just a list that starts at the clinic, visits each stop once, and comes back to the clinic.

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

Here ""solution"" is the tour: the sequence of place identifiers you plan to visit in order, starting and ending at the clinic and including every community stop exactly once. Think of it like filling out a short form: just drop the sequence of IDs in the array in the order the team will drive them. This example is only a sketch of the expected shape — not the actual answer.

Please be sure to use the identifiers 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': [[82, 58], [57, 100], [48, 53], [4, 5], [100, 9], [44, 50], [72, 39], [69, 34], [69, 94], [21, 0], [50, 29], [76, 19], [9, 22], [34, 54], [37, 96], [0, 6], [28, 0]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [174, 381], [370, 622], [88, 347], [239, 468], [44, 303], [201, 470], [201, 478], [214, 462], [340, 573], [51, 248], [292, 547], [273, 487], [52, 248], [136, 387], [152, 388], [350, 578]], 'tour_length': 495.9578148259617, 'objective': 495.9578148259617}","[0, 10, 13, 14, 1, 8, 5, 12, 15, 3, 9, 16, 7, 6, 4, 11, 2, 0]",495.9578148259617,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 82, 'y': 58, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 57, 'y': 100, 'tw_start': 174, 'tw_end': 381}, {'id': 3, 'x': 48, 'y': 53, 'tw_start': 370, 'tw_end': 622}, {'id': 4, 'x': 4, 'y': 5, 'tw_start': 88, 'tw_end': 347}, {'id': 5, 'x': 100, 'y': 9, 'tw_start': 239, 'tw_end': 468}, {'id': 6, 'x': 44, 'y': 50, 'tw_start': 44, 'tw_end': 303}, {'id': 7, 'x': 72, 'y': 39, 'tw_start': 201, 'tw_end': 470}, {'id': 8, 'x': 69, 'y': 34, 'tw_start': 201, 'tw_end': 478}, {'id': 9, 'x': 69, 'y': 94, 'tw_start': 214, 'tw_end': 462}, {'id': 10, 'x': 21, 'y': 0, 'tw_start': 340, 'tw_end': 573}, {'id': 11, 'x': 50, 'y': 29, 'tw_start': 51, 'tw_end': 248}, {'id': 12, 'x': 76, 'y': 19, 'tw_start': 292, 'tw_end': 547}, {'id': 13, 'x': 9, 'y': 22, 'tw_start': 273, 'tw_end': 487}, {'id': 14, 'x': 34, 'y': 54, 'tw_start': 52, 'tw_end': 248}, {'id': 15, 'x': 37, 'y': 96, 'tw_start': 136, 'tw_end': 387}, {'id': 16, 'x': 0, 'y': 6, 'tw_start': 152, 'tw_end': 388}, {'id': 17, 'x': 28, 'y': 0, 'tw_start': 350, 'tw_end': 578}], 'depot': 1, 'objective': 495.9578148259617}","[1, 11, 14, 15, 2, 9, 6, 13, 16, 4, 10, 17, 8, 7, 5, 12, 3, 1]",6,markdown_table,1
TSPTW,TSPTW,"Someone juggling portrait sessions must plan a one-day loop: leave the studio, visit every client location once and during its booked time window, and finish back at the studio. What makes one plan better than another is simply how little driving it requires — add up all the travel legs (including the final leg back) and pick the route with the smallest total — and arriving early is okay since waiting for the slot to start is allowed. The concrete schedule and distances are shown below.

# total_locations_including_studio=21
# studio_node_id=A
# time windows are listed per node in the table
location_id,location_x_coord,location_y_coord,booking_start_time,booking_end_time
A,0,37,0,1240
B,0,57,74,391
C,4,66,300,584
D,7,49,161,486
E,18,0,176,494
F,21,0,198,466
G,21,9,208,468
H,21,34,337,619
I,29,9,104,431
J,32,69,173,459
K,39,60,408,704
L,43,74,52,384
M,61,77,283,546
N,64,14,62,377
O,89,100,279,565
P,100,54,403,717
Q,53,68,68,329
R,57,65,112,421
S,69,70,15,304
T,75,31,343,668
U,84,12,154,472

If you'd like to hand me a proposed route, just pop it into this little JSON shape so it's easy to read and check:

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

Think of it like a short form: ""solution"" is the ordered list of stops — start at the studio, visit each client once in the order shown, and finish back at the studio. The placeholders are just that (a sketch of the shape I want), so replace studio_id and client_id with the actual stop identifiers from the instance when you submit a route.

Please make sure you use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[0, 37], [0, 57], [4, 66], [7, 49], [18, 0], [21, 0], [21, 9], [21, 34], [29, 9], [32, 69], [39, 60], [43, 74], [61, 77], [64, 14], [89, 100], [100, 54], [53, 68], [57, 65], [69, 70], [75, 31], [84, 12]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [74, 391], [300, 584], [161, 486], [176, 494], [198, 466], [208, 468], [337, 619], [104, 431], [173, 459], [408, 704], [52, 384], [283, 546], [62, 377], [279, 565], [403, 717], [68, 329], [112, 421], [15, 304], [343, 668], [154, 472]], 'tour_length': 542.8329217805294, 'objective': 542.8329217805294}","[0, 17, 18, 16, 11, 9, 1, 3, 6, 4, 5, 8, 13, 20, 19, 15, 14, 12, 10, 2, 7, 0]",542.8329217805294,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 'A', 'x': 0, 'y': 37, 'tw_start': 0, 'tw_end': 1240}, {'id': 'B', 'x': 0, 'y': 57, 'tw_start': 74, 'tw_end': 391}, {'id': 'C', 'x': 4, 'y': 66, 'tw_start': 300, 'tw_end': 584}, {'id': 'D', 'x': 7, 'y': 49, 'tw_start': 161, 'tw_end': 486}, {'id': 'E', 'x': 18, 'y': 0, 'tw_start': 176, 'tw_end': 494}, {'id': 'F', 'x': 21, 'y': 0, 'tw_start': 198, 'tw_end': 466}, {'id': 'G', 'x': 21, 'y': 9, 'tw_start': 208, 'tw_end': 468}, {'id': 'H', 'x': 21, 'y': 34, 'tw_start': 337, 'tw_end': 619}, {'id': 'I', 'x': 29, 'y': 9, 'tw_start': 104, 'tw_end': 431}, {'id': 'J', 'x': 32, 'y': 69, 'tw_start': 173, 'tw_end': 459}, {'id': 'K', 'x': 39, 'y': 60, 'tw_start': 408, 'tw_end': 704}, {'id': 'L', 'x': 43, 'y': 74, 'tw_start': 52, 'tw_end': 384}, {'id': 'M', 'x': 61, 'y': 77, 'tw_start': 283, 'tw_end': 546}, {'id': 'N', 'x': 64, 'y': 14, 'tw_start': 62, 'tw_end': 377}, {'id': 'O', 'x': 89, 'y': 100, 'tw_start': 279, 'tw_end': 565}, {'id': 'P', 'x': 100, 'y': 54, 'tw_start': 403, 'tw_end': 717}, {'id': 'Q', 'x': 53, 'y': 68, 'tw_start': 68, 'tw_end': 329}, {'id': 'R', 'x': 57, 'y': 65, 'tw_start': 112, 'tw_end': 421}, {'id': 'S', 'x': 69, 'y': 70, 'tw_start': 15, 'tw_end': 304}, {'id': 'T', 'x': 75, 'y': 31, 'tw_start': 343, 'tw_end': 668}, {'id': 'U', 'x': 84, 'y': 12, 'tw_start': 154, 'tw_end': 472}], 'depot': 'A', 'objective': 542.8329217805294}","['A', 'R', 'S', 'Q', 'L', 'J', 'B', 'D', 'G', 'E', 'F', 'I', 'N', 'U', 'T', 'P', 'O', 'M', 'K', 'C', 'H', 'A']",7,csv,names
TSPTW,TSPTW,"Recently the crew schedule required a single-van tour that starts and ends at the depot, visits each customer property only once during its allowed service period, and avoids unnecessary back-and-forth. The winning route is the one with the smallest total driving distance, which you find by summing the distances of each leg of the trip; arriving early and waiting until a service window opens is allowed. The specific addresses, service windows and travel lengths are shown below.

There are 19 stops in total, and the depot is node 0.

| location_id | coord_x | coord_y | service_window_start | service_window_end |
|---|---|---|---|---|
| 0 | 43 | 100 | 0 | 1067 |
| 1 | 82 | 97 | 42 | 319 |
| 2 | 42 | 96 | 49 | 282 |
| 3 | 31 | 91 | 309 | 517 |
| 4 | 49 | 91 | 88 | 353 |
| 5 | 83 | 85 | 279 | 535 |
| 6 | 94 | 75 | 269 | 515 |
| 7 | 92 | 75 | 97 | 325 |
| 8 | 79 | 75 | 70 | 352 |
| 9 | 100 | 70 | 226 | 459 |
| 10 | 85 | 69 | 179 | 465 |
| 11 | 96 | 66 | 59 | 310 |
| 12 | 90 | 57 | 196 | 449 |
| 13 | 69 | 56 | 7 | 285 |
| 14 | 69 | 53 | 361 | 610 |
| 15 | 78 | 50 | 270 | 553 |
| 16 | 36 | 48 | 274 | 483 |
| 17 | 10 | 28 | 223 | 476 |
| 18 | 0 | 0 | 164 | 429 |

These entries list each stop with its coordinates and allowed service window for route computation.

When you send back the chosen tour, just use this simple JSON layout so it's easy to check:

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

This shows the shape I need: ""solution"" is the ordered list of stops — start at the depot, list each customer once in the order you'll visit them, and finish back at the depot. The snippet above is just a sketch of the format, not the actual route.

Please use the exact identifiers from the instance input when you fill that array — 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': [[43, 100], [82, 97], [42, 96], [31, 91], [49, 91], [83, 85], [94, 75], [92, 75], [79, 75], [100, 70], [85, 69], [96, 66], [90, 57], [69, 56], [69, 53], [78, 50], [36, 48], [10, 28], [0, 0]], 'depot': 0, 'num_nodes': 19, 'time_windows': [[0, 1067], [42, 319], [49, 282], [309, 517], [88, 353], [279, 535], [269, 515], [97, 325], [70, 352], [226, 459], [179, 465], [59, 310], [196, 449], [7, 285], [361, 610], [270, 553], [274, 483], [223, 476], [164, 429]], 'tour_length': 436.217451873266, 'objective': 436.217451873266}","[0, 2, 4, 1, 7, 11, 10, 8, 13, 18, 17, 16, 14, 15, 12, 9, 6, 5, 3, 0]",436.217451873266,"{'problem_type': 'TSPTW', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 43, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 82, 'y': 97, 'tw_start': 42, 'tw_end': 319}, {'id': 2, 'x': 42, 'y': 96, 'tw_start': 49, 'tw_end': 282}, {'id': 3, 'x': 31, 'y': 91, 'tw_start': 309, 'tw_end': 517}, {'id': 4, 'x': 49, 'y': 91, 'tw_start': 88, 'tw_end': 353}, {'id': 5, 'x': 83, 'y': 85, 'tw_start': 279, 'tw_end': 535}, {'id': 6, 'x': 94, 'y': 75, 'tw_start': 269, 'tw_end': 515}, {'id': 7, 'x': 92, 'y': 75, 'tw_start': 97, 'tw_end': 325}, {'id': 8, 'x': 79, 'y': 75, 'tw_start': 70, 'tw_end': 352}, {'id': 9, 'x': 100, 'y': 70, 'tw_start': 226, 'tw_end': 459}, {'id': 10, 'x': 85, 'y': 69, 'tw_start': 179, 'tw_end': 465}, {'id': 11, 'x': 96, 'y': 66, 'tw_start': 59, 'tw_end': 310}, {'id': 12, 'x': 90, 'y': 57, 'tw_start': 196, 'tw_end': 449}, {'id': 13, 'x': 69, 'y': 56, 'tw_start': 7, 'tw_end': 285}, {'id': 14, 'x': 69, 'y': 53, 'tw_start': 361, 'tw_end': 610}, {'id': 15, 'x': 78, 'y': 50, 'tw_start': 270, 'tw_end': 553}, {'id': 16, 'x': 36, 'y': 48, 'tw_start': 274, 'tw_end': 483}, {'id': 17, 'x': 10, 'y': 28, 'tw_start': 223, 'tw_end': 476}, {'id': 18, 'x': 0, 'y': 0, 'tw_start': 164, 'tw_end': 429}], 'depot': 0, 'objective': 436.217451873266}","[0, 2, 4, 1, 7, 11, 10, 8, 13, 18, 17, 16, 14, 15, 12, 9, 6, 5, 3, 0]",8,markdown_table,0
TSPTW,TSPTW,"Many people on the tour team have wrestled with the same homework: start at headquarters, go to each venue once during its agreed time window, and return to headquarters, all while trying to keep driving to a minimum. The decision is the order of stops; a better choice is the route with the lowest total driving distance — simply add up the distances for all legs of the trip — and it’s allowed to hang around and wait if a venue’s window hasn’t started yet. No stop can be skipped or revisited, and arrival times must respect the windows. The exact itinerary data appears below.

{
  ""total_locations_including_headquarters"": 19,
  ""nodes"": [
    {
      ""venue_identifier"": ""A"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 7,
      ""earliest_arrival_time"": 0,
      ""latest_arrival_time"": 1067
    },
    {
      ""venue_identifier"": ""B"",
      ""x_coordinate"": 30,
      ""y_coordinate"": 100,
      ""earliest_arrival_time"": 106,
      ""latest_arrival_time"": 354
    },
    {
      ""venue_identifier"": ""C"",
      ""x_coordinate"": 28,
      ""y_coordinate"": 87,
      ""earliest_arrival_time"": 252,
      ""latest_arrival_time"": 527
    },
    {
      ""venue_identifier"": ""D"",
      ""x_coordinate"": 24,
      ""y_coordinate"": 71,
      ""earliest_arrival_time"": 80,
      ""latest_arrival_time"": 275
    },
    {
      ""venue_identifier"": ""E"",
      ""x_coordinate"": 30,
      ""y_coordinate"": 38,
      ""earliest_arrival_time"": 53,
      ""latest_arrival_time"": 334
    },
    {
      ""venue_identifier"": ""F"",
      ""x_coordinate"": 55,
      ""y_coordinate"": 59,
      ""earliest_arrival_time"": 339,
      ""latest_arrival_time"": 591
    },
    {
      ""venue_identifier"": ""G"",
      ""x_coordinate"": 79,
      ""y_coordinate"": 64,
      ""earliest_arrival_time"": 233,
      ""latest_arrival_time"": 491
    },
    {
      ""venue_identifier"": ""H"",
      ""x_coordinate"": 66,
      ""y_coordinate"": 66,
      ""earliest_arrival_time"": 68,
      ""latest_arrival_time"": 350
    },
    {
      ""venue_identifier"": ""I"",
      ""x_coordinate"": 61,
      ""y_coordinate"": 75,
      ""earliest_arrival_time"": 162,
      ""latest_arrival_time"": 393
    },
    {
      ""venue_identifier"": ""J"",
      ""x_coordinate"": 81,
      ""y_coordinate"": 82,
      ""earliest_arrival_time"": 201,
      ""latest_arrival_time"": 399
    },
    {
      ""venue_identifier"": ""K"",
      ""x_coordinate"": 61,
      ""y_coordinate"": 98,
      ""earliest_arrival_time"": 64,
      ""latest_arrival_time"": 330
    },
    {
      ""venue_identifier"": ""L"",
      ""x_coordinate"": 54,
      ""y_coordinate"": 42,
      ""earliest_arrival_time"": 32,
      ""latest_arrival_time"": 284
    },
    {
      ""venue_identifier"": ""M"",
      ""x_coordinate"": 61,
      ""y_coordinate"": 31,
      ""earliest_arrival_time"": 95,
      ""latest_arrival_time"": 326
    },
    {
      ""venue_identifier"": ""N"",
      ""x_coordinate"": 54,
      ""y_coordinate"": 20,
      ""earliest_arrival_time"": 112,
      ""latest_arrival_time"": 340
    },
    {
      ""venue_identifier"": ""O"",
      ""x_coordinate"": 67,
      ""y_coordinate"": 14,
      ""earliest_arrival_time"": 278,
      ""latest_arrival_time"": 501
    },
    {
      ""venue_identifier"": ""P"",
      ""x_coordinate"": 57,
      ""y_coordinate"": 7,
      ""earliest_arrival_time"": 219,
      ""latest_arrival_time"": 459
    },
    {
      ""venue_identifier"": ""Q"",
      ""x_coordinate"": 82,
      ""y_coordinate"": 0,
      ""earliest_arrival_time"": 257,
      ""latest_arrival_time"": 542
    },
    {
      ""venue_identifier"": ""R"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 12,
      ""earliest_arrival_time"": 284,
      ""latest_arrival_time"": 499
    },
    {
      ""venue_identifier"": ""S"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 18,
      ""earliest_arrival_time"": 12,
      ""latest_arrival_time"": 231
    }
  ],
  ""headquarters_node_id"": ""A""
}

You can just send the planned route back in a tiny JSON snippet like this:

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

This just means: put the ordered list of stops under ""solution"" — start with the HQ identifier, list each venue once in the visit order, and end with the HQ identifier again. The placeholders above are just showing the shape (hq_id is the depot/headquarters; venue_id stands for each visit location; ""..."" means the rest of the stops in between). Treat it like a simple form, not a full report.

Reminder: that JSON is only a sketch of the shape I expect, not the actual route. 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, 7], [30, 100], [28, 87], [24, 71], [30, 38], [55, 59], [79, 64], [66, 66], [61, 75], [81, 82], [61, 98], [54, 42], [61, 31], [54, 20], [67, 14], [57, 7], [82, 0], [100, 12], [100, 18]], 'depot': 0, 'num_nodes': 19, 'time_windows': [[0, 1067], [106, 354], [252, 527], [80, 275], [53, 334], [339, 591], [233, 491], [68, 350], [162, 393], [201, 399], [64, 330], [32, 284], [95, 326], [112, 340], [278, 501], [219, 459], [257, 542], [284, 499], [12, 231]], 'tour_length': 576.1090955295339, 'objective': 576.1090955295339}","[0, 4, 11, 12, 13, 18, 7, 8, 3, 2, 1, 10, 9, 6, 5, 15, 14, 17, 16, 0]",576.1090955295339,"{'problem_type': 'TSPTW', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 0, 'y': 7, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 30, 'y': 100, 'tw_start': 106, 'tw_end': 354}, {'id': 'C', 'x': 28, 'y': 87, 'tw_start': 252, 'tw_end': 527}, {'id': 'D', 'x': 24, 'y': 71, 'tw_start': 80, 'tw_end': 275}, {'id': 'E', 'x': 30, 'y': 38, 'tw_start': 53, 'tw_end': 334}, {'id': 'F', 'x': 55, 'y': 59, 'tw_start': 339, 'tw_end': 591}, {'id': 'G', 'x': 79, 'y': 64, 'tw_start': 233, 'tw_end': 491}, {'id': 'H', 'x': 66, 'y': 66, 'tw_start': 68, 'tw_end': 350}, {'id': 'I', 'x': 61, 'y': 75, 'tw_start': 162, 'tw_end': 393}, {'id': 'J', 'x': 81, 'y': 82, 'tw_start': 201, 'tw_end': 399}, {'id': 'K', 'x': 61, 'y': 98, 'tw_start': 64, 'tw_end': 330}, {'id': 'L', 'x': 54, 'y': 42, 'tw_start': 32, 'tw_end': 284}, {'id': 'M', 'x': 61, 'y': 31, 'tw_start': 95, 'tw_end': 326}, {'id': 'N', 'x': 54, 'y': 20, 'tw_start': 112, 'tw_end': 340}, {'id': 'O', 'x': 67, 'y': 14, 'tw_start': 278, 'tw_end': 501}, {'id': 'P', 'x': 57, 'y': 7, 'tw_start': 219, 'tw_end': 459}, {'id': 'Q', 'x': 82, 'y': 0, 'tw_start': 257, 'tw_end': 542}, {'id': 'R', 'x': 100, 'y': 12, 'tw_start': 284, 'tw_end': 499}, {'id': 'S', 'x': 100, 'y': 18, 'tw_start': 12, 'tw_end': 231}], 'depot': 'A', 'objective': 576.1090955295339}","['A', 'E', 'L', 'M', 'N', 'S', 'H', 'I', 'D', 'C', 'B', 'K', 'J', 'G', 'F', 'P', 'O', 'R', 'Q', 'A']",9,json,names
TSPTW,TSPTW,"Many people count on the mobile library, so the planner must lay out a single route that leaves the branch, visits every community stop once within its visiting window, and returns to the branch afterward. The idea is to pick the order that results in the least overall driving — compute that by adding up the distance of each leg from stop to stop and back home — and early arrivals can wait until a place opens. The detailed stops and their hours are listed below.

There are 23 locations in total, and the tour must start and end at depot 0.

| stop_id | coordinate_x | coordinate_y | visit_window_start | visit_window_end |
|---|---|---|---|---|
| 0 | 22 | 56 | 0 | 1240 |
| 1 | 23 | 68 | 412 | 642 |
| 2 | 27 | 68 | 314 | 573 |
| 3 | 23 | 98 | 416 | 751 |
| 4 | 39 | 20 | 425 | 704 |
| 5 | 39 | 57 | 388 | 709 |
| 6 | 47 | 68 | 143 | 462 |
| 7 | 46 | 83 | 16 | 309 |
| 8 | 42 | 90 | 103 | 342 |
| 9 | 39 | 91 | 34 | 338 |
| 10 | 60 | 91 | 153 | 460 |
| 11 | 57 | 54 | 29 | 290 |
| 12 | 57 | 11 | 243 | 557 |
| 13 | 51 | 5 | 143 | 439 |
| 14 | 76 | 83 | 399 | 694 |
| 15 | 70 | 83 | 105 | 333 |
| 16 | 66 | 90 | 392 | 620 |
| 17 | 81 | 90 | 394 | 679 |
| 18 | 81 | 54 | 423 | 739 |
| 19 | 85 | 20 | 450 | 715 |
| 20 | 75 | 5 | 346 | 616 |
| 21 | 100 | 100 | 216 | 512 |
| 22 | 0 | 0 | 394 | 730 |

The planner must order these stops to minimize total driving while arriving within each visit window and returning to depot 0 across all 23 locations.

You can just hand the route back in a tiny JSON snippet like this — an ordered list that starts and ends at the branch:

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

This shows the shape I want: ""solution"" is the tour in visit order, the first entry is the branch (depot), the middle entries are the community stops in the order you plan to visit them, and the final entry is the branch again. It’s just a sketch of the expected shape, not the actual answer — please fill it with the exact IDs from the instance when you return the real route.

Please don’t 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': [[22, 56], [23, 68], [27, 68], [23, 98], [39, 20], [39, 57], [47, 68], [46, 83], [42, 90], [39, 91], [60, 91], [57, 54], [57, 11], [51, 5], [76, 83], [70, 83], [66, 90], [81, 90], [81, 54], [85, 20], [75, 5], [100, 100], [0, 0]], 'depot': 0, 'num_nodes': 23, 'time_windows': [[0, 1240], [412, 642], [314, 573], [416, 751], [425, 704], [388, 709], [143, 462], [16, 309], [103, 342], [34, 338], [153, 460], [29, 290], [243, 557], [143, 439], [399, 694], [105, 333], [392, 620], [394, 679], [423, 739], [450, 715], [346, 616], [216, 512], [394, 730]], 'tour_length': 621.5325886104289, 'objective': 621.5325886104289}","[0, 9, 8, 7, 6, 11, 13, 12, 15, 21, 17, 14, 16, 10, 3, 1, 2, 5, 18, 19, 20, 4, 22, 0]",621.5325886104289,"{'problem_type': 'TSPTW', 'num_nodes': 23, 'nodes': [{'id': 0, 'x': 22, 'y': 56, 'tw_start': 0, 'tw_end': 1240}, {'id': 1, 'x': 23, 'y': 68, 'tw_start': 412, 'tw_end': 642}, {'id': 2, 'x': 27, 'y': 68, 'tw_start': 314, 'tw_end': 573}, {'id': 3, 'x': 23, 'y': 98, 'tw_start': 416, 'tw_end': 751}, {'id': 4, 'x': 39, 'y': 20, 'tw_start': 425, 'tw_end': 704}, {'id': 5, 'x': 39, 'y': 57, 'tw_start': 388, 'tw_end': 709}, {'id': 6, 'x': 47, 'y': 68, 'tw_start': 143, 'tw_end': 462}, {'id': 7, 'x': 46, 'y': 83, 'tw_start': 16, 'tw_end': 309}, {'id': 8, 'x': 42, 'y': 90, 'tw_start': 103, 'tw_end': 342}, {'id': 9, 'x': 39, 'y': 91, 'tw_start': 34, 'tw_end': 338}, {'id': 10, 'x': 60, 'y': 91, 'tw_start': 153, 'tw_end': 460}, {'id': 11, 'x': 57, 'y': 54, 'tw_start': 29, 'tw_end': 290}, {'id': 12, 'x': 57, 'y': 11, 'tw_start': 243, 'tw_end': 557}, {'id': 13, 'x': 51, 'y': 5, 'tw_start': 143, 'tw_end': 439}, {'id': 14, 'x': 76, 'y': 83, 'tw_start': 399, 'tw_end': 694}, {'id': 15, 'x': 70, 'y': 83, 'tw_start': 105, 'tw_end': 333}, {'id': 16, 'x': 66, 'y': 90, 'tw_start': 392, 'tw_end': 620}, {'id': 17, 'x': 81, 'y': 90, 'tw_start': 394, 'tw_end': 679}, {'id': 18, 'x': 81, 'y': 54, 'tw_start': 423, 'tw_end': 739}, {'id': 19, 'x': 85, 'y': 20, 'tw_start': 450, 'tw_end': 715}, {'id': 20, 'x': 75, 'y': 5, 'tw_start': 346, 'tw_end': 616}, {'id': 21, 'x': 100, 'y': 100, 'tw_start': 216, 'tw_end': 512}, {'id': 22, 'x': 0, 'y': 0, 'tw_start': 394, 'tw_end': 730}], 'depot': 0, 'objective': 621.5325886104289}","[0, 9, 8, 7, 6, 11, 13, 12, 15, 21, 17, 14, 16, 10, 3, 1, 2, 5, 18, 19, 20, 4, 22, 0]",10,markdown_table,0
TSPTW,TSPTW,"Imagine organizing a calibration trip where the technician sets off from the lab, calls on each customer exactly once during that customer’s available time window (waiting is permitted if the tech gets there before the window), and finally returns to the lab. The measure of a good plan is straightforward: the total distance of the whole tour — sum every driving leg from start to finish — and the smaller that sum, the better the plan. The detailed instance information is listed below.

{
  ""total_locations_including_lab"": 22,
  ""nodes"": [
    {
      ""site_id"": 1,
      ""site_x"": 63,
      ""site_y"": 100,
      ""available_from"": 0,
      ""available_until"": 1240
    },
    {
      ""site_id"": 2,
      ""site_x"": 66,
      ""site_y"": 94,
      ""available_from"": 351,
      ""available_until"": 616
    },
    {
      ""site_id"": 3,
      ""site_x"": 12,
      ""site_y"": 66,
      ""available_from"": 26,
      ""available_until"": 360
    },
    {
      ""site_id"": 4,
      ""site_x"": 0,
      ""site_y"": 43,
      ""available_from"": 398,
      ""available_until"": 728
    },
    {
      ""site_id"": 5,
      ""site_x"": 3,
      ""site_y"": 37,
      ""available_from"": 448,
      ""available_until"": 693
    },
    {
      ""site_id"": 6,
      ""site_x"": 9,
      ""site_y"": 31,
      ""available_from"": 178,
      ""available_until"": 489
    },
    {
      ""site_id"": 7,
      ""site_x"": 60,
      ""site_y"": 40,
      ""available_from"": 313,
      ""available_until"": 556
    },
    {
      ""site_id"": 8,
      ""site_x"": 38,
      ""site_y"": 57,
      ""available_from"": 367,
      ""available_until"": 618
    },
    {
      ""site_id"": 9,
      ""site_x"": 22,
      ""site_y"": 9,
      ""available_from"": 100,
      ""available_until"": 386
    },
    {
      ""site_id"": 10,
      ""site_x"": 38,
      ""site_y"": 23,
      ""available_from"": 267,
      ""available_until"": 558
    },
    {
      ""site_id"": 11,
      ""site_x"": 60,
      ""site_y"": 11,
      ""available_from"": 41,
      ""available_until"": 365
    },
    {
      ""site_id"": 12,
      ""site_x"": 63,
      ""site_y"": 9,
      ""available_from"": 119,
      ""available_until"": 359
    },
    {
      ""site_id"": 13,
      ""site_x"": 78,
      ""site_y"": 34,
      ""available_from"": 400,
      ""available_until"": 734
    },
    {
      ""site_id"": 14,
      ""site_x"": 82,
      ""site_y"": 11,
      ""available_from"": 388,
      ""available_until"": 705
    },
    {
      ""site_id"": 15,
      ""site_x"": 78,
      ""site_y"": 0,
      ""available_from"": 295,
      ""available_until"": 583
    },
    {
      ""site_id"": 16,
      ""site_x"": 91,
      ""site_y"": 0,
      ""available_from"": 39,
      ""available_until"": 310
    },
    {
      ""site_id"": 17,
      ""site_x"": 100,
      ""site_y"": 46,
      ""available_from"": 168,
      ""available_until"": 422
    },
    {
      ""site_id"": 18,
      ""site_x"": 88,
      ""site_y"": 51,
      ""available_from"": 326,
      ""available_until"": 607
    },
    {
      ""site_id"": 19,
      ""site_x"": 91,
      ""site_y"": 46,
      ""available_from"": 36,
      ""available_until"": 286
    },
    {
      ""site_id"": 20,
      ""site_x"": 75,
      ""site_y"": 83,
      ""available_from"": 308,
      ""available_until"": 542
    },
    {
      ""site_id"": 21,
      ""site_x"": 82,
      ""site_y"": 83,
      ""available_from"": 383,
      ""available_until"": 665
    },
    {
      ""site_id"": 22,
      ""site_x"": 98,
      ""site_y"": 74,
      ""available_from"": 216,
      ""available_until"": 509
    }
  ],
  ""lab_node_id"": 1
}

Oh, and when you send back the technician’s plan, please use this simple JSON layout so it’s really clear what the tour looks like:

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

Here ""solution"" is just the tour listed in order — who the tech visits, starting and ending at the lab. Each item in the list is the identifier for that stop (the lab or a customer). Think of it like filling out a little itinerary form, not a technical file — just the sequence in plain identifiers.

This is only a sketch of the expected shape, not the actual answer — please return the real sequence when you’re ready.

All identifiers in your returned JSON must match exactly how 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': [[63, 100], [66, 94], [12, 66], [0, 43], [3, 37], [9, 31], [60, 40], [38, 57], [22, 9], [38, 23], [60, 11], [63, 9], [78, 34], [82, 11], [78, 0], [91, 0], [100, 46], [88, 51], [91, 46], [75, 83], [82, 83], [98, 74]], 'depot': 0, 'num_nodes': 22, 'time_windows': [[0, 1240], [351, 616], [26, 360], [398, 728], [448, 693], [178, 489], [313, 556], [367, 618], [100, 386], [267, 558], [41, 365], [119, 359], [400, 734], [388, 705], [295, 583], [39, 310], [168, 422], [326, 607], [36, 286], [308, 542], [383, 665], [216, 509]], 'tour_length': 694.8331402402799, 'objective': 694.8331402402799}","[0, 2, 18, 16, 15, 11, 10, 8, 5, 9, 6, 14, 13, 12, 17, 21, 20, 19, 1, 7, 4, 3, 0]",694.8331402402799,"{'problem_type': 'TSPTW', 'num_nodes': 22, 'nodes': [{'id': 1, 'x': 63, 'y': 100, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 66, 'y': 94, 'tw_start': 351, 'tw_end': 616}, {'id': 3, 'x': 12, 'y': 66, 'tw_start': 26, 'tw_end': 360}, {'id': 4, 'x': 0, 'y': 43, 'tw_start': 398, 'tw_end': 728}, {'id': 5, 'x': 3, 'y': 37, 'tw_start': 448, 'tw_end': 693}, {'id': 6, 'x': 9, 'y': 31, 'tw_start': 178, 'tw_end': 489}, {'id': 7, 'x': 60, 'y': 40, 'tw_start': 313, 'tw_end': 556}, {'id': 8, 'x': 38, 'y': 57, 'tw_start': 367, 'tw_end': 618}, {'id': 9, 'x': 22, 'y': 9, 'tw_start': 100, 'tw_end': 386}, {'id': 10, 'x': 38, 'y': 23, 'tw_start': 267, 'tw_end': 558}, {'id': 11, 'x': 60, 'y': 11, 'tw_start': 41, 'tw_end': 365}, {'id': 12, 'x': 63, 'y': 9, 'tw_start': 119, 'tw_end': 359}, {'id': 13, 'x': 78, 'y': 34, 'tw_start': 400, 'tw_end': 734}, {'id': 14, 'x': 82, 'y': 11, 'tw_start': 388, 'tw_end': 705}, {'id': 15, 'x': 78, 'y': 0, 'tw_start': 295, 'tw_end': 583}, {'id': 16, 'x': 91, 'y': 0, 'tw_start': 39, 'tw_end': 310}, {'id': 17, 'x': 100, 'y': 46, 'tw_start': 168, 'tw_end': 422}, {'id': 18, 'x': 88, 'y': 51, 'tw_start': 326, 'tw_end': 607}, {'id': 19, 'x': 91, 'y': 46, 'tw_start': 36, 'tw_end': 286}, {'id': 20, 'x': 75, 'y': 83, 'tw_start': 308, 'tw_end': 542}, {'id': 21, 'x': 82, 'y': 83, 'tw_start': 383, 'tw_end': 665}, {'id': 22, 'x': 98, 'y': 74, 'tw_start': 216, 'tw_end': 509}], 'depot': 1, 'objective': 694.8331402402799}","[1, 3, 19, 17, 16, 12, 11, 9, 6, 10, 7, 15, 14, 13, 18, 22, 21, 20, 2, 8, 5, 4, 1]",11,json,1
TSPTW,TSPTW,"Recently the bakery has started juggling a bunch of morning drop-offs: the driver must start at the bakery, visit each café and shop on the list a single time, and return to the bakery afterward. Every customer has a preferred time frame for deliveries, so the route needs to respect those windows (waiting is allowed if a place isn’t ready yet, but being late isn’t). Which delivery order is preferred comes down to total distance driven — sum up the distance between each stop in the route plus the return trip, and the smaller total is better. The exact stops, their windows and the travel distances are listed below.

# total_stops_including_bakery=16
# bakery_node_id=0
# time windows are listed per node in the table
stop_id,coord_x,coord_y,earliest_arrival_time,latest_arrival_time
0,0,34,0,1067
1,4,81,245,492
2,4,100,302,506
3,7,44,295,541
4,18,0,373,600
5,18,94,245,529
6,21,84,39,324
7,25,75,266,467
8,64,2,116,379
9,64,22,26,276
10,86,34,134,388
11,89,47,17,296
12,96,34,377,665
13,100,56,290,497
14,34,33,294,490
15,95,59,8,233

When you’re ready to give the route, just pop it into a tiny JSON snippet like this so I can read it programmatically:

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

Pretty simple — ""solution"" is the ordered list of stops: start at the bakery, visit each place once, and come back to the bakery. The placeholders (bakery_id, shop_id, etc.) are just showing the shape of the answer — they’re not the real identifiers, just a sketch.

Please make sure to use the exact identifiers from 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': [[0, 34], [4, 81], [4, 100], [7, 44], [18, 0], [18, 94], [21, 84], [25, 75], [64, 2], [64, 22], [86, 34], [89, 47], [96, 34], [100, 56], [34, 33], [95, 59]], 'depot': 0, 'num_nodes': 16, 'time_windows': [[0, 1067], [245, 492], [302, 506], [295, 541], [373, 600], [245, 529], [39, 324], [266, 467], [116, 379], [26, 276], [134, 388], [17, 296], [377, 665], [290, 497], [294, 490], [8, 233]], 'tour_length': 551.7867725117662, 'objective': 551.7867725117662}","[0, 8, 9, 10, 11, 15, 7, 6, 5, 2, 1, 3, 14, 13, 12, 4, 0]",551.7867725117662,"{'problem_type': 'TSPTW', 'num_nodes': 16, 'nodes': [{'id': 0, 'x': 0, 'y': 34, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 4, 'y': 81, 'tw_start': 245, 'tw_end': 492}, {'id': 2, 'x': 4, 'y': 100, 'tw_start': 302, 'tw_end': 506}, {'id': 3, 'x': 7, 'y': 44, 'tw_start': 295, 'tw_end': 541}, {'id': 4, 'x': 18, 'y': 0, 'tw_start': 373, 'tw_end': 600}, {'id': 5, 'x': 18, 'y': 94, 'tw_start': 245, 'tw_end': 529}, {'id': 6, 'x': 21, 'y': 84, 'tw_start': 39, 'tw_end': 324}, {'id': 7, 'x': 25, 'y': 75, 'tw_start': 266, 'tw_end': 467}, {'id': 8, 'x': 64, 'y': 2, 'tw_start': 116, 'tw_end': 379}, {'id': 9, 'x': 64, 'y': 22, 'tw_start': 26, 'tw_end': 276}, {'id': 10, 'x': 86, 'y': 34, 'tw_start': 134, 'tw_end': 388}, {'id': 11, 'x': 89, 'y': 47, 'tw_start': 17, 'tw_end': 296}, {'id': 12, 'x': 96, 'y': 34, 'tw_start': 377, 'tw_end': 665}, {'id': 13, 'x': 100, 'y': 56, 'tw_start': 290, 'tw_end': 497}, {'id': 14, 'x': 34, 'y': 33, 'tw_start': 294, 'tw_end': 490}, {'id': 15, 'x': 95, 'y': 59, 'tw_start': 8, 'tw_end': 233}], 'depot': 0, 'objective': 551.7867725117662}","[0, 8, 9, 10, 11, 15, 7, 6, 5, 2, 1, 3, 14, 13, 12, 4, 0]",12,csv,0
TSPTW,TSPTW,"Someone is lining up a route for an art restorer who must leave the studio, work at every gallery on the list once within each gallery’s specific access slot, and end the day back at the studio. The practical choice is picking the order and arrival times; arriving early and waiting is OK, but every gallery has to be visited exactly once. The plan that’s better is simply the one that racks up the fewest total miles — calculated by adding each leg of the trip from studio through all galleries and back — and the detailed schedule and distances are shown below.

{
  ""total_locations_including_studio"": 25,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 0,
      ""access_window_start"": 0,
      ""access_window_end"": 1240
    },
    {
      ""location_id"": 2,
      ""map_x_coordinate"": 45,
      ""map_y_coordinate"": 0,
      ""access_window_start"": 343,
      ""access_window_end"": 639
    },
    {
      ""location_id"": 3,
      ""map_x_coordinate"": 46,
      ""map_y_coordinate"": 18,
      ""access_window_start"": 59,
      ""access_window_end"": 288
    },
    {
      ""location_id"": 4,
      ""map_x_coordinate"": 27,
      ""map_y_coordinate"": 13,
      ""access_window_start"": 415,
      ""access_window_end"": 710
    },
    {
      ""location_id"": 5,
      ""map_x_coordinate"": 46,
      ""map_y_coordinate"": 31,
      ""access_window_start"": 359,
      ""access_window_end"": 639
    },
    {
      ""location_id"": 6,
      ""map_x_coordinate"": 38,
      ""map_y_coordinate"": 40,
      ""access_window_start"": 52,
      ""access_window_end"": 292
    },
    {
      ""location_id"": 7,
      ""map_x_coordinate"": 42,
      ""map_y_coordinate"": 46,
      ""access_window_start"": 309,
      ""access_window_end"": 583
    },
    {
      ""location_id"": 8,
      ""map_x_coordinate"": 45,
      ""map_y_coordinate"": 46,
      ""access_window_start"": 90,
      ""access_window_end"": 371
    },
    {
      ""location_id"": 9,
      ""map_x_coordinate"": 54,
      ""map_y_coordinate"": 49,
      ""access_window_start"": 28,
      ""access_window_end"": 320
    },
    {
      ""location_id"": 10,
      ""map_x_coordinate"": 51,
      ""map_y_coordinate"": 49,
      ""access_window_start"": 121,
      ""access_window_end"": 436
    },
    {
      ""location_id"": 11,
      ""map_x_coordinate"": 73,
      ""map_y_coordinate"": 54,
      ""access_window_start"": 139,
      ""access_window_end"": 416
    },
    {
      ""location_id"": 12,
      ""map_x_coordinate"": 70,
      ""map_y_coordinate"": 56,
      ""access_window_start"": 5,
      ""access_window_end"": 238
    },
    {
      ""location_id"": 13,
      ""map_x_coordinate"": 69,
      ""map_y_coordinate"": 56,
      ""access_window_start"": 177,
      ""access_window_end"": 456
    },
    {
      ""location_id"": 14,
      ""map_x_coordinate"": 66,
      ""map_y_coordinate"": 56,
      ""access_window_start"": 270,
      ""access_window_end"": 528
    },
    {
      ""location_id"": 15,
      ""map_x_coordinate"": 69,
      ""map_y_coordinate"": 67,
      ""access_window_start"": 313,
      ""access_window_end"": 635
    },
    {
      ""location_id"": 16,
      ""map_x_coordinate"": 83,
      ""map_y_coordinate"": 74,
      ""access_window_start"": 351,
      ""access_window_end"": 581
    },
    {
      ""location_id"": 17,
      ""map_x_coordinate"": 84,
      ""map_y_coordinate"": 79,
      ""access_window_start"": 216,
      ""access_window_end"": 454
    },
    {
      ""location_id"": 18,
      ""map_x_coordinate"": 82,
      ""map_y_coordinate"": 85,
      ""access_window_start"": 109,
      ""access_window_end"": 445
    },
    {
      ""location_id"": 19,
      ""map_x_coordinate"": 90,
      ""map_y_coordinate"": 86,
      ""access_window_start"": 64,
      ""access_window_end"": 346
    },
    {
      ""location_id"": 20,
      ""map_x_coordinate"": 76,
      ""map_y_coordinate"": 86,
      ""access_window_start"": 278,
      ""access_window_end"": 583
    },
    {
      ""location_id"": 21,
      ""map_x_coordinate"": 70,
      ""map_y_coordinate"": 100,
      ""access_window_start"": 252,
      ""access_window_end"": 479
    },
    {
      ""location_id"": 22,
      ""map_x_coordinate"": 91,
      ""map_y_coordinate"": 100,
      ""access_window_start"": 147,
      ""access_window_end"": 431
    },
    {
      ""location_id"": 23,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 100,
      ""access_window_start"": 39,
      ""access_window_end"": 304
    },
    {
      ""location_id"": 24,
      ""map_x_coordinate"": 78,
      ""map_y_coordinate"": 41,
      ""access_window_start"": 14,
      ""access_window_end"": 249
    },
    {
      ""location_id"": 25,
      ""map_x_coordinate"": 87,
      ""map_y_coordinate"": 72,
      ""access_window_start"": 179,
      ""access_window_end"": 419
    }
  ],
  ""studio_node_id"": 1
}

And if you want the route in a tidy, machine-friendly snippet, I usually show it like this:

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

This just means ""solution"" is a simple ordered list: start at the studio, visit each gallery once (in the order listed), and come back to the studio. Treat the placeholders as labels you would swap for the actual IDs from the instance — it’s just a sketch of the shape I expect, not the real route.

Please be sure to use the exact identifiers from the instance input — do not rename them or invent new ones.  
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [45, 0], [46, 18], [27, 13], [46, 31], [38, 40], [42, 46], [45, 46], [54, 49], [51, 49], [73, 54], [70, 56], [69, 56], [66, 56], [69, 67], [83, 74], [84, 79], [82, 85], [90, 86], [76, 86], [70, 100], [91, 100], [100, 100], [78, 41], [87, 72]], 'depot': 0, 'num_nodes': 25, 'time_windows': [[0, 1240], [343, 639], [59, 288], [415, 710], [359, 639], [52, 292], [309, 583], [90, 371], [28, 320], [121, 436], [139, 416], [5, 238], [177, 456], [270, 528], [313, 635], [351, 581], [216, 454], [109, 445], [64, 346], [278, 583], [252, 479], [147, 431], [39, 304], [14, 249], [179, 419]], 'tour_length': 404.9439576712628, 'objective': 404.9439576712628}","[0, 2, 5, 7, 8, 12, 11, 10, 23, 24, 18, 22, 21, 20, 19, 17, 16, 15, 14, 13, 9, 6, 4, 1, 3, 0]",404.9439576712628,"{'problem_type': 'TSPTW', 'num_nodes': 25, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 45, 'y': 0, 'tw_start': 343, 'tw_end': 639}, {'id': 3, 'x': 46, 'y': 18, 'tw_start': 59, 'tw_end': 288}, {'id': 4, 'x': 27, 'y': 13, 'tw_start': 415, 'tw_end': 710}, {'id': 5, 'x': 46, 'y': 31, 'tw_start': 359, 'tw_end': 639}, {'id': 6, 'x': 38, 'y': 40, 'tw_start': 52, 'tw_end': 292}, {'id': 7, 'x': 42, 'y': 46, 'tw_start': 309, 'tw_end': 583}, {'id': 8, 'x': 45, 'y': 46, 'tw_start': 90, 'tw_end': 371}, {'id': 9, 'x': 54, 'y': 49, 'tw_start': 28, 'tw_end': 320}, {'id': 10, 'x': 51, 'y': 49, 'tw_start': 121, 'tw_end': 436}, {'id': 11, 'x': 73, 'y': 54, 'tw_start': 139, 'tw_end': 416}, {'id': 12, 'x': 70, 'y': 56, 'tw_start': 5, 'tw_end': 238}, {'id': 13, 'x': 69, 'y': 56, 'tw_start': 177, 'tw_end': 456}, {'id': 14, 'x': 66, 'y': 56, 'tw_start': 270, 'tw_end': 528}, {'id': 15, 'x': 69, 'y': 67, 'tw_start': 313, 'tw_end': 635}, {'id': 16, 'x': 83, 'y': 74, 'tw_start': 351, 'tw_end': 581}, {'id': 17, 'x': 84, 'y': 79, 'tw_start': 216, 'tw_end': 454}, {'id': 18, 'x': 82, 'y': 85, 'tw_start': 109, 'tw_end': 445}, {'id': 19, 'x': 90, 'y': 86, 'tw_start': 64, 'tw_end': 346}, {'id': 20, 'x': 76, 'y': 86, 'tw_start': 278, 'tw_end': 583}, {'id': 21, 'x': 70, 'y': 100, 'tw_start': 252, 'tw_end': 479}, {'id': 22, 'x': 91, 'y': 100, 'tw_start': 147, 'tw_end': 431}, {'id': 23, 'x': 100, 'y': 100, 'tw_start': 39, 'tw_end': 304}, {'id': 24, 'x': 78, 'y': 41, 'tw_start': 14, 'tw_end': 249}, {'id': 25, 'x': 87, 'y': 72, 'tw_start': 179, 'tw_end': 419}], 'depot': 1, 'objective': 404.9439576712628}","[1, 3, 6, 8, 9, 13, 12, 11, 24, 25, 19, 23, 22, 21, 20, 18, 17, 16, 15, 14, 10, 7, 5, 2, 4, 1]",13,json,1
TSPTW,TSPTW,"Recently the city asked for a daily route that starts and ends at the maintenance yard, hits every street-tree inspection spot exactly once during its allotted time period, and keeps the miles driven to an absolute minimum. The way to tell which route is better is straightforward — total the distances for each leg of the trip (including leaving and returning to the yard); the route with the smallest total distance wins. Crews are allowed to wait if they get there early, but every point must be visited once and only once. The concrete details are shown below.

# total_locations_including_yard=17
# yard_node_identifier=1
# time windows are listed per node in the table
inspection_point_id,x_coordinate,y_coordinate,time_window_start,time_window_end
1,32,46,0,1067
2,28,68,16,224
3,26,29,382,670
4,5,85,1,288
5,21,12,247,526
6,21,77,176,420
7,85,37,189,448
8,100,46,54,251
9,47,6,119,381
10,95,49,78,337
11,44,0,376,579
12,80,4,260,498
13,0,80,336,548
14,24,50,268,544
15,90,49,366,626
16,0,57,192,446
17,23,100,337,586

Oh, and one more practical thing — when you give the route back, please put it in a tiny JSON object so it's easy to read and share. Something like this:

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

This just means ""solution"" holds the ordered list: start at the maintenance yard, list each inspection spot in the order the crew will visit them, and finish back at the yard. The identifiers in the array are placeholders you would replace with the actual IDs from the instance — this snippet is just a sketch of the shape I expect, not the real route.

Please make sure you use the exact identifiers from the problem 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': [[32, 46], [28, 68], [26, 29], [5, 85], [21, 12], [21, 77], [85, 37], [100, 46], [47, 6], [95, 49], [44, 0], [80, 4], [0, 80], [24, 50], [90, 49], [0, 57], [23, 100]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [16, 224], [382, 670], [1, 288], [247, 526], [176, 420], [189, 448], [54, 251], [119, 381], [78, 337], [376, 579], [260, 498], [336, 548], [268, 544], [366, 626], [192, 446], [337, 586]], 'tour_length': 599.827872076573, 'objective': 599.827872076573}","[0, 7, 9, 1, 5, 3, 15, 4, 8, 14, 6, 11, 10, 2, 13, 12, 16, 0]",599.827872076573,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 32, 'y': 46, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 28, 'y': 68, 'tw_start': 16, 'tw_end': 224}, {'id': 3, 'x': 26, 'y': 29, 'tw_start': 382, 'tw_end': 670}, {'id': 4, 'x': 5, 'y': 85, 'tw_start': 1, 'tw_end': 288}, {'id': 5, 'x': 21, 'y': 12, 'tw_start': 247, 'tw_end': 526}, {'id': 6, 'x': 21, 'y': 77, 'tw_start': 176, 'tw_end': 420}, {'id': 7, 'x': 85, 'y': 37, 'tw_start': 189, 'tw_end': 448}, {'id': 8, 'x': 100, 'y': 46, 'tw_start': 54, 'tw_end': 251}, {'id': 9, 'x': 47, 'y': 6, 'tw_start': 119, 'tw_end': 381}, {'id': 10, 'x': 95, 'y': 49, 'tw_start': 78, 'tw_end': 337}, {'id': 11, 'x': 44, 'y': 0, 'tw_start': 376, 'tw_end': 579}, {'id': 12, 'x': 80, 'y': 4, 'tw_start': 260, 'tw_end': 498}, {'id': 13, 'x': 0, 'y': 80, 'tw_start': 336, 'tw_end': 548}, {'id': 14, 'x': 24, 'y': 50, 'tw_start': 268, 'tw_end': 544}, {'id': 15, 'x': 90, 'y': 49, 'tw_start': 366, 'tw_end': 626}, {'id': 16, 'x': 0, 'y': 57, 'tw_start': 192, 'tw_end': 446}, {'id': 17, 'x': 23, 'y': 100, 'tw_start': 337, 'tw_end': 586}], 'depot': 1, 'objective': 599.827872076573}","[1, 8, 10, 2, 6, 4, 16, 5, 9, 15, 7, 12, 11, 3, 14, 13, 17, 1]",14,csv,1
TSPTW,TSPTW,"Many days involve a single catering run: start at the kitchen, hit every event once within its promised arrival slot, and head back to the kitchen. The better the plan, the fewer miles driven overall — which you get by summing the distances for each leg in the route, including the return leg — and arriving early is fine because waiting for the arrival period is allowed. Every stop must be included exactly once. The specific event locations and their time windows are shown below.

You must cover 17 locations, starting and ending at kitchen 0.
Visit location 0 at coordinates (81, 97), arriving between 0 and 1067 (arriving early is allowed).
Visit location 1 at coordinates (25, 100), arriving between 214 and 438 (arriving early is allowed).
Visit location 2 at coordinates (44, 92), arriving between 154 and 391 (arriving early is allowed).
Visit location 3 at coordinates (95, 78), arriving between 233 and 477 (arriving early is allowed).
Visit location 4 at coordinates (66, 73), arriving between 356 and 598 (arriving early is allowed).
Visit location 5 at coordinates (94, 70), arriving between 384 and 661 (arriving early is allowed).
Visit location 6 at coordinates (98, 70), arriving between 80 and 365 (arriving early is allowed).
Visit location 7 at coordinates (97, 62), arriving between 45 and 318 (arriving early is allowed).
Visit location 8 at coordinates (94, 56), arriving between 147 and 426 (arriving early is allowed).
Visit location 9 at coordinates (73, 53), arriving between 336 and 608 (arriving early is allowed).
Visit location 10 at coordinates (100, 49), arriving between 306 and 530 (arriving early is allowed).
Visit location 11 at coordinates (0, 51), arriving between 31 and 264 (arriving early is allowed).
Visit location 12 at coordinates (20, 42), arriving between 67 and 328 (arriving early is allowed).
Visit location 13 at coordinates (39, 38), arriving between 134 and 422 (arriving early is allowed).
Visit location 14 at coordinates (27, 18), arriving between 248 and 522 (arriving early is allowed).
Visit location 15 at coordinates (2, 13), arriving between 51 and 329 (arriving early is allowed).
Visit location 16 at coordinates (95, 0), arriving between 358 and 599 (arriving early is allowed).
Plan routes to minimize total miles while visiting every stop exactly once within its time window.

Also, when you hand back the route, just stick to a simple JSON layout like this:

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

Think of that as a little route form: ""solution"" is the ordered list of stops (start at the kitchen, visit each event once, and come back to the kitchen). The placeholders there are just showing the shape I expect — replace them with the actual IDs from the instance when you send the real answer.

This JSON is only a sketch of the shape I want, not the actual route — please use the exact identifiers from the instance input, no renaming and no new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'coordinates': [[81, 97], [25, 100], [44, 92], [95, 78], [66, 73], [94, 70], [98, 70], [97, 62], [94, 56], [73, 53], [100, 49], [0, 51], [20, 42], [39, 38], [27, 18], [2, 13], [95, 0]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [214, 438], [154, 391], [233, 477], [356, 598], [384, 661], [80, 365], [45, 318], [147, 426], [336, 608], [306, 530], [31, 264], [67, 328], [134, 422], [248, 522], [51, 329], [358, 599]], 'tour_length': 574.9497628732163, 'objective': 574.9497628732163}","[0, 6, 7, 13, 12, 11, 15, 14, 1, 2, 4, 8, 5, 3, 10, 16, 9, 0]",574.9497628732163,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 81, 'y': 97, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 25, 'y': 100, 'tw_start': 214, 'tw_end': 438}, {'id': 2, 'x': 44, 'y': 92, 'tw_start': 154, 'tw_end': 391}, {'id': 3, 'x': 95, 'y': 78, 'tw_start': 233, 'tw_end': 477}, {'id': 4, 'x': 66, 'y': 73, 'tw_start': 356, 'tw_end': 598}, {'id': 5, 'x': 94, 'y': 70, 'tw_start': 384, 'tw_end': 661}, {'id': 6, 'x': 98, 'y': 70, 'tw_start': 80, 'tw_end': 365}, {'id': 7, 'x': 97, 'y': 62, 'tw_start': 45, 'tw_end': 318}, {'id': 8, 'x': 94, 'y': 56, 'tw_start': 147, 'tw_end': 426}, {'id': 9, 'x': 73, 'y': 53, 'tw_start': 336, 'tw_end': 608}, {'id': 10, 'x': 100, 'y': 49, 'tw_start': 306, 'tw_end': 530}, {'id': 11, 'x': 0, 'y': 51, 'tw_start': 31, 'tw_end': 264}, {'id': 12, 'x': 20, 'y': 42, 'tw_start': 67, 'tw_end': 328}, {'id': 13, 'x': 39, 'y': 38, 'tw_start': 134, 'tw_end': 422}, {'id': 14, 'x': 27, 'y': 18, 'tw_start': 248, 'tw_end': 522}, {'id': 15, 'x': 2, 'y': 13, 'tw_start': 51, 'tw_end': 329}, {'id': 16, 'x': 95, 'y': 0, 'tw_start': 358, 'tw_end': 599}], 'depot': 0, 'objective': 574.9497628732163}","[0, 6, 7, 13, 12, 11, 15, 14, 1, 2, 4, 8, 5, 3, 10, 16, 9, 0]",15,nl,0
TSPTW,TSPTW,"I help plan outreach days for a nonprofit, where the idea is to leave the office, visit every beneficiary address one time only within the time slot each family agreed to, and come back to the office at the end of the day. The trick is to arrange the order of stops so the total driving distance is as small as possible — that total is just the sum of the distances between each stop in the route, including the trip back to the office — and it’s okay to wait at a location if its time window hasn’t opened yet. Concrete details are shown below.

There are 22 locations in total (including the office), and the office node is 0.

| location_id | location_x_coordinate | location_y_coordinate | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| 0 | 100 | 79 | 0 | 1240 |
| 1 | 93 | 21 | 273 | 585 |
| 2 | 93 | 27 | 78 | 361 |
| 3 | 84 | 85 | 179 | 421 |
| 4 | 80 | 0 | 165 | 398 |
| 5 | 70 | 5 | 11 | 252 |
| 6 | 72 | 42 | 434 | 721 |
| 7 | 63 | 59 | 435 | 709 |
| 8 | 60 | 100 | 140 | 423 |
| 9 | 37 | 11 | 198 | 435 |
| 10 | 47 | 37 | 289 | 538 |
| 11 | 19 | 46 | 279 | 578 |
| 12 | 22 | 47 | 68 | 300 |
| 13 | 50 | 99 | 352 | 629 |
| 14 | 36 | 82 | 26 | 363 |
| 15 | 31 | 59 | 26 | 329 |
| 16 | 27 | 97 | 443 | 696 |
| 17 | 22 | 97 | 64 | 303 |
| 18 | 1 | 29 | 136 | 373 |
| 19 | 1 | 40 | 312 | 544 |
| 20 | 0 | 40 | 229 | 567 |
| 21 | 4 | 66 | 367 | 661 |

I'll use these details to find the shortest route that visits every location and returns to the office 0 while respecting each time window.

Also, when you send the route back, please follow this little JSON sketch for the answer format:

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

""solution"" is the ordered list of stops — start at the office, visit each family once, and return to the office at the end. The names there are just placeholders: office_id stands for the office/depot and family_id stands for each beneficiary address. The ""..."" is where all the other stops go. This is just the shape I need, not the actual route.

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': [[100, 79], [93, 21], [93, 27], [84, 85], [80, 0], [70, 5], [72, 42], [63, 59], [60, 100], [37, 11], [47, 37], [19, 46], [22, 47], [50, 99], [36, 82], [31, 59], [27, 97], [22, 97], [1, 29], [1, 40], [0, 40], [4, 66]], 'depot': 0, 'num_nodes': 22, 'time_windows': [[0, 1240], [273, 585], [78, 361], [179, 421], [165, 398], [11, 252], [434, 721], [435, 709], [140, 423], [198, 435], [289, 538], [279, 578], [68, 300], [352, 629], [26, 363], [26, 329], [443, 696], [64, 303], [136, 373], [312, 544], [229, 567], [367, 661]], 'tour_length': 646.0327585258808, 'objective': 646.0327585258808}","[0, 14, 17, 15, 12, 18, 9, 5, 4, 1, 2, 3, 8, 7, 6, 10, 11, 19, 20, 21, 16, 13, 0]",646.0327585258808,"{'problem_type': 'TSPTW', 'num_nodes': 22, 'nodes': [{'id': 0, 'x': 100, 'y': 79, 'tw_start': 0, 'tw_end': 1240}, {'id': 1, 'x': 93, 'y': 21, 'tw_start': 273, 'tw_end': 585}, {'id': 2, 'x': 93, 'y': 27, 'tw_start': 78, 'tw_end': 361}, {'id': 3, 'x': 84, 'y': 85, 'tw_start': 179, 'tw_end': 421}, {'id': 4, 'x': 80, 'y': 0, 'tw_start': 165, 'tw_end': 398}, {'id': 5, 'x': 70, 'y': 5, 'tw_start': 11, 'tw_end': 252}, {'id': 6, 'x': 72, 'y': 42, 'tw_start': 434, 'tw_end': 721}, {'id': 7, 'x': 63, 'y': 59, 'tw_start': 435, 'tw_end': 709}, {'id': 8, 'x': 60, 'y': 100, 'tw_start': 140, 'tw_end': 423}, {'id': 9, 'x': 37, 'y': 11, 'tw_start': 198, 'tw_end': 435}, {'id': 10, 'x': 47, 'y': 37, 'tw_start': 289, 'tw_end': 538}, {'id': 11, 'x': 19, 'y': 46, 'tw_start': 279, 'tw_end': 578}, {'id': 12, 'x': 22, 'y': 47, 'tw_start': 68, 'tw_end': 300}, {'id': 13, 'x': 50, 'y': 99, 'tw_start': 352, 'tw_end': 629}, {'id': 14, 'x': 36, 'y': 82, 'tw_start': 26, 'tw_end': 363}, {'id': 15, 'x': 31, 'y': 59, 'tw_start': 26, 'tw_end': 329}, {'id': 16, 'x': 27, 'y': 97, 'tw_start': 443, 'tw_end': 696}, {'id': 17, 'x': 22, 'y': 97, 'tw_start': 64, 'tw_end': 303}, {'id': 18, 'x': 1, 'y': 29, 'tw_start': 136, 'tw_end': 373}, {'id': 19, 'x': 1, 'y': 40, 'tw_start': 312, 'tw_end': 544}, {'id': 20, 'x': 0, 'y': 40, 'tw_start': 229, 'tw_end': 567}, {'id': 21, 'x': 4, 'y': 66, 'tw_start': 367, 'tw_end': 661}], 'depot': 0, 'objective': 646.0327585258808}","[0, 14, 17, 15, 12, 18, 9, 5, 4, 1, 2, 3, 8, 7, 6, 10, 11, 19, 20, 21, 16, 13, 0]",16,markdown_table,0
TSPTW,TSPTW,"We have a mobile groomer who needs to plan a day that starts and finishes at the shop, visits every booked client one time during that client’s appointment window, and is allowed to hang around if it gets there early. The choice to make is the visiting order; better orders are simply those where the total trip length (calculated by summing the distance between each pair of consecutive locations, including the legs from and back to the home base) is lower than other orders. The specific appointments and distances are listed below.

{
  ""total_locations_count"": 22,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""map_x_coordinate"": 99,
      ""map_y_coordinate"": 71,
      ""earliest_arrival_time"": 0,
      ""latest_arrival_time"": 1240
    },
    {
      ""location_id"": ""B"",
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 95,
      ""earliest_arrival_time"": 18,
      ""latest_arrival_time"": 353
    },
    {
      ""location_id"": ""C"",
      ""map_x_coordinate"": 12,
      ""map_y_coordinate"": 56,
      ""earliest_arrival_time"": 360,
      ""latest_arrival_time"": 618
    },
    {
      ""location_id"": ""D"",
      ""map_x_coordinate"": 44,
      ""map_y_coordinate"": 16,
      ""earliest_arrival_time"": 441,
      ""latest_arrival_time"": 735
    },
    {
      ""location_id"": ""E"",
      ""map_x_coordinate"": 33,
      ""map_y_coordinate"": 45,
      ""earliest_arrival_time"": 262,
      ""latest_arrival_time"": 572
    },
    {
      ""location_id"": ""F"",
      ""map_x_coordinate"": 34,
      ""map_y_coordinate"": 45,
      ""earliest_arrival_time"": 366,
      ""latest_arrival_time"": 665
    },
    {
      ""location_id"": ""G"",
      ""map_x_coordinate"": 1,
      ""map_y_coordinate"": 100,
      ""earliest_arrival_time"": 57,
      ""latest_arrival_time"": 321
    },
    {
      ""location_id"": ""H"",
      ""map_x_coordinate"": 36,
      ""map_y_coordinate"": 99,
      ""earliest_arrival_time"": 418,
      ""latest_arrival_time"": 669
    },
    {
      ""location_id"": ""I"",
      ""map_x_coordinate"": 96,
      ""map_y_coordinate"": 49,
      ""earliest_arrival_time"": 167,
      ""latest_arrival_time"": 442
    },
    {
      ""location_id"": ""J"",
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 49,
      ""earliest_arrival_time"": 198,
      ""latest_arrival_time"": 492
    },
    {
      ""location_id"": ""K"",
      ""map_x_coordinate"": 14,
      ""map_y_coordinate"": 100,
      ""earliest_arrival_time"": 425,
      ""latest_arrival_time"": 677
    },
    {
      ""location_id"": ""L"",
      ""map_x_coordinate"": 45,
      ""map_y_coordinate"": 25,
      ""earliest_arrival_time"": 54,
      ""latest_arrival_time"": 302
    },
    {
      ""location_id"": ""M"",
      ""map_x_coordinate"": 83,
      ""map_y_coordinate"": 30,
      ""earliest_arrival_time"": 400,
      ""latest_arrival_time"": 698
    },
    {
      ""location_id"": ""N"",
      ""map_x_coordinate"": 77,
      ""map_y_coordinate"": 21,
      ""earliest_arrival_time"": 128,
      ""latest_arrival_time"": 446
    },
    {
      ""location_id"": ""O"",
      ""map_x_coordinate"": 94,
      ""map_y_coordinate"": 35,
      ""earliest_arrival_time"": 388,
      ""latest_arrival_time"": 709
    },
    {
      ""location_id"": ""P"",
      ""map_x_coordinate"": 82,
      ""map_y_coordinate"": 37,
      ""earliest_arrival_time"": 414,
      ""latest_arrival_time"": 668
    },
    {
      ""location_id"": ""Q"",
      ""map_x_coordinate"": 36,
      ""map_y_coordinate"": 0,
      ""earliest_arrival_time"": 340,
      ""latest_arrival_time"": 617
    },
    {
      ""location_id"": ""R"",
      ""map_x_coordinate"": 97,
      ""map_y_coordinate"": 2,
      ""earliest_arrival_time"": 379,
      ""latest_arrival_time"": 687
    },
    {
      ""location_id"": ""S"",
      ""map_x_coordinate"": 63,
      ""map_y_coordinate"": 38,
      ""earliest_arrival_time"": 350,
      ""latest_arrival_time"": 649
    },
    {
      ""location_id"": ""T"",
      ""map_x_coordinate"": 86,
      ""map_y_coordinate"": 9,
      ""earliest_arrival_time"": 80,
      ""latest_arrival_time"": 366
    },
    {
      ""location_id"": ""U"",
      ""map_x_coordinate"": 92,
      ""map_y_coordinate"": 65,
      ""earliest_arrival_time"": 444,
      ""latest_arrival_time"": 775
    },
    {
      ""location_id"": ""V"",
      ""map_x_coordinate"": 97,
      ""map_y_coordinate"": 63,
      ""earliest_arrival_time"": 19,
      ""latest_arrival_time"": 263
    }
  ],
  ""home_shop_id"": ""A""
}

Also, when you send back the visiting order, just stick to a tiny JSON outline like this so it's easy to read and parse:

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

Think of that as a simple form: ""solution"" is the ordered list of stops (start at the shop, visit each client once, and return to the shop). The bits in the array are placeholders showing the shape I need — replace them with the actual identifiers from the instance. This is just a sketch of the expected shape, not the real answer.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[99, 71], [0, 95], [12, 56], [44, 16], [33, 45], [34, 45], [1, 100], [36, 99], [96, 49], [100, 49], [14, 100], [45, 25], [83, 30], [77, 21], [94, 35], [82, 37], [36, 0], [97, 2], [63, 38], [86, 9], [92, 65], [97, 63]], 'depot': 0, 'num_nodes': 22, 'time_windows': [[0, 1240], [18, 353], [360, 618], [441, 735], [262, 572], [366, 665], [57, 321], [418, 669], [167, 442], [198, 492], [425, 677], [54, 302], [400, 698], [128, 446], [388, 709], [414, 668], [340, 617], [379, 687], [350, 649], [80, 366], [444, 775], [19, 263]], 'tour_length': 608.6302689040499, 'objective': 608.6302689040499}","[0, 21, 11, 13, 19, 9, 8, 1, 6, 10, 7, 2, 4, 5, 16, 3, 18, 15, 12, 17, 14, 20, 0]",608.6302689040499,"{'problem_type': 'TSPTW', 'num_nodes': 22, 'nodes': [{'id': 'A', 'x': 99, 'y': 71, 'tw_start': 0, 'tw_end': 1240}, {'id': 'B', 'x': 0, 'y': 95, 'tw_start': 18, 'tw_end': 353}, {'id': 'C', 'x': 12, 'y': 56, 'tw_start': 360, 'tw_end': 618}, {'id': 'D', 'x': 44, 'y': 16, 'tw_start': 441, 'tw_end': 735}, {'id': 'E', 'x': 33, 'y': 45, 'tw_start': 262, 'tw_end': 572}, {'id': 'F', 'x': 34, 'y': 45, 'tw_start': 366, 'tw_end': 665}, {'id': 'G', 'x': 1, 'y': 100, 'tw_start': 57, 'tw_end': 321}, {'id': 'H', 'x': 36, 'y': 99, 'tw_start': 418, 'tw_end': 669}, {'id': 'I', 'x': 96, 'y': 49, 'tw_start': 167, 'tw_end': 442}, {'id': 'J', 'x': 100, 'y': 49, 'tw_start': 198, 'tw_end': 492}, {'id': 'K', 'x': 14, 'y': 100, 'tw_start': 425, 'tw_end': 677}, {'id': 'L', 'x': 45, 'y': 25, 'tw_start': 54, 'tw_end': 302}, {'id': 'M', 'x': 83, 'y': 30, 'tw_start': 400, 'tw_end': 698}, {'id': 'N', 'x': 77, 'y': 21, 'tw_start': 128, 'tw_end': 446}, {'id': 'O', 'x': 94, 'y': 35, 'tw_start': 388, 'tw_end': 709}, {'id': 'P', 'x': 82, 'y': 37, 'tw_start': 414, 'tw_end': 668}, {'id': 'Q', 'x': 36, 'y': 0, 'tw_start': 340, 'tw_end': 617}, {'id': 'R', 'x': 97, 'y': 2, 'tw_start': 379, 'tw_end': 687}, {'id': 'S', 'x': 63, 'y': 38, 'tw_start': 350, 'tw_end': 649}, {'id': 'T', 'x': 86, 'y': 9, 'tw_start': 80, 'tw_end': 366}, {'id': 'U', 'x': 92, 'y': 65, 'tw_start': 444, 'tw_end': 775}, {'id': 'V', 'x': 97, 'y': 63, 'tw_start': 19, 'tw_end': 263}], 'depot': 'A', 'objective': 608.6302689040499}","['A', 'V', 'L', 'N', 'T', 'J', 'I', 'B', 'G', 'K', 'H', 'C', 'E', 'F', 'Q', 'D', 'S', 'P', 'M', 'R', 'O', 'U', 'A']",17,json,names
TSPTW,TSPTW,"On a Monday morning a field rep sets out from the regional office, needs to visit every client one time while each is open for visits, and must end the day back at the office. The simplest way to judge different schedules is by total distance driven — just add up the length of each leg between stops and the trip home, and the plan with the lowest total is preferred. It’s fine to wait until a client’s window opens, but skipping or repeating visits isn’t allowed. The concrete list of stops, windows and distances is provided below.

It includes 19 locations in total, with the regional office recorded as A.
Location A at coordinates (0, 35) is available for visits from 0 to 1067.
Location B at coordinates (2, 42) is available for visits from 386 to 616.
Location C at coordinates (4, 12) is available for visits from 174 to 438.
Location D at coordinates (9, 17) is available for visits from 343 to 595.
Location E at coordinates (10, 74) is available for visits from 151 to 385.
Location F at coordinates (10, 10) is available for visits from 269 to 464.
Location G at coordinates (16, 11) is available for visits from 240 to 468.
Location H at coordinates (18, 0) is available for visits from 308 to 511.
Location I at coordinates (28, 3) is available for visits from 228 to 468.
Location J at coordinates (36, 26) is available for visits from 249 to 449.
Location K at coordinates (36, 29) is available for visits from 225 to 473.
Location L at coordinates (41, 78) is available for visits from 217 to 470.
Location M at coordinates (47, 21) is available for visits from 262 to 534.
Location N at coordinates (49, 100) is available for visits from 104 to 378.
Location O at coordinates (60, 44) is available for visits from 193 to 394.
Location P at coordinates (61, 78) is available for visits from 22 to 249.
Location Q at coordinates (63, 8) is available for visits from 304 to 567.
Location R at coordinates (80, 34) is available for visits from 305 to 550.
Location S at coordinates (100, 90) is available for visits from 170 to 379.
The field rep must start and finish at A and visit all 19 locations within their time windows.

Also, if you want to hand the route back to me in a machine-friendly way, a little JSON snippet like this is perfect — nothing fancy, just the sequence of stops from the office and back:

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

Pretty straightforward: the solution array is the visit order, starting at the office, listing each client once in the order you’ll visit them, and finishing back at the office. Think of each placeholder as “put the exact ID for that stop here.”

This is just a sketch of the shape I expect, not the actual route — please fill it in with the real identifiers from the instance.

Please be careful to use the identifiers exactly as they appear in the instance input — no renaming and no inventing 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, 35], [2, 42], [4, 12], [9, 17], [10, 74], [10, 10], [16, 11], [18, 0], [28, 3], [36, 26], [36, 29], [41, 78], [47, 21], [49, 100], [60, 44], [61, 78], [63, 8], [80, 34], [100, 90]], 'depot': 0, 'num_nodes': 19, 'time_windows': [[0, 1067], [386, 616], [174, 438], [343, 595], [151, 385], [269, 464], [240, 468], [308, 511], [228, 468], [249, 449], [225, 473], [217, 470], [262, 534], [104, 378], [193, 394], [22, 249], [304, 567], [305, 550], [170, 379]], 'tour_length': 466.9438645163762, 'objective': 466.9438645163762}","[0, 4, 13, 11, 15, 18, 17, 14, 10, 9, 3, 2, 5, 6, 7, 8, 16, 12, 1, 0]",466.9438645163762,"{'problem_type': 'TSPTW', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 0, 'y': 35, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 2, 'y': 42, 'tw_start': 386, 'tw_end': 616}, {'id': 'C', 'x': 4, 'y': 12, 'tw_start': 174, 'tw_end': 438}, {'id': 'D', 'x': 9, 'y': 17, 'tw_start': 343, 'tw_end': 595}, {'id': 'E', 'x': 10, 'y': 74, 'tw_start': 151, 'tw_end': 385}, {'id': 'F', 'x': 10, 'y': 10, 'tw_start': 269, 'tw_end': 464}, {'id': 'G', 'x': 16, 'y': 11, 'tw_start': 240, 'tw_end': 468}, {'id': 'H', 'x': 18, 'y': 0, 'tw_start': 308, 'tw_end': 511}, {'id': 'I', 'x': 28, 'y': 3, 'tw_start': 228, 'tw_end': 468}, {'id': 'J', 'x': 36, 'y': 26, 'tw_start': 249, 'tw_end': 449}, {'id': 'K', 'x': 36, 'y': 29, 'tw_start': 225, 'tw_end': 473}, {'id': 'L', 'x': 41, 'y': 78, 'tw_start': 217, 'tw_end': 470}, {'id': 'M', 'x': 47, 'y': 21, 'tw_start': 262, 'tw_end': 534}, {'id': 'N', 'x': 49, 'y': 100, 'tw_start': 104, 'tw_end': 378}, {'id': 'O', 'x': 60, 'y': 44, 'tw_start': 193, 'tw_end': 394}, {'id': 'P', 'x': 61, 'y': 78, 'tw_start': 22, 'tw_end': 249}, {'id': 'Q', 'x': 63, 'y': 8, 'tw_start': 304, 'tw_end': 567}, {'id': 'R', 'x': 80, 'y': 34, 'tw_start': 305, 'tw_end': 550}, {'id': 'S', 'x': 100, 'y': 90, 'tw_start': 170, 'tw_end': 379}], 'depot': 'A', 'objective': 466.9438645163762}","['A', 'E', 'N', 'L', 'P', 'S', 'R', 'O', 'K', 'J', 'D', 'C', 'F', 'G', 'H', 'I', 'Q', 'M', 'B', 'A']",18,nl,names
TSPTW,TSPTW,"Many people on the logistics team are focused on one simple problem: build a route that leaves the warehouse, visits every delivery address once during its assigned time slot, and returns to the warehouse while keeping total travel distance as low as possible. You evaluate any candidate route by summing the distances between each pair of consecutive stops (including the start and finish at the warehouse); the smaller that sum, the better. Waiting before a window opens is allowed, but repeating a stop or leaving one out isn’t. The detailed list of stops and windows is shown below.

{
  ""total_stops_including_warehouse"": 21,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coordinate"": 78,
      ""y_coordinate"": 0,
      ""earliest_delivery_time"": 0,
      ""latest_delivery_time"": 1240
    },
    {
      ""location_id"": ""B"",
      ""x_coordinate"": 23,
      ""y_coordinate"": 6,
      ""earliest_delivery_time"": 124,
      ""latest_delivery_time"": 461
    },
    {
      ""location_id"": ""C"",
      ""x_coordinate"": 20,
      ""y_coordinate"": 12,
      ""earliest_delivery_time"": 63,
      ""latest_delivery_time"": 311
    },
    {
      ""location_id"": ""D"",
      ""x_coordinate"": 27,
      ""y_coordinate"": 14,
      ""earliest_delivery_time"": 83,
      ""latest_delivery_time"": 409
    },
    {
      ""location_id"": ""E"",
      ""x_coordinate"": 20,
      ""y_coordinate"": 29,
      ""earliest_delivery_time"": 295,
      ""latest_delivery_time"": 537
    },
    {
      ""location_id"": ""F"",
      ""x_coordinate"": 35,
      ""y_coordinate"": 31,
      ""earliest_delivery_time"": 198,
      ""latest_delivery_time"": 493
    },
    {
      ""location_id"": ""G"",
      ""x_coordinate"": 72,
      ""y_coordinate"": 40,
      ""earliest_delivery_time"": 37,
      ""latest_delivery_time"": 362
    },
    {
      ""location_id"": ""H"",
      ""x_coordinate"": 55,
      ""y_coordinate"": 45,
      ""earliest_delivery_time"": 362,
      ""latest_delivery_time"": 644
    },
    {
      ""location_id"": ""I"",
      ""x_coordinate"": 61,
      ""y_coordinate"": 51,
      ""earliest_delivery_time"": 436,
      ""latest_delivery_time"": 708
    },
    {
      ""location_id"": ""J"",
      ""x_coordinate"": 47,
      ""y_coordinate"": 57,
      ""earliest_delivery_time"": 443,
      ""latest_delivery_time"": 744
    },
    {
      ""location_id"": ""K"",
      ""x_coordinate"": 57,
      ""y_coordinate"": 65,
      ""earliest_delivery_time"": 286,
      ""latest_delivery_time"": 530
    },
    {
      ""location_id"": ""L"",
      ""x_coordinate"": 38,
      ""y_coordinate"": 66,
      ""earliest_delivery_time"": 397,
      ""latest_delivery_time"": 671
    },
    {
      ""location_id"": ""M"",
      ""x_coordinate"": 63,
      ""y_coordinate"": 78,
      ""earliest_delivery_time"": 73,
      ""latest_delivery_time"": 300
    },
    {
      ""location_id"": ""N"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 86,
      ""earliest_delivery_time"": 252,
      ""latest_delivery_time"": 537
    },
    {
      ""location_id"": ""O"",
      ""x_coordinate"": 95,
      ""y_coordinate"": 87,
      ""earliest_delivery_time"": 324,
      ""latest_delivery_time"": 650
    },
    {
      ""location_id"": ""P"",
      ""x_coordinate"": 50,
      ""y_coordinate"": 90,
      ""earliest_delivery_time"": 35,
      ""latest_delivery_time"": 343
    },
    {
      ""location_id"": ""Q"",
      ""x_coordinate"": 63,
      ""y_coordinate"": 91,
      ""earliest_delivery_time"": 84,
      ""latest_delivery_time"": 406
    },
    {
      ""location_id"": ""R"",
      ""x_coordinate"": 77,
      ""y_coordinate"": 92,
      ""earliest_delivery_time"": 369,
      ""latest_delivery_time"": 655
    },
    {
      ""location_id"": ""S"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 92,
      ""earliest_delivery_time"": 320,
      ""latest_delivery_time"": 581
    },
    {
      ""location_id"": ""T"",
      ""x_coordinate"": 33,
      ""y_coordinate"": 96,
      ""earliest_delivery_time"": 212,
      ""latest_delivery_time"": 530
    },
    {
      ""location_id"": ""U"",
      ""x_coordinate"": 13,
      ""y_coordinate"": 100,
      ""earliest_delivery_time"": 207,
      ""latest_delivery_time"": 472
    }
  ],
  ""warehouse_node_id"": ""A""
}

Also, when you give me the final route, please use this simple JSON shape so it's easy to parse:

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

Think of that as a little form: the first item is the warehouse where the truck leaves from, the middle items are the delivery addresses in the exact order you visit them, and the last item is the warehouse again (you come back at the end). This is just a sketch of the shape I expect — not the actual route.

Please be sure to use the identifiers exactly as they appear in the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[78, 0], [23, 6], [20, 12], [27, 14], [20, 29], [35, 31], [72, 40], [55, 45], [61, 51], [47, 57], [57, 65], [38, 66], [63, 78], [100, 86], [95, 87], [50, 90], [63, 91], [77, 92], [0, 92], [33, 96], [13, 100]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [124, 461], [63, 311], [83, 409], [295, 537], [198, 493], [37, 362], [362, 644], [436, 708], [443, 744], [286, 530], [397, 671], [73, 300], [252, 537], [324, 650], [35, 343], [84, 406], [369, 655], [320, 581], [212, 530], [207, 472]], 'tour_length': 541.4377842115626, 'objective': 541.4377842115626}","[0, 6, 12, 16, 15, 5, 3, 1, 2, 4, 18, 20, 19, 17, 14, 13, 10, 11, 9, 8, 7, 0]",541.4377842115626,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 'A', 'x': 78, 'y': 0, 'tw_start': 0, 'tw_end': 1240}, {'id': 'B', 'x': 23, 'y': 6, 'tw_start': 124, 'tw_end': 461}, {'id': 'C', 'x': 20, 'y': 12, 'tw_start': 63, 'tw_end': 311}, {'id': 'D', 'x': 27, 'y': 14, 'tw_start': 83, 'tw_end': 409}, {'id': 'E', 'x': 20, 'y': 29, 'tw_start': 295, 'tw_end': 537}, {'id': 'F', 'x': 35, 'y': 31, 'tw_start': 198, 'tw_end': 493}, {'id': 'G', 'x': 72, 'y': 40, 'tw_start': 37, 'tw_end': 362}, {'id': 'H', 'x': 55, 'y': 45, 'tw_start': 362, 'tw_end': 644}, {'id': 'I', 'x': 61, 'y': 51, 'tw_start': 436, 'tw_end': 708}, {'id': 'J', 'x': 47, 'y': 57, 'tw_start': 443, 'tw_end': 744}, {'id': 'K', 'x': 57, 'y': 65, 'tw_start': 286, 'tw_end': 530}, {'id': 'L', 'x': 38, 'y': 66, 'tw_start': 397, 'tw_end': 671}, {'id': 'M', 'x': 63, 'y': 78, 'tw_start': 73, 'tw_end': 300}, {'id': 'N', 'x': 100, 'y': 86, 'tw_start': 252, 'tw_end': 537}, {'id': 'O', 'x': 95, 'y': 87, 'tw_start': 324, 'tw_end': 650}, {'id': 'P', 'x': 50, 'y': 90, 'tw_start': 35, 'tw_end': 343}, {'id': 'Q', 'x': 63, 'y': 91, 'tw_start': 84, 'tw_end': 406}, {'id': 'R', 'x': 77, 'y': 92, 'tw_start': 369, 'tw_end': 655}, {'id': 'S', 'x': 0, 'y': 92, 'tw_start': 320, 'tw_end': 581}, {'id': 'T', 'x': 33, 'y': 96, 'tw_start': 212, 'tw_end': 530}, {'id': 'U', 'x': 13, 'y': 100, 'tw_start': 207, 'tw_end': 472}], 'depot': 'A', 'objective': 541.4377842115626}","['A', 'G', 'M', 'Q', 'P', 'F', 'D', 'B', 'C', 'E', 'S', 'U', 'T', 'R', 'O', 'N', 'K', 'L', 'J', 'I', 'H', 'A']",19,json,names
TSPTW,TSPTW,"On a typical morning a community health worker straps on a GPS and a schedule: leave the clinic, visit each household once during its allotted appointment window (it’s acceptable to wait if arriving ahead of time), and return to the clinic at day’s end. The practical question is how to arrange the stops so the total miles driven are as small as possible — calculate that by adding every leg of the trip, from clinic to first house, between houses, and back to the clinic; the route with the lowest sum is preferable. No household can be missed or visited more than once, and every visit must fall inside its planned window. The concrete details will be shown below.

{
  ""total_locations_including_clinic"": 18,
  ""nodes"": [
    {
      ""household_node_id"": 0,
      ""x_coordinate_map"": 68,
      ""y_coordinate_map"": 69,
      ""visit_window_start_time"": 0,
      ""visit_window_end_time"": 1067
    },
    {
      ""household_node_id"": 1,
      ""x_coordinate_map"": 42,
      ""y_coordinate_map"": 83,
      ""visit_window_start_time"": 191,
      ""visit_window_end_time"": 466
    },
    {
      ""household_node_id"": 2,
      ""x_coordinate_map"": 5,
      ""y_coordinate_map"": 72,
      ""visit_window_start_time"": 130,
      ""visit_window_end_time"": 340
    },
    {
      ""household_node_id"": 3,
      ""x_coordinate_map"": 20,
      ""y_coordinate_map"": 68,
      ""visit_window_start_time"": 276,
      ""visit_window_end_time"": 550
    },
    {
      ""household_node_id"": 4,
      ""x_coordinate_map"": 92,
      ""y_coordinate_map"": 47,
      ""visit_window_start_time"": 39,
      ""visit_window_end_time"": 256
    },
    {
      ""household_node_id"": 5,
      ""x_coordinate_map"": 100,
      ""y_coordinate_map"": 26,
      ""visit_window_start_time"": 55,
      ""visit_window_end_time"": 282
    },
    {
      ""household_node_id"": 6,
      ""x_coordinate_map"": 38,
      ""y_coordinate_map"": 17,
      ""visit_window_start_time"": 174,
      ""visit_window_end_time"": 441
    },
    {
      ""household_node_id"": 7,
      ""x_coordinate_map"": 25,
      ""y_coordinate_map"": 35,
      ""visit_window_start_time"": 252,
      ""visit_window_end_time"": 506
    },
    {
      ""household_node_id"": 8,
      ""x_coordinate_map"": 0,
      ""y_coordinate_map"": 100,
      ""visit_window_start_time"": 136,
      ""visit_window_end_time"": 412
    },
    {
      ""household_node_id"": 9,
      ""x_coordinate_map"": 18,
      ""y_coordinate_map"": 100,
      ""visit_window_start_time"": 182,
      ""visit_window_end_time"": 471
    },
    {
      ""household_node_id"": 10,
      ""x_coordinate_map"": 36,
      ""y_coordinate_map"": 53,
      ""visit_window_start_time"": 246,
      ""visit_window_end_time"": 452
    },
    {
      ""household_node_id"": 11,
      ""x_coordinate_map"": 5,
      ""y_coordinate_map"": 98,
      ""visit_window_start_time"": 262,
      ""visit_window_end_time"": 487
    },
    {
      ""household_node_id"": 12,
      ""x_coordinate_map"": 88,
      ""y_coordinate_map"": 88,
      ""visit_window_start_time"": 266,
      ""visit_window_end_time"": 467
    },
    {
      ""household_node_id"": 13,
      ""x_coordinate_map"": 73,
      ""y_coordinate_map"": 0,
      ""visit_window_start_time"": 67,
      ""visit_window_end_time"": 344
    },
    {
      ""household_node_id"": 14,
      ""x_coordinate_map"": 31,
      ""y_coordinate_map"": 66,
      ""visit_window_start_time"": 88,
      ""visit_window_end_time"": 363
    },
    {
      ""household_node_id"": 15,
      ""x_coordinate_map"": 91,
      ""y_coordinate_map"": 27,
      ""visit_window_start_time"": 108,
      ""visit_window_end_time"": 364
    },
    {
      ""household_node_id"": 16,
      ""x_coordinate_map"": 55,
      ""y_coordinate_map"": 56,
      ""visit_window_start_time"": 269,
      ""visit_window_end_time"": 513
    },
    {
      ""household_node_id"": 17,
      ""x_coordinate_map"": 88,
      ""y_coordinate_map"": 52,
      ""visit_window_start_time"": 118,
      ""visit_window_end_time"": 333
    }
  ],
  ""clinic_node_id"": 0
}

When you send the route back, just stick to a tiny JSON layout so it's easy to read and machine-friendly. Something like this will do:

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

This shows the visit order: start at the clinic, go to each household in the listed sequence (you can wait if you arrive early), and finish back at the clinic. It's just a sketch of the shape I expect — not the actual route yet.

Please make sure you use the exact identifiers from the instance input, without renaming or inventing 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': [[68, 69], [42, 83], [5, 72], [20, 68], [92, 47], [100, 26], [38, 17], [25, 35], [0, 100], [18, 100], [36, 53], [5, 98], [88, 88], [73, 0], [31, 66], [91, 27], [55, 56], [88, 52]], 'depot': 0, 'num_nodes': 18, 'time_windows': [[0, 1067], [191, 466], [130, 340], [276, 550], [39, 256], [55, 282], [174, 441], [252, 506], [136, 412], [182, 471], [246, 452], [262, 487], [266, 467], [67, 344], [88, 363], [108, 364], [269, 513], [118, 333]], 'tour_length': 399.38334280985515, 'objective': 399.38334280985515}","[0, 17, 4, 5, 15, 13, 6, 7, 10, 14, 3, 2, 8, 11, 9, 1, 16, 12, 0]",399.38334280985515,"{'problem_type': 'TSPTW', 'num_nodes': 18, 'nodes': [{'id': 0, 'x': 68, 'y': 69, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 42, 'y': 83, 'tw_start': 191, 'tw_end': 466}, {'id': 2, 'x': 5, 'y': 72, 'tw_start': 130, 'tw_end': 340}, {'id': 3, 'x': 20, 'y': 68, 'tw_start': 276, 'tw_end': 550}, {'id': 4, 'x': 92, 'y': 47, 'tw_start': 39, 'tw_end': 256}, {'id': 5, 'x': 100, 'y': 26, 'tw_start': 55, 'tw_end': 282}, {'id': 6, 'x': 38, 'y': 17, 'tw_start': 174, 'tw_end': 441}, {'id': 7, 'x': 25, 'y': 35, 'tw_start': 252, 'tw_end': 506}, {'id': 8, 'x': 0, 'y': 100, 'tw_start': 136, 'tw_end': 412}, {'id': 9, 'x': 18, 'y': 100, 'tw_start': 182, 'tw_end': 471}, {'id': 10, 'x': 36, 'y': 53, 'tw_start': 246, 'tw_end': 452}, {'id': 11, 'x': 5, 'y': 98, 'tw_start': 262, 'tw_end': 487}, {'id': 12, 'x': 88, 'y': 88, 'tw_start': 266, 'tw_end': 467}, {'id': 13, 'x': 73, 'y': 0, 'tw_start': 67, 'tw_end': 344}, {'id': 14, 'x': 31, 'y': 66, 'tw_start': 88, 'tw_end': 363}, {'id': 15, 'x': 91, 'y': 27, 'tw_start': 108, 'tw_end': 364}, {'id': 16, 'x': 55, 'y': 56, 'tw_start': 269, 'tw_end': 513}, {'id': 17, 'x': 88, 'y': 52, 'tw_start': 118, 'tw_end': 333}], 'depot': 0, 'objective': 399.38334280985515}","[0, 17, 4, 5, 15, 13, 6, 7, 10, 14, 3, 2, 8, 11, 9, 1, 16, 12, 0]",20,json,0
TSPTW,TSPTW,"Many mornings the challenge is the same: leave the oven, pop into every cafe on the list once while they’re open, and return to the oven, all while keeping the odometer reading as low as possible. The best route is the one with the smallest total miles — calculated by summing every driving leg from one stop to the next and including the trips from and back to the oven. It’s okay to wait for an opening, but each cafe must be visited exactly one time. Exact locations, time windows and mileages follow below.

{
  ""total_stops_including_oven"": 16,
  ""nodes"": [
    {
      ""stop_id"": 1,
      ""map_x_coord"": 0,
      ""map_y_coord"": 42,
      ""opening_time"": 0,
      ""closing_time"": 1067
    },
    {
      ""stop_id"": 2,
      ""map_x_coord"": 8,
      ""map_y_coord"": 19,
      ""opening_time"": 12,
      ""closing_time"": 236
    },
    {
      ""stop_id"": 3,
      ""map_x_coord"": 9,
      ""map_y_coord"": 100,
      ""opening_time"": 253,
      ""closing_time"": 538
    },
    {
      ""stop_id"": 4,
      ""map_x_coord"": 13,
      ""map_y_coord"": 42,
      ""opening_time"": 338,
      ""closing_time"": 606
    },
    {
      ""stop_id"": 5,
      ""map_x_coord"": 18,
      ""map_y_coord"": 44,
      ""opening_time"": 305,
      ""closing_time"": 564
    },
    {
      ""stop_id"": 6,
      ""map_x_coord"": 23,
      ""map_y_coord"": 3,
      ""opening_time"": 100,
      ""closing_time"": 382
    },
    {
      ""stop_id"": 7,
      ""map_x_coord"": 31,
      ""map_y_coord"": 42,
      ""opening_time"": 260,
      ""closing_time"": 508
    },
    {
      ""stop_id"": 8,
      ""map_x_coord"": 50,
      ""map_y_coord"": 44,
      ""opening_time"": 43,
      ""closing_time"": 280
    },
    {
      ""stop_id"": 9,
      ""map_x_coord"": 50,
      ""map_y_coord"": 30,
      ""opening_time"": 178,
      ""closing_time"": 456
    },
    {
      ""stop_id"": 10,
      ""map_x_coord"": 50,
      ""map_y_coord"": 12,
      ""opening_time"": 212,
      ""closing_time"": 442
    },
    {
      ""stop_id"": 11,
      ""map_x_coord"": 53,
      ""map_y_coord"": 30,
      ""opening_time"": 378,
      ""closing_time"": 583
    },
    {
      ""stop_id"": 12,
      ""map_x_coord"": 59,
      ""map_y_coord"": 30,
      ""opening_time"": 163,
      ""closing_time"": 362
    },
    {
      ""stop_id"": 13,
      ""map_x_coord"": 64,
      ""map_y_coord"": 3,
      ""opening_time"": 287,
      ""closing_time"": 570
    },
    {
      ""stop_id"": 14,
      ""map_x_coord"": 86,
      ""map_y_coord"": 51,
      ""opening_time"": 108,
      ""closing_time"": 385
    },
    {
      ""stop_id"": 15,
      ""map_x_coord"": 93,
      ""map_y_coord"": 0,
      ""opening_time"": 113,
      ""closing_time"": 395
    },
    {
      ""stop_id"": 16,
      ""map_x_coord"": 100,
      ""map_y_coord"": 94,
      ""opening_time"": 292,
      ""closing_time"": 564
    }
  ],
  ""oven_node_id"": 1
}

Oh, and when you send the actual route back, please use a little JSON snippet like this — just a tidy list that starts and ends at the oven:

{
  ""solution"": [oven_id, cafe_id, ..., oven_id]
}

Think of ""solution"" as the ordered list of stops: the first item is the oven, then every cafe exactly once in the order you’ll visit them, and then the oven again to finish. It’s just a simple checklist, not the final answer — a sketch of the shape I’m expecting.

Please 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”.","{'coordinates': [[0, 42], [8, 19], [9, 100], [13, 42], [18, 44], [23, 3], [31, 42], [50, 44], [50, 30], [50, 12], [53, 30], [59, 30], [64, 3], [86, 51], [93, 0], [100, 94]], 'depot': 0, 'num_nodes': 16, 'time_windows': [[0, 1067], [12, 236], [253, 538], [338, 606], [305, 564], [100, 382], [260, 508], [43, 280], [178, 456], [212, 442], [378, 583], [163, 362], [287, 570], [108, 385], [113, 395], [292, 564]], 'tour_length': 542.8016930302134, 'objective': 542.8016930302134}","[0, 1, 5, 14, 11, 7, 15, 13, 12, 9, 10, 8, 6, 4, 3, 2, 0]",542.8016930302134,"{'problem_type': 'TSPTW', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 0, 'y': 42, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 8, 'y': 19, 'tw_start': 12, 'tw_end': 236}, {'id': 3, 'x': 9, 'y': 100, 'tw_start': 253, 'tw_end': 538}, {'id': 4, 'x': 13, 'y': 42, 'tw_start': 338, 'tw_end': 606}, {'id': 5, 'x': 18, 'y': 44, 'tw_start': 305, 'tw_end': 564}, {'id': 6, 'x': 23, 'y': 3, 'tw_start': 100, 'tw_end': 382}, {'id': 7, 'x': 31, 'y': 42, 'tw_start': 260, 'tw_end': 508}, {'id': 8, 'x': 50, 'y': 44, 'tw_start': 43, 'tw_end': 280}, {'id': 9, 'x': 50, 'y': 30, 'tw_start': 178, 'tw_end': 456}, {'id': 10, 'x': 50, 'y': 12, 'tw_start': 212, 'tw_end': 442}, {'id': 11, 'x': 53, 'y': 30, 'tw_start': 378, 'tw_end': 583}, {'id': 12, 'x': 59, 'y': 30, 'tw_start': 163, 'tw_end': 362}, {'id': 13, 'x': 64, 'y': 3, 'tw_start': 287, 'tw_end': 570}, {'id': 14, 'x': 86, 'y': 51, 'tw_start': 108, 'tw_end': 385}, {'id': 15, 'x': 93, 'y': 0, 'tw_start': 113, 'tw_end': 395}, {'id': 16, 'x': 100, 'y': 94, 'tw_start': 292, 'tw_end': 564}], 'depot': 1, 'objective': 542.8016930302134}","[1, 2, 6, 15, 12, 8, 16, 14, 13, 10, 11, 9, 7, 5, 4, 3, 1]",21,json,1
TSPTW,TSPTW,"Out in the field the situation is straightforward: a technician drives out from the depot, visits a set of ATMs exactly one time each within their service windows, and finishes the loop back at the depot. The question is how to order and time the visits so every ATM is covered once, no visit falls outside its allowed time, and the whole trip is as short as possible — measure that by summing up the distance of every leg of the route. Waiting for a window to open is allowed. The concrete details are below.

# total_locations=19
# depot_node_id=A
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,service_window_start,service_window_end
A,0,16,0,1067
B,22,56,6,294
C,25,100,281,505
D,43,87,321,543
E,51,82,338,543
F,91,81,273,519
G,72,72,37,254
H,52,68,4,244
I,79,45,116,368
J,47,44,115,338
K,98,19,288,487
L,89,17,350,626
M,42,17,259,510
N,50,7,346,558
O,76,6,30,247
P,100,6,308,505
Q,97,4,226,516
R,83,4,332,576
S,89,0,24,299

Just toss the answer back in a tiny JSON object like this so it's easy to parse:

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

This little block means: the ""solution"" field carries the route as an ordered list that starts at the depot, visits each ATM exactly once (in the order shown), and finishes at the depot again. Think of it as the simple form you fill in with the place IDs — it's just the shape I expect, not the real route.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. 
- For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 16], [22, 56], [25, 100], [43, 87], [51, 82], [91, 81], [72, 72], [52, 68], [79, 45], [47, 44], [98, 19], [89, 17], [42, 17], [50, 7], [76, 6], [100, 6], [97, 4], [83, 4], [89, 0]], 'depot': 0, 'num_nodes': 19, 'time_windows': [[0, 1067], [6, 294], [281, 505], [321, 543], [338, 543], [273, 519], [37, 254], [4, 244], [116, 368], [115, 338], [288, 487], [350, 626], [259, 510], [346, 558], [30, 247], [308, 505], [226, 516], [332, 576], [24, 299]], 'tour_length': 637.2325787763588, 'objective': 637.2325787763588}","[0, 1, 7, 6, 8, 18, 14, 12, 9, 2, 3, 4, 5, 10, 15, 16, 17, 13, 11, 0]",637.2325787763588,"{'problem_type': 'TSPTW', 'num_nodes': 19, 'nodes': [{'id': 'A', 'x': 0, 'y': 16, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 22, 'y': 56, 'tw_start': 6, 'tw_end': 294}, {'id': 'C', 'x': 25, 'y': 100, 'tw_start': 281, 'tw_end': 505}, {'id': 'D', 'x': 43, 'y': 87, 'tw_start': 321, 'tw_end': 543}, {'id': 'E', 'x': 51, 'y': 82, 'tw_start': 338, 'tw_end': 543}, {'id': 'F', 'x': 91, 'y': 81, 'tw_start': 273, 'tw_end': 519}, {'id': 'G', 'x': 72, 'y': 72, 'tw_start': 37, 'tw_end': 254}, {'id': 'H', 'x': 52, 'y': 68, 'tw_start': 4, 'tw_end': 244}, {'id': 'I', 'x': 79, 'y': 45, 'tw_start': 116, 'tw_end': 368}, {'id': 'J', 'x': 47, 'y': 44, 'tw_start': 115, 'tw_end': 338}, {'id': 'K', 'x': 98, 'y': 19, 'tw_start': 288, 'tw_end': 487}, {'id': 'L', 'x': 89, 'y': 17, 'tw_start': 350, 'tw_end': 626}, {'id': 'M', 'x': 42, 'y': 17, 'tw_start': 259, 'tw_end': 510}, {'id': 'N', 'x': 50, 'y': 7, 'tw_start': 346, 'tw_end': 558}, {'id': 'O', 'x': 76, 'y': 6, 'tw_start': 30, 'tw_end': 247}, {'id': 'P', 'x': 100, 'y': 6, 'tw_start': 308, 'tw_end': 505}, {'id': 'Q', 'x': 97, 'y': 4, 'tw_start': 226, 'tw_end': 516}, {'id': 'R', 'x': 83, 'y': 4, 'tw_start': 332, 'tw_end': 576}, {'id': 'S', 'x': 89, 'y': 0, 'tw_start': 24, 'tw_end': 299}], 'depot': 'A', 'objective': 637.2325787763588}","['A', 'B', 'H', 'G', 'I', 'S', 'O', 'M', 'J', 'C', 'D', 'E', 'F', 'K', 'P', 'Q', 'R', 'N', 'L', 'A']",22,csv,names
TSPTW,TSPTW,"We need to plan a route for a visiting nurse who starts and finishes at the clinic, visits each patient’s home one time only during that patient’s availability window, and can wait if she gets there early. The better plan is simply the one with the smallest total driving distance, calculated by summing the distance between each consecutive stop plus the return leg to the clinic. The concrete patient times and locations are shown below.

There are 17 locations in total and the clinic is node 1.

| location_node_id | map_x_coordinate | map_y_coordinate | availability_start_time | availability_end_time |
|---|---|---|---|---|
| 1 | 68 | 7 | 0 | 1067 |
| 2 | 95 | 0 | 46 | 281 |
| 3 | 83 | 18 | 291 | 492 |
| 4 | 75 | 22 | 31 | 259 |
| 5 | 43 | 20 | 365 | 624 |
| 6 | 87 | 35 | 263 | 492 |
| 7 | 26 | 39 | 230 | 425 |
| 8 | 0 | 54 | 246 | 529 |
| 9 | 61 | 58 | 237 | 516 |
| 10 | 80 | 74 | 280 | 486 |
| 11 | 30 | 82 | 350 | 550 |
| 12 | 49 | 88 | 207 | 414 |
| 13 | 48 | 88 | 4 | 239 |
| 14 | 100 | 96 | 114 | 355 |
| 15 | 68 | 98 | 223 | 422 |
| 16 | 42 | 100 | 47 | 295 |
| 17 | 40 | 94 | 133 | 397 |

We will minimize total driving distance for a tour that starts and ends at clinic 1.

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

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

Think of that array as the ordered stops: start at the clinic, list each patient’s identifier in the order they should be visited (one time each), and finish back at the clinic. This is just a sketch of the shape I expect — don’t treat the example values as the actual answer.

Please make sure to 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”.","{'coordinates': [[68, 7], [95, 0], [83, 18], [75, 22], [43, 20], [87, 35], [26, 39], [0, 54], [61, 58], [80, 74], [30, 82], [49, 88], [48, 88], [100, 96], [68, 98], [42, 100], [40, 94]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [46, 281], [291, 492], [31, 259], [365, 624], [263, 492], [230, 425], [246, 529], [237, 516], [280, 486], [350, 550], [207, 414], [4, 239], [114, 355], [223, 422], [47, 295], [133, 397]], 'tour_length': 541.9600203006103, 'objective': 541.9600203006103}","[0, 1, 3, 13, 11, 12, 16, 15, 14, 9, 5, 2, 4, 6, 7, 10, 8, 0]",541.9600203006103,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 68, 'y': 7, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 95, 'y': 0, 'tw_start': 46, 'tw_end': 281}, {'id': 3, 'x': 83, 'y': 18, 'tw_start': 291, 'tw_end': 492}, {'id': 4, 'x': 75, 'y': 22, 'tw_start': 31, 'tw_end': 259}, {'id': 5, 'x': 43, 'y': 20, 'tw_start': 365, 'tw_end': 624}, {'id': 6, 'x': 87, 'y': 35, 'tw_start': 263, 'tw_end': 492}, {'id': 7, 'x': 26, 'y': 39, 'tw_start': 230, 'tw_end': 425}, {'id': 8, 'x': 0, 'y': 54, 'tw_start': 246, 'tw_end': 529}, {'id': 9, 'x': 61, 'y': 58, 'tw_start': 237, 'tw_end': 516}, {'id': 10, 'x': 80, 'y': 74, 'tw_start': 280, 'tw_end': 486}, {'id': 11, 'x': 30, 'y': 82, 'tw_start': 350, 'tw_end': 550}, {'id': 12, 'x': 49, 'y': 88, 'tw_start': 207, 'tw_end': 414}, {'id': 13, 'x': 48, 'y': 88, 'tw_start': 4, 'tw_end': 239}, {'id': 14, 'x': 100, 'y': 96, 'tw_start': 114, 'tw_end': 355}, {'id': 15, 'x': 68, 'y': 98, 'tw_start': 223, 'tw_end': 422}, {'id': 16, 'x': 42, 'y': 100, 'tw_start': 47, 'tw_end': 295}, {'id': 17, 'x': 40, 'y': 94, 'tw_start': 133, 'tw_end': 397}], 'depot': 1, 'objective': 541.9600203006103}","[1, 2, 4, 14, 12, 13, 17, 16, 15, 10, 6, 3, 5, 7, 8, 11, 9, 1]",23,markdown_table,1
TSPTW,TSPTW,"Someone in the studio booked a string of one-off shoots across the city and needs a sensible route: leave the studio, go to each shoot exactly once during its scheduled access period, and return to the studio at the end. It’s okay to arrive early and wait for a location to open, but every location must be visited once and only once. The easy way to compare plans is to add up the travel between stops (and the final trip home) — the plan with the least total distance is the better plan. The exact schedule and location details are provided below.

{
  ""total_locations_including_studio"": 20,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""map_x_coordinate"": 44,
      ""map_y_coordinate"": 16,
      ""access_open_time"": 0,
      ""access_close_time"": 1067
    },
    {
      ""location_id"": 1,
      ""map_x_coordinate"": 47,
      ""map_y_coordinate"": 95,
      ""access_open_time"": 18,
      ""access_close_time"": 238
    },
    {
      ""location_id"": 2,
      ""map_x_coordinate"": 84,
      ""map_y_coordinate"": 40,
      ""access_open_time"": 274,
      ""access_close_time"": 474
    },
    {
      ""location_id"": 3,
      ""map_x_coordinate"": 74,
      ""map_y_coordinate"": 50,
      ""access_open_time"": 325,
      ""access_close_time"": 520
    },
    {
      ""location_id"": 4,
      ""map_x_coordinate"": 86,
      ""map_y_coordinate"": 100,
      ""access_open_time"": 95,
      ""access_close_time"": 361
    },
    {
      ""location_id"": 5,
      ""map_x_coordinate"": 47,
      ""map_y_coordinate"": 72,
      ""access_open_time"": 122,
      ""access_close_time"": 326
    },
    {
      ""location_id"": 6,
      ""map_x_coordinate"": 88,
      ""map_y_coordinate"": 81,
      ""access_open_time"": 139,
      ""access_close_time"": 359
    },
    {
      ""location_id"": 7,
      ""map_x_coordinate"": 7,
      ""map_y_coordinate"": 35,
      ""access_open_time"": 326,
      ""access_close_time"": 551
    },
    {
      ""location_id"": 8,
      ""map_x_coordinate"": 52,
      ""map_y_coordinate"": 59,
      ""access_open_time"": 306,
      ""access_close_time"": 586
    },
    {
      ""location_id"": 9,
      ""map_x_coordinate"": 42,
      ""map_y_coordinate"": 91,
      ""access_open_time"": 168,
      ""access_close_time"": 450
    },
    {
      ""location_id"": 10,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 0,
      ""access_open_time"": 146,
      ""access_close_time"": 433
    },
    {
      ""location_id"": 11,
      ""map_x_coordinate"": 65,
      ""map_y_coordinate"": 99,
      ""access_open_time"": 34,
      ""access_close_time"": 295
    },
    {
      ""location_id"": 12,
      ""map_x_coordinate"": 63,
      ""map_y_coordinate"": 8,
      ""access_open_time"": 191,
      ""access_close_time"": 423
    },
    {
      ""location_id"": 13,
      ""map_x_coordinate"": 23,
      ""map_y_coordinate"": 71,
      ""access_open_time"": 245,
      ""access_close_time"": 507
    },
    {
      ""location_id"": 14,
      ""map_x_coordinate"": 28,
      ""map_y_coordinate"": 57,
      ""access_open_time"": 1,
      ""access_close_time"": 211
    },
    {
      ""location_id"": 15,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 32,
      ""access_open_time"": 276,
      ""access_close_time"": 535
    },
    {
      ""location_id"": 16,
      ""map_x_coordinate"": 39,
      ""map_y_coordinate"": 73,
      ""access_open_time"": 374,
      ""access_close_time"": 642
    },
    {
      ""location_id"": 17,
      ""map_x_coordinate"": 89,
      ""map_y_coordinate"": 43,
      ""access_open_time"": 368,
      ""access_close_time"": 631
    },
    {
      ""location_id"": 18,
      ""map_x_coordinate"": 96,
      ""map_y_coordinate"": 51,
      ""access_open_time"": 115,
      ""access_close_time"": 319
    },
    {
      ""location_id"": 19,
      ""map_x_coordinate"": 12,
      ""map_y_coordinate"": 51,
      ""access_open_time"": 303,
      ""access_close_time"": 559
    }
  ],
  ""studio_node_id"": 0
}

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

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

Think of this like a little form: the ""solution"" field holds the ordered list of stops starting and ending at the studio. studio_id is the place we leave from and return to, each shoot_id is a shoot location visited once in the order shown, and the ... just means ""all the other stops in between"" — it's a sketch of the shape I need, not the actual route.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[44, 16], [47, 95], [84, 40], [74, 50], [86, 100], [47, 72], [88, 81], [7, 35], [52, 59], [42, 91], [100, 0], [65, 99], [63, 8], [23, 71], [28, 57], [0, 32], [39, 73], [89, 43], [96, 51], [12, 51]], 'depot': 0, 'num_nodes': 20, 'time_windows': [[0, 1067], [18, 238], [274, 474], [325, 520], [95, 361], [122, 326], [139, 359], [326, 551], [306, 586], [168, 450], [146, 433], [34, 295], [191, 423], [245, 507], [1, 211], [276, 535], [374, 642], [368, 631], [115, 319], [303, 559]], 'tour_length': 486.57810699271994, 'objective': 486.57810699271994}","[0, 14, 5, 9, 1, 11, 4, 6, 18, 10, 12, 2, 17, 3, 8, 16, 13, 19, 7, 15, 0]",486.57810699271994,"{'problem_type': 'TSPTW', 'num_nodes': 20, 'nodes': [{'id': 0, 'x': 44, 'y': 16, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 47, 'y': 95, 'tw_start': 18, 'tw_end': 238}, {'id': 2, 'x': 84, 'y': 40, 'tw_start': 274, 'tw_end': 474}, {'id': 3, 'x': 74, 'y': 50, 'tw_start': 325, 'tw_end': 520}, {'id': 4, 'x': 86, 'y': 100, 'tw_start': 95, 'tw_end': 361}, {'id': 5, 'x': 47, 'y': 72, 'tw_start': 122, 'tw_end': 326}, {'id': 6, 'x': 88, 'y': 81, 'tw_start': 139, 'tw_end': 359}, {'id': 7, 'x': 7, 'y': 35, 'tw_start': 326, 'tw_end': 551}, {'id': 8, 'x': 52, 'y': 59, 'tw_start': 306, 'tw_end': 586}, {'id': 9, 'x': 42, 'y': 91, 'tw_start': 168, 'tw_end': 450}, {'id': 10, 'x': 100, 'y': 0, 'tw_start': 146, 'tw_end': 433}, {'id': 11, 'x': 65, 'y': 99, 'tw_start': 34, 'tw_end': 295}, {'id': 12, 'x': 63, 'y': 8, 'tw_start': 191, 'tw_end': 423}, {'id': 13, 'x': 23, 'y': 71, 'tw_start': 245, 'tw_end': 507}, {'id': 14, 'x': 28, 'y': 57, 'tw_start': 1, 'tw_end': 211}, {'id': 15, 'x': 0, 'y': 32, 'tw_start': 276, 'tw_end': 535}, {'id': 16, 'x': 39, 'y': 73, 'tw_start': 374, 'tw_end': 642}, {'id': 17, 'x': 89, 'y': 43, 'tw_start': 368, 'tw_end': 631}, {'id': 18, 'x': 96, 'y': 51, 'tw_start': 115, 'tw_end': 319}, {'id': 19, 'x': 12, 'y': 51, 'tw_start': 303, 'tw_end': 559}], 'depot': 0, 'objective': 486.57810699271994}","[0, 14, 5, 9, 1, 11, 4, 6, 18, 10, 12, 2, 17, 3, 8, 16, 13, 19, 7, 15, 0]",24,json,0
TSPTW,TSPTW,"At the office there’s a route to plan: dispatch the salesperson, have them visit each retailer exactly once while they’re doing demos, and get them back to base before day’s end. The question is which route and timing will let every visit occur inside its demo slot (it’s acceptable to wait if arriving early), and the route that’s best is the one that minimizes total miles driven — total travel equals the sum of every trip between points plus the trips from and to the office. Every retailer must be visited one time only. The concrete times and places are listed below.

There are 21 locations including the office, and the office is node 1.

| location_id | x_coordinate | y_coordinate | demo_start_time | demo_end_time |
|---|---|---|---|---|
| 1 | 25 | 29 | 0 | 1240 |
| 2 | 72 | 24 | 21 | 287 |
| 3 | 54 | 48 | 431 | 713 |
| 4 | 75 | 66 | 195 | 472 |
| 5 | 76 | 31 | 94 | 361 |
| 6 | 47 | 71 | 166 | 398 |
| 7 | 46 | 100 | 346 | 618 |
| 8 | 36 | 59 | 370 | 692 |
| 9 | 68 | 84 | 95 | 395 |
| 10 | 18 | 39 | 212 | 537 |
| 11 | 78 | 31 | 97 | 399 |
| 12 | 30 | 55 | 274 | 532 |
| 13 | 20 | 29 | 61 | 360 |
| 14 | 61 | 11 | 333 | 594 |
| 15 | 56 | 11 | 290 | 560 |
| 16 | 69 | 24 | 321 | 569 |
| 17 | 77 | 24 | 401 | 659 |
| 18 | 59 | 35 | 165 | 397 |
| 19 | 59 | 26 | 50 | 333 |
| 20 | 0 | 0 | 120 | 440 |
| 21 | 100 | 67 | 6 | 274 |

Start and end the tour at office 1 and visit all 21 locations within their demo slots while minimizing total miles driven.

Also, if you want to give me the route in a tidy, machine-friendly form, here's the little JSON shape I expect — just a simple list that starts and ends at the office.

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

Think of this as a form: ""solution"" is the ordered tour (start at the office, visit each retailer once, come back to the office). The placeholders here stand in for the exact IDs from the instance — you’ll replace them with the real identifiers when you send the actual route. This snippet is only a sketch of the expected shape, not the final answer.

Please use the identifiers exactly as they appear in the instance input — do not rename them and do not 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': [[25, 29], [72, 24], [54, 48], [75, 66], [76, 31], [47, 71], [46, 100], [36, 59], [68, 84], [18, 39], [78, 31], [30, 55], [20, 29], [61, 11], [56, 11], [69, 24], [77, 24], [59, 35], [59, 26], [0, 0], [100, 67]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [21, 287], [431, 713], [195, 472], [94, 361], [166, 398], [346, 618], [370, 692], [95, 395], [212, 537], [97, 399], [274, 532], [61, 360], [333, 594], [290, 560], [321, 569], [401, 659], [165, 397], [50, 333], [120, 440], [6, 274]], 'tour_length': 461.48834695246524, 'objective': 461.48834695246524}","[0, 12, 19, 18, 17, 1, 4, 10, 20, 3, 8, 6, 5, 7, 11, 9, 2, 16, 15, 13, 14, 0]",461.48834695246524,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 1, 'x': 25, 'y': 29, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 72, 'y': 24, 'tw_start': 21, 'tw_end': 287}, {'id': 3, 'x': 54, 'y': 48, 'tw_start': 431, 'tw_end': 713}, {'id': 4, 'x': 75, 'y': 66, 'tw_start': 195, 'tw_end': 472}, {'id': 5, 'x': 76, 'y': 31, 'tw_start': 94, 'tw_end': 361}, {'id': 6, 'x': 47, 'y': 71, 'tw_start': 166, 'tw_end': 398}, {'id': 7, 'x': 46, 'y': 100, 'tw_start': 346, 'tw_end': 618}, {'id': 8, 'x': 36, 'y': 59, 'tw_start': 370, 'tw_end': 692}, {'id': 9, 'x': 68, 'y': 84, 'tw_start': 95, 'tw_end': 395}, {'id': 10, 'x': 18, 'y': 39, 'tw_start': 212, 'tw_end': 537}, {'id': 11, 'x': 78, 'y': 31, 'tw_start': 97, 'tw_end': 399}, {'id': 12, 'x': 30, 'y': 55, 'tw_start': 274, 'tw_end': 532}, {'id': 13, 'x': 20, 'y': 29, 'tw_start': 61, 'tw_end': 360}, {'id': 14, 'x': 61, 'y': 11, 'tw_start': 333, 'tw_end': 594}, {'id': 15, 'x': 56, 'y': 11, 'tw_start': 290, 'tw_end': 560}, {'id': 16, 'x': 69, 'y': 24, 'tw_start': 321, 'tw_end': 569}, {'id': 17, 'x': 77, 'y': 24, 'tw_start': 401, 'tw_end': 659}, {'id': 18, 'x': 59, 'y': 35, 'tw_start': 165, 'tw_end': 397}, {'id': 19, 'x': 59, 'y': 26, 'tw_start': 50, 'tw_end': 333}, {'id': 20, 'x': 0, 'y': 0, 'tw_start': 120, 'tw_end': 440}, {'id': 21, 'x': 100, 'y': 67, 'tw_start': 6, 'tw_end': 274}], 'depot': 1, 'objective': 461.48834695246524}","[1, 13, 20, 19, 18, 2, 5, 11, 21, 4, 9, 7, 6, 8, 12, 10, 3, 17, 16, 14, 15, 1]",25,markdown_table,1
TSPTW,TSPTW,"Recently the branch started planning mobile visits to neighborhood centers, and the challenge is to plan one loop that starts and finishes at the branch, drops by every center once while respecting their allowed visit times, and keeps the driving as low as possible. To tell which loop is best, add up the distance of every leg of the trip — the lowest total distance is the winner. Visits can be delayed by waiting if arriving early, but each center must be visited exactly once. The concrete details are given below.

{
  ""total_stops_including_branch"": 21,
  ""nodes"": [
    {
      ""location_node_id"": 0,
      ""map_x_coordinate"": 29,
      ""map_y_coordinate"": 100,
      ""visit_window_start"": 0,
      ""visit_window_end"": 1240
    },
    {
      ""location_node_id"": 1,
      ""map_x_coordinate"": 19,
      ""map_y_coordinate"": 93,
      ""visit_window_start"": 152,
      ""visit_window_end"": 379
    },
    {
      ""location_node_id"": 2,
      ""map_x_coordinate"": 42,
      ""map_y_coordinate"": 93,
      ""visit_window_start"": 56,
      ""visit_window_end"": 328
    },
    {
      ""location_node_id"": 3,
      ""map_x_coordinate"": 46,
      ""map_y_coordinate"": 91,
      ""visit_window_start"": 222,
      ""visit_window_end"": 493
    },
    {
      ""location_node_id"": 4,
      ""map_x_coordinate"": 45,
      ""map_y_coordinate"": 91,
      ""visit_window_start"": 239,
      ""visit_window_end"": 532
    },
    {
      ""location_node_id"": 5,
      ""map_x_coordinate"": 42,
      ""map_y_coordinate"": 88,
      ""visit_window_start"": 4,
      ""visit_window_end"": 282
    },
    {
      ""location_node_id"": 6,
      ""map_x_coordinate"": 88,
      ""map_y_coordinate"": 85,
      ""visit_window_start"": 434,
      ""visit_window_end"": 718
    },
    {
      ""location_node_id"": 7,
      ""map_x_coordinate"": 81,
      ""map_y_coordinate"": 85,
      ""visit_window_start"": 305,
      ""visit_window_end"": 566
    },
    {
      ""location_node_id"": 8,
      ""map_x_coordinate"": 85,
      ""map_y_coordinate"": 79,
      ""visit_window_start"": 349,
      ""visit_window_end"": 661
    },
    {
      ""location_node_id"": 9,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 80,
      ""visit_window_start"": 235,
      ""visit_window_end"": 570
    },
    {
      ""location_node_id"": 10,
      ""map_x_coordinate"": 86,
      ""map_y_coordinate"": 68,
      ""visit_window_start"": 56,
      ""visit_window_end"": 284
    },
    {
      ""location_node_id"": 11,
      ""map_x_coordinate"": 84,
      ""map_y_coordinate"": 67,
      ""visit_window_start"": 347,
      ""visit_window_end"": 663
    },
    {
      ""location_node_id"": 12,
      ""map_x_coordinate"": 88,
      ""map_y_coordinate"": 53,
      ""visit_window_start"": 54,
      ""visit_window_end"": 309
    },
    {
      ""location_node_id"": 13,
      ""map_x_coordinate"": 74,
      ""map_y_coordinate"": 53,
      ""visit_window_start"": 7,
      ""visit_window_end"": 266
    },
    {
      ""location_node_id"": 14,
      ""map_x_coordinate"": 85,
      ""map_y_coordinate"": 45,
      ""visit_window_start"": 348,
      ""visit_window_end"": 632
    },
    {
      ""location_node_id"": 15,
      ""map_x_coordinate"": 75,
      ""map_y_coordinate"": 45,
      ""visit_window_start"": 156,
      ""visit_window_end"": 424
    },
    {
      ""location_node_id"": 16,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 34,
      ""visit_window_start"": 0,
      ""visit_window_end"": 259
    },
    {
      ""location_node_id"": 17,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 21,
      ""visit_window_start"": 291,
      ""visit_window_end"": 626
    },
    {
      ""location_node_id"": 18,
      ""map_x_coordinate"": 6,
      ""map_y_coordinate"": 21,
      ""visit_window_start"": 382,
      ""visit_window_end"": 610
    },
    {
      ""location_node_id"": 19,
      ""map_x_coordinate"": 96,
      ""map_y_coordinate"": 2,
      ""visit_window_start"": 405,
      ""visit_window_end"": 719
    },
    {
      ""location_node_id"": 20,
      ""map_x_coordinate"": 31,
      ""map_y_coordinate"": 0,
      ""visit_window_start"": 351,
      ""visit_window_end"": 629
    }
  ],
  ""branch_node_id"": 0
}

When you send the route back, just use a tiny JSON layout so it's easy to read and plug into the planner. For example, something in the shape below works nicely:

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

""solution"" is the ordered loop: the first and last entry are the branch, and everything in between is a center in the order you'll visit them. Think of it as a simple form to fill out — it's just the shape we expect, not the real route itself.

Please use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[29, 100], [19, 93], [42, 93], [46, 91], [45, 91], [42, 88], [88, 85], [81, 85], [85, 79], [100, 80], [86, 68], [84, 67], [88, 53], [74, 53], [85, 45], [75, 45], [0, 34], [0, 21], [6, 21], [96, 2], [31, 0]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [152, 379], [56, 328], [222, 493], [239, 532], [4, 282], [434, 718], [305, 566], [349, 661], [235, 570], [56, 284], [347, 663], [54, 309], [7, 266], [348, 632], [156, 424], [0, 259], [291, 626], [382, 610], [405, 719], [351, 629]], 'tour_length': 668.8203901906604, 'objective': 668.8203901906604}","[0, 16, 1, 2, 5, 10, 12, 13, 15, 14, 11, 8, 9, 6, 7, 3, 4, 17, 18, 20, 19, 0]",668.8203901906604,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 0, 'x': 29, 'y': 100, 'tw_start': 0, 'tw_end': 1240}, {'id': 1, 'x': 19, 'y': 93, 'tw_start': 152, 'tw_end': 379}, {'id': 2, 'x': 42, 'y': 93, 'tw_start': 56, 'tw_end': 328}, {'id': 3, 'x': 46, 'y': 91, 'tw_start': 222, 'tw_end': 493}, {'id': 4, 'x': 45, 'y': 91, 'tw_start': 239, 'tw_end': 532}, {'id': 5, 'x': 42, 'y': 88, 'tw_start': 4, 'tw_end': 282}, {'id': 6, 'x': 88, 'y': 85, 'tw_start': 434, 'tw_end': 718}, {'id': 7, 'x': 81, 'y': 85, 'tw_start': 305, 'tw_end': 566}, {'id': 8, 'x': 85, 'y': 79, 'tw_start': 349, 'tw_end': 661}, {'id': 9, 'x': 100, 'y': 80, 'tw_start': 235, 'tw_end': 570}, {'id': 10, 'x': 86, 'y': 68, 'tw_start': 56, 'tw_end': 284}, {'id': 11, 'x': 84, 'y': 67, 'tw_start': 347, 'tw_end': 663}, {'id': 12, 'x': 88, 'y': 53, 'tw_start': 54, 'tw_end': 309}, {'id': 13, 'x': 74, 'y': 53, 'tw_start': 7, 'tw_end': 266}, {'id': 14, 'x': 85, 'y': 45, 'tw_start': 348, 'tw_end': 632}, {'id': 15, 'x': 75, 'y': 45, 'tw_start': 156, 'tw_end': 424}, {'id': 16, 'x': 0, 'y': 34, 'tw_start': 0, 'tw_end': 259}, {'id': 17, 'x': 0, 'y': 21, 'tw_start': 291, 'tw_end': 626}, {'id': 18, 'x': 6, 'y': 21, 'tw_start': 382, 'tw_end': 610}, {'id': 19, 'x': 96, 'y': 2, 'tw_start': 405, 'tw_end': 719}, {'id': 20, 'x': 31, 'y': 0, 'tw_start': 351, 'tw_end': 629}], 'depot': 0, 'objective': 668.8203901906604}","[0, 16, 1, 2, 5, 10, 12, 13, 15, 14, 11, 8, 9, 6, 7, 3, 4, 17, 18, 20, 19, 0]",26,json,0
TSPTW,TSPTW,"We have a single truck that must leave the farm, visit every market stall one time to set up during its assigned opening window, and then return to the farm at the end. The decision is simply the order of visits — a good order means the total miles driven (add up all the legs: farm to first, between stalls, and back to farm) is as small as possible. Every stall must be visited exactly once within its time slot, and standing by until a stall’s setup window starts is allowed. The concrete details are listed below.

There are 18 total locations (farm plus stalls) and the farm depot is A.
Location A is at (19, 78) and must be served between 0 and 1067.
Location B is at (0, 17) and must be served between 154 and 377.
Location C is at (16, 14) and must be served between 25 and 241.
Location D is at (77, 75) and must be served between 95 and 336.
Location E is at (52, 77) and must be served between 290 and 529.
Location F is at (77, 83) and must be served between 22 and 309.
Location G is at (40, 97) and must be served between 365 and 635.
Location H is at (56, 97) and must be served between 384 and 631.
Location I is at (58, 100) and must be served between 373 and 574.
Location J is at (52, 43) and must be served between 141 and 357.
Location K is at (46, 43) and must be served between 75 and 283.
Location L is at (43, 43) and must be served between 241 and 511.
Location M is at (55, 40) and must be served between 224 and 432.
Location N is at (57, 38) and must be served between 314 and 570.
Location O is at (60, 23) and must be served between 150 and 409.
Location P is at (92, 0) and must be served between 100 and 328.
Location Q is at (100, 6) and must be served between 355 and 578.
Location R is at (96, 16) and must be served between 182 and 462.
We must choose an order that minimizes total miles while visiting each location within its setup window and returning to the farm.

You can return the chosen route in a tiny JSON object like this — nothing fancy, just the order of stops so I know which stall you hit when and that you start and end at the farm:

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

Just so it’s clear: ""solution"" holds the list of stops in order, beginning and ending with the farm. Each placeholder there stands for the identifier of the farm or a stall (the ""..."" just means all the other stalls in between). This is only a sketch of the shape I expect — don’t treat these placeholders as your actual answer.

Please 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': [[19, 78], [0, 17], [16, 14], [77, 75], [52, 77], [77, 83], [40, 97], [56, 97], [58, 100], [52, 43], [46, 43], [43, 43], [55, 40], [57, 38], [60, 23], [92, 0], [100, 6], [96, 16]], 'depot': 0, 'num_nodes': 18, 'time_windows': [[0, 1067], [154, 377], [25, 241], [95, 336], [290, 529], [22, 309], [365, 635], [384, 631], [373, 574], [141, 357], [75, 283], [241, 511], [224, 432], [314, 570], [150, 409], [100, 328], [355, 578], [182, 462]], 'tour_length': 452.7461755048688, 'objective': 452.7461755048688}","[0, 5, 3, 9, 10, 1, 2, 14, 15, 16, 17, 13, 12, 11, 4, 7, 8, 6, 0]",452.7461755048688,"{'problem_type': 'TSPTW', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 19, 'y': 78, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 17, 'tw_start': 154, 'tw_end': 377}, {'id': 'C', 'x': 16, 'y': 14, 'tw_start': 25, 'tw_end': 241}, {'id': 'D', 'x': 77, 'y': 75, 'tw_start': 95, 'tw_end': 336}, {'id': 'E', 'x': 52, 'y': 77, 'tw_start': 290, 'tw_end': 529}, {'id': 'F', 'x': 77, 'y': 83, 'tw_start': 22, 'tw_end': 309}, {'id': 'G', 'x': 40, 'y': 97, 'tw_start': 365, 'tw_end': 635}, {'id': 'H', 'x': 56, 'y': 97, 'tw_start': 384, 'tw_end': 631}, {'id': 'I', 'x': 58, 'y': 100, 'tw_start': 373, 'tw_end': 574}, {'id': 'J', 'x': 52, 'y': 43, 'tw_start': 141, 'tw_end': 357}, {'id': 'K', 'x': 46, 'y': 43, 'tw_start': 75, 'tw_end': 283}, {'id': 'L', 'x': 43, 'y': 43, 'tw_start': 241, 'tw_end': 511}, {'id': 'M', 'x': 55, 'y': 40, 'tw_start': 224, 'tw_end': 432}, {'id': 'N', 'x': 57, 'y': 38, 'tw_start': 314, 'tw_end': 570}, {'id': 'O', 'x': 60, 'y': 23, 'tw_start': 150, 'tw_end': 409}, {'id': 'P', 'x': 92, 'y': 0, 'tw_start': 100, 'tw_end': 328}, {'id': 'Q', 'x': 100, 'y': 6, 'tw_start': 355, 'tw_end': 578}, {'id': 'R', 'x': 96, 'y': 16, 'tw_start': 182, 'tw_end': 462}], 'depot': 'A', 'objective': 452.7461755048688}","['A', 'F', 'D', 'J', 'K', 'B', 'C', 'O', 'P', 'Q', 'R', 'N', 'M', 'L', 'E', 'H', 'I', 'G', 'A']",27,nl,names
TSPTW,TSPTW,"Back at headquarters the morning plan is simple: the inspector must start here, knock out inspections at all sites exactly once within each site’s specified inspection window (it’s okay to wait until the slot opens), and return here at the end of the run. Routes are judged by how much driving they require — add up each leg from one place to the next, including returning to HQ, and the route with the smallest total distance wins. The full details for each site and its time window are shown below.

Here are the 18 locations (HQ = A):
Site A at coordinates (5, 5) — inspection window 0 to 1067.
Site B at coordinates (0, 26) — inspection window 274 to 474.
Site C at coordinates (1, 26) — inspection window 57 to 251.
Site D at coordinates (7, 41) — inspection window 244 to 482.
Site E at coordinates (8, 51) — inspection window 52 to 339.
Site F at coordinates (9, 66) — inspection window 205 to 422.
Site G at coordinates (28, 0) — inspection window 194 to 454.
Site H at coordinates (25, 3) — inspection window 29 to 250.
Site I at coordinates (57, 15) — inspection window 313 to 551.
Site J at coordinates (86, 16) — inspection window 212 to 448.
Site K at coordinates (100, 23) — inspection window 17 to 227.
Site L at coordinates (54, 25) — inspection window 172 to 387.
Site M at coordinates (67, 48) — inspection window 19 to 295.
Site N at coordinates (57, 51) — inspection window 380 to 651.
Site O at coordinates (29, 54) — inspection window 331 to 548.
Site P at coordinates (31, 56) — inspection window 372 to 585.
Site Q at coordinates (24, 75) — inspection window 369 to 659.
Site R at coordinates (87, 100) — inspection window 276 to 565.
Start and finish at A; visit each site once within its window and minimize total driving distance.

Oh, and when you send the route back, just use a little JSON sketch like this so it's easy to parse:

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

Think of that as a simple form: the solution array is the visit order — start at HQ, list every site once in the order you’ll visit them, and finish back at HQ. It’s just the shape I expect, not the actual route.

Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones.  
For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[5, 5], [0, 26], [1, 26], [7, 41], [8, 51], [9, 66], [28, 0], [25, 3], [57, 15], [86, 16], [100, 23], [54, 25], [67, 48], [57, 51], [29, 54], [31, 56], [24, 75], [87, 100]], 'depot': 0, 'num_nodes': 18, 'time_windows': [[0, 1067], [274, 474], [57, 251], [244, 482], [52, 339], [205, 422], [194, 454], [29, 250], [313, 551], [212, 448], [17, 227], [172, 387], [19, 295], [380, 651], [331, 548], [372, 585], [369, 659], [276, 565]], 'tour_length': 634.3372971066408, 'objective': 634.3372971066408}","[0, 7, 2, 4, 12, 10, 9, 6, 8, 11, 1, 3, 5, 16, 14, 15, 17, 13, 0]",634.3372971066408,"{'problem_type': 'TSPTW', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 5, 'y': 5, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 26, 'tw_start': 274, 'tw_end': 474}, {'id': 'C', 'x': 1, 'y': 26, 'tw_start': 57, 'tw_end': 251}, {'id': 'D', 'x': 7, 'y': 41, 'tw_start': 244, 'tw_end': 482}, {'id': 'E', 'x': 8, 'y': 51, 'tw_start': 52, 'tw_end': 339}, {'id': 'F', 'x': 9, 'y': 66, 'tw_start': 205, 'tw_end': 422}, {'id': 'G', 'x': 28, 'y': 0, 'tw_start': 194, 'tw_end': 454}, {'id': 'H', 'x': 25, 'y': 3, 'tw_start': 29, 'tw_end': 250}, {'id': 'I', 'x': 57, 'y': 15, 'tw_start': 313, 'tw_end': 551}, {'id': 'J', 'x': 86, 'y': 16, 'tw_start': 212, 'tw_end': 448}, {'id': 'K', 'x': 100, 'y': 23, 'tw_start': 17, 'tw_end': 227}, {'id': 'L', 'x': 54, 'y': 25, 'tw_start': 172, 'tw_end': 387}, {'id': 'M', 'x': 67, 'y': 48, 'tw_start': 19, 'tw_end': 295}, {'id': 'N', 'x': 57, 'y': 51, 'tw_start': 380, 'tw_end': 651}, {'id': 'O', 'x': 29, 'y': 54, 'tw_start': 331, 'tw_end': 548}, {'id': 'P', 'x': 31, 'y': 56, 'tw_start': 372, 'tw_end': 585}, {'id': 'Q', 'x': 24, 'y': 75, 'tw_start': 369, 'tw_end': 659}, {'id': 'R', 'x': 87, 'y': 100, 'tw_start': 276, 'tw_end': 565}], 'depot': 'A', 'objective': 634.3372971066408}","['A', 'H', 'C', 'E', 'M', 'K', 'J', 'G', 'I', 'L', 'B', 'D', 'F', 'Q', 'O', 'P', 'R', 'N', 'A']",28,nl,names
TSPTW,TSPTW,"Recently the gardening company had to sort out a day’s work — a team leaves the depot, must tend each customer’s garden one time during that customer’s scheduled window, and then return to the depot. The job is to pick the sequence of visits so the total driving is as small as possible: for each plan, sum the lengths of the legs between stops (and back home) and choose the smallest total. Every client must be visited exactly once and time windows must be respected; arriving early can be handled by waiting. The full list of appointments and distances is shown below.

{
  ""num_locations_including_depot"": 25,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""x_coordinate"": 66,
      ""y_coordinate"": 0,
      ""time_window_start"": 0,
      ""time_window_end"": 1240
    },
    {
      ""location_id"": 1,
      ""x_coordinate"": 83,
      ""y_coordinate"": 32,
      ""time_window_start"": 228,
      ""time_window_end"": 500
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 89,
      ""y_coordinate"": 48,
      ""time_window_start"": 365,
      ""time_window_end"": 685
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 97,
      ""y_coordinate"": 96,
      ""time_window_start"": 149,
      ""time_window_end"": 453
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 100,
      ""y_coordinate"": 92,
      ""time_window_start"": 347,
      ""time_window_end"": 647
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 90,
      ""y_coordinate"": 100,
      ""time_window_start"": 68,
      ""time_window_end"": 392
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 64,
      ""y_coordinate"": 100,
      ""time_window_start"": 243,
      ""time_window_end"": 500
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 71,
      ""y_coordinate"": 90,
      ""time_window_start"": 191,
      ""time_window_end"": 421
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 75,
      ""y_coordinate"": 76,
      ""time_window_start"": 57,
      ""time_window_end"": 369
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 49,
      ""y_coordinate"": 60,
      ""time_window_start"": 0,
      ""time_window_end"": 272
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 81,
      ""y_coordinate"": 69,
      ""time_window_start"": 235,
      ""time_window_end"": 467
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 53,
      ""y_coordinate"": 6,
      ""time_window_start"": 438,
      ""time_window_end"": 689
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 49,
      ""y_coordinate"": 4,
      ""time_window_start"": 137,
      ""time_window_end"": 396
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 49,
      ""y_coordinate"": 5,
      ""time_window_start"": 103,
      ""time_window_end"": 329
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 32,
      ""y_coordinate"": 14,
      ""time_window_start"": 328,
      ""time_window_end"": 663
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 40,
      ""y_coordinate"": 19,
      ""time_window_start"": 101,
      ""time_window_end"": 401
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 36,
      ""y_coordinate"": 41,
      ""time_window_start"": 334,
      ""time_window_end"": 655
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 33,
      ""y_coordinate"": 40,
      ""time_window_start"": 190,
      ""time_window_end"": 450
    },
    {
      ""location_id"": 18,
      ""x_coordinate"": 40,
      ""y_coordinate"": 47,
      ""time_window_start"": 146,
      ""time_window_end"": 452
    },
    {
      ""location_id"": 19,
      ""x_coordinate"": 9,
      ""y_coordinate"": 57,
      ""time_window_start"": 368,
      ""time_window_end"": 614
    },
    {
      ""location_id"": 20,
      ""x_coordinate"": 42,
      ""y_coordinate"": 77,
      ""time_window_start"": 167,
      ""time_window_end"": 494
    },
    {
      ""location_id"": 21,
      ""x_coordinate"": 18,
      ""y_coordinate"": 90,
      ""time_window_start"": 363,
      ""time_window_end"": 700
    },
    {
      ""location_id"": 22,
      ""x_coordinate"": 7,
      ""y_coordinate"": 70,
      ""time_window_start"": 340,
      ""time_window_end"": 609
    },
    {
      ""location_id"": 23,
      ""x_coordinate"": 0,
      ""y_coordinate"": 31,
      ""time_window_start"": 266,
      ""time_window_end"": 566
    },
    {
      ""location_id"": 24,
      ""x_coordinate"": 11,
      ""y_coordinate"": 19,
      ""time_window_start"": 35,
      ""time_window_end"": 322
    }
  ],
  ""depot_location_id"": 0
}

When you're ready to give the planned route, just hand it back in this simple JSON layout so it's easy to read:

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

This just means: ""solution"" is the sequence of stops — start at the depot, list each customer once in the order they'll be visited, and end at the depot. The names in the example are placeholders to show the shape; they're not the actual labels from the instance.

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

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[66, 0], [83, 32], [89, 48], [97, 96], [100, 92], [90, 100], [64, 100], [71, 90], [75, 76], [49, 60], [81, 69], [53, 6], [49, 4], [49, 5], [32, 14], [40, 19], [36, 41], [33, 40], [40, 47], [9, 57], [42, 77], [18, 90], [7, 70], [0, 31], [11, 19]], 'depot': 0, 'num_nodes': 25, 'time_windows': [[0, 1240], [228, 500], [365, 685], [149, 453], [347, 647], [68, 392], [243, 500], [191, 421], [57, 369], [0, 272], [235, 467], [438, 689], [137, 396], [103, 329], [328, 663], [101, 401], [334, 655], [190, 450], [146, 452], [368, 614], [167, 494], [363, 700], [340, 609], [266, 566], [35, 322]], 'tour_length': 566.0944212435757, 'objective': 566.0944212435757}","[0, 12, 13, 15, 24, 17, 18, 9, 20, 8, 7, 6, 5, 3, 4, 10, 2, 1, 14, 23, 19, 22, 21, 16, 11, 0]",566.0944212435757,"{'problem_type': 'TSPTW', 'num_nodes': 25, 'nodes': [{'id': 0, 'x': 66, 'y': 0, 'tw_start': 0, 'tw_end': 1240}, {'id': 1, 'x': 83, 'y': 32, 'tw_start': 228, 'tw_end': 500}, {'id': 2, 'x': 89, 'y': 48, 'tw_start': 365, 'tw_end': 685}, {'id': 3, 'x': 97, 'y': 96, 'tw_start': 149, 'tw_end': 453}, {'id': 4, 'x': 100, 'y': 92, 'tw_start': 347, 'tw_end': 647}, {'id': 5, 'x': 90, 'y': 100, 'tw_start': 68, 'tw_end': 392}, {'id': 6, 'x': 64, 'y': 100, 'tw_start': 243, 'tw_end': 500}, {'id': 7, 'x': 71, 'y': 90, 'tw_start': 191, 'tw_end': 421}, {'id': 8, 'x': 75, 'y': 76, 'tw_start': 57, 'tw_end': 369}, {'id': 9, 'x': 49, 'y': 60, 'tw_start': 0, 'tw_end': 272}, {'id': 10, 'x': 81, 'y': 69, 'tw_start': 235, 'tw_end': 467}, {'id': 11, 'x': 53, 'y': 6, 'tw_start': 438, 'tw_end': 689}, {'id': 12, 'x': 49, 'y': 4, 'tw_start': 137, 'tw_end': 396}, {'id': 13, 'x': 49, 'y': 5, 'tw_start': 103, 'tw_end': 329}, {'id': 14, 'x': 32, 'y': 14, 'tw_start': 328, 'tw_end': 663}, {'id': 15, 'x': 40, 'y': 19, 'tw_start': 101, 'tw_end': 401}, {'id': 16, 'x': 36, 'y': 41, 'tw_start': 334, 'tw_end': 655}, {'id': 17, 'x': 33, 'y': 40, 'tw_start': 190, 'tw_end': 450}, {'id': 18, 'x': 40, 'y': 47, 'tw_start': 146, 'tw_end': 452}, {'id': 19, 'x': 9, 'y': 57, 'tw_start': 368, 'tw_end': 614}, {'id': 20, 'x': 42, 'y': 77, 'tw_start': 167, 'tw_end': 494}, {'id': 21, 'x': 18, 'y': 90, 'tw_start': 363, 'tw_end': 700}, {'id': 22, 'x': 7, 'y': 70, 'tw_start': 340, 'tw_end': 609}, {'id': 23, 'x': 0, 'y': 31, 'tw_start': 266, 'tw_end': 566}, {'id': 24, 'x': 11, 'y': 19, 'tw_start': 35, 'tw_end': 322}], 'depot': 0, 'objective': 566.0944212435757}","[0, 12, 13, 15, 24, 17, 18, 9, 20, 8, 7, 6, 5, 3, 4, 10, 2, 1, 14, 23, 19, 22, 21, 16, 11, 0]",29,json,0
TSPTW,TSPTW,"Someone in charge of the ice cream truck schedule has to pick the order of stops so the day starts and ends at the truck yard, every stop gets visited exactly once during its allotted time, and no place is skipped or visited twice. The goal is to keep the total driving to a minimum: tally the distance between each consecutive stop in the route (and include the drive back to base) and prefer the route with the smallest total, with waiting allowed if reaching a stop early. The specific stops, time windows, and distances appear below.

There are 17 locations to serve, with the route starting and ending at the truck yard 0.

| stop_id | map_x | map_y | active_start_time | active_end_time |
|---|---|---|---|---|
| 0 | 81 | 19 | 0 | 1067 |
| 1 | 44 | 42 | 275 | 485 |
| 2 | 44 | 58 | 302 | 553 |
| 3 | 100 | 10 | 369 | 567 |
| 4 | 63 | 8 | 102 | 355 |
| 5 | 32 | 8 | 115 | 378 |
| 6 | 0 | 56 | 294 | 498 |
| 7 | 81 | 42 | 199 | 442 |
| 8 | 24 | 65 | 143 | 427 |
| 9 | 73 | 11 | 321 | 582 |
| 10 | 8 | 48 | 277 | 515 |
| 11 | 98 | 31 | 357 | 618 |
| 12 | 73 | 100 | 282 | 560 |
| 13 | 64 | 55 | 106 | 378 |
| 14 | 53 | 40 | 75 | 303 |
| 15 | 100 | 0 | 130 | 419 |
| 16 | 47 | 84 | 332 | 594 |

The schedule must visit every stop once within its time window and return to 0.

Oh, and when you send the route back, you can just use this simple JSON layout:

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

Think of ""solution"" as the ordered list of stops: start at the depot, follow the stops in order, and finish back at the depot. The depot_id and location_id bits are placeholders for the actual stop identifiers from the instance. This is just a sketch of the shape I need — not the real route.

Please use the identifiers exactly as they appear in the instance input — do not rename them or introduce 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': [[81, 19], [44, 42], [44, 58], [100, 10], [63, 8], [32, 8], [0, 56], [81, 42], [24, 65], [73, 11], [8, 48], [98, 31], [73, 100], [64, 55], [53, 40], [100, 0], [47, 84]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [275, 485], [302, 553], [369, 567], [102, 355], [115, 378], [294, 498], [199, 442], [143, 427], [321, 582], [277, 515], [357, 618], [282, 560], [106, 378], [75, 303], [130, 419], [332, 594]], 'tour_length': 486.3168372856074, 'objective': 486.3168372856074}","[0, 15, 4, 5, 14, 7, 13, 2, 1, 10, 6, 8, 16, 12, 11, 3, 9, 0]",486.3168372856074,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 81, 'y': 19, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 44, 'y': 42, 'tw_start': 275, 'tw_end': 485}, {'id': 2, 'x': 44, 'y': 58, 'tw_start': 302, 'tw_end': 553}, {'id': 3, 'x': 100, 'y': 10, 'tw_start': 369, 'tw_end': 567}, {'id': 4, 'x': 63, 'y': 8, 'tw_start': 102, 'tw_end': 355}, {'id': 5, 'x': 32, 'y': 8, 'tw_start': 115, 'tw_end': 378}, {'id': 6, 'x': 0, 'y': 56, 'tw_start': 294, 'tw_end': 498}, {'id': 7, 'x': 81, 'y': 42, 'tw_start': 199, 'tw_end': 442}, {'id': 8, 'x': 24, 'y': 65, 'tw_start': 143, 'tw_end': 427}, {'id': 9, 'x': 73, 'y': 11, 'tw_start': 321, 'tw_end': 582}, {'id': 10, 'x': 8, 'y': 48, 'tw_start': 277, 'tw_end': 515}, {'id': 11, 'x': 98, 'y': 31, 'tw_start': 357, 'tw_end': 618}, {'id': 12, 'x': 73, 'y': 100, 'tw_start': 282, 'tw_end': 560}, {'id': 13, 'x': 64, 'y': 55, 'tw_start': 106, 'tw_end': 378}, {'id': 14, 'x': 53, 'y': 40, 'tw_start': 75, 'tw_end': 303}, {'id': 15, 'x': 100, 'y': 0, 'tw_start': 130, 'tw_end': 419}, {'id': 16, 'x': 47, 'y': 84, 'tw_start': 332, 'tw_end': 594}], 'depot': 0, 'objective': 486.3168372856074}","[0, 15, 4, 5, 14, 7, 13, 2, 1, 10, 6, 8, 16, 12, 11, 3, 9, 0]",30,markdown_table,0
TSPTW,TSPTW,"On a typical morning the mobile lab team has to craft a route: leave the lab, swing by each clinic once during its designated pickup time (it’s allowed to wait if arriving too early), and return to base at the end. The decision is just the order of stops, and the route that’s better is the one that minimizes how far the van drives overall — total distance is the sum of each leg from one stop to the next, plus the journey back to the lab. No stops can be skipped or repeated, and every pickup must fall inside its window. The specific stops and time windows are listed below.

{
  ""total_stops_including_lab"": 19,
  ""nodes"": [
    {
      ""stop_id"": 1,
      ""x_coordinate"": 36,
      ""y_coordinate"": 91,
      ""pickup_earliest_time"": 0,
      ""pickup_latest_time"": 1067
    },
    {
      ""stop_id"": 2,
      ""x_coordinate"": 18,
      ""y_coordinate"": 72,
      ""pickup_earliest_time"": 60,
      ""pickup_latest_time"": 345
    },
    {
      ""stop_id"": 3,
      ""x_coordinate"": 41,
      ""y_coordinate"": 70,
      ""pickup_earliest_time"": 285,
      ""pickup_latest_time"": 565
    },
    {
      ""stop_id"": 4,
      ""x_coordinate"": 40,
      ""y_coordinate"": 70,
      ""pickup_earliest_time"": 78,
      ""pickup_latest_time"": 329
    },
    {
      ""stop_id"": 5,
      ""x_coordinate"": 86,
      ""y_coordinate"": 68,
      ""pickup_earliest_time"": 272,
      ""pickup_latest_time"": 532
    },
    {
      ""stop_id"": 6,
      ""x_coordinate"": 55,
      ""y_coordinate"": 52,
      ""pickup_earliest_time"": 158,
      ""pickup_latest_time"": 353
    },
    {
      ""stop_id"": 7,
      ""x_coordinate"": 58,
      ""y_coordinate"": 52,
      ""pickup_earliest_time"": 226,
      ""pickup_latest_time"": 444
    },
    {
      ""stop_id"": 8,
      ""x_coordinate"": 2,
      ""y_coordinate"": 20,
      ""pickup_earliest_time"": 174,
      ""pickup_latest_time"": 461
    },
    {
      ""stop_id"": 9,
      ""x_coordinate"": 74,
      ""y_coordinate"": 23,
      ""pickup_earliest_time"": 154,
      ""pickup_latest_time"": 430
    },
    {
      ""stop_id"": 10,
      ""x_coordinate"": 79,
      ""y_coordinate"": 66,
      ""pickup_earliest_time"": 73,
      ""pickup_latest_time"": 332
    },
    {
      ""stop_id"": 11,
      ""x_coordinate"": 59,
      ""y_coordinate"": 66,
      ""pickup_earliest_time"": 379,
      ""pickup_latest_time"": 582
    },
    {
      ""stop_id"": 12,
      ""x_coordinate"": 70,
      ""y_coordinate"": 58,
      ""pickup_earliest_time"": 3,
      ""pickup_latest_time"": 239
    },
    {
      ""stop_id"": 13,
      ""x_coordinate"": 55,
      ""y_coordinate"": 53,
      ""pickup_earliest_time"": 35,
      ""pickup_latest_time"": 302
    },
    {
      ""stop_id"": 14,
      ""x_coordinate"": 100,
      ""y_coordinate"": 100,
      ""pickup_earliest_time"": 354,
      ""pickup_latest_time"": 590
    },
    {
      ""stop_id"": 15,
      ""x_coordinate"": 89,
      ""y_coordinate"": 99,
      ""pickup_earliest_time"": 100,
      ""pickup_latest_time"": 336
    },
    {
      ""stop_id"": 16,
      ""x_coordinate"": 95,
      ""y_coordinate"": 100,
      ""pickup_earliest_time"": 280,
      ""pickup_latest_time"": 475
    },
    {
      ""stop_id"": 17,
      ""x_coordinate"": 82,
      ""y_coordinate"": 100,
      ""pickup_earliest_time"": 228,
      ""pickup_latest_time"": 482
    },
    {
      ""stop_id"": 18,
      ""x_coordinate"": 0,
      ""y_coordinate"": 0,
      ""pickup_earliest_time"": 247,
      ""pickup_latest_time"": 464
    },
    {
      ""stop_id"": 19,
      ""x_coordinate"": 9,
      ""y_coordinate"": 0,
      ""pickup_earliest_time"": 277,
      ""pickup_latest_time"": 479
    }
  ],
  ""lab_depot_id"": 1
}

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

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

""solution"" is the ordered list of stops — start at the lab (first entry), visit each clinic once in the order shown, and come back to the lab (last entry). The names in the example above are just placeholders to show the shape; replace them with the actual IDs from the instance. This JSON is only a sketch of the expected shape, not the final answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[36, 91], [18, 72], [41, 70], [40, 70], [86, 68], [55, 52], [58, 52], [2, 20], [74, 23], [79, 66], [59, 66], [70, 58], [55, 53], [100, 100], [89, 99], [95, 100], [82, 100], [0, 0], [9, 0]], 'depot': 0, 'num_nodes': 19, 'time_windows': [[0, 1067], [60, 345], [285, 565], [78, 329], [272, 532], [158, 353], [226, 444], [174, 461], [154, 430], [73, 332], [379, 582], [3, 239], [35, 302], [354, 590], [100, 336], [280, 475], [228, 482], [247, 464], [277, 479]], 'tour_length': 513.8699148179337, 'objective': 513.8699148179337}","[0, 14, 9, 11, 5, 12, 3, 1, 7, 17, 18, 8, 6, 4, 13, 15, 16, 10, 2, 0]",513.8699148179337,"{'problem_type': 'TSPTW', 'num_nodes': 19, 'nodes': [{'id': 1, 'x': 36, 'y': 91, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 18, 'y': 72, 'tw_start': 60, 'tw_end': 345}, {'id': 3, 'x': 41, 'y': 70, 'tw_start': 285, 'tw_end': 565}, {'id': 4, 'x': 40, 'y': 70, 'tw_start': 78, 'tw_end': 329}, {'id': 5, 'x': 86, 'y': 68, 'tw_start': 272, 'tw_end': 532}, {'id': 6, 'x': 55, 'y': 52, 'tw_start': 158, 'tw_end': 353}, {'id': 7, 'x': 58, 'y': 52, 'tw_start': 226, 'tw_end': 444}, {'id': 8, 'x': 2, 'y': 20, 'tw_start': 174, 'tw_end': 461}, {'id': 9, 'x': 74, 'y': 23, 'tw_start': 154, 'tw_end': 430}, {'id': 10, 'x': 79, 'y': 66, 'tw_start': 73, 'tw_end': 332}, {'id': 11, 'x': 59, 'y': 66, 'tw_start': 379, 'tw_end': 582}, {'id': 12, 'x': 70, 'y': 58, 'tw_start': 3, 'tw_end': 239}, {'id': 13, 'x': 55, 'y': 53, 'tw_start': 35, 'tw_end': 302}, {'id': 14, 'x': 100, 'y': 100, 'tw_start': 354, 'tw_end': 590}, {'id': 15, 'x': 89, 'y': 99, 'tw_start': 100, 'tw_end': 336}, {'id': 16, 'x': 95, 'y': 100, 'tw_start': 280, 'tw_end': 475}, {'id': 17, 'x': 82, 'y': 100, 'tw_start': 228, 'tw_end': 482}, {'id': 18, 'x': 0, 'y': 0, 'tw_start': 247, 'tw_end': 464}, {'id': 19, 'x': 9, 'y': 0, 'tw_start': 277, 'tw_end': 479}], 'depot': 1, 'objective': 513.8699148179337}","[1, 15, 10, 12, 6, 13, 4, 2, 8, 18, 19, 9, 7, 5, 14, 16, 17, 11, 3, 1]",31,json,1
TSPTW,TSPTW,"Recently an agent told a story about a day packed with back-to-back viewings, each with a strict time window, and the need to start and finish at the brokerage. The decision was which order to follow so each flat is shown once at the right time (arriving early and waiting if necessary is okay) and the overall miles driven — calculated by adding every drive between stops, including the return — end up as low as possible. The exact appointments and addresses are listed below.

There were 25 stops in total, starting and ending at the brokerage office 1.

| stop_id | map_x_coordinate | map_y_coordinate | viewing_window_start | viewing_window_end |
|---|---|---|---|---|
| 1 | 49 | 87 | 0 | 1240 |
| 2 | 0 | 14 | 89 | 414 |
| 3 | 79 | 39 | 333 | 560 |
| 4 | 12 | 72 | 112 | 361 |
| 5 | 89 | 28 | 122 | 375 |
| 6 | 28 | 25 | 28 | 305 |
| 7 | 49 | 20 | 330 | 624 |
| 8 | 7 | 48 | 303 | 538 |
| 9 | 63 | 60 | 429 | 749 |
| 10 | 65 | 54 | 363 | 681 |
| 11 | 31 | 3 | 420 | 707 |
| 12 | 64 | 96 | 90 | 385 |
| 13 | 12 | 0 | 335 | 643 |
| 14 | 5 | 0 | 235 | 468 |
| 15 | 43 | 0 | 167 | 496 |
| 16 | 61 | 3 | 263 | 549 |
| 17 | 100 | 100 | 121 | 388 |
| 18 | 62 | 100 | 403 | 704 |
| 19 | 78 | 3 | 355 | 631 |
| 20 | 2 | 0 | 284 | 537 |
| 21 | 29 | 0 | 318 | 591 |
| 22 | 49 | 100 | 199 | 498 |
| 23 | 45 | 0 | 422 | 654 |
| 24 | 58 | 100 | 371 | 630 |
| 25 | 98 | 100 | 200 | 428 |

The agent then planned a visiting order that met each viewing window while keeping the total miles driven as low as possible.

Oh, and when you hand back the route, a little JSON like this is perfect — just a tiny, predictable shape so it's easy to check automatically:

{
  ""solution"": [brokerage_id, flat_id, ..., brokerage_id]
}

This just shows the shape I need: ""solution"" is the ordered list of stops (start at the brokerage, visit every flat once in the listed order, and return to the brokerage). The placeholder names above are only a sketch of the format — don’t treat them as the real IDs.

Please make sure to use the exact identifiers from the instance input (no renaming, 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': [[49, 87], [0, 14], [79, 39], [12, 72], [89, 28], [28, 25], [49, 20], [7, 48], [63, 60], [65, 54], [31, 3], [64, 96], [12, 0], [5, 0], [43, 0], [61, 3], [100, 100], [62, 100], [78, 3], [2, 0], [29, 0], [49, 100], [45, 0], [58, 100], [98, 100]], 'depot': 0, 'num_nodes': 25, 'time_windows': [[0, 1240], [89, 414], [333, 560], [112, 361], [122, 375], [28, 305], [330, 624], [303, 538], [429, 749], [363, 681], [420, 707], [90, 385], [335, 643], [235, 468], [167, 496], [263, 549], [121, 388], [403, 704], [355, 631], [284, 537], [318, 591], [199, 498], [422, 654], [371, 630], [200, 428]], 'tour_length': 596.7589170840024, 'objective': 596.7589170840024}","[0, 5, 4, 16, 24, 11, 21, 3, 7, 1, 19, 13, 12, 20, 10, 14, 22, 6, 15, 18, 2, 9, 8, 17, 23, 0]",596.7589170840024,"{'problem_type': 'TSPTW', 'num_nodes': 25, 'nodes': [{'id': 1, 'x': 49, 'y': 87, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 0, 'y': 14, 'tw_start': 89, 'tw_end': 414}, {'id': 3, 'x': 79, 'y': 39, 'tw_start': 333, 'tw_end': 560}, {'id': 4, 'x': 12, 'y': 72, 'tw_start': 112, 'tw_end': 361}, {'id': 5, 'x': 89, 'y': 28, 'tw_start': 122, 'tw_end': 375}, {'id': 6, 'x': 28, 'y': 25, 'tw_start': 28, 'tw_end': 305}, {'id': 7, 'x': 49, 'y': 20, 'tw_start': 330, 'tw_end': 624}, {'id': 8, 'x': 7, 'y': 48, 'tw_start': 303, 'tw_end': 538}, {'id': 9, 'x': 63, 'y': 60, 'tw_start': 429, 'tw_end': 749}, {'id': 10, 'x': 65, 'y': 54, 'tw_start': 363, 'tw_end': 681}, {'id': 11, 'x': 31, 'y': 3, 'tw_start': 420, 'tw_end': 707}, {'id': 12, 'x': 64, 'y': 96, 'tw_start': 90, 'tw_end': 385}, {'id': 13, 'x': 12, 'y': 0, 'tw_start': 335, 'tw_end': 643}, {'id': 14, 'x': 5, 'y': 0, 'tw_start': 235, 'tw_end': 468}, {'id': 15, 'x': 43, 'y': 0, 'tw_start': 167, 'tw_end': 496}, {'id': 16, 'x': 61, 'y': 3, 'tw_start': 263, 'tw_end': 549}, {'id': 17, 'x': 100, 'y': 100, 'tw_start': 121, 'tw_end': 388}, {'id': 18, 'x': 62, 'y': 100, 'tw_start': 403, 'tw_end': 704}, {'id': 19, 'x': 78, 'y': 3, 'tw_start': 355, 'tw_end': 631}, {'id': 20, 'x': 2, 'y': 0, 'tw_start': 284, 'tw_end': 537}, {'id': 21, 'x': 29, 'y': 0, 'tw_start': 318, 'tw_end': 591}, {'id': 22, 'x': 49, 'y': 100, 'tw_start': 199, 'tw_end': 498}, {'id': 23, 'x': 45, 'y': 0, 'tw_start': 422, 'tw_end': 654}, {'id': 24, 'x': 58, 'y': 100, 'tw_start': 371, 'tw_end': 630}, {'id': 25, 'x': 98, 'y': 100, 'tw_start': 200, 'tw_end': 428}], 'depot': 1, 'objective': 596.7589170840024}","[1, 6, 5, 17, 25, 12, 22, 4, 8, 2, 20, 14, 13, 21, 11, 15, 23, 7, 16, 19, 3, 10, 9, 18, 24, 1]",32,markdown_table,1
TSPTW,TSPTW,"There’s a tuner with a van, a handful of schools, and a single-day route to sort out: begin at the workshop, visit every school once during its available lesson period, then return to the workshop. What makes one route nicer than another is how little driving it requires — the total distance comes from summing each leg of the trip — and arriving ahead of a lesson to wait is allowed if needed. The specific schools, their time windows, and distances appear below.

# total_locations_including_workshop=19
# workshop_id=1
# time windows are listed per node in the table
location_id,coord_x,coord_y,lesson_period_start,lesson_period_end
1,80,100,0,1067
2,50,100,116,359
3,84,90,21,263
4,82,89,359,563
5,81,87,296,530
6,90,86,254,473
7,100,66,61,271
8,88,67,27,239
9,86,56,257,537
10,98,56,315,576
11,32,51,42,264
12,91,44,120,338
13,81,45,199,445
14,44,41,138,366
15,49,43,321,592
16,22,20,119,402
17,73,5,369,595
18,100,5,137,380
19,0,0,365,644

When you send back the route, just paste a tiny JSON snippet that looks like this — nice and simple:

{
  ""solution"": [workshop_id, school_id, ..., workshop_id]
}

Here ""solution"" should be the tour: start at the workshop, list each school in the order you'll visit them, and finish back at the workshop. The placeholders (workshop_id and school_id) are just that — placeholders showing the shape I expect, not the real labels.

Please use the exact identifiers from the problem input when you fill this in — 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': [[80, 100], [50, 100], [84, 90], [82, 89], [81, 87], [90, 86], [100, 66], [88, 67], [86, 56], [98, 56], [32, 51], [91, 44], [81, 45], [44, 41], [49, 43], [22, 20], [73, 5], [100, 5], [0, 0]], 'depot': 0, 'num_nodes': 19, 'time_windows': [[0, 1067], [116, 359], [21, 263], [359, 563], [296, 530], [254, 473], [61, 271], [27, 239], [257, 537], [315, 576], [42, 264], [120, 338], [199, 445], [138, 366], [321, 592], [119, 402], [369, 595], [137, 380], [365, 644]], 'tour_length': 685.5836500353505, 'objective': 685.5836500353505}","[0, 2, 6, 7, 1, 10, 15, 13, 12, 11, 17, 16, 8, 9, 5, 3, 4, 14, 18, 0]",685.5836500353505,"{'problem_type': 'TSPTW', 'num_nodes': 19, 'nodes': [{'id': 1, 'x': 80, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 50, 'y': 100, 'tw_start': 116, 'tw_end': 359}, {'id': 3, 'x': 84, 'y': 90, 'tw_start': 21, 'tw_end': 263}, {'id': 4, 'x': 82, 'y': 89, 'tw_start': 359, 'tw_end': 563}, {'id': 5, 'x': 81, 'y': 87, 'tw_start': 296, 'tw_end': 530}, {'id': 6, 'x': 90, 'y': 86, 'tw_start': 254, 'tw_end': 473}, {'id': 7, 'x': 100, 'y': 66, 'tw_start': 61, 'tw_end': 271}, {'id': 8, 'x': 88, 'y': 67, 'tw_start': 27, 'tw_end': 239}, {'id': 9, 'x': 86, 'y': 56, 'tw_start': 257, 'tw_end': 537}, {'id': 10, 'x': 98, 'y': 56, 'tw_start': 315, 'tw_end': 576}, {'id': 11, 'x': 32, 'y': 51, 'tw_start': 42, 'tw_end': 264}, {'id': 12, 'x': 91, 'y': 44, 'tw_start': 120, 'tw_end': 338}, {'id': 13, 'x': 81, 'y': 45, 'tw_start': 199, 'tw_end': 445}, {'id': 14, 'x': 44, 'y': 41, 'tw_start': 138, 'tw_end': 366}, {'id': 15, 'x': 49, 'y': 43, 'tw_start': 321, 'tw_end': 592}, {'id': 16, 'x': 22, 'y': 20, 'tw_start': 119, 'tw_end': 402}, {'id': 17, 'x': 73, 'y': 5, 'tw_start': 369, 'tw_end': 595}, {'id': 18, 'x': 100, 'y': 5, 'tw_start': 137, 'tw_end': 380}, {'id': 19, 'x': 0, 'y': 0, 'tw_start': 365, 'tw_end': 644}], 'depot': 1, 'objective': 685.5836500353505}","[1, 3, 7, 8, 2, 11, 16, 14, 13, 12, 18, 17, 9, 10, 6, 4, 5, 15, 19, 1]",33,csv,1
TSPTW,TSPTW,"Out in the field, planning a tech’s day looks like this: pick a route that leaves the depot, hits every customer one time during the slot they were promised, and heads back to the depot at the end. What counts as a good route is simple — the one with the smallest sum of miles driven — and that sum comes from adding the distances between each pair of consecutive stops in the route plus the trip out and the trip back. Arriving before a window opens and waiting is allowed, but no customer can be missed or visited twice. The concrete route details and appointment times are shown below.

{
  ""total_locations_including_depot"": 17,
  ""nodes"": [
    {
      ""stop_id"": ""A"",
      ""location_x_coord"": 2,
      ""location_y_coord"": 79,
      ""earliest_allowed_arrival"": 0,
      ""latest_allowed_arrival"": 1067
    },
    {
      ""stop_id"": ""B"",
      ""location_x_coord"": 0,
      ""location_y_coord"": 85,
      ""earliest_allowed_arrival"": 150,
      ""latest_allowed_arrival"": 422
    },
    {
      ""stop_id"": ""C"",
      ""location_x_coord"": 12,
      ""location_y_coord"": 87,
      ""earliest_allowed_arrival"": 349,
      ""latest_allowed_arrival"": 563
    },
    {
      ""stop_id"": ""D"",
      ""location_x_coord"": 9,
      ""location_y_coord"": 79,
      ""earliest_allowed_arrival"": 25,
      ""latest_allowed_arrival"": 305
    },
    {
      ""stop_id"": ""E"",
      ""location_x_coord"": 13,
      ""location_y_coord"": 84,
      ""earliest_allowed_arrival"": 151,
      ""latest_allowed_arrival"": 397
    },
    {
      ""stop_id"": ""F"",
      ""location_x_coord"": 36,
      ""location_y_coord"": 95,
      ""earliest_allowed_arrival"": 375,
      ""latest_allowed_arrival"": 576
    },
    {
      ""stop_id"": ""G"",
      ""location_x_coord"": 39,
      ""location_y_coord"": 95,
      ""earliest_allowed_arrival"": 251,
      ""latest_allowed_arrival"": 452
    },
    {
      ""stop_id"": ""H"",
      ""location_x_coord"": 62,
      ""location_y_coord"": 33,
      ""earliest_allowed_arrival"": 145,
      ""latest_allowed_arrival"": 417
    },
    {
      ""stop_id"": ""I"",
      ""location_x_coord"": 71,
      ""location_y_coord"": 79,
      ""earliest_allowed_arrival"": 168,
      ""latest_allowed_arrival"": 458
    },
    {
      ""stop_id"": ""J"",
      ""location_x_coord"": 68,
      ""location_y_coord"": 100,
      ""earliest_allowed_arrival"": 216,
      ""latest_allowed_arrival"": 442
    },
    {
      ""stop_id"": ""K"",
      ""location_x_coord"": 74,
      ""location_y_coord"": 86,
      ""earliest_allowed_arrival"": 85,
      ""latest_allowed_arrival"": 313
    },
    {
      ""stop_id"": ""L"",
      ""location_x_coord"": 74,
      ""location_y_coord"": 33,
      ""earliest_allowed_arrival"": 144,
      ""latest_allowed_arrival"": 345
    },
    {
      ""stop_id"": ""M"",
      ""location_x_coord"": 74,
      ""location_y_coord"": 25,
      ""earliest_allowed_arrival"": 143,
      ""latest_allowed_arrival"": 382
    },
    {
      ""stop_id"": ""N"",
      ""location_x_coord"": 77,
      ""location_y_coord"": 4,
      ""earliest_allowed_arrival"": 280,
      ""latest_allowed_arrival"": 538
    },
    {
      ""stop_id"": ""O"",
      ""location_x_coord"": 77,
      ""location_y_coord"": 0,
      ""earliest_allowed_arrival"": 275,
      ""latest_allowed_arrival"": 469
    },
    {
      ""stop_id"": ""P"",
      ""location_x_coord"": 98,
      ""location_y_coord"": 41,
      ""earliest_allowed_arrival"": 84,
      ""latest_allowed_arrival"": 342
    },
    {
      ""stop_id"": ""Q"",
      ""location_x_coord"": 100,
      ""location_y_coord"": 41,
      ""earliest_allowed_arrival"": 187,
      ""latest_allowed_arrival"": 382
    }
  ],
  ""service_center_id"": ""A""
}

And hey — when you send the route back, please use a tiny JSON shape so it's easy to read and plug in. Something like this:

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

This little block just means: put the stops in order inside ""solution"", starting at the depot and finishing at the depot, with every customer listed exactly once. It's just a quick sketch of the shape I need, not the real answer itself.

Please don’t rename any of the identifiers from the instance input — use them exactly as given, no made-up labels. 
- for example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[2, 79], [0, 85], [12, 87], [9, 79], [13, 84], [36, 95], [39, 95], [62, 33], [71, 79], [68, 100], [74, 86], [74, 33], [74, 25], [77, 4], [77, 0], [98, 41], [100, 41]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [150, 422], [349, 563], [25, 305], [151, 397], [375, 576], [251, 452], [145, 417], [168, 458], [216, 442], [85, 313], [144, 345], [143, 382], [280, 538], [275, 469], [84, 342], [187, 382]], 'tour_length': 459.9904981631132, 'objective': 459.9904981631132}","[0, 10, 4, 1, 3, 7, 11, 12, 13, 14, 16, 15, 8, 9, 6, 5, 2, 0]",459.9904981631132,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 'A', 'x': 2, 'y': 79, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 85, 'tw_start': 150, 'tw_end': 422}, {'id': 'C', 'x': 12, 'y': 87, 'tw_start': 349, 'tw_end': 563}, {'id': 'D', 'x': 9, 'y': 79, 'tw_start': 25, 'tw_end': 305}, {'id': 'E', 'x': 13, 'y': 84, 'tw_start': 151, 'tw_end': 397}, {'id': 'F', 'x': 36, 'y': 95, 'tw_start': 375, 'tw_end': 576}, {'id': 'G', 'x': 39, 'y': 95, 'tw_start': 251, 'tw_end': 452}, {'id': 'H', 'x': 62, 'y': 33, 'tw_start': 145, 'tw_end': 417}, {'id': 'I', 'x': 71, 'y': 79, 'tw_start': 168, 'tw_end': 458}, {'id': 'J', 'x': 68, 'y': 100, 'tw_start': 216, 'tw_end': 442}, {'id': 'K', 'x': 74, 'y': 86, 'tw_start': 85, 'tw_end': 313}, {'id': 'L', 'x': 74, 'y': 33, 'tw_start': 144, 'tw_end': 345}, {'id': 'M', 'x': 74, 'y': 25, 'tw_start': 143, 'tw_end': 382}, {'id': 'N', 'x': 77, 'y': 4, 'tw_start': 280, 'tw_end': 538}, {'id': 'O', 'x': 77, 'y': 0, 'tw_start': 275, 'tw_end': 469}, {'id': 'P', 'x': 98, 'y': 41, 'tw_start': 84, 'tw_end': 342}, {'id': 'Q', 'x': 100, 'y': 41, 'tw_start': 187, 'tw_end': 382}], 'depot': 'A', 'objective': 459.9904981631132}","['A', 'K', 'E', 'B', 'D', 'H', 'L', 'M', 'N', 'O', 'Q', 'P', 'I', 'J', 'G', 'F', 'C', 'A']",34,json,names
TSPTW,TSPTW,"We’ve got a vintage-car rally that starts at the clubhouse, must call at each museum and landmark exactly one time, and then finishes back at the clubhouse. The crew has to decide the visiting order, making sure each stop is reached during its hours (waiting is allowed if they get there early). What makes one visiting order better than another is simply how many miles the cars end up doing — total miles are found by adding every segment between consecutive stops, including the return — and the goal is the route with the smallest total. The concrete stops, hours and distances appear below.

There are 18 locations in total, with the clubhouse at A.

| stop_id | map_x_coordinate | map_y_coordinate | opening_time | closing_time |
|---|---|---|---|---|
| A | 100 | 63 | 0 | 1067 |
| B | 48 | 100 | 312 | 581 |
| C | 71 | 61 | 212 | 413 |
| D | 36 | 59 | 297 | 548 |
| E | 100 | 25 | 303 | 570 |
| F | 92 | 45 | 311 | 555 |
| G | 100 | 24 | 54 | 313 |
| H | 24 | 66 | 240 | 506 |
| I | 10 | 47 | 65 | 278 |
| J | 0 | 96 | 345 | 612 |
| K | 12 | 65 | 352 | 619 |
| L | 99 | 82 | 231 | 489 |
| M | 95 | 91 | 344 | 595 |
| N | 100 | 86 | 245 | 454 |
| O | 74 | 26 | 183 | 447 |
| P | 30 | 0 | 105 | 318 |
| Q | 39 | 77 | 121 | 339 |
| R | 44 | 13 | 83 | 318 |

We’ll use these entries to plan the shortest route that starts and ends at A while visiting all 18 stops within their hours.

Also, when you send back the chosen route, please use this simple JSON layout so it's easy to read and feed into whatever's checking the rally results:

{
  ""solution"": [""clubhouse_id"", ""museum_id"", ..., ""clubhouse_id""]
}

This just says: ""solution"" is the tour as an ordered list — start at the clubhouse, list each stop in visiting order, and finish back at the clubhouse. The quoted names in the array are placeholders: swap them for the exact identifiers from the instance when you give the real route. It's just a sketch of the shape I need, not the final answer itself.

Please use the identifiers exactly as they appear in the instance input — no renaming and no invented labels. 
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[100, 63], [48, 100], [71, 61], [36, 59], [100, 25], [92, 45], [100, 24], [24, 66], [10, 47], [0, 96], [12, 65], [99, 82], [95, 91], [100, 86], [74, 26], [30, 0], [39, 77], [44, 13]], 'depot': 0, 'num_nodes': 18, 'time_windows': [[0, 1067], [312, 581], [212, 413], [297, 548], [303, 570], [311, 555], [54, 313], [240, 506], [65, 278], [345, 612], [352, 619], [231, 489], [344, 595], [245, 454], [183, 447], [105, 318], [121, 339], [83, 318]], 'tour_length': 549.295984250807, 'objective': 549.295984250807}","[0, 16, 8, 15, 17, 14, 6, 4, 5, 11, 13, 12, 2, 3, 7, 10, 9, 1, 0]",549.295984250807,"{'problem_type': 'TSPTW', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 100, 'y': 63, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 48, 'y': 100, 'tw_start': 312, 'tw_end': 581}, {'id': 'C', 'x': 71, 'y': 61, 'tw_start': 212, 'tw_end': 413}, {'id': 'D', 'x': 36, 'y': 59, 'tw_start': 297, 'tw_end': 548}, {'id': 'E', 'x': 100, 'y': 25, 'tw_start': 303, 'tw_end': 570}, {'id': 'F', 'x': 92, 'y': 45, 'tw_start': 311, 'tw_end': 555}, {'id': 'G', 'x': 100, 'y': 24, 'tw_start': 54, 'tw_end': 313}, {'id': 'H', 'x': 24, 'y': 66, 'tw_start': 240, 'tw_end': 506}, {'id': 'I', 'x': 10, 'y': 47, 'tw_start': 65, 'tw_end': 278}, {'id': 'J', 'x': 0, 'y': 96, 'tw_start': 345, 'tw_end': 612}, {'id': 'K', 'x': 12, 'y': 65, 'tw_start': 352, 'tw_end': 619}, {'id': 'L', 'x': 99, 'y': 82, 'tw_start': 231, 'tw_end': 489}, {'id': 'M', 'x': 95, 'y': 91, 'tw_start': 344, 'tw_end': 595}, {'id': 'N', 'x': 100, 'y': 86, 'tw_start': 245, 'tw_end': 454}, {'id': 'O', 'x': 74, 'y': 26, 'tw_start': 183, 'tw_end': 447}, {'id': 'P', 'x': 30, 'y': 0, 'tw_start': 105, 'tw_end': 318}, {'id': 'Q', 'x': 39, 'y': 77, 'tw_start': 121, 'tw_end': 339}, {'id': 'R', 'x': 44, 'y': 13, 'tw_start': 83, 'tw_end': 318}], 'depot': 'A', 'objective': 549.295984250807}","['A', 'Q', 'I', 'P', 'R', 'O', 'G', 'E', 'F', 'L', 'N', 'M', 'C', 'D', 'H', 'K', 'J', 'B', 'A']",35,markdown_table,names
TSPTW,TSPTW,"On a typical service day, the technician must leave the garage, go out to a collection of sites (each expecting service only during a given time window), and return home, making sure each site is visited exactly once and waiting if arriving early. The goal is to arrange the order and timing so the round trip uses as few miles as possible — the total distance being the sum of all legs between stops. The precise locations and their time slots are shown below.

The technician will consider 21 locations in total, with the garage identified as node 1.

| location_id | map_x_coordinate | map_y_coordinate | service_time_window_start | service_time_window_end |
|---|---|---|---|---|
| 1 | 2 | 42 | 0 | 1240 |
| 2 | 5 | 79 | 409 | 692 |
| 3 | 5 | 85 | 84 | 318 |
| 4 | 5 | 91 | 313 | 582 |
| 5 | 9 | 94 | 370 | 670 |
| 6 | 19 | 0 | 359 | 615 |
| 7 | 19 | 73 | 312 | 567 |
| 8 | 26 | 91 | 423 | 720 |
| 9 | 26 | 100 | 146 | 402 |
| 10 | 30 | 91 | 86 | 389 |
| 11 | 44 | 100 | 98 | 391 |
| 12 | 58 | 28 | 119 | 419 |
| 13 | 65 | 48 | 367 | 680 |
| 14 | 65 | 61 | 343 | 589 |
| 15 | 68 | 0 | 39 | 344 |
| 16 | 86 | 30 | 166 | 440 |
| 17 | 89 | 30 | 14 | 268 |
| 18 | 100 | 45 | 15 | 339 |
| 19 | 100 | 61 | 109 | 398 |
| 20 | 0 | 98 | 17 | 318 |
| 21 | 42 | 42 | 145 | 472 |

The technician must schedule visits for these 21 locations (garage 1) so the round trip covers as few miles as possible.

Also, when you send back the final route, just use a small JSON snippet like this so it's easy to parse:

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

Think of this as a little form: ""solution"" is the ordered list of stops — start at the garage, go visit each site once in the order shown, and then come back to the garage. The garage_id and site_id bits are just placeholders showing where the actual stop identifiers go. This block is only a sketch of the shape I want, not the actual route.

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': [[2, 42], [5, 79], [5, 85], [5, 91], [9, 94], [19, 0], [19, 73], [26, 91], [26, 100], [30, 91], [44, 100], [58, 28], [65, 48], [65, 61], [68, 0], [86, 30], [89, 30], [100, 45], [100, 61], [0, 98], [42, 42]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [409, 692], [84, 318], [313, 582], [370, 670], [359, 615], [312, 567], [423, 720], [146, 402], [86, 389], [98, 391], [119, 419], [367, 680], [343, 589], [39, 344], [166, 440], [14, 268], [15, 339], [109, 398], [17, 318], [145, 472]], 'tour_length': 545.6102720684523, 'objective': 545.6102720684523}","[0, 2, 19, 9, 8, 10, 18, 17, 16, 15, 14, 5, 11, 20, 12, 13, 7, 4, 3, 1, 6, 0]",545.6102720684523,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 1, 'x': 2, 'y': 42, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 5, 'y': 79, 'tw_start': 409, 'tw_end': 692}, {'id': 3, 'x': 5, 'y': 85, 'tw_start': 84, 'tw_end': 318}, {'id': 4, 'x': 5, 'y': 91, 'tw_start': 313, 'tw_end': 582}, {'id': 5, 'x': 9, 'y': 94, 'tw_start': 370, 'tw_end': 670}, {'id': 6, 'x': 19, 'y': 0, 'tw_start': 359, 'tw_end': 615}, {'id': 7, 'x': 19, 'y': 73, 'tw_start': 312, 'tw_end': 567}, {'id': 8, 'x': 26, 'y': 91, 'tw_start': 423, 'tw_end': 720}, {'id': 9, 'x': 26, 'y': 100, 'tw_start': 146, 'tw_end': 402}, {'id': 10, 'x': 30, 'y': 91, 'tw_start': 86, 'tw_end': 389}, {'id': 11, 'x': 44, 'y': 100, 'tw_start': 98, 'tw_end': 391}, {'id': 12, 'x': 58, 'y': 28, 'tw_start': 119, 'tw_end': 419}, {'id': 13, 'x': 65, 'y': 48, 'tw_start': 367, 'tw_end': 680}, {'id': 14, 'x': 65, 'y': 61, 'tw_start': 343, 'tw_end': 589}, {'id': 15, 'x': 68, 'y': 0, 'tw_start': 39, 'tw_end': 344}, {'id': 16, 'x': 86, 'y': 30, 'tw_start': 166, 'tw_end': 440}, {'id': 17, 'x': 89, 'y': 30, 'tw_start': 14, 'tw_end': 268}, {'id': 18, 'x': 100, 'y': 45, 'tw_start': 15, 'tw_end': 339}, {'id': 19, 'x': 100, 'y': 61, 'tw_start': 109, 'tw_end': 398}, {'id': 20, 'x': 0, 'y': 98, 'tw_start': 17, 'tw_end': 318}, {'id': 21, 'x': 42, 'y': 42, 'tw_start': 145, 'tw_end': 472}], 'depot': 1, 'objective': 545.6102720684523}","[1, 3, 20, 10, 9, 11, 19, 18, 17, 16, 15, 6, 12, 21, 13, 14, 8, 5, 4, 2, 7, 1]",36,markdown_table,1
TSPTW,TSPTW,"There’s a morning puzzle at the community shuttle: the van needs to head out from the depot, stop at each registered rider’s place exactly once during that rider’s pickup window (it can wait if it gets there too soon), and then return to base. The goal is straightforward in plain terms — keep the total driving distance down by summing all the segments of the route and picking the shortest possible loop that still meets everyone’s time window. No stop can be skipped or visited twice. Concrete details about riders, locations, and windows appear below.

Below are the 18 locations (including depot A) to visit in that loop.
Stop A: coordinates (0, 58); pickup window 0 to 1067.
Stop B: coordinates (0, 76); pickup window 344 to 570.
Stop C: coordinates (20, 68); pickup window 349 to 640.
Stop D: coordinates (32, 50); pickup window 320 to 596.
Stop E: coordinates (40, 34); pickup window 96 to 346.
Stop F: coordinates (56, 34); pickup window 26 to 229.
Stop G: coordinates (78, 61); pickup window 387 to 613.
Stop H: coordinates (84, 100); pickup window 290 to 562.
Stop I: coordinates (100, 84); pickup window 332 to 623.
Stop J: coordinates (84, 39); pickup window 93 to 291.
Stop K: coordinates (92, 32); pickup window 159 to 366.
Stop L: coordinates (100, 26); pickup window 8 to 237.
Stop M: coordinates (86, 16); pickup window 304 to 553.
Stop N: coordinates (76, 0); pickup window 121 to 378.
Stop O: coordinates (48, 3); pickup window 90 to 285.
Stop P: coordinates (30, 16); pickup window 296 to 551.
Stop Q: coordinates (16, 42); pickup window 295 to 493.
Stop R: coordinates (12, 42); pickup window 324 to 578.
The route must start and end at depot A, visiting each of the 18 locations exactly once within their windows.

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

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

""solution"" should be the ordered list of stops: start at the depot, visit each rider once in the order shown, and finish back at the depot. The names in the array above are placeholders to show the shape of the answer — this is just a sketch, not the actual route.

Please use the exact identifiers from the instance input — don’t rename or invent labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 58], [0, 76], [20, 68], [32, 50], [40, 34], [56, 34], [78, 61], [84, 100], [100, 84], [84, 39], [92, 32], [100, 26], [86, 16], [76, 0], [48, 3], [30, 16], [16, 42], [12, 42]], 'depot': 0, 'num_nodes': 18, 'time_windows': [[0, 1067], [344, 570], [349, 640], [320, 596], [96, 346], [26, 229], [387, 613], [290, 562], [332, 623], [93, 291], [159, 366], [8, 237], [304, 553], [121, 378], [90, 285], [296, 551], [295, 493], [324, 578]], 'tour_length': 561.0870789837885, 'objective': 561.0870789837885}","[0, 4, 14, 5, 9, 10, 11, 12, 13, 15, 17, 16, 3, 2, 1, 7, 8, 6, 0]",561.0870789837885,"{'problem_type': 'TSPTW', 'num_nodes': 18, 'nodes': [{'id': 'A', 'x': 0, 'y': 58, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 76, 'tw_start': 344, 'tw_end': 570}, {'id': 'C', 'x': 20, 'y': 68, 'tw_start': 349, 'tw_end': 640}, {'id': 'D', 'x': 32, 'y': 50, 'tw_start': 320, 'tw_end': 596}, {'id': 'E', 'x': 40, 'y': 34, 'tw_start': 96, 'tw_end': 346}, {'id': 'F', 'x': 56, 'y': 34, 'tw_start': 26, 'tw_end': 229}, {'id': 'G', 'x': 78, 'y': 61, 'tw_start': 387, 'tw_end': 613}, {'id': 'H', 'x': 84, 'y': 100, 'tw_start': 290, 'tw_end': 562}, {'id': 'I', 'x': 100, 'y': 84, 'tw_start': 332, 'tw_end': 623}, {'id': 'J', 'x': 84, 'y': 39, 'tw_start': 93, 'tw_end': 291}, {'id': 'K', 'x': 92, 'y': 32, 'tw_start': 159, 'tw_end': 366}, {'id': 'L', 'x': 100, 'y': 26, 'tw_start': 8, 'tw_end': 237}, {'id': 'M', 'x': 86, 'y': 16, 'tw_start': 304, 'tw_end': 553}, {'id': 'N', 'x': 76, 'y': 0, 'tw_start': 121, 'tw_end': 378}, {'id': 'O', 'x': 48, 'y': 3, 'tw_start': 90, 'tw_end': 285}, {'id': 'P', 'x': 30, 'y': 16, 'tw_start': 296, 'tw_end': 551}, {'id': 'Q', 'x': 16, 'y': 42, 'tw_start': 295, 'tw_end': 493}, {'id': 'R', 'x': 12, 'y': 42, 'tw_start': 324, 'tw_end': 578}], 'depot': 'A', 'objective': 561.0870789837885}","['A', 'E', 'O', 'F', 'J', 'K', 'L', 'M', 'N', 'P', 'R', 'Q', 'D', 'C', 'B', 'H', 'I', 'G', 'A']",37,nl,names
TSPTW,TSPTW,"There’s a repair crew that needs a daily run: one technician leaves the shop, visits each customer one time during their appointment window (they can hang out if they get there early), and then returns to the shop. The goal is to choose the sequence of stops so the total miles driven — the sum of distances from the shop through every house and back — is as small as possible. It’s important that every household gets exactly one visit and nobody is visited twice or left out. The concrete details follow below.

# total_locations_count=23
# shop_node=1
# time windows are listed per node in the table
location_id,coord_x,coord_y,appointment_window_start,appointment_window_end
1,53,91,0,1240
2,85,73,8,321
3,0,71,274,579
4,8,71,378,694
5,100,70,433,719
6,86,70,220,491
7,81,70,69,359
8,53,70,124,454
9,65,67,263,555
10,79,60,160,391
11,58,58,14,287
12,73,58,38,332
13,48,57,397,722
14,85,57,297,546
15,47,53,389,714
16,27,33,88,397
17,45,33,129,445
18,44,33,449,678
19,38,21,404,700
20,43,20,438,716
21,74,100,382,614
22,23,1,151,384
23,76,0,439,757

Also, when you send back the route, please put it in a little JSON sketch so it's easy to read and check. Something like this:

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

Here ""solution"" is just the ordered list of stops for the day: start at the shop, go to each customer once, and come back to the shop. The placeholders shop_id and customer_id are just examples showing the kind of labels that go in the list — think of them like blanks you fill in with the actual IDs from the instance. This JSON is just the shape I want you to follow, not the real answer itself.

Please make sure you 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': [[53, 91], [85, 73], [0, 71], [8, 71], [100, 70], [86, 70], [81, 70], [53, 70], [65, 67], [79, 60], [58, 58], [73, 58], [48, 57], [85, 57], [47, 53], [27, 33], [45, 33], [44, 33], [38, 21], [43, 20], [74, 100], [23, 1], [76, 0]], 'depot': 0, 'num_nodes': 23, 'time_windows': [[0, 1240], [8, 321], [274, 579], [378, 694], [433, 719], [220, 491], [69, 359], [124, 454], [263, 555], [160, 391], [14, 287], [38, 332], [397, 722], [297, 546], [389, 714], [88, 397], [129, 445], [449, 678], [404, 700], [438, 716], [382, 614], [151, 384], [439, 757]], 'tour_length': 586.826904808321, 'objective': 586.826904808321}","[0, 7, 15, 21, 16, 10, 8, 11, 9, 13, 1, 6, 5, 4, 20, 2, 3, 12, 14, 17, 18, 19, 22, 0]",586.826904808321,"{'problem_type': 'TSPTW', 'num_nodes': 23, 'nodes': [{'id': 1, 'x': 53, 'y': 91, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 85, 'y': 73, 'tw_start': 8, 'tw_end': 321}, {'id': 3, 'x': 0, 'y': 71, 'tw_start': 274, 'tw_end': 579}, {'id': 4, 'x': 8, 'y': 71, 'tw_start': 378, 'tw_end': 694}, {'id': 5, 'x': 100, 'y': 70, 'tw_start': 433, 'tw_end': 719}, {'id': 6, 'x': 86, 'y': 70, 'tw_start': 220, 'tw_end': 491}, {'id': 7, 'x': 81, 'y': 70, 'tw_start': 69, 'tw_end': 359}, {'id': 8, 'x': 53, 'y': 70, 'tw_start': 124, 'tw_end': 454}, {'id': 9, 'x': 65, 'y': 67, 'tw_start': 263, 'tw_end': 555}, {'id': 10, 'x': 79, 'y': 60, 'tw_start': 160, 'tw_end': 391}, {'id': 11, 'x': 58, 'y': 58, 'tw_start': 14, 'tw_end': 287}, {'id': 12, 'x': 73, 'y': 58, 'tw_start': 38, 'tw_end': 332}, {'id': 13, 'x': 48, 'y': 57, 'tw_start': 397, 'tw_end': 722}, {'id': 14, 'x': 85, 'y': 57, 'tw_start': 297, 'tw_end': 546}, {'id': 15, 'x': 47, 'y': 53, 'tw_start': 389, 'tw_end': 714}, {'id': 16, 'x': 27, 'y': 33, 'tw_start': 88, 'tw_end': 397}, {'id': 17, 'x': 45, 'y': 33, 'tw_start': 129, 'tw_end': 445}, {'id': 18, 'x': 44, 'y': 33, 'tw_start': 449, 'tw_end': 678}, {'id': 19, 'x': 38, 'y': 21, 'tw_start': 404, 'tw_end': 700}, {'id': 20, 'x': 43, 'y': 20, 'tw_start': 438, 'tw_end': 716}, {'id': 21, 'x': 74, 'y': 100, 'tw_start': 382, 'tw_end': 614}, {'id': 22, 'x': 23, 'y': 1, 'tw_start': 151, 'tw_end': 384}, {'id': 23, 'x': 76, 'y': 0, 'tw_start': 439, 'tw_end': 757}], 'depot': 1, 'objective': 586.826904808321}","[1, 8, 16, 22, 17, 11, 9, 12, 10, 14, 2, 7, 6, 5, 21, 3, 4, 13, 15, 18, 19, 20, 23, 1]",38,csv,1
TSPTW,TSPTW,"Someone has to map out the phlebotomist’s day so they can start at the lab, hit each appointment once within its window (it’s fine to wait if an appointment’s not open yet), and finish back at the lab. The clear goal is to pick the order of visits that yields the least total travel distance — simply add up the distances between stops and back to the lab to get that number. The full list of locations and their time slots appears below.

There are 16 locations including the lab A that must be visited in the route.

| stop_id | coord_x | coord_y | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| A | 0 | 35 | 0 | 1067 |
| B | 17 | 32 | 311 | 519 |
| C | 14 | 38 | 225 | 468 |
| D | 19 | 40 | 55 | 310 |
| E | 31 | 53 | 106 | 347 |
| F | 43 | 74 | 31 | 270 |
| G | 39 | 87 | 118 | 392 |
| H | 39 | 92 | 22 | 256 |
| I | 39 | 95 | 177 | 442 |
| J | 34 | 100 | 222 | 481 |
| K | 39 | 100 | 301 | 579 |
| L | 45 | 100 | 121 | 367 |
| M | 48 | 100 | 325 | 615 |
| N | 36 | 40 | 345 | 575 |
| O | 100 | 0 | 75 | 317 |
| P | 98 | 0 | 287 | 529 |

Someone should choose the visit order that starts and ends at A and visits every appointment once, minimizing total travel distance.

You can just send back the visit order in a little JSON snippet like this so it's easy to read and use.

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

Think of that array as the day’s itinerary: start at the lab (the first lab_id), list each appointment once in the order you plan to visit them, and finish back at the lab (the final lab_id). It’s just a simple checklist-style list, nothing fancy.

Please use the exact identifiers that appear in the instance input — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[0, 35], [17, 32], [14, 38], [19, 40], [31, 53], [43, 74], [39, 87], [39, 92], [39, 95], [34, 100], [39, 100], [45, 100], [48, 100], [36, 40], [100, 0], [98, 0]], 'depot': 0, 'num_nodes': 16, 'time_windows': [[0, 1067], [311, 519], [225, 468], [55, 310], [106, 347], [31, 270], [118, 392], [22, 256], [177, 442], [222, 481], [301, 579], [121, 367], [325, 615], [345, 575], [75, 317], [287, 529]], 'tour_length': 468.11972088706057, 'objective': 468.11972088706057}","[0, 3, 4, 5, 6, 7, 8, 11, 14, 15, 13, 1, 2, 9, 10, 12, 0]",468.11972088706057,"{'problem_type': 'TSPTW', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 0, 'y': 35, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 17, 'y': 32, 'tw_start': 311, 'tw_end': 519}, {'id': 'C', 'x': 14, 'y': 38, 'tw_start': 225, 'tw_end': 468}, {'id': 'D', 'x': 19, 'y': 40, 'tw_start': 55, 'tw_end': 310}, {'id': 'E', 'x': 31, 'y': 53, 'tw_start': 106, 'tw_end': 347}, {'id': 'F', 'x': 43, 'y': 74, 'tw_start': 31, 'tw_end': 270}, {'id': 'G', 'x': 39, 'y': 87, 'tw_start': 118, 'tw_end': 392}, {'id': 'H', 'x': 39, 'y': 92, 'tw_start': 22, 'tw_end': 256}, {'id': 'I', 'x': 39, 'y': 95, 'tw_start': 177, 'tw_end': 442}, {'id': 'J', 'x': 34, 'y': 100, 'tw_start': 222, 'tw_end': 481}, {'id': 'K', 'x': 39, 'y': 100, 'tw_start': 301, 'tw_end': 579}, {'id': 'L', 'x': 45, 'y': 100, 'tw_start': 121, 'tw_end': 367}, {'id': 'M', 'x': 48, 'y': 100, 'tw_start': 325, 'tw_end': 615}, {'id': 'N', 'x': 36, 'y': 40, 'tw_start': 345, 'tw_end': 575}, {'id': 'O', 'x': 100, 'y': 0, 'tw_start': 75, 'tw_end': 317}, {'id': 'P', 'x': 98, 'y': 0, 'tw_start': 287, 'tw_end': 529}], 'depot': 'A', 'objective': 468.11972088706057}","['A', 'D', 'E', 'F', 'G', 'H', 'I', 'L', 'O', 'P', 'N', 'B', 'C', 'J', 'K', 'M', 'A']",39,markdown_table,names
TSPTW,TSPTW,"Back at the warehouse the team is figuring out today’s loop: leave the yard, top up each stand one time only during that stand’s allowed restocking window (pauses are fine if the crew is early), and come home when done. The winning route is simply the one that minimizes total driving distance — add the distance from warehouse to the first stand, each stretch between successive stands, and the leg back to the warehouse to get the total. No stand can be skipped or repeated, and the concrete instance details follow below.

{
  ""total_locations_including_warehouse"": 21,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""map_x_coordinate"": 24,
      ""map_y_coordinate"": 44,
      ""restock_window_start"": 0,
      ""restock_window_end"": 1240
    },
    {
      ""location_id"": ""B"",
      ""map_x_coordinate"": 49,
      ""map_y_coordinate"": 91,
      ""restock_window_start"": 358,
      ""restock_window_end"": 604
    },
    {
      ""location_id"": ""C"",
      ""map_x_coordinate"": 72,
      ""map_y_coordinate"": 62,
      ""restock_window_start"": 303,
      ""restock_window_end"": 553
    },
    {
      ""location_id"": ""D"",
      ""map_x_coordinate"": 39,
      ""map_y_coordinate"": 80,
      ""restock_window_start"": 98,
      ""restock_window_end"": 422
    },
    {
      ""location_id"": ""E"",
      ""map_x_coordinate"": 74,
      ""map_y_coordinate"": 52,
      ""restock_window_start"": 112,
      ""restock_window_end"": 367
    },
    {
      ""location_id"": ""F"",
      ""map_x_coordinate"": 83,
      ""map_y_coordinate"": 28,
      ""restock_window_start"": 0,
      ""restock_window_end"": 323
    },
    {
      ""location_id"": ""G"",
      ""map_x_coordinate"": 81,
      ""map_y_coordinate"": 6,
      ""restock_window_start"": 357,
      ""restock_window_end"": 653
    },
    {
      ""location_id"": ""H"",
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 11,
      ""restock_window_start"": 338,
      ""restock_window_end"": 581
    },
    {
      ""location_id"": ""I"",
      ""map_x_coordinate"": 26,
      ""map_y_coordinate"": 100,
      ""restock_window_start"": 206,
      ""restock_window_end"": 471
    },
    {
      ""location_id"": ""J"",
      ""map_x_coordinate"": 28,
      ""map_y_coordinate"": 0,
      ""restock_window_start"": 42,
      ""restock_window_end"": 322
    },
    {
      ""location_id"": ""K"",
      ""map_x_coordinate"": 81,
      ""map_y_coordinate"": 43,
      ""restock_window_start"": 415,
      ""restock_window_end"": 645
    },
    {
      ""location_id"": ""L"",
      ""map_x_coordinate"": 33,
      ""map_y_coordinate"": 49,
      ""restock_window_start"": 131,
      ""restock_window_end"": 380
    },
    {
      ""location_id"": ""M"",
      ""map_x_coordinate"": 50,
      ""map_y_coordinate"": 49,
      ""restock_window_start"": 107,
      ""restock_window_end"": 435
    },
    {
      ""location_id"": ""N"",
      ""map_x_coordinate"": 63,
      ""map_y_coordinate"": 87,
      ""restock_window_start"": 211,
      ""restock_window_end"": 489
    },
    {
      ""location_id"": ""O"",
      ""map_x_coordinate"": 14,
      ""map_y_coordinate"": 48,
      ""restock_window_start"": 343,
      ""restock_window_end"": 585
    },
    {
      ""location_id"": ""P"",
      ""map_x_coordinate"": 53,
      ""map_y_coordinate"": 20,
      ""restock_window_start"": 219,
      ""restock_window_end"": 493
    },
    {
      ""location_id"": ""Q"",
      ""map_x_coordinate"": 11,
      ""map_y_coordinate"": 58,
      ""restock_window_start"": 269,
      ""restock_window_end"": 607
    },
    {
      ""location_id"": ""R"",
      ""map_x_coordinate"": 83,
      ""map_y_coordinate"": 48,
      ""restock_window_start"": 347,
      ""restock_window_end"": 617
    },
    {
      ""location_id"": ""S"",
      ""map_x_coordinate"": 50,
      ""map_y_coordinate"": 91,
      ""restock_window_start"": 373,
      ""restock_window_end"": 617
    },
    {
      ""location_id"": ""T"",
      ""map_x_coordinate"": 96,
      ""map_y_coordinate"": 58,
      ""restock_window_start"": 13,
      ""restock_window_end"": 262
    },
    {
      ""location_id"": ""U"",
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 30,
      ""restock_window_start"": 153,
      ""restock_window_end"": 436
    }
  ],
  ""warehouse_id"": ""A""
}

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

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

Think of that as a simple form: ""solution"" holds the ordered list of stops — start at the warehouse, visit each stand exactly once (waiting is fine if you arrive early), and finish back at the warehouse. The names in the array are just placeholders showing the expected layout, not the real IDs.

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': [[24, 44], [49, 91], [72, 62], [39, 80], [74, 52], [83, 28], [81, 6], [0, 11], [26, 100], [28, 0], [81, 43], [33, 49], [50, 49], [63, 87], [14, 48], [53, 20], [11, 58], [83, 48], [50, 91], [96, 58], [100, 30]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [358, 604], [303, 553], [98, 422], [112, 367], [0, 323], [357, 653], [338, 581], [206, 471], [42, 322], [415, 645], [131, 380], [107, 435], [211, 489], [343, 585], [219, 493], [269, 607], [347, 617], [373, 617], [13, 262], [153, 436]], 'tour_length': 562.2783266499762, 'objective': 562.2783266499762}","[0, 3, 11, 12, 4, 19, 20, 5, 15, 9, 7, 14, 16, 8, 1, 18, 13, 2, 17, 10, 6, 0]",562.2783266499762,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 'A', 'x': 24, 'y': 44, 'tw_start': 0, 'tw_end': 1240}, {'id': 'B', 'x': 49, 'y': 91, 'tw_start': 358, 'tw_end': 604}, {'id': 'C', 'x': 72, 'y': 62, 'tw_start': 303, 'tw_end': 553}, {'id': 'D', 'x': 39, 'y': 80, 'tw_start': 98, 'tw_end': 422}, {'id': 'E', 'x': 74, 'y': 52, 'tw_start': 112, 'tw_end': 367}, {'id': 'F', 'x': 83, 'y': 28, 'tw_start': 0, 'tw_end': 323}, {'id': 'G', 'x': 81, 'y': 6, 'tw_start': 357, 'tw_end': 653}, {'id': 'H', 'x': 0, 'y': 11, 'tw_start': 338, 'tw_end': 581}, {'id': 'I', 'x': 26, 'y': 100, 'tw_start': 206, 'tw_end': 471}, {'id': 'J', 'x': 28, 'y': 0, 'tw_start': 42, 'tw_end': 322}, {'id': 'K', 'x': 81, 'y': 43, 'tw_start': 415, 'tw_end': 645}, {'id': 'L', 'x': 33, 'y': 49, 'tw_start': 131, 'tw_end': 380}, {'id': 'M', 'x': 50, 'y': 49, 'tw_start': 107, 'tw_end': 435}, {'id': 'N', 'x': 63, 'y': 87, 'tw_start': 211, 'tw_end': 489}, {'id': 'O', 'x': 14, 'y': 48, 'tw_start': 343, 'tw_end': 585}, {'id': 'P', 'x': 53, 'y': 20, 'tw_start': 219, 'tw_end': 493}, {'id': 'Q', 'x': 11, 'y': 58, 'tw_start': 269, 'tw_end': 607}, {'id': 'R', 'x': 83, 'y': 48, 'tw_start': 347, 'tw_end': 617}, {'id': 'S', 'x': 50, 'y': 91, 'tw_start': 373, 'tw_end': 617}, {'id': 'T', 'x': 96, 'y': 58, 'tw_start': 13, 'tw_end': 262}, {'id': 'U', 'x': 100, 'y': 30, 'tw_start': 153, 'tw_end': 436}], 'depot': 'A', 'objective': 562.2783266499762}","['A', 'D', 'L', 'M', 'E', 'T', 'U', 'F', 'P', 'J', 'H', 'O', 'Q', 'I', 'B', 'S', 'N', 'C', 'R', 'K', 'G', 'A']",40,json,names
TSPTW,TSPTW,"Someone who runs the medical-waste rounds needs a route that departs the facility, hits every clinic one time during its designated pickup period (waiting allowed if arriving early), and returns to the facility afterward. The key decision is the order of visits: different orders change the total driving needed, and the aim is to pick the order that leads to the least total driving distance — computed by summing each leg from the depot to the first stop, from each stop to the next, and finally back to the depot. Nothing can be skipped or doubled up, and each clinic’s pickup window must be obeyed. The detailed list of clinics, time windows, and distances is shown below.

There are 21 locations including the facility, and the facility node id is A.

| location_node_id | map_x_coordinate | map_y_coordinate | pickup_window_start | pickup_window_end |
|---|---|---|---|---|
| A | 46 | 3 | 0 | 1240 |
| B | 70 | 74 | 277 | 605 |
| C | 53 | 90 | 229 | 511 |
| D | 17 | 100 | 22 | 252 |
| E | 53 | 20 | 248 | 523 |
| F | 100 | 52 | 378 | 622 |
| G | 83 | 57 | 11 | 287 |
| H | 46 | 2 | 107 | 338 |
| I | 27 | 18 | 326 | 564 |
| J | 54 | 97 | 274 | 531 |
| K | 81 | 20 | 78 | 346 |
| L | 100 | 59 | 361 | 631 |
| M | 48 | 0 | 338 | 578 |
| N | 9 | 66 | 348 | 600 |
| O | 79 | 5 | 305 | 594 |
| P | 1 | 57 | 419 | 688 |
| Q | 1 | 36 | 29 | 257 |
| R | 53 | 80 | 372 | 657 |
| S | 14 | 94 | 349 | 601 |
| T | 80 | 66 | 155 | 384 |
| U | 0 | 12 | 433 | 734 |

These entries should be used to select the visit order that minimizes total driving distance while obeying every pickup window and returning to the facility.

When you send the final route back, just drop it in this simple JSON shape so it's easy to pick up:

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

Pretty straightforward — ""solution"" is the ordered list of stops (start at the depot, visit each clinic once, and end at the depot). Think of the items in the array as the exact IDs you see in the instance (this JSON is only a sketch of the shape I expect, not the actual route).

Please use the identifiers exactly as they appear in the problem 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': [[46, 3], [70, 74], [53, 90], [17, 100], [53, 20], [100, 52], [83, 57], [46, 2], [27, 18], [54, 97], [81, 20], [100, 59], [48, 0], [9, 66], [79, 5], [1, 57], [1, 36], [53, 80], [14, 94], [80, 66], [0, 12]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [277, 605], [229, 511], [22, 252], [248, 523], [378, 622], [11, 287], [107, 338], [326, 564], [274, 531], [78, 346], [361, 631], [338, 578], [348, 600], [305, 594], [419, 688], [29, 257], [372, 657], [349, 601], [155, 384], [433, 734]], 'tour_length': 670.7129645710203, 'objective': 670.7129645710203}","[0, 16, 3, 19, 6, 10, 4, 7, 8, 12, 14, 5, 11, 1, 17, 2, 9, 18, 13, 15, 20, 0]",670.7129645710203,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 'A', 'x': 46, 'y': 3, 'tw_start': 0, 'tw_end': 1240}, {'id': 'B', 'x': 70, 'y': 74, 'tw_start': 277, 'tw_end': 605}, {'id': 'C', 'x': 53, 'y': 90, 'tw_start': 229, 'tw_end': 511}, {'id': 'D', 'x': 17, 'y': 100, 'tw_start': 22, 'tw_end': 252}, {'id': 'E', 'x': 53, 'y': 20, 'tw_start': 248, 'tw_end': 523}, {'id': 'F', 'x': 100, 'y': 52, 'tw_start': 378, 'tw_end': 622}, {'id': 'G', 'x': 83, 'y': 57, 'tw_start': 11, 'tw_end': 287}, {'id': 'H', 'x': 46, 'y': 2, 'tw_start': 107, 'tw_end': 338}, {'id': 'I', 'x': 27, 'y': 18, 'tw_start': 326, 'tw_end': 564}, {'id': 'J', 'x': 54, 'y': 97, 'tw_start': 274, 'tw_end': 531}, {'id': 'K', 'x': 81, 'y': 20, 'tw_start': 78, 'tw_end': 346}, {'id': 'L', 'x': 100, 'y': 59, 'tw_start': 361, 'tw_end': 631}, {'id': 'M', 'x': 48, 'y': 0, 'tw_start': 338, 'tw_end': 578}, {'id': 'N', 'x': 9, 'y': 66, 'tw_start': 348, 'tw_end': 600}, {'id': 'O', 'x': 79, 'y': 5, 'tw_start': 305, 'tw_end': 594}, {'id': 'P', 'x': 1, 'y': 57, 'tw_start': 419, 'tw_end': 688}, {'id': 'Q', 'x': 1, 'y': 36, 'tw_start': 29, 'tw_end': 257}, {'id': 'R', 'x': 53, 'y': 80, 'tw_start': 372, 'tw_end': 657}, {'id': 'S', 'x': 14, 'y': 94, 'tw_start': 349, 'tw_end': 601}, {'id': 'T', 'x': 80, 'y': 66, 'tw_start': 155, 'tw_end': 384}, {'id': 'U', 'x': 0, 'y': 12, 'tw_start': 433, 'tw_end': 734}], 'depot': 'A', 'objective': 670.7129645710203}","['A', 'Q', 'D', 'T', 'G', 'K', 'E', 'H', 'I', 'M', 'O', 'F', 'L', 'B', 'R', 'C', 'J', 'S', 'N', 'P', 'U', 'A']",41,markdown_table,names
TSPTW,TSPTW,"Recently a detailer had to plan a day of driveway cleanings: start at the garage, hit every driveway one time during the customer’s requested window (it’s okay to wait if the window isn’t open yet), and then come back to base. The only thing that separates a decent day from a great one is how little driving is done overall — just add up the distances of each leg (garage to first stop, between stops, and back) and choose the route with the smallest sum. No driveways can be skipped or repeated, and every job must fall inside its time slot. The concrete route data is shown below.

{
  ""total_locations_including_garage"": 17,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""x_coordinate"": 88,
      ""y_coordinate"": 100,
      ""earliest_service_time"": 0,
      ""latest_service_time"": 1067
    },
    {
      ""location_id"": 2,
      ""x_coordinate"": 17,
      ""y_coordinate"": 64,
      ""earliest_service_time"": 362,
      ""latest_service_time"": 581
    },
    {
      ""location_id"": 3,
      ""x_coordinate"": 59,
      ""y_coordinate"": 83,
      ""earliest_service_time"": 237,
      ""latest_service_time"": 497
    },
    {
      ""location_id"": 4,
      ""x_coordinate"": 100,
      ""y_coordinate"": 10,
      ""earliest_service_time"": 123,
      ""latest_service_time"": 399
    },
    {
      ""location_id"": 5,
      ""x_coordinate"": 2,
      ""y_coordinate"": 33,
      ""earliest_service_time"": 367,
      ""latest_service_time"": 647
    },
    {
      ""location_id"": 6,
      ""x_coordinate"": 63,
      ""y_coordinate"": 100,
      ""earliest_service_time"": 286,
      ""latest_service_time"": 507
    },
    {
      ""location_id"": 7,
      ""x_coordinate"": 36,
      ""y_coordinate"": 14,
      ""earliest_service_time"": 109,
      ""latest_service_time"": 396
    },
    {
      ""location_id"": 8,
      ""x_coordinate"": 75,
      ""y_coordinate"": 82,
      ""earliest_service_time"": 3,
      ""latest_service_time"": 267
    },
    {
      ""location_id"": 9,
      ""x_coordinate"": 85,
      ""y_coordinate"": 9,
      ""earliest_service_time"": 274,
      ""latest_service_time"": 528
    },
    {
      ""location_id"": 10,
      ""x_coordinate"": 19,
      ""y_coordinate"": 86,
      ""earliest_service_time"": 384,
      ""latest_service_time"": 608
    },
    {
      ""location_id"": 11,
      ""x_coordinate"": 39,
      ""y_coordinate"": 19,
      ""earliest_service_time"": 131,
      ""latest_service_time"": 333
    },
    {
      ""location_id"": 12,
      ""x_coordinate"": 54,
      ""y_coordinate"": 5,
      ""earliest_service_time"": 171,
      ""latest_service_time"": 391
    },
    {
      ""location_id"": 13,
      ""x_coordinate"": 27,
      ""y_coordinate"": 53,
      ""earliest_service_time"": 133,
      ""latest_service_time"": 408
    },
    {
      ""location_id"": 14,
      ""x_coordinate"": 0,
      ""y_coordinate"": 70,
      ""earliest_service_time"": 362,
      ""latest_service_time"": 574
    },
    {
      ""location_id"": 15,
      ""x_coordinate"": 26,
      ""y_coordinate"": 48,
      ""earliest_service_time"": 144,
      ""latest_service_time"": 428
    },
    {
      ""location_id"": 16,
      ""x_coordinate"": 10,
      ""y_coordinate"": 0,
      ""earliest_service_time"": 23,
      ""latest_service_time"": 226
    },
    {
      ""location_id"": 17,
      ""x_coordinate"": 79,
      ""y_coordinate"": 95,
      ""earliest_service_time"": 63,
      ""latest_service_time"": 314
    }
  ],
  ""garage_node_id"": 1
}

Also, when you give the final route, please stick to this simple JSON shape so it's easy to parse:

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

Here ""solution"" is just the ordered list of stops: start at the garage, list each driveway once in the order they’re visited (you can wait if a time slot isn’t open yet), and end back at the garage. Think of the placeholders as the labels you’ll fill in from the instance — just a form to show the visited sequence. This JSON is only 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 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': [[88, 100], [17, 64], [59, 83], [100, 10], [2, 33], [63, 100], [36, 14], [75, 82], [85, 9], [19, 86], [39, 19], [54, 5], [27, 53], [0, 70], [26, 48], [10, 0], [79, 95]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [362, 581], [237, 497], [123, 399], [367, 647], [286, 507], [109, 396], [3, 267], [274, 528], [384, 608], [131, 333], [171, 391], [133, 408], [362, 574], [144, 428], [23, 226], [63, 314]], 'tour_length': 561.1427441571013, 'objective': 561.1427441571013}","[0, 16, 7, 12, 14, 15, 6, 10, 11, 8, 3, 2, 5, 9, 13, 4, 1, 0]",561.1427441571013,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 1, 'x': 88, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 17, 'y': 64, 'tw_start': 362, 'tw_end': 581}, {'id': 3, 'x': 59, 'y': 83, 'tw_start': 237, 'tw_end': 497}, {'id': 4, 'x': 100, 'y': 10, 'tw_start': 123, 'tw_end': 399}, {'id': 5, 'x': 2, 'y': 33, 'tw_start': 367, 'tw_end': 647}, {'id': 6, 'x': 63, 'y': 100, 'tw_start': 286, 'tw_end': 507}, {'id': 7, 'x': 36, 'y': 14, 'tw_start': 109, 'tw_end': 396}, {'id': 8, 'x': 75, 'y': 82, 'tw_start': 3, 'tw_end': 267}, {'id': 9, 'x': 85, 'y': 9, 'tw_start': 274, 'tw_end': 528}, {'id': 10, 'x': 19, 'y': 86, 'tw_start': 384, 'tw_end': 608}, {'id': 11, 'x': 39, 'y': 19, 'tw_start': 131, 'tw_end': 333}, {'id': 12, 'x': 54, 'y': 5, 'tw_start': 171, 'tw_end': 391}, {'id': 13, 'x': 27, 'y': 53, 'tw_start': 133, 'tw_end': 408}, {'id': 14, 'x': 0, 'y': 70, 'tw_start': 362, 'tw_end': 574}, {'id': 15, 'x': 26, 'y': 48, 'tw_start': 144, 'tw_end': 428}, {'id': 16, 'x': 10, 'y': 0, 'tw_start': 23, 'tw_end': 226}, {'id': 17, 'x': 79, 'y': 95, 'tw_start': 63, 'tw_end': 314}], 'depot': 1, 'objective': 561.1427441571013}","[1, 17, 8, 13, 15, 16, 7, 11, 12, 9, 4, 3, 6, 10, 14, 5, 2, 1]",42,json,1
TSPTW,TSPTW,"Back at the store the dispatcher sketches a run: the truck must leave the store, visit every customer exactly once to deliver during the customer’s specified time window (waiting is allowed), and return to the starting point. The planner’s job is to pick the order of customers, since that order sets the total miles traveled. The “better” plan is simply the one that results in fewer total miles — figured by summing the distance between each consecutive stop plus the return leg. The concrete details are listed below.

There are 16 locations in this run, and the depot is node A.
Location A at (19, 39) must be served between 0 and 1067.
Location B at (14, 29) must be served between 318 and 558.
Location C at (49, 31) must be served between 136 and 365.
Location D at (2, 12) must be served between 312 and 538.
Location E at (15, 63) must be served between 81 and 283.
Location F at (89, 0) must be served between 181 and 421.
Location G at (100, 22) must be served between 326 and 541.
Location H at (53, 100) must be served between 147 and 420.
Location I at (37, 87) must be served between 319 and 550.
Location J at (75, 76) must be served between 178 and 401.
Location K at (53, 78) must be served between 361 and 567.
Location L at (73, 27) must be served between 362 and 622.
Location M at (63, 7) must be served between 206 and 403.
Location N at (91, 21) must be served between 184 and 418.
Location O at (27, 7) must be served between 62 and 320.
Location P at (0, 2) must be served between 376 and 625.
The planner must sequence these stops to minimize total miles while respecting every time window and returning to depot A.

Just so we're on the same page, send the route back in this simple JSON shape — an ordered list of stop IDs starting and ending at the store.

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

Think of this like a little form: the array is the run in order, the first entry is where the truck leaves from, the last entry is where it comes back to, and everything in between is each customer visited exactly once. This JSON is just a sketch of the shape I expect, not the actual route.

Please use the exact identifiers from the instance input — don’t rename them or invent new labels.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[19, 39], [14, 29], [49, 31], [2, 12], [15, 63], [89, 0], [100, 22], [53, 100], [37, 87], [75, 76], [53, 78], [73, 27], [63, 7], [91, 21], [27, 7], [0, 2]], 'depot': 0, 'num_nodes': 16, 'time_windows': [[0, 1067], [318, 558], [136, 365], [312, 538], [81, 283], [181, 421], [326, 541], [147, 420], [319, 550], [178, 401], [361, 567], [362, 622], [206, 403], [184, 418], [62, 320], [376, 625]], 'tour_length': 518.1396368275216, 'objective': 518.1396368275216}","[0, 4, 7, 9, 2, 14, 12, 5, 6, 13, 11, 10, 8, 1, 3, 15, 0]",518.1396368275216,"{'problem_type': 'TSPTW', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 19, 'y': 39, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 14, 'y': 29, 'tw_start': 318, 'tw_end': 558}, {'id': 'C', 'x': 49, 'y': 31, 'tw_start': 136, 'tw_end': 365}, {'id': 'D', 'x': 2, 'y': 12, 'tw_start': 312, 'tw_end': 538}, {'id': 'E', 'x': 15, 'y': 63, 'tw_start': 81, 'tw_end': 283}, {'id': 'F', 'x': 89, 'y': 0, 'tw_start': 181, 'tw_end': 421}, {'id': 'G', 'x': 100, 'y': 22, 'tw_start': 326, 'tw_end': 541}, {'id': 'H', 'x': 53, 'y': 100, 'tw_start': 147, 'tw_end': 420}, {'id': 'I', 'x': 37, 'y': 87, 'tw_start': 319, 'tw_end': 550}, {'id': 'J', 'x': 75, 'y': 76, 'tw_start': 178, 'tw_end': 401}, {'id': 'K', 'x': 53, 'y': 78, 'tw_start': 361, 'tw_end': 567}, {'id': 'L', 'x': 73, 'y': 27, 'tw_start': 362, 'tw_end': 622}, {'id': 'M', 'x': 63, 'y': 7, 'tw_start': 206, 'tw_end': 403}, {'id': 'N', 'x': 91, 'y': 21, 'tw_start': 184, 'tw_end': 418}, {'id': 'O', 'x': 27, 'y': 7, 'tw_start': 62, 'tw_end': 320}, {'id': 'P', 'x': 0, 'y': 2, 'tw_start': 376, 'tw_end': 625}], 'depot': 'A', 'objective': 518.1396368275216}","['A', 'E', 'H', 'J', 'C', 'O', 'M', 'F', 'G', 'N', 'L', 'K', 'I', 'B', 'D', 'P', 'A']",43,nl,names
TSPTW,TSPTW,"Back at the office the scheduler lays out a run: start and end at the office, visit every meter site once and only once, and make sure each visit falls inside that site's permitted time slot (waiting ahead of the slot is allowed). The decision is how to arrange the stops so the whole loop uses the least driving — figured by adding up the distances between consecutive stops and the return trip. Every meter must be visited exactly one time, and the precise locations and their access windows are provided below.

{
  ""total_locations_including_office"": 21,
  ""nodes"": [
    {
      ""site_id"": 0,
      ""x_coordinate"": 88,
      ""y_coordinate"": 0,
      ""access_window_start"": 0,
      ""access_window_end"": 1240
    },
    {
      ""site_id"": 1,
      ""x_coordinate"": 100,
      ""y_coordinate"": 4,
      ""access_window_start"": 280,
      ""access_window_end"": 531
    },
    {
      ""site_id"": 2,
      ""x_coordinate"": 83,
      ""y_coordinate"": 6,
      ""access_window_start"": 138,
      ""access_window_end"": 425
    },
    {
      ""site_id"": 3,
      ""x_coordinate"": 25,
      ""y_coordinate"": 9,
      ""access_window_start"": 188,
      ""access_window_end"": 431
    },
    {
      ""site_id"": 4,
      ""x_coordinate"": 37,
      ""y_coordinate"": 13,
      ""access_window_start"": 77,
      ""access_window_end"": 349
    },
    {
      ""site_id"": 5,
      ""x_coordinate"": 83,
      ""y_coordinate"": 26,
      ""access_window_start"": 341,
      ""access_window_end"": 668
    },
    {
      ""site_id"": 6,
      ""x_coordinate"": 19,
      ""y_coordinate"": 26,
      ""access_window_start"": 37,
      ""access_window_end"": 307
    },
    {
      ""site_id"": 7,
      ""x_coordinate"": 0,
      ""y_coordinate"": 34,
      ""access_window_start"": 45,
      ""access_window_end"": 272
    },
    {
      ""site_id"": 8,
      ""x_coordinate"": 83,
      ""y_coordinate"": 35,
      ""access_window_start"": 298,
      ""access_window_end"": 591
    },
    {
      ""site_id"": 9,
      ""x_coordinate"": 25,
      ""y_coordinate"": 38,
      ""access_window_start"": 73,
      ""access_window_end"": 325
    },
    {
      ""site_id"": 10,
      ""x_coordinate"": 15,
      ""y_coordinate"": 38,
      ""access_window_start"": 10,
      ""access_window_end"": 330
    },
    {
      ""site_id"": 11,
      ""x_coordinate"": 37,
      ""y_coordinate"": 42,
      ""access_window_start"": 439,
      ""access_window_end"": 680
    },
    {
      ""site_id"": 12,
      ""x_coordinate"": 83,
      ""y_coordinate"": 55,
      ""access_window_start"": 104,
      ""access_window_end"": 427
    },
    {
      ""site_id"": 13,
      ""x_coordinate"": 15,
      ""y_coordinate"": 58,
      ""access_window_start"": 417,
      ""access_window_end"": 690
    },
    {
      ""site_id"": 14,
      ""x_coordinate"": 25,
      ""y_coordinate"": 58,
      ""access_window_start"": 22,
      ""access_window_end"": 252
    },
    {
      ""site_id"": 15,
      ""x_coordinate"": 83,
      ""y_coordinate"": 64,
      ""access_window_start"": 258,
      ""access_window_end"": 528
    },
    {
      ""site_id"": 16,
      ""x_coordinate"": 9,
      ""y_coordinate"": 67,
      ""access_window_start"": 12,
      ""access_window_end"": 304
    },
    {
      ""site_id"": 17,
      ""x_coordinate"": 100,
      ""y_coordinate"": 71,
      ""access_window_start"": 5,
      ""access_window_end"": 319
    },
    {
      ""site_id"": 18,
      ""x_coordinate"": 94,
      ""y_coordinate"": 87,
      ""access_window_start"": 138,
      ""access_window_end"": 368
    },
    {
      ""site_id"": 19,
      ""x_coordinate"": 83,
      ""y_coordinate"": 93,
      ""access_window_start"": 265,
      ""access_window_end"": 535
    },
    {
      ""site_id"": 20,
      ""x_coordinate"": 19,
      ""y_coordinate"": 100,
      ""access_window_start"": 439,
      ""access_window_end"": 726
    }
  ],
  ""office_node_id"": 0
}

Also, when you send the route back, just use this simple JSON shape so I can read it easily:

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

Think of that as a little form: ""solution"" holds the stop-by-stop order of the loop (starting and ending at the office). office_id and site_id are just placeholders for the actual site identifiers in your instance, and the ... stands in for the other stops in between. This is just the shape I want — not the real answer filled in.

Please make sure you use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[88, 0], [100, 4], [83, 6], [25, 9], [37, 13], [83, 26], [19, 26], [0, 34], [83, 35], [25, 38], [15, 38], [37, 42], [83, 55], [15, 58], [25, 58], [83, 64], [9, 67], [100, 71], [94, 87], [83, 93], [19, 100]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [280, 531], [138, 425], [188, 431], [77, 349], [341, 668], [37, 307], [45, 272], [298, 591], [73, 325], [10, 330], [439, 680], [104, 427], [417, 690], [22, 252], [258, 528], [12, 304], [5, 319], [138, 368], [265, 535], [439, 726]], 'tour_length': 685.4218820662575, 'objective': 685.4218820662575}","[0, 9, 14, 16, 7, 10, 6, 3, 4, 17, 18, 19, 15, 12, 8, 5, 2, 1, 20, 13, 11, 0]",685.4218820662575,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 0, 'x': 88, 'y': 0, 'tw_start': 0, 'tw_end': 1240}, {'id': 1, 'x': 100, 'y': 4, 'tw_start': 280, 'tw_end': 531}, {'id': 2, 'x': 83, 'y': 6, 'tw_start': 138, 'tw_end': 425}, {'id': 3, 'x': 25, 'y': 9, 'tw_start': 188, 'tw_end': 431}, {'id': 4, 'x': 37, 'y': 13, 'tw_start': 77, 'tw_end': 349}, {'id': 5, 'x': 83, 'y': 26, 'tw_start': 341, 'tw_end': 668}, {'id': 6, 'x': 19, 'y': 26, 'tw_start': 37, 'tw_end': 307}, {'id': 7, 'x': 0, 'y': 34, 'tw_start': 45, 'tw_end': 272}, {'id': 8, 'x': 83, 'y': 35, 'tw_start': 298, 'tw_end': 591}, {'id': 9, 'x': 25, 'y': 38, 'tw_start': 73, 'tw_end': 325}, {'id': 10, 'x': 15, 'y': 38, 'tw_start': 10, 'tw_end': 330}, {'id': 11, 'x': 37, 'y': 42, 'tw_start': 439, 'tw_end': 680}, {'id': 12, 'x': 83, 'y': 55, 'tw_start': 104, 'tw_end': 427}, {'id': 13, 'x': 15, 'y': 58, 'tw_start': 417, 'tw_end': 690}, {'id': 14, 'x': 25, 'y': 58, 'tw_start': 22, 'tw_end': 252}, {'id': 15, 'x': 83, 'y': 64, 'tw_start': 258, 'tw_end': 528}, {'id': 16, 'x': 9, 'y': 67, 'tw_start': 12, 'tw_end': 304}, {'id': 17, 'x': 100, 'y': 71, 'tw_start': 5, 'tw_end': 319}, {'id': 18, 'x': 94, 'y': 87, 'tw_start': 138, 'tw_end': 368}, {'id': 19, 'x': 83, 'y': 93, 'tw_start': 265, 'tw_end': 535}, {'id': 20, 'x': 19, 'y': 100, 'tw_start': 439, 'tw_end': 726}], 'depot': 0, 'objective': 685.4218820662575}","[0, 9, 14, 16, 7, 10, 6, 3, 4, 17, 18, 19, 15, 12, 8, 5, 2, 1, 20, 13, 11, 0]",44,json,0
TSPTW,TSPTW,"Many households booked cleanings for the same day, and the team must be routed from the office through every address one time and back to the office, all while respecting each household’s allowed arrival period (a bit of waiting is fine). The question is which order to visit the homes so the crew can hit all the time slots without going back over the same address. A better schedule is simply the one that results in fewer kilometers driven overall — compute that by adding the distances for every consecutive hop in the route, including leaving and returning to the office. The detailed bookings and windows are listed below.

There are 19 locations including the office; the office is node 0.

| location_id | location_x_coordinate | location_y_coordinate | earliest_allowed_arrival | latest_allowed_arrival |
|---|---|---|---|---|
| 0 | 0 | 23 | 0 | 1067 |
| 1 | 14 | 39 | 106 | 369 |
| 2 | 23 | 100 | 105 | 387 |
| 3 | 23 | 88 | 145 | 392 |
| 4 | 50 | 45 | 19 | 254 |
| 5 | 57 | 34 | 322 | 595 |
| 6 | 76 | 34 | 87 | 302 |
| 7 | 75 | 26 | 317 | 601 |
| 8 | 78 | 26 | 37 | 274 |
| 9 | 79 | 26 | 130 | 409 |
| 10 | 81 | 22 | 32 | 246 |
| 11 | 100 | 17 | 291 | 490 |
| 12 | 72 | 16 | 191 | 427 |
| 13 | 74 | 14 | 129 | 362 |
| 14 | 95 | 11 | 205 | 415 |
| 15 | 83 | 6 | 221 | 494 |
| 16 | 84 | 6 | 294 | 503 |
| 17 | 96 | 0 | 57 | 277 |
| 18 | 95 | 1 | 140 | 373 |

Plan a tour that visits each location once and returns to the office at node 0 while respecting all arrival windows and minimizing kilometers driven.

Also, when you give the final route, please use a tiny JSON layout like this so it's easy to parse:

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

This just shows the shape I want — ""solution"" is the ordered list of stops, starting at the office, visiting every home once, and coming back to the office. Think of it like filling in the visit order on a simple form; replace each placeholder with the matching identifier from the instance. The JSON above is only a sketch of the expected shape, not the actual answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[0, 23], [14, 39], [23, 100], [23, 88], [50, 45], [57, 34], [76, 34], [75, 26], [78, 26], [79, 26], [81, 22], [100, 17], [72, 16], [74, 14], [95, 11], [83, 6], [84, 6], [96, 0], [95, 1]], 'depot': 0, 'num_nodes': 19, 'time_windows': [[0, 1067], [106, 369], [105, 387], [145, 392], [19, 254], [322, 595], [87, 302], [317, 601], [37, 274], [130, 409], [32, 246], [291, 490], [191, 427], [129, 362], [205, 415], [221, 494], [294, 503], [57, 277], [140, 373]], 'tour_length': 482.5630821886137, 'objective': 482.5630821886137}","[0, 1, 4, 6, 8, 9, 10, 14, 17, 18, 15, 13, 12, 3, 2, 5, 7, 11, 16, 0]",482.5630821886137,"{'problem_type': 'TSPTW', 'num_nodes': 19, 'nodes': [{'id': 0, 'x': 0, 'y': 23, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 14, 'y': 39, 'tw_start': 106, 'tw_end': 369}, {'id': 2, 'x': 23, 'y': 100, 'tw_start': 105, 'tw_end': 387}, {'id': 3, 'x': 23, 'y': 88, 'tw_start': 145, 'tw_end': 392}, {'id': 4, 'x': 50, 'y': 45, 'tw_start': 19, 'tw_end': 254}, {'id': 5, 'x': 57, 'y': 34, 'tw_start': 322, 'tw_end': 595}, {'id': 6, 'x': 76, 'y': 34, 'tw_start': 87, 'tw_end': 302}, {'id': 7, 'x': 75, 'y': 26, 'tw_start': 317, 'tw_end': 601}, {'id': 8, 'x': 78, 'y': 26, 'tw_start': 37, 'tw_end': 274}, {'id': 9, 'x': 79, 'y': 26, 'tw_start': 130, 'tw_end': 409}, {'id': 10, 'x': 81, 'y': 22, 'tw_start': 32, 'tw_end': 246}, {'id': 11, 'x': 100, 'y': 17, 'tw_start': 291, 'tw_end': 490}, {'id': 12, 'x': 72, 'y': 16, 'tw_start': 191, 'tw_end': 427}, {'id': 13, 'x': 74, 'y': 14, 'tw_start': 129, 'tw_end': 362}, {'id': 14, 'x': 95, 'y': 11, 'tw_start': 205, 'tw_end': 415}, {'id': 15, 'x': 83, 'y': 6, 'tw_start': 221, 'tw_end': 494}, {'id': 16, 'x': 84, 'y': 6, 'tw_start': 294, 'tw_end': 503}, {'id': 17, 'x': 96, 'y': 0, 'tw_start': 57, 'tw_end': 277}, {'id': 18, 'x': 95, 'y': 1, 'tw_start': 140, 'tw_end': 373}], 'depot': 0, 'objective': 482.5630821886137}","[0, 1, 4, 6, 8, 9, 10, 14, 17, 18, 15, 13, 12, 3, 2, 5, 7, 11, 16, 0]",45,markdown_table,0
TSPTW,TSPTW,"I pictured a sales rep leaving the branch in the morning, swinging by a handful of prospects, and then heading back to the office at the end of the day. The trick is picking the order to visit so every prospective client is seen exactly once, each meeting happens inside the slot they gave, and the rep doesn’t rack up more driving than necessary — total distance is just the sum of the miles between stops (including the trip home), so the plan with the smallest sum is the nicer one. If the rep gets to a place early, waiting until the meeting window opens is fine, but nobody can be skipped or visited twice. The exact locations, times, and distances are listed below.

{
  ""total_locations_including_branch"": 21,
  ""nodes"": [
    {
      ""location_id"": 1,
      ""location_x"": 100,
      ""location_y"": 35,
      ""earliest_meeting_time"": 0,
      ""latest_meeting_time"": 1240
    },
    {
      ""location_id"": 2,
      ""location_x"": 23,
      ""location_y"": 60,
      ""earliest_meeting_time"": 98,
      ""latest_meeting_time"": 330
    },
    {
      ""location_id"": 3,
      ""location_x"": 47,
      ""location_y"": 49,
      ""earliest_meeting_time"": 59,
      ""latest_meeting_time"": 352
    },
    {
      ""location_id"": 4,
      ""location_x"": 66,
      ""location_y"": 29,
      ""earliest_meeting_time"": 383,
      ""latest_meeting_time"": 613
    },
    {
      ""location_id"": 5,
      ""location_x"": 79,
      ""location_y"": 28,
      ""earliest_meeting_time"": 331,
      ""latest_meeting_time"": 595
    },
    {
      ""location_id"": 6,
      ""location_x"": 87,
      ""location_y"": 87,
      ""earliest_meeting_time"": 215,
      ""latest_meeting_time"": 546
    },
    {
      ""location_id"": 7,
      ""location_x"": 37,
      ""location_y"": 24,
      ""earliest_meeting_time"": 149,
      ""latest_meeting_time"": 427
    },
    {
      ""location_id"": 8,
      ""location_x"": 37,
      ""location_y"": 31,
      ""earliest_meeting_time"": 6,
      ""latest_meeting_time"": 240
    },
    {
      ""location_id"": 9,
      ""location_x"": 17,
      ""location_y"": 0,
      ""earliest_meeting_time"": 116,
      ""latest_meeting_time"": 345
    },
    {
      ""location_id"": 10,
      ""location_x"": 69,
      ""location_y"": 29,
      ""earliest_meeting_time"": 284,
      ""latest_meeting_time"": 558
    },
    {
      ""location_id"": 11,
      ""location_x"": 69,
      ""location_y"": 36,
      ""earliest_meeting_time"": 247,
      ""latest_meeting_time"": 492
    },
    {
      ""location_id"": 12,
      ""location_x"": 77,
      ""location_y"": 42,
      ""earliest_meeting_time"": 133,
      ""latest_meeting_time"": 433
    },
    {
      ""location_id"": 13,
      ""location_x"": 43,
      ""location_y"": 80,
      ""earliest_meeting_time"": 435,
      ""latest_meeting_time"": 666
    },
    {
      ""location_id"": 14,
      ""location_x"": 0,
      ""location_y"": 31,
      ""earliest_meeting_time"": 401,
      ""latest_meeting_time"": 692
    },
    {
      ""location_id"": 15,
      ""location_x"": 55,
      ""location_y"": 97,
      ""earliest_meeting_time"": 254,
      ""latest_meeting_time"": 536
    },
    {
      ""location_id"": 16,
      ""location_x"": 58,
      ""location_y"": 24,
      ""earliest_meeting_time"": 31,
      ""latest_meeting_time"": 266
    },
    {
      ""location_id"": 17,
      ""location_x"": 0,
      ""location_y"": 38,
      ""earliest_meeting_time"": 271,
      ""latest_meeting_time"": 534
    },
    {
      ""location_id"": 18,
      ""location_x"": 11,
      ""location_y"": 8,
      ""earliest_meeting_time"": 413,
      ""latest_meeting_time"": 685
    },
    {
      ""location_id"": 19,
      ""location_x"": 83,
      ""location_y"": 67,
      ""earliest_meeting_time"": 64,
      ""latest_meeting_time"": 370
    },
    {
      ""location_id"": 20,
      ""location_x"": 4,
      ""location_y"": 5,
      ""earliest_meeting_time"": 132,
      ""latest_meeting_time"": 417
    },
    {
      ""location_id"": 21,
      ""location_x"": 12,
      ""location_y"": 100,
      ""earliest_meeting_time"": 314,
      ""latest_meeting_time"": 641
    }
  ],
  ""branch_office_node_id"": 1
}

If you want the route in a neat, machine-friendly form, just drop it into a tiny JSON object like this:

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

Think of that as: ""solution"" is the list that gives the visit order — start at the branch (first placeholder), go visit each prospect once (the middle placeholders), and come back to the branch (last placeholder). This is just a sketch of the shape I expect, not the actual route.

Please use the exact identifiers from the instance input — no renaming and no invented labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[100, 35], [23, 60], [47, 49], [66, 29], [79, 28], [87, 87], [37, 24], [37, 31], [17, 0], [69, 29], [69, 36], [77, 42], [43, 80], [0, 31], [55, 97], [58, 24], [0, 38], [11, 8], [83, 67], [4, 5], [12, 100]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [98, 330], [59, 352], [383, 613], [331, 595], [215, 546], [149, 427], [6, 240], [116, 345], [284, 558], [247, 492], [133, 433], [435, 666], [401, 692], [254, 536], [31, 266], [271, 534], [413, 685], [64, 370], [132, 417], [314, 641]], 'tour_length': 623.3796291303311, 'objective': 623.3796291303311}","[0, 15, 8, 19, 7, 2, 1, 14, 5, 18, 11, 10, 4, 9, 3, 6, 17, 13, 16, 20, 12, 0]",623.3796291303311,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 1, 'x': 100, 'y': 35, 'tw_start': 0, 'tw_end': 1240}, {'id': 2, 'x': 23, 'y': 60, 'tw_start': 98, 'tw_end': 330}, {'id': 3, 'x': 47, 'y': 49, 'tw_start': 59, 'tw_end': 352}, {'id': 4, 'x': 66, 'y': 29, 'tw_start': 383, 'tw_end': 613}, {'id': 5, 'x': 79, 'y': 28, 'tw_start': 331, 'tw_end': 595}, {'id': 6, 'x': 87, 'y': 87, 'tw_start': 215, 'tw_end': 546}, {'id': 7, 'x': 37, 'y': 24, 'tw_start': 149, 'tw_end': 427}, {'id': 8, 'x': 37, 'y': 31, 'tw_start': 6, 'tw_end': 240}, {'id': 9, 'x': 17, 'y': 0, 'tw_start': 116, 'tw_end': 345}, {'id': 10, 'x': 69, 'y': 29, 'tw_start': 284, 'tw_end': 558}, {'id': 11, 'x': 69, 'y': 36, 'tw_start': 247, 'tw_end': 492}, {'id': 12, 'x': 77, 'y': 42, 'tw_start': 133, 'tw_end': 433}, {'id': 13, 'x': 43, 'y': 80, 'tw_start': 435, 'tw_end': 666}, {'id': 14, 'x': 0, 'y': 31, 'tw_start': 401, 'tw_end': 692}, {'id': 15, 'x': 55, 'y': 97, 'tw_start': 254, 'tw_end': 536}, {'id': 16, 'x': 58, 'y': 24, 'tw_start': 31, 'tw_end': 266}, {'id': 17, 'x': 0, 'y': 38, 'tw_start': 271, 'tw_end': 534}, {'id': 18, 'x': 11, 'y': 8, 'tw_start': 413, 'tw_end': 685}, {'id': 19, 'x': 83, 'y': 67, 'tw_start': 64, 'tw_end': 370}, {'id': 20, 'x': 4, 'y': 5, 'tw_start': 132, 'tw_end': 417}, {'id': 21, 'x': 12, 'y': 100, 'tw_start': 314, 'tw_end': 641}], 'depot': 1, 'objective': 623.3796291303311}","[1, 16, 9, 20, 8, 3, 2, 15, 6, 19, 12, 11, 5, 10, 4, 7, 18, 14, 17, 21, 13, 1]",46,json,1
TSPTW,TSPTW,"Recently the logistics team had to map out a route where a researcher leaves the basecamp, stops at every survey point exactly once to collect data, and ends the day back at basecamp. Each stop has its own allowed sampling hours, so arrivals must be within those windows (it’s acceptable to hang around a bit if the window hasn’t started), and no detours that repeat sites or skip them are permitted. The goal is to minimize how much they have to drive — check that by totaling the distances of all legs of the trip — and the concrete site/timing info appears below.

# total_sites_including_basecamp=17
# basecamp_node_id=0
# time windows are listed per node in the table
site_id,coord_x,coord_y,earliest_sampling_time,latest_sampling_time
0,12,35,0,1067
1,23,41,329,542
2,42,49,48,336
3,10,53,41,282
4,39,66,227,473
5,0,67,33,232
6,9,100,40,291
7,41,0,211,427
8,51,2,247,521
9,68,35,16,258
10,70,15,267,485
11,74,2,119,372
12,84,0,348,620
13,89,30,226,491
14,96,40,141,397
15,89,76,180,393
16,100,91,272,520

Oh, and when you send the final route back, please use a tiny JSON snippet like this so it's easy to parse:

{
  ""solution"": [basecamp_id, survey_point_id, ..., basecamp_id]
}

This just means: ""solution"" is the ordered list of stops for the day, starting and ending at the basecamp, with every survey point shown in the order they'll be visited. The tokens in the list (like basecamp_id and survey_point_id) are placeholders for the actual site identifiers from the instance — this block is just a sketch of the shape I expect, not the real answer.

Please use the exact identifiers from the instance input with no renaming and don’t introduce 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': [[12, 35], [23, 41], [42, 49], [10, 53], [39, 66], [0, 67], [9, 100], [41, 0], [51, 2], [68, 35], [70, 15], [74, 2], [84, 0], [89, 30], [96, 40], [89, 76], [100, 91]], 'depot': 0, 'num_nodes': 17, 'time_windows': [[0, 1067], [329, 542], [48, 336], [41, 282], [227, 473], [33, 232], [40, 291], [211, 427], [247, 521], [16, 258], [267, 485], [119, 372], [348, 620], [226, 491], [141, 397], [180, 393], [272, 520]], 'tour_length': 591.1973404350725, 'objective': 591.1973404350725}","[0, 3, 5, 6, 2, 9, 7, 8, 11, 10, 13, 14, 16, 15, 4, 1, 12, 0]",591.1973404350725,"{'problem_type': 'TSPTW', 'num_nodes': 17, 'nodes': [{'id': 0, 'x': 12, 'y': 35, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 23, 'y': 41, 'tw_start': 329, 'tw_end': 542}, {'id': 2, 'x': 42, 'y': 49, 'tw_start': 48, 'tw_end': 336}, {'id': 3, 'x': 10, 'y': 53, 'tw_start': 41, 'tw_end': 282}, {'id': 4, 'x': 39, 'y': 66, 'tw_start': 227, 'tw_end': 473}, {'id': 5, 'x': 0, 'y': 67, 'tw_start': 33, 'tw_end': 232}, {'id': 6, 'x': 9, 'y': 100, 'tw_start': 40, 'tw_end': 291}, {'id': 7, 'x': 41, 'y': 0, 'tw_start': 211, 'tw_end': 427}, {'id': 8, 'x': 51, 'y': 2, 'tw_start': 247, 'tw_end': 521}, {'id': 9, 'x': 68, 'y': 35, 'tw_start': 16, 'tw_end': 258}, {'id': 10, 'x': 70, 'y': 15, 'tw_start': 267, 'tw_end': 485}, {'id': 11, 'x': 74, 'y': 2, 'tw_start': 119, 'tw_end': 372}, {'id': 12, 'x': 84, 'y': 0, 'tw_start': 348, 'tw_end': 620}, {'id': 13, 'x': 89, 'y': 30, 'tw_start': 226, 'tw_end': 491}, {'id': 14, 'x': 96, 'y': 40, 'tw_start': 141, 'tw_end': 397}, {'id': 15, 'x': 89, 'y': 76, 'tw_start': 180, 'tw_end': 393}, {'id': 16, 'x': 100, 'y': 91, 'tw_start': 272, 'tw_end': 520}], 'depot': 0, 'objective': 591.1973404350725}","[0, 3, 5, 6, 2, 9, 7, 8, 11, 10, 13, 14, 16, 15, 4, 1, 12, 0]",47,csv,0
TSPTW,TSPTW,"Someone at the shop is mapping out the day’s bouquet drops: the route must start and finish at the store, visit every delivery address exactly once, and hit each recipient within their promised delivery window. Hanging around until a window opens is allowed, but any route that racks up more driving distance is worse — total distance is just the sum of the driving between each pair of stops, including coming back to the shop. The specific locations and their time slots are shown below.

# total_locations_including_shop=16
# shop_node=1
# time windows are listed per node in the table
stop_id,location_x,location_y,earliest_delivery_time,latest_delivery_time
1,53,96,0,1067
2,55,94,139,421
3,47,92,8,232
4,54,67,22,290
5,80,60,272,498
6,73,58,262,494
7,37,53,293,531
8,0,53,159,444
9,49,45,97,303
10,52,35,226,514
11,54,33,146,346
12,64,24,131,374
13,73,24,62,320
14,87,100,387,624
15,100,0,137,370
16,96,0,44,324

Also, when you send the route back, just stick to a tiny JSON shape like this — nothing fancy:

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

This just means: ""solution"" holds the tour as an ordered list of stops — start at the shop, list each delivery address once in the order you'll visit them, and finish back at the shop. Think of the placeholders ( shop_id, address_id ) as blanks you'll fill with the actual IDs from the instance.

This JSON is only a sketch of the expected shape, not the real answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[53, 96], [55, 94], [47, 92], [54, 67], [80, 60], [73, 58], [37, 53], [0, 53], [49, 45], [52, 35], [54, 33], [64, 24], [73, 24], [87, 100], [100, 0], [96, 0]], 'depot': 0, 'num_nodes': 16, 'time_windows': [[0, 1067], [139, 421], [8, 232], [22, 290], [272, 498], [262, 494], [293, 531], [159, 444], [97, 303], [226, 514], [146, 346], [131, 374], [62, 320], [387, 624], [137, 370], [44, 324]], 'tour_length': 398.38975513381826, 'objective': 398.38975513381826}","[0, 1, 2, 3, 8, 12, 14, 15, 11, 10, 9, 7, 6, 5, 4, 13, 0]",398.38975513381826,"{'problem_type': 'TSPTW', 'num_nodes': 16, 'nodes': [{'id': 1, 'x': 53, 'y': 96, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 55, 'y': 94, 'tw_start': 139, 'tw_end': 421}, {'id': 3, 'x': 47, 'y': 92, 'tw_start': 8, 'tw_end': 232}, {'id': 4, 'x': 54, 'y': 67, 'tw_start': 22, 'tw_end': 290}, {'id': 5, 'x': 80, 'y': 60, 'tw_start': 272, 'tw_end': 498}, {'id': 6, 'x': 73, 'y': 58, 'tw_start': 262, 'tw_end': 494}, {'id': 7, 'x': 37, 'y': 53, 'tw_start': 293, 'tw_end': 531}, {'id': 8, 'x': 0, 'y': 53, 'tw_start': 159, 'tw_end': 444}, {'id': 9, 'x': 49, 'y': 45, 'tw_start': 97, 'tw_end': 303}, {'id': 10, 'x': 52, 'y': 35, 'tw_start': 226, 'tw_end': 514}, {'id': 11, 'x': 54, 'y': 33, 'tw_start': 146, 'tw_end': 346}, {'id': 12, 'x': 64, 'y': 24, 'tw_start': 131, 'tw_end': 374}, {'id': 13, 'x': 73, 'y': 24, 'tw_start': 62, 'tw_end': 320}, {'id': 14, 'x': 87, 'y': 100, 'tw_start': 387, 'tw_end': 624}, {'id': 15, 'x': 100, 'y': 0, 'tw_start': 137, 'tw_end': 370}, {'id': 16, 'x': 96, 'y': 0, 'tw_start': 44, 'tw_end': 324}], 'depot': 1, 'objective': 398.38975513381826}","[1, 2, 3, 4, 9, 13, 15, 16, 12, 11, 10, 8, 7, 6, 5, 14, 1]",48,csv,1
TSPTW,TSPTW,"We have an outreach plan to make: a counselor leaves the service center, drops by every household on a roster exactly once, and comes back to base. The aim is to arrange the order of visits so every household is met within its available meeting window and the total distance driven is as small as possible — tally the distance between each consecutive stop and the final leg home, and that total should be minimized. Waiting at a house if the counselor gets there before the window starts is allowed, but no household can be skipped or visited twice. The concrete list of homes and their time windows is provided below.

There are 21 locations in total, including the service center A.

| location_id | x_coordinate | y_coordinate | earliest_meeting_time | latest_meeting_time |
|---|---|---|---|---|
| A | 0 | 81 | 0 | 1240 |
| B | 11 | 92 | 265 | 530 |
| C | 10 | 16 | 360 | 648 |
| D | 10 | 0 | 372 | 669 |
| E | 21 | 6 | 353 | 646 |
| F | 18 | 58 | 186 | 520 |
| G | 14 | 73 | 244 | 537 |
| H | 18 | 84 | 99 | 395 |
| I | 35 | 31 | 257 | 504 |
| J | 44 | 68 | 26 | 320 |
| K | 73 | 100 | 344 | 628 |
| L | 76 | 100 | 102 | 402 |
| M | 73 | 38 | 36 | 311 |
| N | 72 | 30 | 73 | 319 |
| O | 81 | 100 | 91 | 360 |
| P | 90 | 100 | 23 | 293 |
| Q | 91 | 100 | 230 | 510 |
| R | 92 | 7 | 172 | 492 |
| S | 100 | 15 | 65 | 348 |
| T | 100 | 17 | 27 | 261 |
| U | 100 | 91 | 258 | 548 |

Every listed location must be visited exactly once and the counselor must return to A.

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

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

This just means: ""solution"" is a list showing the visit order — start at the service center, list each household exactly once in the order they'll be visited, and finish back at the center. The names in the example above are just placeholders to show the shape, not the real labels you'll use.

Please make sure to use the exact identifiers from 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': [[0, 81], [11, 92], [10, 16], [10, 0], [21, 6], [18, 58], [14, 73], [18, 84], [35, 31], [44, 68], [73, 100], [76, 100], [73, 38], [72, 30], [81, 100], [90, 100], [91, 100], [92, 7], [100, 15], [100, 17], [100, 91]], 'depot': 0, 'num_nodes': 21, 'time_windows': [[0, 1240], [265, 530], [360, 648], [372, 669], [353, 646], [186, 520], [244, 537], [99, 395], [257, 504], [26, 320], [344, 628], [102, 402], [36, 311], [73, 319], [91, 360], [23, 293], [230, 510], [172, 492], [65, 348], [27, 261], [258, 548]], 'tour_length': 598.6805277732223, 'objective': 598.6805277732223}","[0, 9, 12, 13, 17, 18, 19, 20, 16, 15, 14, 11, 1, 7, 6, 5, 2, 3, 4, 8, 10, 0]",598.6805277732223,"{'problem_type': 'TSPTW', 'num_nodes': 21, 'nodes': [{'id': 'A', 'x': 0, 'y': 81, 'tw_start': 0, 'tw_end': 1240}, {'id': 'B', 'x': 11, 'y': 92, 'tw_start': 265, 'tw_end': 530}, {'id': 'C', 'x': 10, 'y': 16, 'tw_start': 360, 'tw_end': 648}, {'id': 'D', 'x': 10, 'y': 0, 'tw_start': 372, 'tw_end': 669}, {'id': 'E', 'x': 21, 'y': 6, 'tw_start': 353, 'tw_end': 646}, {'id': 'F', 'x': 18, 'y': 58, 'tw_start': 186, 'tw_end': 520}, {'id': 'G', 'x': 14, 'y': 73, 'tw_start': 244, 'tw_end': 537}, {'id': 'H', 'x': 18, 'y': 84, 'tw_start': 99, 'tw_end': 395}, {'id': 'I', 'x': 35, 'y': 31, 'tw_start': 257, 'tw_end': 504}, {'id': 'J', 'x': 44, 'y': 68, 'tw_start': 26, 'tw_end': 320}, {'id': 'K', 'x': 73, 'y': 100, 'tw_start': 344, 'tw_end': 628}, {'id': 'L', 'x': 76, 'y': 100, 'tw_start': 102, 'tw_end': 402}, {'id': 'M', 'x': 73, 'y': 38, 'tw_start': 36, 'tw_end': 311}, {'id': 'N', 'x': 72, 'y': 30, 'tw_start': 73, 'tw_end': 319}, {'id': 'O', 'x': 81, 'y': 100, 'tw_start': 91, 'tw_end': 360}, {'id': 'P', 'x': 90, 'y': 100, 'tw_start': 23, 'tw_end': 293}, {'id': 'Q', 'x': 91, 'y': 100, 'tw_start': 230, 'tw_end': 510}, {'id': 'R', 'x': 92, 'y': 7, 'tw_start': 172, 'tw_end': 492}, {'id': 'S', 'x': 100, 'y': 15, 'tw_start': 65, 'tw_end': 348}, {'id': 'T', 'x': 100, 'y': 17, 'tw_start': 27, 'tw_end': 261}, {'id': 'U', 'x': 100, 'y': 91, 'tw_start': 258, 'tw_end': 548}], 'depot': 'A', 'objective': 598.6805277732223}","['A', 'J', 'M', 'N', 'R', 'S', 'T', 'U', 'Q', 'P', 'O', 'L', 'B', 'H', 'G', 'F', 'C', 'D', 'E', 'I', 'K', 'A']",49,markdown_table,names
TSPTW,TSPTW,"Across town there’s a charity van that needs a single, tidy loop: start at the depot, visit each distribution site one time only, and come back to the depot, all while making sure each visit falls inside that site’s receiving hours (waiting is okay if the van shows up early). The deciding factor is total miles driven — add together the distances of each leg in the journey to get the total, and aim for the route with the smallest number. The concrete route data and time windows are shown below.

# total_locations_including_depot=16
# depot_node_id=A
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,earliest_receiving_time,latest_receiving_time
A,0,9,0,1067
B,7,25,340,588
C,1,32,372,571
D,2,35,38,236
E,7,40,71,318
F,6,43,250,448
G,14,53,367,642
H,19,56,115,316
I,33,79,65,272
J,22,86,47,292
K,31,95,95,324
L,19,100,383,644
M,89,0,368,576
N,92,31,148,396
O,96,12,29,224
P,100,0,260,516

If you'd like the answer in a tidy, machine-friendly form, just use this simple layout:

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

Here ""solution"" is an ordered list showing the van's loop — start at the depot, visit each site once (in the order shown), and come back to the depot. Think of it like filling in a short itinerary: each entry is the identifier for the spot visited, in travel order. This JSON is just a sketch of the shape I expect the real answer to take, not the actual route.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 9], [7, 25], [1, 32], [2, 35], [7, 40], [6, 43], [14, 53], [19, 56], [33, 79], [22, 86], [31, 95], [19, 100], [89, 0], [92, 31], [96, 12], [100, 0]], 'depot': 0, 'num_nodes': 16, 'time_windows': [[0, 1067], [340, 588], [372, 571], [38, 236], [71, 318], [250, 448], [367, 642], [115, 316], [65, 272], [47, 292], [95, 324], [383, 644], [368, 576], [148, 396], [29, 224], [260, 516]], 'tour_length': 656.0677537738044, 'objective': 656.0677537738044}","[0, 3, 14, 13, 8, 10, 9, 7, 5, 4, 2, 1, 12, 15, 6, 11, 0]",656.0677537738044,"{'problem_type': 'TSPTW', 'num_nodes': 16, 'nodes': [{'id': 'A', 'x': 0, 'y': 9, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 7, 'y': 25, 'tw_start': 340, 'tw_end': 588}, {'id': 'C', 'x': 1, 'y': 32, 'tw_start': 372, 'tw_end': 571}, {'id': 'D', 'x': 2, 'y': 35, 'tw_start': 38, 'tw_end': 236}, {'id': 'E', 'x': 7, 'y': 40, 'tw_start': 71, 'tw_end': 318}, {'id': 'F', 'x': 6, 'y': 43, 'tw_start': 250, 'tw_end': 448}, {'id': 'G', 'x': 14, 'y': 53, 'tw_start': 367, 'tw_end': 642}, {'id': 'H', 'x': 19, 'y': 56, 'tw_start': 115, 'tw_end': 316}, {'id': 'I', 'x': 33, 'y': 79, 'tw_start': 65, 'tw_end': 272}, {'id': 'J', 'x': 22, 'y': 86, 'tw_start': 47, 'tw_end': 292}, {'id': 'K', 'x': 31, 'y': 95, 'tw_start': 95, 'tw_end': 324}, {'id': 'L', 'x': 19, 'y': 100, 'tw_start': 383, 'tw_end': 644}, {'id': 'M', 'x': 89, 'y': 0, 'tw_start': 368, 'tw_end': 576}, {'id': 'N', 'x': 92, 'y': 31, 'tw_start': 148, 'tw_end': 396}, {'id': 'O', 'x': 96, 'y': 12, 'tw_start': 29, 'tw_end': 224}, {'id': 'P', 'x': 100, 'y': 0, 'tw_start': 260, 'tw_end': 516}], 'depot': 'A', 'objective': 656.0677537738044}","['A', 'D', 'O', 'N', 'I', 'K', 'J', 'H', 'F', 'E', 'C', 'B', 'M', 'P', 'G', 'L', 'A']",50,csv,names