STP/STP_S_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
STP,STP,"Someone on the infrastructure team laid out a list of potential cable runs and their prices; the decision to make is which runs to actually install so every listed community center is tied into the same network. What makes one decision better than another is simple: the plan that costs less in total (just add up the prices of the selected runs) is preferred. It’s okay to use intermediate junctions as connectors, but every marked center has to be part of the network and segments aren’t to be duplicated. The specific map and costs are provided below.

The map shows 15 locations, 16 candidate cable runs, and the community centers to connect are 14 15.
Candidate run between 1 and 8 with installation cost 101.0.
Candidate run between 1 and 4 with installation cost 224640.0.
Candidate run between 1 and 10 with installation cost 1382.0.
Candidate run between 2 and 14 with installation cost 741.0.
Candidate run between 2 and 13 with installation cost 839.0.
Candidate run between 2 and 4 with installation cost 223769.0.
Candidate run between 3 and 13 with installation cost 2012.0.
Candidate run between 7 and 8 with installation cost 1732.0.
Candidate run between 8 and 14 with installation cost 846.0.
Candidate run between 9 and 10 with installation cost 988.0.
Candidate run between 9 and 11 with installation cost 107.0.
Candidate run between 9 and 15 with installation cost 1802.0.
Candidate run between 10 and 15 with installation cost 1095.0.
Candidate run between 6 and 14 with installation cost 1496.0.
Candidate run between 5 and 15 with installation cost 3211.0.
Candidate run between 12 and 13 with installation cost 1356.0.
Choose segments that connect all 14 15 at the lowest total cost.

Also, when you send back the chosen set of cable runs, please put them in this simple JSON shape so it's easy to check automatically:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as just a list of segments to install — each inner pair [X, Y] means ""connect node X to node Y"". This is only a sketch of the shape I need, not the actual plan.

Please use the exact identifiers from the instance input — do not rename or invent labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 16, 'edges': [{'u': 1, 'v': 8, 'w': 101.0}, {'u': 1, 'v': 4, 'w': 224640.0}, {'u': 1, 'v': 10, 'w': 1382.0}, {'u': 2, 'v': 14, 'w': 741.0}, {'u': 2, 'v': 13, 'w': 839.0}, {'u': 2, 'v': 4, 'w': 223769.0}, {'u': 3, 'v': 13, 'w': 2012.0}, {'u': 7, 'v': 8, 'w': 1732.0}, {'u': 8, 'v': 14, 'w': 846.0}, {'u': 9, 'v': 10, 'w': 988.0}, {'u': 9, 'v': 11, 'w': 107.0}, {'u': 9, 'v': 15, 'w': 1802.0}, {'u': 10, 'v': 15, 'w': 1095.0}, {'u': 6, 'v': 14, 'w': 1496.0}, {'u': 5, 'v': 15, 'w': 3211.0}, {'u': 12, 'v': 13, 'w': 1356.0}], 'terminals': [14, 15], 'source_file': 'I062.stp', 'density': 0.1523809523809524, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0000.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0000.png'}","[[1, 8], [1, 10], [8, 14], [10, 15]]",3424.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 16, 'edges': [{'u': 1, 'v': 8, 'w': 101.0}, {'u': 1, 'v': 4, 'w': 224640.0}, {'u': 1, 'v': 10, 'w': 1382.0}, {'u': 2, 'v': 14, 'w': 741.0}, {'u': 2, 'v': 13, 'w': 839.0}, {'u': 2, 'v': 4, 'w': 223769.0}, {'u': 3, 'v': 13, 'w': 2012.0}, {'u': 7, 'v': 8, 'w': 1732.0}, {'u': 8, 'v': 14, 'w': 846.0}, {'u': 9, 'v': 10, 'w': 988.0}, {'u': 9, 'v': 11, 'w': 107.0}, {'u': 9, 'v': 15, 'w': 1802.0}, {'u': 10, 'v': 15, 'w': 1095.0}, {'u': 6, 'v': 14, 'w': 1496.0}, {'u': 5, 'v': 15, 'w': 3211.0}, {'u': 12, 'v': 13, 'w': 1356.0}], 'density': 0.1523809523809524, 'source_file': 'I062.stp', 'terminals': [14, 15]}","[[1, 8], [1, 10], [8, 14], [10, 15]]",1,markdown_table,1
STP,STP,"We’ve got a small courtyard with marked seating spots and a network of existing stepping stones. The decision is which of the possible paths between those stones to actually lay down so that all the flagged seats are connected by the finished network, using other stones as stepping points if needed. One plan beats another if the total amount of path laid (calculated by adding up the lengths of every chosen link) is smaller, and every flagged seat ends up included once in the connected layout without repeating the same segment. The concrete layout and distances follow below.

There are 10 existing stepping stones, 11 candidate paths, and the flagged seating stones are 5 6 8.
Between stone 8 and stone 4 we could lay a path of length 242860.0.
Between stone 8 and stone 1 we could lay a path of length 241748.0.
Between stone 1 and stone 2 we could lay a path of length 1442.0.
Between stone 1 and stone 3 we could lay a path of length 737.0.
Between stone 2 and stone 9 we could lay a path of length 775.0.
Between stone 3 and stone 7 we could lay a path of length 539.0.
Between stone 3 and stone 9 we could lay a path of length 1461.0.
Between stone 4 and stone 5 we could lay a path of length 644.0.
Between stone 4 and stone 6 we could lay a path of length 1275.0.
Between stone 6 and stone 10 we could lay a path of length 1196.0.
Between stone 7 and stone 10 we could lay a path of length 918.0.
Below we list each candidate path so we can choose the shortest set that connects all 5 6 8.

Just drop your chosen links into this little JSON form so I know which stone-to-stone segments you're proposing:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as the list of path segments to lay down. Each inner pair like [u1, v1] is one connection between two stones (use the exact labels from the courtyard map). This block is just a sketch of the shape I expect, not the actual answer.

Please make sure to use the exact identifiers from the instance input — 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”. ""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 8, 'v': 4, 'w': 242860.0}, {'u': 8, 'v': 1, 'w': 241748.0}, {'u': 1, 'v': 2, 'w': 1442.0}, {'u': 1, 'v': 3, 'w': 737.0}, {'u': 2, 'v': 9, 'w': 775.0}, {'u': 3, 'v': 7, 'w': 539.0}, {'u': 3, 'v': 9, 'w': 1461.0}, {'u': 4, 'v': 5, 'w': 644.0}, {'u': 4, 'v': 6, 'w': 1275.0}, {'u': 6, 'v': 10, 'w': 1196.0}, {'u': 7, 'v': 10, 'w': 918.0}], 'terminals': [5, 6, 8], 'source_file': 'I044.stp', 'density': 0.24444444444444444, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0001.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0001.png'}","[[4, 8], [4, 5], [4, 6]]",244779.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 8, 'v': 4, 'w': 242860.0}, {'u': 8, 'v': 1, 'w': 241748.0}, {'u': 1, 'v': 2, 'w': 1442.0}, {'u': 1, 'v': 3, 'w': 737.0}, {'u': 2, 'v': 9, 'w': 775.0}, {'u': 3, 'v': 7, 'w': 539.0}, {'u': 3, 'v': 9, 'w': 1461.0}, {'u': 4, 'v': 5, 'w': 644.0}, {'u': 4, 'v': 6, 'w': 1275.0}, {'u': 6, 'v': 10, 'w': 1196.0}, {'u': 7, 'v': 10, 'w': 918.0}], 'density': 0.24444444444444444, 'source_file': 'I044.stp', 'terminals': [5, 6, 8]}","[[4, 8], [4, 5], [4, 6]]",2,nl,1
STP,STP,"We have a map of poles and possible spans between them, and a few fixed distribution boxes that all need to be connected into a single overhead line. The decision is which spans to actually string from the list of feasible options, using intermediate poles where it’s handy to hop between runs. The winning plan is the one with the smallest total cable length — total length equals the sum of every chosen span — and every box must be included in the connected chain with no repeats. The specific instance details follow below.

There are 11 nodes, 11 feasible spans, and the required distribution boxes are 2 4 5 9.
Candidate span connecting node 6 and node 2, length 1742.0.
Candidate span connecting node 6 and node 11, length 9125.0.
Candidate span connecting node 4 and node 7, length 6382.0.
Candidate span connecting node 4 and node 2, length 4162.0.
Candidate span connecting node 7 and node 3, length 3939.0.
Candidate span connecting node 7 and node 8, length 8736.0.
Candidate span connecting node 9 and node 1, length 2404.0.
Candidate span connecting node 2 and node 1, length 126.0.
Candidate span connecting node 5 and node 8, length 6057.0.
Candidate span connecting node 3 and node 10, length 1127.0.
Candidate span connecting node 10 and node 11, length 1648.0.
We must select a subset of these spans so the 2 4 5 9 form a single continuous overhead line with minimal total cable length.

You can just give the chosen spans in this simple JSON shape — a list of edge pairs inside the ""solution"" array.

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This is just a sketch of the shape I want: each inner pair is a span (an edge) between two poles/points you picked. Fill that array with the actual pairs from the instance when you submit the final plan.

Please use the exact identifiers that appear in the instance input — no renaming and no new labels. 
For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 11, 'edges': [{'u': 6, 'v': 2, 'w': 1742.0}, {'u': 6, 'v': 11, 'w': 9125.0}, {'u': 4, 'v': 7, 'w': 6382.0}, {'u': 4, 'v': 2, 'w': 4162.0}, {'u': 7, 'v': 3, 'w': 3939.0}, {'u': 7, 'v': 8, 'w': 8736.0}, {'u': 9, 'v': 1, 'w': 2404.0}, {'u': 2, 'v': 1, 'w': 126.0}, {'u': 5, 'v': 8, 'w': 6057.0}, {'u': 3, 'v': 10, 'w': 1127.0}, {'u': 10, 'v': 11, 'w': 1648.0}], 'terminals': [2, 4, 5, 9], 'source_file': 'I025.stp', 'density': 0.2, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0002.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0002.png'}","[[4, 7], [2, 4], [7, 8], [1, 9], [1, 2], [5, 8]]",27867.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 11, 'edges': [{'u': 6, 'v': 2, 'w': 1742.0}, {'u': 6, 'v': 11, 'w': 9125.0}, {'u': 4, 'v': 7, 'w': 6382.0}, {'u': 4, 'v': 2, 'w': 4162.0}, {'u': 7, 'v': 3, 'w': 3939.0}, {'u': 7, 'v': 8, 'w': 8736.0}, {'u': 9, 'v': 1, 'w': 2404.0}, {'u': 2, 'v': 1, 'w': 126.0}, {'u': 5, 'v': 8, 'w': 6057.0}, {'u': 3, 'v': 10, 'w': 1127.0}, {'u': 10, 'v': 11, 'w': 1648.0}], 'density': 0.2, 'source_file': 'I025.stp', 'terminals': [2, 4, 5, 9]}","[[4, 7], [2, 4], [7, 8], [1, 9], [1, 2], [5, 8]]",3,nl,1
STP,STP,"We’re planning a walkable route through a museum by deciding which hallways to unlock so all of the flagged exhibit rooms are connected without any breaks. The route can pass through extra galleries to make connections easier, but every highlighted room must be on that single continuous route. To compare plans, just sum the lengths of every corridor section opened — the plan with the lowest total length wins. Every highlighted room has to be included, and corridor pieces are counted once when opened. The specific layout and measurements are listed below.

{
  ""total_locations"": 11,
  ""total_corridor_segments"": 13,
  ""edges"": [
    {
      ""endpoint_location_a"": 1,
      ""endpoint_location_b"": 2,
      ""corridor_length"": 764.0
    },
    {
      ""endpoint_location_a"": 1,
      ""endpoint_location_b"": 3,
      ""corridor_length"": 238.0
    },
    {
      ""endpoint_location_a"": 1,
      ""endpoint_location_b"": 9,
      ""corridor_length"": 252230.0
    },
    {
      ""endpoint_location_a"": 2,
      ""endpoint_location_b"": 3,
      ""corridor_length"": 743.0
    },
    {
      ""endpoint_location_a"": 2,
      ""endpoint_location_b"": 5,
      ""corridor_length"": 485.0
    },
    {
      ""endpoint_location_a"": 3,
      ""endpoint_location_b"": 11,
      ""corridor_length"": 426.0
    },
    {
      ""endpoint_location_a"": 4,
      ""endpoint_location_b"": 7,
      ""corridor_length"": 419.0
    },
    {
      ""endpoint_location_a"": 6,
      ""endpoint_location_b"": 7,
      ""corridor_length"": 166.0
    },
    {
      ""endpoint_location_a"": 6,
      ""endpoint_location_b"": 8,
      ""corridor_length"": 634.0
    },
    {
      ""endpoint_location_a"": 6,
      ""endpoint_location_b"": 9,
      ""corridor_length"": 252721.0
    },
    {
      ""endpoint_location_a"": 7,
      ""endpoint_location_b"": 10,
      ""corridor_length"": 634.0
    },
    {
      ""endpoint_location_a"": 8,
      ""endpoint_location_b"": 10,
      ""corridor_length"": 165.0
    },
    {
      ""endpoint_location_a"": 8,
      ""endpoint_location_b"": 11,
      ""corridor_length"": 660.0
    }
  ],
  ""highlighted_exhibit_rooms"": [
    2,
    4,
    5,
    10,
    11
  ]
}

When you send back the plan, just use a tiny JSON snippet that lists which corridor segments to open. Something casual like this works fine:

{
  ""solution"": [[""room1"", ""room2""], [""room3"", ""room4""]]
}

Each pair in the solution array is one corridor to unlock — the two entries are the room labels at the ends of that corridor. Think of it like filling out a short checklist of hallway connections: one pair per opened passage. This is just a sketch of the shape I want, not the actual answer.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 1, 'v': 2, 'w': 764.0}, {'u': 1, 'v': 3, 'w': 238.0}, {'u': 1, 'v': 9, 'w': 252230.0}, {'u': 2, 'v': 3, 'w': 743.0}, {'u': 2, 'v': 5, 'w': 485.0}, {'u': 3, 'v': 11, 'w': 426.0}, {'u': 4, 'v': 7, 'w': 419.0}, {'u': 6, 'v': 7, 'w': 166.0}, {'u': 6, 'v': 8, 'w': 634.0}, {'u': 6, 'v': 9, 'w': 252721.0}, {'u': 7, 'v': 10, 'w': 634.0}, {'u': 8, 'v': 10, 'w': 165.0}, {'u': 8, 'v': 11, 'w': 660.0}], 'terminals': [2, 4, 5, 10, 11], 'source_file': 'I064.stp', 'density': 0.23636363636363636, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0003.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0003.png'}","[[2, 3], [2, 5], [3, 11], [4, 7], [7, 10], [8, 10], [8, 11]]",3532.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 1, 'v': 2, 'w': 764.0}, {'u': 1, 'v': 3, 'w': 238.0}, {'u': 1, 'v': 9, 'w': 252230.0}, {'u': 2, 'v': 3, 'w': 743.0}, {'u': 2, 'v': 5, 'w': 485.0}, {'u': 3, 'v': 11, 'w': 426.0}, {'u': 4, 'v': 7, 'w': 419.0}, {'u': 6, 'v': 7, 'w': 166.0}, {'u': 6, 'v': 8, 'w': 634.0}, {'u': 6, 'v': 9, 'w': 252721.0}, {'u': 7, 'v': 10, 'w': 634.0}, {'u': 8, 'v': 10, 'w': 165.0}, {'u': 8, 'v': 11, 'w': 660.0}], 'density': 0.23636363636363636, 'source_file': 'I064.stp', 'terminals': [2, 4, 5, 10, 11]}","[[2, 3], [2, 5], [3, 11], [4, 7], [7, 10], [8, 10], [8, 11]]",4,json,1
STP,STP,"There’s a straightforward but picky task on the table: pick which irrigation ditches to build across a farm grid so that every highlighted crop plot is part of one continuous watering system, using corner junctions when useful. The smarter choices are the ones that keep the total digging short — just add up the lengths of all the built sections to see how much work they require. Every flagged plot must be connected to that single network, and each section is either built or not, counted only once. The concrete layout and which plots need water are listed below.

# total_junctions=15
# total_channel_sections=17
# required_plot_nodes=B D G J M N O
junction_u,junction_v,section_length
K,H,520.0
K,I,1038.0
I,J,2383.0
I,G,568.0
E,F,294003.0
E,G,293500.0
F,M,203.0
F,L,608.0
G,C,1005.0
O,L,294.0
O,N,671.0
D,C,994.0
L,H,926.0
N,M,609.0
M,B,382.0
A,B,227502.0
A,C,227504.0

Also, when you hand back the chosen ditch segments, please use this simple JSON shape so I (and any tools) can read it easily:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as just a list of built ditch sections — each item is a pair giving the two corner junctions that the section runs between. This example is just the shape I expect, not the actual plan — fill it with the actual pairs from the instance.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 11, 'v': 8, 'w': 520.0}, {'u': 11, 'v': 9, 'w': 1038.0}, {'u': 9, 'v': 10, 'w': 2383.0}, {'u': 9, 'v': 7, 'w': 568.0}, {'u': 5, 'v': 6, 'w': 294003.0}, {'u': 5, 'v': 7, 'w': 293500.0}, {'u': 6, 'v': 13, 'w': 203.0}, {'u': 6, 'v': 12, 'w': 608.0}, {'u': 7, 'v': 3, 'w': 1005.0}, {'u': 15, 'v': 12, 'w': 294.0}, {'u': 15, 'v': 14, 'w': 671.0}, {'u': 4, 'v': 3, 'w': 994.0}, {'u': 12, 'v': 8, 'w': 926.0}, {'u': 14, 'v': 13, 'w': 609.0}, {'u': 13, 'v': 2, 'w': 382.0}, {'u': 1, 'v': 2, 'w': 227502.0}, {'u': 1, 'v': 3, 'w': 227504.0}], 'terminals': [2, 4, 7, 10, 13, 14, 15], 'source_file': 'I024.stp', 'density': 0.1619047619047619, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0004.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0004.png'}","[[8, 11], [9, 11], [9, 10], [7, 9], [3, 7], [12, 15], [14, 15], [3, 4], [8, 12], [13, 14], [2, 13]]",9390.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 'K', 'v': 'H', 'w': 520.0}, {'u': 'K', 'v': 'I', 'w': 1038.0}, {'u': 'I', 'v': 'J', 'w': 2383.0}, {'u': 'I', 'v': 'G', 'w': 568.0}, {'u': 'E', 'v': 'F', 'w': 294003.0}, {'u': 'E', 'v': 'G', 'w': 293500.0}, {'u': 'F', 'v': 'M', 'w': 203.0}, {'u': 'F', 'v': 'L', 'w': 608.0}, {'u': 'G', 'v': 'C', 'w': 1005.0}, {'u': 'O', 'v': 'L', 'w': 294.0}, {'u': 'O', 'v': 'N', 'w': 671.0}, {'u': 'D', 'v': 'C', 'w': 994.0}, {'u': 'L', 'v': 'H', 'w': 926.0}, {'u': 'N', 'v': 'M', 'w': 609.0}, {'u': 'M', 'v': 'B', 'w': 382.0}, {'u': 'A', 'v': 'B', 'w': 227502.0}, {'u': 'A', 'v': 'C', 'w': 227504.0}], 'density': 0.1619047619047619, 'source_file': 'I024.stp', 'terminals': ['B', 'D', 'G', 'J', 'M', 'N', 'O']}","[['H', 'K'], ['I', 'K'], ['I', 'J'], ['G', 'I'], ['C', 'G'], ['L', 'O'], ['N', 'O'], ['C', 'D'], ['H', 'L'], ['M', 'N'], ['B', 'M']]",5,csv,names
STP,STP,"There’s a festival coming, and the organizers need to figure out which temporary walkways to lay across the lawns so the marked vendor booths form one connected network; existing plazas can be used as crossroads to make connections shorter. A good plan links every booth (nothing left disconnected), avoids needless duplicate stretches, and minimizes the total length of walkway installed — simply total the lengths of all chosen pieces. The plan and exact distances are shown below.

They show 10 total locations, 11 candidate walkway segments, and the vendor booths to connect: 3 6 9 10.
Temporary walkway between 10 and 1 — length 1082.0.
Temporary walkway between 10 and 7 — length 1079.0.
Temporary walkway between 10 and 9 — length 1684.0.
Temporary walkway between 8 and 4 — length 476.0.
Temporary walkway between 8 and 3 — length 239.0.
Temporary walkway between 8 and 5 — length 752.0.
Temporary walkway between 1 and 6 — length 318.0.
Temporary walkway between 2 and 3 — length 496.0.
Temporary walkway between 2 and 4 — length 276.0.
Temporary walkway between 3 and 6 — length 54.0.
Temporary walkway between 5 and 6 — length 971.0.
The solution should join every booth in 3 6 9 10 while minimizing the total installed length.

Just so we're on the same page, when you give the final plan please use this simple JSON layout:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is a list of walkway segments to put down. Each pair [X, Y] is the two labeled spots (a vendor booth or an existing plaza/crossroad) that should be connected by that piece of path. Treat it like filling out a little checklist: list each connection you want us to build.

This is only a sketch of the shape I expect the answer to take — not the actual plan itself.

Please make sure to 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”.""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 10, 'v': 1, 'w': 1082.0}, {'u': 10, 'v': 7, 'w': 1079.0}, {'u': 10, 'v': 9, 'w': 1684.0}, {'u': 8, 'v': 4, 'w': 476.0}, {'u': 8, 'v': 3, 'w': 239.0}, {'u': 8, 'v': 5, 'w': 752.0}, {'u': 1, 'v': 6, 'w': 318.0}, {'u': 2, 'v': 3, 'w': 496.0}, {'u': 2, 'v': 4, 'w': 276.0}, {'u': 3, 'v': 6, 'w': 54.0}, {'u': 5, 'v': 6, 'w': 971.0}], 'terminals': [3, 6, 9, 10], 'source_file': 'I007.stp', 'density': 0.24444444444444444, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0005.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0005.png'}","[[1, 10], [9, 10], [1, 6], [3, 6]]",3138.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 10, 'v': 1, 'w': 1082.0}, {'u': 10, 'v': 7, 'w': 1079.0}, {'u': 10, 'v': 9, 'w': 1684.0}, {'u': 8, 'v': 4, 'w': 476.0}, {'u': 8, 'v': 3, 'w': 239.0}, {'u': 8, 'v': 5, 'w': 752.0}, {'u': 1, 'v': 6, 'w': 318.0}, {'u': 2, 'v': 3, 'w': 496.0}, {'u': 2, 'v': 4, 'w': 276.0}, {'u': 3, 'v': 6, 'w': 54.0}, {'u': 5, 'v': 6, 'w': 971.0}], 'density': 0.24444444444444444, 'source_file': 'I007.stp', 'terminals': [3, 6, 9, 10]}","[[1, 10], [9, 10], [1, 6], [3, 6]]",6,markdown_table,1
STP,STP,"There’s a neighborhood project with poles and service panels laid out, and the challenge is to choose which conduit runs to build so every panel is part of a single, unbroken electrical path. Crews can drop in extra junction boxes to make the connections cleaner, and the measure of success is straightforward: the sum of the costs of the chosen conduit runs should be as small as it can be. No required panel can be left disconnected, and adding needless duplicate runs just increases cost. The exact map and prices are listed below.

The site map lists 13 locations, 13 available conduit runs, and required service panels B L.
Crews can build a conduit between M and J for 175.0.
Crews can build a conduit between K and L for 1671.0.
Crews can build a conduit between K and H for 2034.0.
Crews can build a conduit between J and I for 175.0.
Crews can build a conduit between J and B for 1927.0.
Crews can build a conduit between G and E for 1089.0.
Crews can build a conduit between G and C for 808.0.
Crews can build a conduit between G and F for 1056.0.
Crews can build a conduit between A and B for 906.0.
Crews can build a conduit between A and C for 205.0.
Crews can build a conduit between B and H for 234.0.
Crews can build a conduit between C and H for 913.0.
Crews can build a conduit between D and I for 1471.0.
No required panel may be left disconnected; choose runs that minimize the total installation cost.

If you want to hand over the chosen runs in a tidy, machine-friendly way, just stick to a tiny JSON object like this:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is a list of conduit runs to build — each inner pair is a connection between two poles/panels (use the exact node IDs from the map). Think of it like a short shopping list: each [u, v] is one run you want the crew to lay down. This block is just a sketch of the shape I expect, not the actual final answer.

Please make sure every identifier you use matches the instance input exactly — 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”.""","{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 13, 'edges': [{'u': 13, 'v': 10, 'w': 175.0}, {'u': 11, 'v': 12, 'w': 1671.0}, {'u': 11, 'v': 8, 'w': 2034.0}, {'u': 10, 'v': 9, 'w': 175.0}, {'u': 10, 'v': 2, 'w': 1927.0}, {'u': 7, 'v': 5, 'w': 1089.0}, {'u': 7, 'v': 3, 'w': 808.0}, {'u': 7, 'v': 6, 'w': 1056.0}, {'u': 1, 'v': 2, 'w': 906.0}, {'u': 1, 'v': 3, 'w': 205.0}, {'u': 2, 'v': 8, 'w': 234.0}, {'u': 3, 'v': 8, 'w': 913.0}, {'u': 4, 'v': 9, 'w': 1471.0}], 'terminals': [2, 12], 'source_file': 'I031.stp', 'density': 0.16666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0006.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0006.png'}","[[11, 12], [8, 11], [2, 8]]",3939.0,"{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 13, 'edges': [{'u': 'M', 'v': 'J', 'w': 175.0}, {'u': 'K', 'v': 'L', 'w': 1671.0}, {'u': 'K', 'v': 'H', 'w': 2034.0}, {'u': 'J', 'v': 'I', 'w': 175.0}, {'u': 'J', 'v': 'B', 'w': 1927.0}, {'u': 'G', 'v': 'E', 'w': 1089.0}, {'u': 'G', 'v': 'C', 'w': 808.0}, {'u': 'G', 'v': 'F', 'w': 1056.0}, {'u': 'A', 'v': 'B', 'w': 906.0}, {'u': 'A', 'v': 'C', 'w': 205.0}, {'u': 'B', 'v': 'H', 'w': 234.0}, {'u': 'C', 'v': 'H', 'w': 913.0}, {'u': 'D', 'v': 'I', 'w': 1471.0}], 'density': 0.16666666666666666, 'source_file': 'I031.stp', 'terminals': ['B', 'L']}","[['K', 'L'], ['H', 'K'], ['B', 'H']]",7,markdown_table,names
STP,STP,"We’re planning a simple maintenance route: pick a set of trail segments so that all the flagged viewpoints end up connected by trails, and it’s okay to route through clearings that aren’t viewpoints. What makes one plan better than another is how much trail needs work — add up the lengths of every segment kept, and the smaller that sum, the better the plan. All marked viewpoints must be on that continuous trail system, intermediate clearings may be used to bridge gaps, and each chosen trail piece contributes its length only once. The exact map and numbers follow below.

The map we're using has 10 locations and 12 trail segments; the flagged viewpoints to connect are 1 5 6.
Keep the segment between 1 and 2 (length 1387.0).
Keep the segment between 1 and 10 (length 554.0).
Keep the segment between 1 and 3 (length 621.0).
Keep the segment between 2 and 6 (length 1832.0).
Keep the segment between 3 and 9 (length 563.0).
Keep the segment between 3 and 4 (length 1838.0).
Keep the segment between 4 and 5 (length 913.0).
Keep the segment between 4 and 6 (length 903.0).
Keep the segment between 5 and 6 (length 152.0).
Keep the segment between 5 and 7 (length 1735.0).
Keep the segment between 10 and 9 (length 598.0).
Keep the segment between 8 and 9 (length 485.0).
We'll count each chosen segment's length once and seek the smallest total while ensuring all 1 5 6 are connected.

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

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here the idea is straightforward: ""solution"" is a list of trail segments, and each segment is written as a pair [endpoint1, endpoint2] using the node identifiers from the map. Think of it like filling out a short form — each line is just one piece of trail you want to keep. This JSON is just the expected shape (a sketch), not the final contents you should submit.

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"".","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 12, 'edges': [{'u': 1, 'v': 2, 'w': 1387.0}, {'u': 1, 'v': 10, 'w': 554.0}, {'u': 1, 'v': 3, 'w': 621.0}, {'u': 2, 'v': 6, 'w': 1832.0}, {'u': 3, 'v': 9, 'w': 563.0}, {'u': 3, 'v': 4, 'w': 1838.0}, {'u': 4, 'v': 5, 'w': 913.0}, {'u': 4, 'v': 6, 'w': 903.0}, {'u': 5, 'v': 6, 'w': 152.0}, {'u': 5, 'v': 7, 'w': 1735.0}, {'u': 10, 'v': 9, 'w': 598.0}, {'u': 8, 'v': 9, 'w': 485.0}], 'terminals': [1, 5, 6], 'source_file': 'I052.stp', 'density': 0.26666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0007.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0007.png'}","[[1, 2], [2, 6], [5, 6]]",3371.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 12, 'edges': [{'u': 1, 'v': 2, 'w': 1387.0}, {'u': 1, 'v': 10, 'w': 554.0}, {'u': 1, 'v': 3, 'w': 621.0}, {'u': 2, 'v': 6, 'w': 1832.0}, {'u': 3, 'v': 9, 'w': 563.0}, {'u': 3, 'v': 4, 'w': 1838.0}, {'u': 4, 'v': 5, 'w': 913.0}, {'u': 4, 'v': 6, 'w': 903.0}, {'u': 5, 'v': 6, 'w': 152.0}, {'u': 5, 'v': 7, 'w': 1735.0}, {'u': 10, 'v': 9, 'w': 598.0}, {'u': 8, 'v': 9, 'w': 485.0}], 'density': 0.26666666666666666, 'source_file': 'I052.stp', 'terminals': [1, 5, 6]}","[[1, 2], [2, 6], [5, 6]]",8,markdown_table,1
STP,STP,"Someone at city hall has to draw up a repair plan so all the designated school entrances are connected by repaired sidewalks. It’s allowed to fix sidewalks at other street corners to let entrances link through those points instead of fixing direct paths every time. A smarter repair plan is the cheaper one that still gets every entrance into the same repaired web — the total expense is simply the sum of the individual repair prices for the chosen sidewalk pieces. No listed entrance can be left out, and repaired pieces are counted once in that total. The specifics and numbers are shown below.

There are 11 intersections and sidewalk endpoints, 13 sidewalk segments available for repair, and the designated school entrances to connect are E I K.
Sidewalk segment connecting G and A costs 714.0 to repair.
Sidewalk segment connecting G and E costs 251.0 to repair.
Sidewalk segment connecting G and F costs 1396.0 to repair.
Sidewalk segment connecting H and I costs 2916.0 to repair.
Sidewalk segment connecting H and J costs 5703.0 to repair.
Sidewalk segment connecting H and A costs 1346.0 to repair.
Sidewalk segment connecting H and B costs 2142.0 to repair.
Sidewalk segment connecting E and D costs 973.0 to repair.
Sidewalk segment connecting D and B costs 876.0 to repair.
Sidewalk segment connecting I and K costs 6572.0 to repair.
Sidewalk segment connecting A and C costs 231943.0 to repair.
Sidewalk segment connecting B and C costs 231579.0 to repair.
Sidewalk segment connecting J and K costs 3604.0 to repair.
No listed entrance may be left out; repaired segments are counted once and the goal is the least total cost connecting E I K.

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

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of sidewalk pieces to fix. Each pair like [u1, v1] means ""repair the path between corner u1 and corner v1"" — think of u1 and v1 as the labels the city used on the map. This JSON is only a sketch of the shape I expect, not the actual repaired-edges answer.

Please make sure all identifiers in your final list match the instance input exactly — don't rename them or make up new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 7, 'v': 1, 'w': 714.0}, {'u': 7, 'v': 5, 'w': 251.0}, {'u': 7, 'v': 6, 'w': 1396.0}, {'u': 8, 'v': 9, 'w': 2916.0}, {'u': 8, 'v': 10, 'w': 5703.0}, {'u': 8, 'v': 1, 'w': 1346.0}, {'u': 8, 'v': 2, 'w': 2142.0}, {'u': 5, 'v': 4, 'w': 973.0}, {'u': 4, 'v': 2, 'w': 876.0}, {'u': 9, 'v': 11, 'w': 6572.0}, {'u': 1, 'v': 3, 'w': 231943.0}, {'u': 2, 'v': 3, 'w': 231579.0}, {'u': 10, 'v': 11, 'w': 3604.0}], 'terminals': [5, 9, 11], 'source_file': 'I037.stp', 'density': 0.23636363636363636, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0008.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0008.png'}","[[1, 7], [5, 7], [8, 9], [1, 8], [9, 11]]",11799.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 'G', 'v': 'A', 'w': 714.0}, {'u': 'G', 'v': 'E', 'w': 251.0}, {'u': 'G', 'v': 'F', 'w': 1396.0}, {'u': 'H', 'v': 'I', 'w': 2916.0}, {'u': 'H', 'v': 'J', 'w': 5703.0}, {'u': 'H', 'v': 'A', 'w': 1346.0}, {'u': 'H', 'v': 'B', 'w': 2142.0}, {'u': 'E', 'v': 'D', 'w': 973.0}, {'u': 'D', 'v': 'B', 'w': 876.0}, {'u': 'I', 'v': 'K', 'w': 6572.0}, {'u': 'A', 'v': 'C', 'w': 231943.0}, {'u': 'B', 'v': 'C', 'w': 231579.0}, {'u': 'J', 'v': 'K', 'w': 3604.0}], 'density': 0.23636363636363636, 'source_file': 'I037.stp', 'terminals': ['E', 'I', 'K']}","[['A', 'G'], ['E', 'G'], ['H', 'I'], ['A', 'H'], ['I', 'K']]",9,markdown_table,names
STP,STP,"I’m picturing a busy warehouse with a handful of storage bays flagged as top priority. The task is to decide which aisles to keep clear so every one of those priority bays can be reached by walking through a single connected corridor system, and it’s okay to use other aisles as connectors between them. A better choice is simply the one that ends up with the least total cleared distance — add up the length of every cleared aisle (count each stretch once) and smaller totals win — and every priority bay has to be reachable, no bay can be left out. The concrete layout and distances are shown below.

{
  ""num_aisle_nodes"": 14,
  ""num_aisle_segments"": 15,
  ""edges"": [
    {
      ""aisle_endpoint_u"": ""L"",
      ""aisle_endpoint_v"": ""N"",
      ""aisle_length"": 113.0
    },
    {
      ""aisle_endpoint_u"": ""J"",
      ""aisle_endpoint_v"": ""N"",
      ""aisle_length"": 277.0
    },
    {
      ""aisle_endpoint_u"": ""A"",
      ""aisle_endpoint_v"": ""C"",
      ""aisle_length"": 461.0
    },
    {
      ""aisle_endpoint_u"": ""B"",
      ""aisle_endpoint_v"": ""N"",
      ""aisle_length"": 1734.0
    },
    {
      ""aisle_endpoint_u"": ""B"",
      ""aisle_endpoint_v"": ""H"",
      ""aisle_length"": 355.0
    },
    {
      ""aisle_endpoint_u"": ""B"",
      ""aisle_endpoint_v"": ""G"",
      ""aisle_length"": 201770.0
    },
    {
      ""aisle_endpoint_u"": ""C"",
      ""aisle_endpoint_v"": ""G"",
      ""aisle_length"": 200255.0
    },
    {
      ""aisle_endpoint_u"": ""C"",
      ""aisle_endpoint_v"": ""M"",
      ""aisle_length"": 1667.0
    },
    {
      ""aisle_endpoint_u"": ""E"",
      ""aisle_endpoint_v"": ""F"",
      ""aisle_length"": 442912.0
    },
    {
      ""aisle_endpoint_u"": ""E"",
      ""aisle_endpoint_v"": ""H"",
      ""aisle_length"": 443755.0
    },
    {
      ""aisle_endpoint_u"": ""F"",
      ""aisle_endpoint_v"": ""H"",
      ""aisle_length"": 1110.0
    },
    {
      ""aisle_endpoint_u"": ""F"",
      ""aisle_endpoint_v"": ""M"",
      ""aisle_length"": 427.0
    },
    {
      ""aisle_endpoint_u"": ""M"",
      ""aisle_endpoint_v"": ""I"",
      ""aisle_length"": 1281.0
    },
    {
      ""aisle_endpoint_u"": ""K"",
      ""aisle_endpoint_v"": ""I"",
      ""aisle_length"": 1503.0
    },
    {
      ""aisle_endpoint_u"": ""D"",
      ""aisle_endpoint_v"": ""I"",
      ""aisle_length"": 2093.0
    }
  ],
  ""priority_bay_nodes"": [
    ""A"",
    ""E""
  ]
}

Also, when you reply with which aisles to keep clear, just use this simple JSON shape so it's easy to read and parse:

{
  ""solution"": [[bay1, aisle1], [bay2, bay3], ...]
}

This little block is just saying: ""solution"" is a list, and each item in the list is a pair naming the two ends of an aisle segment to keep clear. Think of each pair as one stretch of corridor between two labeled locations in the warehouse. It’s only a sketch of the expected shape — not the actual final answer.

Please be sure to use the exact identifiers from the instance input with no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 15, 'edges': [{'u': 12, 'v': 14, 'w': 113.0}, {'u': 10, 'v': 14, 'w': 277.0}, {'u': 1, 'v': 3, 'w': 461.0}, {'u': 2, 'v': 14, 'w': 1734.0}, {'u': 2, 'v': 8, 'w': 355.0}, {'u': 2, 'v': 7, 'w': 201770.0}, {'u': 3, 'v': 7, 'w': 200255.0}, {'u': 3, 'v': 13, 'w': 1667.0}, {'u': 5, 'v': 6, 'w': 442912.0}, {'u': 5, 'v': 8, 'w': 443755.0}, {'u': 6, 'v': 8, 'w': 1110.0}, {'u': 6, 'v': 13, 'w': 427.0}, {'u': 13, 'v': 9, 'w': 1281.0}, {'u': 11, 'v': 9, 'w': 1503.0}, {'u': 4, 'v': 9, 'w': 2093.0}], 'terminals': [1, 5], 'source_file': 'I050.stp', 'density': 0.16483516483516483, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0009.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0009.png'}","[[1, 3], [3, 13], [5, 6], [6, 13]]",445467.0,"{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 15, 'edges': [{'u': 'L', 'v': 'N', 'w': 113.0}, {'u': 'J', 'v': 'N', 'w': 277.0}, {'u': 'A', 'v': 'C', 'w': 461.0}, {'u': 'B', 'v': 'N', 'w': 1734.0}, {'u': 'B', 'v': 'H', 'w': 355.0}, {'u': 'B', 'v': 'G', 'w': 201770.0}, {'u': 'C', 'v': 'G', 'w': 200255.0}, {'u': 'C', 'v': 'M', 'w': 1667.0}, {'u': 'E', 'v': 'F', 'w': 442912.0}, {'u': 'E', 'v': 'H', 'w': 443755.0}, {'u': 'F', 'v': 'H', 'w': 1110.0}, {'u': 'F', 'v': 'M', 'w': 427.0}, {'u': 'M', 'v': 'I', 'w': 1281.0}, {'u': 'K', 'v': 'I', 'w': 1503.0}, {'u': 'D', 'v': 'I', 'w': 2093.0}], 'density': 0.16483516483516483, 'source_file': 'I050.stp', 'terminals': ['A', 'E']}","[['A', 'C'], ['C', 'M'], ['E', 'F'], ['F', 'M']]",10,json,names
STP,STP,"Someone on the reserve staff needs to map out repairs to get all the marsh observation platforms back onto one connected trail. They’ll choose which footbridges and boardwalk pieces to put back in service, and they can also repair non-viewing platforms to make the path work. The idea is to keep the repair tab as small as possible — just total up the cost of the pieces you commit to fixing, and that total is what you try to keep lowest. Every key observation point must be included in the continuous route, and each segment is either fixed or not (no double repairs). The concrete sections and their costs are listed below.

There are 10 distinct platforms and junctions and 11 repairable segments listed; the required observation platforms to include on the continuous route are C G H.
Repair the segment connecting J and H at a cost of 1477.0.
Repair the segment connecting D and E at a cost of 1218.0.
Repair the segment connecting E and C at a cost of 703.0.
Repair the segment connecting E and F at a cost of 1883.0.
Repair the segment connecting A and B at a cost of 512.0.
Repair the segment connecting A and C at a cost of 703.0.
Repair the segment connecting G and C at a cost of 515.0.
Repair the segment connecting G and B at a cost of 705.0.
Repair the segment connecting G and I at a cost of 1074.0.
Repair the segment connecting B and H at a cost of 1179.0.
Repair the segment connecting H and F at a cost of 1225.0.
They should total the repair costs and minimize that sum while ensuring every required observation platform C G H is on the final continuous route.

When you're ready to tell the crew which pieces to repair, just give the answer in this simple JSON layout:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This means ""solution"" should be a list of edge pairs — each pair [u1, v1] is the boardwalk or bridge segment between those two platform/node identifiers that you'll fix. Think of it like filling in a form: list the connections you want repaired so everything connects.

This JSON is just the shape I expect, not the actual repair plan itself.

Please make sure you use the exact identifiers from the problem input — don't rename them or invent new labels.  
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 10, 'v': 8, 'w': 1477.0}, {'u': 4, 'v': 5, 'w': 1218.0}, {'u': 5, 'v': 3, 'w': 703.0}, {'u': 5, 'v': 6, 'w': 1883.0}, {'u': 1, 'v': 2, 'w': 512.0}, {'u': 1, 'v': 3, 'w': 703.0}, {'u': 7, 'v': 3, 'w': 515.0}, {'u': 7, 'v': 2, 'w': 705.0}, {'u': 7, 'v': 9, 'w': 1074.0}, {'u': 2, 'v': 8, 'w': 1179.0}, {'u': 8, 'v': 6, 'w': 1225.0}], 'terminals': [3, 7, 8], 'source_file': 'I061.stp', 'density': 0.24444444444444444, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0010.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0010.png'}","[[3, 7], [2, 7], [2, 8]]",2399.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 'J', 'v': 'H', 'w': 1477.0}, {'u': 'D', 'v': 'E', 'w': 1218.0}, {'u': 'E', 'v': 'C', 'w': 703.0}, {'u': 'E', 'v': 'F', 'w': 1883.0}, {'u': 'A', 'v': 'B', 'w': 512.0}, {'u': 'A', 'v': 'C', 'w': 703.0}, {'u': 'G', 'v': 'C', 'w': 515.0}, {'u': 'G', 'v': 'B', 'w': 705.0}, {'u': 'G', 'v': 'I', 'w': 1074.0}, {'u': 'B', 'v': 'H', 'w': 1179.0}, {'u': 'H', 'v': 'F', 'w': 1225.0}], 'density': 0.24444444444444444, 'source_file': 'I061.stp', 'terminals': ['C', 'G', 'H']}","[['C', 'G'], ['B', 'G'], ['B', 'H']]",11,nl,names
STP,STP,"We’ve got a campus map with a handful of important buildings that must be connected, and the team needs to pick which backbone links to activate so those buildings all end up on a single live path. Other building connections can serve as intermediate hops, but better plans are the ones that achieve full connectivity while keeping the sum of the activated cable lengths as low as possible — calculated by summing the length of every turned-on link. All listed key buildings must be included in the network, each active link is counted toward the total, and the specific link lengths and layout are shown below.

Here are the specifics: 11 nodes, 13 candidate links, and the key buildings E F H.
We can activate the link between J and E with length 1481.0.
We can activate the link between J and F with length 1934.0.
We can activate the link between J and G with length 4474.0.
We can activate the link between K and H with length 2242.0.
We can activate the link between H and E with length 419.0.
We can activate the link between H and C with length 607.0.
We can activate the link between I and D with length 785.0.
We can activate the link between I and C with length 781.0.
We can activate the link between I and A with length 39085.0.
We can activate the link between B and F with length 403.0.
We can activate the link between B and D with length 343.0.
We can activate the link between C and D with length 760.0.
We can activate the link between E and F with length 999.0.
We’ll pick a set of these links so all E F H end up on a single live path while keeping the total activated length as low as possible.

Quick note — when you give your chosen set of links, please use this simple JSON layout so it’s easy to parse:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here, ""solution"" is just a list of link pairs. Each pair [u, v] means “turn on the cable between building/node u and building/node v.” Think of it like listing the specific edges you want active — just the pairs, nothing extra. The JSON above is only a sketch of the expected shape, not your final answer.

Please make sure to use the node identifiers exactly as they appear in the problem instance — 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”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 10, 'v': 5, 'w': 1481.0}, {'u': 10, 'v': 6, 'w': 1934.0}, {'u': 10, 'v': 7, 'w': 4474.0}, {'u': 11, 'v': 8, 'w': 2242.0}, {'u': 8, 'v': 5, 'w': 419.0}, {'u': 8, 'v': 3, 'w': 607.0}, {'u': 9, 'v': 4, 'w': 785.0}, {'u': 9, 'v': 3, 'w': 781.0}, {'u': 9, 'v': 1, 'w': 39085.0}, {'u': 2, 'v': 6, 'w': 403.0}, {'u': 2, 'v': 4, 'w': 343.0}, {'u': 3, 'v': 4, 'w': 760.0}, {'u': 5, 'v': 6, 'w': 999.0}], 'terminals': [5, 6, 8], 'source_file': 'I075.stp', 'density': 0.23636363636363636, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0011.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0011.png'}","[[5, 8], [5, 6]]",1418.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 'J', 'v': 'E', 'w': 1481.0}, {'u': 'J', 'v': 'F', 'w': 1934.0}, {'u': 'J', 'v': 'G', 'w': 4474.0}, {'u': 'K', 'v': 'H', 'w': 2242.0}, {'u': 'H', 'v': 'E', 'w': 419.0}, {'u': 'H', 'v': 'C', 'w': 607.0}, {'u': 'I', 'v': 'D', 'w': 785.0}, {'u': 'I', 'v': 'C', 'w': 781.0}, {'u': 'I', 'v': 'A', 'w': 39085.0}, {'u': 'B', 'v': 'F', 'w': 403.0}, {'u': 'B', 'v': 'D', 'w': 343.0}, {'u': 'C', 'v': 'D', 'w': 760.0}, {'u': 'E', 'v': 'F', 'w': 999.0}], 'density': 0.23636363636363636, 'source_file': 'I075.stp', 'terminals': ['E', 'F', 'H']}","[['E', 'H'], ['E', 'F']]",12,nl,names
STP,STP,"Imagine pruning the delivery map: pick a set of links between stores that keeps every flagship connected, letting trucks pass through regional hubs when helpful. The way to tell which pruning worked best is to total the lengths of the links that were left open — the smaller that total, the better the pruning. No flagship is allowed to be disconnected and no lane is counted more than once. The concrete store locations and route distances are shown below.

There are 15 locations, 16 candidate lanes, and these flagship stores: 1 5 8.
Consider the lane between 6 and 9 with distance 529.0.
Consider the lane between 6 and 5 with distance 1403.0.
Consider the lane between 13 and 11 with distance 426.0.
Consider the lane between 0 and 9 with distance 847.0.
Consider the lane between 0 and 4 with distance 392.0.
Consider the lane between 0 and 1 with distance 1289.0.
Consider the lane between 1 and 9 with distance 447.0.
Consider the lane between 1 and 8 with distance 914.0.
Consider the lane between 10 and 8 with distance 880.0.
Consider the lane between 10 and 3 with distance 24.0.
Consider the lane between 10 and 11 with distance 1545.0.
Consider the lane between 3 and 2 with distance 241.0.
Consider the lane between 3 and 12 with distance 422.0.
Consider the lane between 4 and 7 with distance 297508.0.
Consider the lane between 2 and 7 with distance 299113.0.
Consider the lane between 14 and 11 with distance 427.0.
Keep in mind that no flagship in 1 5 8 may be disconnected and no lane is counted more than once; minimize the total distance of the lanes you keep.

When you send the pruned map back, please use this JSON layout so it's easy to read by both people and tools:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of the links you decided to keep open. Each inner pair [u, v] represents a single link between two locations — think of it as ""leave the lane between u and v open."" This block is only a sketch of the shape I expect, not the actual answer — replace the placeholders with the real pairs from your work.

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"".","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 16, 'edges': [{'u': 7, 'v': 10, 'w': 529.0}, {'u': 7, 'v': 6, 'w': 1403.0}, {'u': 14, 'v': 12, 'w': 426.0}, {'u': 1, 'v': 10, 'w': 847.0}, {'u': 1, 'v': 5, 'w': 392.0}, {'u': 1, 'v': 2, 'w': 1289.0}, {'u': 2, 'v': 10, 'w': 447.0}, {'u': 2, 'v': 9, 'w': 914.0}, {'u': 11, 'v': 9, 'w': 880.0}, {'u': 11, 'v': 4, 'w': 24.0}, {'u': 11, 'v': 12, 'w': 1545.0}, {'u': 4, 'v': 3, 'w': 241.0}, {'u': 4, 'v': 13, 'w': 422.0}, {'u': 5, 'v': 8, 'w': 297508.0}, {'u': 3, 'v': 8, 'w': 299113.0}, {'u': 15, 'v': 12, 'w': 427.0}], 'terminals': [2, 6, 9], 'source_file': 'I024.stp', 'density': 0.1523809523809524, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0012.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0012.png'}","[[7, 10], [6, 7], [2, 10], [2, 9]]",3293.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 16, 'edges': [{'u': 6, 'v': 9, 'w': 529.0}, {'u': 6, 'v': 5, 'w': 1403.0}, {'u': 13, 'v': 11, 'w': 426.0}, {'u': 0, 'v': 9, 'w': 847.0}, {'u': 0, 'v': 4, 'w': 392.0}, {'u': 0, 'v': 1, 'w': 1289.0}, {'u': 1, 'v': 9, 'w': 447.0}, {'u': 1, 'v': 8, 'w': 914.0}, {'u': 10, 'v': 8, 'w': 880.0}, {'u': 10, 'v': 3, 'w': 24.0}, {'u': 10, 'v': 11, 'w': 1545.0}, {'u': 3, 'v': 2, 'w': 241.0}, {'u': 3, 'v': 12, 'w': 422.0}, {'u': 4, 'v': 7, 'w': 297508.0}, {'u': 2, 'v': 7, 'w': 299113.0}, {'u': 14, 'v': 11, 'w': 427.0}], 'density': 0.1523809523809524, 'source_file': 'I024.stp', 'terminals': [1, 5, 8]}","[[6, 9], [5, 6], [1, 9], [1, 8]]",13,nl,0
STP,STP,"We have a set of treatment plants and a bunch of possible pipe pieces that could be installed between places. The decision is which pieces to actually put in so that all the plants are part of one continuous pipeline, with any intersections happening only at current valve stations; the best option is the one with the smallest combined pipe length, which you get by summing the lengths of the chosen pieces. All named sites must be included and no segment should be counted twice. The specific layout and numbers are listed below.

# total_locations=13
# available_pipe_segments=14
# required_treatment_plants=8 9 11
endpoint_a,endpoint_b,segment_length
2,8,5103.0
2,1,3925.0
2,12,9750.0
9,0,3393.0
12,11,1338.0
12,10,15651.0
0,3,31.0
0,1,6157.0
4,5,158.0
4,6,345.0
5,7,329.0
6,7,121.0
7,8,1341.0
1,8,2147.0

If you want to hand me back a proposed set of pipe pieces, just send it in this simple JSON shape:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is a list of the pipe segments you choose; each pair [uX, vX] is one piece connecting site uX to site vX. Think of it like a form where you tick off each connection you want — one pair per segment, and don't list the same segment twice. This block is just a sketch of the shape I expect, not the actual answer.

And please use the exact identifiers from the instance input — don't rename or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 14, 'edges': [{'u': 3, 'v': 9, 'w': 5103.0}, {'u': 3, 'v': 2, 'w': 3925.0}, {'u': 3, 'v': 13, 'w': 9750.0}, {'u': 10, 'v': 1, 'w': 3393.0}, {'u': 13, 'v': 12, 'w': 1338.0}, {'u': 13, 'v': 11, 'w': 15651.0}, {'u': 1, 'v': 4, 'w': 31.0}, {'u': 1, 'v': 2, 'w': 6157.0}, {'u': 5, 'v': 6, 'w': 158.0}, {'u': 5, 'v': 7, 'w': 345.0}, {'u': 6, 'v': 8, 'w': 329.0}, {'u': 7, 'v': 8, 'w': 121.0}, {'u': 8, 'v': 9, 'w': 1341.0}, {'u': 2, 'v': 9, 'w': 2147.0}], 'terminals': [9, 10, 12], 'source_file': 'I025.stp', 'density': 0.1794871794871795, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0013.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0013.png'}","[[2, 3], [3, 13], [1, 10], [12, 13], [1, 2], [2, 9]]",26710.0,"{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 14, 'edges': [{'u': 2, 'v': 8, 'w': 5103.0}, {'u': 2, 'v': 1, 'w': 3925.0}, {'u': 2, 'v': 12, 'w': 9750.0}, {'u': 9, 'v': 0, 'w': 3393.0}, {'u': 12, 'v': 11, 'w': 1338.0}, {'u': 12, 'v': 10, 'w': 15651.0}, {'u': 0, 'v': 3, 'w': 31.0}, {'u': 0, 'v': 1, 'w': 6157.0}, {'u': 4, 'v': 5, 'w': 158.0}, {'u': 4, 'v': 6, 'w': 345.0}, {'u': 5, 'v': 7, 'w': 329.0}, {'u': 6, 'v': 7, 'w': 121.0}, {'u': 7, 'v': 8, 'w': 1341.0}, {'u': 1, 'v': 8, 'w': 2147.0}], 'density': 0.1794871794871795, 'source_file': 'I025.stp', 'terminals': [8, 9, 11]}","[[1, 2], [2, 12], [0, 9], [11, 12], [0, 1], [1, 8]]",14,csv,0
STP,STP,"Many people think of it as a puzzle of holiday wiring: there are landmark trees to light, lamp posts that can join things, and a set of candidate runs between them. The task is to pick which runs to put in so every landmark tree is on the same continuous power circuit, using posts as connectors where useful. Better solutions are simply those that use less total wiring — the total is the sum of the lengths of the installed runs — and nothing can be left out or wired twice. The exact map and numbers are provided below.

There are 13 locations, 15 available runs, and the required landmark trees are 6 10.
Candidate run connecting 11 and 6 with length 403.0.
Candidate run connecting 12 and 6 with length 417.0.
Candidate run connecting 12 and 13 with length 858.0.
Candidate run connecting 1 and 3 with length 612.0.
Candidate run connecting 1 and 8 with length 2672.0.
Candidate run connecting 7 and 5 with length 207608.0.
Candidate run connecting 7 and 2 with length 207399.0.
Candidate run connecting 9 and 4 with length 1599.0.
Candidate run connecting 9 and 3 with length 2254.0.
Candidate run connecting 10 and 4 with length 721.0.
Candidate run connecting 2 and 3 with length 1604.0.
Candidate run connecting 2 and 4 with length 2258.0.
Candidate run connecting 5 and 6 with length 795.0.
Candidate run connecting 5 and 8 with length 1275.0.
Candidate run connecting 13 and 8 with length 758.0.
Select runs that join all 6 10 into one continuous circuit while minimizing total wiring.

If you want to hand the wiring plan back to me, just stick it in a tiny JSON snippet like this — nice and simple so I can read it straight away.

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This just means ""solution"" is a list of runs to install; each inner pair [u, v] is an edge connecting two locations (think: between two trees or a tree and a lamp post). It's just a sketch of the shape I expect, not the actual answer — fill in the real pairs from the instance.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 15, 'edges': [{'u': 11, 'v': 6, 'w': 403.0}, {'u': 12, 'v': 6, 'w': 417.0}, {'u': 12, 'v': 13, 'w': 858.0}, {'u': 1, 'v': 3, 'w': 612.0}, {'u': 1, 'v': 8, 'w': 2672.0}, {'u': 7, 'v': 5, 'w': 207608.0}, {'u': 7, 'v': 2, 'w': 207399.0}, {'u': 9, 'v': 4, 'w': 1599.0}, {'u': 9, 'v': 3, 'w': 2254.0}, {'u': 10, 'v': 4, 'w': 721.0}, {'u': 2, 'v': 3, 'w': 1604.0}, {'u': 2, 'v': 4, 'w': 2258.0}, {'u': 5, 'v': 6, 'w': 795.0}, {'u': 5, 'v': 8, 'w': 1275.0}, {'u': 13, 'v': 8, 'w': 758.0}], 'terminals': [6, 10], 'source_file': 'I007.stp', 'density': 0.19230769230769232, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0014.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0014.png'}","[[6, 12], [12, 13], [1, 3], [1, 8], [4, 9], [3, 9], [4, 10], [8, 13]]",9891.0,"{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 15, 'edges': [{'u': 11, 'v': 6, 'w': 403.0}, {'u': 12, 'v': 6, 'w': 417.0}, {'u': 12, 'v': 13, 'w': 858.0}, {'u': 1, 'v': 3, 'w': 612.0}, {'u': 1, 'v': 8, 'w': 2672.0}, {'u': 7, 'v': 5, 'w': 207608.0}, {'u': 7, 'v': 2, 'w': 207399.0}, {'u': 9, 'v': 4, 'w': 1599.0}, {'u': 9, 'v': 3, 'w': 2254.0}, {'u': 10, 'v': 4, 'w': 721.0}, {'u': 2, 'v': 3, 'w': 1604.0}, {'u': 2, 'v': 4, 'w': 2258.0}, {'u': 5, 'v': 6, 'w': 795.0}, {'u': 5, 'v': 8, 'w': 1275.0}, {'u': 13, 'v': 8, 'w': 758.0}], 'density': 0.19230769230769232, 'source_file': 'I007.stp', 'terminals': [6, 10]}","[[6, 12], [12, 13], [1, 3], [1, 8], [4, 9], [3, 9], [4, 10], [8, 13]]",15,markdown_table,1
STP,STP,"Out in the subdivision the idea is to shut off some access roads but keep enough streets so all the fire hydrants can still be reached, using small residential streets where needed to connect things. The decision is which road segments to preserve so every hydrant sits on the same usable street network; a plan is judged by the total length of the roads that remain — simply add up those lengths, and the lower the total the better. The preserved streets must let crews get to every hydrant (none left out) and avoid keeping unnecessary extra loops. The specific roads and distances are shown below.

# total_intersections=12
# total_road_segments=12
# hydrant_locations=3 7 9
segment_endpoint_a,segment_endpoint_b,segment_length
10,2,505.0
8,9,1756.0
8,0,1545.0
8,5,1159.0
9,1,1517.0
9,7,1962.0
6,0,605.0
6,7,1749.0
6,2,2189.0
3,7,1060.0
11,5,1828.0
5,4,658.0

When you send the plan back, just stick to this simple JSON shape so it's easy to read by the rest of the tools:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of road segments you want to keep; each pair [u1, v1] describes a street between the two intersections u1 and v1. Think of it like filling out a quick form: one line per kept street. This JSON is only a sketch of the expected shape — not the final answer itself.

Please make sure to use the exact intersection 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”.""","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 12, 'edges': [{'u': 11, 'v': 3, 'w': 505.0}, {'u': 9, 'v': 10, 'w': 1756.0}, {'u': 9, 'v': 1, 'w': 1545.0}, {'u': 9, 'v': 6, 'w': 1159.0}, {'u': 10, 'v': 2, 'w': 1517.0}, {'u': 10, 'v': 8, 'w': 1962.0}, {'u': 7, 'v': 1, 'w': 605.0}, {'u': 7, 'v': 8, 'w': 1749.0}, {'u': 7, 'v': 3, 'w': 2189.0}, {'u': 4, 'v': 8, 'w': 1060.0}, {'u': 12, 'v': 6, 'w': 1828.0}, {'u': 6, 'v': 5, 'w': 658.0}], 'terminals': [4, 8, 10], 'source_file': 'I063.stp', 'density': 0.18181818181818182, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0015.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0015.png'}","[[8, 10], [4, 8]]",3022.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 12, 'edges': [{'u': 10, 'v': 2, 'w': 505.0}, {'u': 8, 'v': 9, 'w': 1756.0}, {'u': 8, 'v': 0, 'w': 1545.0}, {'u': 8, 'v': 5, 'w': 1159.0}, {'u': 9, 'v': 1, 'w': 1517.0}, {'u': 9, 'v': 7, 'w': 1962.0}, {'u': 6, 'v': 0, 'w': 605.0}, {'u': 6, 'v': 7, 'w': 1749.0}, {'u': 6, 'v': 2, 'w': 2189.0}, {'u': 3, 'v': 7, 'w': 1060.0}, {'u': 11, 'v': 5, 'w': 1828.0}, {'u': 5, 'v': 4, 'w': 658.0}], 'density': 0.18181818181818182, 'source_file': 'I063.stp', 'terminals': [3, 7, 9]}","[[7, 9], [3, 7]]",16,csv,0
STP,STP,"There’s a shift where the plow crew must make a choice: which parts of the taxiway system to clear so that a set of assigned gates are all reachable from one another. Using other aprons as shortcuts is allowed if it saves on clearing, but every assigned gate must sit on the cleared network and the plan shouldn’t include redundant cleared stretches. A good plan is the one that minimizes how much pavement is cleared in total — you figure that out by summing the distances of all cleared segments. The specific layout and numbers are shown below.

For the plow crew: 11 total pavement nodes, 14 possible clear segments, assigned gates 1 3 11.
Segment between 7 and 8: clearing length 3457.0 m.
Segment between 7 and 6: clearing length 5229.0 m.
Segment between 11 and 1: clearing length 610.0 m.
Segment between 11 and 9: clearing length 2245.0 m.
Segment between 10 and 8: clearing length 2382.0 m.
Segment between 10 and 9: clearing length 1711.0 m.
Segment between 10 and 6: clearing length 1538.0 m.
Segment between 4 and 2: clearing length 1251.0 m.
Segment between 5 and 1: clearing length 922.0 m.
Segment between 5 and 3: clearing length 908.0 m.
Segment between 2 and 3: clearing length 657.0 m.
Segment between 2 and 9: clearing length 807.0 m.
Segment between 3 and 9: clearing length 744.0 m.
Segment between 9 and 6: clearing length 1501.0 m.
The plow crew must select a subset of these segments that places all 1 3 11 on one cleared network without redundant stretches, minimizing the total cleared meters.

When you're ready to give the plan, just use the tiny JSON layout below so it's easy to parse:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is a list of the taxiway segments to clear; each pair like [u1, v1] is one segment connecting two pavement nodes. Think of it like filling out a short form: list the connecting pairs you want cleared so all assigned gates are connected.

This is only a sketch of the expected shape, not the actual answer—fill in the actual node identifiers from the instance.

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”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 14, 'edges': [{'u': 7, 'v': 8, 'w': 3457.0}, {'u': 7, 'v': 6, 'w': 5229.0}, {'u': 11, 'v': 1, 'w': 610.0}, {'u': 11, 'v': 9, 'w': 2245.0}, {'u': 10, 'v': 8, 'w': 2382.0}, {'u': 10, 'v': 9, 'w': 1711.0}, {'u': 10, 'v': 6, 'w': 1538.0}, {'u': 4, 'v': 2, 'w': 1251.0}, {'u': 5, 'v': 1, 'w': 922.0}, {'u': 5, 'v': 3, 'w': 908.0}, {'u': 2, 'v': 3, 'w': 657.0}, {'u': 2, 'v': 9, 'w': 807.0}, {'u': 3, 'v': 9, 'w': 744.0}, {'u': 9, 'v': 6, 'w': 1501.0}], 'terminals': [1, 3, 11], 'source_file': 'I056.stp', 'density': 0.2545454545454545, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0016.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0016.png'}","[[1, 11], [1, 5], [3, 5]]",2440.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 14, 'edges': [{'u': 7, 'v': 8, 'w': 3457.0}, {'u': 7, 'v': 6, 'w': 5229.0}, {'u': 11, 'v': 1, 'w': 610.0}, {'u': 11, 'v': 9, 'w': 2245.0}, {'u': 10, 'v': 8, 'w': 2382.0}, {'u': 10, 'v': 9, 'w': 1711.0}, {'u': 10, 'v': 6, 'w': 1538.0}, {'u': 4, 'v': 2, 'w': 1251.0}, {'u': 5, 'v': 1, 'w': 922.0}, {'u': 5, 'v': 3, 'w': 908.0}, {'u': 2, 'v': 3, 'w': 657.0}, {'u': 2, 'v': 9, 'w': 807.0}, {'u': 3, 'v': 9, 'w': 744.0}, {'u': 9, 'v': 6, 'w': 1501.0}], 'density': 0.2545454545454545, 'source_file': 'I056.stp', 'terminals': [1, 3, 11]}","[[1, 11], [1, 5], [3, 5]]",17,nl,1
STP,STP,"Imagine a landscape of protected pockets and a web of possible restoration strips — the task is to choose which strips to fix up so every protected pocket can be reached from any other via those strips, allowing hops across unprotected land where needed. The best setup is the one that uses the least restoration area: sum the area of each corridor that gets restored (shared sections aren’t counted twice) and pick the combination with the smallest total, while making sure no protected site is left out. The concrete details are shown below.

There are 12 patches, 14 candidate corridors, and protected patches: 1 7 11.
Candidate corridor between patches 4 and 3, restoration area 2719.0.
Candidate corridor between patches 4 and 11, restoration area 483.0.
Candidate corridor between patches 9 and 8, restoration area 5425.0.
Candidate corridor between patches 9 and 10, restoration area 874.0.
Candidate corridor between patches 5 and 6, restoration area 338.0.
Candidate corridor between patches 6 and 7, restoration area 11798.0.
Candidate corridor between patches 6 and 8, restoration area 6893.0.
Candidate corridor between patches 7 and 10, restoration area 918.0.
Candidate corridor between patches 7 and 1, restoration area 8826.0.
Candidate corridor between patches 10 and 11, restoration area 3523.0.
Candidate corridor between patches 11 and 2, restoration area 5137.0.
Candidate corridor between patches 1 and 2, restoration area 971.0.
Candidate corridor between patches 2 and 0, restoration area 3429.0.
Candidate corridor between patches 0 and 3, restoration area 4570.0.
Use the list below to choose corridors that link every protected patch while minimizing the total restored area.

If you want to hand in a candidate set of strips to restore, just follow this little JSON layout — super simple, just a list of edge pairs that you'd like to include:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Pretty casual mapping: ""solution"" is the list of corridors you’d repair, and each pair like [u1, v1] is one corridor connecting two sites (write them in the exact identifier form the instance uses). This block is just a sketch of the shape I expect, not the actual answer itself.

Quick reminder: 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”.""","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 5, 'v': 4, 'w': 2719.0}, {'u': 5, 'v': 12, 'w': 483.0}, {'u': 10, 'v': 9, 'w': 5425.0}, {'u': 10, 'v': 11, 'w': 874.0}, {'u': 6, 'v': 7, 'w': 338.0}, {'u': 7, 'v': 8, 'w': 11798.0}, {'u': 7, 'v': 9, 'w': 6893.0}, {'u': 8, 'v': 11, 'w': 918.0}, {'u': 8, 'v': 2, 'w': 8826.0}, {'u': 11, 'v': 12, 'w': 3523.0}, {'u': 12, 'v': 3, 'w': 5137.0}, {'u': 2, 'v': 3, 'w': 971.0}, {'u': 3, 'v': 1, 'w': 3429.0}, {'u': 1, 'v': 4, 'w': 4570.0}], 'terminals': [2, 8, 12], 'source_file': 'I044.stp', 'density': 0.21212121212121213, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0017.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0017.png'}","[[8, 11], [11, 12], [3, 12], [2, 3]]",10549.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 4, 'v': 3, 'w': 2719.0}, {'u': 4, 'v': 11, 'w': 483.0}, {'u': 9, 'v': 8, 'w': 5425.0}, {'u': 9, 'v': 10, 'w': 874.0}, {'u': 5, 'v': 6, 'w': 338.0}, {'u': 6, 'v': 7, 'w': 11798.0}, {'u': 6, 'v': 8, 'w': 6893.0}, {'u': 7, 'v': 10, 'w': 918.0}, {'u': 7, 'v': 1, 'w': 8826.0}, {'u': 10, 'v': 11, 'w': 3523.0}, {'u': 11, 'v': 2, 'w': 5137.0}, {'u': 1, 'v': 2, 'w': 971.0}, {'u': 2, 'v': 0, 'w': 3429.0}, {'u': 0, 'v': 3, 'w': 4570.0}], 'density': 0.21212121212121213, 'source_file': 'I044.stp', 'terminals': [1, 7, 11]}","[[7, 10], [10, 11], [2, 11], [1, 2]]",18,markdown_table,0
STP,STP,"Someone’s designing the overhead rigging for a small art walk and wants every highlighted work to sit on the same accessible skeleton of truss. The practical decision is which truss segments to assemble so the whole set of installations is connected — extra support junctions can be inserted where they make things shorter or neater. A smarter assembly uses the least truss overall: tally the length of each chosen piece and keep that grand total as low as possible, while ensuring every installation is part of the same continuous structure and nothing important is omitted or needlessly doubled. The detailed map and dimensions are shown below.

{
  ""total_support_junctions"": 11,
  ""total_truss_segments"": 11,
  ""edges"": [
    {
      ""junction_u"": ""G"",
      ""junction_v"": ""I"",
      ""segment_length"": 2159.0
    },
    {
      ""junction_u"": ""K"",
      ""junction_v"": ""A"",
      ""segment_length"": 2274.0
    },
    {
      ""junction_u"": ""K"",
      ""junction_v"": ""E"",
      ""segment_length"": 2097.0
    },
    {
      ""junction_u"": ""K"",
      ""junction_v"": ""H"",
      ""segment_length"": 2288.0
    },
    {
      ""junction_u"": ""H"",
      ""junction_v"": ""D"",
      ""segment_length"": 2056.0
    },
    {
      ""junction_u"": ""H"",
      ""junction_v"": ""J"",
      ""segment_length"": 1130.0
    },
    {
      ""junction_u"": ""E"",
      ""junction_v"": ""F"",
      ""segment_length"": 21.0
    },
    {
      ""junction_u"": ""A"",
      ""junction_v"": ""I"",
      ""segment_length"": 216.0
    },
    {
      ""junction_u"": ""F"",
      ""junction_v"": ""B"",
      ""segment_length"": 1997.0
    },
    {
      ""junction_u"": ""I"",
      ""junction_v"": ""C"",
      ""segment_length"": 2032.0
    },
    {
      ""junction_u"": ""B"",
      ""junction_v"": ""C"",
      ""segment_length"": 877.0
    }
  ],
  ""featured_installation_nodes"": [
    ""B"",
    ""C"",
    ""G"",
    ""J"",
    ""K""
  ]
}

When you send the list of chosen truss pieces back, please stick to this simple JSON layout so it's easy to check which segments you picked.

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of the truss segments to assemble; each inner pair [u, v] names the two junctions that a piece connects. Think of it like filling out a short form: each entry says ""connect this spot to that spot."" This block is only a sketch of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input — do not rename them or make up new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 11, 'edges': [{'u': 7, 'v': 9, 'w': 2159.0}, {'u': 11, 'v': 1, 'w': 2274.0}, {'u': 11, 'v': 5, 'w': 2097.0}, {'u': 11, 'v': 8, 'w': 2288.0}, {'u': 8, 'v': 4, 'w': 2056.0}, {'u': 8, 'v': 10, 'w': 1130.0}, {'u': 5, 'v': 6, 'w': 21.0}, {'u': 1, 'v': 9, 'w': 216.0}, {'u': 6, 'v': 2, 'w': 1997.0}, {'u': 9, 'v': 3, 'w': 2032.0}, {'u': 2, 'v': 3, 'w': 877.0}], 'terminals': [2, 3, 7, 10, 11], 'source_file': 'I035.stp', 'density': 0.2, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0018.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0018.png'}","[[7, 9], [1, 11], [8, 11], [8, 10], [1, 9], [3, 9], [2, 3]]",10976.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 11, 'edges': [{'u': 'G', 'v': 'I', 'w': 2159.0}, {'u': 'K', 'v': 'A', 'w': 2274.0}, {'u': 'K', 'v': 'E', 'w': 2097.0}, {'u': 'K', 'v': 'H', 'w': 2288.0}, {'u': 'H', 'v': 'D', 'w': 2056.0}, {'u': 'H', 'v': 'J', 'w': 1130.0}, {'u': 'E', 'v': 'F', 'w': 21.0}, {'u': 'A', 'v': 'I', 'w': 216.0}, {'u': 'F', 'v': 'B', 'w': 1997.0}, {'u': 'I', 'v': 'C', 'w': 2032.0}, {'u': 'B', 'v': 'C', 'w': 877.0}], 'density': 0.2, 'source_file': 'I035.stp', 'terminals': ['B', 'C', 'G', 'J', 'K']}","[['G', 'I'], ['A', 'K'], ['H', 'K'], ['H', 'J'], ['A', 'I'], ['C', 'I'], ['B', 'C']]",19,json,names
STP,STP,"On a quiet street a few households agreed to join certain gardens with decorative fence sections so they’d form one continuous fenced area for the whole group. The question is which specific fence links to put up so every agreed garden is part of that single connected system, and corners can share gate posts to avoid extra hardware. The measure of a good layout is how little fencing it takes overall — just add up the lengths of all the installed sections to see the total. Each agreed garden must be connected and no fence section may be counted or built twice. The concrete plan and measurements appear below.

There are 12 distinct gate posts, 14 candidate decorative sections, and the agreed gardens sit at nodes 0 1 2 6 7 10.
A decorative fence section connects gate posts 8 and 9 with length 630.0.
A decorative fence section connects gate posts 8 and 0 with length 1042.0.
A decorative fence section connects gate posts 8 and 6 with length 505.0.
A decorative fence section connects gate posts 9 and 11 with length 631.0.
A decorative fence section connects gate posts 9 and 2 with length 61.0.
A decorative fence section connects gate posts 2 and 10 with length 403.0.
A decorative fence section connects gate posts 11 and 1 with length 384.0.
A decorative fence section connects gate posts 11 and 3 with length 1529.0.
A decorative fence section connects gate posts 0 and 1 with length 790.0.
A decorative fence section connects gate posts 10 and 7 with length 34.0.
A decorative fence section connects gate posts 4 and 5 with length 530.0.
A decorative fence section connects gate posts 4 and 6 with length 187.0.
A decorative fence section connects gate posts 5 and 7 with length 185.0.
A decorative fence section connects gate posts 6 and 7 with length 557.0.
Select sections so every agreed garden in 0 1 2 6 7 10 is part of a single connected fenced area while keeping the total installed length as small as possible.

If you want to tell me which exact fence links to build, a nice simple way to send that back is in this little JSON shape:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of fence sections to install; each little pair like [u1, v1] means ""connect corner u1 to corner v1"" (one fence section between those two spots). Think of it as filling in a checklist of which links to put up — nothing fancy, just the pairs of endpoints.

This JSON is only a sketch of the shape I expect, not the actual answer. When you fill it in, use the exact node 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”.""","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 9, 'v': 10, 'w': 630.0}, {'u': 9, 'v': 1, 'w': 1042.0}, {'u': 9, 'v': 7, 'w': 505.0}, {'u': 10, 'v': 12, 'w': 631.0}, {'u': 10, 'v': 3, 'w': 61.0}, {'u': 3, 'v': 11, 'w': 403.0}, {'u': 12, 'v': 2, 'w': 384.0}, {'u': 12, 'v': 4, 'w': 1529.0}, {'u': 1, 'v': 2, 'w': 790.0}, {'u': 11, 'v': 8, 'w': 34.0}, {'u': 5, 'v': 6, 'w': 530.0}, {'u': 5, 'v': 7, 'w': 187.0}, {'u': 6, 'v': 8, 'w': 185.0}, {'u': 7, 'v': 8, 'w': 557.0}], 'terminals': [1, 2, 3, 7, 8, 11], 'source_file': 'I064.stp', 'density': 0.21212121212121213, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0019.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0019.png'}","[[10, 12], [3, 10], [3, 11], [2, 12], [1, 2], [8, 11], [7, 8]]",2860.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 8, 'v': 9, 'w': 630.0}, {'u': 8, 'v': 0, 'w': 1042.0}, {'u': 8, 'v': 6, 'w': 505.0}, {'u': 9, 'v': 11, 'w': 631.0}, {'u': 9, 'v': 2, 'w': 61.0}, {'u': 2, 'v': 10, 'w': 403.0}, {'u': 11, 'v': 1, 'w': 384.0}, {'u': 11, 'v': 3, 'w': 1529.0}, {'u': 0, 'v': 1, 'w': 790.0}, {'u': 10, 'v': 7, 'w': 34.0}, {'u': 4, 'v': 5, 'w': 530.0}, {'u': 4, 'v': 6, 'w': 187.0}, {'u': 5, 'v': 7, 'w': 185.0}, {'u': 6, 'v': 7, 'w': 557.0}], 'density': 0.21212121212121213, 'source_file': 'I064.stp', 'terminals': [0, 1, 2, 6, 7, 10]}","[[9, 11], [2, 9], [2, 10], [1, 11], [0, 1], [7, 10], [6, 7]]",20,markdown_table,0
STP,STP,"Someone at the municipal office needs a trenching route that links all the listed public buildings with fiber; the trick is to pick streets so the whole set becomes one connected network while keeping the total length of new trenches as small as possible. To see which idea is better, add together the lengths of all the streets chosen — the smaller that sum, the better the plan. Every specified building has to be on the connected route, and any intermediate intersections can be used to save digging. The specific sites and street lengths are shown below.

# total_intersections=10
# total_streets=10
# designated_buildings=1 2 4 5 9
intersection_u,intersection_v,street_length
3,10,602.0
3,4,990.0
4,2,596.0
4,9,654.0
9,8,1482.0
9,10,570.0
5,1,3821.0
6,1,1850.0
1,7,682.0
1,2,2904.0

Also, when you send your plan back, please use this simple JSON layout so it's easy for the office to read automatically:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as just a list of street segments to trench. Each inner pair like [u1, v1] is one chosen street, given by its two end intersections or building IDs. This block is just a sketch of the shape I need — not your final trenching choices — so fill it with the actual pairs from the map when you submit the plan.

Please use the exact node 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”.","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 10, 'edges': [{'u': 3, 'v': 10, 'w': 602.0}, {'u': 3, 'v': 4, 'w': 990.0}, {'u': 4, 'v': 2, 'w': 596.0}, {'u': 4, 'v': 9, 'w': 654.0}, {'u': 9, 'v': 8, 'w': 1482.0}, {'u': 9, 'v': 10, 'w': 570.0}, {'u': 5, 'v': 1, 'w': 3821.0}, {'u': 6, 'v': 1, 'w': 1850.0}, {'u': 1, 'v': 7, 'w': 682.0}, {'u': 1, 'v': 2, 'w': 2904.0}], 'terminals': [1, 2, 4, 5, 9], 'source_file': 'I040.stp', 'density': 0.2222222222222222, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0020.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0020.png'}","[[2, 4], [4, 9], [1, 5], [1, 2]]",7975.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 10, 'edges': [{'u': 3, 'v': 10, 'w': 602.0}, {'u': 3, 'v': 4, 'w': 990.0}, {'u': 4, 'v': 2, 'w': 596.0}, {'u': 4, 'v': 9, 'w': 654.0}, {'u': 9, 'v': 8, 'w': 1482.0}, {'u': 9, 'v': 10, 'w': 570.0}, {'u': 5, 'v': 1, 'w': 3821.0}, {'u': 6, 'v': 1, 'w': 1850.0}, {'u': 1, 'v': 7, 'w': 682.0}, {'u': 1, 'v': 2, 'w': 2904.0}], 'density': 0.2222222222222222, 'source_file': 'I040.stp', 'terminals': [1, 2, 4, 5, 9]}","[[2, 4], [4, 9], [1, 5], [1, 2]]",21,csv,1
STP,STP,"A homeowner has marked several beds and asked for a piping layout that reaches them all while using as little pipe as possible. The choice to make is which paths to install so the marked beds are all linked together in one continuous network, with the option to branch through other garden points to save material. Better plans are those with a smaller total run of pipe — total length is found by adding up each installed segment — and every marked bed must be connected; no bed can be left out and the system can’t be split into separate pieces. The precise site plan and lengths are shown below.

# total_site_points=10
# possible_pipe_segments=11
# marked_bed_nodes=1 7 9 10
endpoint_a,endpoint_b,segment_length
8,4,5592.0
8,9,13868.0
7,9,5387.0
7,6,1139.0
5,9,4107.0
5,10,10961.0
1,2,623.0
1,10,1700.0
3,2,3906.0
3,10,4324.0
6,4,8478.0

If you want to hand me the proposed piping in a tidy, machine-friendly way, just follow this shape when you reply:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This shows the shape I expect: ""solution"" is a list of pipe segments, and each pair [u, v] is a single installed segment between point u and point v on the site plan. Think of it like ticking off which connections to lay pipe along — one pair per segment.

Just so you know, that JSON is only a sketch of the shape I need, not the actual plan — fill it with the actual segment identifiers from the instance.

Please use the exact identifiers from the instance input with no renaming or invented labels — do not change them. 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”.","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 8, 'v': 4, 'w': 5592.0}, {'u': 8, 'v': 9, 'w': 13868.0}, {'u': 7, 'v': 9, 'w': 5387.0}, {'u': 7, 'v': 6, 'w': 1139.0}, {'u': 5, 'v': 9, 'w': 4107.0}, {'u': 5, 'v': 10, 'w': 10961.0}, {'u': 1, 'v': 2, 'w': 623.0}, {'u': 1, 'v': 10, 'w': 1700.0}, {'u': 3, 'v': 2, 'w': 3906.0}, {'u': 3, 'v': 10, 'w': 4324.0}, {'u': 6, 'v': 4, 'w': 8478.0}], 'terminals': [1, 7, 9, 10], 'source_file': 'I082.stp', 'density': 0.24444444444444444, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0021.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0021.png'}","[[7, 9], [5, 9], [5, 10], [1, 10]]",22155.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 8, 'v': 4, 'w': 5592.0}, {'u': 8, 'v': 9, 'w': 13868.0}, {'u': 7, 'v': 9, 'w': 5387.0}, {'u': 7, 'v': 6, 'w': 1139.0}, {'u': 5, 'v': 9, 'w': 4107.0}, {'u': 5, 'v': 10, 'w': 10961.0}, {'u': 1, 'v': 2, 'w': 623.0}, {'u': 1, 'v': 10, 'w': 1700.0}, {'u': 3, 'v': 2, 'w': 3906.0}, {'u': 3, 'v': 10, 'w': 4324.0}, {'u': 6, 'v': 4, 'w': 8478.0}], 'density': 0.24444444444444444, 'source_file': 'I082.stp', 'terminals': [1, 7, 9, 10]}","[[7, 9], [5, 9], [5, 10], [1, 10]]",22,csv,1
STP,STP,"At the nature reserve the challenge is to recommend which footpaths to harden so the handful of trailheads become one connected network. The practical test for any recommendation is the total paving length: take the lengths of every path included in the plan, add them up, and the plan with the smallest total is preferred. Detouring the paved connections through other clearings or junctions is allowed if it saves overall length, but no trailhead can be omitted and no segment is counted more than once. The specific map and path lengths appear below.

The map shows 12 locations, 14 paths, and the trailheads to be joined are 2 5.
Footpath segment joining 2 and 3 with length 4384.0.
Footpath segment joining 2 and 0 with length 1739.0.
Footpath segment joining 2 and 8 with length 1876.0.
Footpath segment joining 3 and 9 with length 5492.0.
Footpath segment joining 3 and 1 with length 2481.0.
Footpath segment joining 4 and 8 with length 403.0.
Footpath segment joining 4 and 5 with length 208.0.
Footpath segment joining 10 and 11 with length 668.0.
Footpath segment joining 10 and 6 with length 3865.0.
Footpath segment joining 11 and 6 with length 4289.0.
Footpath segment joining 5 and 8 with length 579.0.
Footpath segment joining 0 and 6 with length 6798.0.
Footpath segment joining 6 and 1 with length 6691.0.
Footpath segment joining 6 and 7 with length 5671.0.
Recommend the subset of paths that yields the smallest total length while connecting all 2 5.

Also, when you give your final recommendation, please use this simple JSON layout so it's clear which paths you're choosing:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

The ""solution"" field is just a list of the path segments to harden; each little pair [u, v] is the two end points of a single trail to include. It's an easy checklist-like sketch — not the finished plan itself, just the shape I expect the answer to take.

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”.""","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 3, 'v': 4, 'w': 4384.0}, {'u': 3, 'v': 1, 'w': 1739.0}, {'u': 3, 'v': 9, 'w': 1876.0}, {'u': 4, 'v': 10, 'w': 5492.0}, {'u': 4, 'v': 2, 'w': 2481.0}, {'u': 5, 'v': 9, 'w': 403.0}, {'u': 5, 'v': 6, 'w': 208.0}, {'u': 11, 'v': 12, 'w': 668.0}, {'u': 11, 'v': 7, 'w': 3865.0}, {'u': 12, 'v': 7, 'w': 4289.0}, {'u': 6, 'v': 9, 'w': 579.0}, {'u': 1, 'v': 7, 'w': 6798.0}, {'u': 7, 'v': 2, 'w': 6691.0}, {'u': 7, 'v': 8, 'w': 5671.0}], 'terminals': [3, 6], 'source_file': 'I050.stp', 'density': 0.21212121212121213, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0022.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0022.png'}","[[3, 9], [6, 9]]",2455.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 2, 'v': 3, 'w': 4384.0}, {'u': 2, 'v': 0, 'w': 1739.0}, {'u': 2, 'v': 8, 'w': 1876.0}, {'u': 3, 'v': 9, 'w': 5492.0}, {'u': 3, 'v': 1, 'w': 2481.0}, {'u': 4, 'v': 8, 'w': 403.0}, {'u': 4, 'v': 5, 'w': 208.0}, {'u': 10, 'v': 11, 'w': 668.0}, {'u': 10, 'v': 6, 'w': 3865.0}, {'u': 11, 'v': 6, 'w': 4289.0}, {'u': 5, 'v': 8, 'w': 579.0}, {'u': 0, 'v': 6, 'w': 6798.0}, {'u': 6, 'v': 1, 'w': 6691.0}, {'u': 6, 'v': 7, 'w': 5671.0}], 'density': 0.21212121212121213, 'source_file': 'I050.stp', 'terminals': [2, 5]}","[[2, 8], [5, 8]]",23,nl,0
STP,STP,"There’s a little puzzle at the museum: which runs of wire should be installed so that all the display cases are linked into a single, continuous security loop? It’s okay to route wiring through other rooms that don’t have displays if that helps shorten things, but every target case has to be included and there shouldn’t be redundant parallel cables. The winner is the plan with the smallest total cable length — add together the lengths of all selected runs to get that number — and the concrete map and lengths follow below.

{
  ""total_locations"": 12,
  ""total_candidate_runs"": 15,
  ""edges"": [
    {
      ""run_endpoint_a"": ""A"",
      ""run_endpoint_b"": ""B"",
      ""run_length"": 1946.0
    },
    {
      ""run_endpoint_a"": ""A"",
      ""run_endpoint_b"": ""C"",
      ""run_length"": 3358.0
    },
    {
      ""run_endpoint_a"": ""A"",
      ""run_endpoint_b"": ""D"",
      ""run_length"": 3361.0
    },
    {
      ""run_endpoint_a"": ""B"",
      ""run_endpoint_b"": ""F"",
      ""run_length"": 2496.0
    },
    {
      ""run_endpoint_a"": ""K"",
      ""run_endpoint_b"": ""G"",
      ""run_length"": 884.0
    },
    {
      ""run_endpoint_a"": ""K"",
      ""run_endpoint_b"": ""H"",
      ""run_length"": 5920.0
    },
    {
      ""run_endpoint_a"": ""K"",
      ""run_endpoint_b"": ""D"",
      ""run_length"": 1181.0
    },
    {
      ""run_endpoint_a"": ""C"",
      ""run_endpoint_b"": ""F"",
      ""run_length"": 519.0
    },
    {
      ""run_endpoint_a"": ""C"",
      ""run_endpoint_b"": ""D"",
      ""run_length"": 938.0
    },
    {
      ""run_endpoint_a"": ""D"",
      ""run_endpoint_b"": ""G"",
      ""run_length"": 1425.0
    },
    {
      ""run_endpoint_a"": ""E"",
      ""run_endpoint_b"": ""H"",
      ""run_length"": 2656.0
    },
    {
      ""run_endpoint_a"": ""L"",
      ""run_endpoint_b"": ""H"",
      ""run_length"": 5068.0
    },
    {
      ""run_endpoint_a"": ""J"",
      ""run_endpoint_b"": ""I"",
      ""run_length"": 4316.0
    },
    {
      ""run_endpoint_a"": ""J"",
      ""run_endpoint_b"": ""F"",
      ""run_length"": 2405.0
    },
    {
      ""run_endpoint_a"": ""H"",
      ""run_endpoint_b"": ""I"",
      ""run_length"": 1211.0
    }
  ],
  ""required_display_cases"": [
    ""D"",
    ""G""
  ]
}

Also, when you send back the wiring plan, please use this simple JSON shape so I can read it automatically:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Pretty straightforward: ""solution"" holds a list of cable runs, and each little pair [u, v] says ""connect node u to node v"" on the museum map. Treat the block above as just a sketch of the shape I need — not the actual wiring plan.

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”.","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 15, 'edges': [{'u': 1, 'v': 2, 'w': 1946.0}, {'u': 1, 'v': 3, 'w': 3358.0}, {'u': 1, 'v': 4, 'w': 3361.0}, {'u': 2, 'v': 6, 'w': 2496.0}, {'u': 11, 'v': 7, 'w': 884.0}, {'u': 11, 'v': 8, 'w': 5920.0}, {'u': 11, 'v': 4, 'w': 1181.0}, {'u': 3, 'v': 6, 'w': 519.0}, {'u': 3, 'v': 4, 'w': 938.0}, {'u': 4, 'v': 7, 'w': 1425.0}, {'u': 5, 'v': 8, 'w': 2656.0}, {'u': 12, 'v': 8, 'w': 5068.0}, {'u': 10, 'v': 9, 'w': 4316.0}, {'u': 10, 'v': 6, 'w': 2405.0}, {'u': 8, 'v': 9, 'w': 1211.0}], 'terminals': [4, 7], 'source_file': 'I012.stp', 'density': 0.22727272727272727, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0023.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0023.png'}","[[4, 7]]",1425.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 15, 'edges': [{'u': 'A', 'v': 'B', 'w': 1946.0}, {'u': 'A', 'v': 'C', 'w': 3358.0}, {'u': 'A', 'v': 'D', 'w': 3361.0}, {'u': 'B', 'v': 'F', 'w': 2496.0}, {'u': 'K', 'v': 'G', 'w': 884.0}, {'u': 'K', 'v': 'H', 'w': 5920.0}, {'u': 'K', 'v': 'D', 'w': 1181.0}, {'u': 'C', 'v': 'F', 'w': 519.0}, {'u': 'C', 'v': 'D', 'w': 938.0}, {'u': 'D', 'v': 'G', 'w': 1425.0}, {'u': 'E', 'v': 'H', 'w': 2656.0}, {'u': 'L', 'v': 'H', 'w': 5068.0}, {'u': 'J', 'v': 'I', 'w': 4316.0}, {'u': 'J', 'v': 'F', 'w': 2405.0}, {'u': 'H', 'v': 'I', 'w': 1211.0}], 'density': 0.22727272727272727, 'source_file': 'I012.stp', 'terminals': ['D', 'G']}","[['D', 'G']]",24,json,names
STP,STP,"There’s a telecom request to connect several crucial desks so they’re all on the same wired network; the team needs to choose which hallways to run the cable through. Passing the wire through other rooms is allowed to create links, and the goal is to end up with the smallest amount of cable possible — compute that by totaling the lengths of the corridors chosen. All required desks have to be part of the final connected route, and corridor lengths are accounted for once in that total. The detailed office layout and lengths are listed below.

# total_rooms_and_junctions=15
# total_corridors=17
# critical_workstation_nodes=B O
corridor_endpoint_u,corridor_endpoint_v,corridor_length_meters
D,K,315.0
D,E,1212.0
E,J,731.0
E,O,862.0
G,M,3188.0
G,I,4327.0
G,F,1337.0
K,L,787.0
O,L,173.0
H,N,290.0
H,I,1321.0
H,J,1646.0
I,C,1376.0
B,F,444.0
B,N,4459.0
J,C,932.0
A,N,3412.0

You can just give the chosen corridors as a simple JSON list so I can read it automatically — nothing fancy, just a list of the hallway endpoints you picked.

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Each pair [u, v] is a corridor between desk/room u and desk/room v that we’d run cable through, and ""solution"" is the whole set of corridors. This is just the shape I’m expecting — a sketch of how to format the answer, not the actual cable plan.

Please be sure to use the exact identifiers from the instance input — don’t rename or invent new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 4, 'v': 11, 'w': 315.0}, {'u': 4, 'v': 5, 'w': 1212.0}, {'u': 5, 'v': 10, 'w': 731.0}, {'u': 5, 'v': 15, 'w': 862.0}, {'u': 7, 'v': 13, 'w': 3188.0}, {'u': 7, 'v': 9, 'w': 4327.0}, {'u': 7, 'v': 6, 'w': 1337.0}, {'u': 11, 'v': 12, 'w': 787.0}, {'u': 15, 'v': 12, 'w': 173.0}, {'u': 8, 'v': 14, 'w': 290.0}, {'u': 8, 'v': 9, 'w': 1321.0}, {'u': 8, 'v': 10, 'w': 1646.0}, {'u': 9, 'v': 3, 'w': 1376.0}, {'u': 2, 'v': 6, 'w': 444.0}, {'u': 2, 'v': 14, 'w': 4459.0}, {'u': 10, 'v': 3, 'w': 932.0}, {'u': 1, 'v': 14, 'w': 3412.0}], 'terminals': [2, 15], 'source_file': 'I049.stp', 'density': 0.1619047619047619, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0024.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0024.png'}","[[5, 10], [5, 15], [8, 14], [8, 10], [2, 14]]",7988.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 'D', 'v': 'K', 'w': 315.0}, {'u': 'D', 'v': 'E', 'w': 1212.0}, {'u': 'E', 'v': 'J', 'w': 731.0}, {'u': 'E', 'v': 'O', 'w': 862.0}, {'u': 'G', 'v': 'M', 'w': 3188.0}, {'u': 'G', 'v': 'I', 'w': 4327.0}, {'u': 'G', 'v': 'F', 'w': 1337.0}, {'u': 'K', 'v': 'L', 'w': 787.0}, {'u': 'O', 'v': 'L', 'w': 173.0}, {'u': 'H', 'v': 'N', 'w': 290.0}, {'u': 'H', 'v': 'I', 'w': 1321.0}, {'u': 'H', 'v': 'J', 'w': 1646.0}, {'u': 'I', 'v': 'C', 'w': 1376.0}, {'u': 'B', 'v': 'F', 'w': 444.0}, {'u': 'B', 'v': 'N', 'w': 4459.0}, {'u': 'J', 'v': 'C', 'w': 932.0}, {'u': 'A', 'v': 'N', 'w': 3412.0}], 'density': 0.1619047619047619, 'source_file': 'I049.stp', 'terminals': ['B', 'O']}","[['E', 'J'], ['E', 'O'], ['H', 'N'], ['H', 'J'], ['B', 'N']]",25,csv,names
STP,STP,"There’s a campsite map with a few main sites and several commons, and the goal is to make a single tidy route that hits every campsite by using some of those commons as link points. The job is picking which paths to open and which commons to route through so that the campsites are all joined together. One plan beats another if the total amount of trail to cut and mark is less — simply total up the lengths of the picked segments to compare — and the plan has to include every campsite and avoid building any redundant, duplicated trails. The concrete layout and numbers appear below.

{
  ""total_locations"": 14,
  ""potential_trails_count"": 13,
  ""edges"": [
    {
      ""endpoint_a"": 12,
      ""endpoint_b"": 1,
      ""trail_length"": 1182.0
    },
    {
      ""endpoint_a"": 12,
      ""endpoint_b"": 14,
      ""trail_length"": 3535.0
    },
    {
      ""endpoint_a"": 12,
      ""endpoint_b"": 4,
      ""trail_length"": 4327.0
    },
    {
      ""endpoint_a"": 1,
      ""endpoint_b"": 2,
      ""trail_length"": 6100.0
    },
    {
      ""endpoint_a"": 1,
      ""endpoint_b"": 7,
      ""trail_length"": 3789.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 2,
      ""trail_length"": 1801.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 11,
      ""trail_length"": 2353.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 8,
      ""trail_length"": 2357.0
    },
    {
      ""endpoint_a"": 13,
      ""endpoint_b"": 11,
      ""trail_length"": 2339.0
    },
    {
      ""endpoint_a"": 11,
      ""endpoint_b"": 5,
      ""trail_length"": 5993.0
    },
    {
      ""endpoint_a"": 6,
      ""endpoint_b"": 7,
      ""trail_length"": 3660.0
    },
    {
      ""endpoint_a"": 3,
      ""endpoint_b"": 8,
      ""trail_length"": 3026.0
    },
    {
      ""endpoint_a"": 9,
      ""endpoint_b"": 8,
      ""trail_length"": 28.0
    }
  ],
  ""required_campsites"": [
    12,
    13
  ]
}

Also, when you send back the plan, please use this simple JSON shape so I can read it straight away:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as a short list of the trail segments you want to open. Each pair like [u1, v1] is one segment connecting two spots on the map (the order doesn’t matter). This block is just a sketch of the shape I expect — you’ll replace the placeholders with the actual node labels from the instance.

Please use the exact node identifiers from the 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”.""","{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 13, 'edges': [{'u': 12, 'v': 1, 'w': 1182.0}, {'u': 12, 'v': 14, 'w': 3535.0}, {'u': 12, 'v': 4, 'w': 4327.0}, {'u': 1, 'v': 2, 'w': 6100.0}, {'u': 1, 'v': 7, 'w': 3789.0}, {'u': 10, 'v': 2, 'w': 1801.0}, {'u': 10, 'v': 11, 'w': 2353.0}, {'u': 10, 'v': 8, 'w': 2357.0}, {'u': 13, 'v': 11, 'w': 2339.0}, {'u': 11, 'v': 5, 'w': 5993.0}, {'u': 6, 'v': 7, 'w': 3660.0}, {'u': 3, 'v': 8, 'w': 3026.0}, {'u': 9, 'v': 8, 'w': 28.0}], 'terminals': [12, 13], 'source_file': 'I004.stp', 'density': 0.14285714285714285, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0025.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0025.png'}","[[1, 12], [1, 2], [2, 10], [10, 11], [11, 13]]",13775.0,"{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 13, 'edges': [{'u': 12, 'v': 1, 'w': 1182.0}, {'u': 12, 'v': 14, 'w': 3535.0}, {'u': 12, 'v': 4, 'w': 4327.0}, {'u': 1, 'v': 2, 'w': 6100.0}, {'u': 1, 'v': 7, 'w': 3789.0}, {'u': 10, 'v': 2, 'w': 1801.0}, {'u': 10, 'v': 11, 'w': 2353.0}, {'u': 10, 'v': 8, 'w': 2357.0}, {'u': 13, 'v': 11, 'w': 2339.0}, {'u': 11, 'v': 5, 'w': 5993.0}, {'u': 6, 'v': 7, 'w': 3660.0}, {'u': 3, 'v': 8, 'w': 3026.0}, {'u': 9, 'v': 8, 'w': 28.0}], 'density': 0.14285714285714285, 'source_file': 'I004.stp', 'terminals': [12, 13]}","[[1, 12], [1, 2], [2, 10], [10, 11], [11, 13]]",26,json,1
STP,STP,"Many people think connecting substations means linking them directly, but the coordinator’s job is to pick which distribution lines to actually build so all substations become one connected network while using as little material as possible. The comparison is done by summing the cost (or length) of each selected line — lower totals are better. Intermediate junctions may be used to make cheaper connections, yet every substation must be included and a given physical line should only be built once. The concrete map and numbers are provided below.

# total_junctions=13
# total_candidate_lines=14
# required_substations=4 5 6 9 10 12
endpoint_node_a,endpoint_node_b,line_material_cost
9,12,1134.0
0,1,1014.0
0,7,201179.0
10,12,2470.0
11,5,437.0
11,6,944.0
11,2,1018.0
1,8,3129.0
1,5,730.0
12,6,903.0
2,3,465.0
2,7,200640.0
4,5,945.0
4,6,440.0

When you send back the actual selection, just use a tiny JSON snippet like this so it's easy to parse:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This little object is just a sketch of the shape I need: ""solution"" holds a list of built lines, and each inner pair [u, v] means ""build the line between node u and node v."" Super informal — think of it as filling out a checkbox form that says which connections get built. The example above is only the expected shape, not the real answer.

Please use the exact identifiers from the instance input with no renaming and no new labels. Valid identifiers look like:
- plain numbers such as “1” or “23”
- single capital letters like “A” or “B”
- a capital letter followed by digits like “A1” or “X7”

Thanks — just paste the JSON shaped like that with the real node IDs and we’re good.","{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 14, 'edges': [{'u': 10, 'v': 13, 'w': 1134.0}, {'u': 1, 'v': 2, 'w': 1014.0}, {'u': 1, 'v': 8, 'w': 201179.0}, {'u': 11, 'v': 13, 'w': 2470.0}, {'u': 12, 'v': 6, 'w': 437.0}, {'u': 12, 'v': 7, 'w': 944.0}, {'u': 12, 'v': 3, 'w': 1018.0}, {'u': 2, 'v': 9, 'w': 3129.0}, {'u': 2, 'v': 6, 'w': 730.0}, {'u': 13, 'v': 7, 'w': 903.0}, {'u': 3, 'v': 4, 'w': 465.0}, {'u': 3, 'v': 8, 'w': 200640.0}, {'u': 5, 'v': 6, 'w': 945.0}, {'u': 5, 'v': 7, 'w': 440.0}], 'terminals': [5, 6, 7, 10, 11, 13], 'source_file': 'I010.stp', 'density': 0.1794871794871795, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0026.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0026.png'}","[[10, 13], [11, 13], [7, 13], [5, 6], [5, 7]]",5892.0,"{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 14, 'edges': [{'u': 9, 'v': 12, 'w': 1134.0}, {'u': 0, 'v': 1, 'w': 1014.0}, {'u': 0, 'v': 7, 'w': 201179.0}, {'u': 10, 'v': 12, 'w': 2470.0}, {'u': 11, 'v': 5, 'w': 437.0}, {'u': 11, 'v': 6, 'w': 944.0}, {'u': 11, 'v': 2, 'w': 1018.0}, {'u': 1, 'v': 8, 'w': 3129.0}, {'u': 1, 'v': 5, 'w': 730.0}, {'u': 12, 'v': 6, 'w': 903.0}, {'u': 2, 'v': 3, 'w': 465.0}, {'u': 2, 'v': 7, 'w': 200640.0}, {'u': 4, 'v': 5, 'w': 945.0}, {'u': 4, 'v': 6, 'w': 440.0}], 'density': 0.1794871794871795, 'source_file': 'I010.stp', 'terminals': [4, 5, 6, 9, 10, 12]}","[[9, 12], [10, 12], [6, 12], [4, 5], [4, 6]]",27,csv,0
STP,STP,"Someone in facilities asked for a plan that shows exactly which corridors to expand so all program classrooms are connected by one accessible corridor system. The choice comes down to selecting certain hallways and possibly using lobbies or other public spots as links so every target classroom sits on the same continuous path. The winner is the plan with the smallest total renovation length — simply add up the lengths of each chosen hallway and public area to compare plans. It’s essential that every classroom on the program list is included in that single network and that no corridor gets counted more than once. The concrete map and classroom details follow below.

{
  ""total_locations"": 14,
  ""total_corridor_segments"": 15,
  ""edges"": [
    {
      ""endpoint_a"": 14,
      ""endpoint_b"": 9,
      ""renovation_length_meters"": 1339.0
    },
    {
      ""endpoint_a"": 7,
      ""endpoint_b"": 6,
      ""renovation_length_meters"": 808.0
    },
    {
      ""endpoint_a"": 12,
      ""endpoint_b"": 13,
      ""renovation_length_meters"": 4049.0
    },
    {
      ""endpoint_a"": 8,
      ""endpoint_b"": 13,
      ""renovation_length_meters"": 19569.0
    },
    {
      ""endpoint_a"": 9,
      ""endpoint_b"": 3,
      ""renovation_length_meters"": 732.0
    },
    {
      ""endpoint_a"": 9,
      ""endpoint_b"": 2,
      ""renovation_length_meters"": 1239.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 1,
      ""renovation_length_meters"": 1236.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 13,
      ""renovation_length_meters"": 7139.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 6,
      ""renovation_length_meters"": 2956.0
    },
    {
      ""endpoint_a"": 2,
      ""endpoint_b"": 5,
      ""renovation_length_meters"": 516.0
    },
    {
      ""endpoint_a"": 2,
      ""endpoint_b"": 3,
      ""renovation_length_meters"": 1959.0
    },
    {
      ""endpoint_a"": 3,
      ""endpoint_b"": 1,
      ""renovation_length_meters"": 685.0
    },
    {
      ""endpoint_a"": 4,
      ""endpoint_b"": 5,
      ""renovation_length_meters"": 1406.0
    },
    {
      ""endpoint_a"": 4,
      ""endpoint_b"": 6,
      ""renovation_length_meters"": 1973.0
    },
    {
      ""endpoint_a"": 5,
      ""endpoint_b"": 11,
      ""renovation_length_meters"": 3326.0
    }
  ],
  ""program_classrooms"": [
    2,
    4,
    5,
    6,
    8,
    11,
    12
  ]
}

Also, when you send back the set of corridors to renovate, please follow this simple JSON layout so I can read it automatically:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

In plain terms: ""solution"" is just a list of corridor links to include. Each pair like [u1, v1] means ""take the hallway (or connection) between node u1 and node v1"" — think of those u/v tokens as the room or junction IDs on the building map. This JSON is only a sketch of the shape I need, not the actual answer.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 15, 'edges': [{'u': 14, 'v': 9, 'w': 1339.0}, {'u': 7, 'v': 6, 'w': 808.0}, {'u': 12, 'v': 13, 'w': 4049.0}, {'u': 8, 'v': 13, 'w': 19569.0}, {'u': 9, 'v': 3, 'w': 732.0}, {'u': 9, 'v': 2, 'w': 1239.0}, {'u': 10, 'v': 1, 'w': 1236.0}, {'u': 10, 'v': 13, 'w': 7139.0}, {'u': 10, 'v': 6, 'w': 2956.0}, {'u': 2, 'v': 5, 'w': 516.0}, {'u': 2, 'v': 3, 'w': 1959.0}, {'u': 3, 'v': 1, 'w': 685.0}, {'u': 4, 'v': 5, 'w': 1406.0}, {'u': 4, 'v': 6, 'w': 1973.0}, {'u': 5, 'v': 11, 'w': 3326.0}], 'terminals': [2, 4, 5, 6, 8, 11, 12], 'source_file': 'I042.stp', 'density': 0.16483516483516483, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0027.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0027.png'}","[[12, 13], [8, 13], [10, 13], [6, 10], [2, 5], [4, 5], [4, 6], [5, 11]]",40934.0,"{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 15, 'edges': [{'u': 14, 'v': 9, 'w': 1339.0}, {'u': 7, 'v': 6, 'w': 808.0}, {'u': 12, 'v': 13, 'w': 4049.0}, {'u': 8, 'v': 13, 'w': 19569.0}, {'u': 9, 'v': 3, 'w': 732.0}, {'u': 9, 'v': 2, 'w': 1239.0}, {'u': 10, 'v': 1, 'w': 1236.0}, {'u': 10, 'v': 13, 'w': 7139.0}, {'u': 10, 'v': 6, 'w': 2956.0}, {'u': 2, 'v': 5, 'w': 516.0}, {'u': 2, 'v': 3, 'w': 1959.0}, {'u': 3, 'v': 1, 'w': 685.0}, {'u': 4, 'v': 5, 'w': 1406.0}, {'u': 4, 'v': 6, 'w': 1973.0}, {'u': 5, 'v': 11, 'w': 3326.0}], 'density': 0.16483516483516483, 'source_file': 'I042.stp', 'terminals': [2, 4, 5, 6, 8, 11, 12]}","[[12, 13], [8, 13], [10, 13], [6, 10], [2, 5], [4, 5], [4, 6], [5, 11]]",28,json,1
STP,STP,"We’ve been asked by the block association to decide how to hook up lamppost circuits so every community square shares one continuous lighting system. The decision is simply which connections to make; a better plan is the one with the smallest total amount of cable used, which you figure out by summing the lengths of all selected connections. It’s okay to route power through other poles or junctions that aren’t squares to save wire, but every square must be part of the single network and no duplicate runs or missing squares are allowed. The specific layout and measurements appear below.

# number_of_poles_and_junctions=15
# number_of_possible_connection_segments=17
# squares_to_connect=A D H I J K L
pole_u,pole_v,cable_length
N,G,64.0
N,O,1157.0
N,K,1636.0
L,A,3580.0
M,A,4918.0
A,K,1411.0
H,D,561.0
H,I,681.0
H,C,759.0
K,B,478.0
J,D,866.0
J,E,253.0
J,G,1343.0
G,F,1179.0
B,E,1194.0
C,D,281.0
C,E,875.0

Also, when you send the actual plan back, please stick to a tiny JSON shape like this so it’s easy to read and plug in:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of it like a little form: ""solution"" is the list of cable runs you want to make, and each pair [u1, v1] is one direct connection between two poles or junctions. This block is just a sketch of the shape I need, not the final wiring list — fill it with the actual pairs from the instance when you reply.

Please make sure to use the exact identifiers given in the instance input — don’t rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 14, 'v': 7, 'w': 64.0}, {'u': 14, 'v': 15, 'w': 1157.0}, {'u': 14, 'v': 11, 'w': 1636.0}, {'u': 12, 'v': 1, 'w': 3580.0}, {'u': 13, 'v': 1, 'w': 4918.0}, {'u': 1, 'v': 11, 'w': 1411.0}, {'u': 8, 'v': 4, 'w': 561.0}, {'u': 8, 'v': 9, 'w': 681.0}, {'u': 8, 'v': 3, 'w': 759.0}, {'u': 11, 'v': 2, 'w': 478.0}, {'u': 10, 'v': 4, 'w': 866.0}, {'u': 10, 'v': 5, 'w': 253.0}, {'u': 10, 'v': 7, 'w': 1343.0}, {'u': 7, 'v': 6, 'w': 1179.0}, {'u': 2, 'v': 5, 'w': 1194.0}, {'u': 3, 'v': 4, 'w': 281.0}, {'u': 3, 'v': 5, 'w': 875.0}], 'terminals': [1, 4, 8, 9, 10, 11, 12], 'source_file': 'I021.stp', 'density': 0.1619047619047619, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0028.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0028.png'}","[[1, 12], [1, 11], [4, 8], [8, 9], [2, 11], [4, 10], [5, 10], [2, 5]]",9024.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 'N', 'v': 'G', 'w': 64.0}, {'u': 'N', 'v': 'O', 'w': 1157.0}, {'u': 'N', 'v': 'K', 'w': 1636.0}, {'u': 'L', 'v': 'A', 'w': 3580.0}, {'u': 'M', 'v': 'A', 'w': 4918.0}, {'u': 'A', 'v': 'K', 'w': 1411.0}, {'u': 'H', 'v': 'D', 'w': 561.0}, {'u': 'H', 'v': 'I', 'w': 681.0}, {'u': 'H', 'v': 'C', 'w': 759.0}, {'u': 'K', 'v': 'B', 'w': 478.0}, {'u': 'J', 'v': 'D', 'w': 866.0}, {'u': 'J', 'v': 'E', 'w': 253.0}, {'u': 'J', 'v': 'G', 'w': 1343.0}, {'u': 'G', 'v': 'F', 'w': 1179.0}, {'u': 'B', 'v': 'E', 'w': 1194.0}, {'u': 'C', 'v': 'D', 'w': 281.0}, {'u': 'C', 'v': 'E', 'w': 875.0}], 'density': 0.1619047619047619, 'source_file': 'I021.stp', 'terminals': ['A', 'D', 'H', 'I', 'J', 'K', 'L']}","[['A', 'L'], ['A', 'K'], ['D', 'H'], ['H', 'I'], ['B', 'K'], ['D', 'J'], ['E', 'J'], ['B', 'E']]",29,csv,names
STP,STP,"Out in the countryside the planner’s job is to select certain roads so that every pickup location is connected into a single drivable web — adding crossroads to bridge gaps is allowed — while keeping the overall miles of road used to a minimum. The way to compare plans is to total the lengths of the chosen roads; the lower that total, the better the plan. It’s required that no pickup be excluded and the chosen roads together form one continuous network, with each road’s length counted once in the sum. The exact roads and distances are listed below.

# total_intersections_and_pickup_sites=12
# total_road_segments_listed=13
# required_pickup_sites=2 4 5 9 10 12
road_endpoint_a,road_endpoint_b,road_length_miles
10,8,803.0
10,3,2085.0
11,8,1392.0
11,9,1070.0
11,6,1201.0
1,6,1179.0
1,9,1343.0
4,12,4015.0
8,2,1039.0
9,5,1403.0
7,12,99.0
5,2,2718.0
5,12,1853.0

You can just send back the chosen roads in a tiny JSON sketch like this — super simple and easy to read:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of road segments; each pair like [u1, v1] stands for the single road that joins crossroads u1 and v1. Think of it like filling out a short form: one row per chosen road, with the two endpoints listed.

This is only a sketch of the expected shape, not the actual answer — replace the placeholders with the real node identifiers from the instance.

Please use the identifiers exactly as they appear in the instance input — no renaming, 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”.""","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 13, 'edges': [{'u': 10, 'v': 8, 'w': 803.0}, {'u': 10, 'v': 3, 'w': 2085.0}, {'u': 11, 'v': 8, 'w': 1392.0}, {'u': 11, 'v': 9, 'w': 1070.0}, {'u': 11, 'v': 6, 'w': 1201.0}, {'u': 1, 'v': 6, 'w': 1179.0}, {'u': 1, 'v': 9, 'w': 1343.0}, {'u': 4, 'v': 12, 'w': 4015.0}, {'u': 8, 'v': 2, 'w': 1039.0}, {'u': 9, 'v': 5, 'w': 1403.0}, {'u': 7, 'v': 12, 'w': 99.0}, {'u': 5, 'v': 2, 'w': 2718.0}, {'u': 5, 'v': 12, 'w': 1853.0}], 'terminals': [2, 4, 5, 9, 10, 12], 'source_file': 'I036.stp', 'density': 0.19696969696969696, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0029.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0029.png'}","[[8, 10], [8, 11], [9, 11], [4, 12], [2, 8], [5, 9], [5, 12]]",11575.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 13, 'edges': [{'u': 10, 'v': 8, 'w': 803.0}, {'u': 10, 'v': 3, 'w': 2085.0}, {'u': 11, 'v': 8, 'w': 1392.0}, {'u': 11, 'v': 9, 'w': 1070.0}, {'u': 11, 'v': 6, 'w': 1201.0}, {'u': 1, 'v': 6, 'w': 1179.0}, {'u': 1, 'v': 9, 'w': 1343.0}, {'u': 4, 'v': 12, 'w': 4015.0}, {'u': 8, 'v': 2, 'w': 1039.0}, {'u': 9, 'v': 5, 'w': 1403.0}, {'u': 7, 'v': 12, 'w': 99.0}, {'u': 5, 'v': 2, 'w': 2718.0}, {'u': 5, 'v': 12, 'w': 1853.0}], 'density': 0.19696969696969696, 'source_file': 'I036.stp', 'terminals': [2, 4, 5, 9, 10, 12]}","[[8, 10], [8, 11], [9, 11], [4, 12], [2, 8], [5, 9], [5, 12]]",30,csv,1
STP,STP,"Recently the maintenance team was asked to design a duct layout that connects every required room into one continuous ventilation route, and they had to pick which duct segments to put in. A few non-room spaces can act as shortcuts, so the decision comes down to selecting the segments that join everything up. The better layout is the one that reaches every required room with a single connected system and keeps the overall duct footage minimal — you measure that by adding up the lengths of the ducts you plan to install. No required room can be skipped, and the system must be one connected network, not split apart. The concrete map and numbers are shown below.

# total_locations=11
# available_duct_segments=11
# required_rooms=0 9
segment_endpoint_a,segment_endpoint_b,segment_length_feet
7,0,690.0
7,8,967.0
7,3,242.0
1,3,1127.0
1,4,1415.0
2,3,1315.0
2,4,1362.0
4,6,2952.0
5,9,1203.0
5,6,1440.0
6,10,1909.0

When you send back which duct segments you picked, a tiny JSON snippet like the one below is the easiest way for me to read it automatically. Nothing fancy — just a list of edge pairs.

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of the duct segments you plan to install. Each segment is written as a short pair [u, v] naming the two endpoints (use the same labels you see on the map). This block is only a sketch of the shape I expect — not the actual answer.

Please make 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”.

When you're ready, paste the real list of segments in that format and I’ll take a look.","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 11, 'edges': [{'u': 8, 'v': 1, 'w': 690.0}, {'u': 8, 'v': 9, 'w': 967.0}, {'u': 8, 'v': 4, 'w': 242.0}, {'u': 2, 'v': 4, 'w': 1127.0}, {'u': 2, 'v': 5, 'w': 1415.0}, {'u': 3, 'v': 4, 'w': 1315.0}, {'u': 3, 'v': 5, 'w': 1362.0}, {'u': 5, 'v': 7, 'w': 2952.0}, {'u': 6, 'v': 10, 'w': 1203.0}, {'u': 6, 'v': 7, 'w': 1440.0}, {'u': 7, 'v': 11, 'w': 1909.0}], 'terminals': [1, 10], 'source_file': 'I032.stp', 'density': 0.2, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0030.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0030.png'}","[[1, 8], [4, 8], [2, 4], [2, 5], [5, 7], [6, 10], [6, 7]]",9069.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 11, 'edges': [{'u': 7, 'v': 0, 'w': 690.0}, {'u': 7, 'v': 8, 'w': 967.0}, {'u': 7, 'v': 3, 'w': 242.0}, {'u': 1, 'v': 3, 'w': 1127.0}, {'u': 1, 'v': 4, 'w': 1415.0}, {'u': 2, 'v': 3, 'w': 1315.0}, {'u': 2, 'v': 4, 'w': 1362.0}, {'u': 4, 'v': 6, 'w': 2952.0}, {'u': 5, 'v': 9, 'w': 1203.0}, {'u': 5, 'v': 6, 'w': 1440.0}, {'u': 6, 'v': 10, 'w': 1909.0}], 'density': 0.2, 'source_file': 'I032.stp', 'terminals': [0, 9]}","[[0, 7], [3, 7], [1, 3], [1, 4], [4, 6], [5, 9], [5, 6]]",31,csv,0
STP,STP,"We were briefed by a field biologist who needs a simple map: which corridors should be maintained so all the tracked habitats form one unbroken route for animals. The best plan is the one that joins all monitored sites, possibly routing through intermediate patches, while keeping the total amount of fencing or clearing (measured by adding up the lengths of the chosen corridors) as small as possible. No monitored patch can be left disconnected, and duplicate or double-counted corridors don’t make sense — each link is counted once. The exact patch list and corridor lengths are given below.

We list the 10 habitat patches, the 10 possible corridors, and the monitored patches we must join: 1 3 6 8.
We can maintain the corridor between 0 and 2 with length 597.0.
We can maintain the corridor between 4 and 5 with length 3884.0.
We can maintain the corridor between 4 and 6 with length 4055.0.
We can maintain the corridor between 3 and 5 with length 814.0.
We can maintain the corridor between 3 and 9 with length 3956.0.
We can maintain the corridor between 9 and 2 with length 1911.0.
We can maintain the corridor between 9 and 1 with length 422.0.
We can maintain the corridor between 5 and 8 with length 1158.0.
We can maintain the corridor between 6 and 7 with length 899.0.
We can maintain the corridor between 7 and 8 with length 899.0.
We will count each maintained corridor once and must connect all 1 3 6 8 while minimizing the total length.

When you hand me the final set of corridors, please put it in this simple JSON shape:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is a list of corridor links to keep; each pair [u, v] means the corridor between patch u and patch v. Think of it like ticking boxes on a form — one pair per corridor, no duplicates, order doesn't matter. This JSON is just a sketch of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input — don't rename patches 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”.""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 10, 'edges': [{'u': 1, 'v': 3, 'w': 597.0}, {'u': 5, 'v': 6, 'w': 3884.0}, {'u': 5, 'v': 7, 'w': 4055.0}, {'u': 4, 'v': 6, 'w': 814.0}, {'u': 4, 'v': 10, 'w': 3956.0}, {'u': 10, 'v': 3, 'w': 1911.0}, {'u': 10, 'v': 2, 'w': 422.0}, {'u': 6, 'v': 9, 'w': 1158.0}, {'u': 7, 'v': 8, 'w': 899.0}, {'u': 8, 'v': 9, 'w': 899.0}], 'terminals': [2, 4, 7, 9], 'source_file': 'I083.stp', 'density': 0.2222222222222222, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0031.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0031.png'}","[[4, 6], [4, 10], [2, 10], [6, 9], [7, 8], [8, 9]]",8148.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 10, 'edges': [{'u': 0, 'v': 2, 'w': 597.0}, {'u': 4, 'v': 5, 'w': 3884.0}, {'u': 4, 'v': 6, 'w': 4055.0}, {'u': 3, 'v': 5, 'w': 814.0}, {'u': 3, 'v': 9, 'w': 3956.0}, {'u': 9, 'v': 2, 'w': 1911.0}, {'u': 9, 'v': 1, 'w': 422.0}, {'u': 5, 'v': 8, 'w': 1158.0}, {'u': 6, 'v': 7, 'w': 899.0}, {'u': 7, 'v': 8, 'w': 899.0}], 'density': 0.2222222222222222, 'source_file': 'I083.stp', 'terminals': [1, 3, 6, 8]}","[[3, 5], [3, 9], [1, 9], [5, 8], [6, 7], [7, 8]]",32,markdown_table,0
STP,STP,"Recently the operations team asked for a quick layout: which backroom paths should be opened so all the specified areas sit on one continuous service circuit. The choice is which corridors to include, and it’s fine to thread the route through spare storage rooms to make connections. A better layout is one that includes every required area in the same connected path (nothing missing or split off) and has the smallest possible total length when you add up the lengths of the opened passages. The exact diagram and lengths are shown below.

{
  ""total_backroom_zones"": 11,
  ""total_potential_passages"": 13,
  ""edges"": [
    {
      ""passage_endpoint_a"": 9,
      ""passage_endpoint_b"": 5,
      ""passage_length"": 279414.0
    },
    {
      ""passage_endpoint_a"": 9,
      ""passage_endpoint_b"": 1,
      ""passage_length"": 279414.0
    },
    {
      ""passage_endpoint_a"": 1,
      ""passage_endpoint_b"": 2,
      ""passage_length"": 208.0
    },
    {
      ""passage_endpoint_a"": 1,
      ""passage_endpoint_b"": 3,
      ""passage_length"": 1005.0
    },
    {
      ""passage_endpoint_a"": 2,
      ""passage_endpoint_b"": 11,
      ""passage_length"": 990.0
    },
    {
      ""passage_endpoint_a"": 2,
      ""passage_endpoint_b"": 4,
      ""passage_length"": 345.0
    },
    {
      ""passage_endpoint_a"": 3,
      ""passage_endpoint_b"": 11,
      ""passage_length"": 122.0
    },
    {
      ""passage_endpoint_a"": 4,
      ""passage_endpoint_b"": 10,
      ""passage_length"": 815.0
    },
    {
      ""passage_endpoint_a"": 10,
      ""passage_endpoint_b"": 5,
      ""passage_length"": 345.0
    },
    {
      ""passage_endpoint_a"": 10,
      ""passage_endpoint_b"": 6,
      ""passage_length"": 600.0
    },
    {
      ""passage_endpoint_a"": 6,
      ""passage_endpoint_b"": 5,
      ""passage_length"": 263.0
    },
    {
      ""passage_endpoint_a"": 6,
      ""passage_endpoint_b"": 8,
      ""passage_length"": 94.0
    },
    {
      ""passage_endpoint_a"": 7,
      ""passage_endpoint_b"": 8,
      ""passage_length"": 488.0
    }
  ],
  ""required_service_areas"": [
    1,
    5
  ]
}

Also, when you send back which passages to open, please use this simple JSON shape so I can read it straight away:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This just means ""solution"" holds a list of pairs; each pair is an edge (a passage) between two room/node identifiers. It's just a sketch of the expected shape — not the actual answer — so fill in the real node IDs from the instance when you reply.

Please use the identifiers exactly as they appear in the instance input — do not rename them and do not 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”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 9, 'v': 5, 'w': 279414.0}, {'u': 9, 'v': 1, 'w': 279414.0}, {'u': 1, 'v': 2, 'w': 208.0}, {'u': 1, 'v': 3, 'w': 1005.0}, {'u': 2, 'v': 11, 'w': 990.0}, {'u': 2, 'v': 4, 'w': 345.0}, {'u': 3, 'v': 11, 'w': 122.0}, {'u': 4, 'v': 10, 'w': 815.0}, {'u': 10, 'v': 5, 'w': 345.0}, {'u': 10, 'v': 6, 'w': 600.0}, {'u': 6, 'v': 5, 'w': 263.0}, {'u': 6, 'v': 8, 'w': 94.0}, {'u': 7, 'v': 8, 'w': 488.0}], 'terminals': [1, 5], 'source_file': 'I042.stp', 'density': 0.23636363636363636, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0032.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0032.png'}","[[1, 2], [2, 4], [4, 10], [5, 10]]",1713.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 9, 'v': 5, 'w': 279414.0}, {'u': 9, 'v': 1, 'w': 279414.0}, {'u': 1, 'v': 2, 'w': 208.0}, {'u': 1, 'v': 3, 'w': 1005.0}, {'u': 2, 'v': 11, 'w': 990.0}, {'u': 2, 'v': 4, 'w': 345.0}, {'u': 3, 'v': 11, 'w': 122.0}, {'u': 4, 'v': 10, 'w': 815.0}, {'u': 10, 'v': 5, 'w': 345.0}, {'u': 10, 'v': 6, 'w': 600.0}, {'u': 6, 'v': 5, 'w': 263.0}, {'u': 6, 'v': 8, 'w': 94.0}, {'u': 7, 'v': 8, 'w': 488.0}], 'density': 0.23636363636363636, 'source_file': 'I042.stp', 'terminals': [1, 5]}","[[1, 2], [2, 4], [4, 10], [5, 10]]",33,json,1
STP,STP,"A venue manager wants a tidy backstage: several stage areas must be joined into one connected setup using platform connectors, and the trick is picking which runs to build — running through other backstage spots is allowed if it shortens the job. One plan is preferable when the total length of installed connectors is smaller; simply sum the lengths of every connector in the plan to get that total. Every staging zone needs to be part of the network, and installing unnecessary duplicate connectors should be avoided. The exact layout and connector lengths are provided below.

{
  ""total_backstage_areas"": 10,
  ""total_possible_connectors"": 12,
  ""edges"": [
    {
      ""connector_endpoint_u"": ""F"",
      ""connector_endpoint_v"": ""D"",
      ""connector_length"": 287.0
    },
    {
      ""connector_endpoint_u"": ""F"",
      ""connector_endpoint_v"": ""G"",
      ""connector_length"": 193.0
    },
    {
      ""connector_endpoint_u"": ""F"",
      ""connector_endpoint_v"": ""H"",
      ""connector_length"": 492.0
    },
    {
      ""connector_endpoint_u"": ""G"",
      ""connector_endpoint_v"": ""I"",
      ""connector_length"": 476.0
    },
    {
      ""connector_endpoint_u"": ""G"",
      ""connector_endpoint_v"": ""J"",
      ""connector_length"": 1115.0
    },
    {
      ""connector_endpoint_u"": ""A"",
      ""connector_endpoint_v"": ""B"",
      ""connector_length"": 781.0
    },
    {
      ""connector_endpoint_u"": ""A"",
      ""connector_endpoint_v"": ""C"",
      ""connector_length"": 613.0
    },
    {
      ""connector_endpoint_u"": ""B"",
      ""connector_endpoint_v"": ""I"",
      ""connector_length"": 627.0
    },
    {
      ""connector_endpoint_u"": ""C"",
      ""connector_endpoint_v"": ""E"",
      ""connector_length"": 358.0
    },
    {
      ""connector_endpoint_u"": ""H"",
      ""connector_endpoint_v"": ""E"",
      ""connector_length"": 286.0
    },
    {
      ""connector_endpoint_u"": ""H"",
      ""connector_endpoint_v"": ""I"",
      ""connector_length"": 148.0
    },
    {
      ""connector_endpoint_u"": ""D"",
      ""connector_endpoint_v"": ""E"",
      ""connector_length"": 518.0
    }
  ],
  ""required_stage_areas"": [
    ""A"",
    ""F""
  ]
}

When you send back your chosen plan, please use this simple JSON shape so it's easy to read and check:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This just sketches the format: ""solution"" holds a list of connector pairs, and each pair [X, Y] is one connector joining staging area X to staging area Y. Think of it as a short form list of which runs to build — that's all it needs to show.

This JSON is only a template for the expected shape, not the actual answer.

Please make sure to use the exact identifiers from the instance input — do not rename them or invent new 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”.""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 12, 'edges': [{'u': 6, 'v': 4, 'w': 287.0}, {'u': 6, 'v': 7, 'w': 193.0}, {'u': 6, 'v': 8, 'w': 492.0}, {'u': 7, 'v': 9, 'w': 476.0}, {'u': 7, 'v': 10, 'w': 1115.0}, {'u': 1, 'v': 2, 'w': 781.0}, {'u': 1, 'v': 3, 'w': 613.0}, {'u': 2, 'v': 9, 'w': 627.0}, {'u': 3, 'v': 5, 'w': 358.0}, {'u': 8, 'v': 5, 'w': 286.0}, {'u': 8, 'v': 9, 'w': 148.0}, {'u': 4, 'v': 5, 'w': 518.0}], 'terminals': [1, 6], 'source_file': 'I037.stp', 'density': 0.26666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0033.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0033.png'}","[[6, 8], [1, 3], [3, 5], [5, 8]]",1749.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 12, 'edges': [{'u': 'F', 'v': 'D', 'w': 287.0}, {'u': 'F', 'v': 'G', 'w': 193.0}, {'u': 'F', 'v': 'H', 'w': 492.0}, {'u': 'G', 'v': 'I', 'w': 476.0}, {'u': 'G', 'v': 'J', 'w': 1115.0}, {'u': 'A', 'v': 'B', 'w': 781.0}, {'u': 'A', 'v': 'C', 'w': 613.0}, {'u': 'B', 'v': 'I', 'w': 627.0}, {'u': 'C', 'v': 'E', 'w': 358.0}, {'u': 'H', 'v': 'E', 'w': 286.0}, {'u': 'H', 'v': 'I', 'w': 148.0}, {'u': 'D', 'v': 'E', 'w': 518.0}], 'density': 0.26666666666666666, 'source_file': 'I037.stp', 'terminals': ['A', 'F']}","[['F', 'H'], ['A', 'C'], ['C', 'E'], ['E', 'H']]",34,json,names
STP,STP,"Someone from the parks team wants a simple plan: choose benches and the short paths between them so all picnic groves are joined into one uninterrupted promenade. The choice is about which connections to use — clearings can act as intermediate tie-ins if that helps — and the winner is the layout with the smallest overall path length. The overall length gets computed by adding up the lengths of each chosen connection. Requirements are straightforward: don’t leave any grove out, make sure everything is connected into a single route, and don’t double-count or build redundant pieces. The exact layout and distances are shown below.

There are 10 marked locations and 11 candidate short paths; the picnic groves to span are 1 3 5 6.
Candidate short path between 3 and 6 with length 1274.0.
Candidate short path between 3 and 0 with length 1231.0.
Candidate short path between 3 and 1 with length 798.0.
Candidate short path between 7 and 0 with length 128.0.
Candidate short path between 7 and 5 with length 2022.0.
Candidate short path between 7 and 4 with length 554.0.
Candidate short path between 4 and 8 with length 1785.0.
Candidate short path between 4 and 1 with length 914.0.
Candidate short path between 9 and 5 with length 1258.0.
Candidate short path between 5 and 2 with length 178.0.
Candidate short path between 2 and 6 with length 1461.0.
Choose a subset of these connections that spans 1 3 5 6 into one uninterrupted promenade with minimum total path length, without leaving any grove out or adding redundant pieces.

Also, to keep things machine-friendly, I'll show the shape I expect the answer to take in a tiny JSON sketch — just a relaxed heads-up so you know what to fill in.

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This just means: ""solution"" is a list of chosen connections, and each inner pair [u, v] is a short path you’d build between bench (or clearing) u and bench v. Think of it like a simple checklist of which links to include in the promenade. The block above is only a sketch of the shape I want — not the final, filled-in plan.

Please make sure to use the exact identifiers from the instance input when you give the real selection — 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”.""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 4, 'v': 7, 'w': 1274.0}, {'u': 4, 'v': 1, 'w': 1231.0}, {'u': 4, 'v': 2, 'w': 798.0}, {'u': 8, 'v': 1, 'w': 128.0}, {'u': 8, 'v': 6, 'w': 2022.0}, {'u': 8, 'v': 5, 'w': 554.0}, {'u': 5, 'v': 9, 'w': 1785.0}, {'u': 5, 'v': 2, 'w': 914.0}, {'u': 10, 'v': 6, 'w': 1258.0}, {'u': 6, 'v': 3, 'w': 178.0}, {'u': 3, 'v': 7, 'w': 1461.0}], 'terminals': [2, 4, 6, 7], 'source_file': 'I040.stp', 'density': 0.24444444444444444, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0034.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0034.png'}","[[4, 7], [2, 4], [3, 6], [3, 7]]",3711.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 3, 'v': 6, 'w': 1274.0}, {'u': 3, 'v': 0, 'w': 1231.0}, {'u': 3, 'v': 1, 'w': 798.0}, {'u': 7, 'v': 0, 'w': 128.0}, {'u': 7, 'v': 5, 'w': 2022.0}, {'u': 7, 'v': 4, 'w': 554.0}, {'u': 4, 'v': 8, 'w': 1785.0}, {'u': 4, 'v': 1, 'w': 914.0}, {'u': 9, 'v': 5, 'w': 1258.0}, {'u': 5, 'v': 2, 'w': 178.0}, {'u': 2, 'v': 6, 'w': 1461.0}], 'density': 0.24444444444444444, 'source_file': 'I040.stp', 'terminals': [1, 3, 5, 6]}","[[3, 6], [1, 3], [2, 5], [2, 6]]",35,markdown_table,0
STP,STP,"Many people on the ops crew are trying to work out which fiber lines to put into service so all of the important racks end up reachable through one contiguous fabric. The decision is picking a subset of trunk links to activate; it’s fine to route traffic through other racks or patch points if that reduces cabling. The best selection is the one that ties together every critical rack while producing the lowest total active fiber length — obtained by adding up the lengths of the activated trunks. Every critical rack must be included, trunks are simply on or off (no duplicate counting), and the full layout and lengths come next.

{
  ""total_nodes_in_layout"": 12,
  ""total_trunk_links"": 14,
  ""edges"": [
    {
      ""endpoint_node_a"": 4,
      ""endpoint_node_b"": 5,
      ""trunk_length_meters"": 1181.0
    },
    {
      ""endpoint_node_a"": 4,
      ""endpoint_node_b"": 6,
      ""trunk_length_meters"": 444.0
    },
    {
      ""endpoint_node_a"": 4,
      ""endpoint_node_b"": 8,
      ""trunk_length_meters"": 238369.0
    },
    {
      ""endpoint_node_a"": 5,
      ""endpoint_node_b"": 12,
      ""trunk_length_meters"": 366.0
    },
    {
      ""endpoint_node_a"": 5,
      ""endpoint_node_b"": 9,
      ""trunk_length_meters"": 707.0
    },
    {
      ""endpoint_node_a"": 6,
      ""endpoint_node_b"": 3,
      ""trunk_length_meters"": 1005.0
    },
    {
      ""endpoint_node_a"": 10,
      ""endpoint_node_b"": 2,
      ""trunk_length_meters"": 571.0
    },
    {
      ""endpoint_node_a"": 10,
      ""endpoint_node_b"": 11,
      ""trunk_length_meters"": 506.0
    },
    {
      ""endpoint_node_a"": 7,
      ""endpoint_node_b"": 8,
      ""trunk_length_meters"": 239523.0
    },
    {
      ""endpoint_node_a"": 7,
      ""endpoint_node_b"": 9,
      ""trunk_length_meters"": 1196.0
    },
    {
      ""endpoint_node_a"": 12,
      ""endpoint_node_b"": 11,
      ""trunk_length_meters"": 31.0
    },
    {
      ""endpoint_node_a"": 1,
      ""endpoint_node_b"": 2,
      ""trunk_length_meters"": 656.0
    },
    {
      ""endpoint_node_a"": 1,
      ""endpoint_node_b"": 3,
      ""trunk_length_meters"": 592.0
    },
    {
      ""endpoint_node_a"": 3,
      ""endpoint_node_b"": 11,
      ""trunk_length_meters"": 159.0
    }
  ],
  ""critical_racks"": [
    5,
    8
  ]
}

Oh — and when you send the answer back, just use this simple JSON layout so I can read it automatically:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This ""solution"" list is just a plain list of trunks to activate. Each inner pair [u, v] denotes a single trunk between node u and node v that you want turned on so the important racks end up connected. Think of it like filling out a short checklist of links rather than a big report.

This JSON is only a sketch of the shape I expect — not the actual set of links. Please use the exact node 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”.","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 4, 'v': 5, 'w': 1181.0}, {'u': 4, 'v': 6, 'w': 444.0}, {'u': 4, 'v': 8, 'w': 238369.0}, {'u': 5, 'v': 12, 'w': 366.0}, {'u': 5, 'v': 9, 'w': 707.0}, {'u': 6, 'v': 3, 'w': 1005.0}, {'u': 10, 'v': 2, 'w': 571.0}, {'u': 10, 'v': 11, 'w': 506.0}, {'u': 7, 'v': 8, 'w': 239523.0}, {'u': 7, 'v': 9, 'w': 1196.0}, {'u': 12, 'v': 11, 'w': 31.0}, {'u': 1, 'v': 2, 'w': 656.0}, {'u': 1, 'v': 3, 'w': 592.0}, {'u': 3, 'v': 11, 'w': 159.0}], 'terminals': [5, 8], 'source_file': 'I049.stp', 'density': 0.21212121212121213, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0035.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0035.png'}","[[4, 5], [4, 8]]",239550.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 14, 'edges': [{'u': 4, 'v': 5, 'w': 1181.0}, {'u': 4, 'v': 6, 'w': 444.0}, {'u': 4, 'v': 8, 'w': 238369.0}, {'u': 5, 'v': 12, 'w': 366.0}, {'u': 5, 'v': 9, 'w': 707.0}, {'u': 6, 'v': 3, 'w': 1005.0}, {'u': 10, 'v': 2, 'w': 571.0}, {'u': 10, 'v': 11, 'w': 506.0}, {'u': 7, 'v': 8, 'w': 239523.0}, {'u': 7, 'v': 9, 'w': 1196.0}, {'u': 12, 'v': 11, 'w': 31.0}, {'u': 1, 'v': 2, 'w': 656.0}, {'u': 1, 'v': 3, 'w': 592.0}, {'u': 3, 'v': 11, 'w': 159.0}], 'density': 0.21212121212121213, 'source_file': 'I049.stp', 'terminals': [5, 8]}","[[4, 5], [4, 8]]",36,json,1
STP,STP,"Picture this: the safety office wants a single, continuous pedestrian route that touches every emergency shelter, and the job is to choose which sidewalks, side streets, and plazas to clear to make that happen. What makes one selection better than another is the total length of pavement that ends up cleared — add up the lengths of the chosen sidewalks to get that total, and smaller is better. The chosen stretches must form one unbroken network hitting every shelter (nothing left out and no disconnected pieces), and cleared segments are counted only once; the concrete map and lengths follow below.

{
  ""total_intersections_and_plazas"": 15,
  ""total_sidewalk_and_street_segments"": 18,
  ""edges"": [
    {
      ""segment_endpoint_node_u"": 13,
      ""segment_endpoint_node_v"": 14,
      ""segment_length_meters"": 610.0
    },
    {
      ""segment_endpoint_node_u"": 13,
      ""segment_endpoint_node_v"": 15,
      ""segment_length_meters"": 8026.0
    },
    {
      ""segment_endpoint_node_u"": 12,
      ""segment_endpoint_node_v"": 11,
      ""segment_length_meters"": 16218.0
    },
    {
      ""segment_endpoint_node_u"": 7,
      ""segment_endpoint_node_v"": 8,
      ""segment_length_meters"": 437.0
    },
    {
      ""segment_endpoint_node_u"": 7,
      ""segment_endpoint_node_v"": 10,
      ""segment_length_meters"": 507.0
    },
    {
      ""segment_endpoint_node_u"": 7,
      ""segment_endpoint_node_v"": 9,
      ""segment_length_meters"": 508.0
    },
    {
      ""segment_endpoint_node_u"": 15,
      ""segment_endpoint_node_v"": 14,
      ""segment_length_meters"": 7848.0
    },
    {
      ""segment_endpoint_node_u"": 15,
      ""segment_endpoint_node_v"": 10,
      ""segment_length_meters"": 7421.0
    },
    {
      ""segment_endpoint_node_u"": 11,
      ""segment_endpoint_node_v"": 3,
      ""segment_length_meters"": 1750.0
    },
    {
      ""segment_endpoint_node_u"": 11,
      ""segment_endpoint_node_v"": 8,
      ""segment_length_meters"": 8092.0
    },
    {
      ""segment_endpoint_node_u"": 8,
      ""segment_endpoint_node_v"": 9,
      ""segment_length_meters"": 294.0
    },
    {
      ""segment_endpoint_node_u"": 10,
      ""segment_endpoint_node_v"": 2,
      ""segment_length_meters"": 10227.0
    },
    {
      ""segment_endpoint_node_u"": 2,
      ""segment_endpoint_node_v"": 1,
      ""segment_length_meters"": 1195.0
    },
    {
      ""segment_endpoint_node_u"": 2,
      ""segment_endpoint_node_v"": 5,
      ""segment_length_meters"": 852.0
    },
    {
      ""segment_endpoint_node_u"": 1,
      ""segment_endpoint_node_v"": 6,
      ""segment_length_meters"": 547.0
    },
    {
      ""segment_endpoint_node_u"": 1,
      ""segment_endpoint_node_v"": 4,
      ""segment_length_meters"": 10427.0
    },
    {
      ""segment_endpoint_node_u"": 3,
      ""segment_endpoint_node_v"": 4,
      ""segment_length_meters"": 1280.0
    },
    {
      ""segment_endpoint_node_u"": 5,
      ""segment_endpoint_node_v"": 6,
      ""segment_length_meters"": 1097.0
    }
  ],
  ""shelter_node_ids"": [
    4,
    5,
    6,
    9,
    10,
    11,
    15
  ]
}

If you want to hand me the set of cleared stretches in a machine-friendly way, just use a tiny JSON snippet like this:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as the checklist of sidewalk segments to clear. Each little pair [u, v] is one segment connecting location u to location v — just list the segments you pick. This block is only a sketch of the shape I expect, not the actual answer.

Please make sure to 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”.""","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 18, 'edges': [{'u': 13, 'v': 14, 'w': 610.0}, {'u': 13, 'v': 15, 'w': 8026.0}, {'u': 12, 'v': 11, 'w': 16218.0}, {'u': 7, 'v': 8, 'w': 437.0}, {'u': 7, 'v': 10, 'w': 507.0}, {'u': 7, 'v': 9, 'w': 508.0}, {'u': 15, 'v': 14, 'w': 7848.0}, {'u': 15, 'v': 10, 'w': 7421.0}, {'u': 11, 'v': 3, 'w': 1750.0}, {'u': 11, 'v': 8, 'w': 8092.0}, {'u': 8, 'v': 9, 'w': 294.0}, {'u': 10, 'v': 2, 'w': 10227.0}, {'u': 2, 'v': 1, 'w': 1195.0}, {'u': 2, 'v': 5, 'w': 852.0}, {'u': 1, 'v': 6, 'w': 547.0}, {'u': 1, 'v': 4, 'w': 10427.0}, {'u': 3, 'v': 4, 'w': 1280.0}, {'u': 5, 'v': 6, 'w': 1097.0}], 'terminals': [4, 5, 6, 9, 10, 11, 15], 'source_file': 'I014.stp', 'density': 0.17142857142857143, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0036.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0036.png'}","[[7, 8], [7, 10], [10, 15], [3, 11], [8, 11], [8, 9], [1, 6], [1, 4], [3, 4], [5, 6]]",31852.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 18, 'edges': [{'u': 13, 'v': 14, 'w': 610.0}, {'u': 13, 'v': 15, 'w': 8026.0}, {'u': 12, 'v': 11, 'w': 16218.0}, {'u': 7, 'v': 8, 'w': 437.0}, {'u': 7, 'v': 10, 'w': 507.0}, {'u': 7, 'v': 9, 'w': 508.0}, {'u': 15, 'v': 14, 'w': 7848.0}, {'u': 15, 'v': 10, 'w': 7421.0}, {'u': 11, 'v': 3, 'w': 1750.0}, {'u': 11, 'v': 8, 'w': 8092.0}, {'u': 8, 'v': 9, 'w': 294.0}, {'u': 10, 'v': 2, 'w': 10227.0}, {'u': 2, 'v': 1, 'w': 1195.0}, {'u': 2, 'v': 5, 'w': 852.0}, {'u': 1, 'v': 6, 'w': 547.0}, {'u': 1, 'v': 4, 'w': 10427.0}, {'u': 3, 'v': 4, 'w': 1280.0}, {'u': 5, 'v': 6, 'w': 1097.0}], 'density': 0.17142857142857143, 'source_file': 'I014.stp', 'terminals': [4, 5, 6, 9, 10, 11, 15]}","[[7, 8], [7, 10], [10, 15], [3, 11], [8, 11], [8, 9], [1, 6], [1, 4], [3, 4], [5, 6]]",37,json,1
STP,STP,"We’re planning the wiring of a new gallery and need to choose which display links to install so every interactive point is part of a single tour loop. It’s okay to run lines through other rooms to join things up, but the goal is to keep the total length of installed connectors as small as possible; the score for any layout is simply the sum of the lengths of the connectors used. Every interactive station must be connected into that one circuit, and no connector should be counted twice. The exact layout and measurements are listed below.

# total_gallery_nodes=11
# total_possible_connectors=15
# interactive_stations=4 5
endpoint_node_a,endpoint_node_b,connector_length
5,6,363.0
5,8,202737.0
5,11,820.0
6,11,470.0
6,4,920.0
10,3,408.0
10,9,182.0
10,7,493.0
11,7,9150.0
7,9,648.0
1,3,27225.0
1,4,16790.0
8,4,203399.0
9,2,409.0
2,3,215.0

Oh — when you reply, please stick to this simple JSON shape so I can read your layout easily:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

The ""solution"" entry should be a list of connector pairs. Each pair [u1, v1] means ""run a connector between station u1 and station v1"" — so you're just listing which links to install. This block is just a sketch of the expected shape, not the actual wiring plan.

Please make sure to use the exact identifiers from the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 15, 'edges': [{'u': 5, 'v': 6, 'w': 363.0}, {'u': 5, 'v': 8, 'w': 202737.0}, {'u': 5, 'v': 11, 'w': 820.0}, {'u': 6, 'v': 11, 'w': 470.0}, {'u': 6, 'v': 4, 'w': 920.0}, {'u': 10, 'v': 3, 'w': 408.0}, {'u': 10, 'v': 9, 'w': 182.0}, {'u': 10, 'v': 7, 'w': 493.0}, {'u': 11, 'v': 7, 'w': 9150.0}, {'u': 7, 'v': 9, 'w': 648.0}, {'u': 1, 'v': 3, 'w': 27225.0}, {'u': 1, 'v': 4, 'w': 16790.0}, {'u': 8, 'v': 4, 'w': 203399.0}, {'u': 9, 'v': 2, 'w': 409.0}, {'u': 2, 'v': 3, 'w': 215.0}], 'terminals': [4, 5], 'source_file': 'I053.stp', 'density': 0.2727272727272727, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0037.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0037.png'}","[[5, 6], [4, 6]]",1283.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 15, 'edges': [{'u': 5, 'v': 6, 'w': 363.0}, {'u': 5, 'v': 8, 'w': 202737.0}, {'u': 5, 'v': 11, 'w': 820.0}, {'u': 6, 'v': 11, 'w': 470.0}, {'u': 6, 'v': 4, 'w': 920.0}, {'u': 10, 'v': 3, 'w': 408.0}, {'u': 10, 'v': 9, 'w': 182.0}, {'u': 10, 'v': 7, 'w': 493.0}, {'u': 11, 'v': 7, 'w': 9150.0}, {'u': 7, 'v': 9, 'w': 648.0}, {'u': 1, 'v': 3, 'w': 27225.0}, {'u': 1, 'v': 4, 'w': 16790.0}, {'u': 8, 'v': 4, 'w': 203399.0}, {'u': 9, 'v': 2, 'w': 409.0}, {'u': 2, 'v': 3, 'w': 215.0}], 'density': 0.2727272727272727, 'source_file': 'I053.stp', 'terminals': [4, 5]}","[[5, 6], [4, 6]]",38,csv,1
STP,STP,"I’m imagining a city planner staring at a map, deciding which streets to pave so every neighborhood hub ends up linked by one continuous paved route. The idea is to pick a set of streets that reaches all the hubs, letting other intersections be used as little junctions where helpful, and then check the plan by adding up the lengths of the streets chosen — the smaller that total sum, the better the plan. Every hub must be on the paved network, each selected street only counts once when totaling length, and the specific streets and their lengths are shown below.

# total_intersections=12
# candidate_streets=12
# neighborhood_hubs=1 7 11 12
intersection_a,intersection_b,street_length
4,12,642.0
12,8,650.0
12,11,274.0
12,5,1194.0
5,6,912.0
2,1,942.0
2,9,247.0
2,6,1444.0
6,3,420.0
7,8,539.0
1,9,1186.0
3,10,882.0

If you want to hand me the final plan in a machine-friendly way, just follow this simple shape:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This ""solution"" list is just a list of streets to pave, each street given as a pair of endpoint identifiers. Think of each [u, v] as ""pave the street between intersection u and intersection v."" This is only a sketch of the expected shape — not the actual answer itself.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 12, 'edges': [{'u': 4, 'v': 12, 'w': 642.0}, {'u': 12, 'v': 8, 'w': 650.0}, {'u': 12, 'v': 11, 'w': 274.0}, {'u': 12, 'v': 5, 'w': 1194.0}, {'u': 5, 'v': 6, 'w': 912.0}, {'u': 2, 'v': 1, 'w': 942.0}, {'u': 2, 'v': 9, 'w': 247.0}, {'u': 2, 'v': 6, 'w': 1444.0}, {'u': 6, 'v': 3, 'w': 420.0}, {'u': 7, 'v': 8, 'w': 539.0}, {'u': 1, 'v': 9, 'w': 1186.0}, {'u': 3, 'v': 10, 'w': 882.0}], 'terminals': [1, 7, 11, 12], 'source_file': 'I070.stp', 'density': 0.18181818181818182, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0038.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0038.png'}","[[8, 12], [11, 12], [5, 12], [5, 6], [1, 2], [2, 6], [7, 8]]",5955.0,"{'problem_type': 'STP', 'num_nodes': 12, 'num_edges': 12, 'edges': [{'u': 4, 'v': 12, 'w': 642.0}, {'u': 12, 'v': 8, 'w': 650.0}, {'u': 12, 'v': 11, 'w': 274.0}, {'u': 12, 'v': 5, 'w': 1194.0}, {'u': 5, 'v': 6, 'w': 912.0}, {'u': 2, 'v': 1, 'w': 942.0}, {'u': 2, 'v': 9, 'w': 247.0}, {'u': 2, 'v': 6, 'w': 1444.0}, {'u': 6, 'v': 3, 'w': 420.0}, {'u': 7, 'v': 8, 'w': 539.0}, {'u': 1, 'v': 9, 'w': 1186.0}, {'u': 3, 'v': 10, 'w': 882.0}], 'density': 0.18181818181818182, 'source_file': 'I070.stp', 'terminals': [1, 7, 11, 12]}","[[8, 12], [11, 12], [5, 12], [5, 6], [1, 2], [2, 6], [7, 8]]",39,csv,1
STP,STP,"A last-minute rethink meant choosing a set of walkways that would join every stage and vendor area into one neat network, with the option to add a few temporary link points where they save money. The question was which exact paths to construct; a better plan is the one that connects all required spots and ends up costing the least overall — tally the construction costs of the selected walkways and prefer the plan with the smallest sum. All stages and vendors must be included in the network, and the same connection can’t be counted twice to game the total. The exact map and cost breakdown are down below.

# total_locations=15
# candidate_walkways_count=18
# required_spots=G J M
endpoint_a,endpoint_b,construction_cost
K,C,7186.0
I,J,1550.0
I,N,1241.0
D,A,110.0
D,J,366.0
D,C,1305.0
J,H,1276.0
M,L,851.0
M,E,1242.0
M,O,2020.0
O,F,948.0
O,N,993.0
H,G,1445.0
H,B,1432.0
H,C,364.0
G,B,194.0
A,E,1132.0
E,N,1915.0

When you’re ready to send the chosen set of walkways, just follow this simple JSON layout so it’s easy to read and check:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as a list of edge pairs — each [u, v] is a walkway joining node u and node v. Fill that list with the pairs you picked for the event map. It’s just a sketch of the expected shape, not the actual answer itself.

Please use the node 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”.""","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 18, 'edges': [{'u': 11, 'v': 3, 'w': 7186.0}, {'u': 9, 'v': 10, 'w': 1550.0}, {'u': 9, 'v': 14, 'w': 1241.0}, {'u': 4, 'v': 1, 'w': 110.0}, {'u': 4, 'v': 10, 'w': 366.0}, {'u': 4, 'v': 3, 'w': 1305.0}, {'u': 10, 'v': 8, 'w': 1276.0}, {'u': 13, 'v': 12, 'w': 851.0}, {'u': 13, 'v': 5, 'w': 1242.0}, {'u': 13, 'v': 15, 'w': 2020.0}, {'u': 15, 'v': 6, 'w': 948.0}, {'u': 15, 'v': 14, 'w': 993.0}, {'u': 8, 'v': 7, 'w': 1445.0}, {'u': 8, 'v': 2, 'w': 1432.0}, {'u': 8, 'v': 3, 'w': 364.0}, {'u': 7, 'v': 2, 'w': 194.0}, {'u': 1, 'v': 5, 'w': 1132.0}, {'u': 5, 'v': 14, 'w': 1915.0}], 'terminals': [7, 10, 13], 'source_file': 'I020.stp', 'density': 0.17142857142857143, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0039.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0039.png'}","[[1, 4], [4, 10], [8, 10], [5, 13], [7, 8], [1, 5]]",5571.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 18, 'edges': [{'u': 'K', 'v': 'C', 'w': 7186.0}, {'u': 'I', 'v': 'J', 'w': 1550.0}, {'u': 'I', 'v': 'N', 'w': 1241.0}, {'u': 'D', 'v': 'A', 'w': 110.0}, {'u': 'D', 'v': 'J', 'w': 366.0}, {'u': 'D', 'v': 'C', 'w': 1305.0}, {'u': 'J', 'v': 'H', 'w': 1276.0}, {'u': 'M', 'v': 'L', 'w': 851.0}, {'u': 'M', 'v': 'E', 'w': 1242.0}, {'u': 'M', 'v': 'O', 'w': 2020.0}, {'u': 'O', 'v': 'F', 'w': 948.0}, {'u': 'O', 'v': 'N', 'w': 993.0}, {'u': 'H', 'v': 'G', 'w': 1445.0}, {'u': 'H', 'v': 'B', 'w': 1432.0}, {'u': 'H', 'v': 'C', 'w': 364.0}, {'u': 'G', 'v': 'B', 'w': 194.0}, {'u': 'A', 'v': 'E', 'w': 1132.0}, {'u': 'E', 'v': 'N', 'w': 1915.0}], 'density': 0.17142857142857143, 'source_file': 'I020.stp', 'terminals': ['G', 'J', 'M']}","[['A', 'D'], ['D', 'J'], ['H', 'J'], ['E', 'M'], ['G', 'H'], ['A', 'E']]",40,csv,names
STP,STP,"I’m looking at a building map and the goal is to activate certain fiber runs so that all the listed offices are connected into a single, continuous network while keeping the sum of cable lengths as low as possible. To compare layouts, just total the lengths of the activated runs; the lowest total is preferable. Intermediate closets or junctions can be used to make links shorter, but every required office must be connected and nothing can be left out or split off. The full layout and measurements are provided below.

I count 15 distinct locations, 16 candidate cable runs, and the offices that must be connected are A D E F H K M.
I see a cable run between L and M with length 1245.0.
I see a cable run between M and H with length 692.0.
I see a cable run between M and D with length 1774.0.
I see a cable run between K and E with length 326386.0.
I see a cable run between K and H with length 326096.0.
I see a cable run between E and F with length 702.0.
I see a cable run between E and G with length 141.0.
I see a cable run between F and O with length 139.0.
I see a cable run between F and B with length 617.0.
I see a cable run between G and O with length 701.0.
I see a cable run between G and I with length 48.0.
I see a cable run between H and N with length 710.0.
I see a cable run between N and C with length 1403.0.
I see a cable run between N and B with length 268.0.
I see a cable run between B and A with length 1725.0.
I see a cable run between O and J with length 173.0.
I'll total activated run lengths to compare layouts and choose the lowest-sum solution.

Also, when you send the chosen layout back, a nice compact way to list the activated runs is with a little JSON sketch like this:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This just means ""solution"" is a list of cable runs to switch on; each pair like [u1, v1] is the run between endpoint u1 and endpoint v1. Treat the u1, v1 entries above as placeholders — the real reply should replace those placeholders with the actual endpoint labels from the map.

This JSON is only a sketch of the shape I want, not the actual answer. Please use the exact identifiers from the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 16, 'edges': [{'u': 12, 'v': 13, 'w': 1245.0}, {'u': 13, 'v': 8, 'w': 692.0}, {'u': 13, 'v': 4, 'w': 1774.0}, {'u': 11, 'v': 5, 'w': 326386.0}, {'u': 11, 'v': 8, 'w': 326096.0}, {'u': 5, 'v': 6, 'w': 702.0}, {'u': 5, 'v': 7, 'w': 141.0}, {'u': 6, 'v': 15, 'w': 139.0}, {'u': 6, 'v': 2, 'w': 617.0}, {'u': 7, 'v': 15, 'w': 701.0}, {'u': 7, 'v': 9, 'w': 48.0}, {'u': 8, 'v': 14, 'w': 710.0}, {'u': 14, 'v': 3, 'w': 1403.0}, {'u': 14, 'v': 2, 'w': 268.0}, {'u': 2, 'v': 1, 'w': 1725.0}, {'u': 15, 'v': 10, 'w': 173.0}], 'terminals': [1, 4, 5, 6, 8, 11, 13], 'source_file': 'I016.stp', 'density': 0.1523809523809524, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0040.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0040.png'}","[[8, 13], [4, 13], [8, 11], [5, 6], [2, 6], [8, 14], [2, 14], [1, 2]]",332584.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 16, 'edges': [{'u': 'L', 'v': 'M', 'w': 1245.0}, {'u': 'M', 'v': 'H', 'w': 692.0}, {'u': 'M', 'v': 'D', 'w': 1774.0}, {'u': 'K', 'v': 'E', 'w': 326386.0}, {'u': 'K', 'v': 'H', 'w': 326096.0}, {'u': 'E', 'v': 'F', 'w': 702.0}, {'u': 'E', 'v': 'G', 'w': 141.0}, {'u': 'F', 'v': 'O', 'w': 139.0}, {'u': 'F', 'v': 'B', 'w': 617.0}, {'u': 'G', 'v': 'O', 'w': 701.0}, {'u': 'G', 'v': 'I', 'w': 48.0}, {'u': 'H', 'v': 'N', 'w': 710.0}, {'u': 'N', 'v': 'C', 'w': 1403.0}, {'u': 'N', 'v': 'B', 'w': 268.0}, {'u': 'B', 'v': 'A', 'w': 1725.0}, {'u': 'O', 'v': 'J', 'w': 173.0}], 'density': 0.1523809523809524, 'source_file': 'I016.stp', 'terminals': ['A', 'D', 'E', 'F', 'H', 'K', 'M']}","[['H', 'M'], ['D', 'M'], ['H', 'K'], ['E', 'F'], ['B', 'F'], ['H', 'N'], ['B', 'N'], ['A', 'B']]",41,markdown_table,names
STP,STP,"In one planning job the engineers have to pick microwave link hops that will join all required cell sites into a single operational backbone, and there are optional relay towers available to route around expensive direct links. The plan must include every required site in that one connected structure — nothing omitted — and using those extra towers is allowed if it reduces the expenses. To rank different plans, sum the cost of each activated hop to get the total cost; the plan with the smallest total cost is preferred, and duplicate selections of the same hop don’t change the cost. The concrete network and costs are shown below.

It comprises 10 distinct towers, 12 candidate hops, and the required cell sites are 2 3 10.
A candidate microwave hop connects 4 and 9 with activation cost 567.0.
A candidate microwave hop connects 4 and 5 with activation cost 662.0.
A candidate microwave hop connects 4 and 6 with activation cost 780.0.
A candidate microwave hop connects 5 and 9 with activation cost 96.0.
A candidate microwave hop connects 5 and 3 with activation cost 1176.0.
A candidate microwave hop connects 6 and 2 with activation cost 788.0.
A candidate microwave hop connects 2 and 7 with activation cost 274167.0.
A candidate microwave hop connects 2 and 10 with activation cost 2409.0.
A candidate microwave hop connects 2 and 8 with activation cost 2143.0.
A candidate microwave hop connects 3 and 1 with activation cost 791.0.
A candidate microwave hop connects 3 and 7 with activation cost 274634.0.
A candidate microwave hop connects 8 and 1 with activation cost 491.0.
The engineers will assemble these hops into one connected backbone that includes every 2 3 10 and minimizes the total activated hop cost.

Also, when you send the actual plan back, please stick to this simple JSON layout so whatever reads it knows where to look. Here's the shape I expect:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

This just means ""solution"" is a list of hops to activate; each inner pair is one link between two sites (the order in a pair doesn't matter). Think of it like filling out a short form: list each chosen hop as its two endpoint identifiers. This block is just a sketch of the shape I want — not the real 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”.""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 12, 'edges': [{'u': 4, 'v': 9, 'w': 567.0}, {'u': 4, 'v': 5, 'w': 662.0}, {'u': 4, 'v': 6, 'w': 780.0}, {'u': 5, 'v': 9, 'w': 96.0}, {'u': 5, 'v': 3, 'w': 1176.0}, {'u': 6, 'v': 2, 'w': 788.0}, {'u': 2, 'v': 7, 'w': 274167.0}, {'u': 2, 'v': 10, 'w': 2409.0}, {'u': 2, 'v': 8, 'w': 2143.0}, {'u': 3, 'v': 1, 'w': 791.0}, {'u': 3, 'v': 7, 'w': 274634.0}, {'u': 8, 'v': 1, 'w': 491.0}], 'terminals': [2, 3, 10], 'source_file': 'I050.stp', 'density': 0.26666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0041.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0041.png'}","[[4, 5], [4, 6], [3, 5], [2, 6], [2, 10]]",5815.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 12, 'edges': [{'u': 4, 'v': 9, 'w': 567.0}, {'u': 4, 'v': 5, 'w': 662.0}, {'u': 4, 'v': 6, 'w': 780.0}, {'u': 5, 'v': 9, 'w': 96.0}, {'u': 5, 'v': 3, 'w': 1176.0}, {'u': 6, 'v': 2, 'w': 788.0}, {'u': 2, 'v': 7, 'w': 274167.0}, {'u': 2, 'v': 10, 'w': 2409.0}, {'u': 2, 'v': 8, 'w': 2143.0}, {'u': 3, 'v': 1, 'w': 791.0}, {'u': 3, 'v': 7, 'w': 274634.0}, {'u': 8, 'v': 1, 'w': 491.0}], 'density': 0.26666666666666666, 'source_file': 'I050.stp', 'terminals': [2, 3, 10]}","[[4, 5], [4, 6], [3, 5], [2, 6], [2, 10]]",42,markdown_table,1
STP,STP,"Recently the curator had to figure out which doors and passages to open so visitors can stroll through all the exhibit halls without gaps. The approach allows linking halls directly or via foyers, and the simplest, most efficient setup is the one with the lowest sum of corridor lengths opened. The total is calculated by summing every opened corridor’s length, and every hall must be connected into that single network with no repeats. The actual map and lengths are shown below.

On this map there are 15 distinct locations, 17 candidate corridors, and the exhibit halls that must be connected are 0 11 13.
Corridor option between 14 and 8 has length 1457.0.
Corridor option between 14 and 11 has length 5351.0.
Corridor option between 14 and 4 has length 93.0.
Corridor option between 4 and 5 has length 9856.0.
Corridor option between 4 and 10 has length 1769.0.
Corridor option between 5 and 2 has length 1294.0.
Corridor option between 5 and 3 has length 2661.0.
Corridor option between 0 and 11 has length 16292.0.
Corridor option between 6 and 13 has length 14965.0.
Corridor option between 11 and 7 has length 2277.0.
Corridor option between 1 and 8 has length 3332.0.
Corridor option between 1 and 10 has length 903.0.
Corridor option between 7 and 8 has length 2159.0.
Corridor option between 7 and 13 has length 22995.0.
Corridor option between 12 and 10 has length 10167.0.
Corridor option between 12 and 9 has length 12084.0.
Corridor option between 12 and 3 has length 2657.0.
The curator will select the set of corridors with the smallest total length that connects all 0 11 13.

Also, to keep things tidy, please give the chosen corridors in a simple JSON layout like this:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of this as a little form: ""solution"" is the list, and each pair [u, v] is a corridor to open between hall u and hall v. This is just the shape I want — a sketch of the expected format, not the actual set of corridors.

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"".","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 15, 'v': 9, 'w': 1457.0}, {'u': 15, 'v': 12, 'w': 5351.0}, {'u': 15, 'v': 5, 'w': 93.0}, {'u': 5, 'v': 6, 'w': 9856.0}, {'u': 5, 'v': 11, 'w': 1769.0}, {'u': 6, 'v': 3, 'w': 1294.0}, {'u': 6, 'v': 4, 'w': 2661.0}, {'u': 1, 'v': 12, 'w': 16292.0}, {'u': 7, 'v': 14, 'w': 14965.0}, {'u': 12, 'v': 8, 'w': 2277.0}, {'u': 2, 'v': 9, 'w': 3332.0}, {'u': 2, 'v': 11, 'w': 903.0}, {'u': 8, 'v': 9, 'w': 2159.0}, {'u': 8, 'v': 14, 'w': 22995.0}, {'u': 13, 'v': 11, 'w': 10167.0}, {'u': 13, 'v': 10, 'w': 12084.0}, {'u': 13, 'v': 4, 'w': 2657.0}], 'terminals': [1, 12, 14], 'source_file': 'I005.stp', 'density': 0.1619047619047619, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0042.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0042.png'}","[[1, 12], [8, 12], [8, 14]]",41564.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 17, 'edges': [{'u': 14, 'v': 8, 'w': 1457.0}, {'u': 14, 'v': 11, 'w': 5351.0}, {'u': 14, 'v': 4, 'w': 93.0}, {'u': 4, 'v': 5, 'w': 9856.0}, {'u': 4, 'v': 10, 'w': 1769.0}, {'u': 5, 'v': 2, 'w': 1294.0}, {'u': 5, 'v': 3, 'w': 2661.0}, {'u': 0, 'v': 11, 'w': 16292.0}, {'u': 6, 'v': 13, 'w': 14965.0}, {'u': 11, 'v': 7, 'w': 2277.0}, {'u': 1, 'v': 8, 'w': 3332.0}, {'u': 1, 'v': 10, 'w': 903.0}, {'u': 7, 'v': 8, 'w': 2159.0}, {'u': 7, 'v': 13, 'w': 22995.0}, {'u': 12, 'v': 10, 'w': 10167.0}, {'u': 12, 'v': 9, 'w': 12084.0}, {'u': 12, 'v': 3, 'w': 2657.0}], 'density': 0.1619047619047619, 'source_file': 'I005.stp', 'terminals': [0, 11, 13]}","[[0, 11], [7, 11], [7, 13]]",43,markdown_table,0
STP,STP,"Imagine laying out a network of footpaths and bridges that connects every lecture hall and lab so students can walk from any building to any other. The choice comes down to which connections to build; the best option keeps the total length of new walkways as low as possible — compute that by summing the lengths of the chosen bridges and paths. Plazas can act as extra connection points to save length, and every academic building needs to be part of the network with no unnecessary repeats. The exact campus diagram and distances are shown below.

{
  ""total_sites"": 14,
  ""total_candidate_paths"": 16,
  ""edges"": [
    {
      ""endpoint_a"": 0,
      ""endpoint_b"": 6,
      ""path_length_meters"": 2226.0
    },
    {
      ""endpoint_a"": 0,
      ""endpoint_b"": 1,
      ""path_length_meters"": 1829.0
    },
    {
      ""endpoint_a"": 1,
      ""endpoint_b"": 4,
      ""path_length_meters"": 631.0
    },
    {
      ""endpoint_a"": 1,
      ""endpoint_b"": 9,
      ""path_length_meters"": 623.0
    },
    {
      ""endpoint_a"": 2,
      ""endpoint_b"": 3,
      ""path_length_meters"": 1035.0
    },
    {
      ""endpoint_a"": 2,
      ""endpoint_b"": 4,
      ""path_length_meters"": 971.0
    },
    {
      ""endpoint_a"": 3,
      ""endpoint_b"": 7,
      ""path_length_meters"": 632.0
    },
    {
      ""endpoint_a"": 3,
      ""endpoint_b"": 12,
      ""path_length_meters"": 1522.0
    },
    {
      ""endpoint_a"": 4,
      ""endpoint_b"": 8,
      ""path_length_meters"": 581.0
    },
    {
      ""endpoint_a"": 6,
      ""endpoint_b"": 12,
      ""path_length_meters"": 215.0
    },
    {
      ""endpoint_a"": 12,
      ""endpoint_b"": 13,
      ""path_length_meters"": 1187.0
    },
    {
      ""endpoint_a"": 5,
      ""endpoint_b"": 11,
      ""path_length_meters"": 367.0
    },
    {
      ""endpoint_a"": 5,
      ""endpoint_b"": 8,
      ""path_length_meters"": 1240.0
    },
    {
      ""endpoint_a"": 7,
      ""endpoint_b"": 11,
      ""path_length_meters"": 1107.0
    },
    {
      ""endpoint_a"": 7,
      ""endpoint_b"": 8,
      ""path_length_meters"": 155.0
    },
    {
      ""endpoint_a"": 11,
      ""endpoint_b"": 10,
      ""path_length_meters"": 536.0
    }
  ],
  ""required_academic_buildings"": [
    0,
    1,
    3,
    7,
    8,
    10,
    12
  ]
}

Also, when you send back the set of connections, it's easiest for me (and any tools reading this) if you pack them into a tiny JSON object with one field called ""solution"". Here's the shape I expect:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of that as a simple form: ""solution"" is the list, and each pair like [u1, v1] is one path or bridge linking two buildings or plazas. It's just a sketch of the format — not the real answer — so replace those placeholders with the actual pairs for your layout.

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”.""","{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 16, 'edges': [{'u': 1, 'v': 7, 'w': 2226.0}, {'u': 1, 'v': 2, 'w': 1829.0}, {'u': 2, 'v': 5, 'w': 631.0}, {'u': 2, 'v': 10, 'w': 623.0}, {'u': 3, 'v': 4, 'w': 1035.0}, {'u': 3, 'v': 5, 'w': 971.0}, {'u': 4, 'v': 8, 'w': 632.0}, {'u': 4, 'v': 13, 'w': 1522.0}, {'u': 5, 'v': 9, 'w': 581.0}, {'u': 7, 'v': 13, 'w': 215.0}, {'u': 13, 'v': 14, 'w': 1187.0}, {'u': 6, 'v': 12, 'w': 367.0}, {'u': 6, 'v': 9, 'w': 1240.0}, {'u': 8, 'v': 12, 'w': 1107.0}, {'u': 8, 'v': 9, 'w': 155.0}, {'u': 12, 'v': 11, 'w': 536.0}], 'terminals': [1, 2, 4, 8, 9, 11, 13], 'source_file': 'I055.stp', 'density': 0.17582417582417584, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0043.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0043.png'}","[[1, 2], [2, 5], [4, 8], [4, 13], [5, 9], [8, 12], [8, 9], [11, 12]]",6993.0,"{'problem_type': 'STP', 'num_nodes': 14, 'num_edges': 16, 'edges': [{'u': 0, 'v': 6, 'w': 2226.0}, {'u': 0, 'v': 1, 'w': 1829.0}, {'u': 1, 'v': 4, 'w': 631.0}, {'u': 1, 'v': 9, 'w': 623.0}, {'u': 2, 'v': 3, 'w': 1035.0}, {'u': 2, 'v': 4, 'w': 971.0}, {'u': 3, 'v': 7, 'w': 632.0}, {'u': 3, 'v': 12, 'w': 1522.0}, {'u': 4, 'v': 8, 'w': 581.0}, {'u': 6, 'v': 12, 'w': 215.0}, {'u': 12, 'v': 13, 'w': 1187.0}, {'u': 5, 'v': 11, 'w': 367.0}, {'u': 5, 'v': 8, 'w': 1240.0}, {'u': 7, 'v': 11, 'w': 1107.0}, {'u': 7, 'v': 8, 'w': 155.0}, {'u': 11, 'v': 10, 'w': 536.0}], 'density': 0.17582417582417584, 'source_file': 'I055.stp', 'terminals': [0, 1, 3, 7, 8, 10, 12]}","[[0, 1], [1, 4], [3, 7], [3, 12], [4, 8], [7, 11], [7, 8], [10, 11]]",44,json,0
STP,STP,"On a recent survey, the task came down to this: choose which connections to run between parking clusters so they all become part of one connected charging network. Better plans use less cable overall — compute the total by adding up the lengths of the links you decide to install — and you’re free to add intermediate junction boxes to cut overall run length. The requirement is that every cluster is included in the single network, no duplicates in counting cable, and nothing gets left out. The specific layout and distances are shown below.

There are 11 locations and 13 candidate links; the required parking clusters you must span are 0 4 7 8 9.
You may run a cable between 7 and 6 with length 1211.0.
You may run a cable between 7 and 5 with length 89.0.
You may run a cable between 7 and 9 with length 4825.0.
You may run a cable between 4 and 10 with length 118.0.
You may run a cable between 4 and 8 with length 1957.0.
You may run a cable between 4 and 1 with length 1001.0.
You may run a cable between 4 and 2 with length 2279.0.
You may run a cable between 9 and 8 with length 601.0.
You may run a cable between 9 and 10 with length 2079.0.
You may run a cable between 0 and 1 with length 648.0.
You may run a cable between 0 and 3 with length 312826.0.
You may run a cable between 2 and 3 with length 312826.0.
You may run a cable between 8 and 6 with length 4785.0.
As you choose, ensure every cluster in 0 4 7 8 9 is included in one connected network, minimize total cable, and avoid double-counting.

When you send the final plan, just drop the chosen links into this simple JSON shape so it's easy to check and add up the cable length — nothing fancy, just the pairs of nodes you want connected. For example:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is the list of links you'll install; each inner pair is a connection between two clusters or junction boxes (use the node labels from the map exactly as given). This little block is just a sketch of the expected shape — not the real answer itself.

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”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 8, 'v': 7, 'w': 1211.0}, {'u': 8, 'v': 6, 'w': 89.0}, {'u': 8, 'v': 10, 'w': 4825.0}, {'u': 5, 'v': 11, 'w': 118.0}, {'u': 5, 'v': 9, 'w': 1957.0}, {'u': 5, 'v': 2, 'w': 1001.0}, {'u': 5, 'v': 3, 'w': 2279.0}, {'u': 10, 'v': 9, 'w': 601.0}, {'u': 10, 'v': 11, 'w': 2079.0}, {'u': 1, 'v': 2, 'w': 648.0}, {'u': 1, 'v': 4, 'w': 312826.0}, {'u': 3, 'v': 4, 'w': 312826.0}, {'u': 9, 'v': 7, 'w': 4785.0}], 'terminals': [1, 5, 8, 9, 10], 'source_file': 'I030.stp', 'density': 0.23636363636363636, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0044.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0044.png'}","[[8, 10], [5, 9], [2, 5], [9, 10], [1, 2]]",9032.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 13, 'edges': [{'u': 7, 'v': 6, 'w': 1211.0}, {'u': 7, 'v': 5, 'w': 89.0}, {'u': 7, 'v': 9, 'w': 4825.0}, {'u': 4, 'v': 10, 'w': 118.0}, {'u': 4, 'v': 8, 'w': 1957.0}, {'u': 4, 'v': 1, 'w': 1001.0}, {'u': 4, 'v': 2, 'w': 2279.0}, {'u': 9, 'v': 8, 'w': 601.0}, {'u': 9, 'v': 10, 'w': 2079.0}, {'u': 0, 'v': 1, 'w': 648.0}, {'u': 0, 'v': 3, 'w': 312826.0}, {'u': 2, 'v': 3, 'w': 312826.0}, {'u': 8, 'v': 6, 'w': 4785.0}], 'density': 0.23636363636363636, 'source_file': 'I030.stp', 'terminals': [0, 4, 7, 8, 9]}","[[7, 9], [4, 8], [1, 4], [8, 9], [0, 1]]",45,nl,0
STP,STP,"Recently the flooding left several shelters cut off, and the team needed to choose which blocked roads to clear so all shelters were linked together. Clearing through some junctions can make the connections shorter, so the trick is to open just the right combination of streets to minimize how many meters the crews have to clear. Judge any plan by adding up the lengths of the reopened segments — a smaller total is better — and ensure every shelter is part of the network and no redundant segments are cleared. The exact map and distances follow below.

# total_nodes=13
# total_blocked_road_segments=16
# shelter_nodes=A B F
node_u,node_v,clearing_distance_meters
C,D,168.0
C,E,924.0
C,A,211712.0
D,B,452.0
D,M,2717.0
E,F,2686.0
E,G,2246.0
F,H,2507.0
A,B,211508.0
I,G,742.0
I,J,2687.0
J,K,962.0
G,H,700.0
K,L,4689.0
K,B,118.0
L,M,2940.0

When you’re ready to send back the road-clearing plan, just follow this simple JSON layout — nothing fancy, just the shape I expect:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of each [uX, vX] pair as one reopened street between two junctions, and the whole ""solution"" list is the set of streets you'll reopen. This is just a sketch of the expected shape, not the actual answer — fill in the real junction IDs from the instance when you reply.

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”.""","{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 16, 'edges': [{'u': 3, 'v': 4, 'w': 168.0}, {'u': 3, 'v': 5, 'w': 924.0}, {'u': 3, 'v': 1, 'w': 211712.0}, {'u': 4, 'v': 2, 'w': 452.0}, {'u': 4, 'v': 13, 'w': 2717.0}, {'u': 5, 'v': 6, 'w': 2686.0}, {'u': 5, 'v': 7, 'w': 2246.0}, {'u': 6, 'v': 8, 'w': 2507.0}, {'u': 1, 'v': 2, 'w': 211508.0}, {'u': 9, 'v': 7, 'w': 742.0}, {'u': 9, 'v': 10, 'w': 2687.0}, {'u': 10, 'v': 11, 'w': 962.0}, {'u': 7, 'v': 8, 'w': 700.0}, {'u': 11, 'v': 12, 'w': 4689.0}, {'u': 11, 'v': 2, 'w': 118.0}, {'u': 12, 'v': 13, 'w': 2940.0}], 'terminals': [1, 2, 6], 'source_file': 'I020.stp', 'density': 0.20512820512820512, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0045.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0045.png'}","[[3, 4], [3, 5], [2, 4], [5, 6], [1, 2]]",215738.0,"{'problem_type': 'STP', 'num_nodes': 13, 'num_edges': 16, 'edges': [{'u': 'C', 'v': 'D', 'w': 168.0}, {'u': 'C', 'v': 'E', 'w': 924.0}, {'u': 'C', 'v': 'A', 'w': 211712.0}, {'u': 'D', 'v': 'B', 'w': 452.0}, {'u': 'D', 'v': 'M', 'w': 2717.0}, {'u': 'E', 'v': 'F', 'w': 2686.0}, {'u': 'E', 'v': 'G', 'w': 2246.0}, {'u': 'F', 'v': 'H', 'w': 2507.0}, {'u': 'A', 'v': 'B', 'w': 211508.0}, {'u': 'I', 'v': 'G', 'w': 742.0}, {'u': 'I', 'v': 'J', 'w': 2687.0}, {'u': 'J', 'v': 'K', 'w': 962.0}, {'u': 'G', 'v': 'H', 'w': 700.0}, {'u': 'K', 'v': 'L', 'w': 4689.0}, {'u': 'K', 'v': 'B', 'w': 118.0}, {'u': 'L', 'v': 'M', 'w': 2940.0}], 'density': 0.20512820512820512, 'source_file': 'I020.stp', 'terminals': ['A', 'B', 'F']}","[['C', 'D'], ['C', 'E'], ['B', 'D'], ['E', 'F'], ['A', 'B']]",46,csv,names
STP,STP,"Someone has to plan the winter schedule at a resort by switching on a selection of lifts and links so every lodge and slope is reachable from the rest. The sensible plans are the ones that keep the overall operated track length down — just add up the length of every lift and connector that’s in use to see how much running it requires; lower totals win. It’s allowed to use intermediate transfer points to stitch sectors together, and every lodge and slope must be included in that single connected network. The detailed instance — the map and track lengths — is given below.

{
  ""num_stations"": 15,
  ""num_tracks"": 19,
  ""edges"": [
    {
      ""endpoint_u"": 6,
      ""endpoint_v"": 15,
      ""track_length"": 3048.0
    },
    {
      ""endpoint_u"": 6,
      ""endpoint_v"": 5,
      ""track_length"": 3553.0
    },
    {
      ""endpoint_u"": 7,
      ""endpoint_v"": 4,
      ""track_length"": 1813.0
    },
    {
      ""endpoint_u"": 14,
      ""endpoint_v"": 9,
      ""track_length"": 324.0
    },
    {
      ""endpoint_u"": 14,
      ""endpoint_v"": 5,
      ""track_length"": 542.0
    },
    {
      ""endpoint_u"": 14,
      ""endpoint_v"": 13,
      ""track_length"": 457.0
    },
    {
      ""endpoint_u"": 11,
      ""endpoint_v"": 3,
      ""track_length"": 344.0
    },
    {
      ""endpoint_u"": 11,
      ""endpoint_v"": 12,
      ""track_length"": 331.0
    },
    {
      ""endpoint_u"": 8,
      ""endpoint_v"": 4,
      ""track_length"": 1225.0
    },
    {
      ""endpoint_u"": 8,
      ""endpoint_v"": 13,
      ""track_length"": 338.0
    },
    {
      ""endpoint_u"": 8,
      ""endpoint_v"": 10,
      ""track_length"": 1025.0
    },
    {
      ""endpoint_u"": 9,
      ""endpoint_v"": 5,
      ""track_length"": 732.0
    },
    {
      ""endpoint_u"": 9,
      ""endpoint_v"": 13,
      ""track_length"": 535.0
    },
    {
      ""endpoint_u"": 12,
      ""endpoint_v"": 2,
      ""track_length"": 462.0
    },
    {
      ""endpoint_u"": 12,
      ""endpoint_v"": 1,
      ""track_length"": 231.0
    },
    {
      ""endpoint_u"": 13,
      ""endpoint_v"": 1,
      ""track_length"": 880.0
    },
    {
      ""endpoint_u"": 1,
      ""endpoint_v"": 2,
      ""track_length"": 488.0
    },
    {
      ""endpoint_u"": 4,
      ""endpoint_v"": 10,
      ""track_length"": 210.0
    },
    {
      ""endpoint_u"": 10,
      ""endpoint_v"": 3,
      ""track_length"": 940.0
    }
  ],
  ""required_sites"": [
    8,
    11,
    12
  ]
}

When you send the actual plan, pop it into this little JSON shape so it's easy to read and check:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Each pair like [u1, v1] is one lift or connector you plan to run — just the two endpoints of that piece of track. It's just a friendly example of the shape I expect, not the real answer.

Please be sure to use the exact node labels from the instance input — don't rename 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”.""","{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 19, 'edges': [{'u': 6, 'v': 15, 'w': 3048.0}, {'u': 6, 'v': 5, 'w': 3553.0}, {'u': 7, 'v': 4, 'w': 1813.0}, {'u': 14, 'v': 9, 'w': 324.0}, {'u': 14, 'v': 5, 'w': 542.0}, {'u': 14, 'v': 13, 'w': 457.0}, {'u': 11, 'v': 3, 'w': 344.0}, {'u': 11, 'v': 12, 'w': 331.0}, {'u': 8, 'v': 4, 'w': 1225.0}, {'u': 8, 'v': 13, 'w': 338.0}, {'u': 8, 'v': 10, 'w': 1025.0}, {'u': 9, 'v': 5, 'w': 732.0}, {'u': 9, 'v': 13, 'w': 535.0}, {'u': 12, 'v': 2, 'w': 462.0}, {'u': 12, 'v': 1, 'w': 231.0}, {'u': 13, 'v': 1, 'w': 880.0}, {'u': 1, 'v': 2, 'w': 488.0}, {'u': 4, 'v': 10, 'w': 210.0}, {'u': 10, 'v': 3, 'w': 940.0}], 'terminals': [8, 11, 12], 'source_file': 'I061.stp', 'density': 0.18095238095238095, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0046.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0046.png'}","[[11, 12], [8, 13], [1, 12], [1, 13]]",1780.0,"{'problem_type': 'STP', 'num_nodes': 15, 'num_edges': 19, 'edges': [{'u': 6, 'v': 15, 'w': 3048.0}, {'u': 6, 'v': 5, 'w': 3553.0}, {'u': 7, 'v': 4, 'w': 1813.0}, {'u': 14, 'v': 9, 'w': 324.0}, {'u': 14, 'v': 5, 'w': 542.0}, {'u': 14, 'v': 13, 'w': 457.0}, {'u': 11, 'v': 3, 'w': 344.0}, {'u': 11, 'v': 12, 'w': 331.0}, {'u': 8, 'v': 4, 'w': 1225.0}, {'u': 8, 'v': 13, 'w': 338.0}, {'u': 8, 'v': 10, 'w': 1025.0}, {'u': 9, 'v': 5, 'w': 732.0}, {'u': 9, 'v': 13, 'w': 535.0}, {'u': 12, 'v': 2, 'w': 462.0}, {'u': 12, 'v': 1, 'w': 231.0}, {'u': 13, 'v': 1, 'w': 880.0}, {'u': 1, 'v': 2, 'w': 488.0}, {'u': 4, 'v': 10, 'w': 210.0}, {'u': 10, 'v': 3, 'w': 940.0}], 'density': 0.18095238095238095, 'source_file': 'I061.stp', 'terminals': [8, 11, 12]}","[[11, 12], [8, 13], [1, 12], [1, 13]]",47,json,1
STP,STP,"We’re laying out a backyard so a cluster of benches and tables are all tied together by a single continuous ribbon of hedges and paths, and the job is picking which links to plant. The decision includes whether to include extra planted junctions or stepping-stone corners to make shorter connections between those spots. The winning layout is the one with the smallest total planting length — simply total the lengths of all chosen hedges and paths — but every seating area must sit on that single connected route and no segment is counted twice. The detailed plan and measurements follow below.

{
  ""total_junctions"": 11,
  ""total_possible_links"": 12,
  ""edges"": [
    {
      ""endpoint_u"": 6,
      ""endpoint_v"": 9,
      ""segment_length_m"": 982.0
    },
    {
      ""endpoint_u"": 6,
      ""endpoint_v"": 10,
      ""segment_length_m"": 3858.0
    },
    {
      ""endpoint_u"": 6,
      ""endpoint_v"": 8,
      ""segment_length_m"": 2707.0
    },
    {
      ""endpoint_u"": 5,
      ""endpoint_v"": 8,
      ""segment_length_m"": 468.0
    },
    {
      ""endpoint_u"": 5,
      ""endpoint_v"": 9,
      ""segment_length_m"": 2590.0
    },
    {
      ""endpoint_u"": 0,
      ""endpoint_v"": 3,
      ""segment_length_m"": 300.0
    },
    {
      ""endpoint_u"": 0,
      ""endpoint_v"": 4,
      ""segment_length_m"": 19.0
    },
    {
      ""endpoint_u"": 3,
      ""endpoint_v"": 2,
      ""segment_length_m"": 1.0
    },
    {
      ""endpoint_u"": 3,
      ""endpoint_v"": 9,
      ""segment_length_m"": 2779.0
    },
    {
      ""endpoint_u"": 4,
      ""endpoint_v"": 7,
      ""segment_length_m"": 1275.0
    },
    {
      ""endpoint_u"": 7,
      ""endpoint_v"": 1,
      ""segment_length_m"": 821.0
    },
    {
      ""endpoint_u"": 7,
      ""endpoint_v"": 8,
      ""segment_length_m"": 2728.0
    }
  ],
  ""seating_areas"": [
    2,
    8
  ]
}

When you’re ready to hand over the chosen links, just drop them in a tiny JSON block like this so I know the shape of your answer:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Think of ""solution"" as the whole planting plan. Each pair like [u1, v1] is one chosen link — it says “connect spot u1 to spot v1” (that could be a hedge segment between a bench and a corner, or a path between two junctions). This snippet is just a sketch of the format I’ll expect, not the actual final plan.

Please use the exact identifiers from the instance input — don’t rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 12, 'edges': [{'u': 7, 'v': 10, 'w': 982.0}, {'u': 7, 'v': 11, 'w': 3858.0}, {'u': 7, 'v': 9, 'w': 2707.0}, {'u': 6, 'v': 9, 'w': 468.0}, {'u': 6, 'v': 10, 'w': 2590.0}, {'u': 1, 'v': 4, 'w': 300.0}, {'u': 1, 'v': 5, 'w': 19.0}, {'u': 4, 'v': 3, 'w': 1.0}, {'u': 4, 'v': 10, 'w': 2779.0}, {'u': 5, 'v': 8, 'w': 1275.0}, {'u': 8, 'v': 2, 'w': 821.0}, {'u': 8, 'v': 9, 'w': 2728.0}], 'terminals': [3, 9], 'source_file': 'I058.stp', 'density': 0.21818181818181817, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0047.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0047.png'}","[[1, 4], [1, 5], [3, 4], [5, 8], [8, 9]]",4323.0,"{'problem_type': 'STP', 'num_nodes': 11, 'num_edges': 12, 'edges': [{'u': 6, 'v': 9, 'w': 982.0}, {'u': 6, 'v': 10, 'w': 3858.0}, {'u': 6, 'v': 8, 'w': 2707.0}, {'u': 5, 'v': 8, 'w': 468.0}, {'u': 5, 'v': 9, 'w': 2590.0}, {'u': 0, 'v': 3, 'w': 300.0}, {'u': 0, 'v': 4, 'w': 19.0}, {'u': 3, 'v': 2, 'w': 1.0}, {'u': 3, 'v': 9, 'w': 2779.0}, {'u': 4, 'v': 7, 'w': 1275.0}, {'u': 7, 'v': 1, 'w': 821.0}, {'u': 7, 'v': 8, 'w': 2728.0}], 'density': 0.21818181818181817, 'source_file': 'I058.stp', 'terminals': [2, 8]}","[[0, 3], [0, 4], [2, 3], [4, 7], [7, 8]]",48,json,0
STP,STP,"We’ve got a campus map with groups of wireless access points that all need to be hooked together into a single backbone, and the task is to pick which cable segments to install so every group is included and everything is connected. What makes one plan better than another is simply the total cable distance — add the lengths of the segments actually used and the smallest sum wins. It’s okay to run cables via intermediate hardware rooms if that cuts down the distance, but every wireless cluster must be part of the one backbone and there can’t be isolated pieces or redundant parallel cables. The detailed layout and numbers follow below.

We’ve got 10 locations, 11 available cable segments, and the wireless clusters to span are 6 9.
Run a cable from 3 to 7 with length 3798.0.
Run a cable from 3 to 10 with length 8962.0.
Run a cable from 1 to 2 with length 389.0.
Run a cable from 1 to 8 with length 2094.0.
Run a cable from 1 to 9 with length 2826.0.
Run a cable from 5 to 10 with length 4098.0.
Run a cable from 5 to 2 with length 2918.0.
Run a cable from 8 to 9 with length 3631.0.
Run a cable from 9 to 10 with length 1410.0.
Run a cable from 4 to 7 with length 792.0.
Run a cable from 6 to 7 with length 6627.0.
Keep every wireless cluster in 6 9 included in one connected backbone, avoid isolated pieces or redundant parallel cables, and minimize the total cable length.

Also, when you send back the actual wiring plan, please use this JSON layout so I can read it automatically:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

In plain terms: ""solution"" should be a list of cable segments, and each [X, Y] pair means ""connect node X to node Y"" (those are the endpoints of the cable). This block is just a sketch of the shape I expect — not the real wiring plan.

Please make sure to use the exact identifiers from the instance input, with no renaming or 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”.","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 3, 'v': 7, 'w': 3798.0}, {'u': 3, 'v': 10, 'w': 8962.0}, {'u': 1, 'v': 2, 'w': 389.0}, {'u': 1, 'v': 8, 'w': 2094.0}, {'u': 1, 'v': 9, 'w': 2826.0}, {'u': 5, 'v': 10, 'w': 4098.0}, {'u': 5, 'v': 2, 'w': 2918.0}, {'u': 8, 'v': 9, 'w': 3631.0}, {'u': 9, 'v': 10, 'w': 1410.0}, {'u': 4, 'v': 7, 'w': 792.0}, {'u': 6, 'v': 7, 'w': 6627.0}], 'terminals': [6, 9], 'source_file': 'I037.stp', 'density': 0.24444444444444444, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0048.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0048.png'}","[[3, 7], [3, 10], [9, 10], [6, 7]]",20797.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 3, 'v': 7, 'w': 3798.0}, {'u': 3, 'v': 10, 'w': 8962.0}, {'u': 1, 'v': 2, 'w': 389.0}, {'u': 1, 'v': 8, 'w': 2094.0}, {'u': 1, 'v': 9, 'w': 2826.0}, {'u': 5, 'v': 10, 'w': 4098.0}, {'u': 5, 'v': 2, 'w': 2918.0}, {'u': 8, 'v': 9, 'w': 3631.0}, {'u': 9, 'v': 10, 'w': 1410.0}, {'u': 4, 'v': 7, 'w': 792.0}, {'u': 6, 'v': 7, 'w': 6627.0}], 'density': 0.24444444444444444, 'source_file': 'I037.stp', 'terminals': [6, 9]}","[[3, 7], [3, 10], [9, 10], [6, 7]]",49,markdown_table,1
STP,STP,"There’s a small-city puzzle: get every plaza connected into one continuous lighting circuit by deciding which lamp posts to tie in. What makes one plan nicer than another is simply how little wire it needs—total wire length equals the sum of the chosen segments—so shorter total runs win, and using spare lamp posts as stepping stones is allowed to cut corners. All plazas must end up on that one circuit, and every piece of wiring is counted once when totaling length. The full diagram and distances are listed below.

{
  ""total_lamp_posts"": 10,
  ""total_possible_wiring_segments"": 11,
  ""edges"": [
    {
      ""endpoint_post_a"": 6,
      ""endpoint_post_b"": 7,
      ""wiring_length"": 1018.0
    },
    {
      ""endpoint_post_a"": 6,
      ""endpoint_post_b"": 10,
      ""wiring_length"": 16.0
    },
    {
      ""endpoint_post_a"": 6,
      ""endpoint_post_b"": 1,
      ""wiring_length"": 2638.0
    },
    {
      ""endpoint_post_a"": 7,
      ""endpoint_post_b"": 2,
      ""wiring_length"": 457.0
    },
    {
      ""endpoint_post_a"": 8,
      ""endpoint_post_b"": 2,
      ""wiring_length"": 3619.0
    },
    {
      ""endpoint_post_a"": 3,
      ""endpoint_post_b"": 4,
      ""wiring_length"": 1343.0
    },
    {
      ""endpoint_post_a"": 3,
      ""endpoint_post_b"": 5,
      ""wiring_length"": 2019.0
    },
    {
      ""endpoint_post_a"": 4,
      ""endpoint_post_b"": 5,
      ""wiring_length"": 1833.0
    },
    {
      ""endpoint_post_a"": 5,
      ""endpoint_post_b"": 10,
      ""wiring_length"": 4914.0
    },
    {
      ""endpoint_post_a"": 2,
      ""endpoint_post_b"": 9,
      ""wiring_length"": 1452.0
    },
    {
      ""endpoint_post_a"": 10,
      ""endpoint_post_b"": 9,
      ""wiring_length"": 1453.0
    }
  ],
  ""plaza_posts"": [
    3,
    4,
    8,
    9,
    10
  ]
}

Oh, and when you're ready to hand me the wiring plan, please toss it in this simple JSON shape so I can read it cleanly:

{
  ""solution"": [[u1, v1], [u2, v2], ...]
}

Here ""solution"" is just a list of the chosen wiring segments, and each little pair like [u1, v1] means ""connect lamp post u1 to lamp post v1"" (order doesn't really matter — it's just the segment between those two). This is only a sketch of the expected shape, not the actual answer — replace those placeholders with the real pairs from the diagram.

One important thing: use the identifiers exactly as they appear in the instance input — do not rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 6, 'v': 7, 'w': 1018.0}, {'u': 6, 'v': 10, 'w': 16.0}, {'u': 6, 'v': 1, 'w': 2638.0}, {'u': 7, 'v': 2, 'w': 457.0}, {'u': 8, 'v': 2, 'w': 3619.0}, {'u': 3, 'v': 4, 'w': 1343.0}, {'u': 3, 'v': 5, 'w': 2019.0}, {'u': 4, 'v': 5, 'w': 1833.0}, {'u': 5, 'v': 10, 'w': 4914.0}, {'u': 2, 'v': 9, 'w': 1452.0}, {'u': 10, 'v': 9, 'w': 1453.0}], 'terminals': [3, 4, 8, 9, 10], 'source_file': 'I081.stp', 'density': 0.24444444444444444, 'viz_instance': 'generated_data/STP/viz/STP_S_r02/instance_0049.png', 'viz_solution': 'generated_data/STP/viz/STP_S_r02/solution_0049.png'}","[[2, 8], [3, 4], [4, 5], [5, 10], [2, 9], [9, 10]]",14614.0,"{'problem_type': 'STP', 'num_nodes': 10, 'num_edges': 11, 'edges': [{'u': 6, 'v': 7, 'w': 1018.0}, {'u': 6, 'v': 10, 'w': 16.0}, {'u': 6, 'v': 1, 'w': 2638.0}, {'u': 7, 'v': 2, 'w': 457.0}, {'u': 8, 'v': 2, 'w': 3619.0}, {'u': 3, 'v': 4, 'w': 1343.0}, {'u': 3, 'v': 5, 'w': 2019.0}, {'u': 4, 'v': 5, 'w': 1833.0}, {'u': 5, 'v': 10, 'w': 4914.0}, {'u': 2, 'v': 9, 'w': 1452.0}, {'u': 10, 'v': 9, 'w': 1453.0}], 'density': 0.24444444444444444, 'source_file': 'I081.stp', 'terminals': [3, 4, 8, 9, 10]}","[[2, 8], [3, 4], [4, 5], [5, 10], [2, 9], [9, 10]]",50,json,1