STP/STP_M_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.

{
  ""total_locations"": 16,
  ""potential_segments_count"": 21,
  ""edges"": [
    {
      ""endpoint_node_a"": ""G"",
      ""endpoint_node_b"": ""M"",
      ""installation_cost"": 20591.0
    },
    {
      ""endpoint_node_a"": ""G"",
      ""endpoint_node_b"": ""F"",
      ""installation_cost"": 587.0
    },
    {
      ""endpoint_node_a"": ""G"",
      ""endpoint_node_b"": ""J"",
      ""installation_cost"": 28663.0
    },
    {
      ""endpoint_node_a"": ""L"",
      ""endpoint_node_b"": ""K"",
      ""installation_cost"": 4563.0
    },
    {
      ""endpoint_node_a"": ""L"",
      ""endpoint_node_b"": ""P"",
      ""installation_cost"": 903.0
    },
    {
      ""endpoint_node_a"": ""L"",
      ""endpoint_node_b"": ""O"",
      ""installation_cost"": 1176.0
    },
    {
      ""endpoint_node_a"": ""H"",
      ""endpoint_node_b"": ""C"",
      ""installation_cost"": 1594.0
    },
    {
      ""endpoint_node_a"": ""H"",
      ""endpoint_node_b"": ""K"",
      ""installation_cost"": 1266.0
    },
    {
      ""endpoint_node_a"": ""H"",
      ""endpoint_node_b"": ""I"",
      ""installation_cost"": 4559.0
    },
    {
      ""endpoint_node_a"": ""J"",
      ""endpoint_node_b"": ""O"",
      ""installation_cost"": 5168.0
    },
    {
      ""endpoint_node_a"": ""J"",
      ""endpoint_node_b"": ""E"",
      ""installation_cost"": 9193.0
    },
    {
      ""endpoint_node_a"": ""I"",
      ""endpoint_node_b"": ""N"",
      ""installation_cost"": 10215.0
    },
    {
      ""endpoint_node_a"": ""I"",
      ""endpoint_node_b"": ""D"",
      ""installation_cost"": 5002.0
    },
    {
      ""endpoint_node_a"": ""K"",
      ""endpoint_node_b"": ""M"",
      ""installation_cost"": 20492.0
    },
    {
      ""endpoint_node_a"": ""M"",
      ""endpoint_node_b"": ""A"",
      ""installation_cost"": 8015.0
    },
    {
      ""endpoint_node_a"": ""B"",
      ""endpoint_node_b"": ""F"",
      ""installation_cost"": 7687.0
    },
    {
      ""endpoint_node_a"": ""E"",
      ""endpoint_node_b"": ""N"",
      ""installation_cost"": 12943.0
    },
    {
      ""endpoint_node_a"": ""D"",
      ""endpoint_node_b"": ""C"",
      ""installation_cost"": 611.0
    },
    {
      ""endpoint_node_a"": ""D"",
      ""endpoint_node_b"": ""P"",
      ""installation_cost"": 4621.0
    },
    {
      ""endpoint_node_a"": ""P"",
      ""endpoint_node_b"": ""O"",
      ""installation_cost"": 1646.0
    },
    {
      ""endpoint_node_a"": ""A"",
      ""endpoint_node_b"": ""F"",
      ""installation_cost"": 28247.0
    }
  ],
  ""community_centers"": [
    ""A"",
    ""D"",
    ""H""
  ]
}

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': 16, 'num_edges': 21, 'edges': [{'u': 7, 'v': 13, 'w': 20591.0}, {'u': 7, 'v': 6, 'w': 587.0}, {'u': 7, 'v': 10, 'w': 28663.0}, {'u': 12, 'v': 11, 'w': 4563.0}, {'u': 12, 'v': 16, 'w': 903.0}, {'u': 12, 'v': 15, 'w': 1176.0}, {'u': 8, 'v': 3, 'w': 1594.0}, {'u': 8, 'v': 11, 'w': 1266.0}, {'u': 8, 'v': 9, 'w': 4559.0}, {'u': 10, 'v': 15, 'w': 5168.0}, {'u': 10, 'v': 5, 'w': 9193.0}, {'u': 9, 'v': 14, 'w': 10215.0}, {'u': 9, 'v': 4, 'w': 5002.0}, {'u': 11, 'v': 13, 'w': 20492.0}, {'u': 13, 'v': 1, 'w': 8015.0}, {'u': 2, 'v': 6, 'w': 7687.0}, {'u': 5, 'v': 14, 'w': 12943.0}, {'u': 4, 'v': 3, 'w': 611.0}, {'u': 4, 'v': 16, 'w': 4621.0}, {'u': 16, 'v': 15, 'w': 1646.0}, {'u': 1, 'v': 6, 'w': 28247.0}], 'terminals': [1, 4, 8], 'source_file': 'I076.stp', 'density': 0.175, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0000.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0000.png'}","[[3, 8], [8, 11], [11, 13], [1, 13], [3, 4]]",31978.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 21, 'edges': [{'u': 'G', 'v': 'M', 'w': 20591.0}, {'u': 'G', 'v': 'F', 'w': 587.0}, {'u': 'G', 'v': 'J', 'w': 28663.0}, {'u': 'L', 'v': 'K', 'w': 4563.0}, {'u': 'L', 'v': 'P', 'w': 903.0}, {'u': 'L', 'v': 'O', 'w': 1176.0}, {'u': 'H', 'v': 'C', 'w': 1594.0}, {'u': 'H', 'v': 'K', 'w': 1266.0}, {'u': 'H', 'v': 'I', 'w': 4559.0}, {'u': 'J', 'v': 'O', 'w': 5168.0}, {'u': 'J', 'v': 'E', 'w': 9193.0}, {'u': 'I', 'v': 'N', 'w': 10215.0}, {'u': 'I', 'v': 'D', 'w': 5002.0}, {'u': 'K', 'v': 'M', 'w': 20492.0}, {'u': 'M', 'v': 'A', 'w': 8015.0}, {'u': 'B', 'v': 'F', 'w': 7687.0}, {'u': 'E', 'v': 'N', 'w': 12943.0}, {'u': 'D', 'v': 'C', 'w': 611.0}, {'u': 'D', 'v': 'P', 'w': 4621.0}, {'u': 'P', 'v': 'O', 'w': 1646.0}, {'u': 'A', 'v': 'F', 'w': 28247.0}], 'density': 0.175, 'source_file': 'I076.stp', 'terminals': ['A', 'D', 'H']}","[['C', 'H'], ['H', 'K'], ['K', 'M'], ['A', 'M'], ['C', 'D']]",1,json,names
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 18 existing stepping stones, 23 candidate paths, and the flagged seating stones are C F G H L O P.
Between stone H and stone J we could lay a path of length 703.0.
Between stone H and stone E we could lay a path of length 1481.0.
Between stone F and stone G we could lay a path of length 370.0.
Between stone F and stone L we could lay a path of length 82.0.
Between stone F and stone C we could lay a path of length 245.0.
Between stone I and stone A we could lay a path of length 417.0.
Between stone I and stone B we could lay a path of length 463.0.
Between stone I and stone R we could lay a path of length 26.0.
Between stone G and stone M we could lay a path of length 43.0.
Between stone G and stone B we could lay a path of length 606.0.
Between stone G and stone C we could lay a path of length 591.0.
Between stone E and stone D we could lay a path of length 1285.0.
Between stone E and stone O we could lay a path of length 341.0.
Between stone J and stone K we could lay a path of length 349.0.
Between stone K and stone B we could lay a path of length 1334.0.
Between stone A and stone O we could lay a path of length 452.0.
Between stone P and stone Q we could lay a path of length 566.0.
Between stone P and stone O we could lay a path of length 1201.0.
Between stone P and stone N we could lay a path of length 1548.0.
Between stone M and stone L we could lay a path of length 376.0.
Between stone M and stone R we could lay a path of length 823.0.
Between stone L and stone R we could lay a path of length 880.0.
Between stone N and stone D we could lay a path of length 280.0.
Below we list each candidate path so we can choose the shortest set that connects all C F G H L O P.

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': 18, 'num_edges': 23, 'edges': [{'u': 8, 'v': 10, 'w': 703.0}, {'u': 8, 'v': 5, 'w': 1481.0}, {'u': 6, 'v': 7, 'w': 370.0}, {'u': 6, 'v': 12, 'w': 82.0}, {'u': 6, 'v': 3, 'w': 245.0}, {'u': 9, 'v': 1, 'w': 417.0}, {'u': 9, 'v': 2, 'w': 463.0}, {'u': 9, 'v': 18, 'w': 26.0}, {'u': 7, 'v': 13, 'w': 43.0}, {'u': 7, 'v': 2, 'w': 606.0}, {'u': 7, 'v': 3, 'w': 591.0}, {'u': 5, 'v': 4, 'w': 1285.0}, {'u': 5, 'v': 15, 'w': 341.0}, {'u': 10, 'v': 11, 'w': 349.0}, {'u': 11, 'v': 2, 'w': 1334.0}, {'u': 1, 'v': 15, 'w': 452.0}, {'u': 16, 'v': 17, 'w': 566.0}, {'u': 16, 'v': 15, 'w': 1201.0}, {'u': 16, 'v': 14, 'w': 1548.0}, {'u': 13, 'v': 12, 'w': 376.0}, {'u': 13, 'v': 18, 'w': 823.0}, {'u': 12, 'v': 18, 'w': 880.0}, {'u': 14, 'v': 4, 'w': 280.0}], 'terminals': [3, 6, 7, 8, 12, 15, 16], 'source_file': 'I055.stp', 'density': 0.1503267973856209, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0001.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0001.png'}","[[5, 8], [6, 7], [6, 12], [3, 6], [1, 9], [9, 18], [7, 13], [5, 15], [1, 15], [15, 16], [13, 18]]",5481.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 23, 'edges': [{'u': 'H', 'v': 'J', 'w': 703.0}, {'u': 'H', 'v': 'E', 'w': 1481.0}, {'u': 'F', 'v': 'G', 'w': 370.0}, {'u': 'F', 'v': 'L', 'w': 82.0}, {'u': 'F', 'v': 'C', 'w': 245.0}, {'u': 'I', 'v': 'A', 'w': 417.0}, {'u': 'I', 'v': 'B', 'w': 463.0}, {'u': 'I', 'v': 'R', 'w': 26.0}, {'u': 'G', 'v': 'M', 'w': 43.0}, {'u': 'G', 'v': 'B', 'w': 606.0}, {'u': 'G', 'v': 'C', 'w': 591.0}, {'u': 'E', 'v': 'D', 'w': 1285.0}, {'u': 'E', 'v': 'O', 'w': 341.0}, {'u': 'J', 'v': 'K', 'w': 349.0}, {'u': 'K', 'v': 'B', 'w': 1334.0}, {'u': 'A', 'v': 'O', 'w': 452.0}, {'u': 'P', 'v': 'Q', 'w': 566.0}, {'u': 'P', 'v': 'O', 'w': 1201.0}, {'u': 'P', 'v': 'N', 'w': 1548.0}, {'u': 'M', 'v': 'L', 'w': 376.0}, {'u': 'M', 'v': 'R', 'w': 823.0}, {'u': 'L', 'v': 'R', 'w': 880.0}, {'u': 'N', 'v': 'D', 'w': 280.0}], 'density': 0.1503267973856209, 'source_file': 'I055.stp', 'terminals': ['C', 'F', 'G', 'H', 'L', 'O', 'P']}","[['E', 'H'], ['F', 'G'], ['F', 'L'], ['C', 'F'], ['A', 'I'], ['I', 'R'], ['G', 'M'], ['E', 'O'], ['A', 'O'], ['O', 'P'], ['M', 'R']]",2,nl,names
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 17 nodes, 19 feasible spans, and the required distribution boxes are 7 11 14.
Candidate span connecting node 8 and node 7, length 334.0.
Candidate span connecting node 8 and node 9, length 1798.0.
Candidate span connecting node 17 and node 11, length 2434.0.
Candidate span connecting node 9 and node 11, length 1258.0.
Candidate span connecting node 9 and node 15, length 212.0.
Candidate span connecting node 5 and node 4, length 612.0.
Candidate span connecting node 5 and node 12, length 523.0.
Candidate span connecting node 5 and node 2, length 152.0.
Candidate span connecting node 2 and node 3, length 1217.0.
Candidate span connecting node 2 and node 13, length 623.0.
Candidate span connecting node 3 and node 12, length 868.0.
Candidate span connecting node 1 and node 15, length 1086.0.
Candidate span connecting node 15 and node 16, length 1297.0.
Candidate span connecting node 11 and node 10, length 218.0.
Candidate span connecting node 12 and node 7, length 472.0.
Candidate span connecting node 14 and node 6, length 1504.0.
Candidate span connecting node 4 and node 6, length 775.0.
Candidate span connecting node 4 and node 7, length 652.0.
Candidate span connecting node 13 and node 6, length 612.0.
We must select a subset of these spans so the 7 11 14 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': 17, 'num_edges': 19, 'edges': [{'u': 8, 'v': 7, 'w': 334.0}, {'u': 8, 'v': 9, 'w': 1798.0}, {'u': 17, 'v': 11, 'w': 2434.0}, {'u': 9, 'v': 11, 'w': 1258.0}, {'u': 9, 'v': 15, 'w': 212.0}, {'u': 5, 'v': 4, 'w': 612.0}, {'u': 5, 'v': 12, 'w': 523.0}, {'u': 5, 'v': 2, 'w': 152.0}, {'u': 2, 'v': 3, 'w': 1217.0}, {'u': 2, 'v': 13, 'w': 623.0}, {'u': 3, 'v': 12, 'w': 868.0}, {'u': 1, 'v': 15, 'w': 1086.0}, {'u': 15, 'v': 16, 'w': 1297.0}, {'u': 11, 'v': 10, 'w': 218.0}, {'u': 12, 'v': 7, 'w': 472.0}, {'u': 14, 'v': 6, 'w': 1504.0}, {'u': 4, 'v': 6, 'w': 775.0}, {'u': 4, 'v': 7, 'w': 652.0}, {'u': 13, 'v': 6, 'w': 612.0}], 'terminals': [7, 11, 14], 'source_file': 'I011.stp', 'density': 0.13970588235294118, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0002.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0002.png'}","[[7, 8], [8, 9], [9, 11], [6, 14], [4, 6], [4, 7]]",6321.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 19, 'edges': [{'u': 8, 'v': 7, 'w': 334.0}, {'u': 8, 'v': 9, 'w': 1798.0}, {'u': 17, 'v': 11, 'w': 2434.0}, {'u': 9, 'v': 11, 'w': 1258.0}, {'u': 9, 'v': 15, 'w': 212.0}, {'u': 5, 'v': 4, 'w': 612.0}, {'u': 5, 'v': 12, 'w': 523.0}, {'u': 5, 'v': 2, 'w': 152.0}, {'u': 2, 'v': 3, 'w': 1217.0}, {'u': 2, 'v': 13, 'w': 623.0}, {'u': 3, 'v': 12, 'w': 868.0}, {'u': 1, 'v': 15, 'w': 1086.0}, {'u': 15, 'v': 16, 'w': 1297.0}, {'u': 11, 'v': 10, 'w': 218.0}, {'u': 12, 'v': 7, 'w': 472.0}, {'u': 14, 'v': 6, 'w': 1504.0}, {'u': 4, 'v': 6, 'w': 775.0}, {'u': 4, 'v': 7, 'w': 652.0}, {'u': 13, 'v': 6, 'w': 612.0}], 'density': 0.13970588235294118, 'source_file': 'I011.stp', 'terminals': [7, 11, 14]}","[[7, 8], [8, 9], [9, 11], [6, 14], [4, 6], [4, 7]]",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"": 16,
  ""total_corridor_segments"": 19,
  ""edges"": [
    {
      ""endpoint_location_a"": 10,
      ""endpoint_location_b"": 5,
      ""corridor_length"": 298.0
    },
    {
      ""endpoint_location_a"": 10,
      ""endpoint_location_b"": 11,
      ""corridor_length"": 250.0
    },
    {
      ""endpoint_location_a"": 10,
      ""endpoint_location_b"": 2,
      ""corridor_length"": 1117.0
    },
    {
      ""endpoint_location_a"": 12,
      ""endpoint_location_b"": 11,
      ""corridor_length"": 791.0
    },
    {
      ""endpoint_location_a"": 12,
      ""endpoint_location_b"": 13,
      ""corridor_length"": 1279.0
    },
    {
      ""endpoint_location_a"": 8,
      ""endpoint_location_b"": 0,
      ""corridor_length"": 48.0
    },
    {
      ""endpoint_location_a"": 8,
      ""endpoint_location_b"": 7,
      ""corridor_length"": 437.0
    },
    {
      ""endpoint_location_a"": 8,
      ""endpoint_location_b"": 9,
      ""corridor_length"": 683.0
    },
    {
      ""endpoint_location_a"": 2,
      ""endpoint_location_b"": 9,
      ""corridor_length"": 1108.0
    },
    {
      ""endpoint_location_a"": 6,
      ""endpoint_location_b"": 15,
      ""corridor_length"": 492.0
    },
    {
      ""endpoint_location_a"": 3,
      ""endpoint_location_b"": 4,
      ""corridor_length"": 285409.0
    },
    {
      ""endpoint_location_a"": 3,
      ""endpoint_location_b"": 5,
      ""corridor_length"": 285017.0
    },
    {
      ""endpoint_location_a"": 4,
      ""endpoint_location_b"": 5,
      ""corridor_length"": 1230.0
    },
    {
      ""endpoint_location_a"": 4,
      ""endpoint_location_b"": 9,
      ""corridor_length"": 447.0
    },
    {
      ""endpoint_location_a"": 7,
      ""endpoint_location_b"": 1,
      ""corridor_length"": 523.0
    },
    {
      ""endpoint_location_a"": 7,
      ""endpoint_location_b"": 15,
      ""corridor_length"": 425.0
    },
    {
      ""endpoint_location_a"": 14,
      ""endpoint_location_b"": 11,
      ""corridor_length"": 863.0
    },
    {
      ""endpoint_location_a"": 14,
      ""endpoint_location_b"": 15,
      ""corridor_length"": 1701.0
    },
    {
      ""endpoint_location_a"": 0,
      ""endpoint_location_b"": 1,
      ""corridor_length"": 962.0
    }
  ],
  ""highlighted_exhibit_rooms"": [
    0,
    1,
    4,
    7,
    8,
    10,
    13,
    15
  ]
}

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': 16, 'num_edges': 19, 'edges': [{'u': 11, 'v': 6, 'w': 298.0}, {'u': 11, 'v': 12, 'w': 250.0}, {'u': 11, 'v': 3, 'w': 1117.0}, {'u': 13, 'v': 12, 'w': 791.0}, {'u': 13, 'v': 14, 'w': 1279.0}, {'u': 9, 'v': 1, 'w': 48.0}, {'u': 9, 'v': 8, 'w': 437.0}, {'u': 9, 'v': 10, 'w': 683.0}, {'u': 3, 'v': 10, 'w': 1108.0}, {'u': 7, 'v': 16, 'w': 492.0}, {'u': 4, 'v': 5, 'w': 285409.0}, {'u': 4, 'v': 6, 'w': 285017.0}, {'u': 5, 'v': 6, 'w': 1230.0}, {'u': 5, 'v': 10, 'w': 447.0}, {'u': 8, 'v': 2, 'w': 523.0}, {'u': 8, 'v': 16, 'w': 425.0}, {'u': 15, 'v': 12, 'w': 863.0}, {'u': 15, 'v': 16, 'w': 1701.0}, {'u': 1, 'v': 2, 'w': 962.0}], 'terminals': [1, 2, 5, 8, 9, 11, 14, 16], 'source_file': 'I024.stp', 'density': 0.15833333333333333, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0003.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0003.png'}","[[6, 11], [11, 12], [12, 13], [13, 14], [1, 9], [8, 9], [9, 10], [5, 6], [5, 10], [2, 8], [8, 16]]",6411.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 19, 'edges': [{'u': 10, 'v': 5, 'w': 298.0}, {'u': 10, 'v': 11, 'w': 250.0}, {'u': 10, 'v': 2, 'w': 1117.0}, {'u': 12, 'v': 11, 'w': 791.0}, {'u': 12, 'v': 13, 'w': 1279.0}, {'u': 8, 'v': 0, 'w': 48.0}, {'u': 8, 'v': 7, 'w': 437.0}, {'u': 8, 'v': 9, 'w': 683.0}, {'u': 2, 'v': 9, 'w': 1108.0}, {'u': 6, 'v': 15, 'w': 492.0}, {'u': 3, 'v': 4, 'w': 285409.0}, {'u': 3, 'v': 5, 'w': 285017.0}, {'u': 4, 'v': 5, 'w': 1230.0}, {'u': 4, 'v': 9, 'w': 447.0}, {'u': 7, 'v': 1, 'w': 523.0}, {'u': 7, 'v': 15, 'w': 425.0}, {'u': 14, 'v': 11, 'w': 863.0}, {'u': 14, 'v': 15, 'w': 1701.0}, {'u': 0, 'v': 1, 'w': 962.0}], 'density': 0.15833333333333333, 'source_file': 'I024.stp', 'terminals': [0, 1, 4, 7, 8, 10, 13, 15]}","[[5, 10], [10, 11], [11, 12], [12, 13], [0, 8], [7, 8], [8, 9], [4, 5], [4, 9], [1, 7], [7, 15]]",4,json,0
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=16
# total_channel_sections=19
# required_plot_nodes=0 1 8 10 12 15
junction_u,junction_v,section_length
4,3,455.0
4,7,232.0
4,13,1115.0
5,3,617.0
5,12,928.0
5,9,1098.0
11,2,1548.0
6,15,290.0
6,7,687.0
7,15,400.0
12,13,519.0
12,2,1172.0
10,9,1779.0
13,0,894.0
14,0,163.0
15,9,1333.0
8,1,270185.0
8,0,270299.0
1,2,1218.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': 16, 'num_edges': 19, 'edges': [{'u': 5, 'v': 4, 'w': 455.0}, {'u': 5, 'v': 8, 'w': 232.0}, {'u': 5, 'v': 14, 'w': 1115.0}, {'u': 6, 'v': 4, 'w': 617.0}, {'u': 6, 'v': 13, 'w': 928.0}, {'u': 6, 'v': 10, 'w': 1098.0}, {'u': 12, 'v': 3, 'w': 1548.0}, {'u': 7, 'v': 16, 'w': 290.0}, {'u': 7, 'v': 8, 'w': 687.0}, {'u': 8, 'v': 16, 'w': 400.0}, {'u': 13, 'v': 14, 'w': 519.0}, {'u': 13, 'v': 3, 'w': 1172.0}, {'u': 11, 'v': 10, 'w': 1779.0}, {'u': 14, 'v': 1, 'w': 894.0}, {'u': 15, 'v': 1, 'w': 163.0}, {'u': 16, 'v': 10, 'w': 1333.0}, {'u': 9, 'v': 2, 'w': 270185.0}, {'u': 9, 'v': 1, 'w': 270299.0}, {'u': 2, 'v': 3, 'w': 1218.0}], 'terminals': [1, 2, 9, 11, 13, 16], 'source_file': 'I007.stp', 'density': 0.15833333333333333, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0004.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0004.png'}","[[5, 8], [5, 14], [8, 16], [13, 14], [3, 13], [10, 11], [1, 14], [10, 16], [2, 9], [2, 3]]",278847.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 19, 'edges': [{'u': 4, 'v': 3, 'w': 455.0}, {'u': 4, 'v': 7, 'w': 232.0}, {'u': 4, 'v': 13, 'w': 1115.0}, {'u': 5, 'v': 3, 'w': 617.0}, {'u': 5, 'v': 12, 'w': 928.0}, {'u': 5, 'v': 9, 'w': 1098.0}, {'u': 11, 'v': 2, 'w': 1548.0}, {'u': 6, 'v': 15, 'w': 290.0}, {'u': 6, 'v': 7, 'w': 687.0}, {'u': 7, 'v': 15, 'w': 400.0}, {'u': 12, 'v': 13, 'w': 519.0}, {'u': 12, 'v': 2, 'w': 1172.0}, {'u': 10, 'v': 9, 'w': 1779.0}, {'u': 13, 'v': 0, 'w': 894.0}, {'u': 14, 'v': 0, 'w': 163.0}, {'u': 15, 'v': 9, 'w': 1333.0}, {'u': 8, 'v': 1, 'w': 270185.0}, {'u': 8, 'v': 0, 'w': 270299.0}, {'u': 1, 'v': 2, 'w': 1218.0}], 'density': 0.15833333333333333, 'source_file': 'I007.stp', 'terminals': [0, 1, 8, 10, 12, 15]}","[[4, 7], [4, 13], [7, 15], [12, 13], [2, 12], [9, 10], [0, 13], [9, 15], [1, 8], [1, 2]]",5,csv,0
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 19 total locations, 21 candidate walkway segments, and the vendor booths to connect: 0 1 4 10 12 16 18.
Temporary walkway between 9 and 8 — length 154.0.
Temporary walkway between 9 and 14 — length 874.0.
Temporary walkway between 9 and 12 — length 2784.0.
Temporary walkway between 10 and 5 — length 1083.0.
Temporary walkway between 10 and 3 — length 1825.0.
Temporary walkway between 10 and 16 — length 1941.0.
Temporary walkway between 16 and 12 — length 912.0.
Temporary walkway between 16 and 11 — length 2340.0.
Temporary walkway between 15 and 14 — length 2233.0.
Temporary walkway between 15 and 0 — length 1971.0.
Temporary walkway between 15 and 18 — length 3394.0.
Temporary walkway between 11 and 17 — length 12.0.
Temporary walkway between 17 and 18 — length 1158.0.
Temporary walkway between 17 and 2 — length 4370.0.
Temporary walkway between 18 and 12 — length 399.0.
Temporary walkway between 6 and 7 — length 1300.0.
Temporary walkway between 6 and 2 — length 2485.0.
Temporary walkway between 7 and 1 — length 1936.0.
Temporary walkway between 1 and 2 — length 1846.0.
Temporary walkway between 14 and 13 — length 264.0.
Temporary walkway between 3 and 4 — length 338.0.
The solution should join every booth in 0 1 4 10 12 16 18 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': 19, 'num_edges': 21, 'edges': [{'u': 10, 'v': 9, 'w': 154.0}, {'u': 10, 'v': 15, 'w': 874.0}, {'u': 10, 'v': 13, 'w': 2784.0}, {'u': 11, 'v': 6, 'w': 1083.0}, {'u': 11, 'v': 4, 'w': 1825.0}, {'u': 11, 'v': 17, 'w': 1941.0}, {'u': 17, 'v': 13, 'w': 912.0}, {'u': 17, 'v': 12, 'w': 2340.0}, {'u': 16, 'v': 15, 'w': 2233.0}, {'u': 16, 'v': 1, 'w': 1971.0}, {'u': 16, 'v': 19, 'w': 3394.0}, {'u': 12, 'v': 18, 'w': 12.0}, {'u': 18, 'v': 19, 'w': 1158.0}, {'u': 18, 'v': 3, 'w': 4370.0}, {'u': 19, 'v': 13, 'w': 399.0}, {'u': 7, 'v': 8, 'w': 1300.0}, {'u': 7, 'v': 3, 'w': 2485.0}, {'u': 8, 'v': 2, 'w': 1936.0}, {'u': 2, 'v': 3, 'w': 1846.0}, {'u': 15, 'v': 14, 'w': 264.0}, {'u': 4, 'v': 5, 'w': 338.0}], 'terminals': [1, 2, 5, 11, 13, 17, 19], 'source_file': 'I031.stp', 'density': 0.12280701754385964, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0005.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0005.png'}","[[4, 11], [11, 17], [13, 17], [1, 16], [16, 19], [18, 19], [3, 18], [13, 19], [2, 3], [4, 5]]",18154.0,"{'problem_type': 'STP', 'num_nodes': 19, 'num_edges': 21, 'edges': [{'u': 9, 'v': 8, 'w': 154.0}, {'u': 9, 'v': 14, 'w': 874.0}, {'u': 9, 'v': 12, 'w': 2784.0}, {'u': 10, 'v': 5, 'w': 1083.0}, {'u': 10, 'v': 3, 'w': 1825.0}, {'u': 10, 'v': 16, 'w': 1941.0}, {'u': 16, 'v': 12, 'w': 912.0}, {'u': 16, 'v': 11, 'w': 2340.0}, {'u': 15, 'v': 14, 'w': 2233.0}, {'u': 15, 'v': 0, 'w': 1971.0}, {'u': 15, 'v': 18, 'w': 3394.0}, {'u': 11, 'v': 17, 'w': 12.0}, {'u': 17, 'v': 18, 'w': 1158.0}, {'u': 17, 'v': 2, 'w': 4370.0}, {'u': 18, 'v': 12, 'w': 399.0}, {'u': 6, 'v': 7, 'w': 1300.0}, {'u': 6, 'v': 2, 'w': 2485.0}, {'u': 7, 'v': 1, 'w': 1936.0}, {'u': 1, 'v': 2, 'w': 1846.0}, {'u': 14, 'v': 13, 'w': 264.0}, {'u': 3, 'v': 4, 'w': 338.0}], 'density': 0.12280701754385964, 'source_file': 'I031.stp', 'terminals': [0, 1, 4, 10, 12, 16, 18]}","[[3, 10], [10, 16], [12, 16], [0, 15], [15, 18], [17, 18], [2, 17], [12, 18], [1, 2], [3, 4]]",6,markdown_table,0
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.

# total_locations=16
# available_conduit_runs=20
# required_service_panels=9 10 11 16
endpoint_a,endpoint_b,run_cost
1,11,3024.0
2,4,597.0
3,4,1869.0
3,15,59.0
4,6,1135.0
5,6,1387.0
5,16,554.0
5,7,621.0
6,10,1832.0
7,14,563.0
7,8,1838.0
8,9,913.0
8,10,903.0
9,10,152.0
9,11,1735.0
11,12,1490.0
16,15,498.0
16,14,598.0
15,13,523.0
13,14,485.0

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': 16, 'num_edges': 20, 'edges': [{'u': 1, 'v': 11, 'w': 3024.0}, {'u': 2, 'v': 4, 'w': 597.0}, {'u': 3, 'v': 4, 'w': 1869.0}, {'u': 3, 'v': 15, 'w': 59.0}, {'u': 4, 'v': 6, 'w': 1135.0}, {'u': 5, 'v': 6, 'w': 1387.0}, {'u': 5, 'v': 16, 'w': 554.0}, {'u': 5, 'v': 7, 'w': 621.0}, {'u': 6, 'v': 10, 'w': 1832.0}, {'u': 7, 'v': 14, 'w': 563.0}, {'u': 7, 'v': 8, 'w': 1838.0}, {'u': 8, 'v': 9, 'w': 913.0}, {'u': 8, 'v': 10, 'w': 903.0}, {'u': 9, 'v': 10, 'w': 152.0}, {'u': 9, 'v': 11, 'w': 1735.0}, {'u': 11, 'v': 12, 'w': 1490.0}, {'u': 16, 'v': 15, 'w': 498.0}, {'u': 16, 'v': 14, 'w': 598.0}, {'u': 15, 'v': 13, 'w': 523.0}, {'u': 13, 'v': 14, 'w': 485.0}], 'terminals': [9, 10, 11, 16], 'source_file': 'I052.stp', 'density': 0.16666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0006.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0006.png'}","[[5, 6], [5, 16], [6, 10], [9, 10], [9, 11]]",5660.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 20, 'edges': [{'u': 1, 'v': 11, 'w': 3024.0}, {'u': 2, 'v': 4, 'w': 597.0}, {'u': 3, 'v': 4, 'w': 1869.0}, {'u': 3, 'v': 15, 'w': 59.0}, {'u': 4, 'v': 6, 'w': 1135.0}, {'u': 5, 'v': 6, 'w': 1387.0}, {'u': 5, 'v': 16, 'w': 554.0}, {'u': 5, 'v': 7, 'w': 621.0}, {'u': 6, 'v': 10, 'w': 1832.0}, {'u': 7, 'v': 14, 'w': 563.0}, {'u': 7, 'v': 8, 'w': 1838.0}, {'u': 8, 'v': 9, 'w': 913.0}, {'u': 8, 'v': 10, 'w': 903.0}, {'u': 9, 'v': 10, 'w': 152.0}, {'u': 9, 'v': 11, 'w': 1735.0}, {'u': 11, 'v': 12, 'w': 1490.0}, {'u': 16, 'v': 15, 'w': 498.0}, {'u': 16, 'v': 14, 'w': 598.0}, {'u': 15, 'v': 13, 'w': 523.0}, {'u': 13, 'v': 14, 'w': 485.0}], 'density': 0.16666666666666666, 'source_file': 'I052.stp', 'terminals': [9, 10, 11, 16]}","[[5, 6], [5, 16], [6, 10], [9, 10], [9, 11]]",7,csv,1
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.

# total_map_locations=17
# total_trail_segments=20
# viewpoint_nodes=5 8 9 10 12
trail_endpoint_a,trail_endpoint_b,segment_length
16,10,1684.0
16,0,7051.0
1,2,97.0
1,7,458.0
2,10,1453.0
2,8,456.0
3,4,1008.0
3,5,568.0
3,6,223879.0
10,9,1486.0
4,13,728.0
4,12,725.0
5,14,1132.0
5,15,787.0
9,11,1939.0
11,12,214.0
13,14,38.0
13,7,103.0
14,8,97.0
7,8,49.0

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': 17, 'num_edges': 20, 'edges': [{'u': 17, 'v': 11, 'w': 1684.0}, {'u': 17, 'v': 1, 'w': 7051.0}, {'u': 2, 'v': 3, 'w': 97.0}, {'u': 2, 'v': 8, 'w': 458.0}, {'u': 3, 'v': 11, 'w': 1453.0}, {'u': 3, 'v': 9, 'w': 456.0}, {'u': 4, 'v': 5, 'w': 1008.0}, {'u': 4, 'v': 6, 'w': 568.0}, {'u': 4, 'v': 7, 'w': 223879.0}, {'u': 11, 'v': 10, 'w': 1486.0}, {'u': 5, 'v': 14, 'w': 728.0}, {'u': 5, 'v': 13, 'w': 725.0}, {'u': 6, 'v': 15, 'w': 1132.0}, {'u': 6, 'v': 16, 'w': 787.0}, {'u': 10, 'v': 12, 'w': 1939.0}, {'u': 12, 'v': 13, 'w': 214.0}, {'u': 14, 'v': 15, 'w': 38.0}, {'u': 14, 'v': 8, 'w': 103.0}, {'u': 15, 'v': 9, 'w': 97.0}, {'u': 8, 'v': 9, 'w': 49.0}], 'terminals': [6, 9, 10, 11, 13], 'source_file': 'I037.stp', 'density': 0.14705882352941177, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0007.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0007.png'}","[[3, 11], [3, 9], [10, 11], [5, 14], [5, 13], [6, 15], [14, 15], [9, 15]]",6115.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 20, 'edges': [{'u': 16, 'v': 10, 'w': 1684.0}, {'u': 16, 'v': 0, 'w': 7051.0}, {'u': 1, 'v': 2, 'w': 97.0}, {'u': 1, 'v': 7, 'w': 458.0}, {'u': 2, 'v': 10, 'w': 1453.0}, {'u': 2, 'v': 8, 'w': 456.0}, {'u': 3, 'v': 4, 'w': 1008.0}, {'u': 3, 'v': 5, 'w': 568.0}, {'u': 3, 'v': 6, 'w': 223879.0}, {'u': 10, 'v': 9, 'w': 1486.0}, {'u': 4, 'v': 13, 'w': 728.0}, {'u': 4, 'v': 12, 'w': 725.0}, {'u': 5, 'v': 14, 'w': 1132.0}, {'u': 5, 'v': 15, 'w': 787.0}, {'u': 9, 'v': 11, 'w': 1939.0}, {'u': 11, 'v': 12, 'w': 214.0}, {'u': 13, 'v': 14, 'w': 38.0}, {'u': 13, 'v': 7, 'w': 103.0}, {'u': 14, 'v': 8, 'w': 97.0}, {'u': 7, 'v': 8, 'w': 49.0}], 'density': 0.14705882352941177, 'source_file': 'I037.stp', 'terminals': [5, 8, 9, 10, 12]}","[[2, 10], [2, 8], [9, 10], [4, 13], [4, 12], [5, 14], [13, 14], [8, 14]]",8,csv,0
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.

{
  ""total_intersections"": 20,
  ""total_sidewalk_segments"": 24,
  ""edges"": [
    {
      ""endpoint_a"": ""J"",
      ""endpoint_b"": ""M"",
      ""repair_cost"": 1387.0
    },
    {
      ""endpoint_a"": ""F"",
      ""endpoint_b"": ""S"",
      ""repair_cost"": 867.0
    },
    {
      ""endpoint_a"": ""K"",
      ""endpoint_b"": ""T"",
      ""repair_cost"": 1377.0
    },
    {
      ""endpoint_a"": ""L"",
      ""endpoint_b"": ""C"",
      ""repair_cost"": 1071.0
    },
    {
      ""endpoint_a"": ""L"",
      ""endpoint_b"": ""M"",
      ""repair_cost"": 1050.0
    },
    {
      ""endpoint_a"": ""M"",
      ""endpoint_b"": ""O"",
      ""repair_cost"": 133.0
    },
    {
      ""endpoint_a"": ""N"",
      ""endpoint_b"": ""C"",
      ""repair_cost"": 238.0
    },
    {
      ""endpoint_a"": ""N"",
      ""endpoint_b"": ""Q"",
      ""repair_cost"": 1039.0
    },
    {
      ""endpoint_a"": ""N"",
      ""endpoint_b"": ""B"",
      ""repair_cost"": 492.0
    },
    {
      ""endpoint_a"": ""O"",
      ""endpoint_b"": ""E"",
      ""repair_cost"": 660.0
    },
    {
      ""endpoint_a"": ""O"",
      ""endpoint_b"": ""T"",
      ""repair_cost"": 892.0
    },
    {
      ""endpoint_a"": ""P"",
      ""endpoint_b"": ""G"",
      ""repair_cost"": 1.0
    },
    {
      ""endpoint_a"": ""P"",
      ""endpoint_b"": ""I"",
      ""repair_cost"": 393.0
    },
    {
      ""endpoint_a"": ""P"",
      ""endpoint_b"": ""H"",
      ""repair_cost"": 318.0
    },
    {
      ""endpoint_a"": ""A"",
      ""endpoint_b"": ""B"",
      ""repair_cost"": 279.0
    },
    {
      ""endpoint_a"": ""A"",
      ""endpoint_b"": ""C"",
      ""repair_cost"": 513.0
    },
    {
      ""endpoint_a"": ""A"",
      ""endpoint_b"": ""H"",
      ""repair_cost"": 256.0
    },
    {
      ""endpoint_a"": ""B"",
      ""endpoint_b"": ""S"",
      ""repair_cost"": 159.0
    },
    {
      ""endpoint_a"": ""D"",
      ""endpoint_b"": ""E"",
      ""repair_cost"": 323.0
    },
    {
      ""endpoint_a"": ""D"",
      ""endpoint_b"": ""H"",
      ""repair_cost"": 366.0
    },
    {
      ""endpoint_a"": ""E"",
      ""endpoint_b"": ""G"",
      ""repair_cost"": 364.0
    },
    {
      ""endpoint_a"": ""H"",
      ""endpoint_b"": ""I"",
      ""repair_cost"": 80.0
    },
    {
      ""endpoint_a"": ""I"",
      ""endpoint_b"": ""S"",
      ""repair_cost"": 289.0
    },
    {
      ""endpoint_a"": ""Q"",
      ""endpoint_b"": ""R"",
      ""repair_cost"": 236.0
    }
  ],
  ""school_entrances"": [
    ""B"",
    ""C"",
    ""F"",
    ""G"",
    ""K"",
    ""M""
  ]
}

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': 20, 'num_edges': 24, 'edges': [{'u': 10, 'v': 13, 'w': 1387.0}, {'u': 6, 'v': 19, 'w': 867.0}, {'u': 11, 'v': 20, 'w': 1377.0}, {'u': 12, 'v': 3, 'w': 1071.0}, {'u': 12, 'v': 13, 'w': 1050.0}, {'u': 13, 'v': 15, 'w': 133.0}, {'u': 14, 'v': 3, 'w': 238.0}, {'u': 14, 'v': 17, 'w': 1039.0}, {'u': 14, 'v': 2, 'w': 492.0}, {'u': 15, 'v': 5, 'w': 660.0}, {'u': 15, 'v': 20, 'w': 892.0}, {'u': 16, 'v': 7, 'w': 1.0}, {'u': 16, 'v': 9, 'w': 393.0}, {'u': 16, 'v': 8, 'w': 318.0}, {'u': 1, 'v': 2, 'w': 279.0}, {'u': 1, 'v': 3, 'w': 513.0}, {'u': 1, 'v': 8, 'w': 256.0}, {'u': 2, 'v': 19, 'w': 159.0}, {'u': 4, 'v': 5, 'w': 323.0}, {'u': 4, 'v': 8, 'w': 366.0}, {'u': 5, 'v': 7, 'w': 364.0}, {'u': 8, 'v': 9, 'w': 80.0}, {'u': 9, 'v': 19, 'w': 289.0}, {'u': 17, 'v': 18, 'w': 236.0}], 'terminals': [2, 3, 6, 7, 11, 13], 'source_file': 'I050.stp', 'density': 0.12631578947368421, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0008.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0008.png'}","[[6, 19], [11, 20], [13, 15], [5, 15], [15, 20], [7, 16], [8, 16], [1, 2], [1, 3], [1, 8], [2, 19], [5, 7]]",5819.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 24, 'edges': [{'u': 'J', 'v': 'M', 'w': 1387.0}, {'u': 'F', 'v': 'S', 'w': 867.0}, {'u': 'K', 'v': 'T', 'w': 1377.0}, {'u': 'L', 'v': 'C', 'w': 1071.0}, {'u': 'L', 'v': 'M', 'w': 1050.0}, {'u': 'M', 'v': 'O', 'w': 133.0}, {'u': 'N', 'v': 'C', 'w': 238.0}, {'u': 'N', 'v': 'Q', 'w': 1039.0}, {'u': 'N', 'v': 'B', 'w': 492.0}, {'u': 'O', 'v': 'E', 'w': 660.0}, {'u': 'O', 'v': 'T', 'w': 892.0}, {'u': 'P', 'v': 'G', 'w': 1.0}, {'u': 'P', 'v': 'I', 'w': 393.0}, {'u': 'P', 'v': 'H', 'w': 318.0}, {'u': 'A', 'v': 'B', 'w': 279.0}, {'u': 'A', 'v': 'C', 'w': 513.0}, {'u': 'A', 'v': 'H', 'w': 256.0}, {'u': 'B', 'v': 'S', 'w': 159.0}, {'u': 'D', 'v': 'E', 'w': 323.0}, {'u': 'D', 'v': 'H', 'w': 366.0}, {'u': 'E', 'v': 'G', 'w': 364.0}, {'u': 'H', 'v': 'I', 'w': 80.0}, {'u': 'I', 'v': 'S', 'w': 289.0}, {'u': 'Q', 'v': 'R', 'w': 236.0}], 'density': 0.12631578947368421, 'source_file': 'I050.stp', 'terminals': ['B', 'C', 'F', 'G', 'K', 'M']}","[['F', 'S'], ['K', 'T'], ['M', 'O'], ['E', 'O'], ['O', 'T'], ['G', 'P'], ['H', 'P'], ['A', 'B'], ['A', 'C'], ['A', 'H'], ['B', 'S'], ['E', 'G']]",9,json,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.

The concrete layout has 16 nodes, 20 aisle segments, and the priority bays are at 0 2 3 4 6 9 13 15.
I see an aisle between node 4 and node 0 with length 624.0.
I see an aisle between node 4 and node 9 with length 106.0.
I see an aisle between node 4 and node 2 with length 1234.0.
I see an aisle between node 7 and node 3 with length 32.0.
I see an aisle between node 7 and node 10 with length 1042.0.
I see an aisle between node 7 and node 6 with length 295.0.
I see an aisle between node 6 and node 8 with length 792.0.
I see an aisle between node 0 and node 3 with length 1368.0.
I see an aisle between node 11 and node 1 with length 363.0.
I see an aisle between node 11 and node 12 with length 540.0.
I see an aisle between node 11 and node 2 with length 1244.0.
I see an aisle between node 11 and node 14 with length 760.0.
I see an aisle between node 12 and node 14 with length 365.0.
I see an aisle between node 13 and node 15 with length 269.0.
I see an aisle between node 10 and node 9 with length 1323.0.
I see an aisle between node 10 and node 5 with length 424.0.
I see an aisle between node 8 and node 5 with length 2017.0.
I see an aisle between node 9 and node 15 with length 1059.0.
I see an aisle between node 2 and node 3 with length 745.0.
I see an aisle between node 14 and node 15 with length 209.0.
I’ll aim to minimize the total cleared distance while keeping all 0 2 3 4 6 9 13 15 connected.

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': 16, 'num_edges': 20, 'edges': [{'u': 5, 'v': 1, 'w': 624.0}, {'u': 5, 'v': 10, 'w': 106.0}, {'u': 5, 'v': 3, 'w': 1234.0}, {'u': 8, 'v': 4, 'w': 32.0}, {'u': 8, 'v': 11, 'w': 1042.0}, {'u': 8, 'v': 7, 'w': 295.0}, {'u': 7, 'v': 9, 'w': 792.0}, {'u': 1, 'v': 4, 'w': 1368.0}, {'u': 12, 'v': 2, 'w': 363.0}, {'u': 12, 'v': 13, 'w': 540.0}, {'u': 12, 'v': 3, 'w': 1244.0}, {'u': 12, 'v': 15, 'w': 760.0}, {'u': 13, 'v': 15, 'w': 365.0}, {'u': 14, 'v': 16, 'w': 269.0}, {'u': 11, 'v': 10, 'w': 1323.0}, {'u': 11, 'v': 6, 'w': 424.0}, {'u': 9, 'v': 6, 'w': 2017.0}, {'u': 10, 'v': 16, 'w': 1059.0}, {'u': 3, 'v': 4, 'w': 745.0}, {'u': 15, 'v': 16, 'w': 209.0}], 'terminals': [1, 3, 4, 5, 7, 10, 14, 16], 'source_file': 'I061.stp', 'density': 0.16666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0009.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0009.png'}","[[1, 5], [5, 10], [3, 5], [4, 8], [7, 8], [14, 16], [10, 16], [3, 4]]",4364.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 20, 'edges': [{'u': 4, 'v': 0, 'w': 624.0}, {'u': 4, 'v': 9, 'w': 106.0}, {'u': 4, 'v': 2, 'w': 1234.0}, {'u': 7, 'v': 3, 'w': 32.0}, {'u': 7, 'v': 10, 'w': 1042.0}, {'u': 7, 'v': 6, 'w': 295.0}, {'u': 6, 'v': 8, 'w': 792.0}, {'u': 0, 'v': 3, 'w': 1368.0}, {'u': 11, 'v': 1, 'w': 363.0}, {'u': 11, 'v': 12, 'w': 540.0}, {'u': 11, 'v': 2, 'w': 1244.0}, {'u': 11, 'v': 14, 'w': 760.0}, {'u': 12, 'v': 14, 'w': 365.0}, {'u': 13, 'v': 15, 'w': 269.0}, {'u': 10, 'v': 9, 'w': 1323.0}, {'u': 10, 'v': 5, 'w': 424.0}, {'u': 8, 'v': 5, 'w': 2017.0}, {'u': 9, 'v': 15, 'w': 1059.0}, {'u': 2, 'v': 3, 'w': 745.0}, {'u': 14, 'v': 15, 'w': 209.0}], 'density': 0.16666666666666666, 'source_file': 'I061.stp', 'terminals': [0, 2, 3, 4, 6, 9, 13, 15]}","[[0, 4], [4, 9], [2, 4], [3, 7], [6, 7], [13, 15], [9, 15], [2, 3]]",10,markdown_table,0
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.

{
  ""total_platforms_and_junctions"": 17,
  ""total_repairable_segments"": 18,
  ""edges"": [
    {
      ""segment_endpoint_a"": 13,
      ""segment_endpoint_b"": 11,
      ""repair_cost"": 1625.0
    },
    {
      ""segment_endpoint_a"": 14,
      ""segment_endpoint_b"": 16,
      ""repair_cost"": 371.0
    },
    {
      ""segment_endpoint_a"": 0,
      ""segment_endpoint_b"": 1,
      ""repair_cost"": 874.0
    },
    {
      ""segment_endpoint_a"": 0,
      ""segment_endpoint_b"": 5,
      ""repair_cost"": 268672.0
    },
    {
      ""segment_endpoint_a"": 1,
      ""segment_endpoint_b"": 7,
      ""repair_cost"": 542.0
    },
    {
      ""segment_endpoint_a"": 2,
      ""segment_endpoint_b"": 5,
      ""repair_cost"": 269381.0
    },
    {
      ""segment_endpoint_a"": 2,
      ""segment_endpoint_b"": 9,
      ""repair_cost"": 534.0
    },
    {
      ""segment_endpoint_a"": 15,
      ""segment_endpoint_b"": 16,
      ""repair_cost"": 302.0
    },
    {
      ""segment_endpoint_a"": 16,
      ""segment_endpoint_b"": 12,
      ""repair_cost"": 1070.0
    },
    {
      ""segment_endpoint_a"": 3,
      ""segment_endpoint_b"": 11,
      ""repair_cost"": 319.0
    },
    {
      ""segment_endpoint_a"": 3,
      ""segment_endpoint_b"": 12,
      ""repair_cost"": 202.0
    },
    {
      ""segment_endpoint_a"": 3,
      ""segment_endpoint_b"": 4,
      ""repair_cost"": 306951.0
    },
    {
      ""segment_endpoint_a"": 9,
      ""segment_endpoint_b"": 8,
      ""repair_cost"": 430.0
    },
    {
      ""segment_endpoint_a"": 9,
      ""segment_endpoint_b"": 11,
      ""repair_cost"": 628.0
    },
    {
      ""segment_endpoint_a"": 8,
      ""segment_endpoint_b"": 10,
      ""repair_cost"": 462.0
    },
    {
      ""segment_endpoint_a"": 8,
      ""segment_endpoint_b"": 7,
      ""repair_cost"": 1343.0
    },
    {
      ""segment_endpoint_a"": 6,
      ""segment_endpoint_b"": 7,
      ""repair_cost"": 696.0
    },
    {
      ""segment_endpoint_a"": 10,
      ""segment_endpoint_b"": 12,
      ""repair_cost"": 904.0
    }
  ],
  ""required_observation_platforms"": [
    1,
    2,
    3,
    8,
    9,
    10,
    12,
    13
  ]
}

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': 17, 'num_edges': 18, 'edges': [{'u': 14, 'v': 12, 'w': 1625.0}, {'u': 15, 'v': 17, 'w': 371.0}, {'u': 1, 'v': 2, 'w': 874.0}, {'u': 1, 'v': 6, 'w': 268672.0}, {'u': 2, 'v': 8, 'w': 542.0}, {'u': 3, 'v': 6, 'w': 269381.0}, {'u': 3, 'v': 10, 'w': 534.0}, {'u': 16, 'v': 17, 'w': 302.0}, {'u': 17, 'v': 13, 'w': 1070.0}, {'u': 4, 'v': 12, 'w': 319.0}, {'u': 4, 'v': 13, 'w': 202.0}, {'u': 4, 'v': 5, 'w': 306951.0}, {'u': 10, 'v': 9, 'w': 430.0}, {'u': 10, 'v': 12, 'w': 628.0}, {'u': 9, 'v': 11, 'w': 462.0}, {'u': 9, 'v': 8, 'w': 1343.0}, {'u': 7, 'v': 8, 'w': 696.0}, {'u': 11, 'v': 13, 'w': 904.0}], 'terminals': [2, 3, 4, 9, 10, 11, 13, 14], 'source_file': 'I075.stp', 'density': 0.1323529411764706, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0010.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0010.png'}","[[12, 14], [2, 8], [3, 10], [4, 12], [4, 13], [9, 10], [10, 12], [9, 11], [8, 9]]",6085.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 18, 'edges': [{'u': 13, 'v': 11, 'w': 1625.0}, {'u': 14, 'v': 16, 'w': 371.0}, {'u': 0, 'v': 1, 'w': 874.0}, {'u': 0, 'v': 5, 'w': 268672.0}, {'u': 1, 'v': 7, 'w': 542.0}, {'u': 2, 'v': 5, 'w': 269381.0}, {'u': 2, 'v': 9, 'w': 534.0}, {'u': 15, 'v': 16, 'w': 302.0}, {'u': 16, 'v': 12, 'w': 1070.0}, {'u': 3, 'v': 11, 'w': 319.0}, {'u': 3, 'v': 12, 'w': 202.0}, {'u': 3, 'v': 4, 'w': 306951.0}, {'u': 9, 'v': 8, 'w': 430.0}, {'u': 9, 'v': 11, 'w': 628.0}, {'u': 8, 'v': 10, 'w': 462.0}, {'u': 8, 'v': 7, 'w': 1343.0}, {'u': 6, 'v': 7, 'w': 696.0}, {'u': 10, 'v': 12, 'w': 904.0}], 'density': 0.1323529411764706, 'source_file': 'I075.stp', 'terminals': [1, 2, 3, 8, 9, 10, 12, 13]}","[[11, 13], [1, 7], [2, 9], [3, 11], [3, 12], [8, 9], [9, 11], [8, 10], [7, 8]]",11,json,0
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.

# campus_node_count=20
# available_link_count=24
# key_buildings=A L M Q
link_endpoint_a,link_endpoint_b,link_length
T,Q,725.0
T,S,613.0
T,I,418.0
L,I,316.0
L,K,553.0
Q,P,71.0
Q,S,1090.0
N,E,1874.0
R,C,206.0
A,O,1054.0
A,F,649.0
M,J,2096.0
B,D,26.0
C,P,1173.0
C,D,1330.0
D,E,735.0
O,G,45.0
O,P,534.0
E,F,1233.0
F,H,104.0
G,I,1290.0
G,H,974.0
H,J,329.0
J,K,1363.0

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': 20, 'num_edges': 24, 'edges': [{'u': 20, 'v': 17, 'w': 725.0}, {'u': 20, 'v': 19, 'w': 613.0}, {'u': 20, 'v': 9, 'w': 418.0}, {'u': 12, 'v': 9, 'w': 316.0}, {'u': 12, 'v': 11, 'w': 553.0}, {'u': 17, 'v': 16, 'w': 71.0}, {'u': 17, 'v': 19, 'w': 1090.0}, {'u': 14, 'v': 5, 'w': 1874.0}, {'u': 18, 'v': 3, 'w': 206.0}, {'u': 1, 'v': 15, 'w': 1054.0}, {'u': 1, 'v': 6, 'w': 649.0}, {'u': 13, 'v': 10, 'w': 2096.0}, {'u': 2, 'v': 4, 'w': 26.0}, {'u': 3, 'v': 16, 'w': 1173.0}, {'u': 3, 'v': 4, 'w': 1330.0}, {'u': 4, 'v': 5, 'w': 735.0}, {'u': 15, 'v': 7, 'w': 45.0}, {'u': 15, 'v': 16, 'w': 534.0}, {'u': 5, 'v': 6, 'w': 1233.0}, {'u': 6, 'v': 8, 'w': 104.0}, {'u': 7, 'v': 9, 'w': 1290.0}, {'u': 7, 'v': 8, 'w': 974.0}, {'u': 8, 'v': 10, 'w': 329.0}, {'u': 10, 'v': 11, 'w': 1363.0}], 'terminals': [1, 12, 13, 17], 'source_file': 'I023.stp', 'density': 0.12631578947368421, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0011.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0011.png'}","[[17, 20], [9, 20], [9, 12], [16, 17], [1, 6], [10, 13], [7, 15], [15, 16], [6, 8], [7, 8], [8, 10]]",6261.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 24, 'edges': [{'u': 'T', 'v': 'Q', 'w': 725.0}, {'u': 'T', 'v': 'S', 'w': 613.0}, {'u': 'T', 'v': 'I', 'w': 418.0}, {'u': 'L', 'v': 'I', 'w': 316.0}, {'u': 'L', 'v': 'K', 'w': 553.0}, {'u': 'Q', 'v': 'P', 'w': 71.0}, {'u': 'Q', 'v': 'S', 'w': 1090.0}, {'u': 'N', 'v': 'E', 'w': 1874.0}, {'u': 'R', 'v': 'C', 'w': 206.0}, {'u': 'A', 'v': 'O', 'w': 1054.0}, {'u': 'A', 'v': 'F', 'w': 649.0}, {'u': 'M', 'v': 'J', 'w': 2096.0}, {'u': 'B', 'v': 'D', 'w': 26.0}, {'u': 'C', 'v': 'P', 'w': 1173.0}, {'u': 'C', 'v': 'D', 'w': 1330.0}, {'u': 'D', 'v': 'E', 'w': 735.0}, {'u': 'O', 'v': 'G', 'w': 45.0}, {'u': 'O', 'v': 'P', 'w': 534.0}, {'u': 'E', 'v': 'F', 'w': 1233.0}, {'u': 'F', 'v': 'H', 'w': 104.0}, {'u': 'G', 'v': 'I', 'w': 1290.0}, {'u': 'G', 'v': 'H', 'w': 974.0}, {'u': 'H', 'v': 'J', 'w': 329.0}, {'u': 'J', 'v': 'K', 'w': 1363.0}], 'density': 0.12631578947368421, 'source_file': 'I023.stp', 'terminals': ['A', 'L', 'M', 'Q']}","[['Q', 'T'], ['I', 'T'], ['I', 'L'], ['P', 'Q'], ['A', 'F'], ['J', 'M'], ['G', 'O'], ['O', 'P'], ['F', 'H'], ['G', 'H'], ['H', 'J']]",12,csv,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.

{
  ""num_locations"": 17,
  ""num_delivery_lanes"": 20,
  ""edges"": [
    {
      ""location_u"": 12,
      ""location_v"": 2,
      ""route_distance"": 477.0
    },
    {
      ""location_u"": 12,
      ""location_v"": 13,
      ""route_distance"": 607.0
    },
    {
      ""location_u"": 14,
      ""location_v"": 11,
      ""route_distance"": 498.0
    },
    {
      ""location_u"": 14,
      ""location_v"": 9,
      ""route_distance"": 1300.0
    },
    {
      ""location_u"": 14,
      ""location_v"": 16,
      ""route_distance"": 1048.0
    },
    {
      ""location_u"": 0,
      ""location_v"": 5,
      ""route_distance"": 623.0
    },
    {
      ""location_u"": 0,
      ""location_v"": 7,
      ""route_distance"": 1406.0
    },
    {
      ""location_u"": 13,
      ""location_v"": 3,
      ""route_distance"": 1107.0
    },
    {
      ""location_u"": 13,
      ""location_v"": 4,
      ""route_distance"": 229.0
    },
    {
      ""location_u"": 1,
      ""location_v"": 2,
      ""route_distance"": 281656.0
    },
    {
      ""location_u"": 1,
      ""location_v"": 3,
      ""route_distance"": 281656.0
    },
    {
      ""location_u"": 2,
      ""location_v"": 11,
      ""route_distance"": 1089.0
    },
    {
      ""location_u"": 3,
      ""location_v"": 6,
      ""route_distance"": 922.0
    },
    {
      ""location_u"": 15,
      ""location_v"": 10,
      ""route_distance"": 111.0
    },
    {
      ""location_u"": 15,
      ""location_v"": 9,
      ""route_distance"": 530.0
    },
    {
      ""location_u"": 16,
      ""location_v"": 5,
      ""route_distance"": 1128.0
    },
    {
      ""location_u"": 6,
      ""location_v"": 5,
      ""route_distance"": 1097.0
    },
    {
      ""location_u"": 6,
      ""location_v"": 11,
      ""route_distance"": 230.0
    },
    {
      ""location_u"": 8,
      ""location_v"": 7,
      ""route_distance"": 897.0
    },
    {
      ""location_u"": 7,
      ""location_v"": 4,
      ""route_distance"": 1628.0
    }
  ],
  ""flagship_locations"": [
    3,
    6,
    7,
    12,
    15,
    16
  ]
}

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': 17, 'num_edges': 20, 'edges': [{'u': 13, 'v': 3, 'w': 477.0}, {'u': 13, 'v': 14, 'w': 607.0}, {'u': 15, 'v': 12, 'w': 498.0}, {'u': 15, 'v': 10, 'w': 1300.0}, {'u': 15, 'v': 17, 'w': 1048.0}, {'u': 1, 'v': 6, 'w': 623.0}, {'u': 1, 'v': 8, 'w': 1406.0}, {'u': 14, 'v': 4, 'w': 1107.0}, {'u': 14, 'v': 5, 'w': 229.0}, {'u': 2, 'v': 3, 'w': 281656.0}, {'u': 2, 'v': 4, 'w': 281656.0}, {'u': 3, 'v': 12, 'w': 1089.0}, {'u': 4, 'v': 7, 'w': 922.0}, {'u': 16, 'v': 11, 'w': 111.0}, {'u': 16, 'v': 10, 'w': 530.0}, {'u': 17, 'v': 6, 'w': 1128.0}, {'u': 7, 'v': 6, 'w': 1097.0}, {'u': 7, 'v': 12, 'w': 230.0}, {'u': 9, 'v': 8, 'w': 897.0}, {'u': 8, 'v': 5, 'w': 1628.0}], 'terminals': [4, 7, 8, 13, 16, 17], 'source_file': 'I045.stp', 'density': 0.14705882352941177, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0012.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0012.png'}","[[13, 14], [12, 15], [10, 15], [15, 17], [4, 14], [5, 14], [4, 7], [10, 16], [7, 12], [5, 8]]",8099.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 20, 'edges': [{'u': 12, 'v': 2, 'w': 477.0}, {'u': 12, 'v': 13, 'w': 607.0}, {'u': 14, 'v': 11, 'w': 498.0}, {'u': 14, 'v': 9, 'w': 1300.0}, {'u': 14, 'v': 16, 'w': 1048.0}, {'u': 0, 'v': 5, 'w': 623.0}, {'u': 0, 'v': 7, 'w': 1406.0}, {'u': 13, 'v': 3, 'w': 1107.0}, {'u': 13, 'v': 4, 'w': 229.0}, {'u': 1, 'v': 2, 'w': 281656.0}, {'u': 1, 'v': 3, 'w': 281656.0}, {'u': 2, 'v': 11, 'w': 1089.0}, {'u': 3, 'v': 6, 'w': 922.0}, {'u': 15, 'v': 10, 'w': 111.0}, {'u': 15, 'v': 9, 'w': 530.0}, {'u': 16, 'v': 5, 'w': 1128.0}, {'u': 6, 'v': 5, 'w': 1097.0}, {'u': 6, 'v': 11, 'w': 230.0}, {'u': 8, 'v': 7, 'w': 897.0}, {'u': 7, 'v': 4, 'w': 1628.0}], 'density': 0.14705882352941177, 'source_file': 'I045.stp', 'terminals': [3, 6, 7, 12, 15, 16]}","[[12, 13], [11, 14], [9, 14], [14, 16], [3, 13], [4, 13], [3, 6], [9, 15], [6, 11], [4, 7]]",13,json,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=20
# available_pipe_segments=26
# required_treatment_plants=2 3 4 7 9 10 11 16 17 19
endpoint_a,endpoint_b,segment_length
15,18,113.0
15,9,23.0
9,8,119.0
9,11,91.0
16,17,834.0
16,1,1446.0
16,14,1095.0
16,2,1277.0
17,18,450.0
17,7,125.0
18,8,44.0
19,3,1156.0
19,20,1368.0
19,2,1532.0
2,4,260306.0
3,12,261.0
3,13,644.0
4,5,259932.0
5,10,458.0
5,7,92.0
6,1,656.0
7,8,457.0
8,10,92.0
10,11,136.0
11,12,218.0
12,13,385.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': 20, 'num_edges': 26, 'edges': [{'u': 15, 'v': 18, 'w': 113.0}, {'u': 15, 'v': 9, 'w': 23.0}, {'u': 9, 'v': 8, 'w': 119.0}, {'u': 9, 'v': 11, 'w': 91.0}, {'u': 16, 'v': 17, 'w': 834.0}, {'u': 16, 'v': 1, 'w': 1446.0}, {'u': 16, 'v': 14, 'w': 1095.0}, {'u': 16, 'v': 2, 'w': 1277.0}, {'u': 17, 'v': 18, 'w': 450.0}, {'u': 17, 'v': 7, 'w': 125.0}, {'u': 18, 'v': 8, 'w': 44.0}, {'u': 19, 'v': 3, 'w': 1156.0}, {'u': 19, 'v': 20, 'w': 1368.0}, {'u': 19, 'v': 2, 'w': 1532.0}, {'u': 2, 'v': 4, 'w': 260306.0}, {'u': 3, 'v': 12, 'w': 261.0}, {'u': 3, 'v': 13, 'w': 644.0}, {'u': 4, 'v': 5, 'w': 259932.0}, {'u': 5, 'v': 10, 'w': 458.0}, {'u': 5, 'v': 7, 'w': 92.0}, {'u': 6, 'v': 1, 'w': 656.0}, {'u': 7, 'v': 8, 'w': 457.0}, {'u': 8, 'v': 10, 'w': 92.0}, {'u': 10, 'v': 11, 'w': 136.0}, {'u': 11, 'v': 12, 'w': 218.0}, {'u': 12, 'v': 13, 'w': 385.0}], 'terminals': [2, 3, 4, 7, 9, 10, 11, 16, 17, 19], 'source_file': 'I044.stp', 'density': 0.1368421052631579, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0013.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0013.png'}","[[9, 11], [16, 17], [2, 16], [7, 17], [3, 19], [3, 12], [4, 5], [5, 10], [5, 7], [10, 11], [11, 12]]",264580.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 26, 'edges': [{'u': 15, 'v': 18, 'w': 113.0}, {'u': 15, 'v': 9, 'w': 23.0}, {'u': 9, 'v': 8, 'w': 119.0}, {'u': 9, 'v': 11, 'w': 91.0}, {'u': 16, 'v': 17, 'w': 834.0}, {'u': 16, 'v': 1, 'w': 1446.0}, {'u': 16, 'v': 14, 'w': 1095.0}, {'u': 16, 'v': 2, 'w': 1277.0}, {'u': 17, 'v': 18, 'w': 450.0}, {'u': 17, 'v': 7, 'w': 125.0}, {'u': 18, 'v': 8, 'w': 44.0}, {'u': 19, 'v': 3, 'w': 1156.0}, {'u': 19, 'v': 20, 'w': 1368.0}, {'u': 19, 'v': 2, 'w': 1532.0}, {'u': 2, 'v': 4, 'w': 260306.0}, {'u': 3, 'v': 12, 'w': 261.0}, {'u': 3, 'v': 13, 'w': 644.0}, {'u': 4, 'v': 5, 'w': 259932.0}, {'u': 5, 'v': 10, 'w': 458.0}, {'u': 5, 'v': 7, 'w': 92.0}, {'u': 6, 'v': 1, 'w': 656.0}, {'u': 7, 'v': 8, 'w': 457.0}, {'u': 8, 'v': 10, 'w': 92.0}, {'u': 10, 'v': 11, 'w': 136.0}, {'u': 11, 'v': 12, 'w': 218.0}, {'u': 12, 'v': 13, 'w': 385.0}], 'density': 0.1368421052631579, 'source_file': 'I044.stp', 'terminals': [2, 3, 4, 7, 9, 10, 11, 16, 17, 19]}","[[9, 11], [16, 17], [2, 16], [7, 17], [3, 19], [3, 12], [4, 5], [5, 10], [5, 7], [10, 11], [11, 12]]",14,csv,1
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 16 locations, 20 available runs, and the required landmark trees are 8 9 12.
Candidate run connecting 16 and 4 with length 21.0.
Candidate run connecting 11 and 10 with length 1390.0.
Candidate run connecting 11 and 2 with length 490.0.
Candidate run connecting 11 and 12 with length 861.0.
Candidate run connecting 2 and 3 with length 468.0.
Candidate run connecting 2 and 6 with length 229.0.
Candidate run connecting 9 and 10 with length 1094.0.
Candidate run connecting 3 and 15 with length 229.0.
Candidate run connecting 3 and 5 with length 729.0.
Candidate run connecting 10 and 1 with length 837.0.
Candidate run connecting 12 and 7 with length 828.0.
Candidate run connecting 12 and 4 with length 740.0.
Candidate run connecting 12 and 14 with length 394.0.
Candidate run connecting 5 and 13 with length 632.0.
Candidate run connecting 4 and 14 with length 347.0.
Candidate run connecting 13 and 7 with length 469.0.
Candidate run connecting 13 and 15 with length 142.0.
Candidate run connecting 14 and 8 with length 205.0.
Candidate run connecting 15 and 6 with length 469.0.
Candidate run connecting 6 and 7 with length 141.0.
Select runs that join all 8 9 12 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': 16, 'num_edges': 20, 'edges': [{'u': 16, 'v': 4, 'w': 21.0}, {'u': 11, 'v': 10, 'w': 1390.0}, {'u': 11, 'v': 2, 'w': 490.0}, {'u': 11, 'v': 12, 'w': 861.0}, {'u': 2, 'v': 3, 'w': 468.0}, {'u': 2, 'v': 6, 'w': 229.0}, {'u': 9, 'v': 10, 'w': 1094.0}, {'u': 3, 'v': 15, 'w': 229.0}, {'u': 3, 'v': 5, 'w': 729.0}, {'u': 10, 'v': 1, 'w': 837.0}, {'u': 12, 'v': 7, 'w': 828.0}, {'u': 12, 'v': 4, 'w': 740.0}, {'u': 12, 'v': 14, 'w': 394.0}, {'u': 5, 'v': 13, 'w': 632.0}, {'u': 4, 'v': 14, 'w': 347.0}, {'u': 13, 'v': 7, 'w': 469.0}, {'u': 13, 'v': 15, 'w': 142.0}, {'u': 14, 'v': 8, 'w': 205.0}, {'u': 15, 'v': 6, 'w': 469.0}, {'u': 6, 'v': 7, 'w': 141.0}], 'terminals': [8, 9, 12], 'source_file': 'I019.stp', 'density': 0.16666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0014.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0014.png'}","[[10, 11], [11, 12], [9, 10], [12, 14], [8, 14]]",3944.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 20, 'edges': [{'u': 16, 'v': 4, 'w': 21.0}, {'u': 11, 'v': 10, 'w': 1390.0}, {'u': 11, 'v': 2, 'w': 490.0}, {'u': 11, 'v': 12, 'w': 861.0}, {'u': 2, 'v': 3, 'w': 468.0}, {'u': 2, 'v': 6, 'w': 229.0}, {'u': 9, 'v': 10, 'w': 1094.0}, {'u': 3, 'v': 15, 'w': 229.0}, {'u': 3, 'v': 5, 'w': 729.0}, {'u': 10, 'v': 1, 'w': 837.0}, {'u': 12, 'v': 7, 'w': 828.0}, {'u': 12, 'v': 4, 'w': 740.0}, {'u': 12, 'v': 14, 'w': 394.0}, {'u': 5, 'v': 13, 'w': 632.0}, {'u': 4, 'v': 14, 'w': 347.0}, {'u': 13, 'v': 7, 'w': 469.0}, {'u': 13, 'v': 15, 'w': 142.0}, {'u': 14, 'v': 8, 'w': 205.0}, {'u': 15, 'v': 6, 'w': 469.0}, {'u': 6, 'v': 7, 'w': 141.0}], 'density': 0.16666666666666666, 'source_file': 'I019.stp', 'terminals': [8, 9, 12]}","[[10, 11], [11, 12], [9, 10], [12, 14], [8, 14]]",15,nl,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"": 19,
  ""total_road_segments"": 22,
  ""edges"": [
    {
      ""segment_endpoint_a"": ""N"",
      ""segment_endpoint_b"": ""G"",
      ""segment_length"": 217.0
    },
    {
      ""segment_endpoint_a"": ""N"",
      ""segment_endpoint_b"": ""H"",
      ""segment_length"": 589.0
    },
    {
      ""segment_endpoint_a"": ""N"",
      ""segment_endpoint_b"": ""B"",
      ""segment_length"": 679.0
    },
    {
      ""segment_endpoint_a"": ""J"",
      ""segment_endpoint_b"": ""L"",
      ""segment_length"": 3395.0
    },
    {
      ""segment_endpoint_a"": ""F"",
      ""segment_endpoint_b"": ""G"",
      ""segment_length"": 588.0
    },
    {
      ""segment_endpoint_a"": ""F"",
      ""segment_endpoint_b"": ""H"",
      ""segment_length"": 214.0
    },
    {
      ""segment_endpoint_a"": ""G"",
      ""segment_endpoint_b"": ""P"",
      ""segment_length"": 1183.0
    },
    {
      ""segment_endpoint_a"": ""H"",
      ""segment_endpoint_b"": ""D"",
      ""segment_length"": 204.0
    },
    {
      ""segment_endpoint_a"": ""O"",
      ""segment_endpoint_b"": ""D"",
      ""segment_length"": 866.0
    },
    {
      ""segment_endpoint_a"": ""I"",
      ""segment_endpoint_b"": ""K"",
      ""segment_length"": 2565.0
    },
    {
      ""segment_endpoint_a"": ""I"",
      ""segment_endpoint_b"": ""L"",
      ""segment_length"": 1078.0
    },
    {
      ""segment_endpoint_a"": ""Q"",
      ""segment_endpoint_b"": ""K"",
      ""segment_length"": 1161.0
    },
    {
      ""segment_endpoint_a"": ""Q"",
      ""segment_endpoint_b"": ""S"",
      ""segment_length"": 367.0
    },
    {
      ""segment_endpoint_a"": ""R"",
      ""segment_endpoint_b"": ""E"",
      ""segment_length"": 517.0
    },
    {
      ""segment_endpoint_a"": ""R"",
      ""segment_endpoint_b"": ""S"",
      ""segment_length"": 1312.0
    },
    {
      ""segment_endpoint_a"": ""L"",
      ""segment_endpoint_b"": ""M"",
      ""segment_length"": 204.0
    },
    {
      ""segment_endpoint_a"": ""M"",
      ""segment_endpoint_b"": ""C"",
      ""segment_length"": 521.0
    },
    {
      ""segment_endpoint_a"": ""M"",
      ""segment_endpoint_b"": ""B"",
      ""segment_length"": 943.0
    },
    {
      ""segment_endpoint_a"": ""A"",
      ""segment_endpoint_b"": ""B"",
      ""segment_length"": 491.0
    },
    {
      ""segment_endpoint_a"": ""A"",
      ""segment_endpoint_b"": ""C"",
      ""segment_length"": 927.0
    },
    {
      ""segment_endpoint_a"": ""C"",
      ""segment_endpoint_b"": ""E"",
      ""segment_length"": 315.0
    },
    {
      ""segment_endpoint_a"": ""D"",
      ""segment_endpoint_b"": ""E"",
      ""segment_length"": 1604.0
    }
  ],
  ""hydrant_locations"": [
    ""B"",
    ""C"",
    ""D"",
    ""E"",
    ""I"",
    ""J"",
    ""N"",
    ""R"",
    ""S""
  ]
}

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': 19, 'num_edges': 22, 'edges': [{'u': 14, 'v': 7, 'w': 217.0}, {'u': 14, 'v': 8, 'w': 589.0}, {'u': 14, 'v': 2, 'w': 679.0}, {'u': 10, 'v': 12, 'w': 3395.0}, {'u': 6, 'v': 7, 'w': 588.0}, {'u': 6, 'v': 8, 'w': 214.0}, {'u': 7, 'v': 16, 'w': 1183.0}, {'u': 8, 'v': 4, 'w': 204.0}, {'u': 15, 'v': 4, 'w': 866.0}, {'u': 9, 'v': 11, 'w': 2565.0}, {'u': 9, 'v': 12, 'w': 1078.0}, {'u': 17, 'v': 11, 'w': 1161.0}, {'u': 17, 'v': 19, 'w': 367.0}, {'u': 18, 'v': 5, 'w': 517.0}, {'u': 18, 'v': 19, 'w': 1312.0}, {'u': 12, 'v': 13, 'w': 204.0}, {'u': 13, 'v': 3, 'w': 521.0}, {'u': 13, 'v': 2, 'w': 943.0}, {'u': 1, 'v': 2, 'w': 491.0}, {'u': 1, 'v': 3, 'w': 927.0}, {'u': 3, 'v': 5, 'w': 315.0}, {'u': 4, 'v': 5, 'w': 1604.0}], 'terminals': [2, 3, 4, 5, 9, 10, 14, 18, 19], 'source_file': 'I047.stp', 'density': 0.1286549707602339, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0015.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0015.png'}","[[8, 14], [2, 14], [10, 12], [4, 8], [9, 12], [5, 18], [18, 19], [12, 13], [3, 13], [2, 13], [3, 5]]",9757.0,"{'problem_type': 'STP', 'num_nodes': 19, 'num_edges': 22, 'edges': [{'u': 'N', 'v': 'G', 'w': 217.0}, {'u': 'N', 'v': 'H', 'w': 589.0}, {'u': 'N', 'v': 'B', 'w': 679.0}, {'u': 'J', 'v': 'L', 'w': 3395.0}, {'u': 'F', 'v': 'G', 'w': 588.0}, {'u': 'F', 'v': 'H', 'w': 214.0}, {'u': 'G', 'v': 'P', 'w': 1183.0}, {'u': 'H', 'v': 'D', 'w': 204.0}, {'u': 'O', 'v': 'D', 'w': 866.0}, {'u': 'I', 'v': 'K', 'w': 2565.0}, {'u': 'I', 'v': 'L', 'w': 1078.0}, {'u': 'Q', 'v': 'K', 'w': 1161.0}, {'u': 'Q', 'v': 'S', 'w': 367.0}, {'u': 'R', 'v': 'E', 'w': 517.0}, {'u': 'R', 'v': 'S', 'w': 1312.0}, {'u': 'L', 'v': 'M', 'w': 204.0}, {'u': 'M', 'v': 'C', 'w': 521.0}, {'u': 'M', 'v': 'B', 'w': 943.0}, {'u': 'A', 'v': 'B', 'w': 491.0}, {'u': 'A', 'v': 'C', 'w': 927.0}, {'u': 'C', 'v': 'E', 'w': 315.0}, {'u': 'D', 'v': 'E', 'w': 1604.0}], 'density': 0.1286549707602339, 'source_file': 'I047.stp', 'terminals': ['B', 'C', 'D', 'E', 'I', 'J', 'N', 'R', 'S']}","[['H', 'N'], ['B', 'N'], ['J', 'L'], ['D', 'H'], ['I', 'L'], ['E', 'R'], ['R', 'S'], ['L', 'M'], ['C', 'M'], ['B', 'M'], ['C', 'E']]",16,json,names
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: 18 total pavement nodes, 22 possible clear segments, assigned gates E F H J L.
Segment between I and J: clearing length 97.0 m.
Segment between I and M: clearing length 49.0 m.
Segment between I and D: clearing length 760.0 m.
Segment between J and N: clearing length 65.0 m.
Segment between J and C: clearing length 770.0 m.
Segment between K and E: clearing length 491.0 m.
Segment between K and L: clearing length 357.0 m.
Segment between K and Q: clearing length 205.0 m.
Segment between L and G: clearing length 291.0 m.
Segment between L and R: clearing length 168.0 m.
Segment between N and M: clearing length 87.0 m.
Segment between N and O: clearing length 1016.0 m.
Segment between O and P: clearing length 833.0 m.
Segment between A and B: clearing length 361.0 m.
Segment between B and D: clearing length 111.0 m.
Segment between P and F: clearing length 134.0 m.
Segment between C and D: clearing length 224.0 m.
Segment between C and H: clearing length 285760.0 m.
Segment between E and F: clearing length 255.0 m.
Segment between E and H: clearing length 285388.0 m.
Segment between F and Q: clearing length 488.0 m.
Segment between Q and R: clearing length 338.0 m.
The plow crew must select a subset of these segments that places all E F H J L 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': 18, 'num_edges': 22, 'edges': [{'u': 9, 'v': 10, 'w': 97.0}, {'u': 9, 'v': 13, 'w': 49.0}, {'u': 9, 'v': 4, 'w': 760.0}, {'u': 10, 'v': 14, 'w': 65.0}, {'u': 10, 'v': 3, 'w': 770.0}, {'u': 11, 'v': 5, 'w': 491.0}, {'u': 11, 'v': 12, 'w': 357.0}, {'u': 11, 'v': 17, 'w': 205.0}, {'u': 12, 'v': 7, 'w': 291.0}, {'u': 12, 'v': 18, 'w': 168.0}, {'u': 14, 'v': 13, 'w': 87.0}, {'u': 14, 'v': 15, 'w': 1016.0}, {'u': 15, 'v': 16, 'w': 833.0}, {'u': 1, 'v': 2, 'w': 361.0}, {'u': 2, 'v': 4, 'w': 111.0}, {'u': 16, 'v': 6, 'w': 134.0}, {'u': 3, 'v': 4, 'w': 224.0}, {'u': 3, 'v': 8, 'w': 285760.0}, {'u': 5, 'v': 6, 'w': 255.0}, {'u': 5, 'v': 8, 'w': 285388.0}, {'u': 6, 'v': 17, 'w': 488.0}, {'u': 17, 'v': 18, 'w': 338.0}], 'terminals': [5, 6, 8, 10, 12], 'source_file': 'I017.stp', 'density': 0.1437908496732026, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0016.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0016.png'}","[[10, 14], [5, 11], [11, 12], [14, 15], [15, 16], [6, 16], [5, 6], [5, 8]]",288539.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 22, 'edges': [{'u': 'I', 'v': 'J', 'w': 97.0}, {'u': 'I', 'v': 'M', 'w': 49.0}, {'u': 'I', 'v': 'D', 'w': 760.0}, {'u': 'J', 'v': 'N', 'w': 65.0}, {'u': 'J', 'v': 'C', 'w': 770.0}, {'u': 'K', 'v': 'E', 'w': 491.0}, {'u': 'K', 'v': 'L', 'w': 357.0}, {'u': 'K', 'v': 'Q', 'w': 205.0}, {'u': 'L', 'v': 'G', 'w': 291.0}, {'u': 'L', 'v': 'R', 'w': 168.0}, {'u': 'N', 'v': 'M', 'w': 87.0}, {'u': 'N', 'v': 'O', 'w': 1016.0}, {'u': 'O', 'v': 'P', 'w': 833.0}, {'u': 'A', 'v': 'B', 'w': 361.0}, {'u': 'B', 'v': 'D', 'w': 111.0}, {'u': 'P', 'v': 'F', 'w': 134.0}, {'u': 'C', 'v': 'D', 'w': 224.0}, {'u': 'C', 'v': 'H', 'w': 285760.0}, {'u': 'E', 'v': 'F', 'w': 255.0}, {'u': 'E', 'v': 'H', 'w': 285388.0}, {'u': 'F', 'v': 'Q', 'w': 488.0}, {'u': 'Q', 'v': 'R', 'w': 338.0}], 'density': 0.1437908496732026, 'source_file': 'I017.stp', 'terminals': ['E', 'F', 'H', 'J', 'L']}","[['J', 'N'], ['E', 'K'], ['K', 'L'], ['N', 'O'], ['O', 'P'], ['F', 'P'], ['E', 'F'], ['E', 'H']]",17,nl,names
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.

# total_patches=17
# total_candidate_corridors=20
# protected_patches=A C H J M Q
patch_a,patch_b,restoration_area
I,M,305.0
I,H,1071.0
Q,D,1560.0
Q,K,1180.0
J,C,1698.0
J,G,1330.0
J,L,2530.0
D,B,2597.0
K,L,831.0
L,N,1834.0
C,B,496.0
G,E,2897.0
G,O,353.0
E,M,1330.0
N,F,777.0
M,A,1070.0
F,O,1703.0
P,A,1091.0
B,A,3231.0
A,H,306.0

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': 17, 'num_edges': 20, 'edges': [{'u': 9, 'v': 13, 'w': 305.0}, {'u': 9, 'v': 8, 'w': 1071.0}, {'u': 17, 'v': 4, 'w': 1560.0}, {'u': 17, 'v': 11, 'w': 1180.0}, {'u': 10, 'v': 3, 'w': 1698.0}, {'u': 10, 'v': 7, 'w': 1330.0}, {'u': 10, 'v': 12, 'w': 2530.0}, {'u': 4, 'v': 2, 'w': 2597.0}, {'u': 11, 'v': 12, 'w': 831.0}, {'u': 12, 'v': 14, 'w': 1834.0}, {'u': 3, 'v': 2, 'w': 496.0}, {'u': 7, 'v': 5, 'w': 2897.0}, {'u': 7, 'v': 15, 'w': 353.0}, {'u': 5, 'v': 13, 'w': 1330.0}, {'u': 14, 'v': 6, 'w': 777.0}, {'u': 13, 'v': 1, 'w': 1070.0}, {'u': 6, 'v': 15, 'w': 1703.0}, {'u': 16, 'v': 1, 'w': 1091.0}, {'u': 2, 'v': 1, 'w': 3231.0}, {'u': 1, 'v': 8, 'w': 306.0}], 'terminals': [1, 3, 8, 10, 13, 17], 'source_file': 'I047.stp', 'density': 0.14705882352941177, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0017.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0017.png'}","[[4, 17], [3, 10], [2, 4], [2, 3], [1, 13], [1, 2], [1, 8]]",10958.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 20, 'edges': [{'u': 'I', 'v': 'M', 'w': 305.0}, {'u': 'I', 'v': 'H', 'w': 1071.0}, {'u': 'Q', 'v': 'D', 'w': 1560.0}, {'u': 'Q', 'v': 'K', 'w': 1180.0}, {'u': 'J', 'v': 'C', 'w': 1698.0}, {'u': 'J', 'v': 'G', 'w': 1330.0}, {'u': 'J', 'v': 'L', 'w': 2530.0}, {'u': 'D', 'v': 'B', 'w': 2597.0}, {'u': 'K', 'v': 'L', 'w': 831.0}, {'u': 'L', 'v': 'N', 'w': 1834.0}, {'u': 'C', 'v': 'B', 'w': 496.0}, {'u': 'G', 'v': 'E', 'w': 2897.0}, {'u': 'G', 'v': 'O', 'w': 353.0}, {'u': 'E', 'v': 'M', 'w': 1330.0}, {'u': 'N', 'v': 'F', 'w': 777.0}, {'u': 'M', 'v': 'A', 'w': 1070.0}, {'u': 'F', 'v': 'O', 'w': 1703.0}, {'u': 'P', 'v': 'A', 'w': 1091.0}, {'u': 'B', 'v': 'A', 'w': 3231.0}, {'u': 'A', 'v': 'H', 'w': 306.0}], 'density': 0.14705882352941177, 'source_file': 'I047.stp', 'terminals': ['A', 'C', 'H', 'J', 'M', 'Q']}","[['D', 'Q'], ['C', 'J'], ['B', 'D'], ['B', 'C'], ['A', 'M'], ['A', 'B'], ['A', 'H']]",18,csv,names
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"": 16,
  ""total_truss_segments"": 19,
  ""edges"": [
    {
      ""junction_u"": 15,
      ""junction_v"": 1,
      ""segment_length"": 943.0
    },
    {
      ""junction_u"": 15,
      ""junction_v"": 14,
      ""segment_length"": 3568.0
    },
    {
      ""junction_u"": 0,
      ""junction_v"": 1,
      ""segment_length"": 2496.0
    },
    {
      ""junction_u"": 0,
      ""junction_v"": 10,
      ""segment_length"": 3024.0
    },
    {
      ""junction_u"": 0,
      ""junction_v"": 5,
      ""segment_length"": 1221.0
    },
    {
      ""junction_u"": 0,
      ""junction_v"": 7,
      ""segment_length"": 2108.0
    },
    {
      ""junction_u"": 1,
      ""junction_v"": 13,
      ""segment_length"": 1677.0
    },
    {
      ""junction_u"": 14,
      ""junction_v"": 12,
      ""segment_length"": 1152.0
    },
    {
      ""junction_u"": 14,
      ""junction_v"": 9,
      ""segment_length"": 2144.0
    },
    {
      ""junction_u"": 9,
      ""junction_v"": 3,
      ""segment_length"": 2944.0
    },
    {
      ""junction_u"": 10,
      ""junction_v"": 11,
      ""segment_length"": 1490.0
    },
    {
      ""junction_u"": 10,
      ""junction_v"": 2,
      ""segment_length"": 1735.0
    },
    {
      ""junction_u"": 7,
      ""junction_v"": 6,
      ""segment_length"": 3345.0
    },
    {
      ""junction_u"": 3,
      ""junction_v"": 4,
      ""segment_length"": 1618.0
    },
    {
      ""junction_u"": 3,
      ""junction_v"": 8,
      ""segment_length"": 277.0
    },
    {
      ""junction_u"": 4,
      ""junction_v"": 6,
      ""segment_length"": 1534.0
    },
    {
      ""junction_u"": 4,
      ""junction_v"": 12,
      ""segment_length"": 2687.0
    },
    {
      ""junction_u"": 5,
      ""junction_v"": 12,
      ""segment_length"": 607.0
    },
    {
      ""junction_u"": 5,
      ""junction_v"": 6,
      ""segment_length"": 2268.0
    }
  ],
  ""featured_installation_nodes"": [
    12,
    14
  ]
}

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': 16, 'num_edges': 19, 'edges': [{'u': 16, 'v': 2, 'w': 943.0}, {'u': 16, 'v': 15, 'w': 3568.0}, {'u': 1, 'v': 2, 'w': 2496.0}, {'u': 1, 'v': 11, 'w': 3024.0}, {'u': 1, 'v': 6, 'w': 1221.0}, {'u': 1, 'v': 8, 'w': 2108.0}, {'u': 2, 'v': 14, 'w': 1677.0}, {'u': 15, 'v': 13, 'w': 1152.0}, {'u': 15, 'v': 10, 'w': 2144.0}, {'u': 10, 'v': 4, 'w': 2944.0}, {'u': 11, 'v': 12, 'w': 1490.0}, {'u': 11, 'v': 3, 'w': 1735.0}, {'u': 8, 'v': 7, 'w': 3345.0}, {'u': 4, 'v': 5, 'w': 1618.0}, {'u': 4, 'v': 9, 'w': 277.0}, {'u': 5, 'v': 7, 'w': 1534.0}, {'u': 5, 'v': 13, 'w': 2687.0}, {'u': 6, 'v': 13, 'w': 607.0}, {'u': 6, 'v': 7, 'w': 2268.0}], 'terminals': [13, 15], 'source_file': 'I052.stp', 'density': 0.15833333333333333, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0018.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0018.png'}","[[13, 15]]",1152.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 19, 'edges': [{'u': 15, 'v': 1, 'w': 943.0}, {'u': 15, 'v': 14, 'w': 3568.0}, {'u': 0, 'v': 1, 'w': 2496.0}, {'u': 0, 'v': 10, 'w': 3024.0}, {'u': 0, 'v': 5, 'w': 1221.0}, {'u': 0, 'v': 7, 'w': 2108.0}, {'u': 1, 'v': 13, 'w': 1677.0}, {'u': 14, 'v': 12, 'w': 1152.0}, {'u': 14, 'v': 9, 'w': 2144.0}, {'u': 9, 'v': 3, 'w': 2944.0}, {'u': 10, 'v': 11, 'w': 1490.0}, {'u': 10, 'v': 2, 'w': 1735.0}, {'u': 7, 'v': 6, 'w': 3345.0}, {'u': 3, 'v': 4, 'w': 1618.0}, {'u': 3, 'v': 8, 'w': 277.0}, {'u': 4, 'v': 6, 'w': 1534.0}, {'u': 4, 'v': 12, 'w': 2687.0}, {'u': 5, 'v': 12, 'w': 607.0}, {'u': 5, 'v': 6, 'w': 2268.0}], 'density': 0.15833333333333333, 'source_file': 'I052.stp', 'terminals': [12, 14]}","[[12, 14]]",19,json,0
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 19 distinct gate posts, 21 candidate decorative sections, and the agreed gardens sit at nodes 16 17.
A decorative fence section connects gate posts 8 and 2 with length 546.0.
A decorative fence section connects gate posts 8 and 9 with length 1610.0.
A decorative fence section connects gate posts 9 and 12 with length 188.0.
A decorative fence section connects gate posts 10 and 11 with length 66.0.
A decorative fence section connects gate posts 10 and 6 with length 129.0.
A decorative fence section connects gate posts 10 and 2 with length 597.0.
A decorative fence section connects gate posts 11 and 7 with length 109.0.
A decorative fence section connects gate posts 11 and 15 with length 919.0.
A decorative fence section connects gate posts 3 and 12 with length 1181.0.
A decorative fence section connects gate posts 4 and 5 with length 173.0.
A decorative fence section connects gate posts 4 and 6 with length 329.0.
A decorative fence section connects gate posts 5 and 7 with length 319.0.
A decorative fence section connects gate posts 5 and 13 with length 1082.0.
A decorative fence section connects gate posts 12 and 13 with length 1175.0.
A decorative fence section connects gate posts 13 and 16 with length 176.0.
A decorative fence section connects gate posts 1 and 2 with length 704.0.
A decorative fence section connects gate posts 14 and 15 with length 1347.0.
A decorative fence section connects gate posts 15 and 17 with length 64.0.
A decorative fence section connects gate posts 6 and 7 with length 94.0.
A decorative fence section connects gate posts 18 and 16 with length 1532.0.
A decorative fence section connects gate posts 19 and 16 with length 950.0.
Select sections so every agreed garden in 16 17 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': 19, 'num_edges': 21, 'edges': [{'u': 8, 'v': 2, 'w': 546.0}, {'u': 8, 'v': 9, 'w': 1610.0}, {'u': 9, 'v': 12, 'w': 188.0}, {'u': 10, 'v': 11, 'w': 66.0}, {'u': 10, 'v': 6, 'w': 129.0}, {'u': 10, 'v': 2, 'w': 597.0}, {'u': 11, 'v': 7, 'w': 109.0}, {'u': 11, 'v': 15, 'w': 919.0}, {'u': 3, 'v': 12, 'w': 1181.0}, {'u': 4, 'v': 5, 'w': 173.0}, {'u': 4, 'v': 6, 'w': 329.0}, {'u': 5, 'v': 7, 'w': 319.0}, {'u': 5, 'v': 13, 'w': 1082.0}, {'u': 12, 'v': 13, 'w': 1175.0}, {'u': 13, 'v': 16, 'w': 176.0}, {'u': 1, 'v': 2, 'w': 704.0}, {'u': 14, 'v': 15, 'w': 1347.0}, {'u': 15, 'v': 17, 'w': 64.0}, {'u': 6, 'v': 7, 'w': 94.0}, {'u': 18, 'v': 16, 'w': 1532.0}, {'u': 19, 'v': 16, 'w': 950.0}], 'terminals': [16, 17], 'source_file': 'I008.stp', 'density': 0.12280701754385964, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0019.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0019.png'}","[[7, 11], [11, 15], [5, 7], [5, 13], [13, 16], [15, 17]]",2669.0,"{'problem_type': 'STP', 'num_nodes': 19, 'num_edges': 21, 'edges': [{'u': 8, 'v': 2, 'w': 546.0}, {'u': 8, 'v': 9, 'w': 1610.0}, {'u': 9, 'v': 12, 'w': 188.0}, {'u': 10, 'v': 11, 'w': 66.0}, {'u': 10, 'v': 6, 'w': 129.0}, {'u': 10, 'v': 2, 'w': 597.0}, {'u': 11, 'v': 7, 'w': 109.0}, {'u': 11, 'v': 15, 'w': 919.0}, {'u': 3, 'v': 12, 'w': 1181.0}, {'u': 4, 'v': 5, 'w': 173.0}, {'u': 4, 'v': 6, 'w': 329.0}, {'u': 5, 'v': 7, 'w': 319.0}, {'u': 5, 'v': 13, 'w': 1082.0}, {'u': 12, 'v': 13, 'w': 1175.0}, {'u': 13, 'v': 16, 'w': 176.0}, {'u': 1, 'v': 2, 'w': 704.0}, {'u': 14, 'v': 15, 'w': 1347.0}, {'u': 15, 'v': 17, 'w': 64.0}, {'u': 6, 'v': 7, 'w': 94.0}, {'u': 18, 'v': 16, 'w': 1532.0}, {'u': 19, 'v': 16, 'w': 950.0}], 'density': 0.12280701754385964, 'source_file': 'I008.stp', 'terminals': [16, 17]}","[[7, 11], [11, 15], [5, 7], [5, 13], [13, 16], [15, 17]]",20,markdown_table,1
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=18
# total_streets=22
# designated_buildings=1 2 7 12 15 16 18
intersection_u,intersection_v,street_length
16,12,879.0
16,4,1484.0
12,10,2235.0
12,18,834.0
17,8,933.0
17,6,242.0
17,4,1050.0
5,8,3550.0
2,15,798.0
2,6,930.0
3,6,826.0
3,18,1421.0
9,10,53.0
1,7,147.0
1,8,902.0
10,11,935.0
18,15,329.0
11,14,2703.0
15,13,288.0
7,13,790.0
7,14,814.0
13,14,597.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': 18, 'num_edges': 22, 'edges': [{'u': 16, 'v': 12, 'w': 879.0}, {'u': 16, 'v': 4, 'w': 1484.0}, {'u': 12, 'v': 10, 'w': 2235.0}, {'u': 12, 'v': 18, 'w': 834.0}, {'u': 17, 'v': 8, 'w': 933.0}, {'u': 17, 'v': 6, 'w': 242.0}, {'u': 17, 'v': 4, 'w': 1050.0}, {'u': 5, 'v': 8, 'w': 3550.0}, {'u': 2, 'v': 15, 'w': 798.0}, {'u': 2, 'v': 6, 'w': 930.0}, {'u': 3, 'v': 6, 'w': 826.0}, {'u': 3, 'v': 18, 'w': 1421.0}, {'u': 9, 'v': 10, 'w': 53.0}, {'u': 1, 'v': 7, 'w': 147.0}, {'u': 1, 'v': 8, 'w': 902.0}, {'u': 10, 'v': 11, 'w': 935.0}, {'u': 18, 'v': 15, 'w': 329.0}, {'u': 11, 'v': 14, 'w': 2703.0}, {'u': 15, 'v': 13, 'w': 288.0}, {'u': 7, 'v': 13, 'w': 790.0}, {'u': 7, 'v': 14, 'w': 814.0}, {'u': 13, 'v': 14, 'w': 597.0}], 'terminals': [1, 2, 7, 12, 15, 16, 18], 'source_file': 'I001.stp', 'density': 0.1437908496732026, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0020.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0020.png'}","[[12, 16], [12, 18], [2, 15], [1, 7], [15, 18], [13, 15], [7, 13]]",4065.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 22, 'edges': [{'u': 16, 'v': 12, 'w': 879.0}, {'u': 16, 'v': 4, 'w': 1484.0}, {'u': 12, 'v': 10, 'w': 2235.0}, {'u': 12, 'v': 18, 'w': 834.0}, {'u': 17, 'v': 8, 'w': 933.0}, {'u': 17, 'v': 6, 'w': 242.0}, {'u': 17, 'v': 4, 'w': 1050.0}, {'u': 5, 'v': 8, 'w': 3550.0}, {'u': 2, 'v': 15, 'w': 798.0}, {'u': 2, 'v': 6, 'w': 930.0}, {'u': 3, 'v': 6, 'w': 826.0}, {'u': 3, 'v': 18, 'w': 1421.0}, {'u': 9, 'v': 10, 'w': 53.0}, {'u': 1, 'v': 7, 'w': 147.0}, {'u': 1, 'v': 8, 'w': 902.0}, {'u': 10, 'v': 11, 'w': 935.0}, {'u': 18, 'v': 15, 'w': 329.0}, {'u': 11, 'v': 14, 'w': 2703.0}, {'u': 15, 'v': 13, 'w': 288.0}, {'u': 7, 'v': 13, 'w': 790.0}, {'u': 7, 'v': 14, 'w': 814.0}, {'u': 13, 'v': 14, 'w': 597.0}], 'density': 0.1437908496732026, 'source_file': 'I001.stp', 'terminals': [1, 2, 7, 12, 15, 16, 18]}","[[12, 16], [12, 18], [2, 15], [1, 7], [15, 18], [13, 15], [7, 13]]",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.

There are 20 distinct survey points, 22 possible pipe segments, and the marked beds are at nodes 0 1 2 3 15 18.
Candidate pipe segment connecting 19 and 18 with length 1112.0.
Candidate pipe segment connecting 19 and 8 with length 1578.0.
Candidate pipe segment connecting 15 and 12 with length 12507.0.
Candidate pipe segment connecting 15 and 16 with length 4430.0.
Candidate pipe segment connecting 15 and 17 with length 6232.0.
Candidate pipe segment connecting 16 and 3 with length 3807.0.
Candidate pipe segment connecting 16 and 11 with length 2671.0.
Candidate pipe segment connecting 0 and 7 with length 637.0.
Candidate pipe segment connecting 0 and 5 with length 2916.0.
Candidate pipe segment connecting 18 and 1 with length 1936.0.
Candidate pipe segment connecting 1 and 8 with length 610.0.
Candidate pipe segment connecting 17 and 2 with length 1259.0.
Candidate pipe segment connecting 17 and 10 with length 1791.0.
Candidate pipe segment connecting 6 and 5 with length 85.0.
Candidate pipe segment connecting 5 and 4 with length 473.0.
Candidate pipe segment connecting 7 and 10 with length 4060.0.
Candidate pipe segment connecting 7 and 8 with length 4707.0.
Candidate pipe segment connecting 9 and 13 with length 2982.0.
Candidate pipe segment connecting 9 and 2 with length 3872.0.
Candidate pipe segment connecting 2 and 3 with length 4389.0.
Candidate pipe segment connecting 3 and 14 with length 979.0.
Candidate pipe segment connecting 13 and 14 with length 4959.0.
Ensure every marked bed in 0 1 2 3 15 18 is included in one continuous piping network and aim to minimize the total installed length.

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': 20, 'num_edges': 22, 'edges': [{'u': 20, 'v': 19, 'w': 1112.0}, {'u': 20, 'v': 9, 'w': 1578.0}, {'u': 16, 'v': 13, 'w': 12507.0}, {'u': 16, 'v': 17, 'w': 4430.0}, {'u': 16, 'v': 18, 'w': 6232.0}, {'u': 17, 'v': 4, 'w': 3807.0}, {'u': 17, 'v': 12, 'w': 2671.0}, {'u': 1, 'v': 8, 'w': 637.0}, {'u': 1, 'v': 6, 'w': 2916.0}, {'u': 19, 'v': 2, 'w': 1936.0}, {'u': 2, 'v': 9, 'w': 610.0}, {'u': 18, 'v': 3, 'w': 1259.0}, {'u': 18, 'v': 11, 'w': 1791.0}, {'u': 7, 'v': 6, 'w': 85.0}, {'u': 6, 'v': 5, 'w': 473.0}, {'u': 8, 'v': 11, 'w': 4060.0}, {'u': 8, 'v': 9, 'w': 4707.0}, {'u': 10, 'v': 14, 'w': 2982.0}, {'u': 10, 'v': 3, 'w': 3872.0}, {'u': 3, 'v': 4, 'w': 4389.0}, {'u': 4, 'v': 15, 'w': 979.0}, {'u': 14, 'v': 15, 'w': 4959.0}], 'terminals': [1, 2, 3, 4, 16, 19], 'source_file': 'I073.stp', 'density': 0.11578947368421053, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0021.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0021.png'}","[[16, 18], [1, 8], [2, 19], [2, 9], [3, 18], [11, 18], [8, 11], [8, 9], [3, 4]]",25621.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 22, 'edges': [{'u': 19, 'v': 18, 'w': 1112.0}, {'u': 19, 'v': 8, 'w': 1578.0}, {'u': 15, 'v': 12, 'w': 12507.0}, {'u': 15, 'v': 16, 'w': 4430.0}, {'u': 15, 'v': 17, 'w': 6232.0}, {'u': 16, 'v': 3, 'w': 3807.0}, {'u': 16, 'v': 11, 'w': 2671.0}, {'u': 0, 'v': 7, 'w': 637.0}, {'u': 0, 'v': 5, 'w': 2916.0}, {'u': 18, 'v': 1, 'w': 1936.0}, {'u': 1, 'v': 8, 'w': 610.0}, {'u': 17, 'v': 2, 'w': 1259.0}, {'u': 17, 'v': 10, 'w': 1791.0}, {'u': 6, 'v': 5, 'w': 85.0}, {'u': 5, 'v': 4, 'w': 473.0}, {'u': 7, 'v': 10, 'w': 4060.0}, {'u': 7, 'v': 8, 'w': 4707.0}, {'u': 9, 'v': 13, 'w': 2982.0}, {'u': 9, 'v': 2, 'w': 3872.0}, {'u': 2, 'v': 3, 'w': 4389.0}, {'u': 3, 'v': 14, 'w': 979.0}, {'u': 13, 'v': 14, 'w': 4959.0}], 'density': 0.11578947368421053, 'source_file': 'I073.stp', 'terminals': [0, 1, 2, 3, 15, 18]}","[[15, 17], [0, 7], [1, 18], [1, 8], [2, 17], [10, 17], [7, 10], [7, 8], [2, 3]]",22,markdown_table,0
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 16 locations, 20 paths, and the trailheads to be joined are 2 10 15.
Footpath segment joining 8 and 15 with length 295.0.
Footpath segment joining 8 and 9 with length 1597.0.
Footpath segment joining 3 and 2 with length 285.0.
Footpath segment joining 3 and 7 with length 1272.0.
Footpath segment joining 3 and 6 with length 941.0.
Footpath segment joining 11 and 10 with length 1786.0.
Footpath segment joining 11 and 1 with length 2164.0.
Footpath segment joining 9 and 5 with length 397.0.
Footpath segment joining 9 and 1 with length 3441.0.
Footpath segment joining 10 and 5 with length 92.0.
Footpath segment joining 10 and 14 with length 1566.0.
Footpath segment joining 4 and 2 with length 288.0.
Footpath segment joining 4 and 7 with length 1248.0.
Footpath segment joining 2 and 6 with length 1190.0.
Footpath segment joining 7 and 15 with length 6995.0.
Footpath segment joining 16 and 1 with length 2168.0.
Footpath segment joining 15 and 12 with length 321.0.
Footpath segment joining 12 and 13 with length 2459.0.
Footpath segment joining 12 and 14 with length 345.0.
Footpath segment joining 13 and 14 with length 2267.0.
Recommend the subset of paths that yields the smallest total length while connecting all 2 10 15.

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': 16, 'num_edges': 20, 'edges': [{'u': 8, 'v': 15, 'w': 295.0}, {'u': 8, 'v': 9, 'w': 1597.0}, {'u': 3, 'v': 2, 'w': 285.0}, {'u': 3, 'v': 7, 'w': 1272.0}, {'u': 3, 'v': 6, 'w': 941.0}, {'u': 11, 'v': 10, 'w': 1786.0}, {'u': 11, 'v': 1, 'w': 2164.0}, {'u': 9, 'v': 5, 'w': 397.0}, {'u': 9, 'v': 1, 'w': 3441.0}, {'u': 10, 'v': 5, 'w': 92.0}, {'u': 10, 'v': 14, 'w': 1566.0}, {'u': 4, 'v': 2, 'w': 288.0}, {'u': 4, 'v': 7, 'w': 1248.0}, {'u': 2, 'v': 6, 'w': 1190.0}, {'u': 7, 'v': 15, 'w': 6995.0}, {'u': 16, 'v': 1, 'w': 2168.0}, {'u': 15, 'v': 12, 'w': 321.0}, {'u': 12, 'v': 13, 'w': 2459.0}, {'u': 12, 'v': 14, 'w': 345.0}, {'u': 13, 'v': 14, 'w': 2267.0}], 'terminals': [2, 10, 15], 'source_file': 'I049.stp', 'density': 0.16666666666666666, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0022.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0022.png'}","[[10, 14], [2, 4], [4, 7], [7, 15], [12, 15], [12, 14]]",10763.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 20, 'edges': [{'u': 8, 'v': 15, 'w': 295.0}, {'u': 8, 'v': 9, 'w': 1597.0}, {'u': 3, 'v': 2, 'w': 285.0}, {'u': 3, 'v': 7, 'w': 1272.0}, {'u': 3, 'v': 6, 'w': 941.0}, {'u': 11, 'v': 10, 'w': 1786.0}, {'u': 11, 'v': 1, 'w': 2164.0}, {'u': 9, 'v': 5, 'w': 397.0}, {'u': 9, 'v': 1, 'w': 3441.0}, {'u': 10, 'v': 5, 'w': 92.0}, {'u': 10, 'v': 14, 'w': 1566.0}, {'u': 4, 'v': 2, 'w': 288.0}, {'u': 4, 'v': 7, 'w': 1248.0}, {'u': 2, 'v': 6, 'w': 1190.0}, {'u': 7, 'v': 15, 'w': 6995.0}, {'u': 16, 'v': 1, 'w': 2168.0}, {'u': 15, 'v': 12, 'w': 321.0}, {'u': 12, 'v': 13, 'w': 2459.0}, {'u': 12, 'v': 14, 'w': 345.0}, {'u': 13, 'v': 14, 'w': 2267.0}], 'density': 0.16666666666666666, 'source_file': 'I049.stp', 'terminals': [2, 10, 15]}","[[10, 14], [2, 4], [4, 7], [7, 15], [12, 15], [12, 14]]",23,nl,1
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=20
# total_candidate_runs=27
# required_display_cases=C E F G I K L O R S
run_endpoint_a,run_endpoint_b,run_length
A,B,671336.0
A,C,676458.0
A,I,588576.0
B,N,3998.0
B,R,5072.0
C,P,260.0
C,Q,317.0
M,J,1642.0
M,N,424.0
D,E,638685.0
D,F,562538.0
D,G,634596.0
N,O,3222.0
F,P,726.0
F,Q,425.0
T,I,301818.0
T,P,505553.0
T,G,325539.0
T,S,469221.0
G,K,621983.0
E,R,1667.0
Q,R,596324.0
I,H,584687.0
H,J,582778.0
J,L,1660.0
K,S,527783.0
S,L,559146.0

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': 20, 'num_edges': 27, 'edges': [{'u': 1, 'v': 2, 'w': 671336.0}, {'u': 1, 'v': 3, 'w': 676458.0}, {'u': 1, 'v': 9, 'w': 588576.0}, {'u': 2, 'v': 14, 'w': 3998.0}, {'u': 2, 'v': 18, 'w': 5072.0}, {'u': 3, 'v': 16, 'w': 260.0}, {'u': 3, 'v': 17, 'w': 317.0}, {'u': 13, 'v': 10, 'w': 1642.0}, {'u': 13, 'v': 14, 'w': 424.0}, {'u': 4, 'v': 5, 'w': 638685.0}, {'u': 4, 'v': 6, 'w': 562538.0}, {'u': 4, 'v': 7, 'w': 634596.0}, {'u': 14, 'v': 15, 'w': 3222.0}, {'u': 6, 'v': 16, 'w': 726.0}, {'u': 6, 'v': 17, 'w': 425.0}, {'u': 20, 'v': 9, 'w': 301818.0}, {'u': 20, 'v': 16, 'w': 505553.0}, {'u': 20, 'v': 7, 'w': 325539.0}, {'u': 20, 'v': 19, 'w': 469221.0}, {'u': 7, 'v': 11, 'w': 621983.0}, {'u': 5, 'v': 18, 'w': 1667.0}, {'u': 17, 'v': 18, 'w': 596324.0}, {'u': 9, 'v': 8, 'w': 584687.0}, {'u': 8, 'v': 10, 'w': 582778.0}, {'u': 10, 'v': 12, 'w': 1660.0}, {'u': 11, 'v': 19, 'w': 527783.0}, {'u': 19, 'v': 12, 'w': 559146.0}], 'terminals': [3, 5, 6, 7, 9, 11, 12, 15, 18, 19], 'source_file': 'I004.stp', 'density': 0.14210526315789473, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0023.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0023.png'}","[[2, 14], [2, 18], [3, 16], [10, 13], [13, 14], [14, 15], [6, 16], [9, 20], [16, 20], [7, 20], [19, 20], [5, 18], [10, 12], [11, 19], [12, 19]]",2707731.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 27, 'edges': [{'u': 'A', 'v': 'B', 'w': 671336.0}, {'u': 'A', 'v': 'C', 'w': 676458.0}, {'u': 'A', 'v': 'I', 'w': 588576.0}, {'u': 'B', 'v': 'N', 'w': 3998.0}, {'u': 'B', 'v': 'R', 'w': 5072.0}, {'u': 'C', 'v': 'P', 'w': 260.0}, {'u': 'C', 'v': 'Q', 'w': 317.0}, {'u': 'M', 'v': 'J', 'w': 1642.0}, {'u': 'M', 'v': 'N', 'w': 424.0}, {'u': 'D', 'v': 'E', 'w': 638685.0}, {'u': 'D', 'v': 'F', 'w': 562538.0}, {'u': 'D', 'v': 'G', 'w': 634596.0}, {'u': 'N', 'v': 'O', 'w': 3222.0}, {'u': 'F', 'v': 'P', 'w': 726.0}, {'u': 'F', 'v': 'Q', 'w': 425.0}, {'u': 'T', 'v': 'I', 'w': 301818.0}, {'u': 'T', 'v': 'P', 'w': 505553.0}, {'u': 'T', 'v': 'G', 'w': 325539.0}, {'u': 'T', 'v': 'S', 'w': 469221.0}, {'u': 'G', 'v': 'K', 'w': 621983.0}, {'u': 'E', 'v': 'R', 'w': 1667.0}, {'u': 'Q', 'v': 'R', 'w': 596324.0}, {'u': 'I', 'v': 'H', 'w': 584687.0}, {'u': 'H', 'v': 'J', 'w': 582778.0}, {'u': 'J', 'v': 'L', 'w': 1660.0}, {'u': 'K', 'v': 'S', 'w': 527783.0}, {'u': 'S', 'v': 'L', 'w': 559146.0}], 'density': 0.14210526315789473, 'source_file': 'I004.stp', 'terminals': ['C', 'E', 'F', 'G', 'I', 'K', 'L', 'O', 'R', 'S']}","[['B', 'N'], ['B', 'R'], ['C', 'P'], ['J', 'M'], ['M', 'N'], ['N', 'O'], ['F', 'P'], ['I', 'T'], ['P', 'T'], ['G', 'T'], ['S', 'T'], ['E', 'R'], ['J', 'L'], ['K', 'S'], ['L', 'S']]",24,csv,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.

Office plan: 19 total nodes, 22 corridor segments, required desks at nodes 1 4 9 10 12 13 14 16 19.
Corridor connecting 9 and 15, length 1769.0.
Corridor connecting 9 and 10, length 829.0.
Corridor connecting 16 and 19, length 2703.0.
Corridor connecting 17 and 14, length 146.0.
Corridor connecting 17 and 4, length 3753.0.
Corridor connecting 17 and 6, length 2611.0.
Corridor connecting 14 and 13, length 1760.0.
Corridor connecting 14 and 2, length 1262.0.
Corridor connecting 14 and 3, length 3965.0.
Corridor connecting 10 and 11, length 1959.0.
Corridor connecting 10 and 13, length 1071.0.
Corridor connecting 10 and 3, length 1463.0.
Corridor connecting 11 and 12, length 1429.0.
Corridor connecting 11 and 15, length 879.0.
Corridor connecting 1 and 4, length 628.0.
Corridor connecting 1 and 3, length 921.0.
Corridor connecting 13 and 12, length 2063.0.
Corridor connecting 18 and 5, length 331.0.
Corridor connecting 6 and 7, length 389.0.
Corridor connecting 6 and 8, length 974.0.
Corridor connecting 19 and 4, length 178.0.
Corridor connecting 19 and 5, length 1160.0.
Run cable along chosen corridors to connect all 1 4 9 10 12 13 14 16 19 while minimizing the total of the listed corridor lengths.

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': 19, 'num_edges': 22, 'edges': [{'u': 9, 'v': 15, 'w': 1769.0}, {'u': 9, 'v': 10, 'w': 829.0}, {'u': 16, 'v': 19, 'w': 2703.0}, {'u': 17, 'v': 14, 'w': 146.0}, {'u': 17, 'v': 4, 'w': 3753.0}, {'u': 17, 'v': 6, 'w': 2611.0}, {'u': 14, 'v': 13, 'w': 1760.0}, {'u': 14, 'v': 2, 'w': 1262.0}, {'u': 14, 'v': 3, 'w': 3965.0}, {'u': 10, 'v': 11, 'w': 1959.0}, {'u': 10, 'v': 13, 'w': 1071.0}, {'u': 10, 'v': 3, 'w': 1463.0}, {'u': 11, 'v': 12, 'w': 1429.0}, {'u': 11, 'v': 15, 'w': 879.0}, {'u': 1, 'v': 4, 'w': 628.0}, {'u': 1, 'v': 3, 'w': 921.0}, {'u': 13, 'v': 12, 'w': 2063.0}, {'u': 18, 'v': 5, 'w': 331.0}, {'u': 6, 'v': 7, 'w': 389.0}, {'u': 6, 'v': 8, 'w': 974.0}, {'u': 19, 'v': 4, 'w': 178.0}, {'u': 19, 'v': 5, 'w': 1160.0}], 'terminals': [1, 4, 9, 10, 12, 13, 14, 16, 19], 'source_file': 'I010.stp', 'density': 0.1286549707602339, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0024.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0024.png'}","[[9, 10], [16, 19], [13, 14], [10, 13], [3, 10], [1, 4], [1, 3], [12, 13], [4, 19]]",11616.0,"{'problem_type': 'STP', 'num_nodes': 19, 'num_edges': 22, 'edges': [{'u': 9, 'v': 15, 'w': 1769.0}, {'u': 9, 'v': 10, 'w': 829.0}, {'u': 16, 'v': 19, 'w': 2703.0}, {'u': 17, 'v': 14, 'w': 146.0}, {'u': 17, 'v': 4, 'w': 3753.0}, {'u': 17, 'v': 6, 'w': 2611.0}, {'u': 14, 'v': 13, 'w': 1760.0}, {'u': 14, 'v': 2, 'w': 1262.0}, {'u': 14, 'v': 3, 'w': 3965.0}, {'u': 10, 'v': 11, 'w': 1959.0}, {'u': 10, 'v': 13, 'w': 1071.0}, {'u': 10, 'v': 3, 'w': 1463.0}, {'u': 11, 'v': 12, 'w': 1429.0}, {'u': 11, 'v': 15, 'w': 879.0}, {'u': 1, 'v': 4, 'w': 628.0}, {'u': 1, 'v': 3, 'w': 921.0}, {'u': 13, 'v': 12, 'w': 2063.0}, {'u': 18, 'v': 5, 'w': 331.0}, {'u': 6, 'v': 7, 'w': 389.0}, {'u': 6, 'v': 8, 'w': 974.0}, {'u': 19, 'v': 4, 'w': 178.0}, {'u': 19, 'v': 5, 'w': 1160.0}], 'density': 0.1286549707602339, 'source_file': 'I010.stp', 'terminals': [1, 4, 9, 10, 12, 13, 14, 16, 19]}","[[9, 10], [16, 19], [13, 14], [10, 13], [3, 10], [1, 4], [1, 3], [12, 13], [4, 19]]",25,markdown_table,1
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"": 20,
  ""potential_trails_count"": 25,
  ""edges"": [
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 9,
      ""trail_length"": 1094.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 0,
      ""trail_length"": 1416.0
    },
    {
      ""endpoint_a"": 10,
      ""endpoint_b"": 6,
      ""trail_length"": 11024.0
    },
    {
      ""endpoint_a"": 13,
      ""endpoint_b"": 2,
      ""trail_length"": 504.0
    },
    {
      ""endpoint_a"": 13,
      ""endpoint_b"": 14,
      ""trail_length"": 4073.0
    },
    {
      ""endpoint_a"": 13,
      ""endpoint_b"": 5,
      ""trail_length"": 1770.0
    },
    {
      ""endpoint_a"": 14,
      ""endpoint_b"": 8,
      ""trail_length"": 893.0
    },
    {
      ""endpoint_a"": 14,
      ""endpoint_b"": 7,
      ""trail_length"": 816.0
    },
    {
      ""endpoint_a"": 3,
      ""endpoint_b"": 5,
      ""trail_length"": 1064.0
    },
    {
      ""endpoint_a"": 3,
      ""endpoint_b"": 6,
      ""trail_length"": 6611.0
    },
    {
      ""endpoint_a"": 19,
      ""endpoint_b"": 11,
      ""trail_length"": 769.0
    },
    {
      ""endpoint_a"": 19,
      ""endpoint_b"": 16,
      ""trail_length"": 1722.0
    },
    {
      ""endpoint_a"": 19,
      ""endpoint_b"": 17,
      ""trail_length"": 1342.0
    },
    {
      ""endpoint_a"": 16,
      ""endpoint_b"": 15,
      ""trail_length"": 1455.0
    },
    {
      ""endpoint_a"": 18,
      ""endpoint_b"": 9,
      ""trail_length"": 1579.0
    },
    {
      ""endpoint_a"": 18,
      ""endpoint_b"": 0,
      ""trail_length"": 556.0
    },
    {
      ""endpoint_a"": 18,
      ""endpoint_b"": 1,
      ""trail_length"": 1589.0
    },
    {
      ""endpoint_a"": 4,
      ""endpoint_b"": 11,
      ""trail_length"": 1721.0
    },
    {
      ""endpoint_a"": 4,
      ""endpoint_b"": 12,
      ""trail_length"": 1562.0
    },
    {
      ""endpoint_a"": 5,
      ""endpoint_b"": 7,
      ""trail_length"": 4693.0
    },
    {
      ""endpoint_a"": 6,
      ""endpoint_b"": 7,
      ""trail_length"": 1192.0
    },
    {
      ""endpoint_a"": 11,
      ""endpoint_b"": 17,
      ""trail_length"": 2072.0
    },
    {
      ""endpoint_a"": 11,
      ""endpoint_b"": 12,
      ""trail_length"": 2868.0
    },
    {
      ""endpoint_a"": 0,
      ""endpoint_b"": 17,
      ""trail_length"": 3063.0
    },
    {
      ""endpoint_a"": 1,
      ""endpoint_b"": 9,
      ""trail_length"": 363.0
    }
  ],
  ""required_campsites"": [
    2,
    3,
    13,
    18
  ]
}

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': 20, 'num_edges': 25, 'edges': [{'u': 11, 'v': 10, 'w': 1094.0}, {'u': 11, 'v': 1, 'w': 1416.0}, {'u': 11, 'v': 7, 'w': 11024.0}, {'u': 14, 'v': 3, 'w': 504.0}, {'u': 14, 'v': 15, 'w': 4073.0}, {'u': 14, 'v': 6, 'w': 1770.0}, {'u': 15, 'v': 9, 'w': 893.0}, {'u': 15, 'v': 8, 'w': 816.0}, {'u': 4, 'v': 6, 'w': 1064.0}, {'u': 4, 'v': 7, 'w': 6611.0}, {'u': 20, 'v': 12, 'w': 769.0}, {'u': 20, 'v': 17, 'w': 1722.0}, {'u': 20, 'v': 18, 'w': 1342.0}, {'u': 17, 'v': 16, 'w': 1455.0}, {'u': 19, 'v': 10, 'w': 1579.0}, {'u': 19, 'v': 1, 'w': 556.0}, {'u': 19, 'v': 2, 'w': 1589.0}, {'u': 5, 'v': 12, 'w': 1721.0}, {'u': 5, 'v': 13, 'w': 1562.0}, {'u': 6, 'v': 8, 'w': 4693.0}, {'u': 7, 'v': 8, 'w': 1192.0}, {'u': 12, 'v': 18, 'w': 2072.0}, {'u': 12, 'v': 13, 'w': 2868.0}, {'u': 1, 'v': 18, 'w': 3063.0}, {'u': 2, 'v': 10, 'w': 363.0}], 'terminals': [3, 4, 14, 19], 'source_file': 'I042.stp', 'density': 0.13157894736842105, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0025.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0025.png'}","[[1, 11], [7, 11], [3, 14], [6, 14], [4, 6], [1, 19], [6, 8], [7, 8]]",22219.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 25, 'edges': [{'u': 10, 'v': 9, 'w': 1094.0}, {'u': 10, 'v': 0, 'w': 1416.0}, {'u': 10, 'v': 6, 'w': 11024.0}, {'u': 13, 'v': 2, 'w': 504.0}, {'u': 13, 'v': 14, 'w': 4073.0}, {'u': 13, 'v': 5, 'w': 1770.0}, {'u': 14, 'v': 8, 'w': 893.0}, {'u': 14, 'v': 7, 'w': 816.0}, {'u': 3, 'v': 5, 'w': 1064.0}, {'u': 3, 'v': 6, 'w': 6611.0}, {'u': 19, 'v': 11, 'w': 769.0}, {'u': 19, 'v': 16, 'w': 1722.0}, {'u': 19, 'v': 17, 'w': 1342.0}, {'u': 16, 'v': 15, 'w': 1455.0}, {'u': 18, 'v': 9, 'w': 1579.0}, {'u': 18, 'v': 0, 'w': 556.0}, {'u': 18, 'v': 1, 'w': 1589.0}, {'u': 4, 'v': 11, 'w': 1721.0}, {'u': 4, 'v': 12, 'w': 1562.0}, {'u': 5, 'v': 7, 'w': 4693.0}, {'u': 6, 'v': 7, 'w': 1192.0}, {'u': 11, 'v': 17, 'w': 2072.0}, {'u': 11, 'v': 12, 'w': 2868.0}, {'u': 0, 'v': 17, 'w': 3063.0}, {'u': 1, 'v': 9, 'w': 363.0}], 'density': 0.13157894736842105, 'source_file': 'I042.stp', 'terminals': [2, 3, 13, 18]}","[[0, 10], [6, 10], [2, 13], [5, 13], [3, 5], [0, 18], [5, 7], [6, 7]]",26,json,0
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=20
# total_candidate_lines=25
# required_substations=I J L M O R
endpoint_node_a,endpoint_node_b,line_material_cost
R,N,779.0
S,T,4621.0
S,L,4406.0
I,A,354.0
I,J,771.0
I,M,153.0
J,N,125.0
J,O,848.0
A,B,166.0
A,H,297435.0
B,L,1672.0
B,M,353.0
C,O,1145.0
C,K,1519.0
C,H,297187.0
D,E,774.0
D,F,496.0
E,P,711.0
F,P,927.0
F,Q,1495.0
G,Q,477.0
K,P,1033.0
K,L,1144.0
M,N,766.0
O,Q,974.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': 20, 'num_edges': 25, 'edges': [{'u': 18, 'v': 14, 'w': 779.0}, {'u': 19, 'v': 20, 'w': 4621.0}, {'u': 19, 'v': 12, 'w': 4406.0}, {'u': 9, 'v': 1, 'w': 354.0}, {'u': 9, 'v': 10, 'w': 771.0}, {'u': 9, 'v': 13, 'w': 153.0}, {'u': 10, 'v': 14, 'w': 125.0}, {'u': 10, 'v': 15, 'w': 848.0}, {'u': 1, 'v': 2, 'w': 166.0}, {'u': 1, 'v': 8, 'w': 297435.0}, {'u': 2, 'v': 12, 'w': 1672.0}, {'u': 2, 'v': 13, 'w': 353.0}, {'u': 3, 'v': 15, 'w': 1145.0}, {'u': 3, 'v': 11, 'w': 1519.0}, {'u': 3, 'v': 8, 'w': 297187.0}, {'u': 4, 'v': 5, 'w': 774.0}, {'u': 4, 'v': 6, 'w': 496.0}, {'u': 5, 'v': 16, 'w': 711.0}, {'u': 6, 'v': 16, 'w': 927.0}, {'u': 6, 'v': 17, 'w': 1495.0}, {'u': 7, 'v': 17, 'w': 477.0}, {'u': 11, 'v': 16, 'w': 1033.0}, {'u': 11, 'v': 12, 'w': 1144.0}, {'u': 13, 'v': 14, 'w': 766.0}, {'u': 15, 'v': 17, 'w': 974.0}], 'terminals': [9, 10, 12, 13, 15, 18], 'source_file': 'I014.stp', 'density': 0.13157894736842105, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0026.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0026.png'}","[[14, 18], [9, 13], [10, 14], [10, 15], [2, 12], [2, 13], [13, 14]]",4696.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 25, 'edges': [{'u': 'R', 'v': 'N', 'w': 779.0}, {'u': 'S', 'v': 'T', 'w': 4621.0}, {'u': 'S', 'v': 'L', 'w': 4406.0}, {'u': 'I', 'v': 'A', 'w': 354.0}, {'u': 'I', 'v': 'J', 'w': 771.0}, {'u': 'I', 'v': 'M', 'w': 153.0}, {'u': 'J', 'v': 'N', 'w': 125.0}, {'u': 'J', 'v': 'O', 'w': 848.0}, {'u': 'A', 'v': 'B', 'w': 166.0}, {'u': 'A', 'v': 'H', 'w': 297435.0}, {'u': 'B', 'v': 'L', 'w': 1672.0}, {'u': 'B', 'v': 'M', 'w': 353.0}, {'u': 'C', 'v': 'O', 'w': 1145.0}, {'u': 'C', 'v': 'K', 'w': 1519.0}, {'u': 'C', 'v': 'H', 'w': 297187.0}, {'u': 'D', 'v': 'E', 'w': 774.0}, {'u': 'D', 'v': 'F', 'w': 496.0}, {'u': 'E', 'v': 'P', 'w': 711.0}, {'u': 'F', 'v': 'P', 'w': 927.0}, {'u': 'F', 'v': 'Q', 'w': 1495.0}, {'u': 'G', 'v': 'Q', 'w': 477.0}, {'u': 'K', 'v': 'P', 'w': 1033.0}, {'u': 'K', 'v': 'L', 'w': 1144.0}, {'u': 'M', 'v': 'N', 'w': 766.0}, {'u': 'O', 'v': 'Q', 'w': 974.0}], 'density': 0.13157894736842105, 'source_file': 'I014.stp', 'terminals': ['I', 'J', 'L', 'M', 'O', 'R']}","[['N', 'R'], ['I', 'M'], ['J', 'N'], ['J', 'O'], ['B', 'L'], ['B', 'M'], ['M', 'N']]",27,csv,names
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.

There are 20 locations and 24 corridor segments; the program classrooms to connect are 1 4 5 6 12 15 17 19.
Choose corridor linking 5 and 6 with renovation length 1023.0.
Choose corridor linking 5 and 11 with renovation length 488.0.
Choose corridor linking 5 and 13 with renovation length 1369.0.
Choose corridor linking 13 and 7 with renovation length 1091.0.
Choose corridor linking 13 and 3 with renovation length 1112.0.
Choose corridor linking 10 and 0 with renovation length 390.0.
Choose corridor linking 10 and 15 with renovation length 207.0.
Choose corridor linking 11 and 12 with renovation length 1012.0.
Choose corridor linking 12 and 4 with renovation length 2518.0.
Choose corridor linking 18 and 9 with renovation length 787.0.
Choose corridor linking 18 and 16 with renovation length 1248.0.
Choose corridor linking 18 and 8 with renovation length 617.0.
Choose corridor linking 18 and 17 with renovation length 1127.0.
Choose corridor linking 19 and 16 with renovation length 738.0.
Choose corridor linking 19 and 0 with renovation length 1151.0.
Choose corridor linking 19 and 2 with renovation length 537.0.
Choose corridor linking 1 and 2 with renovation length 299954.0.
Choose corridor linking 1 and 3 with renovation length 300213.0.
Choose corridor linking 2 and 9 with renovation length 1256.0.
Choose corridor linking 3 and 9 with renovation length 92.0.
Choose corridor linking 4 and 7 with renovation length 2005.0.
Choose corridor linking 7 and 8 with renovation length 704.0.
Choose corridor linking 15 and 16 with renovation length 1046.0.
Choose corridor linking 16 and 14 with renovation length 1029.0.
The selected corridors must join all 1 4 5 6 12 15 17 19 into one accessible corridor system and no corridor may be counted more than once.

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': 20, 'num_edges': 24, 'edges': [{'u': 6, 'v': 7, 'w': 1023.0}, {'u': 6, 'v': 12, 'w': 488.0}, {'u': 6, 'v': 14, 'w': 1369.0}, {'u': 14, 'v': 8, 'w': 1091.0}, {'u': 14, 'v': 4, 'w': 1112.0}, {'u': 11, 'v': 1, 'w': 390.0}, {'u': 11, 'v': 16, 'w': 207.0}, {'u': 12, 'v': 13, 'w': 1012.0}, {'u': 13, 'v': 5, 'w': 2518.0}, {'u': 19, 'v': 10, 'w': 787.0}, {'u': 19, 'v': 17, 'w': 1248.0}, {'u': 19, 'v': 9, 'w': 617.0}, {'u': 19, 'v': 18, 'w': 1127.0}, {'u': 20, 'v': 17, 'w': 738.0}, {'u': 20, 'v': 1, 'w': 1151.0}, {'u': 20, 'v': 3, 'w': 537.0}, {'u': 2, 'v': 3, 'w': 299954.0}, {'u': 2, 'v': 4, 'w': 300213.0}, {'u': 3, 'v': 10, 'w': 1256.0}, {'u': 4, 'v': 10, 'w': 92.0}, {'u': 5, 'v': 8, 'w': 2005.0}, {'u': 8, 'v': 9, 'w': 704.0}, {'u': 16, 'v': 17, 'w': 1046.0}, {'u': 17, 'v': 15, 'w': 1029.0}], 'terminals': [2, 5, 6, 7, 13, 16, 18, 20], 'source_file': 'I067.stp', 'density': 0.12631578947368421, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0027.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0027.png'}","[[6, 7], [6, 12], [6, 14], [4, 14], [12, 13], [5, 13], [10, 19], [17, 19], [18, 19], [17, 20], [2, 4], [4, 10], [16, 17]]",312773.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 24, 'edges': [{'u': 5, 'v': 6, 'w': 1023.0}, {'u': 5, 'v': 11, 'w': 488.0}, {'u': 5, 'v': 13, 'w': 1369.0}, {'u': 13, 'v': 7, 'w': 1091.0}, {'u': 13, 'v': 3, 'w': 1112.0}, {'u': 10, 'v': 0, 'w': 390.0}, {'u': 10, 'v': 15, 'w': 207.0}, {'u': 11, 'v': 12, 'w': 1012.0}, {'u': 12, 'v': 4, 'w': 2518.0}, {'u': 18, 'v': 9, 'w': 787.0}, {'u': 18, 'v': 16, 'w': 1248.0}, {'u': 18, 'v': 8, 'w': 617.0}, {'u': 18, 'v': 17, 'w': 1127.0}, {'u': 19, 'v': 16, 'w': 738.0}, {'u': 19, 'v': 0, 'w': 1151.0}, {'u': 19, 'v': 2, 'w': 537.0}, {'u': 1, 'v': 2, 'w': 299954.0}, {'u': 1, 'v': 3, 'w': 300213.0}, {'u': 2, 'v': 9, 'w': 1256.0}, {'u': 3, 'v': 9, 'w': 92.0}, {'u': 4, 'v': 7, 'w': 2005.0}, {'u': 7, 'v': 8, 'w': 704.0}, {'u': 15, 'v': 16, 'w': 1046.0}, {'u': 16, 'v': 14, 'w': 1029.0}], 'density': 0.12631578947368421, 'source_file': 'I067.stp', 'terminals': [1, 4, 5, 6, 12, 15, 17, 19]}","[[5, 6], [5, 11], [5, 13], [3, 13], [11, 12], [4, 12], [9, 18], [16, 18], [17, 18], [16, 19], [1, 3], [3, 9], [15, 16]]",28,nl,0
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=16
# number_of_possible_connection_segments=21
# squares_to_connect=A F G H J L O P
pole_u,pole_v,cable_length
P,N,2603.0
P,J,4377.0
N,O,1635.0
C,H,182537.0
C,I,287.0
C,F,1292.0
D,G,334.0
D,L,513.0
D,I,990.0
E,F,476.0
E,G,642.0
E,H,183497.0
F,J,129.0
G,K,879.0
I,L,1485.0
B,A,16388.0
B,M,1601.0
B,O,6748.0
J,K,714.0
K,M,1791.0
L,M,416.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': 16, 'num_edges': 21, 'edges': [{'u': 16, 'v': 14, 'w': 2603.0}, {'u': 16, 'v': 10, 'w': 4377.0}, {'u': 14, 'v': 15, 'w': 1635.0}, {'u': 3, 'v': 8, 'w': 182537.0}, {'u': 3, 'v': 9, 'w': 287.0}, {'u': 3, 'v': 6, 'w': 1292.0}, {'u': 4, 'v': 7, 'w': 334.0}, {'u': 4, 'v': 12, 'w': 513.0}, {'u': 4, 'v': 9, 'w': 990.0}, {'u': 5, 'v': 6, 'w': 476.0}, {'u': 5, 'v': 7, 'w': 642.0}, {'u': 5, 'v': 8, 'w': 183497.0}, {'u': 6, 'v': 10, 'w': 129.0}, {'u': 7, 'v': 11, 'w': 879.0}, {'u': 9, 'v': 12, 'w': 1485.0}, {'u': 2, 'v': 1, 'w': 16388.0}, {'u': 2, 'v': 13, 'w': 1601.0}, {'u': 2, 'v': 15, 'w': 6748.0}, {'u': 10, 'v': 11, 'w': 714.0}, {'u': 11, 'v': 13, 'w': 1791.0}, {'u': 12, 'v': 13, 'w': 416.0}], 'terminals': [1, 6, 7, 8, 10, 12, 15, 16], 'source_file': 'I012.stp', 'density': 0.175, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0028.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0028.png'}","[[14, 16], [10, 16], [14, 15], [4, 7], [4, 12], [5, 6], [5, 7], [5, 8], [6, 10], [1, 2], [2, 13], [12, 13]]",212611.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 21, 'edges': [{'u': 'P', 'v': 'N', 'w': 2603.0}, {'u': 'P', 'v': 'J', 'w': 4377.0}, {'u': 'N', 'v': 'O', 'w': 1635.0}, {'u': 'C', 'v': 'H', 'w': 182537.0}, {'u': 'C', 'v': 'I', 'w': 287.0}, {'u': 'C', 'v': 'F', 'w': 1292.0}, {'u': 'D', 'v': 'G', 'w': 334.0}, {'u': 'D', 'v': 'L', 'w': 513.0}, {'u': 'D', 'v': 'I', 'w': 990.0}, {'u': 'E', 'v': 'F', 'w': 476.0}, {'u': 'E', 'v': 'G', 'w': 642.0}, {'u': 'E', 'v': 'H', 'w': 183497.0}, {'u': 'F', 'v': 'J', 'w': 129.0}, {'u': 'G', 'v': 'K', 'w': 879.0}, {'u': 'I', 'v': 'L', 'w': 1485.0}, {'u': 'B', 'v': 'A', 'w': 16388.0}, {'u': 'B', 'v': 'M', 'w': 1601.0}, {'u': 'B', 'v': 'O', 'w': 6748.0}, {'u': 'J', 'v': 'K', 'w': 714.0}, {'u': 'K', 'v': 'M', 'w': 1791.0}, {'u': 'L', 'v': 'M', 'w': 416.0}], 'density': 0.175, 'source_file': 'I012.stp', 'terminals': ['A', 'F', 'G', 'H', 'J', 'L', 'O', 'P']}","[['N', 'P'], ['J', 'P'], ['N', 'O'], ['D', 'G'], ['D', 'L'], ['E', 'F'], ['E', 'G'], ['E', 'H'], ['F', 'J'], ['A', 'B'], ['B', 'M'], ['L', 'M']]",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.

Below are the 22 candidate roads among the 17 map points; the required pickup sites are C K M O P Q.
Road between H and I with length 539.0.
Road between H and N with length 439.0.
Road between H and D with length 273.0.
Road between I and E with length 307.0.
Road between I and O with length 434.0.
Road between I and D with length 811.0.
Road between J and A with length 362.0.
Road between J and K with length 260.0.
Road between J and P with length 354.0.
Road between K and Q with length 344.0.
Road between D and G with length 53.0.
Road between E and F with length 431.0.
Road between F and C with length 257.0.
Road between F and P with length 104.0.
Road between N and O with length 543.0.
Road between N and L with length 147.0.
Road between M and B with length 2723.0.
Road between O and C with length 49.0.
Road between P and Q with length 246.0.
Road between A and B with length 731.0.
Road between A and C with length 368.0.
Road between B and L with length 383.0.
The planner must select a subset of these roads that spans every required pickup site C K M O P Q while minimizing the total miles used.

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': 17, 'num_edges': 22, 'edges': [{'u': 8, 'v': 9, 'w': 539.0}, {'u': 8, 'v': 14, 'w': 439.0}, {'u': 8, 'v': 4, 'w': 273.0}, {'u': 9, 'v': 5, 'w': 307.0}, {'u': 9, 'v': 15, 'w': 434.0}, {'u': 9, 'v': 4, 'w': 811.0}, {'u': 10, 'v': 1, 'w': 362.0}, {'u': 10, 'v': 11, 'w': 260.0}, {'u': 10, 'v': 16, 'w': 354.0}, {'u': 11, 'v': 17, 'w': 344.0}, {'u': 4, 'v': 7, 'w': 53.0}, {'u': 5, 'v': 6, 'w': 431.0}, {'u': 6, 'v': 3, 'w': 257.0}, {'u': 6, 'v': 16, 'w': 104.0}, {'u': 14, 'v': 15, 'w': 543.0}, {'u': 14, 'v': 12, 'w': 147.0}, {'u': 13, 'v': 2, 'w': 2723.0}, {'u': 15, 'v': 3, 'w': 49.0}, {'u': 16, 'v': 17, 'w': 246.0}, {'u': 1, 'v': 2, 'w': 731.0}, {'u': 1, 'v': 3, 'w': 368.0}, {'u': 2, 'v': 12, 'w': 383.0}], 'terminals': [3, 11, 13, 15, 16, 17], 'source_file': 'I042.stp', 'density': 0.16176470588235295, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0029.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0029.png'}","[[11, 17], [3, 6], [6, 16], [14, 15], [12, 14], [2, 13], [3, 15], [16, 17], [2, 12]]",4796.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 22, 'edges': [{'u': 'H', 'v': 'I', 'w': 539.0}, {'u': 'H', 'v': 'N', 'w': 439.0}, {'u': 'H', 'v': 'D', 'w': 273.0}, {'u': 'I', 'v': 'E', 'w': 307.0}, {'u': 'I', 'v': 'O', 'w': 434.0}, {'u': 'I', 'v': 'D', 'w': 811.0}, {'u': 'J', 'v': 'A', 'w': 362.0}, {'u': 'J', 'v': 'K', 'w': 260.0}, {'u': 'J', 'v': 'P', 'w': 354.0}, {'u': 'K', 'v': 'Q', 'w': 344.0}, {'u': 'D', 'v': 'G', 'w': 53.0}, {'u': 'E', 'v': 'F', 'w': 431.0}, {'u': 'F', 'v': 'C', 'w': 257.0}, {'u': 'F', 'v': 'P', 'w': 104.0}, {'u': 'N', 'v': 'O', 'w': 543.0}, {'u': 'N', 'v': 'L', 'w': 147.0}, {'u': 'M', 'v': 'B', 'w': 2723.0}, {'u': 'O', 'v': 'C', 'w': 49.0}, {'u': 'P', 'v': 'Q', 'w': 246.0}, {'u': 'A', 'v': 'B', 'w': 731.0}, {'u': 'A', 'v': 'C', 'w': 368.0}, {'u': 'B', 'v': 'L', 'w': 383.0}], 'density': 0.16176470588235295, 'source_file': 'I042.stp', 'terminals': ['C', 'K', 'M', 'O', 'P', 'Q']}","[['K', 'Q'], ['C', 'F'], ['F', 'P'], ['N', 'O'], ['L', 'N'], ['B', 'M'], ['C', 'O'], ['P', 'Q'], ['B', 'L']]",30,nl,names
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"": 16,
  ""available_duct_segments"": 22,
  ""edges"": [
    {
      ""segment_endpoint_a"": ""J"",
      ""segment_endpoint_b"": ""H"",
      ""segment_length_feet"": 974.0
    },
    {
      ""segment_endpoint_a"": ""J"",
      ""segment_endpoint_b"": ""F"",
      ""segment_length_feet"": 1239.0
    },
    {
      ""segment_endpoint_a"": ""J"",
      ""segment_endpoint_b"": ""K"",
      ""segment_length_feet"": 1971.0
    },
    {
      ""segment_endpoint_a"": ""F"",
      ""segment_endpoint_b"": ""H"",
      ""segment_length_feet"": 455.0
    },
    {
      ""segment_endpoint_a"": ""O"",
      ""segment_endpoint_b"": ""P"",
      ""segment_length_feet"": 3480.0
    },
    {
      ""segment_endpoint_a"": ""O"",
      ""segment_endpoint_b"": ""C"",
      ""segment_length_feet"": 3308.0
    },
    {
      ""segment_endpoint_a"": ""O"",
      ""segment_endpoint_b"": ""I"",
      ""segment_length_feet"": 121.0
    },
    {
      ""segment_endpoint_a"": ""O"",
      ""segment_endpoint_b"": ""L"",
      ""segment_length_feet"": 1883.0
    },
    {
      ""segment_endpoint_a"": ""P"",
      ""segment_endpoint_b"": ""C"",
      ""segment_length_feet"": 472.0
    },
    {
      ""segment_endpoint_a"": ""N"",
      ""segment_endpoint_b"": ""A"",
      ""segment_length_feet"": 7002.0
    },
    {
      ""segment_endpoint_a"": ""A"",
      ""segment_endpoint_b"": ""B"",
      ""segment_length_feet"": 1195.0
    },
    {
      ""segment_endpoint_a"": ""A"",
      ""segment_endpoint_b"": ""L"",
      ""segment_length_feet"": 1527.0
    },
    {
      ""segment_endpoint_a"": ""K"",
      ""segment_endpoint_b"": ""L"",
      ""segment_length_feet"": 364.0
    },
    {
      ""segment_endpoint_a"": ""K"",
      ""segment_endpoint_b"": ""B"",
      ""segment_length_feet"": 1356.0
    },
    {
      ""segment_endpoint_a"": ""M"",
      ""segment_endpoint_b"": ""I"",
      ""segment_length_feet"": 1487.0
    },
    {
      ""segment_endpoint_a"": ""M"",
      ""segment_endpoint_b"": ""G"",
      ""segment_length_feet"": 4393.0
    },
    {
      ""segment_endpoint_a"": ""M"",
      ""segment_endpoint_b"": ""H"",
      ""segment_length_feet"": 1074.0
    },
    {
      ""segment_endpoint_a"": ""C"",
      ""segment_endpoint_b"": ""D"",
      ""segment_length_feet"": 436.0
    },
    {
      ""segment_endpoint_a"": ""C"",
      ""segment_endpoint_b"": ""E"",
      ""segment_length_feet"": 467.0
    },
    {
      ""segment_endpoint_a"": ""E"",
      ""segment_endpoint_b"": ""I"",
      ""segment_length_feet"": 3276.0
    },
    {
      ""segment_endpoint_a"": ""E"",
      ""segment_endpoint_b"": ""G"",
      ""segment_length_feet"": 55.0
    },
    {
      ""segment_endpoint_a"": ""G"",
      ""segment_endpoint_b"": ""D"",
      ""segment_length_feet"": 80.0
    }
  ],
  ""required_rooms"": [
    ""B"",
    ""C"",
    ""D"",
    ""G"",
    ""L"",
    ""P""
  ]
}

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': 16, 'num_edges': 22, 'edges': [{'u': 10, 'v': 8, 'w': 974.0}, {'u': 10, 'v': 6, 'w': 1239.0}, {'u': 10, 'v': 11, 'w': 1971.0}, {'u': 6, 'v': 8, 'w': 455.0}, {'u': 15, 'v': 16, 'w': 3480.0}, {'u': 15, 'v': 3, 'w': 3308.0}, {'u': 15, 'v': 9, 'w': 121.0}, {'u': 15, 'v': 12, 'w': 1883.0}, {'u': 16, 'v': 3, 'w': 472.0}, {'u': 14, 'v': 1, 'w': 7002.0}, {'u': 1, 'v': 2, 'w': 1195.0}, {'u': 1, 'v': 12, 'w': 1527.0}, {'u': 11, 'v': 12, 'w': 364.0}, {'u': 11, 'v': 2, 'w': 1356.0}, {'u': 13, 'v': 9, 'w': 1487.0}, {'u': 13, 'v': 7, 'w': 4393.0}, {'u': 13, 'v': 8, 'w': 1074.0}, {'u': 3, 'v': 4, 'w': 436.0}, {'u': 3, 'v': 5, 'w': 467.0}, {'u': 5, 'v': 9, 'w': 3276.0}, {'u': 5, 'v': 7, 'w': 55.0}, {'u': 7, 'v': 4, 'w': 80.0}], 'terminals': [2, 3, 4, 7, 12, 16], 'source_file': 'I037.stp', 'density': 0.18333333333333332, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0030.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0030.png'}","[[3, 15], [12, 15], [3, 16], [11, 12], [2, 11], [3, 4], [4, 7]]",7899.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 22, 'edges': [{'u': 'J', 'v': 'H', 'w': 974.0}, {'u': 'J', 'v': 'F', 'w': 1239.0}, {'u': 'J', 'v': 'K', 'w': 1971.0}, {'u': 'F', 'v': 'H', 'w': 455.0}, {'u': 'O', 'v': 'P', 'w': 3480.0}, {'u': 'O', 'v': 'C', 'w': 3308.0}, {'u': 'O', 'v': 'I', 'w': 121.0}, {'u': 'O', 'v': 'L', 'w': 1883.0}, {'u': 'P', 'v': 'C', 'w': 472.0}, {'u': 'N', 'v': 'A', 'w': 7002.0}, {'u': 'A', 'v': 'B', 'w': 1195.0}, {'u': 'A', 'v': 'L', 'w': 1527.0}, {'u': 'K', 'v': 'L', 'w': 364.0}, {'u': 'K', 'v': 'B', 'w': 1356.0}, {'u': 'M', 'v': 'I', 'w': 1487.0}, {'u': 'M', 'v': 'G', 'w': 4393.0}, {'u': 'M', 'v': 'H', 'w': 1074.0}, {'u': 'C', 'v': 'D', 'w': 436.0}, {'u': 'C', 'v': 'E', 'w': 467.0}, {'u': 'E', 'v': 'I', 'w': 3276.0}, {'u': 'E', 'v': 'G', 'w': 55.0}, {'u': 'G', 'v': 'D', 'w': 80.0}], 'density': 0.18333333333333332, 'source_file': 'I037.stp', 'terminals': ['B', 'C', 'D', 'G', 'L', 'P']}","[['C', 'O'], ['L', 'O'], ['C', 'P'], ['K', 'L'], ['B', 'K'], ['C', 'D'], ['D', 'G']]",31,json,names
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 16 habitat patches, the 18 possible corridors, and the monitored patches we must join: 6 7 8 10 13 14.
We can maintain the corridor between 4 and 10 with length 221.0.
We can maintain the corridor between 4 and 7 with length 1716.0.
We can maintain the corridor between 3 and 13 with length 852.0.
We can maintain the corridor between 5 and 7 with length 3540.0.
We can maintain the corridor between 13 and 15 with length 1447.0.
We can maintain the corridor between 13 and 11 with length 1092.0.
We can maintain the corridor between 14 and 15 with length 1121.0.
We can maintain the corridor between 7 and 8 with length 1942.0.
We can maintain the corridor between 8 and 6 with length 1265.0.
We can maintain the corridor between 8 and 1 with length 1052.0.
We can maintain the corridor between 9 and 1 with length 335.0.
We can maintain the corridor between 9 and 2 with length 978.0.
We can maintain the corridor between 9 and 15 with length 1127.0.
We can maintain the corridor between 0 and 1 with length 1134.0.
We can maintain the corridor between 0 and 2 with length 664.0.
We can maintain the corridor between 10 and 12 with length 214.0.
We can maintain the corridor between 10 and 11 with length 1260.0.
We can maintain the corridor between 11 and 2 with length 650.0.
We will count each maintained corridor once and must connect all 6 7 8 10 13 14 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': 16, 'num_edges': 18, 'edges': [{'u': 5, 'v': 11, 'w': 221.0}, {'u': 5, 'v': 8, 'w': 1716.0}, {'u': 4, 'v': 14, 'w': 852.0}, {'u': 6, 'v': 8, 'w': 3540.0}, {'u': 14, 'v': 16, 'w': 1447.0}, {'u': 14, 'v': 12, 'w': 1092.0}, {'u': 15, 'v': 16, 'w': 1121.0}, {'u': 8, 'v': 9, 'w': 1942.0}, {'u': 9, 'v': 7, 'w': 1265.0}, {'u': 9, 'v': 2, 'w': 1052.0}, {'u': 10, 'v': 2, 'w': 335.0}, {'u': 10, 'v': 3, 'w': 978.0}, {'u': 10, 'v': 16, 'w': 1127.0}, {'u': 1, 'v': 2, 'w': 1134.0}, {'u': 1, 'v': 3, 'w': 664.0}, {'u': 11, 'v': 13, 'w': 214.0}, {'u': 11, 'v': 12, 'w': 1260.0}, {'u': 12, 'v': 3, 'w': 650.0}], 'terminals': [7, 8, 9, 11, 14, 15], 'source_file': 'I040.stp', 'density': 0.15, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0031.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0031.png'}","[[5, 11], [5, 8], [14, 16], [12, 14], [15, 16], [8, 9], [7, 9], [11, 12]]",10064.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 18, 'edges': [{'u': 4, 'v': 10, 'w': 221.0}, {'u': 4, 'v': 7, 'w': 1716.0}, {'u': 3, 'v': 13, 'w': 852.0}, {'u': 5, 'v': 7, 'w': 3540.0}, {'u': 13, 'v': 15, 'w': 1447.0}, {'u': 13, 'v': 11, 'w': 1092.0}, {'u': 14, 'v': 15, 'w': 1121.0}, {'u': 7, 'v': 8, 'w': 1942.0}, {'u': 8, 'v': 6, 'w': 1265.0}, {'u': 8, 'v': 1, 'w': 1052.0}, {'u': 9, 'v': 1, 'w': 335.0}, {'u': 9, 'v': 2, 'w': 978.0}, {'u': 9, 'v': 15, 'w': 1127.0}, {'u': 0, 'v': 1, 'w': 1134.0}, {'u': 0, 'v': 2, 'w': 664.0}, {'u': 10, 'v': 12, 'w': 214.0}, {'u': 10, 'v': 11, 'w': 1260.0}, {'u': 11, 'v': 2, 'w': 650.0}], 'density': 0.15, 'source_file': 'I040.stp', 'terminals': [6, 7, 8, 10, 13, 14]}","[[4, 10], [4, 7], [13, 15], [11, 13], [14, 15], [7, 8], [6, 8], [10, 11]]",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.

The store layout instance contains 18 backroom zones, 21 candidate passages, and the required service areas are D H K M Q.
Candidate corridor between O and I with length 190.0.
Candidate corridor between D and C with length 469.0.
Candidate corridor between D and A with length 4757.0.
Candidate corridor between D and L with length 506.0.
Candidate corridor between N and K with length 1379.0.
Candidate corridor between B and F with length 1271.0.
Candidate corridor between B and E with length 1269.0.
Candidate corridor between P and Q with length 4015.0.
Candidate corridor between E and H with length 646.0.
Candidate corridor between E and F with length 919.0.
Candidate corridor between C and K with length 129.0.
Candidate corridor between F and J with length 118.0.
Candidate corridor between I and J with length 1425.0.
Candidate corridor between I and G with length 206.0.
Candidate corridor between J and L with length 2127.0.
Candidate corridor between Q and M with length 131.0.
Candidate corridor between Q and R with length 1630.0.
Candidate corridor between K and L with length 518.0.
Candidate corridor between G and H with length 1216.0.
Candidate corridor between G and M with length 1195.0.
Candidate corridor between H and M with length 395.0.
Select corridors that join all D H K M Q into one continuous service circuit while minimizing the total opened passage length.

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': 18, 'num_edges': 21, 'edges': [{'u': 15, 'v': 9, 'w': 190.0}, {'u': 4, 'v': 3, 'w': 469.0}, {'u': 4, 'v': 1, 'w': 4757.0}, {'u': 4, 'v': 12, 'w': 506.0}, {'u': 14, 'v': 11, 'w': 1379.0}, {'u': 2, 'v': 6, 'w': 1271.0}, {'u': 2, 'v': 5, 'w': 1269.0}, {'u': 16, 'v': 17, 'w': 4015.0}, {'u': 5, 'v': 8, 'w': 646.0}, {'u': 5, 'v': 6, 'w': 919.0}, {'u': 3, 'v': 11, 'w': 129.0}, {'u': 6, 'v': 10, 'w': 118.0}, {'u': 9, 'v': 10, 'w': 1425.0}, {'u': 9, 'v': 7, 'w': 206.0}, {'u': 10, 'v': 12, 'w': 2127.0}, {'u': 17, 'v': 13, 'w': 131.0}, {'u': 17, 'v': 18, 'w': 1630.0}, {'u': 11, 'v': 12, 'w': 518.0}, {'u': 7, 'v': 8, 'w': 1216.0}, {'u': 7, 'v': 13, 'w': 1195.0}, {'u': 8, 'v': 13, 'w': 395.0}], 'terminals': [4, 8, 11, 13, 17], 'source_file': 'I049.stp', 'density': 0.13725490196078433, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0032.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0032.png'}","[[4, 12], [5, 8], [5, 6], [6, 10], [10, 12], [13, 17], [11, 12], [8, 13]]",5360.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 21, 'edges': [{'u': 'O', 'v': 'I', 'w': 190.0}, {'u': 'D', 'v': 'C', 'w': 469.0}, {'u': 'D', 'v': 'A', 'w': 4757.0}, {'u': 'D', 'v': 'L', 'w': 506.0}, {'u': 'N', 'v': 'K', 'w': 1379.0}, {'u': 'B', 'v': 'F', 'w': 1271.0}, {'u': 'B', 'v': 'E', 'w': 1269.0}, {'u': 'P', 'v': 'Q', 'w': 4015.0}, {'u': 'E', 'v': 'H', 'w': 646.0}, {'u': 'E', 'v': 'F', 'w': 919.0}, {'u': 'C', 'v': 'K', 'w': 129.0}, {'u': 'F', 'v': 'J', 'w': 118.0}, {'u': 'I', 'v': 'J', 'w': 1425.0}, {'u': 'I', 'v': 'G', 'w': 206.0}, {'u': 'J', 'v': 'L', 'w': 2127.0}, {'u': 'Q', 'v': 'M', 'w': 131.0}, {'u': 'Q', 'v': 'R', 'w': 1630.0}, {'u': 'K', 'v': 'L', 'w': 518.0}, {'u': 'G', 'v': 'H', 'w': 1216.0}, {'u': 'G', 'v': 'M', 'w': 1195.0}, {'u': 'H', 'v': 'M', 'w': 395.0}], 'density': 0.13725490196078433, 'source_file': 'I049.stp', 'terminals': ['D', 'H', 'K', 'M', 'Q']}","[['D', 'L'], ['E', 'H'], ['E', 'F'], ['F', 'J'], ['J', 'L'], ['M', 'Q'], ['K', 'L'], ['H', 'M']]",33,markdown_table,names
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"": 18,
  ""total_possible_connectors"": 21,
  ""edges"": [
    {
      ""connector_endpoint_u"": 5,
      ""connector_endpoint_v"": 4,
      ""connector_length"": 168.0
    },
    {
      ""connector_endpoint_u"": 5,
      ""connector_endpoint_v"": 16,
      ""connector_length"": 337.0
    },
    {
      ""connector_endpoint_u"": 5,
      ""connector_endpoint_v"": 17,
      ""connector_length"": 1432.0
    },
    {
      ""connector_endpoint_u"": 18,
      ""connector_endpoint_v"": 7,
      ""connector_length"": 860.0
    },
    {
      ""connector_endpoint_u"": 18,
      ""connector_endpoint_v"": 17,
      ""connector_length"": 2334.0
    },
    {
      ""connector_endpoint_u"": 13,
      ""connector_endpoint_v"": 9,
      ""connector_length"": 128.0
    },
    {
      ""connector_endpoint_u"": 13,
      ""connector_endpoint_v"": 16,
      ""connector_length"": 400.0
    },
    {
      ""connector_endpoint_u"": 13,
      ""connector_endpoint_v"": 7,
      ""connector_length"": 1091.0
    },
    {
      ""connector_endpoint_u"": 12,
      ""connector_endpoint_v"": 6,
      ""connector_length"": 1655.0
    },
    {
      ""connector_endpoint_u"": 7,
      ""connector_endpoint_v"": 6,
      ""connector_length"": 2133.0
    },
    {
      ""connector_endpoint_u"": 14,
      ""connector_endpoint_v"": 3,
      ""connector_length"": 330.0
    },
    {
      ""connector_endpoint_u"": 15,
      ""connector_endpoint_v"": 3,
      ""connector_length"": 1003.0
    },
    {
      ""connector_endpoint_u"": 15,
      ""connector_endpoint_v"": 2,
      ""connector_length"": 876.0
    },
    {
      ""connector_endpoint_u"": 15,
      ""connector_endpoint_v"": 17,
      ""connector_length"": 1083.0
    },
    {
      ""connector_endpoint_u"": 1,
      ""connector_endpoint_v"": 2,
      ""connector_length"": 1048.0
    },
    {
      ""connector_endpoint_u"": 1,
      ""connector_endpoint_v"": 3,
      ""connector_length"": 1026.0
    },
    {
      ""connector_endpoint_u"": 16,
      ""connector_endpoint_v"": 10,
      ""connector_length"": 150.0
    },
    {
      ""connector_endpoint_u"": 11,
      ""connector_endpoint_v"": 9,
      ""connector_length"": 952.0
    },
    {
      ""connector_endpoint_u"": 8,
      ""connector_endpoint_v"": 6,
      ""connector_length"": 1683.0
    },
    {
      ""connector_endpoint_u"": 9,
      ""connector_endpoint_v"": 10,
      ""connector_length"": 408.0
    },
    {
      ""connector_endpoint_u"": 10,
      ""connector_endpoint_v"": 4,
      ""connector_length"": 337.0
    }
  ],
  ""required_stage_areas"": [
    6,
    9,
    10,
    13,
    16
  ]
}

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': 18, 'num_edges': 21, 'edges': [{'u': 5, 'v': 4, 'w': 168.0}, {'u': 5, 'v': 16, 'w': 337.0}, {'u': 5, 'v': 17, 'w': 1432.0}, {'u': 18, 'v': 7, 'w': 860.0}, {'u': 18, 'v': 17, 'w': 2334.0}, {'u': 13, 'v': 9, 'w': 128.0}, {'u': 13, 'v': 16, 'w': 400.0}, {'u': 13, 'v': 7, 'w': 1091.0}, {'u': 12, 'v': 6, 'w': 1655.0}, {'u': 7, 'v': 6, 'w': 2133.0}, {'u': 14, 'v': 3, 'w': 330.0}, {'u': 15, 'v': 3, 'w': 1003.0}, {'u': 15, 'v': 2, 'w': 876.0}, {'u': 15, 'v': 17, 'w': 1083.0}, {'u': 1, 'v': 2, 'w': 1048.0}, {'u': 1, 'v': 3, 'w': 1026.0}, {'u': 16, 'v': 10, 'w': 150.0}, {'u': 11, 'v': 9, 'w': 952.0}, {'u': 8, 'v': 6, 'w': 1683.0}, {'u': 9, 'v': 10, 'w': 408.0}, {'u': 10, 'v': 4, 'w': 337.0}], 'terminals': [6, 9, 10, 13, 16], 'source_file': 'I019.stp', 'density': 0.13725490196078433, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0033.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0033.png'}","[[9, 13], [13, 16], [7, 13], [6, 7], [10, 16]]",3902.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 21, 'edges': [{'u': 5, 'v': 4, 'w': 168.0}, {'u': 5, 'v': 16, 'w': 337.0}, {'u': 5, 'v': 17, 'w': 1432.0}, {'u': 18, 'v': 7, 'w': 860.0}, {'u': 18, 'v': 17, 'w': 2334.0}, {'u': 13, 'v': 9, 'w': 128.0}, {'u': 13, 'v': 16, 'w': 400.0}, {'u': 13, 'v': 7, 'w': 1091.0}, {'u': 12, 'v': 6, 'w': 1655.0}, {'u': 7, 'v': 6, 'w': 2133.0}, {'u': 14, 'v': 3, 'w': 330.0}, {'u': 15, 'v': 3, 'w': 1003.0}, {'u': 15, 'v': 2, 'w': 876.0}, {'u': 15, 'v': 17, 'w': 1083.0}, {'u': 1, 'v': 2, 'w': 1048.0}, {'u': 1, 'v': 3, 'w': 1026.0}, {'u': 16, 'v': 10, 'w': 150.0}, {'u': 11, 'v': 9, 'w': 952.0}, {'u': 8, 'v': 6, 'w': 1683.0}, {'u': 9, 'v': 10, 'w': 408.0}, {'u': 10, 'v': 4, 'w': 337.0}], 'density': 0.13725490196078433, 'source_file': 'I019.stp', 'terminals': [6, 9, 10, 13, 16]}","[[9, 13], [13, 16], [7, 13], [6, 7], [10, 16]]",34,json,1
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 18 marked locations and 20 candidate short paths; the picnic groves to span are 1 4 6 9 11 13 14 15 17.
Candidate short path between 1 and 2 with length 303288.0.
Candidate short path between 1 and 3 with length 302912.0.
Candidate short path between 2 and 5 with length 1026.0.
Candidate short path between 2 and 8 with length 1258.0.
Candidate short path between 14 and 12 with length 1644.0.
Candidate short path between 14 and 8 with length 29.0.
Candidate short path between 14 and 15 with length 175.0.
Candidate short path between 5 and 18 with length 2669.0.
Candidate short path between 5 and 3 with length 1788.0.
Candidate short path between 3 and 8 with length 1046.0.
Candidate short path between 15 and 11 with length 4147.0.
Candidate short path between 4 and 10 with length 324.0.
Candidate short path between 11 and 7 with length 261.0.
Candidate short path between 12 and 6 with length 165.0.
Candidate short path between 6 and 7 with length 2599.0.
Candidate short path between 9 and 10 with length 1036.0.
Candidate short path between 10 and 18 with length 447.0.
Candidate short path between 13 and 17 with length 1556.0.
Candidate short path between 16 and 17 with length 897.0.
Candidate short path between 17 and 18 with length 167.0.
Choose a subset of these connections that spans 1 4 6 9 11 13 14 15 17 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': 18, 'num_edges': 20, 'edges': [{'u': 1, 'v': 2, 'w': 303288.0}, {'u': 1, 'v': 3, 'w': 302912.0}, {'u': 2, 'v': 5, 'w': 1026.0}, {'u': 2, 'v': 8, 'w': 1258.0}, {'u': 14, 'v': 12, 'w': 1644.0}, {'u': 14, 'v': 8, 'w': 29.0}, {'u': 14, 'v': 15, 'w': 175.0}, {'u': 5, 'v': 18, 'w': 2669.0}, {'u': 5, 'v': 3, 'w': 1788.0}, {'u': 3, 'v': 8, 'w': 1046.0}, {'u': 15, 'v': 11, 'w': 4147.0}, {'u': 4, 'v': 10, 'w': 324.0}, {'u': 11, 'v': 7, 'w': 261.0}, {'u': 12, 'v': 6, 'w': 165.0}, {'u': 6, 'v': 7, 'w': 2599.0}, {'u': 9, 'v': 10, 'w': 1036.0}, {'u': 10, 'v': 18, 'w': 447.0}, {'u': 13, 'v': 17, 'w': 1556.0}, {'u': 16, 'v': 17, 'w': 897.0}, {'u': 17, 'v': 18, 'w': 167.0}], 'terminals': [1, 4, 6, 9, 11, 13, 14, 15, 17], 'source_file': 'I082.stp', 'density': 0.13071895424836602, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0034.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0034.png'}","[[1, 2], [2, 5], [2, 8], [12, 14], [8, 14], [14, 15], [5, 18], [4, 10], [7, 11], [6, 12], [6, 7], [9, 10], [10, 18], [13, 17], [17, 18]]",316644.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 20, 'edges': [{'u': 1, 'v': 2, 'w': 303288.0}, {'u': 1, 'v': 3, 'w': 302912.0}, {'u': 2, 'v': 5, 'w': 1026.0}, {'u': 2, 'v': 8, 'w': 1258.0}, {'u': 14, 'v': 12, 'w': 1644.0}, {'u': 14, 'v': 8, 'w': 29.0}, {'u': 14, 'v': 15, 'w': 175.0}, {'u': 5, 'v': 18, 'w': 2669.0}, {'u': 5, 'v': 3, 'w': 1788.0}, {'u': 3, 'v': 8, 'w': 1046.0}, {'u': 15, 'v': 11, 'w': 4147.0}, {'u': 4, 'v': 10, 'w': 324.0}, {'u': 11, 'v': 7, 'w': 261.0}, {'u': 12, 'v': 6, 'w': 165.0}, {'u': 6, 'v': 7, 'w': 2599.0}, {'u': 9, 'v': 10, 'w': 1036.0}, {'u': 10, 'v': 18, 'w': 447.0}, {'u': 13, 'v': 17, 'w': 1556.0}, {'u': 16, 'v': 17, 'w': 897.0}, {'u': 17, 'v': 18, 'w': 167.0}], 'density': 0.13071895424836602, 'source_file': 'I082.stp', 'terminals': [1, 4, 6, 9, 11, 13, 14, 15, 17]}","[[1, 2], [2, 5], [2, 8], [12, 14], [8, 14], [14, 15], [5, 18], [4, 10], [7, 11], [6, 12], [6, 7], [9, 10], [10, 18], [13, 17], [17, 18]]",35,markdown_table,1
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"": 17,
  ""total_trunk_links"": 21,
  ""edges"": [
    {
      ""endpoint_node_a"": ""L"",
      ""endpoint_node_b"": ""E"",
      ""trunk_length_meters"": 239.0
    },
    {
      ""endpoint_node_a"": ""L"",
      ""endpoint_node_b"": ""D"",
      ""trunk_length_meters"": 696.0
    },
    {
      ""endpoint_node_a"": ""L"",
      ""endpoint_node_b"": ""O"",
      ""trunk_length_meters"": 2237.0
    },
    {
      ""endpoint_node_a"": ""K"",
      ""endpoint_node_b"": ""A"",
      ""trunk_length_meters"": 960.0
    },
    {
      ""endpoint_node_a"": ""K"",
      ""endpoint_node_b"": ""P"",
      ""trunk_length_meters"": 2069.0
    },
    {
      ""endpoint_node_a"": ""J"",
      ""endpoint_node_b"": ""I"",
      ""trunk_length_meters"": 302.0
    },
    {
      ""endpoint_node_a"": ""J"",
      ""endpoint_node_b"": ""F"",
      ""trunk_length_meters"": 368.0
    },
    {
      ""endpoint_node_a"": ""J"",
      ""endpoint_node_b"": ""Q"",
      ""trunk_length_meters"": 1950.0
    },
    {
      ""endpoint_node_a"": ""B"",
      ""endpoint_node_b"": ""E"",
      ""trunk_length_meters"": 387.0
    },
    {
      ""endpoint_node_a"": ""B"",
      ""endpoint_node_b"": ""Q"",
      ""trunk_length_meters"": 2125.0
    },
    {
      ""endpoint_node_a"": ""C"",
      ""endpoint_node_b"": ""D"",
      ""trunk_length_meters"": 251.0
    },
    {
      ""endpoint_node_a"": ""C"",
      ""endpoint_node_b"": ""E"",
      ""trunk_length_meters"": 701.0
    },
    {
      ""endpoint_node_a"": ""C"",
      ""endpoint_node_b"": ""G"",
      ""trunk_length_meters"": 301.0
    },
    {
      ""endpoint_node_a"": ""D"",
      ""endpoint_node_b"": ""H"",
      ""trunk_length_meters"": 295.0
    },
    {
      ""endpoint_node_a"": ""A"",
      ""endpoint_node_b"": ""F"",
      ""trunk_length_meters"": 254.0
    },
    {
      ""endpoint_node_a"": ""M"",
      ""endpoint_node_b"": ""N"",
      ""trunk_length_meters"": 153.0
    },
    {
      ""endpoint_node_a"": ""M"",
      ""endpoint_node_b"": ""G"",
      ""trunk_length_meters"": 187.0
    },
    {
      ""endpoint_node_a"": ""M"",
      ""endpoint_node_b"": ""P"",
      ""trunk_length_meters"": 2577.0
    },
    {
      ""endpoint_node_a"": ""N"",
      ""endpoint_node_b"": ""H"",
      ""trunk_length_meters"": 150.0
    },
    {
      ""endpoint_node_a"": ""P"",
      ""endpoint_node_b"": ""Q"",
      ""trunk_length_meters"": 1633.0
    },
    {
      ""endpoint_node_a"": ""G"",
      ""endpoint_node_b"": ""H"",
      ""trunk_length_meters"": 189.0
    }
  ],
  ""critical_racks"": [
    ""B"",
    ""K"",
    ""M""
  ]
}

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': 17, 'num_edges': 21, 'edges': [{'u': 12, 'v': 5, 'w': 239.0}, {'u': 12, 'v': 4, 'w': 696.0}, {'u': 12, 'v': 15, 'w': 2237.0}, {'u': 11, 'v': 1, 'w': 960.0}, {'u': 11, 'v': 16, 'w': 2069.0}, {'u': 10, 'v': 9, 'w': 302.0}, {'u': 10, 'v': 6, 'w': 368.0}, {'u': 10, 'v': 17, 'w': 1950.0}, {'u': 2, 'v': 5, 'w': 387.0}, {'u': 2, 'v': 17, 'w': 2125.0}, {'u': 3, 'v': 4, 'w': 251.0}, {'u': 3, 'v': 5, 'w': 701.0}, {'u': 3, 'v': 7, 'w': 301.0}, {'u': 4, 'v': 8, 'w': 295.0}, {'u': 1, 'v': 6, 'w': 254.0}, {'u': 13, 'v': 14, 'w': 153.0}, {'u': 13, 'v': 7, 'w': 187.0}, {'u': 13, 'v': 16, 'w': 2577.0}, {'u': 14, 'v': 8, 'w': 150.0}, {'u': 16, 'v': 17, 'w': 1633.0}, {'u': 7, 'v': 8, 'w': 189.0}], 'terminals': [2, 11, 13], 'source_file': 'I020.stp', 'density': 0.15441176470588236, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0035.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0035.png'}","[[11, 16], [2, 5], [3, 5], [3, 7], [7, 13], [13, 16]]",6222.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 21, 'edges': [{'u': 'L', 'v': 'E', 'w': 239.0}, {'u': 'L', 'v': 'D', 'w': 696.0}, {'u': 'L', 'v': 'O', 'w': 2237.0}, {'u': 'K', 'v': 'A', 'w': 960.0}, {'u': 'K', 'v': 'P', 'w': 2069.0}, {'u': 'J', 'v': 'I', 'w': 302.0}, {'u': 'J', 'v': 'F', 'w': 368.0}, {'u': 'J', 'v': 'Q', 'w': 1950.0}, {'u': 'B', 'v': 'E', 'w': 387.0}, {'u': 'B', 'v': 'Q', 'w': 2125.0}, {'u': 'C', 'v': 'D', 'w': 251.0}, {'u': 'C', 'v': 'E', 'w': 701.0}, {'u': 'C', 'v': 'G', 'w': 301.0}, {'u': 'D', 'v': 'H', 'w': 295.0}, {'u': 'A', 'v': 'F', 'w': 254.0}, {'u': 'M', 'v': 'N', 'w': 153.0}, {'u': 'M', 'v': 'G', 'w': 187.0}, {'u': 'M', 'v': 'P', 'w': 2577.0}, {'u': 'N', 'v': 'H', 'w': 150.0}, {'u': 'P', 'v': 'Q', 'w': 1633.0}, {'u': 'G', 'v': 'H', 'w': 189.0}], 'density': 0.15441176470588236, 'source_file': 'I020.stp', 'terminals': ['B', 'K', 'M']}","[['K', 'P'], ['B', 'E'], ['C', 'E'], ['C', 'G'], ['G', 'M'], ['M', 'P']]",36,json,names
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.

There are 16 distinct pedestrian locations, 19 distinct sidewalk and street segments, and emergency shelters at nodes 8 9 10 16.
Sidewalk/side-street/plaza segment connecting nodes 11 and 12 with length 9604.0.
Sidewalk/side-street/plaza segment connecting nodes 11 and 10 with length 3985.0.
Sidewalk/side-street/plaza segment connecting nodes 11 and 15 with length 3454.0.
Sidewalk/side-street/plaza segment connecting nodes 3 and 2 with length 1105.0.
Sidewalk/side-street/plaza segment connecting nodes 3 and 4 with length 92.0.
Sidewalk/side-street/plaza segment connecting nodes 3 and 13 with length 630.0.
Sidewalk/side-street/plaza segment connecting nodes 12 and 16 with length 2056.0.
Sidewalk/side-street/plaza segment connecting nodes 4 and 2 with length 1117.0.
Sidewalk/side-street/plaza segment connecting nodes 1 and 9 with length 64.0.
Sidewalk/side-street/plaza segment connecting nodes 1 and 5 with length 1376.0.
Sidewalk/side-street/plaza segment connecting nodes 1 and 7 with length 988.0.
Sidewalk/side-street/plaza segment connecting nodes 16 and 10 with length 7366.0.
Sidewalk/side-street/plaza segment connecting nodes 9 and 6 with length 1061.0.
Sidewalk/side-street/plaza segment connecting nodes 13 and 14 with length 1660.0.
Sidewalk/side-street/plaza segment connecting nodes 13 and 15 with length 2780.0.
Sidewalk/side-street/plaza segment connecting nodes 7 and 8 with length 844.0.
Sidewalk/side-street/plaza segment connecting nodes 7 and 14 with length 1143.0.
Sidewalk/side-street/plaza segment connecting nodes 15 and 14 with length 3568.0.
Sidewalk/side-street/plaza segment connecting nodes 6 and 8 with length 334.0.
The job is to choose segments so the cleared pavement forms one unbroken network touching all shelters 8 9 10 16 while minimizing the total cleared length.

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': 16, 'num_edges': 19, 'edges': [{'u': 11, 'v': 12, 'w': 9604.0}, {'u': 11, 'v': 10, 'w': 3985.0}, {'u': 11, 'v': 15, 'w': 3454.0}, {'u': 3, 'v': 2, 'w': 1105.0}, {'u': 3, 'v': 4, 'w': 92.0}, {'u': 3, 'v': 13, 'w': 630.0}, {'u': 12, 'v': 16, 'w': 2056.0}, {'u': 4, 'v': 2, 'w': 1117.0}, {'u': 1, 'v': 9, 'w': 64.0}, {'u': 1, 'v': 5, 'w': 1376.0}, {'u': 1, 'v': 7, 'w': 988.0}, {'u': 16, 'v': 10, 'w': 7366.0}, {'u': 9, 'v': 6, 'w': 1061.0}, {'u': 13, 'v': 14, 'w': 1660.0}, {'u': 13, 'v': 15, 'w': 2780.0}, {'u': 7, 'v': 8, 'w': 844.0}, {'u': 7, 'v': 14, 'w': 1143.0}, {'u': 15, 'v': 14, 'w': 3568.0}, {'u': 6, 'v': 8, 'w': 334.0}], 'terminals': [8, 9, 10, 16], 'source_file': 'I050.stp', 'density': 0.15833333333333333, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0036.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0036.png'}","[[10, 11], [11, 15], [1, 9], [1, 7], [10, 16], [7, 8], [7, 14], [14, 15]]",21412.0,"{'problem_type': 'STP', 'num_nodes': 16, 'num_edges': 19, 'edges': [{'u': 11, 'v': 12, 'w': 9604.0}, {'u': 11, 'v': 10, 'w': 3985.0}, {'u': 11, 'v': 15, 'w': 3454.0}, {'u': 3, 'v': 2, 'w': 1105.0}, {'u': 3, 'v': 4, 'w': 92.0}, {'u': 3, 'v': 13, 'w': 630.0}, {'u': 12, 'v': 16, 'w': 2056.0}, {'u': 4, 'v': 2, 'w': 1117.0}, {'u': 1, 'v': 9, 'w': 64.0}, {'u': 1, 'v': 5, 'w': 1376.0}, {'u': 1, 'v': 7, 'w': 988.0}, {'u': 16, 'v': 10, 'w': 7366.0}, {'u': 9, 'v': 6, 'w': 1061.0}, {'u': 13, 'v': 14, 'w': 1660.0}, {'u': 13, 'v': 15, 'w': 2780.0}, {'u': 7, 'v': 8, 'w': 844.0}, {'u': 7, 'v': 14, 'w': 1143.0}, {'u': 15, 'v': 14, 'w': 3568.0}, {'u': 6, 'v': 8, 'w': 334.0}], 'density': 0.15833333333333333, 'source_file': 'I050.stp', 'terminals': [8, 9, 10, 16]}","[[10, 11], [11, 15], [1, 9], [1, 7], [10, 16], [7, 8], [7, 14], [14, 15]]",37,markdown_table,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.

We have 17 nodes, 19 candidate connectors, and the interactive stations are B E I N Q.
A candidate connector between M and K has length 243.0.
A candidate connector between M and O has length 1914.0.
A candidate connector between L and N has length 972.0.
A candidate connector between P and D has length 675.0.
A candidate connector between P and C has length 503.0.
A candidate connector between H and I has length 1932.0.
A candidate connector between H and J has length 681.0.
A candidate connector between H and Q has length 533.0.
A candidate connector between N and F has length 619.0.
A candidate connector between N and A has length 1359.0.
A candidate connector between O and F has length 703.0.
A candidate connector between O and I has length 241.0.
A candidate connector between A and B has length 668.0.
A candidate connector between I and G has length 1010.0.
A candidate connector between C and D has length 1171.0.
A candidate connector between D and G has length 273.0.
A candidate connector between E and F has length 1199.0.
A candidate connector between E and G has length 900.0.
A candidate connector between J and K has length 1983.0.
We’ll use these measurements to pick the shortest possible single-loop wiring that includes every interactive station.

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': 17, 'num_edges': 19, 'edges': [{'u': 13, 'v': 11, 'w': 243.0}, {'u': 13, 'v': 15, 'w': 1914.0}, {'u': 12, 'v': 14, 'w': 972.0}, {'u': 16, 'v': 4, 'w': 675.0}, {'u': 16, 'v': 3, 'w': 503.0}, {'u': 8, 'v': 9, 'w': 1932.0}, {'u': 8, 'v': 10, 'w': 681.0}, {'u': 8, 'v': 17, 'w': 533.0}, {'u': 14, 'v': 6, 'w': 619.0}, {'u': 14, 'v': 1, 'w': 1359.0}, {'u': 15, 'v': 6, 'w': 703.0}, {'u': 15, 'v': 9, 'w': 241.0}, {'u': 1, 'v': 2, 'w': 668.0}, {'u': 9, 'v': 7, 'w': 1010.0}, {'u': 3, 'v': 4, 'w': 1171.0}, {'u': 4, 'v': 7, 'w': 273.0}, {'u': 5, 'v': 6, 'w': 1199.0}, {'u': 5, 'v': 7, 'w': 900.0}, {'u': 10, 'v': 11, 'w': 1983.0}], 'terminals': [2, 5, 9, 14, 17], 'source_file': 'I006.stp', 'density': 0.13970588235294118, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0037.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0037.png'}","[[8, 9], [8, 17], [6, 14], [1, 14], [6, 15], [9, 15], [1, 2], [5, 6]]",7254.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 19, 'edges': [{'u': 'M', 'v': 'K', 'w': 243.0}, {'u': 'M', 'v': 'O', 'w': 1914.0}, {'u': 'L', 'v': 'N', 'w': 972.0}, {'u': 'P', 'v': 'D', 'w': 675.0}, {'u': 'P', 'v': 'C', 'w': 503.0}, {'u': 'H', 'v': 'I', 'w': 1932.0}, {'u': 'H', 'v': 'J', 'w': 681.0}, {'u': 'H', 'v': 'Q', 'w': 533.0}, {'u': 'N', 'v': 'F', 'w': 619.0}, {'u': 'N', 'v': 'A', 'w': 1359.0}, {'u': 'O', 'v': 'F', 'w': 703.0}, {'u': 'O', 'v': 'I', 'w': 241.0}, {'u': 'A', 'v': 'B', 'w': 668.0}, {'u': 'I', 'v': 'G', 'w': 1010.0}, {'u': 'C', 'v': 'D', 'w': 1171.0}, {'u': 'D', 'v': 'G', 'w': 273.0}, {'u': 'E', 'v': 'F', 'w': 1199.0}, {'u': 'E', 'v': 'G', 'w': 900.0}, {'u': 'J', 'v': 'K', 'w': 1983.0}], 'density': 0.13970588235294118, 'source_file': 'I006.stp', 'terminals': ['B', 'E', 'I', 'N', 'Q']}","[['H', 'I'], ['H', 'Q'], ['F', 'N'], ['A', 'N'], ['F', 'O'], ['I', 'O'], ['A', 'B'], ['E', 'F']]",38,nl,names
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"": 17,
  ""candidate_streets"": 20,
  ""edges"": [
    {
      ""intersection_a"": 0,
      ""intersection_b"": 1,
      ""street_length"": 5127.0
    },
    {
      ""intersection_a"": 5,
      ""intersection_b"": 11,
      ""street_length"": 1222.0
    },
    {
      ""intersection_a"": 5,
      ""intersection_b"": 7,
      ""street_length"": 1278.0
    },
    {
      ""intersection_a"": 5,
      ""intersection_b"": 2,
      ""street_length"": 576.0
    },
    {
      ""intersection_a"": 1,
      ""intersection_b"": 9,
      ""street_length"": 2645.0
    },
    {
      ""intersection_a"": 6,
      ""intersection_b"": 12,
      ""street_length"": 1441.0
    },
    {
      ""intersection_a"": 6,
      ""intersection_b"": 7,
      ""street_length"": 836.0
    },
    {
      ""intersection_a"": 6,
      ""intersection_b"": 2,
      ""street_length"": 979.0
    },
    {
      ""intersection_a"": 7,
      ""intersection_b"": 10,
      ""street_length"": 2296.0
    },
    {
      ""intersection_a"": 11,
      ""intersection_b"": 14,
      ""street_length"": 2104.0
    },
    {
      ""intersection_a"": 11,
      ""intersection_b"": 16,
      ""street_length"": 3613.0
    },
    {
      ""intersection_a"": 16,
      ""intersection_b"": 10,
      ""street_length"": 206.0
    },
    {
      ""intersection_a"": 16,
      ""intersection_b"": 8,
      ""street_length"": 3801.0
    },
    {
      ""intersection_a"": 15,
      ""intersection_b"": 14,
      ""street_length"": 5578.0
    },
    {
      ""intersection_a"": 12,
      ""intersection_b"": 9,
      ""street_length"": 3142.0
    },
    {
      ""intersection_a"": 12,
      ""intersection_b"": 4,
      ""street_length"": 6843.0
    },
    {
      ""intersection_a"": 10,
      ""intersection_b"": 9,
      ""street_length"": 1596.0
    },
    {
      ""intersection_a"": 4,
      ""intersection_b"": 3,
      ""street_length"": 3318.0
    },
    {
      ""intersection_a"": 4,
      ""intersection_b"": 14,
      ""street_length"": 3759.0
    },
    {
      ""intersection_a"": 3,
      ""intersection_b"": 13,
      ""street_length"": 10634.0
    }
  ],
  ""neighborhood_hubs"": [
    0,
    4
  ]
}

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': 17, 'num_edges': 20, 'edges': [{'u': 1, 'v': 2, 'w': 5127.0}, {'u': 6, 'v': 12, 'w': 1222.0}, {'u': 6, 'v': 8, 'w': 1278.0}, {'u': 6, 'v': 3, 'w': 576.0}, {'u': 2, 'v': 10, 'w': 2645.0}, {'u': 7, 'v': 13, 'w': 1441.0}, {'u': 7, 'v': 8, 'w': 836.0}, {'u': 7, 'v': 3, 'w': 979.0}, {'u': 8, 'v': 11, 'w': 2296.0}, {'u': 12, 'v': 15, 'w': 2104.0}, {'u': 12, 'v': 17, 'w': 3613.0}, {'u': 17, 'v': 11, 'w': 206.0}, {'u': 17, 'v': 9, 'w': 3801.0}, {'u': 16, 'v': 15, 'w': 5578.0}, {'u': 13, 'v': 10, 'w': 3142.0}, {'u': 13, 'v': 5, 'w': 6843.0}, {'u': 11, 'v': 10, 'w': 1596.0}, {'u': 5, 'v': 4, 'w': 3318.0}, {'u': 5, 'v': 15, 'w': 3759.0}, {'u': 4, 'v': 14, 'w': 10634.0}], 'terminals': [1, 5], 'source_file': 'I019.stp', 'density': 0.14705882352941177, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0038.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0038.png'}","[[1, 2], [2, 10], [10, 13], [5, 13]]",17757.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 20, 'edges': [{'u': 0, 'v': 1, 'w': 5127.0}, {'u': 5, 'v': 11, 'w': 1222.0}, {'u': 5, 'v': 7, 'w': 1278.0}, {'u': 5, 'v': 2, 'w': 576.0}, {'u': 1, 'v': 9, 'w': 2645.0}, {'u': 6, 'v': 12, 'w': 1441.0}, {'u': 6, 'v': 7, 'w': 836.0}, {'u': 6, 'v': 2, 'w': 979.0}, {'u': 7, 'v': 10, 'w': 2296.0}, {'u': 11, 'v': 14, 'w': 2104.0}, {'u': 11, 'v': 16, 'w': 3613.0}, {'u': 16, 'v': 10, 'w': 206.0}, {'u': 16, 'v': 8, 'w': 3801.0}, {'u': 15, 'v': 14, 'w': 5578.0}, {'u': 12, 'v': 9, 'w': 3142.0}, {'u': 12, 'v': 4, 'w': 6843.0}, {'u': 10, 'v': 9, 'w': 1596.0}, {'u': 4, 'v': 3, 'w': 3318.0}, {'u': 4, 'v': 14, 'w': 3759.0}, {'u': 3, 'v': 13, 'w': 10634.0}], 'density': 0.14705882352941177, 'source_file': 'I019.stp', 'terminals': [0, 4]}","[[0, 1], [1, 9], [9, 12], [4, 12]]",39,json,0
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.

The map showed 19 distinct locations, 24 candidate walkways, and the required spots were 0 1 5 6 7 10 13 15 16.
A candidate walkway linking 10 and 8 would cost 173000.0.
A candidate walkway linking 10 and 7 would cost 174697.0.
A candidate walkway linking 12 and 3 would cost 1552.0.
A candidate walkway linking 12 and 2 would cost 3612.0.
A candidate walkway linking 13 and 1 would cost 2965.0.
A candidate walkway linking 13 and 17 would cost 531.0.
A candidate walkway linking 11 and 9 would cost 849.0.
A candidate walkway linking 11 and 18 would cost 428.0.
A candidate walkway linking 14 and 2 would cost 188.0.
A candidate walkway linking 14 and 5 would cost 964.0.
A candidate walkway linking 14 and 16 would cost 1235.0.
A candidate walkway linking 15 and 5 would cost 1240.0.
A candidate walkway linking 15 and 0 would cost 851.0.
A candidate walkway linking 15 and 17 would cost 1254.0.
A candidate walkway linking 16 and 9 would cost 1999.0.
A candidate walkway linking 16 and 6 would cost 849.0.
A candidate walkway linking 17 and 7 would cost 1166.0.
A candidate walkway linking 3 and 0 would cost 4991.0.
A candidate walkway linking 18 and 8 would cost 2185.0.
A candidate walkway linking 4 and 5 would cost 415.0.
A candidate walkway linking 4 and 6 would cost 885.0.
A candidate walkway linking 6 and 7 would cost 233.0.
A candidate walkway linking 8 and 9 would cost 917.0.
A candidate walkway linking 0 and 1 would cost 939.0.
The task remained to select segments that connect all 0 1 5 6 7 10 13 15 16 at the minimum total construction cost.

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': 19, 'num_edges': 24, 'edges': [{'u': 11, 'v': 9, 'w': 173000.0}, {'u': 11, 'v': 8, 'w': 174697.0}, {'u': 13, 'v': 4, 'w': 1552.0}, {'u': 13, 'v': 3, 'w': 3612.0}, {'u': 14, 'v': 2, 'w': 2965.0}, {'u': 14, 'v': 18, 'w': 531.0}, {'u': 12, 'v': 10, 'w': 849.0}, {'u': 12, 'v': 19, 'w': 428.0}, {'u': 15, 'v': 3, 'w': 188.0}, {'u': 15, 'v': 6, 'w': 964.0}, {'u': 15, 'v': 17, 'w': 1235.0}, {'u': 16, 'v': 6, 'w': 1240.0}, {'u': 16, 'v': 1, 'w': 851.0}, {'u': 16, 'v': 18, 'w': 1254.0}, {'u': 17, 'v': 10, 'w': 1999.0}, {'u': 17, 'v': 7, 'w': 849.0}, {'u': 18, 'v': 8, 'w': 1166.0}, {'u': 4, 'v': 1, 'w': 4991.0}, {'u': 19, 'v': 9, 'w': 2185.0}, {'u': 5, 'v': 6, 'w': 415.0}, {'u': 5, 'v': 7, 'w': 885.0}, {'u': 7, 'v': 8, 'w': 233.0}, {'u': 9, 'v': 10, 'w': 917.0}, {'u': 1, 'v': 2, 'w': 939.0}], 'terminals': [1, 2, 6, 7, 8, 11, 14, 16, 17], 'source_file': 'I040.stp', 'density': 0.14035087719298245, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0039.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0039.png'}","[[8, 11], [14, 18], [6, 16], [1, 16], [16, 18], [7, 17], [8, 18], [7, 8], [1, 2]]",181760.0,"{'problem_type': 'STP', 'num_nodes': 19, 'num_edges': 24, 'edges': [{'u': 10, 'v': 8, 'w': 173000.0}, {'u': 10, 'v': 7, 'w': 174697.0}, {'u': 12, 'v': 3, 'w': 1552.0}, {'u': 12, 'v': 2, 'w': 3612.0}, {'u': 13, 'v': 1, 'w': 2965.0}, {'u': 13, 'v': 17, 'w': 531.0}, {'u': 11, 'v': 9, 'w': 849.0}, {'u': 11, 'v': 18, 'w': 428.0}, {'u': 14, 'v': 2, 'w': 188.0}, {'u': 14, 'v': 5, 'w': 964.0}, {'u': 14, 'v': 16, 'w': 1235.0}, {'u': 15, 'v': 5, 'w': 1240.0}, {'u': 15, 'v': 0, 'w': 851.0}, {'u': 15, 'v': 17, 'w': 1254.0}, {'u': 16, 'v': 9, 'w': 1999.0}, {'u': 16, 'v': 6, 'w': 849.0}, {'u': 17, 'v': 7, 'w': 1166.0}, {'u': 3, 'v': 0, 'w': 4991.0}, {'u': 18, 'v': 8, 'w': 2185.0}, {'u': 4, 'v': 5, 'w': 415.0}, {'u': 4, 'v': 6, 'w': 885.0}, {'u': 6, 'v': 7, 'w': 233.0}, {'u': 8, 'v': 9, 'w': 917.0}, {'u': 0, 'v': 1, 'w': 939.0}], 'density': 0.14035087719298245, 'source_file': 'I040.stp', 'terminals': [0, 1, 5, 6, 7, 10, 13, 15, 16]}","[[7, 10], [13, 17], [5, 15], [0, 15], [15, 17], [6, 16], [7, 17], [6, 7], [0, 1]]",40,markdown_table,0
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.

{
  ""total_locations"": 18,
  ""total_cable_segments"": 23,
  ""edges"": [
    {
      ""endpoint_a_node"": ""F"",
      ""endpoint_b_node"": ""E"",
      ""cable_length"": 437.0
    },
    {
      ""endpoint_a_node"": ""F"",
      ""endpoint_b_node"": ""N"",
      ""cable_length"": 104.0
    },
    {
      ""endpoint_a_node"": ""F"",
      ""endpoint_b_node"": ""G"",
      ""cable_length"": 843.0
    },
    {
      ""endpoint_a_node"": ""G"",
      ""endpoint_b_node"": ""D"",
      ""cable_length"": 887.0
    },
    {
      ""endpoint_a_node"": ""G"",
      ""endpoint_b_node"": ""O"",
      ""cable_length"": 2234.0
    },
    {
      ""endpoint_a_node"": ""H"",
      ""endpoint_b_node"": ""E"",
      ""cable_length"": 482.0
    },
    {
      ""endpoint_a_node"": ""H"",
      ""endpoint_b_node"": ""P"",
      ""cable_length"": 104.0
    },
    {
      ""endpoint_a_node"": ""H"",
      ""endpoint_b_node"": ""I"",
      ""cable_length"": 387.0
    },
    {
      ""endpoint_a_node"": ""I"",
      ""endpoint_b_node"": ""D"",
      ""cable_length"": 486.0
    },
    {
      ""endpoint_a_node"": ""I"",
      ""endpoint_b_node"": ""Q"",
      ""cable_length"": 2692.0
    },
    {
      ""endpoint_a_node"": ""O"",
      ""endpoint_b_node"": ""Q"",
      ""cable_length"": 918.0
    },
    {
      ""endpoint_a_node"": ""O"",
      ""endpoint_b_node"": ""J"",
      ""cable_length"": 1209.0
    },
    {
      ""endpoint_a_node"": ""C"",
      ""endpoint_b_node"": ""D"",
      ""cable_length"": 173401.0
    },
    {
      ""endpoint_a_node"": ""C"",
      ""endpoint_b_node"": ""E"",
      ""cable_length"": 173833.0
    },
    {
      ""endpoint_a_node"": ""N"",
      ""endpoint_b_node"": ""L"",
      ""cable_length"": 917.0
    },
    {
      ""endpoint_a_node"": ""N"",
      ""endpoint_b_node"": ""P"",
      ""cable_length"": 917.0
    },
    {
      ""endpoint_a_node"": ""M"",
      ""endpoint_b_node"": ""A"",
      ""cable_length"": 917.0
    },
    {
      ""endpoint_a_node"": ""M"",
      ""endpoint_b_node"": ""R"",
      ""cable_length"": 3184.0
    },
    {
      ""endpoint_a_node"": ""M"",
      ""endpoint_b_node"": ""P"",
      ""cable_length"": 1834.0
    },
    {
      ""endpoint_a_node"": ""J"",
      ""endpoint_b_node"": ""L"",
      ""cable_length"": 1094.0
    },
    {
      ""endpoint_a_node"": ""J"",
      ""endpoint_b_node"": ""B"",
      ""cable_length"": 1097.0
    },
    {
      ""endpoint_a_node"": ""Q"",
      ""endpoint_b_node"": ""R"",
      ""cable_length"": 1835.0
    },
    {
      ""endpoint_a_node"": ""R"",
      ""endpoint_b_node"": ""K"",
      ""cable_length"": 2313.0
    }
  ],
  ""required_offices"": [
    ""B"",
    ""D"",
    ""H"",
    ""I"",
    ""L"",
    ""M"",
    ""P"",
    ""Q"",
    ""R""
  ]
}

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': 18, 'num_edges': 23, 'edges': [{'u': 6, 'v': 5, 'w': 437.0}, {'u': 6, 'v': 14, 'w': 104.0}, {'u': 6, 'v': 7, 'w': 843.0}, {'u': 7, 'v': 4, 'w': 887.0}, {'u': 7, 'v': 15, 'w': 2234.0}, {'u': 8, 'v': 5, 'w': 482.0}, {'u': 8, 'v': 16, 'w': 104.0}, {'u': 8, 'v': 9, 'w': 387.0}, {'u': 9, 'v': 4, 'w': 486.0}, {'u': 9, 'v': 17, 'w': 2692.0}, {'u': 15, 'v': 17, 'w': 918.0}, {'u': 15, 'v': 10, 'w': 1209.0}, {'u': 3, 'v': 4, 'w': 173401.0}, {'u': 3, 'v': 5, 'w': 173833.0}, {'u': 14, 'v': 12, 'w': 917.0}, {'u': 14, 'v': 16, 'w': 917.0}, {'u': 13, 'v': 1, 'w': 917.0}, {'u': 13, 'v': 18, 'w': 3184.0}, {'u': 13, 'v': 16, 'w': 1834.0}, {'u': 10, 'v': 12, 'w': 1094.0}, {'u': 10, 'v': 2, 'w': 1097.0}, {'u': 17, 'v': 18, 'w': 1835.0}, {'u': 18, 'v': 11, 'w': 2313.0}], 'terminals': [2, 4, 8, 9, 12, 13, 16, 17, 18], 'source_file': 'I002.stp', 'density': 0.1503267973856209, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0040.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0040.png'}","[[8, 16], [8, 9], [4, 9], [15, 17], [10, 15], [12, 14], [14, 16], [13, 16], [10, 12], [2, 10], [17, 18]]",10798.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 23, 'edges': [{'u': 'F', 'v': 'E', 'w': 437.0}, {'u': 'F', 'v': 'N', 'w': 104.0}, {'u': 'F', 'v': 'G', 'w': 843.0}, {'u': 'G', 'v': 'D', 'w': 887.0}, {'u': 'G', 'v': 'O', 'w': 2234.0}, {'u': 'H', 'v': 'E', 'w': 482.0}, {'u': 'H', 'v': 'P', 'w': 104.0}, {'u': 'H', 'v': 'I', 'w': 387.0}, {'u': 'I', 'v': 'D', 'w': 486.0}, {'u': 'I', 'v': 'Q', 'w': 2692.0}, {'u': 'O', 'v': 'Q', 'w': 918.0}, {'u': 'O', 'v': 'J', 'w': 1209.0}, {'u': 'C', 'v': 'D', 'w': 173401.0}, {'u': 'C', 'v': 'E', 'w': 173833.0}, {'u': 'N', 'v': 'L', 'w': 917.0}, {'u': 'N', 'v': 'P', 'w': 917.0}, {'u': 'M', 'v': 'A', 'w': 917.0}, {'u': 'M', 'v': 'R', 'w': 3184.0}, {'u': 'M', 'v': 'P', 'w': 1834.0}, {'u': 'J', 'v': 'L', 'w': 1094.0}, {'u': 'J', 'v': 'B', 'w': 1097.0}, {'u': 'Q', 'v': 'R', 'w': 1835.0}, {'u': 'R', 'v': 'K', 'w': 2313.0}], 'density': 0.1503267973856209, 'source_file': 'I002.stp', 'terminals': ['B', 'D', 'H', 'I', 'L', 'M', 'P', 'Q', 'R']}","[['H', 'P'], ['H', 'I'], ['D', 'I'], ['O', 'Q'], ['J', 'O'], ['L', 'N'], ['N', 'P'], ['M', 'P'], ['J', 'L'], ['B', 'J'], ['Q', 'R']]",41,json,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 20 distinct towers, 26 candidate hops, and the required cell sites are 2 3 4 7 9 11 12 14 15 18.
A candidate microwave hop connects 8 and 3 with activation cost 161446.0.
A candidate microwave hop connects 8 and 2 with activation cost 162713.0.
A candidate microwave hop connects 13 and 4 with activation cost 2299.0.
A candidate microwave hop connects 13 and 9 with activation cost 5894.0.
A candidate microwave hop connects 13 and 0 with activation cost 781.0.
A candidate microwave hop connects 17 and 2 with activation cost 3753.0.
A candidate microwave hop connects 17 and 15 with activation cost 18228.0.
A candidate microwave hop connects 17 and 1 with activation cost 7342.0.
A candidate microwave hop connects 16 and 18 with activation cost 220.0.
A candidate microwave hop connects 16 and 9 with activation cost 4881.0.
A candidate microwave hop connects 16 and 1 with activation cost 5736.0.
A candidate microwave hop connects 5 and 7 with activation cost 1361.0.
A candidate microwave hop connects 5 and 15 with activation cost 7759.0.
A candidate microwave hop connects 6 and 15 with activation cost 4051.0.
A candidate microwave hop connects 6 and 14 with activation cost 3101.0.
A candidate microwave hop connects 6 and 7 with activation cost 2452.0.
A candidate microwave hop connects 7 and 14 with activation cost 3661.0.
A candidate microwave hop connects 19 and 2 with activation cost 1209.0.
A candidate microwave hop connects 19 and 0 with activation cost 4868.0.
A candidate microwave hop connects 19 and 3 with activation cost 2196.0.
A candidate microwave hop connects 12 and 10 with activation cost 822.0.
A candidate microwave hop connects 12 and 0 with activation cost 6234.0.
A candidate microwave hop connects 1 and 4 with activation cost 759.0.
A candidate microwave hop connects 3 and 4 with activation cost 1830.0.
A candidate microwave hop connects 9 and 10 with activation cost 78.0.
A candidate microwave hop connects 10 and 11 with activation cost 547.0.
The engineers will assemble these hops into one connected backbone that includes every 2 3 4 7 9 11 12 14 15 18 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': 20, 'num_edges': 26, 'edges': [{'u': 9, 'v': 4, 'w': 161446.0}, {'u': 9, 'v': 3, 'w': 162713.0}, {'u': 14, 'v': 5, 'w': 2299.0}, {'u': 14, 'v': 10, 'w': 5894.0}, {'u': 14, 'v': 1, 'w': 781.0}, {'u': 18, 'v': 3, 'w': 3753.0}, {'u': 18, 'v': 16, 'w': 18228.0}, {'u': 18, 'v': 2, 'w': 7342.0}, {'u': 17, 'v': 19, 'w': 220.0}, {'u': 17, 'v': 10, 'w': 4881.0}, {'u': 17, 'v': 2, 'w': 5736.0}, {'u': 6, 'v': 8, 'w': 1361.0}, {'u': 6, 'v': 16, 'w': 7759.0}, {'u': 7, 'v': 16, 'w': 4051.0}, {'u': 7, 'v': 15, 'w': 3101.0}, {'u': 7, 'v': 8, 'w': 2452.0}, {'u': 8, 'v': 15, 'w': 3661.0}, {'u': 20, 'v': 3, 'w': 1209.0}, {'u': 20, 'v': 1, 'w': 4868.0}, {'u': 20, 'v': 4, 'w': 2196.0}, {'u': 13, 'v': 11, 'w': 822.0}, {'u': 13, 'v': 1, 'w': 6234.0}, {'u': 2, 'v': 5, 'w': 759.0}, {'u': 4, 'v': 5, 'w': 1830.0}, {'u': 10, 'v': 11, 'w': 78.0}, {'u': 11, 'v': 12, 'w': 547.0}], 'terminals': [3, 4, 5, 8, 10, 12, 13, 15, 16, 19], 'source_file': 'I025.stp', 'density': 0.1368421052631579, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0041.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0041.png'}","[[3, 18], [16, 18], [17, 19], [10, 17], [2, 17], [7, 16], [7, 15], [7, 8], [3, 20], [4, 20], [11, 13], [2, 5], [4, 5], [10, 11], [11, 12]]",49863.0,"{'problem_type': 'STP', 'num_nodes': 20, 'num_edges': 26, 'edges': [{'u': 8, 'v': 3, 'w': 161446.0}, {'u': 8, 'v': 2, 'w': 162713.0}, {'u': 13, 'v': 4, 'w': 2299.0}, {'u': 13, 'v': 9, 'w': 5894.0}, {'u': 13, 'v': 0, 'w': 781.0}, {'u': 17, 'v': 2, 'w': 3753.0}, {'u': 17, 'v': 15, 'w': 18228.0}, {'u': 17, 'v': 1, 'w': 7342.0}, {'u': 16, 'v': 18, 'w': 220.0}, {'u': 16, 'v': 9, 'w': 4881.0}, {'u': 16, 'v': 1, 'w': 5736.0}, {'u': 5, 'v': 7, 'w': 1361.0}, {'u': 5, 'v': 15, 'w': 7759.0}, {'u': 6, 'v': 15, 'w': 4051.0}, {'u': 6, 'v': 14, 'w': 3101.0}, {'u': 6, 'v': 7, 'w': 2452.0}, {'u': 7, 'v': 14, 'w': 3661.0}, {'u': 19, 'v': 2, 'w': 1209.0}, {'u': 19, 'v': 0, 'w': 4868.0}, {'u': 19, 'v': 3, 'w': 2196.0}, {'u': 12, 'v': 10, 'w': 822.0}, {'u': 12, 'v': 0, 'w': 6234.0}, {'u': 1, 'v': 4, 'w': 759.0}, {'u': 3, 'v': 4, 'w': 1830.0}, {'u': 9, 'v': 10, 'w': 78.0}, {'u': 10, 'v': 11, 'w': 547.0}], 'density': 0.1368421052631579, 'source_file': 'I025.stp', 'terminals': [2, 3, 4, 7, 9, 11, 12, 14, 15, 18]}","[[2, 17], [15, 17], [16, 18], [9, 16], [1, 16], [6, 15], [6, 14], [6, 7], [2, 19], [3, 19], [10, 12], [1, 4], [3, 4], [9, 10], [10, 11]]",42,markdown_table,0
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.

{
  ""total_rooms"": 18,
  ""total_corridors"": 21,
  ""edges"": [
    {
      ""endpoint_room_a"": 7,
      ""endpoint_room_b"": 17,
      ""corridor_length"": 6212.0
    },
    {
      ""endpoint_room_a"": 7,
      ""endpoint_room_b"": 8,
      ""corridor_length"": 3296.0
    },
    {
      ""endpoint_room_a"": 7,
      ""endpoint_room_b"": 6,
      ""corridor_length"": 1879.0
    },
    {
      ""endpoint_room_a"": 11,
      ""endpoint_room_b"": 5,
      ""corridor_length"": 659.0
    },
    {
      ""endpoint_room_a"": 11,
      ""endpoint_room_b"": 13,
      ""corridor_length"": 2791.0
    },
    {
      ""endpoint_room_a"": 5,
      ""endpoint_room_b"": 1,
      ""corridor_length"": 5183.0
    },
    {
      ""endpoint_room_a"": 8,
      ""endpoint_room_b"": 15,
      ""corridor_length"": 217.0
    },
    {
      ""endpoint_room_a"": 8,
      ""endpoint_room_b"": 2,
      ""corridor_length"": 3015.0
    },
    {
      ""endpoint_room_a"": 4,
      ""endpoint_room_b"": 16,
      ""corridor_length"": 193.0
    },
    {
      ""endpoint_room_a"": 4,
      ""endpoint_room_b"": 0,
      ""corridor_length"": 2903.0
    },
    {
      ""endpoint_room_a"": 6,
      ""endpoint_room_b"": 13,
      ""corridor_length"": 9714.0
    },
    {
      ""endpoint_room_a"": 6,
      ""endpoint_room_b"": 2,
      ""corridor_length"": 6911.0
    },
    {
      ""endpoint_room_a"": 12,
      ""endpoint_room_b"": 17,
      ""corridor_length"": 7443.0
    },
    {
      ""endpoint_room_a"": 9,
      ""endpoint_room_b"": 3,
      ""corridor_length"": 1339.0
    },
    {
      ""endpoint_room_a"": 9,
      ""endpoint_room_b"": 15,
      ""corridor_length"": 1365.0
    },
    {
      ""endpoint_room_a"": 14,
      ""endpoint_room_b"": 17,
      ""corridor_length"": 16048.0
    },
    {
      ""endpoint_room_a"": 13,
      ""endpoint_room_b"": 17,
      ""corridor_length"": 10867.0
    },
    {
      ""endpoint_room_a"": 0,
      ""endpoint_room_b"": 10,
      ""corridor_length"": 1130.0
    },
    {
      ""endpoint_room_a"": 1,
      ""endpoint_room_b"": 10,
      ""corridor_length"": 14721.0
    },
    {
      ""endpoint_room_a"": 10,
      ""endpoint_room_b"": 15,
      ""corridor_length"": 2476.0
    },
    {
      ""endpoint_room_a"": 15,
      ""endpoint_room_b"": 16,
      ""corridor_length"": 4264.0
    }
  ],
  ""required_exhibit_halls"": [
    2,
    3,
    8
  ]
}

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': 18, 'num_edges': 21, 'edges': [{'u': 8, 'v': 18, 'w': 6212.0}, {'u': 8, 'v': 9, 'w': 3296.0}, {'u': 8, 'v': 7, 'w': 1879.0}, {'u': 12, 'v': 6, 'w': 659.0}, {'u': 12, 'v': 14, 'w': 2791.0}, {'u': 6, 'v': 2, 'w': 5183.0}, {'u': 9, 'v': 16, 'w': 217.0}, {'u': 9, 'v': 3, 'w': 3015.0}, {'u': 5, 'v': 17, 'w': 193.0}, {'u': 5, 'v': 1, 'w': 2903.0}, {'u': 7, 'v': 14, 'w': 9714.0}, {'u': 7, 'v': 3, 'w': 6911.0}, {'u': 13, 'v': 18, 'w': 7443.0}, {'u': 10, 'v': 4, 'w': 1339.0}, {'u': 10, 'v': 16, 'w': 1365.0}, {'u': 15, 'v': 18, 'w': 16048.0}, {'u': 14, 'v': 18, 'w': 10867.0}, {'u': 1, 'v': 11, 'w': 1130.0}, {'u': 2, 'v': 11, 'w': 14721.0}, {'u': 11, 'v': 16, 'w': 2476.0}, {'u': 16, 'v': 17, 'w': 4264.0}], 'terminals': [3, 4, 9], 'source_file': 'I060.stp', 'density': 0.13725490196078433, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0042.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0042.png'}","[[9, 16], [3, 9], [4, 10], [10, 16]]",5936.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 21, 'edges': [{'u': 7, 'v': 17, 'w': 6212.0}, {'u': 7, 'v': 8, 'w': 3296.0}, {'u': 7, 'v': 6, 'w': 1879.0}, {'u': 11, 'v': 5, 'w': 659.0}, {'u': 11, 'v': 13, 'w': 2791.0}, {'u': 5, 'v': 1, 'w': 5183.0}, {'u': 8, 'v': 15, 'w': 217.0}, {'u': 8, 'v': 2, 'w': 3015.0}, {'u': 4, 'v': 16, 'w': 193.0}, {'u': 4, 'v': 0, 'w': 2903.0}, {'u': 6, 'v': 13, 'w': 9714.0}, {'u': 6, 'v': 2, 'w': 6911.0}, {'u': 12, 'v': 17, 'w': 7443.0}, {'u': 9, 'v': 3, 'w': 1339.0}, {'u': 9, 'v': 15, 'w': 1365.0}, {'u': 14, 'v': 17, 'w': 16048.0}, {'u': 13, 'v': 17, 'w': 10867.0}, {'u': 0, 'v': 10, 'w': 1130.0}, {'u': 1, 'v': 10, 'w': 14721.0}, {'u': 10, 'v': 15, 'w': 2476.0}, {'u': 15, 'v': 16, 'w': 4264.0}], 'density': 0.13725490196078433, 'source_file': 'I060.stp', 'terminals': [2, 3, 8]}","[[8, 15], [2, 8], [3, 9], [9, 15]]",43,json,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.

The diagram shows 17 distinct sites, 22 candidate pedestrian connections, and the academic buildings that must be joined: A F G J N Q.
Consider a candidate walkway linking Q and H with length 6562.0.
Consider a candidate walkway linking Q and I with length 6816.0.
Consider a candidate walkway linking N and L with length 1321.0.
Consider a candidate walkway linking N and P with length 534.0.
Consider a candidate walkway linking N and M with length 763.0.
Consider a candidate walkway linking P and O with length 341.0.
Consider a candidate walkway linking O and K with length 867.0.
Consider a candidate walkway linking O and F with length 1403.0.
Consider a candidate walkway linking F and D with length 224.0.
Consider a candidate walkway linking G and M with length 812.0.
Consider a candidate walkway linking G and B with length 783.0.
Consider a candidate walkway linking H and J with length 1307.0.
Consider a candidate walkway linking H and I with length 645.0.
Consider a candidate walkway linking H and B with length 2493.0.
Consider a candidate walkway linking A and I with length 722.0.
Consider a candidate walkway linking A and K with length 1405.0.
Consider a candidate walkway linking J and C with length 545.0.
Consider a candidate walkway linking J and L with length 636.0.
Consider a candidate walkway linking E and B with length 244308.0.
Consider a candidate walkway linking E and C with length 244315.0.
Consider a candidate walkway linking C and M with length 1163.0.
Consider a candidate walkway linking K and L with length 735.0.
Select a subset of the 22 candidate paths that connects all A F G J N Q across the 17 sites while minimizing the summed lengths.

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': 17, 'num_edges': 22, 'edges': [{'u': 17, 'v': 8, 'w': 6562.0}, {'u': 17, 'v': 9, 'w': 6816.0}, {'u': 14, 'v': 12, 'w': 1321.0}, {'u': 14, 'v': 16, 'w': 534.0}, {'u': 14, 'v': 13, 'w': 763.0}, {'u': 16, 'v': 15, 'w': 341.0}, {'u': 15, 'v': 11, 'w': 867.0}, {'u': 15, 'v': 6, 'w': 1403.0}, {'u': 6, 'v': 4, 'w': 224.0}, {'u': 7, 'v': 13, 'w': 812.0}, {'u': 7, 'v': 2, 'w': 783.0}, {'u': 8, 'v': 10, 'w': 1307.0}, {'u': 8, 'v': 9, 'w': 645.0}, {'u': 8, 'v': 2, 'w': 2493.0}, {'u': 1, 'v': 9, 'w': 722.0}, {'u': 1, 'v': 11, 'w': 1405.0}, {'u': 10, 'v': 3, 'w': 545.0}, {'u': 10, 'v': 12, 'w': 636.0}, {'u': 5, 'v': 2, 'w': 244308.0}, {'u': 5, 'v': 3, 'w': 244315.0}, {'u': 3, 'v': 13, 'w': 1163.0}, {'u': 11, 'v': 12, 'w': 735.0}], 'terminals': [1, 6, 7, 10, 14, 17], 'source_file': 'I031.stp', 'density': 0.16176470588235295, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0043.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0043.png'}","[[8, 17], [14, 16], [13, 14], [15, 16], [6, 15], [7, 13], [8, 10], [8, 9], [1, 9], [3, 10], [3, 13]]",14797.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 22, 'edges': [{'u': 'Q', 'v': 'H', 'w': 6562.0}, {'u': 'Q', 'v': 'I', 'w': 6816.0}, {'u': 'N', 'v': 'L', 'w': 1321.0}, {'u': 'N', 'v': 'P', 'w': 534.0}, {'u': 'N', 'v': 'M', 'w': 763.0}, {'u': 'P', 'v': 'O', 'w': 341.0}, {'u': 'O', 'v': 'K', 'w': 867.0}, {'u': 'O', 'v': 'F', 'w': 1403.0}, {'u': 'F', 'v': 'D', 'w': 224.0}, {'u': 'G', 'v': 'M', 'w': 812.0}, {'u': 'G', 'v': 'B', 'w': 783.0}, {'u': 'H', 'v': 'J', 'w': 1307.0}, {'u': 'H', 'v': 'I', 'w': 645.0}, {'u': 'H', 'v': 'B', 'w': 2493.0}, {'u': 'A', 'v': 'I', 'w': 722.0}, {'u': 'A', 'v': 'K', 'w': 1405.0}, {'u': 'J', 'v': 'C', 'w': 545.0}, {'u': 'J', 'v': 'L', 'w': 636.0}, {'u': 'E', 'v': 'B', 'w': 244308.0}, {'u': 'E', 'v': 'C', 'w': 244315.0}, {'u': 'C', 'v': 'M', 'w': 1163.0}, {'u': 'K', 'v': 'L', 'w': 735.0}], 'density': 0.16176470588235295, 'source_file': 'I031.stp', 'terminals': ['A', 'F', 'G', 'J', 'N', 'Q']}","[['H', 'Q'], ['N', 'P'], ['M', 'N'], ['O', 'P'], ['F', 'O'], ['G', 'M'], ['H', 'J'], ['H', 'I'], ['A', 'I'], ['C', 'J'], ['C', 'M']]",44,nl,names
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.

{
  ""total_network_locations"": 18,
  ""total_candidate_links"": 19,
  ""edges"": [
    {
      ""link_endpoint_a"": 15,
      ""link_endpoint_b"": 2,
      ""cable_run_length_or_cost"": 1548.0
    },
    {
      ""link_endpoint_a"": 15,
      ""link_endpoint_b"": 11,
      ""cable_run_length_or_cost"": 5256.0
    },
    {
      ""link_endpoint_a"": 15,
      ""link_endpoint_b"": 12,
      ""cable_run_length_or_cost"": 2278.0
    },
    {
      ""link_endpoint_a"": 6,
      ""link_endpoint_b"": 4,
      ""cable_run_length_or_cost"": 634.0
    },
    {
      ""link_endpoint_a"": 12,
      ""link_endpoint_b"": 3,
      ""cable_run_length_or_cost"": 2349.0
    },
    {
      ""link_endpoint_a"": 12,
      ""link_endpoint_b"": 10,
      ""cable_run_length_or_cost"": 418.0
    },
    {
      ""link_endpoint_a"": 11,
      ""link_endpoint_b"": 1,
      ""cable_run_length_or_cost"": 5024.0
    },
    {
      ""link_endpoint_a"": 0,
      ""link_endpoint_b"": 16,
      ""cable_run_length_or_cost"": 2434.0
    },
    {
      ""link_endpoint_a"": 0,
      ""link_endpoint_b"": 1,
      ""cable_run_length_or_cost"": 5458.0
    },
    {
      ""link_endpoint_a"": 17,
      ""link_endpoint_b"": 5,
      ""cable_run_length_or_cost"": 925.0
    },
    {
      ""link_endpoint_a"": 13,
      ""link_endpoint_b"": 7,
      ""cable_run_length_or_cost"": 363.0
    },
    {
      ""link_endpoint_a"": 13,
      ""link_endpoint_b"": 8,
      ""cable_run_length_or_cost"": 1355.0
    },
    {
      ""link_endpoint_a"": 13,
      ""link_endpoint_b"": 5,
      ""cable_run_length_or_cost"": 1564.0
    },
    {
      ""link_endpoint_a"": 3,
      ""link_endpoint_b"": 14,
      ""cable_run_length_or_cost"": 4242.0
    },
    {
      ""link_endpoint_a"": 9,
      ""link_endpoint_b"": 10,
      ""cable_run_length_or_cost"": 1426.0
    },
    {
      ""link_endpoint_a"": 1,
      ""link_endpoint_b"": 16,
      ""cable_run_length_or_cost"": 4658.0
    },
    {
      ""link_endpoint_a"": 2,
      ""link_endpoint_b"": 7,
      ""cable_run_length_or_cost"": 837.0
    },
    {
      ""link_endpoint_a"": 4,
      ""link_endpoint_b"": 5,
      ""cable_run_length_or_cost"": 845.0
    },
    {
      ""link_endpoint_a"": 4,
      ""link_endpoint_b"": 7,
      ""cable_run_length_or_cost"": 1642.0
    }
  ],
  ""required_parking_clusters"": [
    7,
    8
  ]
}

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': 18, 'num_edges': 19, 'edges': [{'u': 16, 'v': 3, 'w': 1548.0}, {'u': 16, 'v': 12, 'w': 5256.0}, {'u': 16, 'v': 13, 'w': 2278.0}, {'u': 7, 'v': 5, 'w': 634.0}, {'u': 13, 'v': 4, 'w': 2349.0}, {'u': 13, 'v': 11, 'w': 418.0}, {'u': 12, 'v': 2, 'w': 5024.0}, {'u': 1, 'v': 17, 'w': 2434.0}, {'u': 1, 'v': 2, 'w': 5458.0}, {'u': 18, 'v': 6, 'w': 925.0}, {'u': 14, 'v': 8, 'w': 363.0}, {'u': 14, 'v': 9, 'w': 1355.0}, {'u': 14, 'v': 6, 'w': 1564.0}, {'u': 4, 'v': 15, 'w': 4242.0}, {'u': 10, 'v': 11, 'w': 1426.0}, {'u': 2, 'v': 17, 'w': 4658.0}, {'u': 3, 'v': 8, 'w': 837.0}, {'u': 5, 'v': 6, 'w': 845.0}, {'u': 5, 'v': 8, 'w': 1642.0}], 'terminals': [8, 9], 'source_file': 'I080.stp', 'density': 0.12418300653594772, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0044.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0044.png'}","[[8, 14], [9, 14]]",1718.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 19, 'edges': [{'u': 15, 'v': 2, 'w': 1548.0}, {'u': 15, 'v': 11, 'w': 5256.0}, {'u': 15, 'v': 12, 'w': 2278.0}, {'u': 6, 'v': 4, 'w': 634.0}, {'u': 12, 'v': 3, 'w': 2349.0}, {'u': 12, 'v': 10, 'w': 418.0}, {'u': 11, 'v': 1, 'w': 5024.0}, {'u': 0, 'v': 16, 'w': 2434.0}, {'u': 0, 'v': 1, 'w': 5458.0}, {'u': 17, 'v': 5, 'w': 925.0}, {'u': 13, 'v': 7, 'w': 363.0}, {'u': 13, 'v': 8, 'w': 1355.0}, {'u': 13, 'v': 5, 'w': 1564.0}, {'u': 3, 'v': 14, 'w': 4242.0}, {'u': 9, 'v': 10, 'w': 1426.0}, {'u': 1, 'v': 16, 'w': 4658.0}, {'u': 2, 'v': 7, 'w': 837.0}, {'u': 4, 'v': 5, 'w': 845.0}, {'u': 4, 'v': 7, 'w': 1642.0}], 'density': 0.12418300653594772, 'source_file': 'I080.stp', 'terminals': [7, 8]}","[[7, 13], [8, 13]]",45,json,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.

There are 18 nodes, 22 blocked road segments, and the shelters are 3 7 10.
Blocked road between 17 and 16; crews must clear 282.0 meters to reopen it.
Blocked road between 17 and 15; crews must clear 60.0 meters to reopen it.
Blocked road between 17 and 1; crews must clear 1902.0 meters to reopen it.
Blocked road between 11 and 10; crews must clear 1710.0 meters to reopen it.
Blocked road between 11 and 13; crews must clear 303.0 meters to reopen it.
Blocked road between 11 and 2; crews must clear 845.0 meters to reopen it.
Blocked road between 2 and 3; crews must clear 331.0 meters to reopen it.
Blocked road between 2 and 14; crews must clear 294.0 meters to reopen it.
Blocked road between 3 and 15; crews must clear 291.0 meters to reopen it.
Blocked road between 3 and 13; crews must clear 493.0 meters to reopen it.
Blocked road between 4 and 5; crews must clear 149.0 meters to reopen it.
Blocked road between 4 and 14; crews must clear 394.0 meters to reopen it.
Blocked road between 5 and 16; crews must clear 391.0 meters to reopen it.
Blocked road between 5 and 9; crews must clear 1775.0 meters to reopen it.
Blocked road between 0 and 8; crews must clear 771.0 meters to reopen it.
Blocked road between 0 and 9; crews must clear 1619.0 meters to reopen it.
Blocked road between 13 and 12; crews must clear 1437.0 meters to reopen it.
Blocked road between 1 and 9; crews must clear 2576.0 meters to reopen it.
Blocked road between 6 and 8; crews must clear 5812.0 meters to reopen it.
Blocked road between 7 and 8; crews must clear 1950.0 meters to reopen it.
Blocked road between 14 and 15; crews must clear 292.0 meters to reopen it.
Blocked road between 14 and 16; crews must clear 98.0 meters to reopen it.
Evaluate plans by summing reopened distances to connect all 3 7 10 with no redundant segments.

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': 18, 'num_edges': 22, 'edges': [{'u': 18, 'v': 17, 'w': 282.0}, {'u': 18, 'v': 16, 'w': 60.0}, {'u': 18, 'v': 2, 'w': 1902.0}, {'u': 12, 'v': 11, 'w': 1710.0}, {'u': 12, 'v': 14, 'w': 303.0}, {'u': 12, 'v': 3, 'w': 845.0}, {'u': 3, 'v': 4, 'w': 331.0}, {'u': 3, 'v': 15, 'w': 294.0}, {'u': 4, 'v': 16, 'w': 291.0}, {'u': 4, 'v': 14, 'w': 493.0}, {'u': 5, 'v': 6, 'w': 149.0}, {'u': 5, 'v': 15, 'w': 394.0}, {'u': 6, 'v': 17, 'w': 391.0}, {'u': 6, 'v': 10, 'w': 1775.0}, {'u': 1, 'v': 9, 'w': 771.0}, {'u': 1, 'v': 10, 'w': 1619.0}, {'u': 14, 'v': 13, 'w': 1437.0}, {'u': 2, 'v': 10, 'w': 2576.0}, {'u': 7, 'v': 9, 'w': 5812.0}, {'u': 8, 'v': 9, 'w': 1950.0}, {'u': 15, 'v': 16, 'w': 292.0}, {'u': 15, 'v': 17, 'w': 98.0}], 'terminals': [4, 8, 11], 'source_file': 'I032.stp', 'density': 0.1437908496732026, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0045.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0045.png'}","[[17, 18], [16, 18], [11, 12], [12, 14], [4, 16], [4, 14], [6, 17], [6, 10], [1, 9], [1, 10], [8, 9]]",9645.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 22, 'edges': [{'u': 17, 'v': 16, 'w': 282.0}, {'u': 17, 'v': 15, 'w': 60.0}, {'u': 17, 'v': 1, 'w': 1902.0}, {'u': 11, 'v': 10, 'w': 1710.0}, {'u': 11, 'v': 13, 'w': 303.0}, {'u': 11, 'v': 2, 'w': 845.0}, {'u': 2, 'v': 3, 'w': 331.0}, {'u': 2, 'v': 14, 'w': 294.0}, {'u': 3, 'v': 15, 'w': 291.0}, {'u': 3, 'v': 13, 'w': 493.0}, {'u': 4, 'v': 5, 'w': 149.0}, {'u': 4, 'v': 14, 'w': 394.0}, {'u': 5, 'v': 16, 'w': 391.0}, {'u': 5, 'v': 9, 'w': 1775.0}, {'u': 0, 'v': 8, 'w': 771.0}, {'u': 0, 'v': 9, 'w': 1619.0}, {'u': 13, 'v': 12, 'w': 1437.0}, {'u': 1, 'v': 9, 'w': 2576.0}, {'u': 6, 'v': 8, 'w': 5812.0}, {'u': 7, 'v': 8, 'w': 1950.0}, {'u': 14, 'v': 15, 'w': 292.0}, {'u': 14, 'v': 16, 'w': 98.0}], 'density': 0.1437908496732026, 'source_file': 'I032.stp', 'terminals': [3, 7, 10]}","[[16, 17], [15, 17], [10, 11], [11, 13], [3, 15], [3, 13], [5, 16], [5, 9], [0, 8], [0, 9], [7, 8]]",46,markdown_table,0
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.

The map contains 17 stations, 20 candidate tracks, and the required sites are 1 6 7 10 12 15.
A lift or connector links station 8 and station 14 with operational length 1976.0.
A lift or connector links station 8 and station 3 with operational length 1149.0.
A lift or connector links station 9 and station 3 with operational length 3879.0.
A lift or connector links station 9 and station 12 with operational length 646.0.
A lift or connector links station 9 and station 11 with operational length 1888.0.
A lift or connector links station 4 and station 0 with operational length 3385.0.
A lift or connector links station 4 and station 10 with operational length 1400.0.
A lift or connector links station 0 and station 1 with operational length 1052.0.
A lift or connector links station 0 and station 6 with operational length 4682.0.
A lift or connector links station 1 and station 12 with operational length 460.0.
A lift or connector links station 1 and station 7 with operational length 2223.0.
A lift or connector links station 6 and station 5 with operational length 697.0.
A lift or connector links station 7 and station 16 with operational length 3074.0.
A lift or connector links station 12 and station 2 with operational length 6349.0.
A lift or connector links station 2 and station 3 with operational length 3129.0.
A lift or connector links station 15 and station 14 with operational length 2663.0.
A lift or connector links station 15 and station 13 with operational length 1669.0.
A lift or connector links station 15 and station 16 with operational length 6421.0.
A lift or connector links station 16 and station 11 with operational length 745.0.
A lift or connector links station 11 and station 14 with operational length 5104.0.
Someone should pick tracks from the list below to interconnect all 1 6 7 10 12 15 while keeping the total operated length as low as possible.

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': 17, 'num_edges': 20, 'edges': [{'u': 9, 'v': 15, 'w': 1976.0}, {'u': 9, 'v': 4, 'w': 1149.0}, {'u': 10, 'v': 4, 'w': 3879.0}, {'u': 10, 'v': 13, 'w': 646.0}, {'u': 10, 'v': 12, 'w': 1888.0}, {'u': 5, 'v': 1, 'w': 3385.0}, {'u': 5, 'v': 11, 'w': 1400.0}, {'u': 1, 'v': 2, 'w': 1052.0}, {'u': 1, 'v': 7, 'w': 4682.0}, {'u': 2, 'v': 13, 'w': 460.0}, {'u': 2, 'v': 8, 'w': 2223.0}, {'u': 7, 'v': 6, 'w': 697.0}, {'u': 8, 'v': 17, 'w': 3074.0}, {'u': 13, 'v': 3, 'w': 6349.0}, {'u': 3, 'v': 4, 'w': 3129.0}, {'u': 16, 'v': 15, 'w': 2663.0}, {'u': 16, 'v': 14, 'w': 1669.0}, {'u': 16, 'v': 17, 'w': 6421.0}, {'u': 17, 'v': 12, 'w': 745.0}, {'u': 12, 'v': 15, 'w': 5104.0}], 'terminals': [2, 7, 8, 11, 13, 16], 'source_file': 'I027.stp', 'density': 0.14705882352941177, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0046.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0046.png'}","[[1, 5], [5, 11], [1, 2], [1, 7], [2, 13], [2, 8], [8, 17], [16, 17]]",22697.0,"{'problem_type': 'STP', 'num_nodes': 17, 'num_edges': 20, 'edges': [{'u': 8, 'v': 14, 'w': 1976.0}, {'u': 8, 'v': 3, 'w': 1149.0}, {'u': 9, 'v': 3, 'w': 3879.0}, {'u': 9, 'v': 12, 'w': 646.0}, {'u': 9, 'v': 11, 'w': 1888.0}, {'u': 4, 'v': 0, 'w': 3385.0}, {'u': 4, 'v': 10, 'w': 1400.0}, {'u': 0, 'v': 1, 'w': 1052.0}, {'u': 0, 'v': 6, 'w': 4682.0}, {'u': 1, 'v': 12, 'w': 460.0}, {'u': 1, 'v': 7, 'w': 2223.0}, {'u': 6, 'v': 5, 'w': 697.0}, {'u': 7, 'v': 16, 'w': 3074.0}, {'u': 12, 'v': 2, 'w': 6349.0}, {'u': 2, 'v': 3, 'w': 3129.0}, {'u': 15, 'v': 14, 'w': 2663.0}, {'u': 15, 'v': 13, 'w': 1669.0}, {'u': 15, 'v': 16, 'w': 6421.0}, {'u': 16, 'v': 11, 'w': 745.0}, {'u': 11, 'v': 14, 'w': 5104.0}], 'density': 0.14705882352941177, 'source_file': 'I027.stp', 'terminals': [1, 6, 7, 10, 12, 15]}","[[0, 4], [4, 10], [0, 1], [0, 6], [1, 12], [1, 7], [7, 16], [15, 16]]",47,nl,0
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.

We’ve laid out the map: 18 nodes, 20 candidate links, seating areas at 3 4 8 13 16.
Candidate link between 7 and 8: 1967.0 m of hedge/path we can plant.
Candidate link between 7 and 9: 234.0 m of hedge/path we can plant.
Candidate link between 8 and 6: 468.0 m of hedge/path we can plant.
Candidate link between 8 and 17: 4023.0 m of hedge/path we can plant.
Candidate link between 13 and 14: 214.0 m of hedge/path we can plant.
Candidate link between 9 and 1: 1986.0 m of hedge/path we can plant.
Candidate link between 9 and 12: 2196.0 m of hedge/path we can plant.
Candidate link between 2 and 3: 1702.0 m of hedge/path we can plant.
Candidate link between 3 and 17: 4257.0 m of hedge/path we can plant.
Candidate link between 11 and 16: 626.0 m of hedge/path we can plant.
Candidate link between 11 and 18: 1079.0 m of hedge/path we can plant.
Candidate link between 11 and 17: 3651.0 m of hedge/path we can plant.
Candidate link between 1 and 10: 2450.0 m of hedge/path we can plant.
Candidate link between 1 and 17: 2670.0 m of hedge/path we can plant.
Candidate link between 14 and 15: 1857.0 m of hedge/path we can plant.
Candidate link between 14 and 17: 1869.0 m of hedge/path we can plant.
Candidate link between 10 and 18: 1984.0 m of hedge/path we can plant.
Candidate link between 12 and 5: 1075.0 m of hedge/path we can plant.
Candidate link between 6 and 4: 392.0 m of hedge/path we can plant.
Candidate link between 6 and 5: 1284.0 m of hedge/path we can plant.
We’ll pick links so every seating area in 3 4 8 13 16 sits on one continuous planted route and the total planted length is minimized across the 18 nodes and 20 candidates.

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': 18, 'num_edges': 20, 'edges': [{'u': 7, 'v': 8, 'w': 1967.0}, {'u': 7, 'v': 9, 'w': 234.0}, {'u': 8, 'v': 6, 'w': 468.0}, {'u': 8, 'v': 17, 'w': 4023.0}, {'u': 13, 'v': 14, 'w': 214.0}, {'u': 9, 'v': 1, 'w': 1986.0}, {'u': 9, 'v': 12, 'w': 2196.0}, {'u': 2, 'v': 3, 'w': 1702.0}, {'u': 3, 'v': 17, 'w': 4257.0}, {'u': 11, 'v': 16, 'w': 626.0}, {'u': 11, 'v': 18, 'w': 1079.0}, {'u': 11, 'v': 17, 'w': 3651.0}, {'u': 1, 'v': 10, 'w': 2450.0}, {'u': 1, 'v': 17, 'w': 2670.0}, {'u': 14, 'v': 15, 'w': 1857.0}, {'u': 14, 'v': 17, 'w': 1869.0}, {'u': 10, 'v': 18, 'w': 1984.0}, {'u': 12, 'v': 5, 'w': 1075.0}, {'u': 6, 'v': 4, 'w': 392.0}, {'u': 6, 'v': 5, 'w': 1284.0}], 'terminals': [3, 4, 8, 13, 16], 'source_file': 'I035.stp', 'density': 0.13071895424836602, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0047.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0047.png'}","[[6, 8], [8, 17], [13, 14], [3, 17], [11, 16], [11, 17], [14, 17], [4, 6]]",15500.0,"{'problem_type': 'STP', 'num_nodes': 18, 'num_edges': 20, 'edges': [{'u': 7, 'v': 8, 'w': 1967.0}, {'u': 7, 'v': 9, 'w': 234.0}, {'u': 8, 'v': 6, 'w': 468.0}, {'u': 8, 'v': 17, 'w': 4023.0}, {'u': 13, 'v': 14, 'w': 214.0}, {'u': 9, 'v': 1, 'w': 1986.0}, {'u': 9, 'v': 12, 'w': 2196.0}, {'u': 2, 'v': 3, 'w': 1702.0}, {'u': 3, 'v': 17, 'w': 4257.0}, {'u': 11, 'v': 16, 'w': 626.0}, {'u': 11, 'v': 18, 'w': 1079.0}, {'u': 11, 'v': 17, 'w': 3651.0}, {'u': 1, 'v': 10, 'w': 2450.0}, {'u': 1, 'v': 17, 'w': 2670.0}, {'u': 14, 'v': 15, 'w': 1857.0}, {'u': 14, 'v': 17, 'w': 1869.0}, {'u': 10, 'v': 18, 'w': 1984.0}, {'u': 12, 'v': 5, 'w': 1075.0}, {'u': 6, 'v': 4, 'w': 392.0}, {'u': 6, 'v': 5, 'w': 1284.0}], 'density': 0.13071895424836602, 'source_file': 'I035.stp', 'terminals': [3, 4, 8, 13, 16]}","[[6, 8], [8, 17], [13, 14], [3, 17], [11, 16], [11, 17], [14, 17], [4, 6]]",48,markdown_table,1
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 19 locations, 25 available cable segments, and the wireless clusters to span are A C O.
Run a cable from D to E with length 244.0.
Run a cable from D to G with length 254.0.
Run a cable from D to M with length 633.0.
Run a cable from E to I with length 1033.0.
Run a cable from E to C with length 2866.0.
Run a cable from F to G with length 2413.0.
Run a cable from F to Q with length 686.0.
Run a cable from F to C with length 1421.0.
Run a cable from G to Q with length 3041.0.
Run a cable from N to O with length 815.0.
Run a cable from N to P with length 3938.0.
Run a cable from N to S with length 1840.0.
Run a cable from O to S with length 1349.0.
Run a cable from O to Q with length 596.0.
Run a cable from M to J with length 283.0.
Run a cable from M to P with length 215.0.
Run a cable from R to S with length 22855.0.
Run a cable from P to K with length 1490.0.
Run a cable from Q to B with length 270758.0.
Run a cable from B to C with length 270850.0.
Run a cable from H to I with length 5321.0.
Run a cable from H to L with length 9151.0.
Run a cable from I to J with length 648.0.
Run a cable from A to K with length 2076.0.
Run a cable from K to J with length 1077.0.
Keep every wireless cluster in A C O 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': 19, 'num_edges': 25, 'edges': [{'u': 4, 'v': 5, 'w': 244.0}, {'u': 4, 'v': 7, 'w': 254.0}, {'u': 4, 'v': 13, 'w': 633.0}, {'u': 5, 'v': 9, 'w': 1033.0}, {'u': 5, 'v': 3, 'w': 2866.0}, {'u': 6, 'v': 7, 'w': 2413.0}, {'u': 6, 'v': 17, 'w': 686.0}, {'u': 6, 'v': 3, 'w': 1421.0}, {'u': 7, 'v': 17, 'w': 3041.0}, {'u': 14, 'v': 15, 'w': 815.0}, {'u': 14, 'v': 16, 'w': 3938.0}, {'u': 14, 'v': 19, 'w': 1840.0}, {'u': 15, 'v': 19, 'w': 1349.0}, {'u': 15, 'v': 17, 'w': 596.0}, {'u': 13, 'v': 10, 'w': 283.0}, {'u': 13, 'v': 16, 'w': 215.0}, {'u': 18, 'v': 19, 'w': 22855.0}, {'u': 16, 'v': 11, 'w': 1490.0}, {'u': 17, 'v': 2, 'w': 270758.0}, {'u': 2, 'v': 3, 'w': 270850.0}, {'u': 8, 'v': 9, 'w': 5321.0}, {'u': 8, 'v': 12, 'w': 9151.0}, {'u': 9, 'v': 10, 'w': 648.0}, {'u': 1, 'v': 11, 'w': 2076.0}, {'u': 11, 'v': 10, 'w': 1077.0}], 'terminals': [1, 3, 15], 'source_file': 'I084.stp', 'density': 0.14619883040935672, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0048.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0048.png'}","[[4, 7], [4, 13], [6, 7], [6, 17], [3, 6], [15, 17], [10, 13], [1, 11], [10, 11]]",9439.0,"{'problem_type': 'STP', 'num_nodes': 19, 'num_edges': 25, 'edges': [{'u': 'D', 'v': 'E', 'w': 244.0}, {'u': 'D', 'v': 'G', 'w': 254.0}, {'u': 'D', 'v': 'M', 'w': 633.0}, {'u': 'E', 'v': 'I', 'w': 1033.0}, {'u': 'E', 'v': 'C', 'w': 2866.0}, {'u': 'F', 'v': 'G', 'w': 2413.0}, {'u': 'F', 'v': 'Q', 'w': 686.0}, {'u': 'F', 'v': 'C', 'w': 1421.0}, {'u': 'G', 'v': 'Q', 'w': 3041.0}, {'u': 'N', 'v': 'O', 'w': 815.0}, {'u': 'N', 'v': 'P', 'w': 3938.0}, {'u': 'N', 'v': 'S', 'w': 1840.0}, {'u': 'O', 'v': 'S', 'w': 1349.0}, {'u': 'O', 'v': 'Q', 'w': 596.0}, {'u': 'M', 'v': 'J', 'w': 283.0}, {'u': 'M', 'v': 'P', 'w': 215.0}, {'u': 'R', 'v': 'S', 'w': 22855.0}, {'u': 'P', 'v': 'K', 'w': 1490.0}, {'u': 'Q', 'v': 'B', 'w': 270758.0}, {'u': 'B', 'v': 'C', 'w': 270850.0}, {'u': 'H', 'v': 'I', 'w': 5321.0}, {'u': 'H', 'v': 'L', 'w': 9151.0}, {'u': 'I', 'v': 'J', 'w': 648.0}, {'u': 'A', 'v': 'K', 'w': 2076.0}, {'u': 'K', 'v': 'J', 'w': 1077.0}], 'density': 0.14619883040935672, 'source_file': 'I084.stp', 'terminals': ['A', 'C', 'O']}","[['D', 'G'], ['D', 'M'], ['F', 'G'], ['F', 'Q'], ['C', 'F'], ['O', 'Q'], ['J', 'M'], ['A', 'K'], ['J', 'K']]",49,markdown_table,names
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=19
# total_possible_wiring_segments=21
# plaza_posts=0 2 3 4 7 11 13 14 18
endpoint_post_a,endpoint_post_b,wiring_length
1,5,390.0
9,5,211.0
9,12,1077.0
2,3,526.0
2,7,330.0
3,8,330.0
3,15,682.0
16,17,1070.0
4,15,568.0
4,11,1611.0
17,18,302.0
17,15,348.0
5,6,1080.0
6,12,229.0
10,14,1223.0
10,0,1205.0
7,8,513.0
7,13,209.0
8,14,187.0
12,13,571.0
13,14,504.0

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': 19, 'num_edges': 21, 'edges': [{'u': 2, 'v': 6, 'w': 390.0}, {'u': 10, 'v': 6, 'w': 211.0}, {'u': 10, 'v': 13, 'w': 1077.0}, {'u': 3, 'v': 4, 'w': 526.0}, {'u': 3, 'v': 8, 'w': 330.0}, {'u': 4, 'v': 9, 'w': 330.0}, {'u': 4, 'v': 16, 'w': 682.0}, {'u': 17, 'v': 18, 'w': 1070.0}, {'u': 5, 'v': 16, 'w': 568.0}, {'u': 5, 'v': 12, 'w': 1611.0}, {'u': 18, 'v': 19, 'w': 302.0}, {'u': 18, 'v': 16, 'w': 348.0}, {'u': 6, 'v': 7, 'w': 1080.0}, {'u': 7, 'v': 13, 'w': 229.0}, {'u': 11, 'v': 15, 'w': 1223.0}, {'u': 11, 'v': 1, 'w': 1205.0}, {'u': 8, 'v': 9, 'w': 513.0}, {'u': 8, 'v': 14, 'w': 209.0}, {'u': 9, 'v': 15, 'w': 187.0}, {'u': 13, 'v': 14, 'w': 571.0}, {'u': 14, 'v': 15, 'w': 504.0}], 'terminals': [1, 3, 4, 5, 8, 12, 14, 15, 19], 'source_file': 'I046.stp', 'density': 0.12280701754385964, 'viz_instance': 'generated_data/STP/viz/STP_M/instance_0049.png', 'viz_solution': 'generated_data/STP/viz/STP_M/solution_0049.png'}","[[3, 8], [4, 9], [4, 16], [5, 16], [5, 12], [18, 19], [16, 18], [11, 15], [1, 11], [8, 14], [9, 15], [14, 15]]",7499.0,"{'problem_type': 'STP', 'num_nodes': 19, 'num_edges': 21, 'edges': [{'u': 1, 'v': 5, 'w': 390.0}, {'u': 9, 'v': 5, 'w': 211.0}, {'u': 9, 'v': 12, 'w': 1077.0}, {'u': 2, 'v': 3, 'w': 526.0}, {'u': 2, 'v': 7, 'w': 330.0}, {'u': 3, 'v': 8, 'w': 330.0}, {'u': 3, 'v': 15, 'w': 682.0}, {'u': 16, 'v': 17, 'w': 1070.0}, {'u': 4, 'v': 15, 'w': 568.0}, {'u': 4, 'v': 11, 'w': 1611.0}, {'u': 17, 'v': 18, 'w': 302.0}, {'u': 17, 'v': 15, 'w': 348.0}, {'u': 5, 'v': 6, 'w': 1080.0}, {'u': 6, 'v': 12, 'w': 229.0}, {'u': 10, 'v': 14, 'w': 1223.0}, {'u': 10, 'v': 0, 'w': 1205.0}, {'u': 7, 'v': 8, 'w': 513.0}, {'u': 7, 'v': 13, 'w': 209.0}, {'u': 8, 'v': 14, 'w': 187.0}, {'u': 12, 'v': 13, 'w': 571.0}, {'u': 13, 'v': 14, 'w': 504.0}], 'density': 0.12280701754385964, 'source_file': 'I046.stp', 'terminals': [0, 2, 3, 4, 7, 11, 13, 14, 18]}","[[2, 7], [3, 8], [3, 15], [4, 15], [4, 11], [17, 18], [15, 17], [10, 14], [0, 10], [7, 13], [8, 14], [13, 14]]",50,csv,0