TSPTW/TSPTW_S_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 10 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 | 87 | 28 | 0 | 918 |
| 1 | 31 | 100 | 125 | 371 |
| 2 | 100 | 50 | 244 | 461 |
| 3 | 37 | 60 | 52 | 232 |
| 4 | 38 | 47 | 19 | 258 |
| 5 | 0 | 63 | 200 | 426 |
| 6 | 73 | 76 | 6 | 254 |
| 7 | 10 | 37 | 278 | 462 |
| 8 | 65 | 21 | 60 | 243 |
| 9 | 36 | 0 | 101 | 312 |

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': [[87, 28], [31, 100], [100, 50], [37, 60], [38, 47], [0, 63], [73, 76], [10, 37], [65, 21], [36, 0]], 'depot': 0, 'num_nodes': 10, 'time_windows': [[0, 918], [125, 371], [244, 461], [52, 232], [19, 258], [200, 426], [6, 254], [278, 462], [60, 243], [101, 312]], 'tour_length': 399.3564936016961, 'objective': 399.3564936016961}","[0, 8, 9, 4, 3, 6, 1, 5, 7, 2, 0]",399.3564936016961,"{'problem_type': 'TSPTW', 'num_nodes': 10, 'nodes': [{'id': 0, 'x': 87, 'y': 28, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 31, 'y': 100, 'tw_start': 125, 'tw_end': 371}, {'id': 2, 'x': 100, 'y': 50, 'tw_start': 244, 'tw_end': 461}, {'id': 3, 'x': 37, 'y': 60, 'tw_start': 52, 'tw_end': 232}, {'id': 4, 'x': 38, 'y': 47, 'tw_start': 19, 'tw_end': 258}, {'id': 5, 'x': 0, 'y': 63, 'tw_start': 200, 'tw_end': 426}, {'id': 6, 'x': 73, 'y': 76, 'tw_start': 6, 'tw_end': 254}, {'id': 7, 'x': 10, 'y': 37, 'tw_start': 278, 'tw_end': 462}, {'id': 8, 'x': 65, 'y': 21, 'tw_start': 60, 'tw_end': 243}, {'id': 9, 'x': 36, 'y': 0, 'tw_start': 101, 'tw_end': 312}], 'depot': 0, 'objective': 399.3564936016961}","[0, 8, 9, 4, 3, 6, 1, 5, 7, 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 6 locations (including the garage A) are listed below, one per line:

| site_id | x_coord | y_coord | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| A | 70 | 0 | 0 | 918 |
| B | 77 | 58 | 144 | 335 |
| C | 45 | 55 | 204 | 383 |
| D | 100 | 13 | 97 | 295 |
| E | 2 | 100 | 152 | 384 |
| F | 0 | 19 | 66 | 276 |

We must plan a single round trip starting and ending at A that visits all 6 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': [[70, 0], [77, 58], [45, 55], [100, 13], [2, 100], [0, 19]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [144, 335], [204, 383], [97, 295], [152, 384], [66, 276]], 'tour_length': 373.2274457728503, 'objective': 373.2274457728503}","[0, 3, 1, 5, 4, 2, 0]",373.2274457728503,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 'A', 'x': 70, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 77, 'y': 58, 'tw_start': 144, 'tw_end': 335}, {'id': 'C', 'x': 45, 'y': 55, 'tw_start': 204, 'tw_end': 383}, {'id': 'D', 'x': 100, 'y': 13, 'tw_start': 97, 'tw_end': 295}, {'id': 'E', 'x': 2, 'y': 100, 'tw_start': 152, 'tw_end': 384}, {'id': 'F', 'x': 0, 'y': 19, 'tw_start': 66, 'tw_end': 276}], 'depot': 'A', 'objective': 373.2274457728503}","['A', 'D', 'B', 'F', 'E', 'C', 'A']",2,markdown_table,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.

The plan lists 8 locations, starting and ending at home node 0.

| stop_id | map_x_coordinate | map_y_coordinate | earliest_allowed_arrival | latest_allowed_arrival |
|---|---|---|---|---|
| 0 | 0 | 100 | 0 | 918 |
| 1 | 0 | 3 | 197 | 368 |
| 2 | 0 | 17 | 202 | 384 |
| 3 | 12 | 24 | 21 | 267 |
| 4 | 76 | 21 | 322 | 557 |
| 5 | 24 | 3 | 101 | 276 |
| 6 | 37 | 17 | 228 | 432 |
| 7 | 100 | 0 | 40 | 249 |

These entries show each stop’s location and allowed arrival window; use them to compute arrival times, any waiting, and the total miles for the best route.

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': [[0, 100], [0, 3], [0, 17], [12, 24], [76, 21], [24, 3], [37, 17], [100, 0]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [197, 368], [202, 384], [21, 267], [322, 557], [101, 276], [228, 432], [40, 249]], 'tour_length': 457.94651147665417, 'objective': 457.94651147665417}","[0, 7, 5, 3, 2, 1, 6, 4, 0]",457.94651147665417,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 0, 'x': 0, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 0, 'y': 3, 'tw_start': 197, 'tw_end': 368}, {'id': 2, 'x': 0, 'y': 17, 'tw_start': 202, 'tw_end': 384}, {'id': 3, 'x': 12, 'y': 24, 'tw_start': 21, 'tw_end': 267}, {'id': 4, 'x': 76, 'y': 21, 'tw_start': 322, 'tw_end': 557}, {'id': 5, 'x': 24, 'y': 3, 'tw_start': 101, 'tw_end': 276}, {'id': 6, 'x': 37, 'y': 17, 'tw_start': 228, 'tw_end': 432}, {'id': 7, 'x': 100, 'y': 0, 'tw_start': 40, 'tw_end': 249}], 'depot': 0, 'objective': 457.94651147665417}","[0, 7, 5, 3, 2, 1, 6, 4, 0]",3,markdown_table,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 5 stops including the shop 1; each stop's coordinates and allowed arrival window are listed one per line below.
Stop 1: coordinates (0, 12), arrival window 0 - 918.
Stop 2: coordinates (46, 29), arrival window 11 - 254.
Stop 3: coordinates (46, 0), arrival window 86 - 308.
Stop 4: coordinates (49, 35), arrival window 104 - 314.
Stop 5: coordinates (100, 100), arrival window 182 - 365.
Visit every stop once, start and finish at 1, and make the route for all 5 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, 12], [46, 29], [46, 0], [49, 35], [100, 100]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [11, 254], [86, 308], [104, 314], [182, 365]], 'tour_length': 299.0738779342313, 'objective': 299.0738779342313}","[0, 2, 1, 3, 4, 0]",299.0738779342313,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 1, 'x': 0, 'y': 12, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 46, 'y': 29, 'tw_start': 11, 'tw_end': 254}, {'id': 3, 'x': 46, 'y': 0, 'tw_start': 86, 'tw_end': 308}, {'id': 4, 'x': 49, 'y': 35, 'tw_start': 104, 'tw_end': 314}, {'id': 5, 'x': 100, 'y': 100, 'tw_start': 182, 'tw_end': 365}], 'depot': 1, 'objective': 299.0738779342313}","[1, 3, 2, 4, 5, 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 9 locations, with the office as 0:
Visit location 0 at (0, 0) and begin inspection between 0 and 918.
Visit location 1 at (73, 18) and begin inspection between 323 and 555.
Visit location 2 at (67, 34) and begin inspection between 313 and 555.
Visit location 3 at (9, 45) and begin inspection between 199 and 443.
Visit location 4 at (30, 76) and begin inspection between 29 and 212.
Visit location 5 at (100, 79) and begin inspection between 15 and 209.
Visit location 6 at (8, 86) and begin inspection between 129 and 319.
Visit location 7 at (16, 88) and begin inspection between 276 and 473.
Visit location 8 at (14, 100) and begin inspection between 93 and 306.
Return to the office 0 after visiting all 9 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': [[0, 0], [73, 18], [67, 34], [9, 45], [30, 76], [100, 79], [8, 86], [16, 88], [14, 100]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [323, 555], [313, 555], [199, 443], [29, 212], [15, 209], [129, 319], [276, 473], [93, 306]], 'tour_length': 435.6611227744208, 'objective': 435.6611227744208}","[0, 5, 4, 7, 8, 6, 3, 2, 1, 0]",435.6611227744208,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 0, 'x': 0, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 73, 'y': 18, 'tw_start': 323, 'tw_end': 555}, {'id': 2, 'x': 67, 'y': 34, 'tw_start': 313, 'tw_end': 555}, {'id': 3, 'x': 9, 'y': 45, 'tw_start': 199, 'tw_end': 443}, {'id': 4, 'x': 30, 'y': 76, 'tw_start': 29, 'tw_end': 212}, {'id': 5, 'x': 100, 'y': 79, 'tw_start': 15, 'tw_end': 209}, {'id': 6, 'x': 8, 'y': 86, 'tw_start': 129, 'tw_end': 319}, {'id': 7, 'x': 16, 'y': 88, 'tw_start': 276, 'tw_end': 473}, {'id': 8, 'x': 14, 'y': 100, 'tw_start': 93, 'tw_end': 306}], 'depot': 0, 'objective': 435.6611227744208}","[0, 5, 4, 7, 8, 6, 3, 2, 1, 0]",5,nl,0
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 5, with clinic 1 as the tour start and end.
Stop 1 is at (0, 21), with access window 0 to 918.
Stop 2 is at (7, 100), with access window 47 to 281.
Stop 3 is at (45, 91), with access window 24 to 274.
Stop 4 is at (65, 0), with access window 257 to 441.
Stop 5 is at (100, 32), with access window 1 to 236.
The leader will plan a loop visiting all 5 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': [[0, 21], [7, 100], [45, 91], [65, 0], [100, 32]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [47, 281], [24, 274], [257, 441], [1, 236]], 'tour_length': 314.7522961726996, 'objective': 314.7522961726996}","[0, 1, 2, 4, 3, 0]",314.7522961726996,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 1, 'x': 0, 'y': 21, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 7, 'y': 100, 'tw_start': 47, 'tw_end': 281}, {'id': 3, 'x': 45, 'y': 91, 'tw_start': 24, 'tw_end': 274}, {'id': 4, 'x': 65, 'y': 0, 'tw_start': 257, 'tw_end': 441}, {'id': 5, 'x': 100, 'y': 32, 'tw_start': 1, 'tw_end': 236}], 'depot': 1, 'objective': 314.7522961726996}","[1, 2, 3, 5, 4, 1]",6,nl,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.

There are 7 stops to serve, with the studio as node A.
Location A: coordinates (12, 0); booked window 0 to 918.
Location B: coordinates (0, 11); booked window 236 to 463.
Location C: coordinates (20, 18); booked window 257 to 430.
Location D: coordinates (100, 31); booked window 119 to 296.
Location E: coordinates (19, 40); booked window 288 to 507.
Location F: coordinates (10, 100); booked window 110 to 282.
Location G: coordinates (82, 98); booked window 103 to 298.
They must visit all 7 stops and return to A, choosing the route with the smallest total driving distance.

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': [[12, 0], [0, 11], [20, 18], [100, 31], [19, 40], [10, 100], [82, 98]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [236, 463], [257, 430], [119, 296], [288, 507], [110, 282], [103, 298]], 'tour_length': 354.86655169020463, 'objective': 354.86655169020463}","[0, 3, 6, 5, 4, 2, 1, 0]",354.86655169020463,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 'A', 'x': 12, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 0, 'y': 11, 'tw_start': 236, 'tw_end': 463}, {'id': 'C', 'x': 20, 'y': 18, 'tw_start': 257, 'tw_end': 430}, {'id': 'D', 'x': 100, 'y': 31, 'tw_start': 119, 'tw_end': 296}, {'id': 'E', 'x': 19, 'y': 40, 'tw_start': 288, 'tw_end': 507}, {'id': 'F', 'x': 10, 'y': 100, 'tw_start': 110, 'tw_end': 282}, {'id': 'G', 'x': 82, 'y': 98, 'tw_start': 103, 'tw_end': 298}], 'depot': 'A', 'objective': 354.86655169020463}","['A', 'D', 'G', 'F', 'E', 'C', 'B', 'A']",7,nl,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.

{
  ""total_locations"": 10,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""coord_x"": 0,
      ""coord_y"": 83,
      ""service_window_start"": 0,
      ""service_window_end"": 918
    },
    {
      ""location_id"": 1,
      ""coord_x"": 89,
      ""coord_y"": 5,
      ""service_window_start"": 243,
      ""service_window_end"": 463
    },
    {
      ""location_id"": 2,
      ""coord_x"": 5,
      ""coord_y"": 0,
      ""service_window_start"": 296,
      ""service_window_end"": 502
    },
    {
      ""location_id"": 3,
      ""coord_x"": 100,
      ""coord_y"": 27,
      ""service_window_start"": 39,
      ""service_window_end"": 266
    },
    {
      ""location_id"": 4,
      ""coord_x"": 18,
      ""coord_y"": 16,
      ""service_window_start"": 254,
      ""service_window_end"": 467
    },
    {
      ""location_id"": 5,
      ""coord_x"": 52,
      ""coord_y"": 50,
      ""service_window_start"": 257,
      ""service_window_end"": 465
    },
    {
      ""location_id"": 6,
      ""coord_x"": 56,
      ""coord_y"": 100,
      ""service_window_start"": 174,
      ""service_window_end"": 377
    },
    {
      ""location_id"": 7,
      ""coord_x"": 20,
      ""coord_y"": 80,
      ""service_window_start"": 8,
      ""service_window_end"": 184
    },
    {
      ""location_id"": 8,
      ""coord_x"": 92,
      ""coord_y"": 35,
      ""service_window_start"": 10,
      ""service_window_end"": 230
    },
    {
      ""location_id"": 9,
      ""coord_x"": 88,
      ""coord_y"": 14,
      ""service_window_start"": 104,
      ""service_window_end"": 314
    }
  ],
  ""depot_node_id"": 0
}

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': [[0, 83], [89, 5], [5, 0], [100, 27], [18, 16], [52, 50], [56, 100], [20, 80], [92, 35], [88, 14]], 'depot': 0, 'num_nodes': 10, 'time_windows': [[0, 918], [243, 463], [296, 502], [39, 266], [254, 467], [257, 465], [174, 377], [8, 184], [10, 230], [104, 314]], 'tour_length': 443.8649780585826, 'objective': 443.8649780585826}","[0, 7, 8, 3, 1, 9, 6, 5, 4, 2, 0]",443.8649780585826,"{'problem_type': 'TSPTW', 'num_nodes': 10, 'nodes': [{'id': 0, 'x': 0, 'y': 83, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 89, 'y': 5, 'tw_start': 243, 'tw_end': 463}, {'id': 2, 'x': 5, 'y': 0, 'tw_start': 296, 'tw_end': 502}, {'id': 3, 'x': 100, 'y': 27, 'tw_start': 39, 'tw_end': 266}, {'id': 4, 'x': 18, 'y': 16, 'tw_start': 254, 'tw_end': 467}, {'id': 5, 'x': 52, 'y': 50, 'tw_start': 257, 'tw_end': 465}, {'id': 6, 'x': 56, 'y': 100, 'tw_start': 174, 'tw_end': 377}, {'id': 7, 'x': 20, 'y': 80, 'tw_start': 8, 'tw_end': 184}, {'id': 8, 'x': 92, 'y': 35, 'tw_start': 10, 'tw_end': 230}, {'id': 9, 'x': 88, 'y': 14, 'tw_start': 104, 'tw_end': 314}], 'depot': 0, 'objective': 443.8649780585826}","[0, 7, 8, 3, 1, 9, 6, 5, 4, 2, 0]",8,json,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.

There are 6 locations in total — the headquarters is node 1.

| venue_identifier | x_coordinate | y_coordinate | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| 1 | 0 | 0 | 0 | 918 |
| 2 | 80 | 12 | 303 | 490 |
| 3 | 3 | 58 | 137 | 367 |
| 4 | 100 | 66 | 76 | 249 |
| 5 | 9 | 79 | 96 | 277 |
| 6 | 75 | 100 | 310 | 544 |

Use these records to construct a route that starts and ends at node 1 and visits all 6 locations within their time windows.

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, 0], [80, 12], [3, 58], [100, 66], [9, 79], [75, 100]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [303, 490], [137, 367], [76, 249], [96, 277], [310, 544]], 'tour_length': 409.91949336724053, 'objective': 409.91949336724053}","[0, 4, 2, 3, 5, 1, 0]",409.91949336724053,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 80, 'y': 12, 'tw_start': 303, 'tw_end': 490}, {'id': 3, 'x': 3, 'y': 58, 'tw_start': 137, 'tw_end': 367}, {'id': 4, 'x': 100, 'y': 66, 'tw_start': 76, 'tw_end': 249}, {'id': 5, 'x': 9, 'y': 79, 'tw_start': 96, 'tw_end': 277}, {'id': 6, 'x': 75, 'y': 100, 'tw_start': 310, 'tw_end': 544}], 'depot': 1, 'objective': 409.91949336724053}","[1, 5, 3, 4, 6, 2, 1]",9,markdown_table,1
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 6 locations in total, and the tour must start and end at depot 0.
Stop 0 at (0, 100) with visit window 0 to 918.
Stop 1 at (48, 100) with visit window 211 to 451.
Stop 2 at (62, 9) with visit window 268 to 451.
Stop 3 at (82, 63) with visit window 298 to 510.
Stop 4 at (100, 0) with visit window 269 to 511.
Stop 5 at (100, 19) with visit window 106 to 282.
The planner must order these stops to minimize total driving while arriving within each visit window and returning to depot 0 across all 6 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': [[0, 100], [48, 100], [62, 9], [82, 63], [100, 0], [100, 19]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [211, 451], [268, 451], [298, 510], [269, 511], [106, 282]], 'tour_length': 342.57489559589874, 'objective': 342.57489559589874}","[0, 5, 4, 2, 3, 1, 0]",342.57489559589874,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 0, 'x': 0, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 48, 'y': 100, 'tw_start': 211, 'tw_end': 451}, {'id': 2, 'x': 62, 'y': 9, 'tw_start': 268, 'tw_end': 451}, {'id': 3, 'x': 82, 'y': 63, 'tw_start': 298, 'tw_end': 510}, {'id': 4, 'x': 100, 'y': 0, 'tw_start': 269, 'tw_end': 511}, {'id': 5, 'x': 100, 'y': 19, 'tw_start': 106, 'tw_end': 282}], 'depot': 0, 'objective': 342.57489559589874}","[0, 5, 4, 2, 3, 1, 0]",10,nl,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.

There are 7 locations including the lab, with lab node id 0.
Site 0 is located at (17, 99) and accepts the technician from 0 until 918.
Site 1 is located at (51, 99) and accepts the technician from 76 until 278.
Site 2 is located at (90, 0) and accepts the technician from 273 until 512.
Site 3 is located at (100, 30) and accepts the technician from 2 until 211.
Site 4 is located at (100, 66) and accepts the technician from 139 until 324.
Site 5 is located at (0, 64) and accepts the technician from 40 until 235.
Site 6 is located at (4, 100) and accepts the technician from 314 until 508.
The objective is to minimize the total driving distance of the tour.

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': [[17, 99], [51, 99], [90, 0], [100, 30], [100, 66], [0, 64], [4, 100]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [76, 278], [273, 512], [2, 211], [139, 324], [40, 235], [314, 508]], 'tour_length': 372.3961214068931, 'objective': 372.3961214068931}","[0, 5, 1, 4, 3, 2, 6, 0]",372.3961214068931,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 0, 'x': 17, 'y': 99, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 51, 'y': 99, 'tw_start': 76, 'tw_end': 278}, {'id': 2, 'x': 90, 'y': 0, 'tw_start': 273, 'tw_end': 512}, {'id': 3, 'x': 100, 'y': 30, 'tw_start': 2, 'tw_end': 211}, {'id': 4, 'x': 100, 'y': 66, 'tw_start': 139, 'tw_end': 324}, {'id': 5, 'x': 0, 'y': 64, 'tw_start': 40, 'tw_end': 235}, {'id': 6, 'x': 4, 'y': 100, 'tw_start': 314, 'tw_end': 508}], 'depot': 0, 'objective': 372.3961214068931}","[0, 5, 1, 4, 3, 2, 6, 0]",11,nl,0
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.

There are 9 locations in total, counting the bakery as node 1.

| stop_id | coord_x | coord_y | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| 1 | 100 | 0 | 0 | 918 |
| 2 | 84 | 4 | 173 | 398 |
| 3 | 18 | 13 | 121 | 369 |
| 4 | 79 | 13 | 321 | 509 |
| 5 | 1 | 22 | 166 | 358 |
| 6 | 36 | 26 | 95 | 265 |
| 7 | 75 | 61 | 203 | 412 |
| 8 | 0 | 69 | 17 | 207 |
| 9 | 92 | 100 | 303 | 490 |

They list each stop so the driver’s route can respect the time windows while minimizing total distance.

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': [[100, 0], [84, 4], [18, 13], [79, 13], [1, 22], [36, 26], [75, 61], [0, 69], [92, 100]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [173, 398], [121, 369], [321, 509], [166, 358], [95, 265], [203, 412], [17, 207], [303, 490]], 'tour_length': 459.3423876776866, 'objective': 459.3423876776866}","[0, 5, 7, 4, 2, 1, 3, 6, 8, 0]",459.3423876776866,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 1, 'x': 100, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 84, 'y': 4, 'tw_start': 173, 'tw_end': 398}, {'id': 3, 'x': 18, 'y': 13, 'tw_start': 121, 'tw_end': 369}, {'id': 4, 'x': 79, 'y': 13, 'tw_start': 321, 'tw_end': 509}, {'id': 5, 'x': 1, 'y': 22, 'tw_start': 166, 'tw_end': 358}, {'id': 6, 'x': 36, 'y': 26, 'tw_start': 95, 'tw_end': 265}, {'id': 7, 'x': 75, 'y': 61, 'tw_start': 203, 'tw_end': 412}, {'id': 8, 'x': 0, 'y': 69, 'tw_start': 17, 'tw_end': 207}, {'id': 9, 'x': 92, 'y': 100, 'tw_start': 303, 'tw_end': 490}], 'depot': 1, 'objective': 459.3423876776866}","[1, 6, 8, 5, 3, 2, 4, 7, 9, 1]",12,markdown_table,1
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.

Someone will consider 7 locations in total, with the studio at node A.
Location A is at (4, 94) and must be visited within the access window 0 to 918.
Location B is at (22, 0) and must be visited within the access window 308 to 549.
Location C is at (56, 21) and must be visited within the access window 86 to 308.
Location D is at (67, 44) and must be visited within the access window 272 to 486.
Location E is at (0, 26) and must be visited within the access window 176 to 364.
Location F is at (93, 62) and must be visited within the access window 31 to 273.
Location G is at (100, 100) and must be visited within the access window 300 to 520.
The chosen route will minimize total miles while visiting each gallery once and returning to the studio.

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': [[4, 94], [22, 0], [56, 21], [67, 44], [0, 26], [93, 62], [100, 100]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [308, 549], [86, 308], [272, 486], [176, 364], [31, 273], [300, 520]], 'tour_length': 454.3891758874684, 'objective': 454.3891758874684}","[0, 5, 2, 1, 4, 3, 6, 0]",454.3891758874684,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 'A', 'x': 4, 'y': 94, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 22, 'y': 0, 'tw_start': 308, 'tw_end': 549}, {'id': 'C', 'x': 56, 'y': 21, 'tw_start': 86, 'tw_end': 308}, {'id': 'D', 'x': 67, 'y': 44, 'tw_start': 272, 'tw_end': 486}, {'id': 'E', 'x': 0, 'y': 26, 'tw_start': 176, 'tw_end': 364}, {'id': 'F', 'x': 93, 'y': 62, 'tw_start': 31, 'tw_end': 273}, {'id': 'G', 'x': 100, 'y': 100, 'tw_start': 300, 'tw_end': 520}], 'depot': 'A', 'objective': 454.3891758874684}","['A', 'F', 'C', 'B', 'E', 'D', 'G', 'A']",13,nl,names
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"": 9,
  ""nodes"": [
    {
      ""inspection_point_id"": 1,
      ""x_coordinate"": 3,
      ""y_coordinate"": 1,
      ""time_window_start"": 0,
      ""time_window_end"": 918
    },
    {
      ""inspection_point_id"": 2,
      ""x_coordinate"": 59,
      ""y_coordinate"": 0,
      ""time_window_start"": 113,
      ""time_window_end"": 309
    },
    {
      ""inspection_point_id"": 3,
      ""x_coordinate"": 85,
      ""y_coordinate"": 18,
      ""time_window_start"": 242,
      ""time_window_end"": 484
    },
    {
      ""inspection_point_id"": 4,
      ""x_coordinate"": 89,
      ""y_coordinate"": 41,
      ""time_window_start"": 296,
      ""time_window_end"": 528
    },
    {
      ""inspection_point_id"": 5,
      ""x_coordinate"": 94,
      ""y_coordinate"": 43,
      ""time_window_start"": 214,
      ""time_window_end"": 388
    },
    {
      ""inspection_point_id"": 6,
      ""x_coordinate"": 8,
      ""y_coordinate"": 61,
      ""time_window_start"": 53,
      ""time_window_end"": 296
    },
    {
      ""inspection_point_id"": 7,
      ""x_coordinate"": 100,
      ""y_coordinate"": 76,
      ""time_window_start"": 202,
      ""time_window_end"": 370
    },
    {
      ""inspection_point_id"": 8,
      ""x_coordinate"": 85,
      ""y_coordinate"": 83,
      ""time_window_start"": 33,
      ""time_window_end"": 256
    },
    {
      ""inspection_point_id"": 9,
      ""x_coordinate"": 0,
      ""y_coordinate"": 100,
      ""time_window_start"": 1,
      ""time_window_end"": 182
    }
  ],
  ""yard_node_identifier"": 1
}

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': [[3, 1], [59, 0], [85, 18], [89, 41], [94, 43], [8, 61], [100, 76], [85, 83], [0, 100]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [113, 309], [242, 484], [296, 528], [214, 388], [53, 296], [202, 370], [33, 256], [1, 182]], 'tour_length': 440.64155402698503, 'objective': 440.64155402698503}","[0, 5, 8, 7, 6, 4, 2, 1, 3, 0]",440.64155402698503,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 1, 'x': 3, 'y': 1, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 59, 'y': 0, 'tw_start': 113, 'tw_end': 309}, {'id': 3, 'x': 85, 'y': 18, 'tw_start': 242, 'tw_end': 484}, {'id': 4, 'x': 89, 'y': 41, 'tw_start': 296, 'tw_end': 528}, {'id': 5, 'x': 94, 'y': 43, 'tw_start': 214, 'tw_end': 388}, {'id': 6, 'x': 8, 'y': 61, 'tw_start': 53, 'tw_end': 296}, {'id': 7, 'x': 100, 'y': 76, 'tw_start': 202, 'tw_end': 370}, {'id': 8, 'x': 85, 'y': 83, 'tw_start': 33, 'tw_end': 256}, {'id': 9, 'x': 0, 'y': 100, 'tw_start': 1, 'tw_end': 182}], 'depot': 1, 'objective': 440.64155402698503}","[1, 6, 9, 8, 7, 5, 3, 2, 4, 1]",14,json,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 5 locations, starting and ending at kitchen 1.

| location_id | x_coordinate | y_coordinate | earliest_allowed_arrival | latest_allowed_arrival |
|---|---|---|---|---|
| 1 | 0 | 27 | 0 | 918 |
| 2 | 100 | 7 | 183 | 408 |
| 3 | 29 | 100 | 217 | 403 |
| 4 | 42 | 100 | 237 | 424 |
| 5 | 36 | 0 | 108 | 338 |

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': [[0, 27], [100, 7], [29, 100], [42, 100], [36, 0]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [183, 408], [217, 403], [237, 424], [108, 338]], 'tour_length': 310.53485400769796, 'objective': 310.53485400769796}","[0, 4, 1, 3, 2, 0]",310.53485400769796,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 1, 'x': 0, 'y': 27, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 100, 'y': 7, 'tw_start': 183, 'tw_end': 408}, {'id': 3, 'x': 29, 'y': 100, 'tw_start': 217, 'tw_end': 403}, {'id': 4, 'x': 42, 'y': 100, 'tw_start': 237, 'tw_end': 424}, {'id': 5, 'x': 36, 'y': 0, 'tw_start': 108, 'tw_end': 338}], 'depot': 1, 'objective': 310.53485400769796}","[1, 5, 2, 4, 3, 1]",15,markdown_table,1
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.

# total_locations_including_office=6
# office_node_id=A
# time windows are listed per node in the table
location_id,location_x_coordinate,location_y_coordinate,earliest_arrival_time,latest_arrival_time
A,39,100,0,918
B,61,55,216,454
C,73,27,219,434
D,86,97,31,228
E,100,0,88,275
F,0,27,324,524

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': [[39, 100], [61, 55], [73, 27], [86, 97], [100, 0], [0, 27]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [216, 454], [219, 434], [31, 228], [88, 275], [324, 524]], 'tour_length': 363.63163143724216, 'objective': 363.63163143724216}","[0, 3, 4, 2, 1, 5, 0]",363.63163143724216,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 'A', 'x': 39, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 61, 'y': 55, 'tw_start': 216, 'tw_end': 454}, {'id': 'C', 'x': 73, 'y': 27, 'tw_start': 219, 'tw_end': 434}, {'id': 'D', 'x': 86, 'y': 97, 'tw_start': 31, 'tw_end': 228}, {'id': 'E', 'x': 100, 'y': 0, 'tw_start': 88, 'tw_end': 275}, {'id': 'F', 'x': 0, 'y': 27, 'tw_start': 324, 'tw_end': 524}], 'depot': 'A', 'objective': 363.63163143724216}","['A', 'D', 'E', 'C', 'B', 'F', 'A']",16,csv,names
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.

We have 8 total locations to consider and the home shop is 1.

| location_id | map_x_coordinate | map_y_coordinate | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| 1 | 18 | 12 | 0 | 918 |
| 2 | 0 | 100 | 297 | 517 |
| 3 | 52 | 84 | 265 | 474 |
| 4 | 76 | 20 | 192 | 400 |
| 5 | 95 | 28 | 65 | 292 |
| 6 | 100 | 96 | 93 | 262 |
| 7 | 90 | 10 | 215 | 397 |
| 8 | 63 | 0 | 314 | 560 |

We will select the visiting order that minimizes the total trip length, summing distances between consecutive locations and including the return to the home shop.

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': [[18, 12], [0, 100], [52, 84], [76, 20], [95, 28], [100, 96], [90, 10], [63, 0]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [297, 517], [265, 474], [192, 400], [65, 292], [93, 262], [215, 397], [314, 560]], 'tour_length': 469.4794014243796, 'objective': 469.4794014243796}","[0, 5, 4, 6, 7, 3, 2, 1, 0]",469.4794014243796,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 1, 'x': 18, 'y': 12, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 0, 'y': 100, 'tw_start': 297, 'tw_end': 517}, {'id': 3, 'x': 52, 'y': 84, 'tw_start': 265, 'tw_end': 474}, {'id': 4, 'x': 76, 'y': 20, 'tw_start': 192, 'tw_end': 400}, {'id': 5, 'x': 95, 'y': 28, 'tw_start': 65, 'tw_end': 292}, {'id': 6, 'x': 100, 'y': 96, 'tw_start': 93, 'tw_end': 262}, {'id': 7, 'x': 90, 'y': 10, 'tw_start': 215, 'tw_end': 397}, {'id': 8, 'x': 63, 'y': 0, 'tw_start': 314, 'tw_end': 560}], 'depot': 1, 'objective': 469.4794014243796}","[1, 6, 5, 7, 8, 4, 3, 2, 1]",17,markdown_table,1
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 9 locations in total, with the regional office recorded as 1.
Location 1 at coordinates (0, 37) is available for visits from 0 to 918.
Location 2 at coordinates (21, 18) is available for visits from 305 to 503.
Location 3 at coordinates (33, 0) is available for visits from 5 to 249.
Location 4 at coordinates (38, 34) is available for visits from 143 to 390.
Location 5 at coordinates (43, 18) is available for visits from 321 to 560.
Location 6 at coordinates (16, 81) is available for visits from 98 to 297.
Location 7 at coordinates (21, 63) is available for visits from 284 to 477.
Location 8 at coordinates (100, 81) is available for visits from 56 to 270.
Location 9 at coordinates (71, 100) is available for visits from 312 to 537.
The field rep must start and finish at 1 and visit all 9 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, 37], [21, 18], [33, 0], [38, 34], [43, 18], [16, 81], [21, 63], [100, 81], [71, 100]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [305, 503], [5, 249], [143, 390], [321, 560], [98, 297], [284, 477], [56, 270], [312, 537]], 'tour_length': 441.9876672637859, 'objective': 441.9876672637859}","[0, 2, 5, 7, 8, 3, 4, 1, 6, 0]",441.9876672637859,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 1, 'x': 0, 'y': 37, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 21, 'y': 18, 'tw_start': 305, 'tw_end': 503}, {'id': 3, 'x': 33, 'y': 0, 'tw_start': 5, 'tw_end': 249}, {'id': 4, 'x': 38, 'y': 34, 'tw_start': 143, 'tw_end': 390}, {'id': 5, 'x': 43, 'y': 18, 'tw_start': 321, 'tw_end': 560}, {'id': 6, 'x': 16, 'y': 81, 'tw_start': 98, 'tw_end': 297}, {'id': 7, 'x': 21, 'y': 63, 'tw_start': 284, 'tw_end': 477}, {'id': 8, 'x': 100, 'y': 81, 'tw_start': 56, 'tw_end': 270}, {'id': 9, 'x': 71, 'y': 100, 'tw_start': 312, 'tw_end': 537}], 'depot': 1, 'objective': 441.9876672637859}","[1, 3, 6, 8, 9, 4, 5, 2, 7, 1]",18,nl,1
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.

You will find 7 locations listed here and the warehouse node id is 0.
Stop 0 at (0, 58) with delivery window [0, 918].
Stop 1 at (10, 9) with delivery window [190, 365].
Stop 2 at (51, 100) with delivery window [205, 455].
Stop 3 at (66, 58) with delivery window [46, 257].
Stop 4 at (68, 51) with delivery window [293, 521].
Stop 5 at (90, 26) with delivery window [232, 458].
Stop 6 at (100, 0) with delivery window [120, 311].
Visit each of the 7 stops (start/finish at 0), observing every delivery window.

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': [[0, 58], [10, 9], [51, 100], [66, 58], [68, 51], [90, 26], [100, 0]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [190, 365], [205, 455], [46, 257], [293, 521], [232, 458], [120, 311]], 'tour_length': 409.95168600048777, 'objective': 409.95168600048777}","[0, 3, 1, 6, 5, 4, 2, 0]",409.95168600048777,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 0, 'x': 0, 'y': 58, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 10, 'y': 9, 'tw_start': 190, 'tw_end': 365}, {'id': 2, 'x': 51, 'y': 100, 'tw_start': 205, 'tw_end': 455}, {'id': 3, 'x': 66, 'y': 58, 'tw_start': 46, 'tw_end': 257}, {'id': 4, 'x': 68, 'y': 51, 'tw_start': 293, 'tw_end': 521}, {'id': 5, 'x': 90, 'y': 26, 'tw_start': 232, 'tw_end': 458}, {'id': 6, 'x': 100, 'y': 0, 'tw_start': 120, 'tw_end': 311}], 'depot': 0, 'objective': 409.95168600048777}","[0, 3, 1, 6, 5, 4, 2, 0]",19,nl,0
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"": 8,
  ""nodes"": [
    {
      ""household_node_id"": 0,
      ""x_coordinate_map"": 23,
      ""y_coordinate_map"": 26,
      ""visit_window_start_time"": 0,
      ""visit_window_end_time"": 918
    },
    {
      ""household_node_id"": 1,
      ""x_coordinate_map"": 91,
      ""y_coordinate_map"": 100,
      ""visit_window_start_time"": 270,
      ""visit_window_end_time"": 504
    },
    {
      ""household_node_id"": 2,
      ""x_coordinate_map"": 0,
      ""y_coordinate_map"": 88,
      ""visit_window_start_time"": 289,
      ""visit_window_end_time"": 532
    },
    {
      ""household_node_id"": 3,
      ""x_coordinate_map"": 83,
      ""y_coordinate_map"": 13,
      ""visit_window_start_time"": 170,
      ""visit_window_end_time"": 379
    },
    {
      ""household_node_id"": 4,
      ""x_coordinate_map"": 82,
      ""y_coordinate_map"": 95,
      ""visit_window_start_time"": 266,
      ""visit_window_end_time"": 487
    },
    {
      ""household_node_id"": 5,
      ""x_coordinate_map"": 100,
      ""y_coordinate_map"": 83,
      ""visit_window_start_time"": 234,
      ""visit_window_end_time"": 467
    },
    {
      ""household_node_id"": 6,
      ""x_coordinate_map"": 80,
      ""y_coordinate_map"": 0,
      ""visit_window_start_time"": 297,
      ""visit_window_end_time"": 492
    },
    {
      ""household_node_id"": 7,
      ""x_coordinate_map"": 2,
      ""y_coordinate_map"": 59,
      ""visit_window_start_time"": 125,
      ""visit_window_end_time"": 300
    }
  ],
  ""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': [[23, 26], [91, 100], [0, 88], [83, 13], [82, 95], [100, 83], [80, 0], [2, 59]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [270, 504], [289, 532], [170, 379], [266, 487], [234, 467], [297, 492], [125, 300]], 'tour_length': 400.25032514799904, 'objective': 400.25032514799904}","[0, 7, 6, 3, 5, 1, 4, 2, 0]",400.25032514799904,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 0, 'x': 23, 'y': 26, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 91, 'y': 100, 'tw_start': 270, 'tw_end': 504}, {'id': 2, 'x': 0, 'y': 88, 'tw_start': 289, 'tw_end': 532}, {'id': 3, 'x': 83, 'y': 13, 'tw_start': 170, 'tw_end': 379}, {'id': 4, 'x': 82, 'y': 95, 'tw_start': 266, 'tw_end': 487}, {'id': 5, 'x': 100, 'y': 83, 'tw_start': 234, 'tw_end': 467}, {'id': 6, 'x': 80, 'y': 0, 'tw_start': 297, 'tw_end': 492}, {'id': 7, 'x': 2, 'y': 59, 'tw_start': 125, 'tw_end': 300}], 'depot': 0, 'objective': 400.25032514799904}","[0, 7, 6, 3, 5, 1, 4, 2, 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.

There are 5 stops in total, with the oven at node A.
Cafe A at (1, 0); open from 0 to 918.
Cafe B at (4, 100); open from 193 to 363.
Cafe C at (0, 40); open from 155 to 367.
Cafe D at (72, 74); open from 95 to 312.
Cafe E at (100, 65); open from 10 to 180.
Visit each of the 5 stops exactly once and return to the oven at node A.

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': [[1, 0], [4, 100], [0, 40], [72, 74], [100, 65]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [193, 363], [155, 367], [95, 312], [10, 180]], 'tour_length': 320.7890795448109, 'objective': 320.7890795448109}","[0, 4, 3, 1, 2, 0]",320.7890795448109,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 'A', 'x': 1, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 4, 'y': 100, 'tw_start': 193, 'tw_end': 363}, {'id': 'C', 'x': 0, 'y': 40, 'tw_start': 155, 'tw_end': 367}, {'id': 'D', 'x': 72, 'y': 74, 'tw_start': 95, 'tw_end': 312}, {'id': 'E', 'x': 100, 'y': 65, 'tw_start': 10, 'tw_end': 180}], 'depot': 'A', 'objective': 320.7890795448109}","['A', 'E', 'D', 'B', 'C', 'A']",21,nl,names
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"": 6,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""x_coordinate"": 55,
      ""y_coordinate"": 100,
      ""service_window_start"": 0,
      ""service_window_end"": 918
    },
    {
      ""location_id"": ""B"",
      ""x_coordinate"": 100,
      ""y_coordinate"": 0,
      ""service_window_start"": 274,
      ""service_window_end"": 471
    },
    {
      ""location_id"": ""C"",
      ""x_coordinate"": 93,
      ""y_coordinate"": 43,
      ""service_window_start"": 42,
      ""service_window_end"": 253
    },
    {
      ""location_id"": ""D"",
      ""x_coordinate"": 99,
      ""y_coordinate"": 48,
      ""service_window_start"": 257,
      ""service_window_end"": 442
    },
    {
      ""location_id"": ""E"",
      ""x_coordinate"": 0,
      ""y_coordinate"": 93,
      ""service_window_start"": 208,
      ""service_window_end"": 382
    },
    {
      ""location_id"": ""F"",
      ""x_coordinate"": 39,
      ""y_coordinate"": 93,
      ""service_window_start"": 17,
      ""service_window_end"": 228
    }
  ],
  ""depot_node_id"": ""A""
}

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': [[55, 100], [100, 0], [93, 43], [99, 48], [0, 93], [39, 93]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [274, 471], [42, 253], [257, 442], [208, 382], [17, 228]], 'tour_length': 433.78825473431607, 'objective': 433.78825473431607}","[0, 2, 5, 4, 1, 3, 0]",433.78825473431607,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 'A', 'x': 55, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 100, 'y': 0, 'tw_start': 274, 'tw_end': 471}, {'id': 'C', 'x': 93, 'y': 43, 'tw_start': 42, 'tw_end': 253}, {'id': 'D', 'x': 99, 'y': 48, 'tw_start': 257, 'tw_end': 442}, {'id': 'E', 'x': 0, 'y': 93, 'tw_start': 208, 'tw_end': 382}, {'id': 'F', 'x': 39, 'y': 93, 'tw_start': 17, 'tw_end': 228}], 'depot': 'A', 'objective': 433.78825473431607}","['A', 'C', 'F', 'E', 'B', 'D', 'A']",22,json,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.

# total_locations_including_clinic=8
# clinic_node_id=A
# time windows are listed per node in the table
location_node_id,map_x_coordinate,map_y_coordinate,availability_start_time,availability_end_time
A,0,100,0,918
B,25,80,180,400
C,61,50,242,490
D,69,41,172,366
E,85,31,265,455
F,63,25,146,320
G,85,22,8,255
H,100,0,279,504

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': [[0, 100], [25, 80], [61, 50], [69, 41], [85, 31], [63, 25], [85, 22], [100, 0]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [180, 400], [242, 490], [172, 366], [265, 455], [146, 320], [8, 255], [279, 504]], 'tour_length': 291.00465032740505, 'objective': 291.00465032740505}","[0, 5, 6, 7, 4, 3, 2, 1, 0]",291.00465032740505,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 'A', 'x': 0, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 25, 'y': 80, 'tw_start': 180, 'tw_end': 400}, {'id': 'C', 'x': 61, 'y': 50, 'tw_start': 242, 'tw_end': 490}, {'id': 'D', 'x': 69, 'y': 41, 'tw_start': 172, 'tw_end': 366}, {'id': 'E', 'x': 85, 'y': 31, 'tw_start': 265, 'tw_end': 455}, {'id': 'F', 'x': 63, 'y': 25, 'tw_start': 146, 'tw_end': 320}, {'id': 'G', 'x': 85, 'y': 22, 'tw_start': 8, 'tw_end': 255}, {'id': 'H', 'x': 100, 'y': 0, 'tw_start': 279, 'tw_end': 504}], 'depot': 'A', 'objective': 291.00465032740505}","['A', 'F', 'G', 'H', 'E', 'D', 'C', 'B', 'A']",23,csv,names
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.

There are 6 locations in total, and the studio (depot) is node A.
Location A: at (0, 75) with access window 0 to 918.
Location B: at (100, 7) with access window 136 to 318.
Location C: at (51, 100) with access window 52 to 240.
Location D: at (71, 9) with access window 183 to 410.
Location E: at (49, 34) with access window 220 to 410.
Location F: at (67, 0) with access window 318 to 547.
Start and finish the route at the studio (node A); visit every location once within its access window.

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': [[0, 75], [100, 7], [51, 100], [71, 9], [49, 34], [67, 0]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [136, 318], [52, 240], [183, 410], [220, 410], [318, 547]], 'tour_length': 302.69216387200356, 'objective': 302.69216387200356}","[0, 2, 1, 5, 3, 4, 0]",302.69216387200356,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 'A', 'x': 0, 'y': 75, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 100, 'y': 7, 'tw_start': 136, 'tw_end': 318}, {'id': 'C', 'x': 51, 'y': 100, 'tw_start': 52, 'tw_end': 240}, {'id': 'D', 'x': 71, 'y': 9, 'tw_start': 183, 'tw_end': 410}, {'id': 'E', 'x': 49, 'y': 34, 'tw_start': 220, 'tw_end': 410}, {'id': 'F', 'x': 67, 'y': 0, 'tw_start': 318, 'tw_end': 547}], 'depot': 'A', 'objective': 302.69216387200356}","['A', 'C', 'B', 'F', 'D', 'E', 'A']",24,nl,names
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.

# total_locations_including_office=8
# office_node_id=0
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,demo_start_time,demo_end_time
0,8,22,0,918
1,100,67,185,403
2,14,0,140,327
3,93,52,118,349
4,99,100,4,181
5,38,99,15,185
6,0,67,285,511
7,72,48,158,333

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': [[8, 22], [100, 67], [14, 0], [93, 52], [99, 100], [38, 99], [0, 67], [72, 48]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [185, 403], [140, 327], [118, 349], [4, 181], [15, 185], [285, 511], [158, 333]], 'tour_length': 404.030371918883, 'objective': 404.030371918883}","[0, 5, 4, 1, 3, 7, 2, 6, 0]",404.030371918883,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 0, 'x': 8, 'y': 22, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 100, 'y': 67, 'tw_start': 185, 'tw_end': 403}, {'id': 2, 'x': 14, 'y': 0, 'tw_start': 140, 'tw_end': 327}, {'id': 3, 'x': 93, 'y': 52, 'tw_start': 118, 'tw_end': 349}, {'id': 4, 'x': 99, 'y': 100, 'tw_start': 4, 'tw_end': 181}, {'id': 5, 'x': 38, 'y': 99, 'tw_start': 15, 'tw_end': 185}, {'id': 6, 'x': 0, 'y': 67, 'tw_start': 285, 'tw_end': 511}, {'id': 7, 'x': 72, 'y': 48, 'tw_start': 158, 'tw_end': 333}], 'depot': 0, 'objective': 404.030371918883}","[0, 5, 4, 1, 3, 7, 2, 6, 0]",25,csv,0
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=10
# branch_node_id=1
# time windows are listed per node in the table
location_node_id,map_x_coordinate,map_y_coordinate,visit_window_start,visit_window_end
1,49,57,0,918
2,89,100,164,370
3,66,60,57,261
4,97,98,133,351
5,71,30,212,382
6,0,13,125,344
7,100,13,168,406
8,73,11,220,400
9,81,74,23,244
10,8,0,8,224

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': [[49, 57], [89, 100], [66, 60], [97, 98], [71, 30], [0, 13], [100, 13], [73, 11], [81, 74], [8, 0]], 'depot': 0, 'num_nodes': 10, 'time_windows': [[0, 918], [164, 370], [57, 261], [133, 351], [212, 382], [125, 344], [168, 406], [220, 400], [23, 244], [8, 224]], 'tour_length': 407.84545198825117, 'objective': 407.84545198825117}","[0, 9, 5, 2, 8, 1, 3, 4, 6, 7, 0]",407.84545198825117,"{'problem_type': 'TSPTW', 'num_nodes': 10, 'nodes': [{'id': 1, 'x': 49, 'y': 57, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 89, 'y': 100, 'tw_start': 164, 'tw_end': 370}, {'id': 3, 'x': 66, 'y': 60, 'tw_start': 57, 'tw_end': 261}, {'id': 4, 'x': 97, 'y': 98, 'tw_start': 133, 'tw_end': 351}, {'id': 5, 'x': 71, 'y': 30, 'tw_start': 212, 'tw_end': 382}, {'id': 6, 'x': 0, 'y': 13, 'tw_start': 125, 'tw_end': 344}, {'id': 7, 'x': 100, 'y': 13, 'tw_start': 168, 'tw_end': 406}, {'id': 8, 'x': 73, 'y': 11, 'tw_start': 220, 'tw_end': 400}, {'id': 9, 'x': 81, 'y': 74, 'tw_start': 23, 'tw_end': 244}, {'id': 10, 'x': 8, 'y': 0, 'tw_start': 8, 'tw_end': 224}], 'depot': 1, 'objective': 407.84545198825117}","[1, 10, 6, 3, 9, 2, 4, 5, 7, 8, 1]",26,csv,1
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 9 total locations (farm plus stalls) and the farm depot is 0.
Location 0 is at (0, 54) and must be served between 0 and 918.
Location 1 is at (0, 89) and must be served between 314 and 529.
Location 2 is at (0, 92) and must be served between 129 and 350.
Location 3 is at (42, 97) and must be served between 153 and 365.
Location 4 is at (61, 0) and must be served between 314 and 513.
Location 5 is at (86, 59) and must be served between 321 and 563.
Location 6 is at (47, 62) and must be served between 65 and 238.
Location 7 is at (100, 92) and must be served between 33 and 202.
Location 8 is at (6, 100) and must be served between 31 and 255.
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': [[0, 54], [0, 89], [0, 92], [42, 97], [61, 0], [86, 59], [47, 62], [100, 92], [6, 100]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [314, 529], [129, 350], [153, 365], [314, 513], [321, 563], [65, 238], [33, 202], [31, 255]], 'tour_length': 452.5456944387096, 'objective': 452.5456944387096}","[0, 6, 7, 3, 8, 2, 1, 5, 4, 0]",452.5456944387096,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 0, 'x': 0, 'y': 54, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 0, 'y': 89, 'tw_start': 314, 'tw_end': 529}, {'id': 2, 'x': 0, 'y': 92, 'tw_start': 129, 'tw_end': 350}, {'id': 3, 'x': 42, 'y': 97, 'tw_start': 153, 'tw_end': 365}, {'id': 4, 'x': 61, 'y': 0, 'tw_start': 314, 'tw_end': 513}, {'id': 5, 'x': 86, 'y': 59, 'tw_start': 321, 'tw_end': 563}, {'id': 6, 'x': 47, 'y': 62, 'tw_start': 65, 'tw_end': 238}, {'id': 7, 'x': 100, 'y': 92, 'tw_start': 33, 'tw_end': 202}, {'id': 8, 'x': 6, 'y': 100, 'tw_start': 31, 'tw_end': 255}], 'depot': 0, 'objective': 452.5456944387096}","[0, 6, 7, 3, 8, 2, 1, 5, 4, 0]",27,nl,0
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.

# total_locations_count=8
# hq_node_id=1
# time windows are listed per node in the table
site_id,x_coord,y_coord,inspection_window_open,inspection_window_close
1,0,48,0,918
2,4,0,23,217
3,56,36,282,451
4,96,40,272,462
5,96,48,39,264
6,96,72,210,450
7,100,20,245,479
8,100,100,94,276

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': [[0, 48], [4, 0], [56, 36], [96, 40], [96, 48], [96, 72], [100, 20], [100, 100]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [23, 217], [282, 451], [272, 462], [39, 264], [210, 450], [245, 479], [94, 276]], 'tour_length': 371.5585991222938, 'objective': 371.5585991222938}","[0, 1, 7, 5, 4, 3, 6, 2, 0]",371.5585991222938,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 1, 'x': 0, 'y': 48, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 4, 'y': 0, 'tw_start': 23, 'tw_end': 217}, {'id': 3, 'x': 56, 'y': 36, 'tw_start': 282, 'tw_end': 451}, {'id': 4, 'x': 96, 'y': 40, 'tw_start': 272, 'tw_end': 462}, {'id': 5, 'x': 96, 'y': 48, 'tw_start': 39, 'tw_end': 264}, {'id': 6, 'x': 96, 'y': 72, 'tw_start': 210, 'tw_end': 450}, {'id': 7, 'x': 100, 'y': 20, 'tw_start': 245, 'tw_end': 479}, {'id': 8, 'x': 100, 'y': 100, 'tw_start': 94, 'tw_end': 276}], 'depot': 1, 'objective': 371.5585991222938}","[1, 2, 8, 6, 5, 4, 7, 3, 1]",28,csv,1
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.

They must handle 9 locations in total, with the depot at 0.
Location 0 at coordinates (43, 92) must be begun no earlier than 0 and no later than 918.
Location 1 at coordinates (67, 44) must be begun no earlier than 250 and no later than 485.
Location 2 at coordinates (51, 58) must be begun no earlier than 330 and no later than 532.
Location 3 at coordinates (68, 85) must be begun no earlier than 124 and no later than 356.
Location 4 at coordinates (67, 100) must be begun no earlier than 113 and no later than 358.
Location 5 at coordinates (79, 93) must be begun no earlier than 286 and no later than 489.
Location 6 at coordinates (100, 57) must be begun no earlier than 250 and no later than 480.
Location 7 at coordinates (87, 92) must be begun no earlier than 34 and no later than 276.
Location 8 at coordinates (0, 0) must be begun no earlier than 168 and no later than 404.
Every plan must visit all 9 locations and return to 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': [[43, 92], [67, 44], [51, 58], [68, 85], [67, 100], [79, 93], [100, 57], [87, 92], [0, 0]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [250, 485], [330, 532], [124, 356], [113, 358], [286, 489], [250, 480], [34, 276], [168, 404]], 'tour_length': 371.60984553893553, 'objective': 371.60984553893553}","[0, 4, 3, 7, 6, 1, 8, 2, 5, 0]",371.60984553893553,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 0, 'x': 43, 'y': 92, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 67, 'y': 44, 'tw_start': 250, 'tw_end': 485}, {'id': 2, 'x': 51, 'y': 58, 'tw_start': 330, 'tw_end': 532}, {'id': 3, 'x': 68, 'y': 85, 'tw_start': 124, 'tw_end': 356}, {'id': 4, 'x': 67, 'y': 100, 'tw_start': 113, 'tw_end': 358}, {'id': 5, 'x': 79, 'y': 93, 'tw_start': 286, 'tw_end': 489}, {'id': 6, 'x': 100, 'y': 57, 'tw_start': 250, 'tw_end': 480}, {'id': 7, 'x': 87, 'y': 92, 'tw_start': 34, 'tw_end': 276}, {'id': 8, 'x': 0, 'y': 0, 'tw_start': 168, 'tw_end': 404}], 'depot': 0, 'objective': 371.60984553893553}","[0, 4, 3, 7, 6, 1, 8, 2, 5, 0]",29,nl,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 5 locations to serve, with the route starting and ending at the truck yard 1.
Stop 1: located at (0, 86), to be visited within [0, 918].
Stop 2: located at (29, 100), to be visited within [106, 348].
Stop 3: located at (61, 56), to be visited within [129, 297].
Stop 4: located at (100, 31), to be visited within [302, 477].
Stop 5: located at (43, 0), to be visited within [106, 352].
The schedule must visit every stop once within its time window and return to 1.

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': [[0, 86], [29, 100], [61, 56], [100, 31], [43, 0]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [106, 348], [129, 297], [302, 477], [106, 352]], 'tour_length': 324.4417659857286, 'objective': 324.4417659857286}","[0, 1, 2, 4, 3, 0]",324.4417659857286,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 1, 'x': 0, 'y': 86, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 29, 'y': 100, 'tw_start': 106, 'tw_end': 348}, {'id': 3, 'x': 61, 'y': 56, 'tw_start': 129, 'tw_end': 297}, {'id': 4, 'x': 100, 'y': 31, 'tw_start': 302, 'tw_end': 477}, {'id': 5, 'x': 43, 'y': 0, 'tw_start': 106, 'tw_end': 352}], 'depot': 1, 'objective': 324.4417659857286}","[1, 2, 3, 5, 4, 1]",30,nl,1
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.

There are 7 stops in total (including the lab), with the lab depot labeled 0.
Stop 0 located at (100, 21), pickup allowed between 0 and 918.
Stop 1 located at (41, 96), pickup allowed between 317 and 532.
Stop 2 located at (57, 41), pickup allowed between 211 and 415.
Stop 3 located at (56, 0), pickup allowed between 97 and 292.
Stop 4 located at (8, 20), pickup allowed between 224 and 454.
Stop 5 located at (36, 100), pickup allowed between 264 and 497.
Stop 6 located at (0, 25), pickup allowed between 30 and 238.
Use these entries to choose an order that visits every stop once and returns to 0, while respecting all pickup windows.

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': [[100, 21], [41, 96], [57, 41], [56, 0], [8, 20], [36, 100], [0, 25]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [317, 532], [211, 415], [97, 292], [224, 454], [264, 497], [30, 238]], 'tour_length': 304.48777685765356, 'objective': 304.48777685765356}","[0, 3, 4, 6, 5, 1, 2, 0]",304.48777685765356,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 0, 'x': 100, 'y': 21, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 41, 'y': 96, 'tw_start': 317, 'tw_end': 532}, {'id': 2, 'x': 57, 'y': 41, 'tw_start': 211, 'tw_end': 415}, {'id': 3, 'x': 56, 'y': 0, 'tw_start': 97, 'tw_end': 292}, {'id': 4, 'x': 8, 'y': 20, 'tw_start': 224, 'tw_end': 454}, {'id': 5, 'x': 36, 'y': 100, 'tw_start': 264, 'tw_end': 497}, {'id': 6, 'x': 0, 'y': 25, 'tw_start': 30, 'tw_end': 238}], 'depot': 0, 'objective': 304.48777685765356}","[0, 3, 4, 6, 5, 1, 2, 0]",31,nl,0
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.

{
  ""total_stops_including_office"": 5,
  ""nodes"": [
    {
      ""stop_id"": 1,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 79,
      ""viewing_window_start"": 0,
      ""viewing_window_end"": 918
    },
    {
      ""stop_id"": 2,
      ""map_x_coordinate"": 97,
      ""map_y_coordinate"": 100,
      ""viewing_window_start"": 125,
      ""viewing_window_end"": 322
    },
    {
      ""stop_id"": 3,
      ""map_x_coordinate"": 92,
      ""map_y_coordinate"": 24,
      ""viewing_window_start"": 271,
      ""viewing_window_end"": 517
    },
    {
      ""stop_id"": 4,
      ""map_x_coordinate"": 2,
      ""map_y_coordinate"": 37,
      ""viewing_window_start"": 329,
      ""viewing_window_end"": 559
    },
    {
      ""stop_id"": 5,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 0,
      ""viewing_window_start"": 125,
      ""viewing_window_end"": 299
    }
  ],
  ""office_node_id"": 1
}

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': [[100, 79], [97, 100], [92, 24], [2, 37], [0, 0]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [125, 322], [271, 517], [329, 559], [125, 299]], 'tour_length': 344.09622016250165, 'objective': 344.09622016250165}","[0, 1, 4, 3, 2, 0]",344.09622016250165,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 1, 'x': 100, 'y': 79, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 97, 'y': 100, 'tw_start': 125, 'tw_end': 322}, {'id': 3, 'x': 92, 'y': 24, 'tw_start': 271, 'tw_end': 517}, {'id': 4, 'x': 2, 'y': 37, 'tw_start': 329, 'tw_end': 559}, {'id': 5, 'x': 0, 'y': 0, 'tw_start': 125, 'tw_end': 299}], 'depot': 1, 'objective': 344.09622016250165}","[1, 2, 5, 4, 3, 1]",32,json,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"": 5,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""coord_x"": 83,
      ""coord_y"": 100,
      ""lesson_period_start"": 0,
      ""lesson_period_end"": 918
    },
    {
      ""location_id"": ""B"",
      ""coord_x"": 0,
      ""coord_y"": 91,
      ""lesson_period_start"": 249,
      ""lesson_period_end"": 464
    },
    {
      ""location_id"": ""C"",
      ""coord_x"": 100,
      ""coord_y"": 71,
      ""lesson_period_start"": 321,
      ""lesson_period_end"": 519
    },
    {
      ""location_id"": ""D"",
      ""coord_x"": 88,
      ""coord_y"": 29,
      ""lesson_period_start"": 95,
      ""lesson_period_end"": 334
    },
    {
      ""location_id"": ""E"",
      ""coord_x"": 7,
      ""coord_y"": 0,
      ""lesson_period_start"": 74,
      ""lesson_period_end"": 322
    }
  ],
  ""workshop_id"": ""A""
}

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': [[83, 100], [0, 91], [100, 71], [88, 29], [7, 0]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [249, 464], [321, 519], [95, 334], [74, 322]], 'tour_length': 384.07541181868277, 'objective': 384.07541181868277}","[0, 3, 4, 1, 2, 0]",384.07541181868277,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 'A', 'x': 83, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 0, 'y': 91, 'tw_start': 249, 'tw_end': 464}, {'id': 'C', 'x': 100, 'y': 71, 'tw_start': 321, 'tw_end': 519}, {'id': 'D', 'x': 88, 'y': 29, 'tw_start': 95, 'tw_end': 334}, {'id': 'E', 'x': 7, 'y': 0, 'tw_start': 74, 'tw_end': 322}], 'depot': 'A', 'objective': 384.07541181868277}","['A', 'D', 'E', 'B', 'C', 'A']",33,json,names
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"": 10,
  ""nodes"": [
    {
      ""stop_id"": 0,
      ""location_x_coord"": 83,
      ""location_y_coord"": 58,
      ""earliest_allowed_arrival"": 0,
      ""latest_allowed_arrival"": 918
    },
    {
      ""stop_id"": 1,
      ""location_x_coord"": 71,
      ""location_y_coord"": 33,
      ""earliest_allowed_arrival"": 4,
      ""latest_allowed_arrival"": 252
    },
    {
      ""stop_id"": 2,
      ""location_x_coord"": 48,
      ""location_y_coord"": 100,
      ""earliest_allowed_arrival"": 14,
      ""latest_allowed_arrival"": 255
    },
    {
      ""stop_id"": 3,
      ""location_x_coord"": 28,
      ""location_y_coord"": 33,
      ""earliest_allowed_arrival"": 176,
      ""latest_allowed_arrival"": 426
    },
    {
      ""stop_id"": 4,
      ""location_x_coord"": 41,
      ""location_y_coord"": 100,
      ""earliest_allowed_arrival"": 24,
      ""latest_allowed_arrival"": 237
    },
    {
      ""stop_id"": 5,
      ""location_x_coord"": 100,
      ""location_y_coord"": 85,
      ""earliest_allowed_arrival"": 323,
      ""latest_allowed_arrival"": 534
    },
    {
      ""stop_id"": 6,
      ""location_x_coord"": 97,
      ""location_y_coord"": 50,
      ""earliest_allowed_arrival"": 210,
      ""latest_allowed_arrival"": 435
    },
    {
      ""stop_id"": 7,
      ""location_x_coord"": 63,
      ""location_y_coord"": 0,
      ""earliest_allowed_arrival"": 151,
      ""latest_allowed_arrival"": 371
    },
    {
      ""stop_id"": 8,
      ""location_x_coord"": 80,
      ""location_y_coord"": 18,
      ""earliest_allowed_arrival"": 195,
      ""latest_allowed_arrival"": 437
    },
    {
      ""stop_id"": 9,
      ""location_x_coord"": 0,
      ""location_y_coord"": 100,
      ""earliest_allowed_arrival"": 15,
      ""latest_allowed_arrival"": 205
    }
  ],
  ""service_center_id"": 0
}

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': [[83, 58], [71, 33], [48, 100], [28, 33], [41, 100], [100, 85], [97, 50], [63, 0], [80, 18], [0, 100]], 'depot': 0, 'num_nodes': 10, 'time_windows': [[0, 918], [4, 252], [14, 255], [176, 426], [24, 237], [323, 534], [210, 435], [151, 371], [195, 437], [15, 205]], 'tour_length': 380.27165386042924, 'objective': 380.27165386042924}","[0, 2, 4, 9, 3, 1, 7, 8, 6, 5, 0]",380.27165386042924,"{'problem_type': 'TSPTW', 'num_nodes': 10, 'nodes': [{'id': 0, 'x': 83, 'y': 58, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 71, 'y': 33, 'tw_start': 4, 'tw_end': 252}, {'id': 2, 'x': 48, 'y': 100, 'tw_start': 14, 'tw_end': 255}, {'id': 3, 'x': 28, 'y': 33, 'tw_start': 176, 'tw_end': 426}, {'id': 4, 'x': 41, 'y': 100, 'tw_start': 24, 'tw_end': 237}, {'id': 5, 'x': 100, 'y': 85, 'tw_start': 323, 'tw_end': 534}, {'id': 6, 'x': 97, 'y': 50, 'tw_start': 210, 'tw_end': 435}, {'id': 7, 'x': 63, 'y': 0, 'tw_start': 151, 'tw_end': 371}, {'id': 8, 'x': 80, 'y': 18, 'tw_start': 195, 'tw_end': 437}, {'id': 9, 'x': 0, 'y': 100, 'tw_start': 15, 'tw_end': 205}], 'depot': 0, 'objective': 380.27165386042924}","[0, 2, 4, 9, 3, 1, 7, 8, 6, 5, 0]",34,json,0
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 7 locations in total, with the clubhouse at A.
Stop A sits at (5, 14), opens at 0 and must be visited by 918.
Stop B sits at (0, 37), opens at 317 and must be visited by 558.
Stop C sits at (9, 45), opens at 152 and must be visited by 370.
Stop D sits at (11, 57), opens at 92 and must be visited by 275.
Stop E sits at (12, 57), opens at 154 and must be visited by 351.
Stop F sits at (41, 100), opens at 194 and must be visited by 368.
Stop G sits at (100, 0), opens at 325 and must be visited by 574.
We’ll use these entries to plan the shortest route that starts and ends at A while visiting all 7 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': [[5, 14], [0, 37], [9, 45], [11, 57], [12, 57], [41, 100], [100, 0]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [317, 558], [152, 370], [92, 275], [154, 351], [194, 368], [325, 574]], 'tour_length': 342.5581602983906, 'objective': 342.5581602983906}","[0, 2, 3, 4, 5, 6, 1, 0]",342.5581602983906,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 'A', 'x': 5, 'y': 14, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 0, 'y': 37, 'tw_start': 317, 'tw_end': 558}, {'id': 'C', 'x': 9, 'y': 45, 'tw_start': 152, 'tw_end': 370}, {'id': 'D', 'x': 11, 'y': 57, 'tw_start': 92, 'tw_end': 275}, {'id': 'E', 'x': 12, 'y': 57, 'tw_start': 154, 'tw_end': 351}, {'id': 'F', 'x': 41, 'y': 100, 'tw_start': 194, 'tw_end': 368}, {'id': 'G', 'x': 100, 'y': 0, 'tw_start': 325, 'tw_end': 574}], 'depot': 'A', 'objective': 342.5581602983906}","['A', 'C', 'D', 'E', 'F', 'G', 'B', 'A']",35,nl,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.

# total_locations_including_garage=9
# garage_node_id=1
# time windows are listed per node in the table
location_id,map_x_coordinate,map_y_coordinate,service_time_window_start,service_time_window_end
1,29,100,0,918
2,80,56,233,444
3,38,0,103,338
4,0,67,228,409
5,83,98,304,539
6,37,55,317,544
7,100,32,204,406
8,79,34,311,550
9,82,76,15,184

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': [[29, 100], [80, 56], [38, 0], [0, 67], [83, 98], [37, 55], [100, 32], [79, 34], [82, 76]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [233, 444], [103, 338], [228, 409], [304, 539], [317, 544], [204, 406], [311, 550], [15, 184]], 'tour_length': 457.3594969838473, 'objective': 457.3594969838473}","[0, 8, 2, 3, 5, 7, 6, 1, 4, 0]",457.3594969838473,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 1, 'x': 29, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 80, 'y': 56, 'tw_start': 233, 'tw_end': 444}, {'id': 3, 'x': 38, 'y': 0, 'tw_start': 103, 'tw_end': 338}, {'id': 4, 'x': 0, 'y': 67, 'tw_start': 228, 'tw_end': 409}, {'id': 5, 'x': 83, 'y': 98, 'tw_start': 304, 'tw_end': 539}, {'id': 6, 'x': 37, 'y': 55, 'tw_start': 317, 'tw_end': 544}, {'id': 7, 'x': 100, 'y': 32, 'tw_start': 204, 'tw_end': 406}, {'id': 8, 'x': 79, 'y': 34, 'tw_start': 311, 'tw_end': 550}, {'id': 9, 'x': 82, 'y': 76, 'tw_start': 15, 'tw_end': 184}], 'depot': 1, 'objective': 457.3594969838473}","[1, 9, 3, 4, 6, 8, 7, 2, 5, 1]",36,csv,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.

{
  ""total_locations_including_depot"": 7,
  ""nodes"": [
    {
      ""stop_id"": 1,
      ""x_coord"": 16,
      ""y_coord"": 14,
      ""pickup_window_start"": 0,
      ""pickup_window_end"": 918
    },
    {
      ""stop_id"": 2,
      ""x_coord"": 67,
      ""y_coord"": 14,
      ""pickup_window_start"": 125,
      ""pickup_window_end"": 360
    },
    {
      ""stop_id"": 3,
      ""x_coord"": 100,
      ""y_coord"": 41,
      ""pickup_window_start"": 329,
      ""pickup_window_end"": 509
    },
    {
      ""stop_id"": 4,
      ""x_coord"": 0,
      ""y_coord"": 32,
      ""pickup_window_start"": 198,
      ""pickup_window_end"": 397
    },
    {
      ""stop_id"": 5,
      ""x_coord"": 0,
      ""y_coord"": 100,
      ""pickup_window_start"": 323,
      ""pickup_window_end"": 561
    },
    {
      ""stop_id"": 6,
      ""x_coord"": 26,
      ""y_coord"": 0,
      ""pickup_window_start"": 280,
      ""pickup_window_end"": 486
    },
    {
      ""stop_id"": 7,
      ""x_coord"": 10,
      ""y_coord"": 0,
      ""pickup_window_start"": 138,
      ""pickup_window_end"": 328
    }
  ],
  ""depot_location_id"": 1
}

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': [[16, 14], [67, 14], [100, 41], [0, 32], [0, 100], [26, 0], [10, 0]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [125, 360], [329, 509], [198, 397], [323, 561], [280, 486], [138, 328]], 'tour_length': 363.15508717185617, 'objective': 363.15508717185617}","[0, 3, 6, 5, 1, 2, 4, 0]",363.15508717185617,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 1, 'x': 16, 'y': 14, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 67, 'y': 14, 'tw_start': 125, 'tw_end': 360}, {'id': 3, 'x': 100, 'y': 41, 'tw_start': 329, 'tw_end': 509}, {'id': 4, 'x': 0, 'y': 32, 'tw_start': 198, 'tw_end': 397}, {'id': 5, 'x': 0, 'y': 100, 'tw_start': 323, 'tw_end': 561}, {'id': 6, 'x': 26, 'y': 0, 'tw_start': 280, 'tw_end': 486}, {'id': 7, 'x': 10, 'y': 0, 'tw_start': 138, 'tw_end': 328}], 'depot': 1, 'objective': 363.15508717185617}","[1, 4, 7, 6, 2, 3, 5, 1]",37,json,1
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.

There are 7 locations in the daily run, with the shop at node 0.

| location_id | coord_x | coord_y | appointment_window_start | appointment_window_end |
|---|---|---|---|---|
| 0 | 0 | 33 | 0 | 918 |
| 1 | 20 | 0 | 18 | 258 |
| 2 | 97 | 5 | 271 | 521 |
| 3 | 28 | 100 | 332 | 546 |
| 4 | 63 | 54 | 256 | 502 |
| 5 | 72 | 69 | 283 | 471 |
| 6 | 100 | 100 | 150 | 328 |

Choose a sequence that visits every location exactly once and returns to node 0 while minimizing the total miles driven.

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': [[0, 33], [20, 0], [97, 5], [28, 100], [63, 54], [72, 69], [100, 100]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [18, 258], [271, 521], [332, 546], [256, 502], [283, 471], [150, 328]], 'tour_length': 451.86574764036317, 'objective': 451.86574764036317}","[0, 1, 5, 6, 2, 4, 3, 0]",451.86574764036317,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 0, 'x': 0, 'y': 33, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 20, 'y': 0, 'tw_start': 18, 'tw_end': 258}, {'id': 2, 'x': 97, 'y': 5, 'tw_start': 271, 'tw_end': 521}, {'id': 3, 'x': 28, 'y': 100, 'tw_start': 332, 'tw_end': 546}, {'id': 4, 'x': 63, 'y': 54, 'tw_start': 256, 'tw_end': 502}, {'id': 5, 'x': 72, 'y': 69, 'tw_start': 283, 'tw_end': 471}, {'id': 6, 'x': 100, 'y': 100, 'tw_start': 150, 'tw_end': 328}], 'depot': 0, 'objective': 451.86574764036317}","[0, 1, 5, 6, 2, 4, 3, 0]",38,markdown_table,0
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.

{
  ""total_locations_including_lab"": 10,
  ""nodes"": [
    {
      ""stop_id"": 1,
      ""coord_x"": 0,
      ""coord_y"": 11,
      ""earliest_arrival_time"": 0,
      ""latest_arrival_time"": 918
    },
    {
      ""stop_id"": 2,
      ""coord_x"": 4,
      ""coord_y"": 20,
      ""earliest_arrival_time"": 318,
      ""latest_arrival_time"": 536
    },
    {
      ""stop_id"": 3,
      ""coord_x"": 23,
      ""coord_y"": 96,
      ""earliest_arrival_time"": 76,
      ""latest_arrival_time"": 299
    },
    {
      ""stop_id"": 4,
      ""coord_x"": 25,
      ""coord_y"": 31,
      ""earliest_arrival_time"": 206,
      ""latest_arrival_time"": 403
    },
    {
      ""stop_id"": 5,
      ""coord_x"": 40,
      ""coord_y"": 33,
      ""earliest_arrival_time"": 37,
      ""latest_arrival_time"": 261
    },
    {
      ""stop_id"": 6,
      ""coord_x"": 59,
      ""coord_y"": 58,
      ""earliest_arrival_time"": 173,
      ""latest_arrival_time"": 405
    },
    {
      ""stop_id"": 7,
      ""coord_x"": 60,
      ""coord_y"": 8,
      ""earliest_arrival_time"": 173,
      ""latest_arrival_time"": 411
    },
    {
      ""stop_id"": 8,
      ""coord_x"": 75,
      ""coord_y"": 100,
      ""earliest_arrival_time"": 184,
      ""latest_arrival_time"": 398
    },
    {
      ""stop_id"": 9,
      ""coord_x"": 78,
      ""coord_y"": 0,
      ""earliest_arrival_time"": 292,
      ""latest_arrival_time"": 493
    },
    {
      ""stop_id"": 10,
      ""coord_x"": 100,
      ""coord_y"": 1,
      ""earliest_arrival_time"": 44,
      ""latest_arrival_time"": 214
    }
  ],
  ""lab_node_id"": 1
}

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, 11], [4, 20], [23, 96], [25, 31], [40, 33], [59, 58], [60, 8], [75, 100], [78, 0], [100, 1]], 'depot': 0, 'num_nodes': 10, 'time_windows': [[0, 918], [318, 536], [76, 299], [206, 403], [37, 261], [173, 405], [173, 411], [184, 398], [292, 493], [44, 214]], 'tour_length': 494.07602704496657, 'objective': 494.07602704496657}","[0, 4, 9, 5, 7, 2, 3, 6, 8, 1, 0]",494.07602704496657,"{'problem_type': 'TSPTW', 'num_nodes': 10, 'nodes': [{'id': 1, 'x': 0, 'y': 11, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 4, 'y': 20, 'tw_start': 318, 'tw_end': 536}, {'id': 3, 'x': 23, 'y': 96, 'tw_start': 76, 'tw_end': 299}, {'id': 4, 'x': 25, 'y': 31, 'tw_start': 206, 'tw_end': 403}, {'id': 5, 'x': 40, 'y': 33, 'tw_start': 37, 'tw_end': 261}, {'id': 6, 'x': 59, 'y': 58, 'tw_start': 173, 'tw_end': 405}, {'id': 7, 'x': 60, 'y': 8, 'tw_start': 173, 'tw_end': 411}, {'id': 8, 'x': 75, 'y': 100, 'tw_start': 184, 'tw_end': 398}, {'id': 9, 'x': 78, 'y': 0, 'tw_start': 292, 'tw_end': 493}, {'id': 10, 'x': 100, 'y': 1, 'tw_start': 44, 'tw_end': 214}], 'depot': 1, 'objective': 494.07602704496657}","[1, 5, 10, 6, 8, 3, 4, 7, 9, 2, 1]",39,json,1
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"": 10,
  ""nodes"": [
    {
      ""location_id"": 0,
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 35,
      ""restock_window_start"": 0,
      ""restock_window_end"": 918
    },
    {
      ""location_id"": 1,
      ""map_x_coordinate"": 25,
      ""map_y_coordinate"": 0,
      ""restock_window_start"": 252,
      ""restock_window_end"": 471
    },
    {
      ""location_id"": 2,
      ""map_x_coordinate"": 25,
      ""map_y_coordinate"": 95,
      ""restock_window_start"": 235,
      ""restock_window_end"": 419
    },
    {
      ""location_id"": 3,
      ""map_x_coordinate"": 50,
      ""map_y_coordinate"": 55,
      ""restock_window_start"": 45,
      ""restock_window_end"": 213
    },
    {
      ""location_id"": 4,
      ""map_x_coordinate"": 75,
      ""map_y_coordinate"": 95,
      ""restock_window_start"": 117,
      ""restock_window_end"": 333
    },
    {
      ""location_id"": 5,
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 35,
      ""restock_window_start"": 131,
      ""restock_window_end"": 334
    },
    {
      ""location_id"": 6,
      ""map_x_coordinate"": 4,
      ""map_y_coordinate"": 10,
      ""restock_window_start"": 301,
      ""restock_window_end"": 498
    },
    {
      ""location_id"": 7,
      ""map_x_coordinate"": 12,
      ""map_y_coordinate"": 100,
      ""restock_window_start"": 171,
      ""restock_window_end"": 404
    },
    {
      ""location_id"": 8,
      ""map_x_coordinate"": 29,
      ""map_y_coordinate"": 10,
      ""restock_window_start"": 132,
      ""restock_window_end"": 351
    },
    {
      ""location_id"": 9,
      ""map_x_coordinate"": 58,
      ""map_y_coordinate"": 10,
      ""restock_window_start"": 288,
      ""restock_window_end"": 534
    }
  ],
  ""warehouse_id"": 0
}

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': [[0, 35], [25, 0], [25, 95], [50, 55], [75, 95], [100, 35], [4, 10], [12, 100], [29, 10], [58, 10]], 'depot': 0, 'num_nodes': 10, 'time_windows': [[0, 918], [252, 471], [235, 419], [45, 213], [117, 333], [131, 334], [301, 498], [171, 404], [132, 351], [288, 534]], 'tour_length': 518.966382168029, 'objective': 518.966382168029}","[0, 3, 8, 5, 4, 2, 7, 6, 1, 9, 0]",518.966382168029,"{'problem_type': 'TSPTW', 'num_nodes': 10, 'nodes': [{'id': 0, 'x': 0, 'y': 35, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 25, 'y': 0, 'tw_start': 252, 'tw_end': 471}, {'id': 2, 'x': 25, 'y': 95, 'tw_start': 235, 'tw_end': 419}, {'id': 3, 'x': 50, 'y': 55, 'tw_start': 45, 'tw_end': 213}, {'id': 4, 'x': 75, 'y': 95, 'tw_start': 117, 'tw_end': 333}, {'id': 5, 'x': 100, 'y': 35, 'tw_start': 131, 'tw_end': 334}, {'id': 6, 'x': 4, 'y': 10, 'tw_start': 301, 'tw_end': 498}, {'id': 7, 'x': 12, 'y': 100, 'tw_start': 171, 'tw_end': 404}, {'id': 8, 'x': 29, 'y': 10, 'tw_start': 132, 'tw_end': 351}, {'id': 9, 'x': 58, 'y': 10, 'tw_start': 288, 'tw_end': 534}], 'depot': 0, 'objective': 518.966382168029}","[0, 3, 8, 5, 4, 2, 7, 6, 1, 9, 0]",40,json,0
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.

{
  ""total_locations_including_facility"": 5,
  ""nodes"": [
    {
      ""location_node_id"": ""A"",
      ""map_x_coordinate"": 54,
      ""map_y_coordinate"": 0,
      ""pickup_window_start"": 0,
      ""pickup_window_end"": 918
    },
    {
      ""location_node_id"": ""B"",
      ""map_x_coordinate"": 98,
      ""map_y_coordinate"": 38,
      ""pickup_window_start"": 49,
      ""pickup_window_end"": 293
    },
    {
      ""location_node_id"": ""C"",
      ""map_x_coordinate"": 100,
      ""map_y_coordinate"": 56,
      ""pickup_window_start"": 164,
      ""pickup_window_end"": 352
    },
    {
      ""location_node_id"": ""D"",
      ""map_x_coordinate"": 35,
      ""map_y_coordinate"": 88,
      ""pickup_window_start"": 153,
      ""pickup_window_end"": 402
    },
    {
      ""location_node_id"": ""E"",
      ""map_x_coordinate"": 0,
      ""map_y_coordinate"": 100,
      ""pickup_window_start"": 164,
      ""pickup_window_end"": 358
    }
  ],
  ""facility_node_id"": ""A""
}

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': [[54, 0], [98, 38], [100, 56], [35, 88], [0, 100]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [49, 293], [164, 352], [153, 402], [164, 358]], 'tour_length': 299.3471015993922, 'objective': 299.3471015993922}","[0, 1, 2, 3, 4, 0]",299.3471015993922,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 'A', 'x': 54, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 98, 'y': 38, 'tw_start': 49, 'tw_end': 293}, {'id': 'C', 'x': 100, 'y': 56, 'tw_start': 164, 'tw_end': 352}, {'id': 'D', 'x': 35, 'y': 88, 'tw_start': 153, 'tw_end': 402}, {'id': 'E', 'x': 0, 'y': 100, 'tw_start': 164, 'tw_end': 358}], 'depot': 'A', 'objective': 299.3471015993922}","['A', 'B', 'C', 'D', 'E', 'A']",41,json,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.

Route data for the 7 locations (garage = node A).
Location A: at (0, 0); service between 0 and 918.
Location B: at (8, 42); service between 211 and 398.
Location C: at (8, 100); service between 25 and 203.
Location D: at (15, 77); service between 42 and 222.
Location E: at (16, 90); service between 46 and 266.
Location F: at (99, 29); service between 60 and 256.
Location G: at (100, 87); service between 299 and 506.
Start and finish at the garage and choose the route with the smallest total driving distance while respecting every service window.

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': [[0, 0], [8, 42], [8, 100], [15, 77], [16, 90], [99, 29], [100, 87]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [211, 398], [25, 203], [42, 222], [46, 266], [60, 256], [299, 506]], 'tour_length': 545.1879730397509, 'objective': 545.1879730397509}","[0, 3, 2, 4, 5, 1, 6, 0]",545.1879730397509,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 8, 'y': 42, 'tw_start': 211, 'tw_end': 398}, {'id': 'C', 'x': 8, 'y': 100, 'tw_start': 25, 'tw_end': 203}, {'id': 'D', 'x': 15, 'y': 77, 'tw_start': 42, 'tw_end': 222}, {'id': 'E', 'x': 16, 'y': 90, 'tw_start': 46, 'tw_end': 266}, {'id': 'F', 'x': 99, 'y': 29, 'tw_start': 60, 'tw_end': 256}, {'id': 'G', 'x': 100, 'y': 87, 'tw_start': 299, 'tw_end': 506}], 'depot': 'A', 'objective': 545.1879730397509}","['A', 'D', 'C', 'E', 'F', 'B', 'G', 'A']",42,nl,names
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.

# total_locations_including_store=6
# store_node_id=0
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,earliest_delivery_time,latest_delivery_time
0,0,43,0,918
1,91,55,222,404
2,38,3,64,234
3,87,100,56,246
4,100,0,59,233
5,86,72,40,245

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': [[0, 43], [91, 55], [38, 3], [87, 100], [100, 0], [86, 72]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [222, 404], [64, 234], [56, 246], [59, 233], [40, 245]], 'tour_length': 355.57655658943685, 'objective': 355.57655658943685}","[0, 2, 4, 5, 3, 1, 0]",355.57655658943685,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 0, 'x': 0, 'y': 43, 'tw_start': 0, 'tw_end': 918}, {'id': 1, 'x': 91, 'y': 55, 'tw_start': 222, 'tw_end': 404}, {'id': 2, 'x': 38, 'y': 3, 'tw_start': 64, 'tw_end': 234}, {'id': 3, 'x': 87, 'y': 100, 'tw_start': 56, 'tw_end': 246}, {'id': 4, 'x': 100, 'y': 0, 'tw_start': 59, 'tw_end': 233}, {'id': 5, 'x': 86, 'y': 72, 'tw_start': 40, 'tw_end': 245}], 'depot': 0, 'objective': 355.57655658943685}","[0, 2, 4, 5, 3, 1, 0]",43,csv,0
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.

There are 8 locations in this run, with the office at node A.
The scheduler notes meter site A at (0, 16) with access window 0 to 918.
The scheduler notes meter site B at (29, 29) with access window 123 to 331.
The scheduler notes meter site C at (82, 16) with access window 206 to 404.
The scheduler notes meter site D at (72, 100) with access window 154 to 383.
The scheduler notes meter site E at (92, 36) with access window 12 to 200.
The scheduler notes meter site F at (100, 7) with access window 238 to 480.
The scheduler notes meter site G at (35, 0) with access window 170 to 382.
The scheduler notes meter site H at (13, 100) with access window 35 to 240.
The scheduler will use these locations and windows to construct the shortest feasible loop.

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': [[0, 16], [29, 29], [82, 16], [72, 100], [92, 36], [100, 7], [35, 0], [13, 100]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [123, 331], [206, 404], [154, 383], [12, 200], [238, 480], [170, 382], [35, 240]], 'tour_length': 492.77327583262576, 'objective': 492.77327583262576}","[0, 4, 3, 7, 1, 6, 2, 5, 0]",492.77327583262576,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 'A', 'x': 0, 'y': 16, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 29, 'y': 29, 'tw_start': 123, 'tw_end': 331}, {'id': 'C', 'x': 82, 'y': 16, 'tw_start': 206, 'tw_end': 404}, {'id': 'D', 'x': 72, 'y': 100, 'tw_start': 154, 'tw_end': 383}, {'id': 'E', 'x': 92, 'y': 36, 'tw_start': 12, 'tw_end': 200}, {'id': 'F', 'x': 100, 'y': 7, 'tw_start': 238, 'tw_end': 480}, {'id': 'G', 'x': 35, 'y': 0, 'tw_start': 170, 'tw_end': 382}, {'id': 'H', 'x': 13, 'y': 100, 'tw_start': 35, 'tw_end': 240}], 'depot': 'A', 'objective': 492.77327583262576}","['A', 'E', 'D', 'H', 'B', 'G', 'C', 'F', 'A']",44,nl,names
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.

{
  ""total_locations_including_office"": 5,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""location_x_coordinate"": 19,
      ""location_y_coordinate"": 100,
      ""earliest_allowed_arrival"": 0,
      ""latest_allowed_arrival"": 918
    },
    {
      ""location_id"": ""B"",
      ""location_x_coordinate"": 20,
      ""location_y_coordinate"": 95,
      ""earliest_allowed_arrival"": 177,
      ""latest_allowed_arrival"": 365
    },
    {
      ""location_id"": ""C"",
      ""location_x_coordinate"": 41,
      ""location_y_coordinate"": 10,
      ""earliest_allowed_arrival"": 89,
      ""latest_allowed_arrival"": 288
    },
    {
      ""location_id"": ""D"",
      ""location_x_coordinate"": 0,
      ""location_y_coordinate"": 0,
      ""earliest_allowed_arrival"": 6,
      ""latest_allowed_arrival"": 200
    },
    {
      ""location_id"": ""E"",
      ""location_x_coordinate"": 100,
      ""location_y_coordinate"": 2,
      ""earliest_allowed_arrival"": 70,
      ""latest_allowed_arrival"": 264
    }
  ],
  ""office_node_id"": ""A""
}

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': [[19, 100], [20, 95], [41, 10], [0, 0], [100, 2]], 'depot': 0, 'num_nodes': 5, 'time_windows': [[0, 918], [177, 365], [89, 288], [6, 200], [70, 264]], 'tour_length': 331.3041809332308, 'objective': 331.3041809332308}","[0, 3, 2, 4, 1, 0]",331.3041809332308,"{'problem_type': 'TSPTW', 'num_nodes': 5, 'nodes': [{'id': 'A', 'x': 19, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 20, 'y': 95, 'tw_start': 177, 'tw_end': 365}, {'id': 'C', 'x': 41, 'y': 10, 'tw_start': 89, 'tw_end': 288}, {'id': 'D', 'x': 0, 'y': 0, 'tw_start': 6, 'tw_end': 200}, {'id': 'E', 'x': 100, 'y': 2, 'tw_start': 70, 'tw_end': 264}], 'depot': 'A', 'objective': 331.3041809332308}","['A', 'D', 'C', 'E', 'B', 'A']",45,json,names
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"": 6,
  ""nodes"": [
    {
      ""location_id"": ""A"",
      ""location_x"": 31,
      ""location_y"": 100,
      ""earliest_meeting_time"": 0,
      ""latest_meeting_time"": 918
    },
    {
      ""location_id"": ""B"",
      ""location_x"": 26,
      ""location_y"": 57,
      ""earliest_meeting_time"": 40,
      ""latest_meeting_time"": 281
    },
    {
      ""location_id"": ""C"",
      ""location_x"": 0,
      ""location_y"": 37,
      ""earliest_meeting_time"": 198,
      ""latest_meeting_time"": 421
    },
    {
      ""location_id"": ""D"",
      ""location_x"": 15,
      ""location_y"": 29,
      ""earliest_meeting_time"": 263,
      ""latest_meeting_time"": 472
    },
    {
      ""location_id"": ""E"",
      ""location_x"": 69,
      ""location_y"": 0,
      ""earliest_meeting_time"": 29,
      ""latest_meeting_time"": 240
    },
    {
      ""location_id"": ""F"",
      ""location_x"": 100,
      ""location_y"": 71,
      ""earliest_meeting_time"": 196,
      ""latest_meeting_time"": 425
    }
  ],
  ""branch_office_node_id"": ""A""
}

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': [[31, 100], [26, 57], [0, 37], [15, 29], [69, 0], [100, 71]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [40, 281], [198, 421], [263, 472], [29, 240], [196, 425]], 'tour_length': 373.45285045495393, 'objective': 373.45285045495393}","[0, 1, 4, 3, 2, 5, 0]",373.45285045495393,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 'A', 'x': 31, 'y': 100, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 26, 'y': 57, 'tw_start': 40, 'tw_end': 281}, {'id': 'C', 'x': 0, 'y': 37, 'tw_start': 198, 'tw_end': 421}, {'id': 'D', 'x': 15, 'y': 29, 'tw_start': 263, 'tw_end': 472}, {'id': 'E', 'x': 69, 'y': 0, 'tw_start': 29, 'tw_end': 240}, {'id': 'F', 'x': 100, 'y': 71, 'tw_start': 196, 'tw_end': 425}], 'depot': 'A', 'objective': 373.45285045495393}","['A', 'B', 'E', 'D', 'C', 'F', 'A']",46,json,names
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.

There are 8 locations in total, with basecamp A as the required start and end point.
Site A at (91, 52) has a sampling window from 0 to 918 (arrival earlier allowed).
Site B at (85, 10) has a sampling window from 26 to 237 (arrival earlier allowed).
Site C at (92, 70) has a sampling window from 137 to 386 (arrival earlier allowed).
Site D at (100, 82) has a sampling window from 37 to 237 (arrival earlier allowed).
Site E at (50, 96) has a sampling window from 323 to 563 (arrival earlier allowed).
Site F at (0, 100) has a sampling window from 272 to 461 (arrival earlier allowed).
Site G at (61, 0) has a sampling window from 57 to 279 (arrival earlier allowed).
Site H at (34, 28) has a sampling window from 310 to 523 (arrival earlier allowed).
The researcher must visit every site exactly once and return to basecamp A; minimize the sum of all leg distances.

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': [[91, 52], [85, 10], [92, 70], [100, 82], [50, 96], [0, 100], [61, 0], [34, 28]], 'depot': 0, 'num_nodes': 8, 'time_windows': [[0, 918], [26, 237], [137, 386], [37, 237], [323, 563], [272, 461], [57, 279], [310, 523]], 'tour_length': 360.81852777005184, 'objective': 360.81852777005184}","[0, 2, 3, 1, 6, 7, 5, 4, 0]",360.81852777005184,"{'problem_type': 'TSPTW', 'num_nodes': 8, 'nodes': [{'id': 'A', 'x': 91, 'y': 52, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 85, 'y': 10, 'tw_start': 26, 'tw_end': 237}, {'id': 'C', 'x': 92, 'y': 70, 'tw_start': 137, 'tw_end': 386}, {'id': 'D', 'x': 100, 'y': 82, 'tw_start': 37, 'tw_end': 237}, {'id': 'E', 'x': 50, 'y': 96, 'tw_start': 323, 'tw_end': 563}, {'id': 'F', 'x': 0, 'y': 100, 'tw_start': 272, 'tw_end': 461}, {'id': 'G', 'x': 61, 'y': 0, 'tw_start': 57, 'tw_end': 279}, {'id': 'H', 'x': 34, 'y': 28, 'tw_start': 310, 'tw_end': 523}], 'depot': 'A', 'objective': 360.81852777005184}","['A', 'C', 'D', 'B', 'G', 'H', 'F', 'E', 'A']",47,nl,names
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.

There are 6 locations in total and the shop is node 1.
Stop 1 — at (59, 95); deliver between 0 and 918.
Stop 2 — at (69, 60); deliver between 190 and 381.
Stop 3 — at (39, 33); deliver between 257 and 439.
Stop 4 — at (79, 24); deliver between 108 and 310.
Stop 5 — at (0, 0); deliver between 169 and 356.
Stop 6 — at (100, 100); deliver between 38 and 256.
Plan a route that visits all 6 locations and returns to 1, meeting each delivery window while keeping total driving distance as low as possible.

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': [[59, 95], [69, 60], [39, 33], [79, 24], [0, 0], [100, 100]], 'depot': 0, 'num_nodes': 6, 'time_windows': [[0, 918], [190, 381], [257, 439], [108, 310], [169, 356], [38, 256]], 'tour_length': 328.07243476344615, 'objective': 328.07243476344615}","[0, 5, 1, 3, 4, 2, 0]",328.07243476344615,"{'problem_type': 'TSPTW', 'num_nodes': 6, 'nodes': [{'id': 1, 'x': 59, 'y': 95, 'tw_start': 0, 'tw_end': 918}, {'id': 2, 'x': 69, 'y': 60, 'tw_start': 190, 'tw_end': 381}, {'id': 3, 'x': 39, 'y': 33, 'tw_start': 257, 'tw_end': 439}, {'id': 4, 'x': 79, 'y': 24, 'tw_start': 108, 'tw_end': 310}, {'id': 5, 'x': 0, 'y': 0, 'tw_start': 169, 'tw_end': 356}, {'id': 6, 'x': 100, 'y': 100, 'tw_start': 38, 'tw_end': 256}], 'depot': 1, 'objective': 328.07243476344615}","[1, 6, 2, 4, 5, 3, 1]",48,nl,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 9 locations in total, including the service center A.

| location_id | x_coordinate | y_coordinate | earliest_meeting_time | latest_meeting_time |
|---|---|---|---|---|
| A | 21 | 56 | 0 | 918 |
| B | 100 | 100 | 96 | 311 |
| C | 100 | 89 | 51 | 258 |
| D | 100 | 81 | 177 | 349 |
| E | 100 | 69 | 112 | 290 |
| F | 42 | 22 | 21 | 270 |
| G | 37 | 39 | 107 | 342 |
| H | 0 | 0 | 85 | 308 |
| I | 11 | 50 | 253 | 470 |

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': [[21, 56], [100, 100], [100, 89], [100, 81], [100, 69], [42, 22], [37, 39], [0, 0], [11, 50]], 'depot': 0, 'num_nodes': 9, 'time_windows': [[0, 918], [96, 311], [51, 258], [177, 349], [112, 290], [21, 270], [107, 342], [85, 308], [253, 470]], 'tour_length': 339.46457293550174, 'objective': 339.46457293550174}","[0, 7, 5, 6, 4, 3, 2, 1, 8, 0]",339.46457293550174,"{'problem_type': 'TSPTW', 'num_nodes': 9, 'nodes': [{'id': 'A', 'x': 21, 'y': 56, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 100, 'y': 100, 'tw_start': 96, 'tw_end': 311}, {'id': 'C', 'x': 100, 'y': 89, 'tw_start': 51, 'tw_end': 258}, {'id': 'D', 'x': 100, 'y': 81, 'tw_start': 177, 'tw_end': 349}, {'id': 'E', 'x': 100, 'y': 69, 'tw_start': 112, 'tw_end': 290}, {'id': 'F', 'x': 42, 'y': 22, 'tw_start': 21, 'tw_end': 270}, {'id': 'G', 'x': 37, 'y': 39, 'tw_start': 107, 'tw_end': 342}, {'id': 'H', 'x': 0, 'y': 0, 'tw_start': 85, 'tw_end': 308}, {'id': 'I', 'x': 11, 'y': 50, 'tw_start': 253, 'tw_end': 470}], 'depot': 'A', 'objective': 339.46457293550174}","['A', 'H', 'F', 'G', 'E', 'D', 'C', 'B', 'I', '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=7
# 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,40,0,918
B,29,25,157,358
C,3,21,116,361
D,29,7,277,525
E,7,0,41,269
F,100,100,313,495
G,65,0,22,251

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, 40], [29, 25], [3, 21], [29, 7], [7, 0], [100, 100], [65, 0]], 'depot': 0, 'num_nodes': 7, 'time_windows': [[0, 918], [157, 358], [116, 361], [277, 525], [41, 269], [313, 495], [22, 251]], 'tour_length': 373.1825502891054, 'objective': 373.1825502891054}","[0, 2, 4, 6, 3, 1, 5, 0]",373.1825502891054,"{'problem_type': 'TSPTW', 'num_nodes': 7, 'nodes': [{'id': 'A', 'x': 0, 'y': 40, 'tw_start': 0, 'tw_end': 918}, {'id': 'B', 'x': 29, 'y': 25, 'tw_start': 157, 'tw_end': 358}, {'id': 'C', 'x': 3, 'y': 21, 'tw_start': 116, 'tw_end': 361}, {'id': 'D', 'x': 29, 'y': 7, 'tw_start': 277, 'tw_end': 525}, {'id': 'E', 'x': 7, 'y': 0, 'tw_start': 41, 'tw_end': 269}, {'id': 'F', 'x': 100, 'y': 100, 'tw_start': 313, 'tw_end': 495}, {'id': 'G', 'x': 65, 'y': 0, 'tw_start': 22, 'tw_end': 251}], 'depot': 'A', 'objective': 373.1825502891054}","['A', 'C', 'E', 'G', 'D', 'B', 'F', 'A']",50,csv,names