SCP/SCP_S_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
SCP,SCP,"In my neighborhood someone is figuring out how to protect a whole house with detectors: the task is to pick which models to place around the house so each room gets at least one detector, and to do that while minimizing how many detector units are used overall. The way to judge any plan is by counting every detector installed across all rooms — the smaller that count, the better. Every room must have coverage, and putting more than one detector in the same room only increases the total and is therefore less desirable. The concrete layout and model options are listed below.

{
  ""total_rooms"": 8,
  ""num_candidate_installations"": 6,
  ""sets"": [
    {
      ""candidate_installation_id"": ""S1"",
      ""rooms_covered"": [
        1,
        2,
        3,
        5,
        6
      ]
    },
    {
      ""candidate_installation_id"": ""S2"",
      ""rooms_covered"": [
        2,
        3,
        7,
        8
      ]
    },
    {
      ""candidate_installation_id"": ""S3"",
      ""rooms_covered"": [
        3,
        4,
        7,
        8
      ]
    },
    {
      ""candidate_installation_id"": ""S4"",
      ""rooms_covered"": [
        3,
        5
      ]
    },
    {
      ""candidate_installation_id"": ""S5"",
      ""rooms_covered"": [
        1,
        2,
        3,
        5,
        6,
        8
      ]
    },
    {
      ""candidate_installation_id"": ""S6"",
      ""rooms_covered"": [
        6,
        7,
        8
      ]
    }
  ]
}

Also, when you send back your plan, just put the chosen detector identifiers into a tiny JSON object so it's easy to read — something like this (this is just the shape, not the actual answer):

{
  ""solution"": [""detector_id"", ...]
}

Think of it like a simple form: ""solution"" is the list of detector models you picked (one entry for each model you want installed). The placeholder detector_id stands in for whatever exact IDs the instance uses; replace those placeholders with the real IDs from the problem when you answer.

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

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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 6, 'density': 0.5, 'sets': [{'id': 1, 'elements': [1, 2, 3, 5, 6]}, {'id': 2, 'elements': [2, 3, 7, 8]}, {'id': 3, 'elements': [3, 4, 7, 8]}, {'id': 4, 'elements': [3, 5]}, {'id': 5, 'elements': [1, 2, 3, 5, 6, 8]}, {'id': 6, 'elements': [6, 7, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 3, 'v': 6}, {'u': 3, 'v': 8}, {'u': 6, 'v': 2}, {'u': 6, 'v': 5}, {'u': 2, 'v': 1}, {'u': 8, 'v': 4}, {'u': 8, 'v': 7}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0000.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0000.png'}","[1, 3]",2.0,"{'num_elements': 8, 'num_sets': 6, 'sets': [{'id': 'S1', 'elements': [1, 2, 3, 5, 6]}, {'id': 'S2', 'elements': [2, 3, 7, 8]}, {'id': 'S3', 'elements': [3, 4, 7, 8]}, {'id': 'S4', 'elements': [3, 5]}, {'id': 'S5', 'elements': [1, 2, 3, 5, 6, 8]}, {'id': 'S6', 'elements': [6, 7, 8]}]}","['S1', 'S3']",1,json,1
SCP,SCP,"On a tight schedule, the event planner needs to assemble a compact roster that still includes every musical genre on the program. The task is to choose which performers to invite; better choices are those with fewer artists, because the effectiveness is just the number of invites (smaller is better), while making sure every genre appears at least once. No genre may be omitted, and duplicate invites don’t increase genre coverage. The specific options are given below.

# total_genres=8
# total_performer_options=6
performer_id,genres_covered
S1,B C F
S2,A B F G H
S3,C E F
S4,A C D E F G
S5,A B C D E H
S6,A H

Also, when you hand me the final picks, please follow this simple JSON layout so it's easy to parse:

{
  ""solution"": [""performer_id"", ...]
}

This just means ""solution"" is a list (an array) of the performer IDs you decide to invite. The string ""performer_id"" is a placeholder showing where each real ID goes — swap those placeholders for the actual IDs from the instance. It's just a sketch of the shape I expect, not the final answer itself.

Please be 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 6, 'density': 0.5208333333333334, 'sets': [{'id': 1, 'elements': [2, 3, 6]}, {'id': 2, 'elements': [1, 2, 6, 7, 8]}, {'id': 3, 'elements': [3, 5, 6]}, {'id': 4, 'elements': [1, 3, 4, 5, 6, 7]}, {'id': 5, 'elements': [1, 2, 3, 4, 5, 8]}, {'id': 6, 'elements': [1, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 8}, {'u': 8, 'v': 4}, {'u': 8, 'v': 5}, {'u': 3, 'v': 1}, {'u': 1, 'v': 5}, {'u': 1, 'v': 7}, {'u': 2, 'v': 7}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0001.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0001.png'}","[4, 5]",2.0,"{'num_elements': 8, 'num_sets': 6, 'sets': [{'id': 'S1', 'elements': ['B', 'C', 'F']}, {'id': 'S2', 'elements': ['A', 'B', 'F', 'G', 'H']}, {'id': 'S3', 'elements': ['C', 'E', 'F']}, {'id': 'S4', 'elements': ['A', 'C', 'D', 'E', 'F', 'G']}, {'id': 'S5', 'elements': ['A', 'B', 'C', 'D', 'E', 'H']}, {'id': 'S6', 'elements': ['A', 'H']}]}","['S4', 'S5']",2,csv,names
SCP,SCP,"Recently the district asked the library to make sure every curriculum topic is represented on the shelves, so the librarian is choosing which titles to buy. The trick is to pick books that together touch every topic, and the smarter plan is the one that does that while keeping the purchase count as low as possible — tally the number of titles to compare options. Every topic must have at least one book, and extra copies that don’t introduce new topics are unnecessary. The concrete instance details are given below.

Instance details: there are 10 total curriculum topics and 10 total available titles.
Title S1 covers topics 1 9.
Title S2 covers topics 2 4 6 7 10.
Title S3 covers topics 3 5 8.
Title S4 covers topics 4 10.
Title S5 covers topics 3 5 8 10.
Title S6 covers topics 2 4 6 10.
Title S7 covers topics 2 7.
Title S8 covers topics 2 3 5 8 9 10.
Title S9 covers topics 1 3 5 8 9 10.
Title S10 covers topics 2 3 4 5 6 7 8 9 10.
The librarian must pick titles that together cover all 10 topics while minimizing the number chosen from the 10 available.

If you want to hand me the chosen titles, just drop them in a tiny JSON blob like this so I know what to expect:

{
  ""solution"": [""book_id"", ...]
}

Here ""solution"" is just the list of book IDs the librarian would buy to cover all the curriculum topics — each entry is the ID of a title from the instance. It's a casual sketch of the shape I expect, not the actual 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 10, 'density': 0.43, 'sets': [{'id': 1, 'elements': [1, 9]}, {'id': 2, 'elements': [2, 4, 6, 7, 10]}, {'id': 3, 'elements': [3, 5, 8]}, {'id': 4, 'elements': [4, 10]}, {'id': 5, 'elements': [3, 5, 8, 10]}, {'id': 6, 'elements': [2, 4, 6, 10]}, {'id': 7, 'elements': [2, 7]}, {'id': 8, 'elements': [2, 3, 5, 8, 9, 10]}, {'id': 9, 'elements': [1, 3, 5, 8, 9, 10]}, {'id': 10, 'elements': [2, 3, 4, 5, 6, 7, 8, 9, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 7, 'v': 10}, {'u': 2, 'v': 4}, {'u': 2, 'v': 6}, {'u': 2, 'v': 10}, {'u': 5, 'v': 8}, {'u': 9, 'v': 1}, {'u': 9, 'v': 8}, {'u': 3, 'v': 8}, {'u': 8, 'v': 10}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0002.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0002.png'}","[9, 10]",2.0,"{'num_elements': 10, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [1, 9]}, {'id': 'S2', 'elements': [2, 4, 6, 7, 10]}, {'id': 'S3', 'elements': [3, 5, 8]}, {'id': 'S4', 'elements': [4, 10]}, {'id': 'S5', 'elements': [3, 5, 8, 10]}, {'id': 'S6', 'elements': [2, 4, 6, 10]}, {'id': 'S7', 'elements': [2, 7]}, {'id': 'S8', 'elements': [2, 3, 5, 8, 9, 10]}, {'id': 'S9', 'elements': [1, 3, 5, 8, 9, 10]}, {'id': 'S10', 'elements': [2, 3, 4, 5, 6, 7, 8, 9, 10]}]}","['S9', 'S10']",3,nl,1
SCP,SCP,"Picture this: an IT manager at a dashboard, checking boxes to enable modules, needing to make sure every required feature lights up but trying to check as few boxes as possible. The work is picking which boxes to check — because each box (module) turns on a set of features — and a smarter pick is one that leaves no required feature dark while keeping the number of checked boxes to a minimum. The way to evaluate any selection is simple: count the checked boxes, and don’t let any required feature be left out; checking extra boxes that only duplicate features just raises the total for no reason. The specific modules and features are listed below.

- **total_required_features**: 9
- **total_available_modules**: 8

| module_id | features_enabled |
|---|---|
| S1 | C E F G H |
| S2 | B D E |
| S3 | B D G |
| S4 | A E G H |
| S5 | A F |
| S6 | A B E G I |
| S7 | E F |
| S8 | A E G I |

Oh, and when you send the selection back, a tiny JSON snippet like this is perfect — just list the module ids you picked:

{
  ""solution"": [""module_id"", ...]
}

The ""solution"" array is where you put the ids of the boxes/modules you checked — one identifier per selected module. Think of it as filling out a short checklist: each entry is the exact label for a module from the instance.

This JSON is just a sketch of the shape I expect, not the actual answer itself — use it as a form to fill in.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 8, 'density': 0.3888888888888889, 'sets': [{'id': 1, 'elements': [3, 5, 6, 7, 8]}, {'id': 2, 'elements': [2, 4, 5]}, {'id': 3, 'elements': [2, 4, 7]}, {'id': 4, 'elements': [1, 5, 7, 8]}, {'id': 5, 'elements': [1, 6]}, {'id': 6, 'elements': [1, 2, 5, 7, 9]}, {'id': 7, 'elements': [5, 6]}, {'id': 8, 'elements': [1, 5, 7, 9]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 9, 'v': 5}, {'u': 8, 'v': 1}, {'u': 8, 'v': 3}, {'u': 8, 'v': 6}, {'u': 3, 'v': 6}, {'u': 7, 'v': 2}, {'u': 7, 'v': 5}, {'u': 5, 'v': 1}, {'u': 4, 'v': 2}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0003.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0003.png'}","[1, 3, 8]",3.0,"{'num_elements': 9, 'num_sets': 8, 'sets': [{'id': 'S1', 'elements': ['C', 'E', 'F', 'G', 'H']}, {'id': 'S2', 'elements': ['B', 'D', 'E']}, {'id': 'S3', 'elements': ['B', 'D', 'G']}, {'id': 'S4', 'elements': ['A', 'E', 'G', 'H']}, {'id': 'S5', 'elements': ['A', 'F']}, {'id': 'S6', 'elements': ['A', 'B', 'E', 'G', 'I']}, {'id': 'S7', 'elements': ['E', 'F']}, {'id': 'S8', 'elements': ['A', 'E', 'G', 'I']}]}","['S1', 'S3', 'S8']",4,markdown_table,names
SCP,SCP,"We heard about a teacher trying to assemble a tiny team of group leaders so all the course topics are handled during project week. The choice comes down to selecting leaders whose combined topic lists include every subject at least once; the better choice is the one that uses the fewest leaders overall, which you can check by simply counting the selected leaders. Every topic must appear under at least one chosen leader, and overlapping topic coverage is fine but doesn’t reduce the headcount. The exact setup appears below.

There are 9 distinct topics and 8 candidate leaders listed below:
Leader S1 handles E H.
Leader S2 handles B E F G.
Leader S3 handles B C D F G.
Leader S4 handles C D G I.
Leader S5 handles A B E F H.
Leader S6 handles B C E F H.
Leader S7 handles B C G I.
Leader S8 handles A E.
We will select as few leaders as possible to cover all 9 topics.

Also, if you could put the final choice into a tiny JSON snippet so I can parse it easily, that would be great — something like this:

{
  ""solution"": [""leader_id"", ...]
}

Here ""solution"" should be a list of the chosen leader identifiers (one per selected leader). Think of each identifier as the little label on a leader’s name tag — that list is just the roster of people you picked. This JSON is only a sketch of the shape I expect, not your actual answer.

Please use the exact identifiers from the instance input — don’t rename them or invent new labels.  
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 8, 'density': 0.4305555555555556, 'sets': [{'id': 1, 'elements': [5, 8]}, {'id': 2, 'elements': [2, 5, 6, 7]}, {'id': 3, 'elements': [2, 3, 4, 6, 7]}, {'id': 4, 'elements': [3, 4, 7, 9]}, {'id': 5, 'elements': [1, 2, 5, 6, 8]}, {'id': 6, 'elements': [2, 3, 5, 6, 8]}, {'id': 7, 'elements': [2, 3, 7, 9]}, {'id': 8, 'elements': [1, 5]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 5, 'v': 6}, {'u': 5, 'v': 8}, {'u': 6, 'v': 2}, {'u': 4, 'v': 7}, {'u': 7, 'v': 3}, {'u': 7, 'v': 9}, {'u': 1, 'v': 8}, {'u': 2, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0004.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0004.png'}","[4, 5]",2.0,"{'num_elements': 9, 'num_sets': 8, 'sets': [{'id': 'S1', 'elements': ['E', 'H']}, {'id': 'S2', 'elements': ['B', 'E', 'F', 'G']}, {'id': 'S3', 'elements': ['B', 'C', 'D', 'F', 'G']}, {'id': 'S4', 'elements': ['C', 'D', 'G', 'I']}, {'id': 'S5', 'elements': ['A', 'B', 'E', 'F', 'H']}, {'id': 'S6', 'elements': ['B', 'C', 'E', 'F', 'H']}, {'id': 'S7', 'elements': ['B', 'C', 'G', 'I']}, {'id': 'S8', 'elements': ['A', 'E']}]}","['S4', 'S5']",5,nl,names
SCP,SCP,"Back at the agency, the task was to choose a handful of communication channels that collectively reach all the client’s target segments. The situation: there’s a list of channels and each one connects with certain segments; the decision is which specific channels to use so the whole audience is reached. A better plan is simply the one that achieves full coverage using as few channels as possible — evaluate by counting selected channels, lower is better — and ensure nobody is left out and don’t include channels that only duplicate reach. The concrete channel-by-group details follow below.

There were 7 channels available and 8 target segments to reach.
Channel S1 reached segments 0 2 6.
Channel S2 reached segments 0 1 2 3 4 6 7.
Channel S3 reached segments 1 2 3 5 6 7.
Channel S4 reached segments 1 2 3 5 6.
Channel S5 reached segments 1 2 7.
Channel S6 reached segments 0 1 2 3 5 6 7.
Channel S7 reached segments 4 7.
The objective was to cover all 8 segments using as few channels as possible.

Quick note on how to return the result so it’s easy to read and machine-friendly — just use this simple JSON shape:

{
  ""solution"": [""channel_id"", ...]
}

""solution"" is the list of channels you’re choosing to cover everybody. Each ""channel_id"" is just a placeholder showing where an actual channel identifier goes — swap it for the exact id from the instance. The array should list the chosen channel ids (one per entry).

This is just a sketch of the expected shape, not the final answer itself — please fill in the real identifiers.

Please use the identifiers exactly as they appear in the instance input — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.5892857142857143, 'sets': [{'id': 1, 'elements': [1, 3, 7]}, {'id': 2, 'elements': [1, 2, 3, 4, 5, 7, 8]}, {'id': 3, 'elements': [2, 3, 4, 6, 7, 8]}, {'id': 4, 'elements': [2, 3, 4, 6, 7]}, {'id': 5, 'elements': [2, 3, 8]}, {'id': 6, 'elements': [1, 2, 3, 4, 6, 7, 8]}, {'id': 7, 'elements': [5, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 8, 'v': 1}, {'u': 8, 'v': 3}, {'u': 6, 'v': 2}, {'u': 3, 'v': 2}, {'u': 3, 'v': 5}, {'u': 4, 'v': 2}, {'u': 2, 'v': 7}, {'u': 7, 'v': 1}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0005.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0005.png'}","[2, 6]",2.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': [0, 2, 6]}, {'id': 'S2', 'elements': [0, 1, 2, 3, 4, 6, 7]}, {'id': 'S3', 'elements': [1, 2, 3, 5, 6, 7]}, {'id': 'S4', 'elements': [1, 2, 3, 5, 6]}, {'id': 'S5', 'elements': [1, 2, 7]}, {'id': 'S6', 'elements': [0, 1, 2, 3, 5, 6, 7]}, {'id': 'S7', 'elements': [4, 7]}]}","['S2', 'S6']",6,nl,0
SCP,SCP,"Back when packing for a long journey, the goal was to sort through a jumble of chargers and pick only what’s needed so every gadget could be powered. The choice is which chargers to bring so each device type has a way to charge; a smarter choice is the one with the fewest chargers that still covers all the devices — the straightforward way to tell is to count how many chargers are in the bag and confirm every device type is included. No device type can be left without a charger, and bringing multiple identical chargers is wasteful unless it’s necessary. The exact details of the devices and available chargers will be shown below.

There are 12 distinct device types to cover and 11 charger options listed below.
Charger S1 covers 0 2 5 6 7 8 10 11.
Charger S2 covers 1 4 11.
Charger S3 covers 3 6 9 11.
Charger S4 covers 0 2 6 9 10 11.
Charger S5 covers 1 4 7 11.
Charger S6 covers 0 5 9.
Charger S7 covers 0 2 6.
Charger S8 covers 8 10.
Charger S9 covers 0 2 7 9 10 11.
Charger S10 covers 0 3 9 10 11.
Charger S11 covers 1 2 3 4 7 10 11.
Choose the fewest chargers that still cover all 12 device types.

Oh, and one more thing — when you send the answer back, keep it in a little JSON shape so it's easy to read by whatever's checking the packing list. Something like this:

{
  ""solution"": [""charger_id"", ...]
}

Here ""solution"" is just the list of charger identifiers you chose to bring — think of each entry as the label stuck to a charger in the inventory. This block is only a sketch of the shape I want, not the actual packing list.

Please 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”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 11, 'density': 0.38636363636363635, 'sets': [{'id': 1, 'elements': [1, 3, 6, 7, 8, 9, 11, 12]}, {'id': 2, 'elements': [2, 5, 12]}, {'id': 3, 'elements': [4, 7, 10, 12]}, {'id': 4, 'elements': [1, 3, 7, 10, 11, 12]}, {'id': 5, 'elements': [2, 5, 8, 12]}, {'id': 6, 'elements': [1, 6, 10]}, {'id': 7, 'elements': [1, 3, 7]}, {'id': 8, 'elements': [9, 11]}, {'id': 9, 'elements': [1, 3, 8, 10, 11, 12]}, {'id': 10, 'elements': [1, 4, 10, 11, 12]}, {'id': 11, 'elements': [2, 3, 4, 5, 8, 11, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 4, 'v': 1}, {'u': 4, 'v': 3}, {'u': 4, 'v': 7}, {'u': 6, 'v': 10}, {'u': 2, 'v': 5}, {'u': 2, 'v': 8}, {'u': 5, 'v': 8}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 8, 'v': 12}, {'u': 11, 'v': 9}, {'u': 3, 'v': 7}, {'u': 3, 'v': 12}, {'u': 12, 'v': 10}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0006.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0006.png'}","[1, 10, 11]",3.0,"{'num_elements': 12, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [0, 2, 5, 6, 7, 8, 10, 11]}, {'id': 'S2', 'elements': [1, 4, 11]}, {'id': 'S3', 'elements': [3, 6, 9, 11]}, {'id': 'S4', 'elements': [0, 2, 6, 9, 10, 11]}, {'id': 'S5', 'elements': [1, 4, 7, 11]}, {'id': 'S6', 'elements': [0, 5, 9]}, {'id': 'S7', 'elements': [0, 2, 6]}, {'id': 'S8', 'elements': [8, 10]}, {'id': 'S9', 'elements': [0, 2, 7, 9, 10, 11]}, {'id': 'S10', 'elements': [0, 3, 9, 10, 11]}, {'id': 'S11', 'elements': [1, 2, 3, 4, 7, 10, 11]}]}","['S1', 'S10', 'S11']",7,nl,0
SCP,SCP,"Someone at the community fair is matching volunteers to shifts and needs to be efficient about it. They want the leanest possible team that still covers every role — success is measured by how many volunteers end up on the roster, so fewer equals better. No job can be left without coverage, and doubling up on roles without reason is avoided wherever possible. The concrete list of roles and who can fill them appears below.

There are 8 distinct roles to cover and 8 available volunteers; they should pick the smallest roster that still covers every role.
Volunteer S1 can cover 2 3 4 5 7.
Volunteer S2 can cover 1 4 5 6.
Volunteer S3 can cover 0 3 5 7.
Volunteer S4 can cover 0 2 4.
Volunteer S5 can cover 1 2 3 4 5 7.
Volunteer S6 can cover 0 1 4.
Volunteer S7 can cover 1 6.
Volunteer S8 can cover 0 7.
They'll aim to assemble the leanest possible team from those 8 volunteers to cover all 8 roles.

Oh, and to keep things tidy, please show the chosen roster in a tiny JSON snippet like the one below — just the shape, nothing else:

{
  ""solution"": [""volunteer_id"", ...]
}

Here ""solution"" is the list of volunteer IDs you plan to put on the roster — one ID per slot in the array. Think of it like filling out a short form: the array holds the exact labels of the volunteers who cover every role. This is just a sketch of the shape I expect, not your final answer.

Please use the identifiers exactly as they appear in the problem input — do not rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 8, 'density': 0.453125, 'sets': [{'id': 1, 'elements': [3, 4, 5, 6, 8]}, {'id': 2, 'elements': [2, 5, 6, 7]}, {'id': 3, 'elements': [1, 4, 6, 8]}, {'id': 4, 'elements': [1, 3, 5]}, {'id': 5, 'elements': [2, 3, 4, 5, 6, 8]}, {'id': 6, 'elements': [1, 2, 5]}, {'id': 7, 'elements': [2, 7]}, {'id': 8, 'elements': [1, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 5, 'v': 1}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 8}, {'u': 4, 'v': 1}, {'u': 4, 'v': 3}, {'u': 7, 'v': 2}, {'u': 6, 'v': 2}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0007.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0007.png'}","[2, 4, 5]",3.0,"{'num_elements': 8, 'num_sets': 8, 'sets': [{'id': 'S1', 'elements': [2, 3, 4, 5, 7]}, {'id': 'S2', 'elements': [1, 4, 5, 6]}, {'id': 'S3', 'elements': [0, 3, 5, 7]}, {'id': 'S4', 'elements': [0, 2, 4]}, {'id': 'S5', 'elements': [1, 2, 3, 4, 5, 7]}, {'id': 'S6', 'elements': [0, 1, 4]}, {'id': 'S7', 'elements': [1, 6]}, {'id': 'S8', 'elements': [0, 7]}]}","['S2', 'S4', 'S5']",8,nl,0
SCP,SCP,"There’s a catering challenge: make a tight, easy-to-read special menu that satisfies every guest’s diet. The task is picking a few dishes so each dietary preference shows up on the menu at least once, and to do that using as few dishes as possible. To tell if one menu beats another, count how many dishes it has — the smaller the number that still covers everyone, the better. No preference can be left out, and piling on dishes that don’t expand coverage is unnecessary. The specific guest preferences and available dishes are detailed below.

# num_preferences=12
# num_dishes_available=12
dish_id,preferences_covered
S1,A E G I J K
S2,B I L
S3,C J
S4,H I K
S5,A B E I
S6,D I K
S7,A C
S8,D K
S9,A B D E F G
S10,A C G J
S11,D F I
S12,B E

Oh, and when you send your final menu, just drop the chosen dishes into this simple JSON shape so whoever’s reading it can parse it quickly:

{
  ""solution"": [""dish_id"", ...]
}

Think of ""solution"" as the list of dishes you picked for the special menu, and ""dish_id"" is just a placeholder showing where each real dish identifier goes. This is just the shape I want — not the actual answer itself — so replace the placeholders with the exact dish IDs from the instance.

Please make sure to use the identifiers exactly as they appear in the 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"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 12, 'density': 0.2777777777777778, 'sets': [{'id': 1, 'elements': [1, 5, 7, 9, 10, 11]}, {'id': 2, 'elements': [2, 9, 12]}, {'id': 3, 'elements': [3, 10]}, {'id': 4, 'elements': [8, 9, 11]}, {'id': 5, 'elements': [1, 2, 5, 9]}, {'id': 6, 'elements': [4, 9, 11]}, {'id': 7, 'elements': [1, 3]}, {'id': 8, 'elements': [4, 11]}, {'id': 9, 'elements': [1, 2, 4, 5, 6, 7]}, {'id': 10, 'elements': [1, 3, 7, 10]}, {'id': 11, 'elements': [4, 6, 9]}, {'id': 12, 'elements': [2, 5]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 8, 'v': 4}, {'u': 12, 'v': 2}, {'u': 4, 'v': 11}, {'u': 6, 'v': 11}, {'u': 9, 'v': 1}, {'u': 9, 'v': 5}, {'u': 9, 'v': 11}, {'u': 2, 'v': 5}, {'u': 7, 'v': 1}, {'u': 7, 'v': 10}, {'u': 10, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0008.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0008.png'}","[2, 4, 9, 10]",4.0,"{'num_elements': 12, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': ['A', 'E', 'G', 'I', 'J', 'K']}, {'id': 'S2', 'elements': ['B', 'I', 'L']}, {'id': 'S3', 'elements': ['C', 'J']}, {'id': 'S4', 'elements': ['H', 'I', 'K']}, {'id': 'S5', 'elements': ['A', 'B', 'E', 'I']}, {'id': 'S6', 'elements': ['D', 'I', 'K']}, {'id': 'S7', 'elements': ['A', 'C']}, {'id': 'S8', 'elements': ['D', 'K']}, {'id': 'S9', 'elements': ['A', 'B', 'D', 'E', 'F', 'G']}, {'id': 'S10', 'elements': ['A', 'C', 'G', 'J']}, {'id': 'S11', 'elements': ['D', 'F', 'I']}, {'id': 'S12', 'elements': ['B', 'E']}]}","['S2', 'S4', 'S9', 'S10']",9,csv,names
SCP,SCP,"A curator needs to assemble a short festival schedule that still represents every theme on the list; some movies touch several themes, so the aim is to select films that together cover all categories with the least number of screenings. The way to compare options is to count how many showings are on the schedule — lower counts win — and the rules are clear: every theme must be included at least once and avoid repeating screenings without purpose. The specific options and their theme coverage are shown below.

{
  ""num_themes"": 11,
  ""num_films_available"": 10,
  ""sets"": [
    {
      ""film_id"": ""S1"",
      ""themes_covered"": [
        0,
        1,
        2,
        5
      ]
    },
    {
      ""film_id"": ""S2"",
      ""themes_covered"": [
        0,
        6,
        10
      ]
    },
    {
      ""film_id"": ""S3"",
      ""themes_covered"": [
        0,
        1,
        2,
        3,
        4,
        5,
        6
      ]
    },
    {
      ""film_id"": ""S4"",
      ""themes_covered"": [
        2,
        3,
        5,
        6,
        8
      ]
    },
    {
      ""film_id"": ""S5"",
      ""themes_covered"": [
        0,
        2,
        8,
        10
      ]
    },
    {
      ""film_id"": ""S6"",
      ""themes_covered"": [
        1,
        2,
        5,
        7,
        9
      ]
    },
    {
      ""film_id"": ""S7"",
      ""themes_covered"": [
        6,
        9
      ]
    },
    {
      ""film_id"": ""S8"",
      ""themes_covered"": [
        3,
        5,
        7,
        8,
        9
      ]
    },
    {
      ""film_id"": ""S9"",
      ""themes_covered"": [
        5,
        6,
        8,
        9,
        10
      ]
    },
    {
      ""film_id"": ""S10"",
      ""themes_covered"": [
        1,
        5,
        6,
        9
      ]
    }
  ]
}

If you want to hand this back in a tidy, machine-friendly way, a tiny JSON object with the chosen film identifiers is perfect. Here’s the shape I expect:

{
  ""solution"": [""film_id"", ...]
}

""solution"" is the list of films you pick for the schedule, and each entry in that array should be a film identifier (the ""film_id"" text above is just a placeholder). Think of this like filling out a short form: put the exact IDs of the movies you’re scheduling into that array. This JSON is just a sketch of the shape I want, not the actual answer.

Please use the identifiers exactly as they appear in the instance input — don’t rename them or make up 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 11, 'num_sets': 10, 'density': 0.4, 'sets': [{'id': 1, 'elements': [1, 2, 3, 6]}, {'id': 2, 'elements': [1, 7, 11]}, {'id': 3, 'elements': [1, 2, 3, 4, 5, 6, 7]}, {'id': 4, 'elements': [3, 4, 6, 7, 9]}, {'id': 5, 'elements': [1, 3, 9, 11]}, {'id': 6, 'elements': [2, 3, 6, 8, 10]}, {'id': 7, 'elements': [7, 10]}, {'id': 8, 'elements': [4, 6, 8, 9, 10]}, {'id': 9, 'elements': [6, 7, 9, 10, 11]}, {'id': 10, 'elements': [2, 6, 7, 10]}], 'graph': {'num_nodes': 11, 'edges': [{'u': 11, 'v': 1}, {'u': 11, 'v': 6}, {'u': 6, 'v': 7}, {'u': 6, 'v': 10}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 8, 'v': 4}, {'u': 8, 'v': 9}, {'u': 9, 'v': 10}, {'u': 1, 'v': 2}, {'u': 2, 'v': 3}, {'u': 2, 'v': 5}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0009.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0009.png'}","[3, 8, 9]",3.0,"{'num_elements': 11, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [0, 1, 2, 5]}, {'id': 'S2', 'elements': [0, 6, 10]}, {'id': 'S3', 'elements': [0, 1, 2, 3, 4, 5, 6]}, {'id': 'S4', 'elements': [2, 3, 5, 6, 8]}, {'id': 'S5', 'elements': [0, 2, 8, 10]}, {'id': 'S6', 'elements': [1, 2, 5, 7, 9]}, {'id': 'S7', 'elements': [6, 9]}, {'id': 'S8', 'elements': [3, 5, 7, 8, 9]}, {'id': 'S9', 'elements': [5, 6, 8, 9, 10]}, {'id': 'S10', 'elements': [1, 5, 6, 9]}]}","['S3', 'S8', 'S9']",10,json,0
SCP,SCP,"There’s a dispatch puzzle: choose a few key curbside spots so that every block with customers is covered, and do it with as few stops as possible. The question is which spots to choose so their coverage covers every block; you judge any plan by counting how many stops it uses — fewer is better. No customer block can be skipped, and making extra stops that only repeat coverage is wasteful and counted against the plan. The concrete instance — the blocks and possible stops — is shown below.

{
  ""total_customer_blocks"": 8,
  ""available_stops_count"": 7,
  ""sets"": [
    {
      ""stop_id"": ""S1"",
      ""covered_blocks"": [
        ""B"",
        ""F""
      ]
    },
    {
      ""stop_id"": ""S2"",
      ""covered_blocks"": [
        ""A"",
        ""B"",
        ""C"",
        ""F"",
        ""G"",
        ""H""
      ]
    },
    {
      ""stop_id"": ""S3"",
      ""covered_blocks"": [
        ""B"",
        ""C"",
        ""E""
      ]
    },
    {
      ""stop_id"": ""S4"",
      ""covered_blocks"": [
        ""C"",
        ""E""
      ]
    },
    {
      ""stop_id"": ""S5"",
      ""covered_blocks"": [
        ""B"",
        ""C"",
        ""D"",
        ""G"",
        ""H""
      ]
    },
    {
      ""stop_id"": ""S6"",
      ""covered_blocks"": [
        ""D"",
        ""F"",
        ""G"",
        ""H""
      ]
    },
    {
      ""stop_id"": ""S7"",
      ""covered_blocks"": [
        ""G"",
        ""H""
      ]
    }
  ]
}

If you want to send the selected curb stops back, just drop them into this tiny JSON shape so it's easy to read by hand or by a script:

{
  ""solution"": [""set_id"", ...]
}

Think of ""solution"" as the single field where you list the stops you'll pick; each string in the array should be the exact identifier of a curb spot from the instance. This little block is just the form I expect — a sketch of the shape, not the actual filled-in plan.

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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.42857142857142855, 'sets': [{'id': 1, 'elements': [2, 6]}, {'id': 2, 'elements': [1, 2, 3, 6, 7, 8]}, {'id': 3, 'elements': [2, 3, 5]}, {'id': 4, 'elements': [3, 5]}, {'id': 5, 'elements': [2, 3, 4, 7, 8]}, {'id': 6, 'elements': [4, 6, 7, 8]}, {'id': 7, 'elements': [7, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 3, 'v': 2}, {'u': 3, 'v': 5}, {'u': 8, 'v': 6}, {'u': 7, 'v': 4}, {'u': 7, 'v': 6}, {'u': 6, 'v': 2}, {'u': 2, 'v': 1}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0010.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0010.png'}","[2, 4, 6]",3.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': ['B', 'F']}, {'id': 'S2', 'elements': ['A', 'B', 'C', 'F', 'G', 'H']}, {'id': 'S3', 'elements': ['B', 'C', 'E']}, {'id': 'S4', 'elements': ['C', 'E']}, {'id': 'S5', 'elements': ['B', 'C', 'D', 'G', 'H']}, {'id': 'S6', 'elements': ['D', 'F', 'G', 'H']}, {'id': 'S7', 'elements': ['G', 'H']}]}","['S2', 'S4', 'S6']",11,json,names
SCP,SCP,"I’m juggling the gallery plan: pick a handful of exhibits so every historical era the museum cares about is shown somewhere on the walls. The choice is which exhibits to include; one choice is better than another if it uses fewer exhibits while still showing every era at least once — you can tell by simply counting how many exhibits were picked, and the smaller that number, the better. Nothing can be left out — each era has to appear at least once — and picking the same exhibit twice doesn’t help, though different exhibits can overlap in which eras they cover. The concrete list of eras and exhibit options is shown below.

{
  ""total_eras"": 8,
  ""total_exhibits"": 7,
  ""sets"": [
    {
      ""exhibit_id"": ""S1"",
      ""covered_eras"": [
        1,
        4,
        7
      ]
    },
    {
      ""exhibit_id"": ""S2"",
      ""covered_eras"": [
        2,
        3,
        6,
        7,
        8
      ]
    },
    {
      ""exhibit_id"": ""S3"",
      ""covered_eras"": [
        2,
        5,
        7
      ]
    },
    {
      ""exhibit_id"": ""S4"",
      ""covered_eras"": [
        1,
        4,
        5,
        7
      ]
    },
    {
      ""exhibit_id"": ""S5"",
      ""covered_eras"": [
        2,
        4,
        6,
        7
      ]
    },
    {
      ""exhibit_id"": ""S6"",
      ""covered_eras"": [
        2,
        3,
        4,
        5,
        7
      ]
    },
    {
      ""exhibit_id"": ""S7"",
      ""covered_eras"": [
        6,
        8
      ]
    }
  ]
}

Also, when you send the final pick, please use this little JSON layout so I can read it easily:

{
  ""solution"": [""exhibit_id"", ...]
}

Think of it like a tiny form: ""solution"" is the list of exhibits you chose, and each entry like ""exhibit_id"" is a placeholder for one exhibit identifier from the instance. This block is just the expected shape — not the actual answer — so replace the placeholder entries with the real exhibit ids from the problem.

Please make sure to use the exhibit 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"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.4642857142857143, 'sets': [{'id': 1, 'elements': [1, 4, 7]}, {'id': 2, 'elements': [2, 3, 6, 7, 8]}, {'id': 3, 'elements': [2, 5, 7]}, {'id': 4, 'elements': [1, 4, 5, 7]}, {'id': 5, 'elements': [2, 4, 6, 7]}, {'id': 6, 'elements': [2, 3, 4, 5, 7]}, {'id': 7, 'elements': [6, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 3, 'v': 5}, {'u': 6, 'v': 2}, {'u': 5, 'v': 2}, {'u': 5, 'v': 7}, {'u': 7, 'v': 4}, {'u': 8, 'v': 2}, {'u': 1, 'v': 4}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0011.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0011.png'}","[2, 4]",2.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': [1, 4, 7]}, {'id': 'S2', 'elements': [2, 3, 6, 7, 8]}, {'id': 'S3', 'elements': [2, 5, 7]}, {'id': 'S4', 'elements': [1, 4, 5, 7]}, {'id': 'S5', 'elements': [2, 4, 6, 7]}, {'id': 'S6', 'elements': [2, 3, 4, 5, 7]}, {'id': 'S7', 'elements': [6, 8]}]}","['S2', 'S4']",12,json,1
SCP,SCP,"We’ve got an HR puzzle: cover every required competency with training, but keep the variety of sessions to a minimum so employees aren’t juggling dozens of course types. The decision is which session types to pick so every needed competency shows up in at least one of them; a better decision is simply the one with fewer different session types — you measure that by counting the unique sessions chosen. Each competency must be included somewhere in the schedule, and there’s no point in scheduling the same type repeatedly just to pad numbers, so the plan should avoid needless duplication. The exact list of competencies and the session options are listed below.

- **total_competencies**: 8
- **total_session_types**: 8

| session_type_id | covered_competency_ids |
|---|---|
| S1 | 1 2 3 4 5 8 |
| S2 | 1 2 4 5 8 |
| S3 | 1 6 |
| S4 | 2 4 5 8 |
| S5 | 1 2 4 8 |
| S6 | 1 3 6 |
| S7 | 1 3 6 7 |
| S8 | 4 6 |

Oh, and when you send the chosen session types back, please stick to a tiny JSON shape like this so it’s easy to check:

{
  ""solution"": [""session_id"", ...]
}

Here ""solution"" is just the list of session types you picked — each entry is a session identifier from the instance (so one item per chosen session). Think of it like filling in a short form: the array holds the session IDs you want to run. This JSON is only a sketch of the expected shape, not the actual answer.

Please use the identifiers exactly as they appear in the instance input — don’t rename them or make up new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 8, 'density': 0.46875, 'sets': [{'id': 1, 'elements': [1, 2, 3, 4, 5, 8]}, {'id': 2, 'elements': [1, 2, 4, 5, 8]}, {'id': 3, 'elements': [1, 6]}, {'id': 4, 'elements': [2, 4, 5, 8]}, {'id': 5, 'elements': [1, 2, 4, 8]}, {'id': 6, 'elements': [1, 3, 6]}, {'id': 7, 'elements': [1, 3, 6, 7]}, {'id': 8, 'elements': [4, 6]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 1, 'v': 6}, {'u': 1, 'v': 8}, {'u': 4, 'v': 8}, {'u': 3, 'v': 6}, {'u': 5, 'v': 8}, {'u': 6, 'v': 7}, {'u': 8, 'v': 2}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0012.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0012.png'}","[4, 7]",2.0,"{'num_elements': 8, 'num_sets': 8, 'sets': [{'id': 'S1', 'elements': [1, 2, 3, 4, 5, 8]}, {'id': 'S2', 'elements': [1, 2, 4, 5, 8]}, {'id': 'S3', 'elements': [1, 6]}, {'id': 'S4', 'elements': [2, 4, 5, 8]}, {'id': 'S5', 'elements': [1, 2, 4, 8]}, {'id': 'S6', 'elements': [1, 3, 6]}, {'id': 'S7', 'elements': [1, 3, 6, 7]}, {'id': 'S8', 'elements': [4, 6]}]}","['S4', 'S7']",13,markdown_table,1
SCP,SCP,"Recently a landscape designer had to sketch out a planting plan that satisfies every habitat in a park but avoids an overly large plant list. The question to answer was which species to pick so each habitat need gets covered by at least one selected species. The simpler plan is the one with fewer different species — you can judge plans by counting the unique species used, and the lower that number, the better. All habitat needs must be met; leaving any unmet is not allowed, and duplicating the same species doesn’t help. The concrete specifics are shown below.

- **total_habitats**: 9
- **available_species_count**: 9

| species_id | habitats_covered |
|---|---|
| S1 | A B G I |
| S2 | A C G |
| S3 | C D |
| S4 | A B G H |
| S5 | D E F |
| S6 | E F I |
| S7 | B G I |
| S8 | B C D |
| S9 | A B D E F G I |

Oh, and just so you know how I’ll format the final pick: I’ll give you a tiny JSON snippet like this.

{
  ""solution"": [""species_id"", ...]
}

Here ""solution"" is the list of species you’d plant (one entry per chosen species). The placeholder ""species_id"" is just standing in for whatever actual species labels appear in the instance input — replace those placeholders with the real IDs when you submit. This JSON is just a sketch of the shape I’ll use, not the actual final plan.

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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 9, 'density': 0.3950617283950617, 'sets': [{'id': 1, 'elements': [1, 2, 7, 9]}, {'id': 2, 'elements': [1, 3, 7]}, {'id': 3, 'elements': [3, 4]}, {'id': 4, 'elements': [1, 2, 7, 8]}, {'id': 5, 'elements': [4, 5, 6]}, {'id': 6, 'elements': [5, 6, 9]}, {'id': 7, 'elements': [2, 7, 9]}, {'id': 8, 'elements': [2, 3, 4]}, {'id': 9, 'elements': [1, 2, 4, 5, 6, 7, 9]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 6, 'v': 5}, {'u': 5, 'v': 9}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 7}, {'u': 4, 'v': 9}, {'u': 2, 'v': 3}, {'u': 2, 'v': 8}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0013.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0013.png'}","[3, 4, 9]",3.0,"{'num_elements': 9, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'G', 'I']}, {'id': 'S2', 'elements': ['A', 'C', 'G']}, {'id': 'S3', 'elements': ['C', 'D']}, {'id': 'S4', 'elements': ['A', 'B', 'G', 'H']}, {'id': 'S5', 'elements': ['D', 'E', 'F']}, {'id': 'S6', 'elements': ['E', 'F', 'I']}, {'id': 'S7', 'elements': ['B', 'G', 'I']}, {'id': 'S8', 'elements': ['B', 'C', 'D']}, {'id': 'S9', 'elements': ['A', 'B', 'D', 'E', 'F', 'G', 'I']}]}","['S3', 'S4', 'S9']",14,markdown_table,names
SCP,SCP,"There’s a DJ piecing together a short setlist that still satisfies a bunch of mood requests; the idea is to pick songs that between them cover all the moods, using as few tracks as possible. Some tracks pull double duty and hit multiple moods, so the choice is about which combination covers everything. You measure success by counting tracks — the lower the count the better — but every requested mood has to appear at least once and no song should appear twice. The exact details are shown below.

{
  ""num_moods_total"": 9,
  ""num_songs_available"": 7,
  ""sets"": [
    {
      ""song_id"": ""S1"",
      ""moods_covered"": [
        ""A"",
        ""D"",
        ""E"",
        ""H""
      ]
    },
    {
      ""song_id"": ""S2"",
      ""moods_covered"": [
        ""F"",
        ""I""
      ]
    },
    {
      ""song_id"": ""S3"",
      ""moods_covered"": [
        ""C"",
        ""E"",
        ""H""
      ]
    },
    {
      ""song_id"": ""S4"",
      ""moods_covered"": [
        ""A"",
        ""D"",
        ""E""
      ]
    },
    {
      ""song_id"": ""S5"",
      ""moods_covered"": [
        ""A"",
        ""B"",
        ""F"",
        ""I""
      ]
    },
    {
      ""song_id"": ""S6"",
      ""moods_covered"": [
        ""G"",
        ""H""
      ]
    },
    {
      ""song_id"": ""S7"",
      ""moods_covered"": [
        ""A"",
        ""C"",
        ""E"",
        ""F"",
        ""H""
      ]
    }
  ]
}

Also, when you reply, please use a tiny JSON sketch so it's easy to read and parse. Something like this:

{
  ""solution"": [""track_id"", ...]
}

Here ""solution"" is just an array listing the tracks you pick for the DJ set — put each chosen track's identifier in there (that's the label from the instance). Think of the JSON as a simple form: the key says what the list is, and the array holds the exact track IDs. This is only a template showing the expected shape, not your actual answer.

Please make sure all identifiers are 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 7, 'density': 0.36507936507936506, 'sets': [{'id': 1, 'elements': [1, 4, 5, 8]}, {'id': 2, 'elements': [6, 9]}, {'id': 3, 'elements': [3, 5, 8]}, {'id': 4, 'elements': [1, 4, 5]}, {'id': 5, 'elements': [1, 2, 6, 9]}, {'id': 6, 'elements': [7, 8]}, {'id': 7, 'elements': [1, 3, 5, 6, 8]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 2, 'v': 9}, {'u': 3, 'v': 5}, {'u': 5, 'v': 8}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 8, 'v': 1}, {'u': 6, 'v': 1}, {'u': 6, 'v': 9}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0014.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0014.png'}","[4, 5, 6, 7]",4.0,"{'num_elements': 9, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'E', 'H']}, {'id': 'S2', 'elements': ['F', 'I']}, {'id': 'S3', 'elements': ['C', 'E', 'H']}, {'id': 'S4', 'elements': ['A', 'D', 'E']}, {'id': 'S5', 'elements': ['A', 'B', 'F', 'I']}, {'id': 'S6', 'elements': ['G', 'H']}, {'id': 'S7', 'elements': ['A', 'C', 'E', 'F', 'H']}]}","['S4', 'S5', 'S6', 'S7']",15,json,names
SCP,SCP,"Someone in charge of building security explained the setup over coffee: cameras need to be positioned so all corridors are covered, and the kicker is to do it with the fewest cameras possible. The task is picking which sites to use so every hallway gets covered at least once; the way to tell if it’s good is to total the cameras used — lower totals are better. Every corridor must be included in that coverage, and putting cameras that only duplicate existing coverage is wasteful. Details about the corridors and camera choices follow below.

There are 12 distinct corridors to monitor and 12 possible camera sites listed below.
Placing a camera at site S1 would cover corridors A B C.
Placing a camera at site S2 would cover corridors A C D I L.
Placing a camera at site S3 would cover corridors A C D I.
Placing a camera at site S4 would cover corridors B D.
Placing a camera at site S5 would cover corridors E G K.
Placing a camera at site S6 would cover corridors F G.
Placing a camera at site S7 would cover corridors B E G H J L.
Placing a camera at site S8 would cover corridors G H I J K.
Placing a camera at site S9 would cover corridors B D F H I J K.
Placing a camera at site S10 would cover corridors G H I.
Placing a camera at site S11 would cover corridors E G H I J.
Placing a camera at site S12 would cover corridors I L.
Solutions are judged by the total cameras used — keep that count as low as possible while covering all 12 corridors.

Oh, and just so everything stays neat, I like to get the final pick in a tiny JSON sketch — super simple and easy to read. Something like this will do:

{
  ""solution"": [""set_id"", ...]
}

Here ""solution"" is the list of camera sites you’re choosing (each entry is the id of a site to place a camera). Think of it like filling out a short form: put each site identifier in that array, and that’s your answer. This is just the shape I’m expecting, not the actual selection.

Please be careful to use the exact identifiers from the instance input — don’t rename anything 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 12, 'density': 0.3263888888888889, 'sets': [{'id': 1, 'elements': [1, 2, 3]}, {'id': 2, 'elements': [1, 3, 4, 9, 12]}, {'id': 3, 'elements': [1, 3, 4, 9]}, {'id': 4, 'elements': [2, 4]}, {'id': 5, 'elements': [5, 7, 11]}, {'id': 6, 'elements': [6, 7]}, {'id': 7, 'elements': [2, 5, 7, 8, 10, 12]}, {'id': 8, 'elements': [7, 8, 9, 10, 11]}, {'id': 9, 'elements': [2, 4, 6, 8, 9, 10, 11]}, {'id': 10, 'elements': [7, 8, 9]}, {'id': 11, 'elements': [5, 7, 8, 9, 10]}, {'id': 12, 'elements': [9, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 11, 'v': 5}, {'u': 11, 'v': 7}, {'u': 8, 'v': 7}, {'u': 4, 'v': 2}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 2, 'v': 3}, {'u': 2, 'v': 9}, {'u': 12, 'v': 9}, {'u': 6, 'v': 9}, {'u': 1, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0015.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0015.png'}","[2, 7, 9]",3.0,"{'num_elements': 12, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'C']}, {'id': 'S2', 'elements': ['A', 'C', 'D', 'I', 'L']}, {'id': 'S3', 'elements': ['A', 'C', 'D', 'I']}, {'id': 'S4', 'elements': ['B', 'D']}, {'id': 'S5', 'elements': ['E', 'G', 'K']}, {'id': 'S6', 'elements': ['F', 'G']}, {'id': 'S7', 'elements': ['B', 'E', 'G', 'H', 'J', 'L']}, {'id': 'S8', 'elements': ['G', 'H', 'I', 'J', 'K']}, {'id': 'S9', 'elements': ['B', 'D', 'F', 'H', 'I', 'J', 'K']}, {'id': 'S10', 'elements': ['G', 'H', 'I']}, {'id': 'S11', 'elements': ['E', 'G', 'H', 'I', 'J']}, {'id': 'S12', 'elements': ['I', 'L']}]}","['S2', 'S7', 'S9']",16,nl,names
SCP,SCP,"Many people prefer a clean brochure with just a few distinct tours, so the operator must choose which built routes to include so that every monument and viewpoint is covered. The choice comes down to which combination of routes reaches every spot while keeping the number of different routes offered to a minimum. To judge any selection, simply count the distinct routes it contains — every point needs to be on at least one route, and duplicates don’t reduce that total. The concrete list of sights and possible routes is given below.

- **total_points_of_interest**: 12
- **available_route_count**: 12

| route_id | route_covered_sights |
|---|---|
| S1 | 0 1 2 5 9 |
| S2 | 0 3 4 5 6 8 9 |
| S3 | 2 3 4 5 11 |
| S4 | 0 1 2 3 4 7 11 |
| S5 | 1 2 3 7 10 |
| S6 | 1 2 8 9 |
| S7 | 1 5 6 9 |
| S8 | 1 3 4 7 9 11 |
| S9 | 1 5 7 8 9 10 |
| S10 | 5 6 7 8 9 |
| S11 | 3 8 10 11 |
| S12 | 4 10 11 |

If you want to hand me the chosen routes in a tidy, machine-friendly way, just send a little JSON snippet like this:

{
  ""solution"": [""route_id"", ...]
}

Think of it like a simple form: ""solution"" is the list of route identifiers you want in the brochure, and each item in the array is one route. This block is just a sketch of the expected shape, not the actual answer — replace the placeholder entries with the real route IDs from the instance.

Please use the identifiers exactly as they appear in the instance input — no renaming and no invented labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 12, 'density': 0.4236111111111111, 'sets': [{'id': 1, 'elements': [1, 2, 3, 6, 10]}, {'id': 2, 'elements': [1, 4, 5, 6, 7, 9, 10]}, {'id': 3, 'elements': [3, 4, 5, 6, 12]}, {'id': 4, 'elements': [1, 2, 3, 4, 5, 8, 12]}, {'id': 5, 'elements': [2, 3, 4, 8, 11]}, {'id': 6, 'elements': [2, 3, 9, 10]}, {'id': 7, 'elements': [2, 6, 7, 10]}, {'id': 8, 'elements': [2, 4, 5, 8, 10, 12]}, {'id': 9, 'elements': [2, 6, 8, 9, 10, 11]}, {'id': 10, 'elements': [6, 7, 8, 9, 10]}, {'id': 11, 'elements': [4, 9, 11, 12]}, {'id': 12, 'elements': [5, 11, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 1, 'v': 3}, {'u': 1, 'v': 6}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 9}, {'u': 3, 'v': 4}, {'u': 6, 'v': 7}, {'u': 6, 'v': 10}, {'u': 11, 'v': 8}, {'u': 11, 'v': 12}, {'u': 12, 'v': 4}, {'u': 8, 'v': 5}, {'u': 8, 'v': 9}, {'u': 9, 'v': 10}, {'u': 4, 'v': 5}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0016.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0016.png'}","[2, 4, 11]",3.0,"{'num_elements': 12, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [0, 1, 2, 5, 9]}, {'id': 'S2', 'elements': [0, 3, 4, 5, 6, 8, 9]}, {'id': 'S3', 'elements': [2, 3, 4, 5, 11]}, {'id': 'S4', 'elements': [0, 1, 2, 3, 4, 7, 11]}, {'id': 'S5', 'elements': [1, 2, 3, 7, 10]}, {'id': 'S6', 'elements': [1, 2, 8, 9]}, {'id': 'S7', 'elements': [1, 5, 6, 9]}, {'id': 'S8', 'elements': [1, 3, 4, 7, 9, 11]}, {'id': 'S9', 'elements': [1, 5, 7, 8, 9, 10]}, {'id': 'S10', 'elements': [5, 6, 7, 8, 9]}, {'id': 'S11', 'elements': [3, 8, 10, 11]}, {'id': 'S12', 'elements': [4, 10, 11]}]}","['S2', 'S4', 'S11']",17,markdown_table,0
SCP,SCP,"Recently the backup team faced a cleanup: dozens of essential files and a list of possible storage sites, and the mission was to pick a small set of sites that together hold every critical file. They measure a good solution by simply counting how many sites are used (fewer sites means a better solution), and they must make sure every file appears in at least one chosen site; duplicating the same site is pointless. The precise setup appears below.

{
  ""total_critical_files"": 8,
  ""available_storage_sites"": 7,
  ""sets"": [
    {
      ""storage_site_id"": ""S1"",
      ""files_in_site"": [
        ""C"",
        ""E"",
        ""H""
      ]
    },
    {
      ""storage_site_id"": ""S2"",
      ""files_in_site"": [
        ""A"",
        ""B"",
        ""C"",
        ""H""
      ]
    },
    {
      ""storage_site_id"": ""S3"",
      ""files_in_site"": [
        ""D"",
        ""F"",
        ""H""
      ]
    },
    {
      ""storage_site_id"": ""S4"",
      ""files_in_site"": [
        ""G"",
        ""H""
      ]
    },
    {
      ""storage_site_id"": ""S5"",
      ""files_in_site"": [
        ""A"",
        ""D"",
        ""E"",
        ""F"",
        ""G"",
        ""H""
      ]
    },
    {
      ""storage_site_id"": ""S6"",
      ""files_in_site"": [
        ""A"",
        ""E"",
        ""G""
      ]
    },
    {
      ""storage_site_id"": ""S7"",
      ""files_in_site"": [
        ""C"",
        ""F""
      ]
    }
  ]
}

When you report back, just drop the chosen sites into a tiny JSON snippet so it's easy to read and parse. Something like this will do:

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

Here ""solution"" is where you list the sites you chose — one identifier per entry — and the ellipsis just means you can include as many as needed. Think of it like a simple form: the array is the list of storage sites to use.

This is only the expected shape of the answer, not the actual picks. Quick reminder: use the identifiers exactly as they appear in 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"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.4107142857142857, 'sets': [{'id': 1, 'elements': [3, 5, 8]}, {'id': 2, 'elements': [1, 2, 3, 8]}, {'id': 3, 'elements': [4, 6, 8]}, {'id': 4, 'elements': [7, 8]}, {'id': 5, 'elements': [1, 4, 5, 6, 7, 8]}, {'id': 6, 'elements': [1, 5, 7]}, {'id': 7, 'elements': [3, 6]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 6, 'v': 4}, {'u': 6, 'v': 8}, {'u': 5, 'v': 8}, {'u': 8, 'v': 1}, {'u': 8, 'v': 7}, {'u': 3, 'v': 1}, {'u': 2, 'v': 1}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0017.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0017.png'}","[2, 5]",2.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': ['C', 'E', 'H']}, {'id': 'S2', 'elements': ['A', 'B', 'C', 'H']}, {'id': 'S3', 'elements': ['D', 'F', 'H']}, {'id': 'S4', 'elements': ['G', 'H']}, {'id': 'S5', 'elements': ['A', 'D', 'E', 'F', 'G', 'H']}, {'id': 'S6', 'elements': ['A', 'E', 'G']}, {'id': 'S7', 'elements': ['C', 'F']}]}","['S2', 'S5']",18,json,names
SCP,SCP,"Someone on the team needs to build a compact freelance lineup that still handles every language pairing requested by projects. The choice is which freelancers to invite onto the roster so that each required language combination is represented at least once, and the cleaner solution is the one with the least people added. In practice this means making sure every pairing is assigned, tallying up the selected freelancers to see how compact the roster is, and avoiding hires that merely duplicate coverage without covering anything new. The exact list of requirements and freelancers will be shown below.

- **total_required_language_pairs**: 12
- **total_available_freelancers**: 11

| freelancer_id | covered_language_pairs |
|---|---|
| S1 | C I L |
| S2 | B H |
| S3 | A D G H I |
| S4 | B J K |
| S5 | B E H L |
| S6 | A C D G I L |
| S7 | F H K L |
| S8 | A D |
| S9 | B E J K L |
| S10 | D E F H K |
| S11 | A D K |

Oh, and to keep things machine- and people-friendly, please return the chosen roster in this little JSON shape:

{
  ""solution"": [""freelancer_id"", ...]
}

Think of it like a simple form: ""solution"" is the list (array) of the freelancer IDs you’re inviting onto the roster. The placeholder freelancer_id is where each exact ID from the instance goes. This JSON is just the expected shape — not the actual answer — so replace the placeholder(s) with the real IDs when you submit.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 11, 'density': 0.3181818181818182, 'sets': [{'id': 1, 'elements': [3, 9, 12]}, {'id': 2, 'elements': [2, 8]}, {'id': 3, 'elements': [1, 4, 7, 8, 9]}, {'id': 4, 'elements': [2, 10, 11]}, {'id': 5, 'elements': [2, 5, 8, 12]}, {'id': 6, 'elements': [1, 3, 4, 7, 9, 12]}, {'id': 7, 'elements': [6, 8, 11, 12]}, {'id': 8, 'elements': [1, 4]}, {'id': 9, 'elements': [2, 5, 10, 11, 12]}, {'id': 10, 'elements': [4, 5, 6, 8, 11]}, {'id': 11, 'elements': [1, 4, 11]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 11, 'v': 6}, {'u': 11, 'v': 8}, {'u': 11, 'v': 12}, {'u': 3, 'v': 1}, {'u': 3, 'v': 9}, {'u': 4, 'v': 1}, {'u': 4, 'v': 7}, {'u': 4, 'v': 12}, {'u': 8, 'v': 10}, {'u': 8, 'v': 12}, {'u': 10, 'v': 2}, {'u': 5, 'v': 2}, {'u': 5, 'v': 6}, {'u': 7, 'v': 9}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0018.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0018.png'}","[6, 9, 10]",3.0,"{'num_elements': 12, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': ['C', 'I', 'L']}, {'id': 'S2', 'elements': ['B', 'H']}, {'id': 'S3', 'elements': ['A', 'D', 'G', 'H', 'I']}, {'id': 'S4', 'elements': ['B', 'J', 'K']}, {'id': 'S5', 'elements': ['B', 'E', 'H', 'L']}, {'id': 'S6', 'elements': ['A', 'C', 'D', 'G', 'I', 'L']}, {'id': 'S7', 'elements': ['F', 'H', 'K', 'L']}, {'id': 'S8', 'elements': ['A', 'D']}, {'id': 'S9', 'elements': ['B', 'E', 'J', 'K', 'L']}, {'id': 'S10', 'elements': ['D', 'E', 'F', 'H', 'K']}, {'id': 'S11', 'elements': ['A', 'D', 'K']}]}","['S6', 'S9', 'S10']",19,markdown_table,names
SCP,SCP,"Recently the department decided it would be handy to have a minimal textbook set for the term, so the coordinator’s challenge became: choose the smallest possible collection of books that together contain every topic from the syllabus. The choice to make is which specific textbooks to pick; a preferable choice is the one that covers every topic but uses the fewest titles. The way to compare choices is by counting the selected textbooks, and no topic should be left out even if some will appear in more than one chosen book. The exact list of topics and book candidates appears below.

# total_syllabus_topics=9
# total_textbook_options=7
textbook_id,topics_covered
S1,A C F H I
S2,B C E I
S3,A B C D E F G H I
S4,B C
S5,A C H
S6,A C D G I
S7,B C E G I

If you want to hand me the picks in a simple, machine-friendly way, you can stick to a tiny JSON sketch like this:

{
  ""solution"": [""book_id"", ...]
}

Think of ""solution"" as the list of chosen textbooks, and put each chosen book's identifier inside that array. The ""book_id"" entry is just a placeholder showing the kind of ID you'll use — it's not an actual book title. This JSON is just the expected shape of the reply, not the real answer itself.

Please use the exact identifiers from the instance input — don't rename them or invent new ones. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 7, 'density': 0.5238095238095238, 'sets': [{'id': 1, 'elements': [1, 3, 6, 8, 9]}, {'id': 2, 'elements': [2, 3, 5, 9]}, {'id': 3, 'elements': [1, 2, 3, 4, 5, 6, 7, 8, 9]}, {'id': 4, 'elements': [2, 3]}, {'id': 5, 'elements': [1, 3, 8]}, {'id': 6, 'elements': [1, 3, 4, 7, 9]}, {'id': 7, 'elements': [2, 3, 5, 7, 9]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 4, 'v': 7}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 5}, {'u': 7, 'v': 3}, {'u': 6, 'v': 1}, {'u': 3, 'v': 1}, {'u': 1, 'v': 8}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0019.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0019.png'}",[3],1.0,"{'num_elements': 9, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'F', 'H', 'I']}, {'id': 'S2', 'elements': ['B', 'C', 'E', 'I']}, {'id': 'S3', 'elements': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']}, {'id': 'S4', 'elements': ['B', 'C']}, {'id': 'S5', 'elements': ['A', 'C', 'H']}, {'id': 'S6', 'elements': ['A', 'C', 'D', 'G', 'I']}, {'id': 'S7', 'elements': ['B', 'C', 'E', 'G', 'I']}]}",['S3'],20,csv,names
SCP,SCP,"I’m putting together a conference and have a stack of vendor packages to choose from—each one covers a few of the services we need like catering, AV, and signage. The job is to pick as few of those packages as possible so every required service shows up in at least one selected bundle; the way to judge a plan is simply by counting how many packages were picked (fewer is better) while making sure nothing important is missing, and avoiding needless overlap where two packages both do the same thing. The concrete package and service details are listed below.

- **total_services_required**: 12
- **total_packages_available**: 12

| package_id | services_in_package |
|---|---|
| S1 | 2 3 5 7 9 10 |
| S2 | 1 3 6 11 |
| S3 | 0 2 7 10 |
| S4 | 0 1 3 4 6 8 10 11 |
| S5 | 1 3 4 11 |
| S6 | 0 5 7 11 |
| S7 | 1 3 4 6 10 |
| S8 | 6 7 10 11 |
| S9 | 3 8 11 |
| S10 | 0 5 9 |
| S11 | 0 1 6 7 |
| S12 | 0 1 4 5 6 8 11 |

If you want to hand back the chosen packages in a neat way, just use this little JSON layout so it's easy for everyone (and whatever script is checking things) to read:

{
  ""solution"": [""package_id"", ...]
}

Think of ""solution"" as a simple list of the package IDs you pick — one string per package, just the exact labels from the package list. This block is just a sketch of the shape I need, not your final answer: replace ""package_id"" and the ... with the real IDs you select.

Please make sure to use the identifiers exactly as they appear in the instance input — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 12, 'density': 0.3888888888888889, 'sets': [{'id': 1, 'elements': [3, 4, 6, 8, 10, 11]}, {'id': 2, 'elements': [2, 4, 7, 12]}, {'id': 3, 'elements': [1, 3, 8, 11]}, {'id': 4, 'elements': [1, 2, 4, 5, 7, 9, 11, 12]}, {'id': 5, 'elements': [2, 4, 5, 12]}, {'id': 6, 'elements': [1, 6, 8, 12]}, {'id': 7, 'elements': [2, 4, 5, 7, 11]}, {'id': 8, 'elements': [7, 8, 11, 12]}, {'id': 9, 'elements': [4, 9, 12]}, {'id': 10, 'elements': [1, 6, 10]}, {'id': 11, 'elements': [1, 2, 7, 8]}, {'id': 12, 'elements': [1, 2, 5, 6, 7, 9, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 3, 'v': 8}, {'u': 4, 'v': 2}, {'u': 4, 'v': 5}, {'u': 4, 'v': 7}, {'u': 4, 'v': 12}, {'u': 1, 'v': 6}, {'u': 1, 'v': 8}, {'u': 1, 'v': 12}, {'u': 10, 'v': 6}, {'u': 2, 'v': 7}, {'u': 12, 'v': 9}, {'u': 7, 'v': 11}, {'u': 11, 'v': 8}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0020.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0020.png'}","[1, 4]",2.0,"{'num_elements': 12, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [2, 3, 5, 7, 9, 10]}, {'id': 'S2', 'elements': [1, 3, 6, 11]}, {'id': 'S3', 'elements': [0, 2, 7, 10]}, {'id': 'S4', 'elements': [0, 1, 3, 4, 6, 8, 10, 11]}, {'id': 'S5', 'elements': [1, 3, 4, 11]}, {'id': 'S6', 'elements': [0, 5, 7, 11]}, {'id': 'S7', 'elements': [1, 3, 4, 6, 10]}, {'id': 'S8', 'elements': [6, 7, 10, 11]}, {'id': 'S9', 'elements': [3, 8, 11]}, {'id': 'S10', 'elements': [0, 5, 9]}, {'id': 'S11', 'elements': [0, 1, 6, 7]}, {'id': 'S12', 'elements': [0, 1, 4, 5, 6, 8, 11]}]}","['S1', 'S4']",21,markdown_table,0
SCP,SCP,"Many people would just grab every toolkit and hope for the best, but here the plan is smarter: pick the least number of kits such that for each repair there’s at least one selected kit with the necessary tools. That means making sure no chore is overlooked and avoiding redundant kit choices, and you judge options by counting the kits — the lower the count that still covers all chores, the better. The exact jobs and what’s in each kit are shown below.

# total_repair_tasks=11
# total_available_toolkits=10
toolkit_id,handled_tasks
S1,A B
S2,A C D E G H J
S3,A B E I J K
S4,B D E F
S5,A B C D E F G
S6,B D F G
S7,B D E F G
S8,A B H I J
S9,I J
S10,B C J K

Also, if you want the answer in a tidy, machine-friendly shape, just hand it back like this:

{
  ""solution"": [""kit_id"", ...]
}

This just means: ""solution"" is the list of chosen kits, and each item in the array is a placeholder for a kit identifier from the instance (replace the placeholder with the actual IDs when you reply). The JSON above is only a sketch of the expected shape — not the final selection.

Please use the exact identifiers from 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 11, 'num_sets': 10, 'density': 0.41818181818181815, 'sets': [{'id': 1, 'elements': [1, 2]}, {'id': 2, 'elements': [1, 3, 4, 5, 7, 8, 10]}, {'id': 3, 'elements': [1, 2, 5, 9, 10, 11]}, {'id': 4, 'elements': [2, 4, 5, 6]}, {'id': 5, 'elements': [1, 2, 3, 4, 5, 6, 7]}, {'id': 6, 'elements': [2, 4, 6, 7]}, {'id': 7, 'elements': [2, 4, 5, 6, 7]}, {'id': 8, 'elements': [1, 2, 8, 9, 10]}, {'id': 9, 'elements': [9, 10]}, {'id': 10, 'elements': [2, 3, 10, 11]}], 'graph': {'num_nodes': 11, 'edges': [{'u': 6, 'v': 5}, {'u': 7, 'v': 5}, {'u': 4, 'v': 5}, {'u': 3, 'v': 2}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 5, 'v': 2}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 10, 'v': 1}, {'u': 8, 'v': 1}, {'u': 2, 'v': 1}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0021.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0021.png'}","[3, 5, 8]",3.0,"{'num_elements': 11, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': ['A', 'B']}, {'id': 'S2', 'elements': ['A', 'C', 'D', 'E', 'G', 'H', 'J']}, {'id': 'S3', 'elements': ['A', 'B', 'E', 'I', 'J', 'K']}, {'id': 'S4', 'elements': ['B', 'D', 'E', 'F']}, {'id': 'S5', 'elements': ['A', 'B', 'C', 'D', 'E', 'F', 'G']}, {'id': 'S6', 'elements': ['B', 'D', 'F', 'G']}, {'id': 'S7', 'elements': ['B', 'D', 'E', 'F', 'G']}, {'id': 'S8', 'elements': ['A', 'B', 'H', 'I', 'J']}, {'id': 'S9', 'elements': ['I', 'J']}, {'id': 'S10', 'elements': ['B', 'C', 'J', 'K']}]}","['S3', 'S5', 'S8']",22,csv,names
SCP,SCP,"Many people imagine ordering ingredients one-by-one, but here the chef has to work with pre-packed bundles and decide which ones to use so every menu item’s ingredients are available. Better choices cover all required ingredients while using the least number of bundles possible. To compare choices, just count the number of bundles included in each plan — fewer is better. Every ingredient must appear in at least one selected bundle, and selecting the same bundle twice is redundant. The concrete bundle details follow below.

- **total_ingredients_needed**: 9
- **total_bundles_available**: 8

| bundle_id | ingredients_in_bundle |
|---|---|
| S1 | 0 1 2 3 7 8 |
| S2 | 1 2 4 7 8 |
| S3 | 3 6 7 |
| S4 | 4 5 |
| S5 | 3 5 8 |
| S6 | 1 3 5 6 7 8 |
| S7 | 1 2 7 8 |
| S8 | 2 3 4 5 6 7 8 |

Oh, and when you send your pick, please follow this little JSON shape so it's easy to check:

{
  ""solution"": [""set_id"", ...]
}

""solution"" should be a list of the bundle IDs you want to use — one ID per chosen bundle. Think of it like filling in a short form: put each bundle identifier from the instance inside that array. This block is just a sketch of the expected shape, not the actual answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 8, 'density': 0.5, 'sets': [{'id': 1, 'elements': [1, 2, 3, 4, 8, 9]}, {'id': 2, 'elements': [2, 3, 5, 8, 9]}, {'id': 3, 'elements': [4, 7, 8]}, {'id': 4, 'elements': [5, 6]}, {'id': 5, 'elements': [4, 6, 9]}, {'id': 6, 'elements': [2, 4, 6, 7, 8, 9]}, {'id': 7, 'elements': [2, 3, 8, 9]}, {'id': 8, 'elements': [3, 4, 5, 6, 7, 8, 9]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 1, 'v': 4}, {'u': 1, 'v': 8}, {'u': 4, 'v': 6}, {'u': 4, 'v': 9}, {'u': 3, 'v': 8}, {'u': 6, 'v': 7}, {'u': 2, 'v': 5}, {'u': 2, 'v': 8}, {'u': 5, 'v': 7}, {'u': 7, 'v': 9}, {'u': 8, 'v': 9}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0022.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0022.png'}","[1, 8]",2.0,"{'num_elements': 9, 'num_sets': 8, 'sets': [{'id': 'S1', 'elements': [0, 1, 2, 3, 7, 8]}, {'id': 'S2', 'elements': [1, 2, 4, 7, 8]}, {'id': 'S3', 'elements': [3, 6, 7]}, {'id': 'S4', 'elements': [4, 5]}, {'id': 'S5', 'elements': [3, 5, 8]}, {'id': 'S6', 'elements': [1, 3, 5, 6, 7, 8]}, {'id': 'S7', 'elements': [1, 2, 7, 8]}, {'id': 'S8', 'elements': [2, 3, 4, 5, 6, 7, 8]}]}","['S1', 'S8']",23,markdown_table,0
SCP,SCP,"At the library, the plan is to assemble a few themed boxes to represent all the subjects in the reading program, and the aim is to do that with as few boxes as possible. The question is which boxes to choose; evaluate each option by how many boxes are selected — the ideal choice uses the smallest number while still including every subject at least once. Nothing can be left unrepresented, and unnecessary duplicate coverage is to be avoided. The specific box contents appear below.

{
  ""total_subjects"": 11,
  ""total_boxes_available"": 11,
  ""sets"": [
    {
      ""box_id"": ""S1"",
      ""subjects_covered"": [
        ""A"",
        ""K""
      ]
    },
    {
      ""box_id"": ""S2"",
      ""subjects_covered"": [
        ""B"",
        ""D"",
        ""G"",
        ""I""
      ]
    },
    {
      ""box_id"": ""S3"",
      ""subjects_covered"": [
        ""F"",
        ""H"",
        ""K""
      ]
    },
    {
      ""box_id"": ""S4"",
      ""subjects_covered"": [
        ""A"",
        ""B"",
        ""D"",
        ""K""
      ]
    },
    {
      ""box_id"": ""S5"",
      ""subjects_covered"": [
        ""B"",
        ""E"",
        ""I""
      ]
    },
    {
      ""box_id"": ""S6"",
      ""subjects_covered"": [
        ""C"",
        ""F"",
        ""K""
      ]
    },
    {
      ""box_id"": ""S7"",
      ""subjects_covered"": [
        ""B"",
        ""D"",
        ""G"",
        ""I"",
        ""J""
      ]
    },
    {
      ""box_id"": ""S8"",
      ""subjects_covered"": [
        ""C"",
        ""D"",
        ""F"",
        ""H"",
        ""K""
      ]
    },
    {
      ""box_id"": ""S9"",
      ""subjects_covered"": [
        ""G"",
        ""I"",
        ""K""
      ]
    },
    {
      ""box_id"": ""S10"",
      ""subjects_covered"": [
        ""I"",
        ""J""
      ]
    },
    {
      ""box_id"": ""S11"",
      ""subjects_covered"": [
        ""A"",
        ""C"",
        ""D"",
        ""F"",
        ""K""
      ]
    }
  ]
}

Oh, and when you reply with your pick of boxes, toss it into a little JSON snippet like this so it's tidy and easy to check:

{
  ""solution"": [""box_id"", ...]
}

This just means ""solution"" should be a list of the themed box identifiers you choose. The ""box_id"" bit is just a placeholder showing the format — replace each placeholder with the actual box identifier from the instance. Think of it like filling out a short form: the key ""solution"" holds the chosen box labels.

This JSON is only a sketch of the expected shape, not the actual answer — you'll fill in the real identifiers from the instance.

Make sure all identifiers are used exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like:
- plain numbers such as “1” or “23”
- single capital letters like “A” or “B”
- a capital letter followed by digits like “A1” or “X7”","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 11, 'num_sets': 11, 'density': 0.32231404958677684, 'sets': [{'id': 1, 'elements': [1, 11]}, {'id': 2, 'elements': [2, 4, 7, 9]}, {'id': 3, 'elements': [6, 8, 11]}, {'id': 4, 'elements': [1, 2, 4, 11]}, {'id': 5, 'elements': [2, 5, 9]}, {'id': 6, 'elements': [3, 6, 11]}, {'id': 7, 'elements': [2, 4, 7, 9, 10]}, {'id': 8, 'elements': [3, 4, 6, 8, 11]}, {'id': 9, 'elements': [7, 9, 11]}, {'id': 10, 'elements': [9, 10]}, {'id': 11, 'elements': [1, 3, 4, 6, 11]}], 'graph': {'num_nodes': 11, 'edges': [{'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 4, 'v': 1}, {'u': 4, 'v': 9}, {'u': 4, 'v': 11}, {'u': 5, 'v': 2}, {'u': 2, 'v': 9}, {'u': 8, 'v': 3}, {'u': 8, 'v': 6}, {'u': 8, 'v': 11}, {'u': 3, 'v': 11}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0023.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0023.png'}","[5, 7, 8, 11]",4.0,"{'num_elements': 11, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': ['A', 'K']}, {'id': 'S2', 'elements': ['B', 'D', 'G', 'I']}, {'id': 'S3', 'elements': ['F', 'H', 'K']}, {'id': 'S4', 'elements': ['A', 'B', 'D', 'K']}, {'id': 'S5', 'elements': ['B', 'E', 'I']}, {'id': 'S6', 'elements': ['C', 'F', 'K']}, {'id': 'S7', 'elements': ['B', 'D', 'G', 'I', 'J']}, {'id': 'S8', 'elements': ['C', 'D', 'F', 'H', 'K']}, {'id': 'S9', 'elements': ['G', 'I', 'K']}, {'id': 'S10', 'elements': ['I', 'J']}, {'id': 'S11', 'elements': ['A', 'C', 'D', 'F', 'K']}]}","['S5', 'S7', 'S8', 'S11']",24,json,names
SCP,SCP,"There’s a backlog of features and a stack of candidate libraries on the table; the role here is to assemble a compact toolkit. The rule is simple: make sure each required feature is handled by at least one library, and try to keep the toolkit minimal — the way to check this is to count the libraries you included (lower counts are better). Nothing from the must-have list can be skipped, and picking libraries that duplicate the same features doesn’t give any extra credit. Concrete details follow below.

{
  ""num_required_features"": 12,
  ""num_candidate_libraries"": 11,
  ""sets"": [
    {
      ""library_id"": ""S1"",
      ""features_provided"": [
        2,
        3,
        6
      ]
    },
    {
      ""library_id"": ""S2"",
      ""features_provided"": [
        3,
        4,
        6,
        8
      ]
    },
    {
      ""library_id"": ""S3"",
      ""features_provided"": [
        2,
        3,
        4,
        5,
        6,
        7,
        9
      ]
    },
    {
      ""library_id"": ""S4"",
      ""features_provided"": [
        1,
        2,
        4,
        5,
        6,
        9,
        10
      ]
    },
    {
      ""library_id"": ""S5"",
      ""features_provided"": [
        1,
        2,
        3,
        6,
        8,
        10
      ]
    },
    {
      ""library_id"": ""S6"",
      ""features_provided"": [
        1,
        3,
        4,
        6,
        7,
        8,
        9,
        10,
        11
      ]
    },
    {
      ""library_id"": ""S7"",
      ""features_provided"": [
        3,
        4
      ]
    },
    {
      ""library_id"": ""S8"",
      ""features_provided"": [
        4,
        5,
        7,
        9,
        10,
        12
      ]
    },
    {
      ""library_id"": ""S9"",
      ""features_provided"": [
        1,
        5,
        6,
        7,
        10,
        11,
        12
      ]
    },
    {
      ""library_id"": ""S10"",
      ""features_provided"": [
        7,
        9,
        10,
        11,
        12
      ]
    },
    {
      ""library_id"": ""S11"",
      ""features_provided"": [
        10,
        11,
        12
      ]
    }
  ]
}

Oh, and one more practical thing — when you reply, please follow a tiny output shape so I can parse it easily. Something like this will do:

{
  ""solution"": [""lib_id"", ...]
}

This is just a sketch of the shape I expect: ""solution"" holds the list of libraries you picked (each entry should be the exact identifier from the instance). Think of it like a simple form: put the chosen library IDs in that array, and you’re done — don’t worry about extra fields or explainers in the JSON itself.

Quick reminder: use the identifiers exactly as they appear in the instance input — no renaming and no inventing new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 11, 'density': 0.44696969696969696, 'sets': [{'id': 1, 'elements': [2, 3, 6]}, {'id': 2, 'elements': [3, 4, 6, 8]}, {'id': 3, 'elements': [2, 3, 4, 5, 6, 7, 9]}, {'id': 4, 'elements': [1, 2, 4, 5, 6, 9, 10]}, {'id': 5, 'elements': [1, 2, 3, 6, 8, 10]}, {'id': 6, 'elements': [1, 3, 4, 6, 7, 8, 9, 10, 11]}, {'id': 7, 'elements': [3, 4]}, {'id': 8, 'elements': [4, 5, 7, 9, 10, 12]}, {'id': 9, 'elements': [1, 5, 6, 7, 10, 11, 12]}, {'id': 10, 'elements': [7, 9, 10, 11, 12]}, {'id': 11, 'elements': [10, 11, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 9, 'v': 5}, {'u': 9, 'v': 10}, {'u': 10, 'v': 7}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 4, 'v': 2}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 5, 'v': 7}, {'u': 6, 'v': 3}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 7, 'v': 1}, {'u': 2, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0024.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0024.png'}","[5, 8, 9]",3.0,"{'num_elements': 12, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [2, 3, 6]}, {'id': 'S2', 'elements': [3, 4, 6, 8]}, {'id': 'S3', 'elements': [2, 3, 4, 5, 6, 7, 9]}, {'id': 'S4', 'elements': [1, 2, 4, 5, 6, 9, 10]}, {'id': 'S5', 'elements': [1, 2, 3, 6, 8, 10]}, {'id': 'S6', 'elements': [1, 3, 4, 6, 7, 8, 9, 10, 11]}, {'id': 'S7', 'elements': [3, 4]}, {'id': 'S8', 'elements': [4, 5, 7, 9, 10, 12]}, {'id': 'S9', 'elements': [1, 5, 6, 7, 10, 11, 12]}, {'id': 'S10', 'elements': [7, 9, 10, 11, 12]}, {'id': 'S11', 'elements': [10, 11, 12]}]}","['S5', 'S8', 'S9']",25,json,1
SCP,SCP,"Many people on the team want a tight, focused exhibit, so the task became: choose a small number of display modules so that every required historical theme is represented at least once. Here’s the setup: there’s a catalog of modules, each touching several themes, and the choice is which modules to pick so the entire theme list is covered. A cleaner solution uses fewer modules — just tally the chosen modules to see how compact the plan is. It’s essential that no theme is left out; duplicate coverage is allowed but makes the plan less compact. The specific modules and themes are listed below.

{
  ""num_themes"": 10,
  ""num_modules"": 9,
  ""sets"": [
    {
      ""module_id"": ""S1"",
      ""themes"": [
        3,
        4,
        7
      ]
    },
    {
      ""module_id"": ""S2"",
      ""themes"": [
        1,
        2,
        3,
        4,
        5,
        7
      ]
    },
    {
      ""module_id"": ""S3"",
      ""themes"": [
        1,
        2,
        7
      ]
    },
    {
      ""module_id"": ""S4"",
      ""themes"": [
        1,
        3,
        4,
        5,
        7
      ]
    },
    {
      ""module_id"": ""S5"",
      ""themes"": [
        5,
        6,
        10
      ]
    },
    {
      ""module_id"": ""S6"",
      ""themes"": [
        1,
        2,
        4,
        7
      ]
    },
    {
      ""module_id"": ""S7"",
      ""themes"": [
        2,
        4,
        5,
        8,
        9
      ]
    },
    {
      ""module_id"": ""S8"",
      ""themes"": [
        2,
        9
      ]
    },
    {
      ""module_id"": ""S9"",
      ""themes"": [
        2,
        5,
        10
      ]
    }
  ]
}

Also, when you send the actual selection back, tuck it into this simple JSON shape so it's easy to read and parse:

{
  ""solution"": [""module_id"", ...]
}

Think of it like a little form: ""solution"" is the list of chosen display modules, and each ""module_id"" is a placeholder for one module from the catalog (one entry per chosen module). This block is just a sketch of the shape I expect, not the final answer itself.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""

Thanks — drop the list in that format when you're ready and I'll check the coverage.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 9, 'density': 0.37777777777777777, 'sets': [{'id': 1, 'elements': [3, 4, 7]}, {'id': 2, 'elements': [1, 2, 3, 4, 5, 7]}, {'id': 3, 'elements': [1, 2, 7]}, {'id': 4, 'elements': [1, 3, 4, 5, 7]}, {'id': 5, 'elements': [5, 6, 10]}, {'id': 6, 'elements': [1, 2, 4, 7]}, {'id': 7, 'elements': [2, 4, 5, 8, 9]}, {'id': 8, 'elements': [2, 9]}, {'id': 9, 'elements': [2, 5, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 1, 'v': 4}, {'u': 7, 'v': 4}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 8}, {'u': 4, 'v': 3}, {'u': 8, 'v': 9}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0025.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0025.png'}","[2, 5, 7]",3.0,"{'num_elements': 10, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': [3, 4, 7]}, {'id': 'S2', 'elements': [1, 2, 3, 4, 5, 7]}, {'id': 'S3', 'elements': [1, 2, 7]}, {'id': 'S4', 'elements': [1, 3, 4, 5, 7]}, {'id': 'S5', 'elements': [5, 6, 10]}, {'id': 'S6', 'elements': [1, 2, 4, 7]}, {'id': 'S7', 'elements': [2, 4, 5, 8, 9]}, {'id': 'S8', 'elements': [2, 9]}, {'id': 'S9', 'elements': [2, 5, 10]}]}","['S2', 'S5', 'S7']",26,json,1
SCP,SCP,"There’s a storm aftermath with limited transport, and each crate on the truck contains different combinations of emergency supplies. The task is to pick the minimum number of crates that together include every essential thing the people need; choices that cover everything while using fewer crates are preferable. The score for any selection is simply how many crates were taken, and nothing essential can be left out (having the same item in multiple crates is allowed but wastes capacity). The concrete crate contents and the list of needs follow below.

{
  ""total_essential_needs"": 9,
  ""total_crates_available"": 9,
  ""sets"": [
    {
      ""crate_id"": ""S1"",
      ""crate_contents"": [
        3,
        6
      ]
    },
    {
      ""crate_id"": ""S2"",
      ""crate_contents"": [
        3,
        4,
        5,
        7,
        8
      ]
    },
    {
      ""crate_id"": ""S3"",
      ""crate_contents"": [
        2,
        8
      ]
    },
    {
      ""crate_id"": ""S4"",
      ""crate_contents"": [
        0,
        2,
        3,
        5,
        6,
        7,
        8
      ]
    },
    {
      ""crate_id"": ""S5"",
      ""crate_contents"": [
        1,
        4,
        8
      ]
    },
    {
      ""crate_id"": ""S6"",
      ""crate_contents"": [
        1,
        3,
        5,
        7,
        8
      ]
    },
    {
      ""crate_id"": ""S7"",
      ""crate_contents"": [
        0,
        2,
        3,
        6,
        8
      ]
    },
    {
      ""crate_id"": ""S8"",
      ""crate_contents"": [
        5,
        7,
        8
      ]
    },
    {
      ""crate_id"": ""S9"",
      ""crate_contents"": [
        2,
        3,
        5,
        6,
        8
      ]
    }
  ]
}

Oh, and when you send your pick, please use this simple JSON layout so it's easy to read:

{
  ""solution"": [""crate_id"", ...]
}

This just means ""solution"" holds a list of crate identifiers — one string per crate you choose. Think of it like filling out a short form: put each crate's label in the array. The snippet above is just a sketch of the shape I need, not your final answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 9, 'density': 0.4567901234567901, 'sets': [{'id': 1, 'elements': [4, 7]}, {'id': 2, 'elements': [4, 5, 6, 8, 9]}, {'id': 3, 'elements': [3, 9]}, {'id': 4, 'elements': [1, 3, 4, 6, 7, 8, 9]}, {'id': 5, 'elements': [2, 5, 9]}, {'id': 6, 'elements': [2, 4, 6, 8, 9]}, {'id': 7, 'elements': [1, 3, 4, 7, 9]}, {'id': 8, 'elements': [6, 8, 9]}, {'id': 9, 'elements': [3, 4, 6, 7, 9]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 2, 'v': 5}, {'u': 2, 'v': 9}, {'u': 9, 'v': 4}, {'u': 9, 'v': 6}, {'u': 9, 'v': 8}, {'u': 3, 'v': 4}, {'u': 1, 'v': 7}, {'u': 4, 'v': 7}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0026.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0026.png'}","[4, 5]",2.0,"{'num_elements': 9, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': [3, 6]}, {'id': 'S2', 'elements': [3, 4, 5, 7, 8]}, {'id': 'S3', 'elements': [2, 8]}, {'id': 'S4', 'elements': [0, 2, 3, 5, 6, 7, 8]}, {'id': 'S5', 'elements': [1, 4, 8]}, {'id': 'S6', 'elements': [1, 3, 5, 7, 8]}, {'id': 'S7', 'elements': [0, 2, 3, 6, 8]}, {'id': 'S8', 'elements': [5, 7, 8]}, {'id': 'S9', 'elements': [2, 3, 5, 6, 8]}]}","['S4', 'S5']",27,json,0
SCP,SCP,"We’ve got a skills checklist and a catalog of training classes, and the HR job is to combine classes so every skill is addressed. The idea is to use as few different courses as will still touch every competency — measure that by tallying how many courses were picked, with a smaller tally being preferable. Every competency must appear in at least one chosen course, and choosing duplicates or extra classes that don’t add new coverage isn’t useful. The concrete course and competency lists are listed below.

{
  ""total_competencies"": 11,
  ""total_courses_available"": 10,
  ""sets"": [
    {
      ""course_id"": ""S1"",
      ""covered_competencies"": [
        ""A"",
        ""B"",
        ""C"",
        ""D"",
        ""E"",
        ""H"",
        ""J"",
        ""K""
      ]
    },
    {
      ""course_id"": ""S2"",
      ""covered_competencies"": [
        ""A"",
        ""B"",
        ""J""
      ]
    },
    {
      ""course_id"": ""S3"",
      ""covered_competencies"": [
        ""A"",
        ""C"",
        ""D"",
        ""F"",
        ""J""
      ]
    },
    {
      ""course_id"": ""S4"",
      ""covered_competencies"": [
        ""A"",
        ""C"",
        ""I""
      ]
    },
    {
      ""course_id"": ""S5"",
      ""covered_competencies"": [
        ""A"",
        ""H"",
        ""K""
      ]
    },
    {
      ""course_id"": ""S6"",
      ""covered_competencies"": [
        ""C"",
        ""F"",
        ""I""
      ]
    },
    {
      ""course_id"": ""S7"",
      ""covered_competencies"": [
        ""A"",
        ""E"",
        ""H"",
        ""K""
      ]
    },
    {
      ""course_id"": ""S8"",
      ""covered_competencies"": [
        ""A"",
        ""D"",
        ""F""
      ]
    },
    {
      ""course_id"": ""S9"",
      ""covered_competencies"": [
        ""A"",
        ""B"",
        ""G"",
        ""J"",
        ""K""
      ]
    },
    {
      ""course_id"": ""S10"",
      ""covered_competencies"": [
        ""A"",
        ""C"",
        ""J"",
        ""K""
      ]
    }
  ]
}

When you send back the final pick, it helps if you use a tiny JSON snippet like this so it's easy to read and plug into the next step.

{
  ""solution"": [""course_id"", ...]
}

This just means ""solution"" is a list (an array) of the course identifiers you picked — one string per chosen course. ""course_id"" in the example is a placeholder; replace each placeholder with the actual labels from the instance. The JSON above is just the expected shape, not the actual answer.

Important: use the exact course identifiers from the instance input — no renaming, and don’t invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 11, 'num_sets': 10, 'density': 0.37272727272727274, 'sets': [{'id': 1, 'elements': [1, 2, 3, 4, 5, 8, 10, 11]}, {'id': 2, 'elements': [1, 2, 10]}, {'id': 3, 'elements': [1, 3, 4, 6, 10]}, {'id': 4, 'elements': [1, 3, 9]}, {'id': 5, 'elements': [1, 8, 11]}, {'id': 6, 'elements': [3, 6, 9]}, {'id': 7, 'elements': [1, 5, 8, 11]}, {'id': 8, 'elements': [1, 4, 6]}, {'id': 9, 'elements': [1, 2, 7, 10, 11]}, {'id': 10, 'elements': [1, 3, 10, 11]}], 'graph': {'num_nodes': 11, 'edges': [{'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 7}, {'u': 9, 'v': 3}, {'u': 9, 'v': 6}, {'u': 4, 'v': 3}, {'u': 11, 'v': 1}, {'u': 11, 'v': 5}, {'u': 11, 'v': 8}, {'u': 1, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0027.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0027.png'}","[1, 6, 9]",3.0,"{'num_elements': 11, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'C', 'D', 'E', 'H', 'J', 'K']}, {'id': 'S2', 'elements': ['A', 'B', 'J']}, {'id': 'S3', 'elements': ['A', 'C', 'D', 'F', 'J']}, {'id': 'S4', 'elements': ['A', 'C', 'I']}, {'id': 'S5', 'elements': ['A', 'H', 'K']}, {'id': 'S6', 'elements': ['C', 'F', 'I']}, {'id': 'S7', 'elements': ['A', 'E', 'H', 'K']}, {'id': 'S8', 'elements': ['A', 'D', 'F']}, {'id': 'S9', 'elements': ['A', 'B', 'G', 'J', 'K']}, {'id': 'S10', 'elements': ['A', 'C', 'J', 'K']}]}","['S1', 'S6', 'S9']",28,json,names
SCP,SCP,"We’re working on thinning down the city’s bus schedule: choose a small set of routes that still make sure every neighborhood sees a bus. The point is to decide which routes to keep; a plan is judged by how many routes it keeps, so tally the chosen lines and aim for the lowest total. It’s important that every neighborhood is covered by at least one of the chosen routes and that each chosen route is only counted once, so no area gets skipped and repeats don’t improve the plan. The exact map and list of routes are shown below.

There are 10 neighborhoods to cover and 9 routes available to choose from.
Route S1 serves neighborhoods A B D.
Route S2 serves neighborhoods A B E F I J.
Route S3 serves neighborhoods B C.
Route S4 serves neighborhoods B D E F G.
Route S5 serves neighborhoods B D E F G I.
Route S6 serves neighborhoods A B D E G.
Route S7 serves neighborhoods E G.
Route S8 serves neighborhoods B F H I J.
Route S9 serves neighborhoods B C D E F I J.
Pick the fewest routes that together cover all 10 neighborhoods.

Also, when you send your proposed trimming plan back, please stick to this little JSON layout so it's easy to read and check:

{
  ""solution"": [""route_id"", ...]
}

This just means ""solution"" should be a list of route identifiers you want to keep — one entry per chosen route. Think of it like filling out a short form: put each route's exact ID in the list (and don't repeat the same route twice). The block above is just the expected shape of the reply, not the actual answer — it's a sketch to follow.

Please use the route IDs exactly as they appear 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 9, 'density': 0.45555555555555555, 'sets': [{'id': 1, 'elements': [1, 2, 4]}, {'id': 2, 'elements': [1, 2, 5, 6, 9, 10]}, {'id': 3, 'elements': [2, 3]}, {'id': 4, 'elements': [2, 4, 5, 6, 7]}, {'id': 5, 'elements': [2, 4, 5, 6, 7, 9]}, {'id': 6, 'elements': [1, 2, 4, 5, 7]}, {'id': 7, 'elements': [5, 7]}, {'id': 8, 'elements': [2, 6, 8, 9, 10]}, {'id': 9, 'elements': [2, 3, 4, 5, 6, 9, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 7, 'v': 4}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 5}, {'u': 10, 'v': 2}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 2, 'v': 8}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0028.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0028.png'}","[6, 8, 9]",3.0,"{'num_elements': 10, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'D']}, {'id': 'S2', 'elements': ['A', 'B', 'E', 'F', 'I', 'J']}, {'id': 'S3', 'elements': ['B', 'C']}, {'id': 'S4', 'elements': ['B', 'D', 'E', 'F', 'G']}, {'id': 'S5', 'elements': ['B', 'D', 'E', 'F', 'G', 'I']}, {'id': 'S6', 'elements': ['A', 'B', 'D', 'E', 'G']}, {'id': 'S7', 'elements': ['E', 'G']}, {'id': 'S8', 'elements': ['B', 'F', 'H', 'I', 'J']}, {'id': 'S9', 'elements': ['B', 'C', 'D', 'E', 'F', 'I', 'J']}]}","['S6', 'S8', 'S9']",29,nl,names
SCP,SCP,"Many people who run small online shops face the same question: which product bundles should be featured so every customer preference category is met? The decision is picking which bundles to show, and the nicer outcome is the one that meets all the preference categories while using the least number of bundles. Practically, that’s checked by counting chosen bundles — the lower the count, the better — and ensuring every preference category is represented at least once; repeating identical bundles doesn’t help. The detailed bundle and preference information is provided below.

{
  ""total_preferences"": 10,
  ""available_bundles_count"": 10,
  ""sets"": [
    {
      ""bundle_id"": ""S1"",
      ""covered_preferences"": [
        2,
        3,
        5,
        8,
        10
      ]
    },
    {
      ""bundle_id"": ""S2"",
      ""covered_preferences"": [
        2,
        5,
        6,
        8
      ]
    },
    {
      ""bundle_id"": ""S3"",
      ""covered_preferences"": [
        1,
        2,
        3
      ]
    },
    {
      ""bundle_id"": ""S4"",
      ""covered_preferences"": [
        4,
        7
      ]
    },
    {
      ""bundle_id"": ""S5"",
      ""covered_preferences"": [
        1,
        5,
        7,
        8,
        9,
        10
      ]
    },
    {
      ""bundle_id"": ""S6"",
      ""covered_preferences"": [
        2,
        8,
        10
      ]
    },
    {
      ""bundle_id"": ""S7"",
      ""covered_preferences"": [
        4,
        5,
        9
      ]
    },
    {
      ""bundle_id"": ""S8"",
      ""covered_preferences"": [
        1,
        5,
        10
      ]
    },
    {
      ""bundle_id"": ""S9"",
      ""covered_preferences"": [
        4,
        7,
        9
      ]
    },
    {
      ""bundle_id"": ""S10"",
      ""covered_preferences"": [
        1,
        5,
        6,
        8,
        10
      ]
    }
  ]
}

Oh, and when you’re ready to send back which bundles to feature, just use this simple JSON shape so I can read it easily:

{
  ""solution"": [""set_id"", ...]
}

Pretty straightforward: ""solution"" is an array where you list the chosen bundle ids (one id per bundle). Think of it like filling in a short form — replace ""set_id"" with the actual ids from the input, keep each id as-is, and don’t repeat the same id twice. This JSON is just a sketch of the shape I expect, not the final answer itself.

Please make sure all identifiers are 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 10, 'density': 0.37, 'sets': [{'id': 1, 'elements': [2, 3, 5, 8, 10]}, {'id': 2, 'elements': [2, 5, 6, 8]}, {'id': 3, 'elements': [1, 2, 3]}, {'id': 4, 'elements': [4, 7]}, {'id': 5, 'elements': [1, 5, 7, 8, 9, 10]}, {'id': 6, 'elements': [2, 8, 10]}, {'id': 7, 'elements': [4, 5, 9]}, {'id': 8, 'elements': [1, 5, 10]}, {'id': 9, 'elements': [4, 7, 9]}, {'id': 10, 'elements': [1, 5, 6, 8, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 6, 'v': 8}, {'u': 6, 'v': 10}, {'u': 8, 'v': 2}, {'u': 4, 'v': 9}, {'u': 5, 'v': 2}, {'u': 5, 'v': 7}, {'u': 7, 'v': 9}, {'u': 2, 'v': 1}, {'u': 2, 'v': 10}, {'u': 1, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0029.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0029.png'}","[3, 9, 10]",3.0,"{'num_elements': 10, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [2, 3, 5, 8, 10]}, {'id': 'S2', 'elements': [2, 5, 6, 8]}, {'id': 'S3', 'elements': [1, 2, 3]}, {'id': 'S4', 'elements': [4, 7]}, {'id': 'S5', 'elements': [1, 5, 7, 8, 9, 10]}, {'id': 'S6', 'elements': [2, 8, 10]}, {'id': 'S7', 'elements': [4, 5, 9]}, {'id': 'S8', 'elements': [1, 5, 10]}, {'id': 'S9', 'elements': [4, 7, 9]}, {'id': 'S10', 'elements': [1, 5, 6, 8, 10]}]}","['S3', 'S9', 'S10']",30,json,1
SCP,SCP,"Someone on the production crew has to build the cast list so that each character can be portrayed by someone on staff, but with as few hires as possible. The decision is which actors to pick; a superior decision is the one that achieves full coverage of the script with the smallest number of people. Measure how good a choice is by adding up the number of actors hired — lower is preferred — while ensuring every role has at least one capable actor and avoiding needless extras. The detailed role-and-actor options are shown below.

{
  ""num_roles"": 9,
  ""num_actor_candidates"": 9,
  ""sets"": [
    {
      ""actor_id"": ""S1"",
      ""roles_actor_can_play"": [
        ""C"",
        ""E""
      ]
    },
    {
      ""actor_id"": ""S2"",
      ""roles_actor_can_play"": [
        ""B"",
        ""E""
      ]
    },
    {
      ""actor_id"": ""S3"",
      ""roles_actor_can_play"": [
        ""C"",
        ""D"",
        ""E"",
        ""F""
      ]
    },
    {
      ""actor_id"": ""S4"",
      ""roles_actor_can_play"": [
        ""B"",
        ""C"",
        ""I""
      ]
    },
    {
      ""actor_id"": ""S5"",
      ""roles_actor_can_play"": [
        ""B"",
        ""C"",
        ""D"",
        ""F"",
        ""G"",
        ""H""
      ]
    },
    {
      ""actor_id"": ""S6"",
      ""roles_actor_can_play"": [
        ""A"",
        ""C"",
        ""E"",
        ""F""
      ]
    },
    {
      ""actor_id"": ""S7"",
      ""roles_actor_can_play"": [
        ""E"",
        ""G"",
        ""I""
      ]
    },
    {
      ""actor_id"": ""S8"",
      ""roles_actor_can_play"": [
        ""E"",
        ""G"",
        ""H"",
        ""I""
      ]
    },
    {
      ""actor_id"": ""S9"",
      ""roles_actor_can_play"": [
        ""E"",
        ""H"",
        ""I""
      ]
    }
  ]
}

If you want to hand me the final cast choice, you can just drop it in as a tiny JSON object like this:

{
  ""solution"": [""actor_id"", ...]
}

Here ""solution"" is the list of actor identifiers you're hiring — think of each entry as the exact name/ID from the cast options. This is just a template showing the shape I expect, not the actual cast list; replace the placeholder entries with the real IDs from the instance input.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 9, 'density': 0.38271604938271603, 'sets': [{'id': 1, 'elements': [3, 5]}, {'id': 2, 'elements': [2, 5]}, {'id': 3, 'elements': [3, 4, 5, 6]}, {'id': 4, 'elements': [2, 3, 9]}, {'id': 5, 'elements': [2, 3, 4, 6, 7, 8]}, {'id': 6, 'elements': [1, 3, 5, 6]}, {'id': 7, 'elements': [5, 7, 9]}, {'id': 8, 'elements': [5, 7, 8, 9]}, {'id': 9, 'elements': [5, 8, 9]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 4, 'v': 2}, {'u': 4, 'v': 5}, {'u': 6, 'v': 3}, {'u': 5, 'v': 3}, {'u': 5, 'v': 9}, {'u': 1, 'v': 3}, {'u': 8, 'v': 9}, {'u': 9, 'v': 7}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0030.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0030.png'}","[5, 6, 8]",3.0,"{'num_elements': 9, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': ['C', 'E']}, {'id': 'S2', 'elements': ['B', 'E']}, {'id': 'S3', 'elements': ['C', 'D', 'E', 'F']}, {'id': 'S4', 'elements': ['B', 'C', 'I']}, {'id': 'S5', 'elements': ['B', 'C', 'D', 'F', 'G', 'H']}, {'id': 'S6', 'elements': ['A', 'C', 'E', 'F']}, {'id': 'S7', 'elements': ['E', 'G', 'I']}, {'id': 'S8', 'elements': ['E', 'G', 'H', 'I']}, {'id': 'S9', 'elements': ['E', 'H', 'I']}]}","['S5', 'S6', 'S8']",31,json,names
SCP,SCP,"Many people in the lab study different things, so the coordinator needs to subscribe to a compact set of journals that together cover every topic; the better subscription plan is simply the one with the smaller total number of journals (just count them), and every topic must be present in at least one of the chosen journals — redundant overlap won’t reduce that total. The concrete details will be shown below.

There are 9 distinct research topics and 9 available journal titles:
The journal S1 covers D E F H I.
The journal S2 covers B D G.
The journal S3 covers C D E F.
The journal S4 covers A B C D E G H I.
The journal S5 covers A C D E F.
The journal S6 covers C E F G.
The journal S7 covers A B D F G I.
The journal S8 covers A D E.
The journal S9 covers A B D F G.
Select the smallest collection of journals that together include all 9 topics.

Oh, and when you send the picked journals back, just use this simple JSON layout so it's easy to parse:

{
  ""solution"": [""journal_id"", ...]
}

Here ""solution"" is the list of journals you choose for the subscription plan; each item is a journal identifier (keep it as the exact identifier from the instance). Think of this block like a little form: the array holds the labels of the journals you want. This is only a sketch of the expected shape, not the actual answer — fill it with the real identifiers from the problem.

Please make sure to use the identifiers exactly as they appear in the 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"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 9, 'num_sets': 9, 'density': 0.5308641975308642, 'sets': [{'id': 1, 'elements': [4, 5, 6, 8, 9]}, {'id': 2, 'elements': [2, 4, 7]}, {'id': 3, 'elements': [3, 4, 5, 6]}, {'id': 4, 'elements': [1, 2, 3, 4, 5, 7, 8, 9]}, {'id': 5, 'elements': [1, 3, 4, 5, 6]}, {'id': 6, 'elements': [3, 5, 6, 7]}, {'id': 7, 'elements': [1, 2, 4, 6, 7, 9]}, {'id': 8, 'elements': [1, 4, 5]}, {'id': 9, 'elements': [1, 2, 4, 6, 7]}], 'graph': {'num_nodes': 9, 'edges': [{'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 8, 'v': 6}, {'u': 9, 'v': 2}, {'u': 9, 'v': 4}, {'u': 9, 'v': 7}, {'u': 3, 'v': 4}, {'u': 4, 'v': 6}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0031.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0031.png'}","[4, 7]",2.0,"{'num_elements': 9, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': ['D', 'E', 'F', 'H', 'I']}, {'id': 'S2', 'elements': ['B', 'D', 'G']}, {'id': 'S3', 'elements': ['C', 'D', 'E', 'F']}, {'id': 'S4', 'elements': ['A', 'B', 'C', 'D', 'E', 'G', 'H', 'I']}, {'id': 'S5', 'elements': ['A', 'C', 'D', 'E', 'F']}, {'id': 'S6', 'elements': ['C', 'E', 'F', 'G']}, {'id': 'S7', 'elements': ['A', 'B', 'D', 'F', 'G', 'I']}, {'id': 'S8', 'elements': ['A', 'D', 'E']}, {'id': 'S9', 'elements': ['A', 'B', 'D', 'F', 'G']}]}","['S4', 'S7']",32,nl,names
SCP,SCP,"There’s a park with a bunch of zones and a toolbox of sensors that each watch certain areas; the manager’s job is to pick just enough of those sensors so that every single zone gets watched by at least one chosen unit. A plan is better when it uses fewer sensors, confirmed simply by tallying the devices picked. No zone can be left out, and extra overlaps aren’t helpful unless they fill uncovered spots. Concrete details follow below.

# num_zones=10
# num_sensors=10
sensor_id,covered_zones
S1,A I
S2,C D F H
S3,B C F G H
S4,B D E F I
S5,D I J
S6,B C D E F H
S7,C G
S8,C F H
S9,A D E I J
S10,E I J

Also, when you send back the plan, just drop it into a tiny JSON snippet so it's easy to read and parse. Something like this will do:

{
  ""solution"": [""sensor_id"", ...]
}

Here ""solution"" is the list of chosen sensors (one entry per sensor). Think of it like a little form: put each sensor's exact label in that array and you're done. This is just the expected shape of the reply, not the actual answer — fill it with the real identifiers from the instance when you submit.

Please 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"".""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 10, 'density': 0.38, 'sets': [{'id': 1, 'elements': [1, 9]}, {'id': 2, 'elements': [3, 4, 6, 8]}, {'id': 3, 'elements': [2, 3, 6, 7, 8]}, {'id': 4, 'elements': [2, 4, 5, 6, 9]}, {'id': 5, 'elements': [4, 9, 10]}, {'id': 6, 'elements': [2, 3, 4, 5, 6, 8]}, {'id': 7, 'elements': [3, 7]}, {'id': 8, 'elements': [3, 6, 8]}, {'id': 9, 'elements': [1, 4, 5, 9, 10]}, {'id': 10, 'elements': [5, 9, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 10, 'v': 9}, {'u': 2, 'v': 3}, {'u': 2, 'v': 6}, {'u': 2, 'v': 8}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 3, 'v': 7}, {'u': 5, 'v': 1}, {'u': 5, 'v': 9}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0032.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0032.png'}","[3, 9]",2.0,"{'num_elements': 10, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': ['A', 'I']}, {'id': 'S2', 'elements': ['C', 'D', 'F', 'H']}, {'id': 'S3', 'elements': ['B', 'C', 'F', 'G', 'H']}, {'id': 'S4', 'elements': ['B', 'D', 'E', 'F', 'I']}, {'id': 'S5', 'elements': ['D', 'I', 'J']}, {'id': 'S6', 'elements': ['B', 'C', 'D', 'E', 'F', 'H']}, {'id': 'S7', 'elements': ['C', 'G']}, {'id': 'S8', 'elements': ['C', 'F', 'H']}, {'id': 'S9', 'elements': ['A', 'D', 'E', 'I', 'J']}, {'id': 'S10', 'elements': ['E', 'I', 'J']}]}","['S3', 'S9']",33,csv,names
SCP,SCP,"Recently the department decided to streamline assessment materials: each question bank covers several learning objectives, and the assignment is to choose the smallest handful of banks that together cover every objective. The decision is which handful to use, and the quality of a choice is judged by how small that handful is — tally the number of banks chosen to compare options. Make sure every objective is covered by at least one chosen bank; overlaps don’t harm coverage but don’t reduce the tally either. The specific instance details are shown below.

{
  ""total_objectives"": 8,
  ""total_banks"": 8,
  ""sets"": [
    {
      ""bank_id"": ""S1"",
      ""objectives_in_bank"": [
        1,
        3,
        5,
        6,
        7,
        8
      ]
    },
    {
      ""bank_id"": ""S2"",
      ""objectives_in_bank"": [
        3,
        4,
        6
      ]
    },
    {
      ""bank_id"": ""S3"",
      ""objectives_in_bank"": [
        1,
        2,
        3,
        4,
        5
      ]
    },
    {
      ""bank_id"": ""S4"",
      ""objectives_in_bank"": [
        2,
        3,
        4,
        5,
        6
      ]
    },
    {
      ""bank_id"": ""S5"",
      ""objectives_in_bank"": [
        2,
        4,
        6
      ]
    },
    {
      ""bank_id"": ""S6"",
      ""objectives_in_bank"": [
        1,
        2,
        3,
        4,
        5,
        7
      ]
    },
    {
      ""bank_id"": ""S7"",
      ""objectives_in_bank"": [
        1,
        3
      ]
    },
    {
      ""bank_id"": ""S8"",
      ""objectives_in_bank"": [
        1,
        3,
        8
      ]
    }
  ]
}

Also, when you send back which banks you picked, keep it simple and use this little JSON layout — just a casual form so it's easy to parse.

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

This just means ""solution"" should be an array listing the banks you choose. The placeholder ""bank_id"" stands in for whatever actual bank identifiers appear in the instance; replace those placeholders with the real IDs when you give the answer. Think of this JSON as a sketch of the shape I want, not the final content.

Make sure every identifier you use matches the instance input exactly — no renaming and no made-up labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 8, 'density': 0.515625, 'sets': [{'id': 1, 'elements': [1, 3, 5, 6, 7, 8]}, {'id': 2, 'elements': [3, 4, 6]}, {'id': 3, 'elements': [1, 2, 3, 4, 5]}, {'id': 4, 'elements': [2, 3, 4, 5, 6]}, {'id': 5, 'elements': [2, 4, 6]}, {'id': 6, 'elements': [1, 2, 3, 4, 5, 7]}, {'id': 7, 'elements': [1, 3]}, {'id': 8, 'elements': [1, 3, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 1, 'v': 3}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 3, 'v': 5}, {'u': 3, 'v': 8}, {'u': 5, 'v': 2}, {'u': 5, 'v': 4}, {'u': 4, 'v': 2}, {'u': 2, 'v': 6}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0033.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0033.png'}","[1, 6]",2.0,"{'num_elements': 8, 'num_sets': 8, 'sets': [{'id': 'S1', 'elements': [1, 3, 5, 6, 7, 8]}, {'id': 'S2', 'elements': [3, 4, 6]}, {'id': 'S3', 'elements': [1, 2, 3, 4, 5]}, {'id': 'S4', 'elements': [2, 3, 4, 5, 6]}, {'id': 'S5', 'elements': [2, 4, 6]}, {'id': 'S6', 'elements': [1, 2, 3, 4, 5, 7]}, {'id': 'S7', 'elements': [1, 3]}, {'id': 'S8', 'elements': [1, 3, 8]}]}","['S1', 'S6']",34,json,1
SCP,SCP,"Recently the warehouse team had to revamp how containers are used: there are many item categories and a number of container types, and the job was to pick a compact set of containers that will accommodate every category. The choice is judged by how few different container types are chosen — success is a lower tally of distinct types — while guaranteeing every single item category fits into at least one of the chosen containers; nothing can be left out, and counting duplicates doesn’t help. The exact options and categories are listed below.

{
  ""num_item_categories"": 8,
  ""num_container_types"": 7,
  ""sets"": [
    {
      ""container_type_id"": ""S1"",
      ""covered_item_categories"": [
        ""A"",
        ""C"",
        ""D"",
        ""E"",
        ""F"",
        ""H""
      ]
    },
    {
      ""container_type_id"": ""S2"",
      ""covered_item_categories"": [
        ""A"",
        ""B"",
        ""C"",
        ""D"",
        ""G""
      ]
    },
    {
      ""container_type_id"": ""S3"",
      ""covered_item_categories"": [
        ""A"",
        ""E"",
        ""F""
      ]
    },
    {
      ""container_type_id"": ""S4"",
      ""covered_item_categories"": [
        ""A"",
        ""B"",
        ""C"",
        ""D"",
        ""E"",
        ""F"",
        ""H""
      ]
    },
    {
      ""container_type_id"": ""S5"",
      ""covered_item_categories"": [
        ""A"",
        ""B"",
        ""C"",
        ""D"",
        ""E"",
        ""G"",
        ""H""
      ]
    },
    {
      ""container_type_id"": ""S6"",
      ""covered_item_categories"": [
        ""A"",
        ""C"",
        ""D"",
        ""F"",
        ""H""
      ]
    },
    {
      ""container_type_id"": ""S7"",
      ""covered_item_categories"": [
        ""B"",
        ""D"",
        ""E"",
        ""G""
      ]
    }
  ]
}

Also, when you send me the final selection, please use this little JSON layout so it’s easy to read and plug into the system:

{
  ""solution"": [""container_id"", ...]
}

Here ""solution"" is just the list of container types you’re picking — each item in the array should be the exact id of a chosen container type from the instance. Think of it like filling out a short form: drop the container ids into the array. This JSON is only a sketch of the expected shape, not the actual answer.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".""

That’s it — just paste the chosen ids into the array and we’ll be good to go.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.6607142857142857, 'sets': [{'id': 1, 'elements': [1, 3, 4, 5, 6, 8]}, {'id': 2, 'elements': [1, 2, 3, 4, 7]}, {'id': 3, 'elements': [1, 5, 6]}, {'id': 4, 'elements': [1, 2, 3, 4, 5, 6, 8]}, {'id': 5, 'elements': [1, 2, 3, 4, 5, 7, 8]}, {'id': 6, 'elements': [1, 3, 4, 6, 8]}, {'id': 7, 'elements': [2, 4, 5, 7]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 1, 'v': 4}, {'u': 1, 'v': 6}, {'u': 1, 'v': 8}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 7}, {'u': 3, 'v': 5}, {'u': 3, 'v': 8}, {'u': 4, 'v': 5}, {'u': 8, 'v': 6}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0034.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0034.png'}","[4, 5]",2.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'D', 'E', 'F', 'H']}, {'id': 'S2', 'elements': ['A', 'B', 'C', 'D', 'G']}, {'id': 'S3', 'elements': ['A', 'E', 'F']}, {'id': 'S4', 'elements': ['A', 'B', 'C', 'D', 'E', 'F', 'H']}, {'id': 'S5', 'elements': ['A', 'B', 'C', 'D', 'E', 'G', 'H']}, {'id': 'S6', 'elements': ['A', 'C', 'D', 'F', 'H']}, {'id': 'S7', 'elements': ['B', 'D', 'E', 'G']}]}","['S4', 'S5']",35,json,names
SCP,SCP,"Recently the park committee realized they don’t need a huge crew — just a carefully chosen group of volunteers so every task-skill is accounted for. The smartest picks are the fewest volunteers whose combined abilities cover everything on the checklist; you can tell by tallying how many volunteers were selected. Nothing on the skill checklist can be skipped, and though a skill can show up more than once, duplicates don’t reduce the team size. The concrete lineup and skills are shown below.

- **total_skills_required**: 11
- **total_available_volunteers**: 10

| volunteer_id | volunteer_skills |
|---|---|
| S1 | 1 9 10 |
| S2 | 3 7 10 11 |
| S3 | 2 3 |
| S4 | 7 10 |
| S5 | 6 8 |
| S6 | 2 4 7 10 |
| S7 | 4 6 7 8 10 |
| S8 | 1 2 7 9 11 |
| S9 | 1 3 7 9 11 |
| S10 | 1 2 3 5 10 11 |

Oh, and when you send the picked team back, please use this simple JSON shape so it’s easy to read by whatever’s checking it:

{
  ""solution"": [""volunteer_id"", ...]
}

Here ""solution"" is just the list of volunteer IDs you picked to cover all the tasks — think of it as the names on the sign-up sheet. This is only a sketch of the shape I want, not the actual answer; replace the placeholder(s) with the real IDs from the instance.

Please use the identifiers exactly as they appear in the instance input — don’t rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 11, 'num_sets': 10, 'density': 0.34545454545454546, 'sets': [{'id': 1, 'elements': [1, 9, 10]}, {'id': 2, 'elements': [3, 7, 10, 11]}, {'id': 3, 'elements': [2, 3]}, {'id': 4, 'elements': [7, 10]}, {'id': 5, 'elements': [6, 8]}, {'id': 6, 'elements': [2, 4, 7, 10]}, {'id': 7, 'elements': [4, 6, 7, 8, 10]}, {'id': 8, 'elements': [1, 2, 7, 9, 11]}, {'id': 9, 'elements': [1, 3, 7, 9, 11]}, {'id': 10, 'elements': [1, 2, 3, 5, 10, 11]}], 'graph': {'num_nodes': 11, 'edges': [{'u': 2, 'v': 3}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 4, 'v': 7}, {'u': 9, 'v': 1}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 10, 'v': 7}, {'u': 7, 'v': 8}, {'u': 8, 'v': 6}, {'u': 11, 'v': 5}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0035.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0035.png'}","[7, 9, 10]",3.0,"{'num_elements': 11, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [1, 9, 10]}, {'id': 'S2', 'elements': [3, 7, 10, 11]}, {'id': 'S3', 'elements': [2, 3]}, {'id': 'S4', 'elements': [7, 10]}, {'id': 'S5', 'elements': [6, 8]}, {'id': 'S6', 'elements': [2, 4, 7, 10]}, {'id': 'S7', 'elements': [4, 6, 7, 8, 10]}, {'id': 'S8', 'elements': [1, 2, 7, 9, 11]}, {'id': 'S9', 'elements': [1, 3, 7, 9, 11]}, {'id': 'S10', 'elements': [1, 2, 3, 5, 10, 11]}]}","['S7', 'S9', 'S10']",36,markdown_table,1
SCP,SCP,"We’ve got a pile of master and sub-keys and a lineup of servers, printers, and appliances; someone needs to decide which keys to keep in the secure drawer. The aim is to keep the smallest possible set of keys that still lets at least one chosen key open every single system. Plans are judged by counting how many keys they include — fewer keys is better — while making sure no system is left unreachable and avoiding unnecessary duplicate coverage. The concrete details are listed below.

# num_systems=8
# num_keys_available=7
key_id,accessible_systems
S1,0 1 4 5 6 7
S2,1 4 5 7
S3,0 2 5
S4,0 1 3 5
S5,0 1 2 4 5 6 7
S6,0 6 7
S7,0 2 4 5 6 7

Oh — and when you send back the plan, stick to a tiny JSON outline like this so it's easy to read and automatic tools can pick it up:

{
  ""solution"": [""key_id"", ...]
}

""solution"" is the list of keys you'll keep in the secure drawer; each ""key_id"" is just a placeholder for one of the actual key identifiers from the instance. This is only a sketch of the shape I want, not the filled-in answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.5892857142857143, 'sets': [{'id': 1, 'elements': [1, 2, 5, 6, 7, 8]}, {'id': 2, 'elements': [2, 5, 6, 8]}, {'id': 3, 'elements': [1, 3, 6]}, {'id': 4, 'elements': [1, 2, 4, 6]}, {'id': 5, 'elements': [1, 2, 3, 5, 6, 7, 8]}, {'id': 6, 'elements': [1, 7, 8]}, {'id': 7, 'elements': [1, 3, 5, 6, 7, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 4, 'v': 5}, {'u': 3, 'v': 8}, {'u': 8, 'v': 1}, {'u': 8, 'v': 6}, {'u': 5, 'v': 6}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 2, 'v': 6}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0036.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0036.png'}","[4, 5]",2.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': [0, 1, 4, 5, 6, 7]}, {'id': 'S2', 'elements': [1, 4, 5, 7]}, {'id': 'S3', 'elements': [0, 2, 5]}, {'id': 'S4', 'elements': [0, 1, 3, 5]}, {'id': 'S5', 'elements': [0, 1, 2, 4, 5, 6, 7]}, {'id': 'S6', 'elements': [0, 6, 7]}, {'id': 'S7', 'elements': [0, 2, 4, 5, 6, 7]}]}","['S4', 'S5']",37,csv,0
SCP,SCP,"Many people on the gardening committee prefer tidy beds, so the gardener’s brief was simple: use the smallest number of plant varieties that still entice every target pollinator species. A plan is better when it contains fewer distinct varieties; you measure that by tallying the varieties selected. It’s mandatory that each pollinator on the list finds at least one attractive plant among the picks, and duplicates don’t add anything useful. The specific lists are shown below.

# num_pollinators=10
# num_varieties_available=9
plant_variety_id,attractive_pollinators
S1,0 1 3 5
S2,0 1 4 6
S3,2 4 5 7
S4,1 2 4 5 6 7
S5,2 5 8 9
S6,1 5 6 8
S7,2 4 9
S8,5 6 8
S9,4 7 9

If you want to hand me the final picks in a tidy way, just use a tiny JSON snippet like this — nothing fancy, just a list of the variety identifiers you choose.

{
  ""solution"": [""variety_id"", ...]
}

""solution"" is simply the list of plant varieties to plant (one entry per variety). Treat each array item as the exact identifier for a variety from the instance input — this JSON is just a sketch of the shape I expect, not the actual answer.

Please be sure to use the identifiers exactly as they appear in the 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 9, 'density': 0.3888888888888889, 'sets': [{'id': 1, 'elements': [1, 2, 4, 6]}, {'id': 2, 'elements': [1, 2, 5, 7]}, {'id': 3, 'elements': [3, 5, 6, 8]}, {'id': 4, 'elements': [2, 3, 5, 6, 7, 8]}, {'id': 5, 'elements': [3, 6, 9, 10]}, {'id': 6, 'elements': [2, 6, 7, 9]}, {'id': 7, 'elements': [3, 5, 10]}, {'id': 8, 'elements': [6, 7, 9]}, {'id': 9, 'elements': [5, 8, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 10}, {'u': 6, 'v': 2}, {'u': 6, 'v': 7}, {'u': 7, 'v': 9}, {'u': 10, 'v': 8}, {'u': 8, 'v': 3}, {'u': 2, 'v': 1}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0037.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0037.png'}","[1, 4, 5]",3.0,"{'num_elements': 10, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': [0, 1, 3, 5]}, {'id': 'S2', 'elements': [0, 1, 4, 6]}, {'id': 'S3', 'elements': [2, 4, 5, 7]}, {'id': 'S4', 'elements': [1, 2, 4, 5, 6, 7]}, {'id': 'S5', 'elements': [2, 5, 8, 9]}, {'id': 'S6', 'elements': [1, 5, 6, 8]}, {'id': 'S7', 'elements': [2, 4, 9]}, {'id': 'S8', 'elements': [5, 6, 8]}, {'id': 'S9', 'elements': [4, 7, 9]}]}","['S1', 'S4', 'S5']",38,csv,0
SCP,SCP,"We were prepping the house for a deep-clean weekend and needed to decide which cleaning kits to put in each area so every room had cleaning supplies on hand. The idea was to keep the number of distinct kits to a minimum (just count the kits chosen) while ensuring every room shows up in at least one kit’s coverage and nothing gets left out or redundantly repeated. The concrete details will be shown below.

We listed 9 available kits and 10 rooms below.
Kit S1 covers 5 8 10.
Kit S2 covers 1 5 6 9 10.
Kit S3 covers 2 3 4.
Kit S4 covers 3 4 7.
Kit S5 covers 1 5 6 7 9.
Kit S6 covers 5 6 9.
Kit S7 covers 2 3 5 7.
Kit S8 covers 2 8.
Kit S9 covers 1 2 8 10.
We'll try to pick as few kits as possible so all 10 rooms are covered.

Also, when you send back which kits you're actually choosing, please use this simple JSON shape so it's easy to read and plug into the checklist:

{
  ""solution"": [""kit_id"", ...]
}

Pretty straightforward: ""solution"" is the list of kit identifiers you'll pick to place around the house, and ""kit_id"" is just a placeholder for each kit's identifier (like the label the instance uses). This is just a sketch of the shape I want — not the final answer.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 9, 'density': 0.35555555555555557, 'sets': [{'id': 1, 'elements': [5, 8, 10]}, {'id': 2, 'elements': [1, 5, 6, 9, 10]}, {'id': 3, 'elements': [2, 3, 4]}, {'id': 4, 'elements': [3, 4, 7]}, {'id': 5, 'elements': [1, 5, 6, 7, 9]}, {'id': 6, 'elements': [5, 6, 9]}, {'id': 7, 'elements': [2, 3, 5, 7]}, {'id': 8, 'elements': [2, 8]}, {'id': 9, 'elements': [1, 2, 8, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 6, 'v': 5}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 1, 'v': 2}, {'u': 1, 'v': 8}, {'u': 1, 'v': 10}, {'u': 2, 'v': 5}, {'u': 5, 'v': 9}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0038.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0038.png'}","[4, 5, 9]",3.0,"{'num_elements': 10, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': [5, 8, 10]}, {'id': 'S2', 'elements': [1, 5, 6, 9, 10]}, {'id': 'S3', 'elements': [2, 3, 4]}, {'id': 'S4', 'elements': [3, 4, 7]}, {'id': 'S5', 'elements': [1, 5, 6, 7, 9]}, {'id': 'S6', 'elements': [5, 6, 9]}, {'id': 'S7', 'elements': [2, 3, 5, 7]}, {'id': 'S8', 'elements': [2, 8]}, {'id': 'S9', 'elements': [1, 2, 8, 10]}]}","['S4', 'S5', 'S9']",39,nl,1
SCP,SCP,"Recently the school decided to streamline extracurriculars: the teacher’s job is to pick a minimal set of clubs so every student sees at least one of their interests on the schedule. The success check is straightforward — add up how many clubs were picked; fewer clubs means a tighter plan — and be careful not to leave anyone without a match or to add clubs only for duplicate coverage. The detailed list of students and club choices follows below.

There are 12 students and 11 clubs to consider.
Club S1 covers students A D H I.
Club S2 covers students B E I.
Club S3 covers students A B C D E F G H I J K.
Club S4 covers students A C D F I J.
Club S5 covers students B C E K.
Club S6 covers students C D F.
Club S7 covers students A C.
Club S8 covers students A D E I J.
Club S9 covers students D G I J.
Club S10 covers students B C E I K.
Club S11 covers students J L.
The teacher should pick as few clubs as possible from the 11 available so all 12 students are covered.

Also, when you send back the picks, please stick to this simple JSON shape — just a friendly way for me to read the list:

{
  ""solution"": [""club_id"", ...]
}

""solution"" is where you list the clubs the teacher should pick; the entries like ""club_id"" are just placeholders for the actual club identifiers from the instance (so replace them with the real IDs, not new labels). This block is only a sketch of the expected shape, not the actual answer itself — think of it like a little form you fill out.

Make sure to use the identifiers exactly as they appear in the instance input — no renaming and no inventing 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”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 11, 'density': 0.3712121212121212, 'sets': [{'id': 1, 'elements': [1, 4, 8, 9]}, {'id': 2, 'elements': [2, 5, 9]}, {'id': 3, 'elements': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}, {'id': 4, 'elements': [1, 3, 4, 6, 9, 10]}, {'id': 5, 'elements': [2, 3, 5, 11]}, {'id': 6, 'elements': [3, 4, 6]}, {'id': 7, 'elements': [1, 3]}, {'id': 8, 'elements': [1, 4, 5, 9, 10]}, {'id': 9, 'elements': [4, 7, 9, 10]}, {'id': 10, 'elements': [2, 3, 5, 9, 11]}, {'id': 11, 'elements': [10, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 12, 'v': 7}, {'u': 7, 'v': 10}, {'u': 4, 'v': 3}, {'u': 4, 'v': 6}, {'u': 1, 'v': 3}, {'u': 1, 'v': 8}, {'u': 11, 'v': 9}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 9, 'v': 2}, {'u': 9, 'v': 5}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0039.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0039.png'}","[3, 11]",2.0,"{'num_elements': 12, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'H', 'I']}, {'id': 'S2', 'elements': ['B', 'E', 'I']}, {'id': 'S3', 'elements': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']}, {'id': 'S4', 'elements': ['A', 'C', 'D', 'F', 'I', 'J']}, {'id': 'S5', 'elements': ['B', 'C', 'E', 'K']}, {'id': 'S6', 'elements': ['C', 'D', 'F']}, {'id': 'S7', 'elements': ['A', 'C']}, {'id': 'S8', 'elements': ['A', 'D', 'E', 'I', 'J']}, {'id': 'S9', 'elements': ['D', 'G', 'I', 'J']}, {'id': 'S10', 'elements': ['B', 'C', 'E', 'I', 'K']}, {'id': 'S11', 'elements': ['J', 'L']}]}","['S3', 'S11']",40,nl,names
SCP,SCP,"We’ve got a storefront full of different display units and a bunch of product categories that need shelf space; the task is to choose only the stands that together show every category. The measure of success is straightforward: add up the stands picked and try to keep that total as low as possible, as long as every category appears at least once. Every category must be represented among the selected stands, and picking extra stands that don’t add new categories is wasteful. The concrete details — which stands have which categories — are given below.

{
  ""total_categories"": 10,
  ""total_display_stands"": 10,
  ""sets"": [
    {
      ""stand_id"": ""S1"",
      ""categories_on_stand"": [
        ""A"",
        ""B"",
        ""G"",
        ""I""
      ]
    },
    {
      ""stand_id"": ""S2"",
      ""categories_on_stand"": [
        ""A"",
        ""B"",
        ""D"",
        ""F"",
        ""G"",
        ""I"",
        ""J""
      ]
    },
    {
      ""stand_id"": ""S3"",
      ""categories_on_stand"": [
        ""D"",
        ""E"",
        ""F"",
        ""J""
      ]
    },
    {
      ""stand_id"": ""S4"",
      ""categories_on_stand"": [
        ""C"",
        ""F"",
        ""J""
      ]
    },
    {
      ""stand_id"": ""S5"",
      ""categories_on_stand"": [
        ""C"",
        ""E""
      ]
    },
    {
      ""stand_id"": ""S6"",
      ""categories_on_stand"": [
        ""B"",
        ""D"",
        ""F"",
        ""J""
      ]
    },
    {
      ""stand_id"": ""S7"",
      ""categories_on_stand"": [
        ""B"",
        ""G"",
        ""H"",
        ""I""
      ]
    },
    {
      ""stand_id"": ""S8"",
      ""categories_on_stand"": [
        ""A"",
        ""H""
      ]
    },
    {
      ""stand_id"": ""S9"",
      ""categories_on_stand"": [
        ""A"",
        ""B"",
        ""H""
      ]
    },
    {
      ""stand_id"": ""S10"",
      ""categories_on_stand"": [
        ""B"",
        ""D"",
        ""E"",
        ""H"",
        ""J""
      ]
    }
  ]
}

Also, when you send back the chosen stands, please use a tiny JSON object in this shape so it’s easy to check and parse:

{
  ""solution"": [""stand_id""]
}

Think of ""solution"" as the list of stand IDs you pick to cover every product category — each entry is one stand’s identifier. This JSON is just a sketch of the expected shape, not the actual answer, so fill the array with the exact stand IDs from the instance when you submit.

Please use the identifiers exactly as they appear in the instance input — no renaming, no made-up labels. 
- for example: ""1"", ""23"", ""A"", ""B"", ""A1"", ""X7""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 10, 'density': 0.38, 'sets': [{'id': 1, 'elements': [1, 2, 7, 9]}, {'id': 2, 'elements': [1, 2, 4, 6, 7, 9, 10]}, {'id': 3, 'elements': [4, 5, 6, 10]}, {'id': 4, 'elements': [3, 6, 10]}, {'id': 5, 'elements': [3, 5]}, {'id': 6, 'elements': [2, 4, 6, 10]}, {'id': 7, 'elements': [2, 7, 8, 9]}, {'id': 8, 'elements': [1, 8]}, {'id': 9, 'elements': [1, 2, 8]}, {'id': 10, 'elements': [2, 4, 5, 8, 10]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 1, 'v': 8}, {'u': 8, 'v': 2}, {'u': 8, 'v': 7}, {'u': 8, 'v': 9}, {'u': 2, 'v': 10}, {'u': 5, 'v': 3}, {'u': 3, 'v': 10}, {'u': 4, 'v': 10}, {'u': 6, 'v': 10}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0040.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0040.png'}","[2, 5, 9]",3.0,"{'num_elements': 10, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'G', 'I']}, {'id': 'S2', 'elements': ['A', 'B', 'D', 'F', 'G', 'I', 'J']}, {'id': 'S3', 'elements': ['D', 'E', 'F', 'J']}, {'id': 'S4', 'elements': ['C', 'F', 'J']}, {'id': 'S5', 'elements': ['C', 'E']}, {'id': 'S6', 'elements': ['B', 'D', 'F', 'J']}, {'id': 'S7', 'elements': ['B', 'G', 'H', 'I']}, {'id': 'S8', 'elements': ['A', 'H']}, {'id': 'S9', 'elements': ['A', 'B', 'H']}, {'id': 'S10', 'elements': ['B', 'D', 'E', 'H', 'J']}]}","['S2', 'S5', 'S9']",41,json,names
SCP,SCP,"There’s a charity brunch coming up and the challenge is selecting caterers so every dietary request is met without hiring a bunch of them. The goal is simple: keep the number of caterers as small as possible (count them up to see how many), but only if every dietary need shows up in the menus of the caterers that are actually hired. Every requirement needs at least one match among the chosen vendors, and leaving anything out is not allowed — the full list of needs and what each caterer offers appears below.

{
  ""num_dietary_requirements"": 11,
  ""num_caterers_available"": 11,
  ""sets"": [
    {
      ""caterer_id"": ""S1"",
      ""offered_requirements"": [
        1,
        2,
        6,
        7,
        8,
        9
      ]
    },
    {
      ""caterer_id"": ""S2"",
      ""offered_requirements"": [
        1,
        2,
        7
      ]
    },
    {
      ""caterer_id"": ""S3"",
      ""offered_requirements"": [
        3,
        4,
        6,
        7,
        8,
        9,
        10
      ]
    },
    {
      ""caterer_id"": ""S4"",
      ""offered_requirements"": [
        3,
        4,
        6,
        11
      ]
    },
    {
      ""caterer_id"": ""S5"",
      ""offered_requirements"": [
        1,
        3,
        5,
        8,
        10,
        11
      ]
    },
    {
      ""caterer_id"": ""S6"",
      ""offered_requirements"": [
        1,
        3,
        4,
        5,
        8,
        11
      ]
    },
    {
      ""caterer_id"": ""S7"",
      ""offered_requirements"": [
        1,
        2,
        9
      ]
    },
    {
      ""caterer_id"": ""S8"",
      ""offered_requirements"": [
        1,
        5,
        8
      ]
    },
    {
      ""caterer_id"": ""S9"",
      ""offered_requirements"": [
        1,
        3,
        7
      ]
    },
    {
      ""caterer_id"": ""S10"",
      ""offered_requirements"": [
        5,
        11
      ]
    },
    {
      ""caterer_id"": ""S11"",
      ""offered_requirements"": [
        3,
        4,
        5,
        6,
        10
      ]
    }
  ]
}

If you want to hand me the picks in a simple, machine-friendly way, just follow this little JSON layout — nothing fancy, just a list of the caterers you picked.

{
  ""solution"": [""caterer_id"", ...]
}

Think of ""solution"" as the form field that holds the chosen caterer IDs. Each entry in the array should be one of the caterer identifiers from the instance (so I know exactly who you hired). This JSON is just a sketch of the shape I expect, not the actual answer — fill in the real IDs when you're ready.

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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 11, 'num_sets': 11, 'density': 0.39669421487603307, 'sets': [{'id': 1, 'elements': [1, 2, 6, 7, 8, 9]}, {'id': 2, 'elements': [1, 2, 7]}, {'id': 3, 'elements': [3, 4, 6, 7, 8, 9, 10]}, {'id': 4, 'elements': [3, 4, 6, 11]}, {'id': 5, 'elements': [1, 3, 5, 8, 10, 11]}, {'id': 6, 'elements': [1, 3, 4, 5, 8, 11]}, {'id': 7, 'elements': [1, 2, 9]}, {'id': 8, 'elements': [1, 5, 8]}, {'id': 9, 'elements': [1, 3, 7]}, {'id': 10, 'elements': [5, 11]}, {'id': 11, 'elements': [3, 4, 5, 6, 10]}], 'graph': {'num_nodes': 11, 'edges': [{'u': 4, 'v': 6}, {'u': 3, 'v': 1}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 8}, {'u': 10, 'v': 5}, {'u': 11, 'v': 5}, {'u': 11, 'v': 6}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 1, 'v': 9}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0041.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0041.png'}","[1, 6, 11]",3.0,"{'num_elements': 11, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [1, 2, 6, 7, 8, 9]}, {'id': 'S2', 'elements': [1, 2, 7]}, {'id': 'S3', 'elements': [3, 4, 6, 7, 8, 9, 10]}, {'id': 'S4', 'elements': [3, 4, 6, 11]}, {'id': 'S5', 'elements': [1, 3, 5, 8, 10, 11]}, {'id': 'S6', 'elements': [1, 3, 4, 5, 8, 11]}, {'id': 'S7', 'elements': [1, 2, 9]}, {'id': 'S8', 'elements': [1, 5, 8]}, {'id': 'S9', 'elements': [1, 3, 7]}, {'id': 'S10', 'elements': [5, 11]}, {'id': 'S11', 'elements': [3, 4, 5, 6, 10]}]}","['S1', 'S6', 'S11']",42,json,1
SCP,SCP,"Recently the maintenance supervisor was asked to cut costs by trimming outside contractors, but without sacrificing repair coverage. The task is to pick a minimal number of contractor teams such that, between them, they can fix every machine type on site. The way to tell which selection is preferred is straightforward: count how many teams are hired — the smaller that number, the better — while ensuring every machine type is covered at least once and not paying for extra teams that add no new capabilities. The specific instance details are below.

There are 12 machine types to keep serviceable and 12 contractor teams available.
Contractor team S1 can repair 0 4.
Contractor team S2 can repair 1 9 10.
Contractor team S3 can repair 3 6 7 8 9.
Contractor team S4 can repair 4 8 9.
Contractor team S5 can repair 0 2 3 4 7 8.
Contractor team S6 can repair 6 9 11.
Contractor team S7 can repair 2 6 8 9 11.
Contractor team S8 can repair 2 4 7 8.
Contractor team S9 can repair 0 2 6 7 8 11.
Contractor team S10 can repair 2 3 5 6 9 11.
Contractor team S11 can repair 1 10 11.
Contractor team S12 can repair 1 3 5 6 8 9 10.
The supervisor's objective is to hire the fewest teams that together cover all 12 machine types from these 12 candidates.

When you're ready, just send the result in a tiny JSON like this so it's easy to parse:

{
  ""solution"": [""team_id"", ...]
}

""solution"" is the list of contractor team IDs you want to hire — one entry per hired team. The ""team_id"" string is just a placeholder showing the format (each item should be the exact ID for a team). This JSON is only a sketch of the shape I expect, not the actual answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 12, 'density': 0.3680555555555556, 'sets': [{'id': 1, 'elements': [1, 5]}, {'id': 2, 'elements': [2, 10, 11]}, {'id': 3, 'elements': [4, 7, 8, 9, 10]}, {'id': 4, 'elements': [5, 9, 10]}, {'id': 5, 'elements': [1, 3, 4, 5, 8, 9]}, {'id': 6, 'elements': [7, 10, 12]}, {'id': 7, 'elements': [3, 7, 9, 10, 12]}, {'id': 8, 'elements': [3, 5, 8, 9]}, {'id': 9, 'elements': [1, 3, 7, 8, 9, 12]}, {'id': 10, 'elements': [3, 4, 6, 7, 10, 12]}, {'id': 11, 'elements': [2, 11, 12]}, {'id': 12, 'elements': [2, 4, 6, 7, 9, 10, 11]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 3, 'v': 7}, {'u': 3, 'v': 9}, {'u': 12, 'v': 2}, {'u': 12, 'v': 4}, {'u': 12, 'v': 10}, {'u': 9, 'v': 4}, {'u': 9, 'v': 5}, {'u': 9, 'v': 8}, {'u': 10, 'v': 6}, {'u': 10, 'v': 7}, {'u': 11, 'v': 2}, {'u': 1, 'v': 5}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0042.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0042.png'}","[5, 11, 12]",3.0,"{'num_elements': 12, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [0, 4]}, {'id': 'S2', 'elements': [1, 9, 10]}, {'id': 'S3', 'elements': [3, 6, 7, 8, 9]}, {'id': 'S4', 'elements': [4, 8, 9]}, {'id': 'S5', 'elements': [0, 2, 3, 4, 7, 8]}, {'id': 'S6', 'elements': [6, 9, 11]}, {'id': 'S7', 'elements': [2, 6, 8, 9, 11]}, {'id': 'S8', 'elements': [2, 4, 7, 8]}, {'id': 'S9', 'elements': [0, 2, 6, 7, 8, 11]}, {'id': 'S10', 'elements': [2, 3, 5, 6, 9, 11]}, {'id': 'S11', 'elements': [1, 10, 11]}, {'id': 'S12', 'elements': [1, 3, 5, 6, 8, 9, 10]}]}","['S5', 'S11', 'S12']",43,nl,0
SCP,SCP,"Picture this — a campaign needs every audience slice to hear about it, and the goal is to assemble the tiniest group of influencers that together cover those slices. The choice is which influencers to invite on board; a better choice is the one that covers every slice but with fewer people. You judge plans by counting collaborators (the smaller the number, the nicer), and it’s crucial that every segment gets at least one touch and the same influencer isn’t double-counted. Concrete details will be shown below.

Concrete details follow — there are 8 audience segments to reach and 7 influencer options to choose from.
Pick influencer S1: covers segments C F G.
Pick influencer S2: covers segments A B D F H.
Pick influencer S3: covers segments A E.
Pick influencer S4: covers segments A D.
Pick influencer S5: covers segments A B C F.
Pick influencer S6: covers segments A B.
Pick influencer S7: covers segments D H.
Aim to cover all 8 segments with as few of the 7 influencers as possible.

Also, when you hand me the final pick, please use this little JSON layout so everything is tidy and easy to read.

{
  ""solution"": [""influencer_id"", ...]
}

Think of it like a simple form: put the IDs of the influencers you want into the solution list. The JSON above is just a sketch of the shape I expect, not the actual answer—replace the placeholder(s) with the real IDs from the instance.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.35714285714285715, 'sets': [{'id': 1, 'elements': [3, 6, 7]}, {'id': 2, 'elements': [1, 2, 4, 6, 8]}, {'id': 3, 'elements': [1, 5]}, {'id': 4, 'elements': [1, 4]}, {'id': 5, 'elements': [1, 2, 3, 6]}, {'id': 6, 'elements': [1, 2]}, {'id': 7, 'elements': [4, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 6, 'v': 1}, {'u': 3, 'v': 5}, {'u': 8, 'v': 4}, {'u': 4, 'v': 2}, {'u': 1, 'v': 2}, {'u': 1, 'v': 5}, {'u': 2, 'v': 7}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0043.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0043.png'}","[1, 2, 3]",3.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': ['C', 'F', 'G']}, {'id': 'S2', 'elements': ['A', 'B', 'D', 'F', 'H']}, {'id': 'S3', 'elements': ['A', 'E']}, {'id': 'S4', 'elements': ['A', 'D']}, {'id': 'S5', 'elements': ['A', 'B', 'C', 'F']}, {'id': 'S6', 'elements': ['A', 'B']}, {'id': 'S7', 'elements': ['D', 'H']}]}","['S1', 'S2', 'S3']",44,nl,names
SCP,SCP,"Recently the hospital asked the nursing lead to simplify supplies: choose as small a set of care kits as possible so every ward’s clinical items are included somewhere. The job is to decide which kits to stock — the quality of a plan is measured by how many kits it uses, so count them and aim low. Every ward must be covered by at least one of the selected kits, and avoid stocking redundant duplicates. The full lists and specifics are shown below.

- **total_wards**: 11
- **total_kits**: 11

| kit_id | wards_covered |
|---|---|
| S1 | 1 7 8 |
| S2 | 2 4 8 11 |
| S3 | 3 7 |
| S4 | 2 4 5 9 11 |
| S5 | 5 8 9 |
| S6 | 2 7 9 11 |
| S7 | 2 3 4 5 7 9 10 |
| S8 | 1 2 4 5 7 8 |
| S9 | 2 4 6 7 9 10 11 |
| S10 | 5 7 10 |
| S11 | 2 4 6 9 |

Oh, and one more thing — when you send back your chosen kits, please put them into this simple JSON shape so it's easy to parse:

{
  ""solution"": [""kit_id"", ...]
}

Just so it's clear: ""solution"" is the list of care kits you'll pick to cover every ward. Each item in that array should be the identifier for a kit (the placeholder ""kit_id"" above is just an example). This JSON is only a sketch of the shape I expect, not your final answer — replace the placeholder entries with the actual kit IDs from the instance.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no extra 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"".""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 11, 'num_sets': 11, 'density': 0.39669421487603307, 'sets': [{'id': 1, 'elements': [1, 7, 8]}, {'id': 2, 'elements': [2, 4, 8, 11]}, {'id': 3, 'elements': [3, 7]}, {'id': 4, 'elements': [2, 4, 5, 9, 11]}, {'id': 5, 'elements': [5, 8, 9]}, {'id': 6, 'elements': [2, 7, 9, 11]}, {'id': 7, 'elements': [2, 3, 4, 5, 7, 9, 10]}, {'id': 8, 'elements': [1, 2, 4, 5, 7, 8]}, {'id': 9, 'elements': [2, 4, 6, 7, 9, 10, 11]}, {'id': 10, 'elements': [5, 7, 10]}, {'id': 11, 'elements': [2, 4, 6, 9]}], 'graph': {'num_nodes': 11, 'edges': [{'u': 5, 'v': 1}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 7, 'v': 4}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 6, 'v': 9}, {'u': 6, 'v': 11}, {'u': 4, 'v': 2}, {'u': 4, 'v': 8}, {'u': 2, 'v': 9}, {'u': 2, 'v': 11}, {'u': 10, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0044.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0044.png'}","[7, 8, 9]",3.0,"{'num_elements': 11, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [1, 7, 8]}, {'id': 'S2', 'elements': [2, 4, 8, 11]}, {'id': 'S3', 'elements': [3, 7]}, {'id': 'S4', 'elements': [2, 4, 5, 9, 11]}, {'id': 'S5', 'elements': [5, 8, 9]}, {'id': 'S6', 'elements': [2, 7, 9, 11]}, {'id': 'S7', 'elements': [2, 3, 4, 5, 7, 9, 10]}, {'id': 'S8', 'elements': [1, 2, 4, 5, 7, 8]}, {'id': 'S9', 'elements': [2, 4, 6, 7, 9, 10, 11]}, {'id': 'S10', 'elements': [5, 7, 10]}, {'id': 'S11', 'elements': [2, 4, 6, 9]}]}","['S7', 'S8', 'S9']",45,markdown_table,1
SCP,SCP,"Out at the depot the plan is to switch on a small set of chargers so that every vehicle type can plug in at one of the switched-on spots. The better plan is the one that covers all vehicle types while turning on fewer spots — you can measure that by counting enabled locations. Nothing can be left uncovered, and enabling a location twice doesn’t change the tally. The specific details are given below.

# total_vehicle_types=8
# available_locations_count=7
location_id,supported_vehicle_types
S1,B C D F
S2,B C F
S3,A B
S4,A D F
S5,D E F
S6,A F G
S7,A B H

When you're ready, just hand me the plan in a tiny JSON snippet like this — it's an easy way to keep the answer structured and readable:

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

This says: ""solution"" should be an array listing the spots you'll enable (the placeholder spot_id just stands in for whatever spot identifiers your instance uses). It's just the shape I expect, not the actual answer — fill in the real IDs from the problem when you submit the solution.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 8, 'num_sets': 7, 'density': 0.375, 'sets': [{'id': 1, 'elements': [2, 3, 4, 6]}, {'id': 2, 'elements': [2, 3, 6]}, {'id': 3, 'elements': [1, 2]}, {'id': 4, 'elements': [1, 4, 6]}, {'id': 5, 'elements': [4, 5, 6]}, {'id': 6, 'elements': [1, 6, 7]}, {'id': 7, 'elements': [1, 2, 8]}], 'graph': {'num_nodes': 8, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 4}, {'u': 6, 'v': 7}, {'u': 3, 'v': 2}, {'u': 1, 'v': 2}, {'u': 4, 'v': 5}, {'u': 8, 'v': 2}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0045.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0045.png'}","[2, 5, 6, 7]",4.0,"{'num_elements': 8, 'num_sets': 7, 'sets': [{'id': 'S1', 'elements': ['B', 'C', 'D', 'F']}, {'id': 'S2', 'elements': ['B', 'C', 'F']}, {'id': 'S3', 'elements': ['A', 'B']}, {'id': 'S4', 'elements': ['A', 'D', 'F']}, {'id': 'S5', 'elements': ['D', 'E', 'F']}, {'id': 'S6', 'elements': ['A', 'F', 'G']}, {'id': 'S7', 'elements': ['A', 'B', 'H']}]}","['S2', 'S5', 'S6', 'S7']",46,csv,names
SCP,SCP,"Many people on the library staff are helping prepare reading kits for partners, and the challenge is to combine books into as few kits as possible while still covering every important genre. The way to know if the plan is good is to count how many kits will be sent—fewer kits means a better pick of combinations. It’s required that each important genre appears in at least one kit; duplicating genres across kits is allowed but discouraged because it inflates the kit total. The exact lists of genres and books can be found below.

- **total_genres**: 12
- **total_candidate_bundles**: 11

| bundle_id | bundle_genre_ids |
|---|---|
| S1 | 3 4 10 12 |
| S2 | 1 7 9 10 12 |
| S3 | 2 3 4 |
| S4 | 1 2 3 9 12 |
| S5 | 6 8 11 12 |
| S6 | 2 6 7 11 12 |
| S7 | 2 7 |
| S8 | 5 6 8 11 12 |
| S9 | 1 2 12 |
| S10 | 2 4 10 |
| S11 | 1 2 4 6 7 8 9 11 12 |

Also, when you're ready to tell me which kits to send, toss them into this little JSON shape so it's easy to parse:

{
  ""solution"": [""kit_id"", ...]
}

Think of ""solution"" as just a list of the kit identifiers you picked — those are the actual kit labels from the instance (the placeholders here like ""kit_id"" just show the shape). This is just a sketch of the format I need, not the real answer.

Quick reminder: use the identifiers exactly as they appear in the instance input — don't rename them or invent new labels. For example:
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 11, 'density': 0.36363636363636365, 'sets': [{'id': 1, 'elements': [3, 4, 10, 12]}, {'id': 2, 'elements': [1, 7, 9, 10, 12]}, {'id': 3, 'elements': [2, 3, 4]}, {'id': 4, 'elements': [1, 2, 3, 9, 12]}, {'id': 5, 'elements': [6, 8, 11, 12]}, {'id': 6, 'elements': [2, 6, 7, 11, 12]}, {'id': 7, 'elements': [2, 7]}, {'id': 8, 'elements': [5, 6, 8, 11, 12]}, {'id': 9, 'elements': [1, 2, 12]}, {'id': 10, 'elements': [2, 4, 10]}, {'id': 11, 'elements': [1, 2, 4, 6, 7, 8, 9, 11, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 6, 'v': 5}, {'u': 6, 'v': 8}, {'u': 6, 'v': 11}, {'u': 6, 'v': 12}, {'u': 9, 'v': 2}, {'u': 10, 'v': 4}, {'u': 7, 'v': 12}, {'u': 3, 'v': 1}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 12, 'v': 2}, {'u': 1, 'v': 2}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0046.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0046.png'}","[1, 8, 11]",3.0,"{'num_elements': 12, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [3, 4, 10, 12]}, {'id': 'S2', 'elements': [1, 7, 9, 10, 12]}, {'id': 'S3', 'elements': [2, 3, 4]}, {'id': 'S4', 'elements': [1, 2, 3, 9, 12]}, {'id': 'S5', 'elements': [6, 8, 11, 12]}, {'id': 'S6', 'elements': [2, 6, 7, 11, 12]}, {'id': 'S7', 'elements': [2, 7]}, {'id': 'S8', 'elements': [5, 6, 8, 11, 12]}, {'id': 'S9', 'elements': [1, 2, 12]}, {'id': 'S10', 'elements': [2, 4, 10]}, {'id': 'S11', 'elements': [1, 2, 4, 6, 7, 8, 9, 11, 12]}]}","['S1', 'S8', 'S11']",47,markdown_table,1
SCP,SCP,"There’s a new shift in the control room and the main concern is arranging camera clusters around the building so no corner goes dark. The decision is simply which clusters to switch on; a plan is better if it gets every blind spot under surveillance while using the least number of clusters — just tally the clusters chosen to see which plan is smaller, and make sure nothing gets missed or redundantly watched. The specific cluster choices and coverage map appear below.

There are 12 blind spots and 10 clusters available:
Cluster S1 watches blind spots 7 11.
Cluster S2 watches blind spots 1 4 6 8 9.
Cluster S3 watches blind spots 2 8 9.
Cluster S4 watches blind spots 3 5.
Cluster S5 watches blind spots 1 6 8 9.
Cluster S6 watches blind spots 3 5 10.
Cluster S7 watches blind spots 0 1 4 5 8 11.
Cluster S8 watches blind spots 1 2 4 6 8 10 11.
Cluster S9 watches blind spots 3 10.
Cluster S10 watches blind spots 7 9 10 11.
Select the fewest clusters that together watch all 12 blind spots from the 10 listed.

Oh, and when you send the final plan, just use this simple JSON layout so it's easy to parse:

{
  ""solution"": [""cluster_id"", ...]
}

This shows that ""solution"" should be a list of the cluster identifiers you want to switch on — basically the set of camera clusters that cover every blind spot. Treat it like a little checklist: put each cluster ID in the array. The block above is just the sketch of the shape I expect, not the actual answer.

Please make sure every identifier you use matches the instance input exactly — no renaming or inventing new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 10, 'density': 0.31666666666666665, 'sets': [{'id': 1, 'elements': [8, 12]}, {'id': 2, 'elements': [2, 5, 7, 9, 10]}, {'id': 3, 'elements': [3, 9, 10]}, {'id': 4, 'elements': [4, 6]}, {'id': 5, 'elements': [2, 7, 9, 10]}, {'id': 6, 'elements': [4, 6, 11]}, {'id': 7, 'elements': [1, 2, 5, 6, 9, 12]}, {'id': 8, 'elements': [2, 3, 5, 7, 9, 11, 12]}, {'id': 9, 'elements': [4, 11]}, {'id': 10, 'elements': [8, 10, 11, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 9, 'v': 3}, {'u': 9, 'v': 10}, {'u': 12, 'v': 1}, {'u': 12, 'v': 7}, {'u': 5, 'v': 10}, {'u': 6, 'v': 4}, {'u': 6, 'v': 11}, {'u': 8, 'v': 1}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 2, 'v': 10}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0047.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0047.png'}","[6, 7, 8, 10]",4.0,"{'num_elements': 12, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [7, 11]}, {'id': 'S2', 'elements': [1, 4, 6, 8, 9]}, {'id': 'S3', 'elements': [2, 8, 9]}, {'id': 'S4', 'elements': [3, 5]}, {'id': 'S5', 'elements': [1, 6, 8, 9]}, {'id': 'S6', 'elements': [3, 5, 10]}, {'id': 'S7', 'elements': [0, 1, 4, 5, 8, 11]}, {'id': 'S8', 'elements': [1, 2, 4, 6, 8, 10, 11]}, {'id': 'S9', 'elements': [3, 10]}, {'id': 'S10', 'elements': [7, 9, 10, 11]}]}","['S6', 'S7', 'S8', 'S10']",48,nl,0
SCP,SCP,"I’m the QA lead juggling a long list of product features and a stack of test suites; the job is to pick the fewest test suites possible so every feature gets at least one hit. The choice is which suites to run, and a better choice is simply the one that uses fewer runs while still touching every feature — count the number of suites selected to see how good a plan is. Nothing can be left untested, and while overlapping coverage can happen, rerunning suites that only duplicate work is wasteful. The concrete details of the features and suites are shown below.

- **total_features**: 10
- **total_test_suites**: 9

| suite_id | covered_features |
|---|---|
| S1 | D E H |
| S2 | B D I J |
| S3 | A B D E F H I |
| S4 | A C D E F I |
| S5 | C D E |
| S6 | A H |
| S7 | A B D G H |
| S8 | E F I |
| S9 | A E |

Oh, and when you give the final plan, please use this tiny JSON shape so it's easy to read and plug into the tracker:

{
  ""solution"": [""suite_id"", ...]
}

Pretty simple: ""solution"" is the list of test suites you choose to run. The placeholder ""suite_id"" just shows where each suite identifier goes — replace those with the actual suite names from the instance. This block is only a sketch of the expected shape, not the actual answer.

Please be sure to use the identifiers exactly as they appear in the instance input — 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”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 10, 'num_sets': 9, 'density': 0.3888888888888889, 'sets': [{'id': 1, 'elements': [4, 5, 8]}, {'id': 2, 'elements': [2, 4, 9, 10]}, {'id': 3, 'elements': [1, 2, 4, 5, 6, 8, 9]}, {'id': 4, 'elements': [1, 3, 4, 5, 6, 9]}, {'id': 5, 'elements': [3, 4, 5]}, {'id': 6, 'elements': [1, 8]}, {'id': 7, 'elements': [1, 2, 4, 7, 8]}, {'id': 8, 'elements': [5, 6, 9]}, {'id': 9, 'elements': [1, 5]}], 'graph': {'num_nodes': 10, 'edges': [{'u': 9, 'v': 5}, {'u': 9, 'v': 10}, {'u': 1, 'v': 2}, {'u': 1, 'v': 4}, {'u': 1, 'v': 8}, {'u': 7, 'v': 8}, {'u': 2, 'v': 10}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 3, 'v': 6}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0048.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0048.png'}","[2, 4, 7]",3.0,"{'num_elements': 10, 'num_sets': 9, 'sets': [{'id': 'S1', 'elements': ['D', 'E', 'H']}, {'id': 'S2', 'elements': ['B', 'D', 'I', 'J']}, {'id': 'S3', 'elements': ['A', 'B', 'D', 'E', 'F', 'H', 'I']}, {'id': 'S4', 'elements': ['A', 'C', 'D', 'E', 'F', 'I']}, {'id': 'S5', 'elements': ['C', 'D', 'E']}, {'id': 'S6', 'elements': ['A', 'H']}, {'id': 'S7', 'elements': ['A', 'B', 'D', 'G', 'H']}, {'id': 'S8', 'elements': ['E', 'F', 'I']}, {'id': 'S9', 'elements': ['A', 'E']}]}","['S2', 'S4', 'S7']",49,markdown_table,names
SCP,SCP,"We’ve got a shoot with a long list of scene types and a bunch of possible venues, and now it’s time to decide which venues to lock in. The goal is to cover all the scene needs using as few venues as possible — compare options by counting how many venues are chosen, with smaller counts favored — and make sure every required setting is present in at least one booked place; skipping any required setting isn’t allowed and overlapping locations that don’t add new settings just cost extra. The concrete details of scenes and candidate locations appear below.

- **num_scene_types**: 12
- **num_candidate_venues**: 11

| venue_id | available_scene_types |
|---|---|
| S1 | A G H |
| S2 | E F H |
| S3 | A E G H L |
| S4 | D G J K |
| S5 | B C L |
| S6 | A C D G H J K |
| S7 | A B C E G H I L |
| S8 | H L |
| S9 | D G J |
| S10 | D G |
| S11 | E H I L |

Also, when you give your final picks, toss them into a tiny JSON snippet like this so everything’s clear and machine-friendly:

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

""solution"" is just the list of venue identifiers you plan to book — one identifier per chosen venue. Think of it like filling out a short form: put the exact venue IDs in that array. This is only a template of the shape I want, not the actual answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 12, 'num_sets': 11, 'density': 0.3333333333333333, 'sets': [{'id': 1, 'elements': [1, 7, 8]}, {'id': 2, 'elements': [5, 6, 8]}, {'id': 3, 'elements': [1, 5, 7, 8, 12]}, {'id': 4, 'elements': [4, 7, 10, 11]}, {'id': 5, 'elements': [2, 3, 12]}, {'id': 6, 'elements': [1, 3, 4, 7, 8, 10, 11]}, {'id': 7, 'elements': [1, 2, 3, 5, 7, 8, 9, 12]}, {'id': 8, 'elements': [8, 12]}, {'id': 9, 'elements': [4, 7, 10]}, {'id': 10, 'elements': [4, 7]}, {'id': 11, 'elements': [5, 8, 9, 12]}], 'graph': {'num_nodes': 12, 'edges': [{'u': 8, 'v': 3}, {'u': 8, 'v': 5}, {'u': 8, 'v': 12}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 11, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 4, 'v': 10}, {'u': 9, 'v': 12}, {'u': 1, 'v': 3}]}, 'viz_instance': 'generated_data/SCP/viz/SCP_S/instance_0049.png', 'viz_solution': 'generated_data/SCP/viz/SCP_S/solution_0049.png'}","[2, 6, 7]",3.0,"{'num_elements': 12, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': ['A', 'G', 'H']}, {'id': 'S2', 'elements': ['E', 'F', 'H']}, {'id': 'S3', 'elements': ['A', 'E', 'G', 'H', 'L']}, {'id': 'S4', 'elements': ['D', 'G', 'J', 'K']}, {'id': 'S5', 'elements': ['B', 'C', 'L']}, {'id': 'S6', 'elements': ['A', 'C', 'D', 'G', 'H', 'J', 'K']}, {'id': 'S7', 'elements': ['A', 'B', 'C', 'E', 'G', 'H', 'I', 'L']}, {'id': 'S8', 'elements': ['H', 'L']}, {'id': 'S9', 'elements': ['D', 'G', 'J']}, {'id': 'S10', 'elements': ['D', 'G']}, {'id': 'S11', 'elements': ['E', 'H', 'I', 'L']}]}","['S2', 'S6', 'S7']",50,markdown_table,names