SP/SP_M_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
SP,SP,"Many kitchens run into the same puzzle: try to offer as many dishes as possible for a service without reusing ingredients across plates. The decision is selecting which recipes to include; the obvious goal is to maximize how many recipes end up on the menu. That goal is measured by simply tallying the chosen recipes, but only menus where every selected dish has ingredients that don’t overlap with any other selected dish are allowed, and each dish must be whole. The candidate recipes and ingredient breakdowns are provided below.

# total_ingredients=18
# total_recipes=17
recipe_id,ingredients
S1,0 5 6 10 14
S2,1 2 12
S3,4 7 8 11 14 16
S4,3 5 11 12 14
S5,0 5 14 15 16
S6,0 6 10 15
S7,3 7 11
S8,7 8 11
S9,2 9 12 13
S10,0 6 15
S11,3 4 8 11
S12,2 4 9 13
S13,1 2 9 12 13 16
S14,3 4 12 14 16 17
S15,0 5 6 10
S16,4 5 12
S17,0 5

When you’re ready to send the chosen menu back, just use this simple JSON shape:

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

Think of ""solution"" as the list of recipe ids for the dishes you picked — one id per chosen plate. The example uses ""set_id"" as a placeholder; in your reply put the actual ids from the instance in that array. This JSON 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. 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': 18, 'num_sets': 17, 'density': 0.22875816993464052, 'sets': [{'id': 1, 'elements': [1, 6, 7, 11, 15]}, {'id': 2, 'elements': [2, 3, 13]}, {'id': 3, 'elements': [5, 8, 9, 12, 15, 17]}, {'id': 4, 'elements': [4, 6, 12, 13, 15]}, {'id': 5, 'elements': [1, 6, 15, 16, 17]}, {'id': 6, 'elements': [1, 7, 11, 16]}, {'id': 7, 'elements': [4, 8, 12]}, {'id': 8, 'elements': [8, 9, 12]}, {'id': 9, 'elements': [3, 10, 13, 14]}, {'id': 10, 'elements': [1, 7, 16]}, {'id': 11, 'elements': [4, 5, 9, 12]}, {'id': 12, 'elements': [3, 5, 10, 14]}, {'id': 13, 'elements': [2, 3, 10, 13, 14, 17]}, {'id': 14, 'elements': [4, 5, 13, 15, 17, 18]}, {'id': 15, 'elements': [1, 6, 7, 11]}, {'id': 16, 'elements': [5, 6, 13]}, {'id': 17, 'elements': [1, 6]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 3, 'v': 2}, {'u': 3, 'v': 14}, {'u': 1, 'v': 6}, {'u': 1, 'v': 16}, {'u': 16, 'v': 7}, {'u': 16, 'v': 11}, {'u': 12, 'v': 4}, {'u': 12, 'v': 8}, {'u': 12, 'v': 9}, {'u': 6, 'v': 15}, {'u': 6, 'v': 18}, {'u': 17, 'v': 5}, {'u': 17, 'v': 13}, {'u': 17, 'v': 15}, {'u': 5, 'v': 4}, {'u': 5, 'v': 15}, {'u': 10, 'v': 14}, {'u': 13, 'v': 14}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0000.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0000.png'}","[2, 8, 10]",3.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [0, 5, 6, 10, 14]}, {'id': 'S2', 'elements': [1, 2, 12]}, {'id': 'S3', 'elements': [4, 7, 8, 11, 14, 16]}, {'id': 'S4', 'elements': [3, 5, 11, 12, 14]}, {'id': 'S5', 'elements': [0, 5, 14, 15, 16]}, {'id': 'S6', 'elements': [0, 6, 10, 15]}, {'id': 'S7', 'elements': [3, 7, 11]}, {'id': 'S8', 'elements': [7, 8, 11]}, {'id': 'S9', 'elements': [2, 9, 12, 13]}, {'id': 'S10', 'elements': [0, 6, 15]}, {'id': 'S11', 'elements': [3, 4, 8, 11]}, {'id': 'S12', 'elements': [2, 4, 9, 13]}, {'id': 'S13', 'elements': [1, 2, 9, 12, 13, 16]}, {'id': 'S14', 'elements': [3, 4, 12, 14, 16, 17]}, {'id': 'S15', 'elements': [0, 5, 6, 10]}, {'id': 'S16', 'elements': [4, 5, 12]}, {'id': 'S17', 'elements': [0, 5]}]}","['S2', 'S8', 'S10']",1,csv,0
SP,SP,"Someone on the planning committee put together several themed gatherings, each with a list of invited guests taken from the same community list. The committee needs to pick a set of gatherings to hold, with the rule that no person can be on more than one chosen guest list. The objective is straightforward: maximize the number of gatherings that actually happen — success is measured by the number of selected gatherings. The specific events and guest lists are shown below.

# total_guests=13
# total_gatherings=13
gathering_id,invited_guests
S1,1 7
S2,1 3 5 8 11
S3,2 6 8
S4,1 4 5 11
S5,3 4 10 11 12
S6,1 10 11
S7,5 9 10
S8,0 1 7 8 11
S9,1 2 7 9 11
S10,2 6 8 9
S11,4 5
S12,1 3 5 6 7 8 10 11
S13,4 5 10 12

If you want to send back which gatherings to hold, just use this little JSON shape so it's easy to read and check:

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

Think of it like a form: ""solution"" is the list of gatherings you pick, and each item in the list should be the exact ID for a guest list from the instance (just one ID per chosen gathering). This JSON 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.3136094674556213, 'sets': [{'id': 1, 'elements': [2, 8]}, {'id': 2, 'elements': [2, 4, 6, 9, 12]}, {'id': 3, 'elements': [3, 7, 9]}, {'id': 4, 'elements': [2, 5, 6, 12]}, {'id': 5, 'elements': [4, 5, 11, 12, 13]}, {'id': 6, 'elements': [2, 11, 12]}, {'id': 7, 'elements': [6, 10, 11]}, {'id': 8, 'elements': [1, 2, 8, 9, 12]}, {'id': 9, 'elements': [2, 3, 8, 10, 12]}, {'id': 10, 'elements': [3, 7, 9, 10]}, {'id': 11, 'elements': [5, 6]}, {'id': 12, 'elements': [2, 4, 6, 7, 8, 9, 11, 12]}, {'id': 13, 'elements': [5, 6, 11, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 3, 'v': 7}, {'u': 3, 'v': 10}, {'u': 4, 'v': 5}, {'u': 4, 'v': 12}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 13, 'v': 5}, {'u': 13, 'v': 11}, {'u': 6, 'v': 7}, {'u': 6, 'v': 11}, {'u': 6, 'v': 12}, {'u': 10, 'v': 9}, {'u': 12, 'v': 2}, {'u': 2, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0001.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0001.png'}","[1, 3, 11]",3.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [1, 7]}, {'id': 'S2', 'elements': [1, 3, 5, 8, 11]}, {'id': 'S3', 'elements': [2, 6, 8]}, {'id': 'S4', 'elements': [1, 4, 5, 11]}, {'id': 'S5', 'elements': [3, 4, 10, 11, 12]}, {'id': 'S6', 'elements': [1, 10, 11]}, {'id': 'S7', 'elements': [5, 9, 10]}, {'id': 'S8', 'elements': [0, 1, 7, 8, 11]}, {'id': 'S9', 'elements': [1, 2, 7, 9, 11]}, {'id': 'S10', 'elements': [2, 6, 8, 9]}, {'id': 'S11', 'elements': [4, 5]}, {'id': 'S12', 'elements': [1, 3, 5, 6, 7, 8, 10, 11]}, {'id': 'S13', 'elements': [4, 5, 10, 12]}]}","['S1', 'S3', 'S11']",2,csv,0
SP,SP,"We got a brief from a stylist who needs a stack of ready-to-go looks for a short event. The task: choose which ensembles to use so there are as many distinct outfits on the rack as possible. Each ensemble is made from specific items, and an item can’t be assigned to more than one ensemble — no doubling up. A better pick is simply the pick that yields a higher count of complete outfits; just tally how many outfits end up selected. The exact list of garments and possible ensembles is laid out below.

{
  ""total_garments"": 18,
  ""total_looks"": 18,
  ""sets"": [
    {
      ""look_id"": ""S1"",
      ""look_garments"": [
        0,
        5,
        15
      ]
    },
    {
      ""look_id"": ""S2"",
      ""look_garments"": [
        11,
        13
      ]
    },
    {
      ""look_id"": ""S3"",
      ""look_garments"": [
        2,
        16,
        17
      ]
    },
    {
      ""look_id"": ""S4"",
      ""look_garments"": [
        2,
        4,
        7,
        11,
        16,
        17
      ]
    },
    {
      ""look_id"": ""S5"",
      ""look_garments"": [
        2,
        3,
        4,
        9,
        16
      ]
    },
    {
      ""look_id"": ""S6"",
      ""look_garments"": [
        0,
        1,
        5,
        7,
        12,
        13,
        15
      ]
    },
    {
      ""look_id"": ""S7"",
      ""look_garments"": [
        6,
        8,
        10,
        14
      ]
    },
    {
      ""look_id"": ""S8"",
      ""look_garments"": [
        3,
        7,
        10,
        11,
        17
      ]
    },
    {
      ""look_id"": ""S9"",
      ""look_garments"": [
        8,
        10,
        12,
        14
      ]
    },
    {
      ""look_id"": ""S10"",
      ""look_garments"": [
        2,
        4
      ]
    },
    {
      ""look_id"": ""S11"",
      ""look_garments"": [
        6,
        8,
        10,
        12,
        14
      ]
    },
    {
      ""look_id"": ""S12"",
      ""look_garments"": [
        1,
        3,
        5,
        7,
        13,
        17
      ]
    },
    {
      ""look_id"": ""S13"",
      ""look_garments"": [
        0,
        5,
        6,
        7,
        8,
        10,
        12,
        14,
        15
      ]
    },
    {
      ""look_id"": ""S14"",
      ""look_garments"": [
        5,
        11,
        12,
        13,
        15,
        17
      ]
    },
    {
      ""look_id"": ""S15"",
      ""look_garments"": [
        12,
        14
      ]
    },
    {
      ""look_id"": ""S16"",
      ""look_garments"": [
        12,
        15
      ]
    },
    {
      ""look_id"": ""S17"",
      ""look_garments"": [
        2,
        4,
        16,
        17
      ]
    },
    {
      ""look_id"": ""S18"",
      ""look_garments"": [
        3,
        7,
        11,
        12,
        16,
        17
      ]
    }
  ]
}

Just drop your final picks in a tiny JSON like this so I can read it easily — nothing fancy, just the list of outfits you want to put on the rack:

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

Here ""solution"" is the array of the ensembles you choose. Each entry should be the identifier for a complete look (the exact ID from the instance), so the array is just the selected look IDs. This block is just the expected shape — not the actual answer.

Please use the IDs 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': 18, 'num_sets': 18, 'density': 0.25, 'sets': [{'id': 1, 'elements': [1, 6, 16]}, {'id': 2, 'elements': [12, 14]}, {'id': 3, 'elements': [3, 17, 18]}, {'id': 4, 'elements': [3, 5, 8, 12, 17, 18]}, {'id': 5, 'elements': [3, 4, 5, 10, 17]}, {'id': 6, 'elements': [1, 2, 6, 8, 13, 14, 16]}, {'id': 7, 'elements': [7, 9, 11, 15]}, {'id': 8, 'elements': [4, 8, 11, 12, 18]}, {'id': 9, 'elements': [9, 11, 13, 15]}, {'id': 10, 'elements': [3, 5]}, {'id': 11, 'elements': [7, 9, 11, 13, 15]}, {'id': 12, 'elements': [2, 4, 6, 8, 14, 18]}, {'id': 13, 'elements': [1, 6, 7, 8, 9, 11, 13, 15, 16]}, {'id': 14, 'elements': [6, 12, 13, 14, 16, 18]}, {'id': 15, 'elements': [13, 15]}, {'id': 16, 'elements': [13, 16]}, {'id': 17, 'elements': [3, 5, 17, 18]}, {'id': 18, 'elements': [4, 8, 12, 13, 17, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 13}, {'u': 6, 'v': 14}, {'u': 6, 'v': 16}, {'u': 17, 'v': 3}, {'u': 17, 'v': 4}, {'u': 11, 'v': 7}, {'u': 11, 'v': 9}, {'u': 11, 'v': 13}, {'u': 11, 'v': 15}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 8, 'v': 13}, {'u': 8, 'v': 18}, {'u': 2, 'v': 14}, {'u': 18, 'v': 4}, {'u': 18, 'v': 12}, {'u': 12, 'v': 14}, {'u': 5, 'v': 10}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0002.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0002.png'}","[1, 2, 7, 10]",4.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [0, 5, 15]}, {'id': 'S2', 'elements': [11, 13]}, {'id': 'S3', 'elements': [2, 16, 17]}, {'id': 'S4', 'elements': [2, 4, 7, 11, 16, 17]}, {'id': 'S5', 'elements': [2, 3, 4, 9, 16]}, {'id': 'S6', 'elements': [0, 1, 5, 7, 12, 13, 15]}, {'id': 'S7', 'elements': [6, 8, 10, 14]}, {'id': 'S8', 'elements': [3, 7, 10, 11, 17]}, {'id': 'S9', 'elements': [8, 10, 12, 14]}, {'id': 'S10', 'elements': [2, 4]}, {'id': 'S11', 'elements': [6, 8, 10, 12, 14]}, {'id': 'S12', 'elements': [1, 3, 5, 7, 13, 17]}, {'id': 'S13', 'elements': [0, 5, 6, 7, 8, 10, 12, 14, 15]}, {'id': 'S14', 'elements': [5, 11, 12, 13, 15, 17]}, {'id': 'S15', 'elements': [12, 14]}, {'id': 'S16', 'elements': [12, 15]}, {'id': 'S17', 'elements': [2, 4, 16, 17]}, {'id': 'S18', 'elements': [3, 7, 11, 12, 16, 17]}]}","['S1', 'S2', 'S7', 'S10']",3,json,0
SP,SP,"A local radio host has a pile of ready-to-go live playlists and needs to pick which ones to air so the station ends up with the largest number of complete, non-overlapping sets. Each playlist must be used whole if chosen, and no track may appear in more than one chosen playlist. The outcome is straightforward to check: tally the number of sets that get picked, and that total is the measure of how good the selection is. The detailed set and song information is provided below.

{
  ""total_songs"": 15,
  ""total_playlists"": 13,
  ""sets"": [
    {
      ""playlist_id"": ""S1"",
      ""playlist_songs"": [
        ""A"",
        ""C"",
        ""H""
      ]
    },
    {
      ""playlist_id"": ""S2"",
      ""playlist_songs"": [
        ""L"",
        ""O""
      ]
    },
    {
      ""playlist_id"": ""S3"",
      ""playlist_songs"": [
        ""D"",
        ""E""
      ]
    },
    {
      ""playlist_id"": ""S4"",
      ""playlist_songs"": [
        ""E"",
        ""F""
      ]
    },
    {
      ""playlist_id"": ""S5"",
      ""playlist_songs"": [
        ""C"",
        ""J"",
        ""K""
      ]
    },
    {
      ""playlist_id"": ""S6"",
      ""playlist_songs"": [
        ""A"",
        ""C"",
        ""F"",
        ""N""
      ]
    },
    {
      ""playlist_id"": ""S7"",
      ""playlist_songs"": [
        ""C"",
        ""F"",
        ""I"",
        ""M"",
        ""O""
      ]
    },
    {
      ""playlist_id"": ""S8"",
      ""playlist_songs"": [
        ""F"",
        ""G"",
        ""H"",
        ""J"",
        ""N""
      ]
    },
    {
      ""playlist_id"": ""S9"",
      ""playlist_songs"": [
        ""F"",
        ""N""
      ]
    },
    {
      ""playlist_id"": ""S10"",
      ""playlist_songs"": [
        ""B"",
        ""I"",
        ""L"",
        ""M"",
        ""O""
      ]
    },
    {
      ""playlist_id"": ""S11"",
      ""playlist_songs"": [
        ""I"",
        ""M"",
        ""O""
      ]
    },
    {
      ""playlist_id"": ""S12"",
      ""playlist_songs"": [
        ""F"",
        ""H"",
        ""J"",
        ""N""
      ]
    },
    {
      ""playlist_id"": ""S13"",
      ""playlist_songs"": [
        ""B"",
        ""I"",
        ""L"",
        ""O""
      ]
    }
  ]
}

Oh, and when you're ready to send back your pick, a little JSON snippet like this is perfect — nice and tidy so the host can read it automatically.

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

Here ""solution"" is just the place where you list the playlists you want to air — put each playlist's identifier in that array. Think of it like filling out a short form: the array contains the exact playlist IDs you picked, nothing more. This JSON is just a sketch of the shape I need, not the actual final answer.

Please use the identifiers exactly as they appear in the instance input — no renaming, no made-up 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': 15, 'num_sets': 13, 'density': 0.22564102564102564, 'sets': [{'id': 1, 'elements': [1, 3, 8]}, {'id': 2, 'elements': [12, 15]}, {'id': 3, 'elements': [4, 5]}, {'id': 4, 'elements': [5, 6]}, {'id': 5, 'elements': [3, 10, 11]}, {'id': 6, 'elements': [1, 3, 6, 14]}, {'id': 7, 'elements': [3, 6, 9, 13, 15]}, {'id': 8, 'elements': [6, 7, 8, 10, 14]}, {'id': 9, 'elements': [6, 14]}, {'id': 10, 'elements': [2, 9, 12, 13, 15]}, {'id': 11, 'elements': [9, 13, 15]}, {'id': 12, 'elements': [6, 8, 10, 14]}, {'id': 13, 'elements': [2, 9, 12, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 12, 'v': 9}, {'u': 12, 'v': 13}, {'u': 12, 'v': 15}, {'u': 10, 'v': 4}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 15, 'v': 2}, {'u': 1, 'v': 3}, {'u': 5, 'v': 7}, {'u': 14, 'v': 6}, {'u': 14, 'v': 11}, {'u': 3, 'v': 8}, {'u': 6, 'v': 8}, {'u': 8, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0003.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0003.png'}","[1, 2, 3, 9]",4.0,"{'num_elements': 15, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'H']}, {'id': 'S2', 'elements': ['L', 'O']}, {'id': 'S3', 'elements': ['D', 'E']}, {'id': 'S4', 'elements': ['E', 'F']}, {'id': 'S5', 'elements': ['C', 'J', 'K']}, {'id': 'S6', 'elements': ['A', 'C', 'F', 'N']}, {'id': 'S7', 'elements': ['C', 'F', 'I', 'M', 'O']}, {'id': 'S8', 'elements': ['F', 'G', 'H', 'J', 'N']}, {'id': 'S9', 'elements': ['F', 'N']}, {'id': 'S10', 'elements': ['B', 'I', 'L', 'M', 'O']}, {'id': 'S11', 'elements': ['I', 'M', 'O']}, {'id': 'S12', 'elements': ['F', 'H', 'J', 'N']}, {'id': 'S13', 'elements': ['B', 'I', 'L', 'O']}]}","['S1', 'S2', 'S3', 'S9']",4,json,names
SP,SP,"I heard a gardener worrying over a stack of planting ideas: each idea is a little bed plan listing which species go together, and the gardener wants to pick as many of those plans as possible. The trick is that a species can only appear in one chosen bed, so any selected plans must use totally different plants. A better choice is simply the one that ends up with more separate beds picked — compare plans by counting how many beds are included — and the exact bed options are shown below.

# total_species=14
# num_bed_plans=11
bed_plan_id,bed_species
S1,H M N
S2,A B G J K N
S3,C J
S4,D G
S5,F G
S6,A B D F G H M
S7,A F G H
S8,A B C
S9,B E K N
S10,A D G H L
S11,A B E I N

If you want to send back which bed plans to pick, a neat little reply in JSON works best — something like this shows the shape I'm expecting:

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

Here ""solution"" is just a list of the chosen bed plan IDs (one entry per picked plan). Think of each ""bed_id"" as the label you see in the instance — slot them into the array in any order you like. This is just a sketch of the shape I want, not the final answer itself.

Please use the exact identifiers from the instance input — do not rename them or invent new labels.
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 11, 'density': 0.2792207792207792, 'sets': [{'id': 1, 'elements': [8, 13, 14]}, {'id': 2, 'elements': [1, 2, 7, 10, 11, 14]}, {'id': 3, 'elements': [3, 10]}, {'id': 4, 'elements': [4, 7]}, {'id': 5, 'elements': [6, 7]}, {'id': 6, 'elements': [1, 2, 4, 6, 7, 8, 13]}, {'id': 7, 'elements': [1, 6, 7, 8]}, {'id': 8, 'elements': [1, 2, 3]}, {'id': 9, 'elements': [2, 5, 11, 14]}, {'id': 10, 'elements': [1, 4, 7, 8, 12]}, {'id': 11, 'elements': [1, 2, 5, 9, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 7, 'v': 1}, {'u': 7, 'v': 8}, {'u': 7, 'v': 13}, {'u': 8, 'v': 6}, {'u': 9, 'v': 14}, {'u': 12, 'v': 13}, {'u': 3, 'v': 10}, {'u': 1, 'v': 2}, {'u': 13, 'v': 4}, {'u': 14, 'v': 2}, {'u': 14, 'v': 11}, {'u': 2, 'v': 10}, {'u': 5, 'v': 11}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0004.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0004.png'}","[1, 3, 4]",3.0,"{'num_elements': 14, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': ['H', 'M', 'N']}, {'id': 'S2', 'elements': ['A', 'B', 'G', 'J', 'K', 'N']}, {'id': 'S3', 'elements': ['C', 'J']}, {'id': 'S4', 'elements': ['D', 'G']}, {'id': 'S5', 'elements': ['F', 'G']}, {'id': 'S6', 'elements': ['A', 'B', 'D', 'F', 'G', 'H', 'M']}, {'id': 'S7', 'elements': ['A', 'F', 'G', 'H']}, {'id': 'S8', 'elements': ['A', 'B', 'C']}, {'id': 'S9', 'elements': ['B', 'E', 'K', 'N']}, {'id': 'S10', 'elements': ['A', 'D', 'G', 'H', 'L']}, {'id': 'S11', 'elements': ['A', 'B', 'E', 'I', 'N']}]}","['S1', 'S3', 'S4']",5,csv,names
SP,SP,"We’re sorting through a stack of proposed discussion clubs the library collected, and the job is to fit in as many of those clubs as we can. Every club recommends one or more titles, and once a club is added to the lineup none of its books can be used by another club — no overlaps allowed. The score for any plan is just the number of clubs that get scheduled; the goal is to make that number as large as possible by picking compatible clubs. The concrete proposals and their reading lists are listed below.

There are 14 proposals covering 14 distinct titles; we must pick the largest set of clubs whose recommended titles don’t overlap.
Club S1 recommends 0 10 11.
Club S2 recommends 2 3 4 5.
Club S3 recommends 2 5 7 9.
Club S4 recommends 1 3 5 6 8 12.
Club S5 recommends 1 3 5.
Club S6 recommends 2 3 4 5 7 8 12.
Club S7 recommends 3 8.
Club S8 recommends 1 5 7.
Club S9 recommends 3 6 8.
Club S10 recommends 1 12 13.
Club S11 recommends 0 11 12.
Club S12 recommends 0 3 13.
Club S13 recommends 0 3 5 8 9 10 11 12 13.
Club S14 recommends 2 3 11 12 13.
We’ll choose compatible clubs so we schedule as many of the 14 proposals as possible without reusing any of the 14 titles.

If you want to tell me which clubs to schedule, just send back a tiny JSON snippet in this shape — super simple and clean:

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

""solution"" should be the list of club IDs you want to include. The [""club_id"", ...] line is just a placeholder showing the format — replace club_id with the real IDs from the instance. This 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 — 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': 14, 'num_sets': 14, 'density': 0.29591836734693877, 'sets': [{'id': 1, 'elements': [1, 11, 12]}, {'id': 2, 'elements': [3, 4, 5, 6]}, {'id': 3, 'elements': [3, 6, 8, 10]}, {'id': 4, 'elements': [2, 4, 6, 7, 9, 13]}, {'id': 5, 'elements': [2, 4, 6]}, {'id': 6, 'elements': [3, 4, 5, 6, 8, 9, 13]}, {'id': 7, 'elements': [4, 9]}, {'id': 8, 'elements': [2, 6, 8]}, {'id': 9, 'elements': [4, 7, 9]}, {'id': 10, 'elements': [2, 13, 14]}, {'id': 11, 'elements': [1, 12, 13]}, {'id': 12, 'elements': [1, 4, 14]}, {'id': 13, 'elements': [1, 4, 6, 9, 10, 11, 12, 13, 14]}, {'id': 14, 'elements': [3, 4, 12, 13, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 1, 'v': 12}, {'u': 7, 'v': 9}, {'u': 2, 'v': 3}, {'u': 2, 'v': 6}, {'u': 2, 'v': 8}, {'u': 3, 'v': 10}, {'u': 4, 'v': 6}, {'u': 4, 'v': 9}, {'u': 4, 'v': 13}, {'u': 5, 'v': 6}, {'u': 10, 'v': 14}, {'u': 14, 'v': 13}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0005.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0005.png'}","[1, 3, 7, 10]",4.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [0, 10, 11]}, {'id': 'S2', 'elements': [2, 3, 4, 5]}, {'id': 'S3', 'elements': [2, 5, 7, 9]}, {'id': 'S4', 'elements': [1, 3, 5, 6, 8, 12]}, {'id': 'S5', 'elements': [1, 3, 5]}, {'id': 'S6', 'elements': [2, 3, 4, 5, 7, 8, 12]}, {'id': 'S7', 'elements': [3, 8]}, {'id': 'S8', 'elements': [1, 5, 7]}, {'id': 'S9', 'elements': [3, 6, 8]}, {'id': 'S10', 'elements': [1, 12, 13]}, {'id': 'S11', 'elements': [0, 11, 12]}, {'id': 'S12', 'elements': [0, 3, 13]}, {'id': 'S13', 'elements': [0, 3, 5, 8, 9, 10, 11, 12, 13]}, {'id': 'S14', 'elements': [2, 3, 11, 12, 13]}]}","['S1', 'S3', 'S7', 'S10']",6,nl,0
SP,SP,"At the office there’s a stack of proposed teams and the goal is to get the most projects going by picking teams that don’t share staff members. The decision boils down to selecting which of the proposed rosters to approve, and one selection is better than another if it produces more approved teams. Performance is determined by counting those approved teams; the candidate lists are below.

- **total_staff_count**: 14
- **total_team_proposals**: 13

| team_proposal_id | team_member_ids |
|---|---|
| S1 | 0 1 |
| S2 | 0 1 3 4 11 |
| S3 | 2 3 6 10 12 |
| S4 | 1 2 3 4 7 10 11 13 |
| S5 | 0 1 3 4 7 9 13 |
| S6 | 4 5 |
| S7 | 2 6 7 12 |
| S8 | 2 3 4 6 7 8 12 |
| S9 | 7 10 |
| S10 | 4 9 11 |
| S11 | 3 8 10 |
| S12 | 3 4 9 |
| S13 | 3 4 7 |

You can just return the picks in a tiny JSON snippet like this — nice and simple.

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

This ""solution"" array should list the approved team identifiers (one per chosen roster). The ""team_id"" entry is just a placeholder showing the kind of label I expect you to use — when you reply, replace the placeholder with the actual team identifiers from the instance.

This is only a sketch of the expected shape, not the actual answer. Please use the identifiers exactly as they appear in the input — no renaming, 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': 14, 'num_sets': 13, 'density': 0.2967032967032967, 'sets': [{'id': 1, 'elements': [1, 2]}, {'id': 2, 'elements': [1, 2, 4, 5, 12]}, {'id': 3, 'elements': [3, 4, 7, 11, 13]}, {'id': 4, 'elements': [2, 3, 4, 5, 8, 11, 12, 14]}, {'id': 5, 'elements': [1, 2, 4, 5, 8, 10, 14]}, {'id': 6, 'elements': [5, 6]}, {'id': 7, 'elements': [3, 7, 8, 13]}, {'id': 8, 'elements': [3, 4, 5, 7, 8, 9, 13]}, {'id': 9, 'elements': [8, 11]}, {'id': 10, 'elements': [5, 10, 12]}, {'id': 11, 'elements': [4, 9, 11]}, {'id': 12, 'elements': [4, 5, 10]}, {'id': 13, 'elements': [4, 5, 8]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 7}, {'u': 10, 'v': 12}, {'u': 9, 'v': 11}, {'u': 12, 'v': 5}, {'u': 5, 'v': 2}, {'u': 5, 'v': 4}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 11}, {'u': 7, 'v': 3}, {'u': 2, 'v': 1}, {'u': 14, 'v': 4}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0006.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0006.png'}","[1, 6, 7, 11]",4.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 1]}, {'id': 'S2', 'elements': [0, 1, 3, 4, 11]}, {'id': 'S3', 'elements': [2, 3, 6, 10, 12]}, {'id': 'S4', 'elements': [1, 2, 3, 4, 7, 10, 11, 13]}, {'id': 'S5', 'elements': [0, 1, 3, 4, 7, 9, 13]}, {'id': 'S6', 'elements': [4, 5]}, {'id': 'S7', 'elements': [2, 6, 7, 12]}, {'id': 'S8', 'elements': [2, 3, 4, 6, 7, 8, 12]}, {'id': 'S9', 'elements': [7, 10]}, {'id': 'S10', 'elements': [4, 9, 11]}, {'id': 'S11', 'elements': [3, 8, 10]}, {'id': 'S12', 'elements': [3, 4, 9]}, {'id': 'S13', 'elements': [3, 4, 7]}]}","['S1', 'S6', 'S7', 'S11']",7,markdown_table,0
SP,SP,"We’re sorting through a stack of route sheets and trying to take as many full routes as possible, with the catch that no delivery address can be on two of the chosen routes — routes can’t be split or partially used. The way to tell which plan is best is simple: count how many routes were picked (only valid if none of their stops overlap). The specific routes and stops are listed below.

# total_unique_stops=18
# total_routes_available=18
route_id,route_stops
S1,0 14
S2,1 2 16 17
S3,1 2 11 16
S4,0 15 17
S5,4 5 7
S6,5 8 9 10
S7,6 7 8 9 10 11 12 13
S8,4 6 7 8 9 10
S9,4 5 6 7 9 10
S10,6 7 9
S11,4 5 6 8 9 10
S12,2 11 12
S13,1 6 7 9 11 12 13 15 16
S14,6 13 14 16 17
S15,13 14 16
S16,12 13 15 17
S17,1 2 11 12 15 17
S18,3 11 13 14 15 16 17

Oh, and to keep things tidy, please give your final pick in this simple JSON format — nothing fancy, just a quick list of the route IDs you want to take:

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

""solution"" is the list of chosen routes (one identifier per route). Treat the JSON above like a form: drop your chosen route identifiers into that array. It's just a sketch of the shape I expect, not the actual answer itself.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 18, 'density': 0.2654320987654321, 'sets': [{'id': 1, 'elements': [1, 15]}, {'id': 2, 'elements': [2, 3, 17, 18]}, {'id': 3, 'elements': [2, 3, 12, 17]}, {'id': 4, 'elements': [1, 16, 18]}, {'id': 5, 'elements': [5, 6, 8]}, {'id': 6, 'elements': [6, 9, 10, 11]}, {'id': 7, 'elements': [7, 8, 9, 10, 11, 12, 13, 14]}, {'id': 8, 'elements': [5, 7, 8, 9, 10, 11]}, {'id': 9, 'elements': [5, 6, 7, 8, 10, 11]}, {'id': 10, 'elements': [7, 8, 10]}, {'id': 11, 'elements': [5, 6, 7, 9, 10, 11]}, {'id': 12, 'elements': [3, 12, 13]}, {'id': 13, 'elements': [2, 7, 8, 10, 12, 13, 14, 16, 17]}, {'id': 14, 'elements': [7, 14, 15, 17, 18]}, {'id': 15, 'elements': [14, 15, 17]}, {'id': 16, 'elements': [13, 14, 16, 18]}, {'id': 17, 'elements': [2, 3, 12, 13, 16, 18]}, {'id': 18, 'elements': [4, 12, 14, 15, 16, 17, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 6, 'v': 5}, {'u': 6, 'v': 11}, {'u': 2, 'v': 3}, {'u': 2, 'v': 12}, {'u': 2, 'v': 17}, {'u': 12, 'v': 13}, {'u': 12, 'v': 17}, {'u': 7, 'v': 8}, {'u': 7, 'v': 10}, {'u': 7, 'v': 13}, {'u': 5, 'v': 9}, {'u': 18, 'v': 14}, {'u': 18, 'v': 15}, {'u': 18, 'v': 16}, {'u': 18, 'v': 17}, {'u': 9, 'v': 8}, {'u': 9, 'v': 11}, {'u': 1, 'v': 4}, {'u': 14, 'v': 13}, {'u': 14, 'v': 16}, {'u': 16, 'v': 15}, {'u': 15, 'v': 4}, {'u': 10, 'v': 11}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0007.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0007.png'}","[1, 3, 6, 16]",4.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [0, 14]}, {'id': 'S2', 'elements': [1, 2, 16, 17]}, {'id': 'S3', 'elements': [1, 2, 11, 16]}, {'id': 'S4', 'elements': [0, 15, 17]}, {'id': 'S5', 'elements': [4, 5, 7]}, {'id': 'S6', 'elements': [5, 8, 9, 10]}, {'id': 'S7', 'elements': [6, 7, 8, 9, 10, 11, 12, 13]}, {'id': 'S8', 'elements': [4, 6, 7, 8, 9, 10]}, {'id': 'S9', 'elements': [4, 5, 6, 7, 9, 10]}, {'id': 'S10', 'elements': [6, 7, 9]}, {'id': 'S11', 'elements': [4, 5, 6, 8, 9, 10]}, {'id': 'S12', 'elements': [2, 11, 12]}, {'id': 'S13', 'elements': [1, 6, 7, 9, 11, 12, 13, 15, 16]}, {'id': 'S14', 'elements': [6, 13, 14, 16, 17]}, {'id': 'S15', 'elements': [13, 14, 16]}, {'id': 'S16', 'elements': [12, 13, 15, 17]}, {'id': 'S17', 'elements': [1, 2, 11, 12, 15, 17]}, {'id': 'S18', 'elements': [3, 11, 13, 14, 15, 16, 17]}]}","['S1', 'S3', 'S6', 'S16']",8,csv,0
SP,SP,"Lately the studio’s trying to run a bunch of shoots at once, and the assignment is to choose as many shoots as will fit together without any model being on two call sheets. Each shoot has its required models and those people can’t be split or double-booked. The best lineup is the one with the biggest number of simultaneous shoots — evaluate by counting them. The concrete details are shown below.

{
  ""total_models"": 13,
  ""total_shoots"": 12,
  ""sets"": [
    {
      ""shoot_id"": ""S1"",
      ""required_models"": [
        1,
        8
      ]
    },
    {
      ""shoot_id"": ""S2"",
      ""required_models"": [
        1,
        12
      ]
    },
    {
      ""shoot_id"": ""S3"",
      ""required_models"": [
        4,
        8,
        10,
        13
      ]
    },
    {
      ""shoot_id"": ""S4"",
      ""required_models"": [
        2,
        5,
        6,
        8
      ]
    },
    {
      ""shoot_id"": ""S5"",
      ""required_models"": [
        6,
        9,
        13
      ]
    },
    {
      ""shoot_id"": ""S6"",
      ""required_models"": [
        2,
        7,
        11,
        12
      ]
    },
    {
      ""shoot_id"": ""S7"",
      ""required_models"": [
        1,
        4,
        6,
        8,
        9,
        13
      ]
    },
    {
      ""shoot_id"": ""S8"",
      ""required_models"": [
        3,
        6
      ]
    },
    {
      ""shoot_id"": ""S9"",
      ""required_models"": [
        10,
        13
      ]
    },
    {
      ""shoot_id"": ""S10"",
      ""required_models"": [
        1,
        2,
        7,
        11,
        12
      ]
    },
    {
      ""shoot_id"": ""S11"",
      ""required_models"": [
        7,
        12
      ]
    },
    {
      ""shoot_id"": ""S12"",
      ""required_models"": [
        5,
        8,
        10,
        13
      ]
    }
  ]
}

Oh, and when you give me the final answer, just drop it into a tiny JSON snippet so it's easy to parse. Something like this:

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

Here ""solution"" is the list of shoots you want to run simultaneously, and each entry is the ID of a shoot (use the exact ID string from the instance). This JSON is just a sketch of the expected shape — it shows what the answer should look like, not the actual picks.

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': 13, 'num_sets': 12, 'density': 0.2564102564102564, 'sets': [{'id': 1, 'elements': [1, 8]}, {'id': 2, 'elements': [1, 12]}, {'id': 3, 'elements': [4, 8, 10, 13]}, {'id': 4, 'elements': [2, 5, 6, 8]}, {'id': 5, 'elements': [6, 9, 13]}, {'id': 6, 'elements': [2, 7, 11, 12]}, {'id': 7, 'elements': [1, 4, 6, 8, 9, 13]}, {'id': 8, 'elements': [3, 6]}, {'id': 9, 'elements': [10, 13]}, {'id': 10, 'elements': [1, 2, 7, 11, 12]}, {'id': 11, 'elements': [7, 12]}, {'id': 12, 'elements': [5, 8, 10, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 4, 'v': 10}, {'u': 4, 'v': 13}, {'u': 12, 'v': 11}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 9, 'v': 3}, {'u': 1, 'v': 2}, {'u': 1, 'v': 5}, {'u': 2, 'v': 11}, {'u': 7, 'v': 11}, {'u': 8, 'v': 5}, {'u': 8, 'v': 13}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0008.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0008.png'}","[1, 8, 9, 11]",4.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [1, 8]}, {'id': 'S2', 'elements': [1, 12]}, {'id': 'S3', 'elements': [4, 8, 10, 13]}, {'id': 'S4', 'elements': [2, 5, 6, 8]}, {'id': 'S5', 'elements': [6, 9, 13]}, {'id': 'S6', 'elements': [2, 7, 11, 12]}, {'id': 'S7', 'elements': [1, 4, 6, 8, 9, 13]}, {'id': 'S8', 'elements': [3, 6]}, {'id': 'S9', 'elements': [10, 13]}, {'id': 'S10', 'elements': [1, 2, 7, 11, 12]}, {'id': 'S11', 'elements': [7, 12]}, {'id': 'S12', 'elements': [5, 8, 10, 13]}]}","['S1', 'S8', 'S9', 'S11']",9,json,1
SP,SP,"Recently the festival organizer asked for help picking the maximum number of booth pairings for the event: the measure of success is simply how many pairings are approved, counted up. There’s one ground rule — don’t allow two approved booths that sell the same thing, so each chosen booth must have a distinct product type. The concrete instance with booth details appears below.

- **total_product_types**: 18
- **total_booth_pairings**: 18

| pairing_id | product_types |
|---|---|
| S1 | 3 5 |
| S2 | 6 7 12 16 |
| S3 | 1 3 15 |
| S4 | 4 7 9 10 17 |
| S5 | 5 10 11 13 14 |
| S6 | 2 6 7 12 16 |
| S7 | 2 4 6 7 8 10 13 |
| S8 | 6 8 10 12 16 |
| S9 | 9 17 18 |
| S10 | 4 5 10 17 |
| S11 | 1 5 11 13 14 15 |
| S12 | 12 16 |
| S13 | 4 5 7 10 11 14 |
| S14 | 5 13 |
| S15 | 1 3 11 15 |
| S16 | 2 6 8 12 |
| S17 | 4 10 17 18 |
| S18 | 17 18 |

When you send back the approved booth choices, a simple JSON layout like this keeps things tidy and easy to read:

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

The ""solution"" list should contain the identifiers of the booths you've approved. ""booth_id"" is just a placeholder showing the shape — replace each placeholder with the actual booth labels from the instance. This JSON is just a sketch of the expected shape, not the real answer itself.

Please make sure to use the exact identifiers 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': 18, 'num_sets': 18, 'density': 0.22530864197530864, 'sets': [{'id': 1, 'elements': [3, 5]}, {'id': 2, 'elements': [6, 7, 12, 16]}, {'id': 3, 'elements': [1, 3, 15]}, {'id': 4, 'elements': [4, 7, 9, 10, 17]}, {'id': 5, 'elements': [5, 10, 11, 13, 14]}, {'id': 6, 'elements': [2, 6, 7, 12, 16]}, {'id': 7, 'elements': [2, 4, 6, 7, 8, 10, 13]}, {'id': 8, 'elements': [6, 8, 10, 12, 16]}, {'id': 9, 'elements': [9, 17, 18]}, {'id': 10, 'elements': [4, 5, 10, 17]}, {'id': 11, 'elements': [1, 5, 11, 13, 14, 15]}, {'id': 12, 'elements': [12, 16]}, {'id': 13, 'elements': [4, 5, 7, 10, 11, 14]}, {'id': 14, 'elements': [5, 13]}, {'id': 15, 'elements': [1, 3, 11, 15]}, {'id': 16, 'elements': [2, 6, 8, 12]}, {'id': 17, 'elements': [4, 10, 17, 18]}, {'id': 18, 'elements': [17, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 10, 'v': 4}, {'u': 10, 'v': 7}, {'u': 10, 'v': 13}, {'u': 4, 'v': 17}, {'u': 5, 'v': 11}, {'u': 5, 'v': 13}, {'u': 5, 'v': 14}, {'u': 3, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 17, 'v': 9}, {'u': 6, 'v': 12}, {'u': 12, 'v': 16}, {'u': 18, 'v': 9}, {'u': 11, 'v': 1}, {'u': 1, 'v': 15}, {'u': 2, 'v': 16}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0009.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0009.png'}","[3, 7, 12, 18]",4.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [3, 5]}, {'id': 'S2', 'elements': [6, 7, 12, 16]}, {'id': 'S3', 'elements': [1, 3, 15]}, {'id': 'S4', 'elements': [4, 7, 9, 10, 17]}, {'id': 'S5', 'elements': [5, 10, 11, 13, 14]}, {'id': 'S6', 'elements': [2, 6, 7, 12, 16]}, {'id': 'S7', 'elements': [2, 4, 6, 7, 8, 10, 13]}, {'id': 'S8', 'elements': [6, 8, 10, 12, 16]}, {'id': 'S9', 'elements': [9, 17, 18]}, {'id': 'S10', 'elements': [4, 5, 10, 17]}, {'id': 'S11', 'elements': [1, 5, 11, 13, 14, 15]}, {'id': 'S12', 'elements': [12, 16]}, {'id': 'S13', 'elements': [4, 5, 7, 10, 11, 14]}, {'id': 'S14', 'elements': [5, 13]}, {'id': 'S15', 'elements': [1, 3, 11, 15]}, {'id': 'S16', 'elements': [2, 6, 8, 12]}, {'id': 'S17', 'elements': [4, 10, 17, 18]}, {'id': 'S18', 'elements': [17, 18]}]}","['S3', 'S7', 'S12', 'S18']",10,markdown_table,1
SP,SP,"We were asked by the counseling office to organize study sessions from a list of suggested groups, trying to have as many separate groups as possible while making sure the groups don’t share any students. The decision is which group proposals to accept so the outcome has the largest possible count of groups; measure that by simply counting how many groups end up being scheduled. Every chosen group must have its own distinct set of students — no student may appear in more than one group. The specific students and the group options are listed below.

{
  ""total_students"": 18,
  ""total_group_proposals"": 18,
  ""sets"": [
    {
      ""group_id"": ""S1"",
      ""group_students"": [
        1,
        16
      ]
    },
    {
      ""group_id"": ""S2"",
      ""group_students"": [
        2,
        12
      ]
    },
    {
      ""group_id"": ""S3"",
      ""group_students"": [
        8,
        9,
        11,
        13
      ]
    },
    {
      ""group_id"": ""S4"",
      ""group_students"": [
        3,
        8
      ]
    },
    {
      ""group_id"": ""S5"",
      ""group_students"": [
        3,
        6,
        7,
        9,
        15
      ]
    },
    {
      ""group_id"": ""S6"",
      ""group_students"": [
        6,
        7,
        8,
        15
      ]
    },
    {
      ""group_id"": ""S7"",
      ""group_students"": [
        5,
        7,
        8
      ]
    },
    {
      ""group_id"": ""S8"",
      ""group_students"": [
        3,
        4,
        5,
        7,
        8,
        11
      ]
    },
    {
      ""group_id"": ""S9"",
      ""group_students"": [
        5,
        8,
        9,
        10,
        11,
        13
      ]
    },
    {
      ""group_id"": ""S10"",
      ""group_students"": [
        8,
        9,
        10,
        11,
        14,
        16,
        17,
        18
      ]
    },
    {
      ""group_id"": ""S11"",
      ""group_students"": [
        4,
        8,
        10,
        12,
        13
      ]
    },
    {
      ""group_id"": ""S12"",
      ""group_students"": [
        2,
        11,
        12,
        13
      ]
    },
    {
      ""group_id"": ""S13"",
      ""group_students"": [
        2,
        3,
        9,
        11,
        13
      ]
    },
    {
      ""group_id"": ""S14"",
      ""group_students"": [
        14,
        16,
        17,
        18
      ]
    },
    {
      ""group_id"": ""S15"",
      ""group_students"": [
        5,
        15
      ]
    },
    {
      ""group_id"": ""S16"",
      ""group_students"": [
        1,
        9,
        14,
        16,
        18
      ]
    },
    {
      ""group_id"": ""S17"",
      ""group_students"": [
        10,
        14,
        16,
        17
      ]
    },
    {
      ""group_id"": ""S18"",
      ""group_students"": [
        10,
        16,
        17,
        18
      ]
    }
  ]
}

If you want to tell me which groups to accept, just send the answer in a tiny JSON snippet like this so it's easy to read and check:

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

This just means ""solution"" should be a list of the group IDs you want to schedule. The example uses ""group_id"" as a placeholder — in your reply, put the actual IDs from the instance instead of that placeholder. Think of it like filling out a quick form: one array with the chosen group labels.

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

Also, 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': 18, 'num_sets': 18, 'density': 0.23148148148148148, 'sets': [{'id': 1, 'elements': [1, 16]}, {'id': 2, 'elements': [2, 12]}, {'id': 3, 'elements': [8, 9, 11, 13]}, {'id': 4, 'elements': [3, 8]}, {'id': 5, 'elements': [3, 6, 7, 9, 15]}, {'id': 6, 'elements': [6, 7, 8, 15]}, {'id': 7, 'elements': [5, 7, 8]}, {'id': 8, 'elements': [3, 4, 5, 7, 8, 11]}, {'id': 9, 'elements': [5, 8, 9, 10, 11, 13]}, {'id': 10, 'elements': [8, 9, 10, 11, 14, 16, 17, 18]}, {'id': 11, 'elements': [4, 8, 10, 12, 13]}, {'id': 12, 'elements': [2, 11, 12, 13]}, {'id': 13, 'elements': [2, 3, 9, 11, 13]}, {'id': 14, 'elements': [14, 16, 17, 18]}, {'id': 15, 'elements': [5, 15]}, {'id': 16, 'elements': [1, 9, 14, 16, 18]}, {'id': 17, 'elements': [10, 14, 16, 17]}, {'id': 18, 'elements': [10, 16, 17, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 14, 'v': 16}, {'u': 2, 'v': 12}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 15, 'v': 6}, {'u': 16, 'v': 10}, {'u': 16, 'v': 17}, {'u': 16, 'v': 18}, {'u': 17, 'v': 1}, {'u': 12, 'v': 13}, {'u': 13, 'v': 11}, {'u': 3, 'v': 4}, {'u': 3, 'v': 8}, {'u': 3, 'v': 11}, {'u': 8, 'v': 9}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0010.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0010.png'}","[1, 2, 4, 15]",4.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [1, 16]}, {'id': 'S2', 'elements': [2, 12]}, {'id': 'S3', 'elements': [8, 9, 11, 13]}, {'id': 'S4', 'elements': [3, 8]}, {'id': 'S5', 'elements': [3, 6, 7, 9, 15]}, {'id': 'S6', 'elements': [6, 7, 8, 15]}, {'id': 'S7', 'elements': [5, 7, 8]}, {'id': 'S8', 'elements': [3, 4, 5, 7, 8, 11]}, {'id': 'S9', 'elements': [5, 8, 9, 10, 11, 13]}, {'id': 'S10', 'elements': [8, 9, 10, 11, 14, 16, 17, 18]}, {'id': 'S11', 'elements': [4, 8, 10, 12, 13]}, {'id': 'S12', 'elements': [2, 11, 12, 13]}, {'id': 'S13', 'elements': [2, 3, 9, 11, 13]}, {'id': 'S14', 'elements': [14, 16, 17, 18]}, {'id': 'S15', 'elements': [5, 15]}, {'id': 'S16', 'elements': [1, 9, 14, 16, 18]}, {'id': 'S17', 'elements': [10, 14, 16, 17]}, {'id': 'S18', 'elements': [10, 16, 17, 18]}]}","['S1', 'S2', 'S4', 'S15']",11,json,1
SP,SP,"Many people signed up across a handful of time slots, and the coordinator now has to lock in which shifts will actually happen. The plan is to include as many shifts as possible, but any person who shows up on more than one of the candidate shifts must only appear once among the shifts that are kept. A schedule’s quality is just the number of shifts it keeps open, counted directly, and the full list of volunteers and shift times is provided below.

- **total_volunteers**: 17
- **total_candidate_shifts**: 16

| shift_id | volunteers |
|---|---|
| S1 | 2 5 7 |
| S2 | 1 3 4 7 8 |
| S3 | 0 6 7 13 |
| S4 | 3 4 8 14 |
| S5 | 1 3 4 7 9 13 |
| S6 | 0 5 13 |
| S7 | 2 6 13 |
| S8 | 0 3 4 7 9 10 |
| S9 | 1 3 4 8 |
| S10 | 4 7 9 13 15 |
| S11 | 10 11 15 16 |
| S12 | 10 11 |
| S13 | 2 4 5 6 7 12 13 15 |
| S14 | 1 4 14 |
| S15 | 4 7 9 11 13 15 16 |
| S16 | 7 15 16 |

If you want to send back which shifts to keep, just give the answer in a tiny JSON snippet — nothing fancy. For this story I’ll sketch it like this:

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

Here ""solution"" is the list of shift identifiers you want to keep open (one per selected shift). The example value ""shift_id"" is just a placeholder to show the shape — replace each placeholder with the actual shift id from the instance when you answer. The JSON is just a sketch of the expected shape, not the real selection.

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': 17, 'num_sets': 16, 'density': 0.25735294117647056, 'sets': [{'id': 1, 'elements': [3, 6, 8]}, {'id': 2, 'elements': [2, 4, 5, 8, 9]}, {'id': 3, 'elements': [1, 7, 8, 14]}, {'id': 4, 'elements': [4, 5, 9, 15]}, {'id': 5, 'elements': [2, 4, 5, 8, 10, 14]}, {'id': 6, 'elements': [1, 6, 14]}, {'id': 7, 'elements': [3, 7, 14]}, {'id': 8, 'elements': [1, 4, 5, 8, 10, 11]}, {'id': 9, 'elements': [2, 4, 5, 9]}, {'id': 10, 'elements': [5, 8, 10, 14, 16]}, {'id': 11, 'elements': [11, 12, 16, 17]}, {'id': 12, 'elements': [11, 12]}, {'id': 13, 'elements': [3, 5, 6, 7, 8, 13, 14, 16]}, {'id': 14, 'elements': [2, 5, 15]}, {'id': 15, 'elements': [5, 8, 10, 12, 14, 16, 17]}, {'id': 16, 'elements': [8, 16, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 6, 'v': 1}, {'u': 7, 'v': 3}, {'u': 16, 'v': 8}, {'u': 16, 'v': 11}, {'u': 16, 'v': 17}, {'u': 1, 'v': 14}, {'u': 8, 'v': 5}, {'u': 8, 'v': 10}, {'u': 8, 'v': 14}, {'u': 9, 'v': 2}, {'u': 14, 'v': 3}, {'u': 13, 'v': 3}, {'u': 5, 'v': 2}, {'u': 5, 'v': 4}, {'u': 11, 'v': 12}, {'u': 4, 'v': 2}, {'u': 4, 'v': 15}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0011.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0011.png'}","[4, 7, 12, 16]",4.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [2, 5, 7]}, {'id': 'S2', 'elements': [1, 3, 4, 7, 8]}, {'id': 'S3', 'elements': [0, 6, 7, 13]}, {'id': 'S4', 'elements': [3, 4, 8, 14]}, {'id': 'S5', 'elements': [1, 3, 4, 7, 9, 13]}, {'id': 'S6', 'elements': [0, 5, 13]}, {'id': 'S7', 'elements': [2, 6, 13]}, {'id': 'S8', 'elements': [0, 3, 4, 7, 9, 10]}, {'id': 'S9', 'elements': [1, 3, 4, 8]}, {'id': 'S10', 'elements': [4, 7, 9, 13, 15]}, {'id': 'S11', 'elements': [10, 11, 15, 16]}, {'id': 'S12', 'elements': [10, 11]}, {'id': 'S13', 'elements': [2, 4, 5, 6, 7, 12, 13, 15]}, {'id': 'S14', 'elements': [1, 4, 14]}, {'id': 'S15', 'elements': [4, 7, 9, 11, 13, 15, 16]}, {'id': 'S16', 'elements': [7, 15, 16]}]}","['S4', 'S7', 'S12', 'S16']",12,markdown_table,0
SP,SP,"There’s a curator trying to make the gallery look full by arranging as many mini exhibits as possible, but every mini exhibit is a fixed group of artifacts and no artifact is allowed to appear in more than one display. A good arrangement is judged by how many separate exhibits end up on the floor — simply tally the selected exhibits — and every selected exhibit must be complete and artifact-unique. The specific exhibit descriptions and their artifacts are shown below.

Below are 12 mini exhibits using 13 distinct artifacts:
Mini exhibit S1 contains the artifacts 0 1 4 11 12.
Mini exhibit S2 contains the artifacts 0 1 9.
Mini exhibit S3 contains the artifacts 2 3 10.
Mini exhibit S4 contains the artifacts 2 5 8.
Mini exhibit S5 contains the artifacts 0 4 6 9.
Mini exhibit S6 contains the artifacts 1 2 3 8 10.
Mini exhibit S7 contains the artifacts 1 4 6 9 10 11.
Mini exhibit S8 contains the artifacts 7 9 12.
Mini exhibit S9 contains the artifacts 3 5.
Mini exhibit S10 contains the artifacts 0 1 6 7 9 11 12.
Mini exhibit S11 contains the artifacts 1 2 5 10.
Mini exhibit S12 contains the artifacts 0 6 9 11.
The curator must select as many complete, artifact-unique mini exhibits as possible to make the gallery look full.

Oh — just put your final pick in a tiny JSON snippet like this so it's easy to check:

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

Think of ""solution"" as the list of exhibits you decided to put on the floor; each item in the array is the ID of one complete exhibit. This block is just the shape I want you to follow — it's a sketch, not the actual answer itself.

Please make sure to use the exhibit IDs 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': 13, 'num_sets': 12, 'density': 0.3141025641025641, 'sets': [{'id': 1, 'elements': [1, 2, 5, 12, 13]}, {'id': 2, 'elements': [1, 2, 10]}, {'id': 3, 'elements': [3, 4, 11]}, {'id': 4, 'elements': [3, 6, 9]}, {'id': 5, 'elements': [1, 5, 7, 10]}, {'id': 6, 'elements': [2, 3, 4, 9, 11]}, {'id': 7, 'elements': [2, 5, 7, 10, 11, 12]}, {'id': 8, 'elements': [8, 10, 13]}, {'id': 9, 'elements': [4, 6]}, {'id': 10, 'elements': [1, 2, 7, 8, 10, 12, 13]}, {'id': 11, 'elements': [2, 3, 6, 11]}, {'id': 12, 'elements': [1, 7, 10, 12]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 11, 'v': 2}, {'u': 11, 'v': 6}, {'u': 13, 'v': 8}, {'u': 13, 'v': 10}, {'u': 9, 'v': 4}, {'u': 5, 'v': 1}, {'u': 2, 'v': 7}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 12, 'v': 10}, {'u': 10, 'v': 1}, {'u': 10, 'v': 7}, {'u': 1, 'v': 7}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0012.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0012.png'}","[5, 9]",2.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [0, 1, 4, 11, 12]}, {'id': 'S2', 'elements': [0, 1, 9]}, {'id': 'S3', 'elements': [2, 3, 10]}, {'id': 'S4', 'elements': [2, 5, 8]}, {'id': 'S5', 'elements': [0, 4, 6, 9]}, {'id': 'S6', 'elements': [1, 2, 3, 8, 10]}, {'id': 'S7', 'elements': [1, 4, 6, 9, 10, 11]}, {'id': 'S8', 'elements': [7, 9, 12]}, {'id': 'S9', 'elements': [3, 5]}, {'id': 'S10', 'elements': [0, 1, 6, 7, 9, 11, 12]}, {'id': 'S11', 'elements': [1, 2, 5, 10]}, {'id': 'S12', 'elements': [0, 6, 9, 11]}]}","['S5', 'S9']",13,nl,0
SP,SP,"Many people on the organizing committee are juggling overlapping workshop proposals, each with its own speaker list. The goal is to fit in the largest number of workshops they can — a better schedule is the one with a higher headcount of selected workshops, determined by a straight count. To keep things realistic, nobody listed as a speaker can be put into more than one of the workshops that get picked. The concrete details are shown below.

# num_speakers=17
# num_workshops=15
workshop_id,speakers
S1,A J N
S2,B D N
S3,A I J L N
S4,E O
S5,C F I L
S6,H M N O
S7,C F I K M
S8,A N O P
S9,I K L M
S10,F I K L M O
S11,H K L M N O
S12,A B M N Q
S13,E G J N O Q
S14,A P
S15,J Q

Also, when you send back which workshops made the cut, a tiny JSON snippet like this is perfect:

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

Here ""solution"" is just the list of the chosen workshop IDs (one string per workshop). The ""workshop_id"" text in the example is only a placeholder showing the format — in your actual reply replace those placeholders with the real IDs from the instance. This JSON is just the expected shape, not the actual answer.

Please be sure to use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 15, 'density': 0.23921568627450981, 'sets': [{'id': 1, 'elements': [1, 10, 14]}, {'id': 2, 'elements': [2, 4, 14]}, {'id': 3, 'elements': [1, 9, 10, 12, 14]}, {'id': 4, 'elements': [5, 15]}, {'id': 5, 'elements': [3, 6, 9, 12]}, {'id': 6, 'elements': [8, 13, 14, 15]}, {'id': 7, 'elements': [3, 6, 9, 11, 13]}, {'id': 8, 'elements': [1, 14, 15, 16]}, {'id': 9, 'elements': [9, 11, 12, 13]}, {'id': 10, 'elements': [6, 9, 11, 12, 13, 15]}, {'id': 11, 'elements': [8, 11, 12, 13, 14, 15]}, {'id': 12, 'elements': [1, 2, 13, 14, 17]}, {'id': 13, 'elements': [5, 7, 10, 14, 15, 17]}, {'id': 14, 'elements': [1, 16]}, {'id': 15, 'elements': [10, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 11, 'v': 12}, {'u': 8, 'v': 5}, {'u': 8, 'v': 7}, {'u': 8, 'v': 15}, {'u': 6, 'v': 9}, {'u': 15, 'v': 13}, {'u': 15, 'v': 14}, {'u': 17, 'v': 2}, {'u': 17, 'v': 14}, {'u': 12, 'v': 9}, {'u': 12, 'v': 13}, {'u': 9, 'v': 3}, {'u': 14, 'v': 10}, {'u': 3, 'v': 10}, {'u': 4, 'v': 2}, {'u': 1, 'v': 10}, {'u': 1, 'v': 16}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0013.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0013.png'}","[2, 4, 5, 14, 15]",5.0,"{'num_elements': 17, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': ['A', 'J', 'N']}, {'id': 'S2', 'elements': ['B', 'D', 'N']}, {'id': 'S3', 'elements': ['A', 'I', 'J', 'L', 'N']}, {'id': 'S4', 'elements': ['E', 'O']}, {'id': 'S5', 'elements': ['C', 'F', 'I', 'L']}, {'id': 'S6', 'elements': ['H', 'M', 'N', 'O']}, {'id': 'S7', 'elements': ['C', 'F', 'I', 'K', 'M']}, {'id': 'S8', 'elements': ['A', 'N', 'O', 'P']}, {'id': 'S9', 'elements': ['I', 'K', 'L', 'M']}, {'id': 'S10', 'elements': ['F', 'I', 'K', 'L', 'M', 'O']}, {'id': 'S11', 'elements': ['H', 'K', 'L', 'M', 'N', 'O']}, {'id': 'S12', 'elements': ['A', 'B', 'M', 'N', 'Q']}, {'id': 'S13', 'elements': ['E', 'G', 'J', 'N', 'O', 'Q']}, {'id': 'S14', 'elements': ['A', 'P']}, {'id': 'S15', 'elements': ['J', 'Q']}]}","['S2', 'S4', 'S5', 'S14', 'S15']",14,csv,names
SP,SP,"I was helping a car rental specialist figure out which tour bundles to offer so the shop can sell as many different packages as possible. The decision is which specific tour packages to pick from the list, and “better” means the shop ends up with a bigger count of bundles ready to sell — you can measure success simply by counting how many bundles are chosen. The catch is that no vehicle can show up in two different selected bundles, so each chosen package has to rely on a distinct set of cars. The exact list of packages and which vehicles they use is shown below.

I counted 13 distinct vehicles and 11 packages.
Package S1 uses vehicles 1 2 3.
Package S2 uses vehicles 1 2 3 4 8 10 13.
Package S3 uses vehicles 1 2 6 8 9 10.
Package S4 uses vehicles 1 2 4.
Package S5 uses vehicles 3 5 9 10.
Package S6 uses vehicles 6 8 10.
Package S7 uses vehicles 3 5 6 7 10.
Package S8 uses vehicles 3 6 9 11 12.
Package S9 uses vehicles 2 6 7 9 11 12.
Package S10 uses vehicles 9 10 11 12.
Package S11 uses vehicles 9 11 12.
I'll use this list to pick as many non-overlapping packages as possible.

When I give the final selection I'll drop it into a tiny JSON snippet so it's easy to read and copy, something like this:

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

Here ""solution"" is just a list of the tour package IDs you should offer — each entry is the exact package identifier from the list above. Think of it like filling in a simple form: one array, many chosen package IDs.

This JSON is only a sketch of the expected shape, not the real 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 11, 'density': 0.34265734265734266, 'sets': [{'id': 1, 'elements': [1, 2, 3]}, {'id': 2, 'elements': [1, 2, 3, 4, 8, 10, 13]}, {'id': 3, 'elements': [1, 2, 6, 8, 9, 10]}, {'id': 4, 'elements': [1, 2, 4]}, {'id': 5, 'elements': [3, 5, 9, 10]}, {'id': 6, 'elements': [6, 8, 10]}, {'id': 7, 'elements': [3, 5, 6, 7, 10]}, {'id': 8, 'elements': [3, 6, 9, 11, 12]}, {'id': 9, 'elements': [2, 6, 7, 9, 11, 12]}, {'id': 10, 'elements': [9, 10, 11, 12]}, {'id': 11, 'elements': [9, 11, 12]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 10}, {'u': 8, 'v': 3}, {'u': 8, 'v': 5}, {'u': 10, 'v': 3}, {'u': 10, 'v': 9}, {'u': 3, 'v': 2}, {'u': 2, 'v': 1}, {'u': 1, 'v': 4}, {'u': 1, 'v': 13}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0014.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0014.png'}","[4, 6, 11]",3.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [1, 2, 3]}, {'id': 'S2', 'elements': [1, 2, 3, 4, 8, 10, 13]}, {'id': 'S3', 'elements': [1, 2, 6, 8, 9, 10]}, {'id': 'S4', 'elements': [1, 2, 4]}, {'id': 'S5', 'elements': [3, 5, 9, 10]}, {'id': 'S6', 'elements': [6, 8, 10]}, {'id': 'S7', 'elements': [3, 5, 6, 7, 10]}, {'id': 'S8', 'elements': [3, 6, 9, 11, 12]}, {'id': 'S9', 'elements': [2, 6, 7, 9, 11, 12]}, {'id': 'S10', 'elements': [9, 10, 11, 12]}, {'id': 'S11', 'elements': [9, 11, 12]}]}","['S4', 'S6', 'S11']",15,nl,1
SP,SP,"I run a small tutoring service and my job is to pick which group lessons to hold each week. The choice is simple: try to fit in as many of those proposed sessions as possible, but never schedule two sessions that include the same student — each student can only show up to one of the chosen sessions. A better plan is just the one with more sessions happening, and success is measured by counting how many sessions got scheduled. The exact list of session options and which students would attend each is shown below.

# total_students=13
# total_sessions=13
session_id,session_students
S1,A B E F H J
S2,E F J
S3,D F K L M
S4,A D H K M
S5,A E I J L
S6,A B C F G M
S7,G H
S8,D F G H
S9,E I J K L
S10,A B E F I J
S11,C I L
S12,C E I L
S13,C D M

Oh, and when you send back the chosen sessions, just stick to a tiny JSON shape so it's easy to read by whatever I'm using to collect schedules. Something like this will do:

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

Here ""solution"" is the list of the session identifiers you want to run this week — each entry is one session to schedule. Think of it like filling out a simple form: put the exact IDs of the sessions you pick into that array. This is just a sketch of the shape I need, not the final answer itself.

Please use the exact identifiers from the instance input — no renaming and no new labels. For example:
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.33727810650887574, 'sets': [{'id': 1, 'elements': [1, 2, 5, 6, 8, 10]}, {'id': 2, 'elements': [5, 6, 10]}, {'id': 3, 'elements': [4, 6, 11, 12, 13]}, {'id': 4, 'elements': [1, 4, 8, 11, 13]}, {'id': 5, 'elements': [1, 5, 9, 10, 12]}, {'id': 6, 'elements': [1, 2, 3, 6, 7, 13]}, {'id': 7, 'elements': [7, 8]}, {'id': 8, 'elements': [4, 6, 7, 8]}, {'id': 9, 'elements': [5, 9, 10, 11, 12]}, {'id': 10, 'elements': [1, 2, 5, 6, 9, 10]}, {'id': 11, 'elements': [3, 9, 12]}, {'id': 12, 'elements': [3, 5, 9, 12]}, {'id': 13, 'elements': [3, 4, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 12, 'v': 9}, {'u': 12, 'v': 11}, {'u': 3, 'v': 4}, {'u': 3, 'v': 11}, {'u': 13, 'v': 4}, {'u': 1, 'v': 2}, {'u': 1, 'v': 6}, {'u': 1, 'v': 10}, {'u': 9, 'v': 5}, {'u': 7, 'v': 8}, {'u': 2, 'v': 10}, {'u': 6, 'v': 4}, {'u': 6, 'v': 8}, {'u': 5, 'v': 10}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0015.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0015.png'}","[2, 7, 13]",3.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'E', 'F', 'H', 'J']}, {'id': 'S2', 'elements': ['E', 'F', 'J']}, {'id': 'S3', 'elements': ['D', 'F', 'K', 'L', 'M']}, {'id': 'S4', 'elements': ['A', 'D', 'H', 'K', 'M']}, {'id': 'S5', 'elements': ['A', 'E', 'I', 'J', 'L']}, {'id': 'S6', 'elements': ['A', 'B', 'C', 'F', 'G', 'M']}, {'id': 'S7', 'elements': ['G', 'H']}, {'id': 'S8', 'elements': ['D', 'F', 'G', 'H']}, {'id': 'S9', 'elements': ['E', 'I', 'J', 'K', 'L']}, {'id': 'S10', 'elements': ['A', 'B', 'E', 'F', 'I', 'J']}, {'id': 'S11', 'elements': ['C', 'I', 'L']}, {'id': 'S12', 'elements': ['C', 'E', 'I', 'L']}, {'id': 'S13', 'elements': ['C', 'D', 'M']}]}","['S2', 'S7', 'S13']",16,csv,names
SP,SP,"On Monday the supervisor left a binder of experimental configurations and asked for the maximum number of them to be prepared for use. Every configuration specifies what instruments it needs, and instruments can’t be shared across selected configurations — each chosen configuration must have exclusive use of its items and be fully assembled. One selection beats another if it results in a greater number of complete configurations; to judge that, simply count how many configurations are ready. The binder’s exact configuration details are provided below.

# total_unique_instruments=14
# total_configurations=11
configuration_id,required_instruments
S1,0 1 4 6 7 8 12 13
S2,0 1 2 6 7 11
S3,1 3 5 7 11
S4,1 2 3 8
S5,9 13
S6,1 2 5 7 11
S7,0 1 2 7
S8,0 1
S9,4 9 10 12 13
S10,1 2 3 7 9 12
S11,0 1 2 3 6 8 9 11

Also, when you send back which configurations to prepare, just follow this simple JSON layout — nothing fancy:

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

Here ""solution"" is the list (an array) of configuration IDs you want prepared. The example entry ""config_id"" is just a placeholder for a single configuration identifier from the binder. Think of it like filling out a short form: list each chosen configuration's ID inside that array. This JSON is only a sketch of the shape I expect, not the actual answer.

Make sure you use the identifiers exactly as they appear in the instance input — no renaming and no new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 11, 'density': 0.35714285714285715, 'sets': [{'id': 1, 'elements': [1, 2, 5, 7, 8, 9, 13, 14]}, {'id': 2, 'elements': [1, 2, 3, 7, 8, 12]}, {'id': 3, 'elements': [2, 4, 6, 8, 12]}, {'id': 4, 'elements': [2, 3, 4, 9]}, {'id': 5, 'elements': [10, 14]}, {'id': 6, 'elements': [2, 3, 6, 8, 12]}, {'id': 7, 'elements': [1, 2, 3, 8]}, {'id': 8, 'elements': [1, 2]}, {'id': 9, 'elements': [5, 10, 11, 13, 14]}, {'id': 10, 'elements': [2, 3, 4, 8, 10, 13]}, {'id': 11, 'elements': [1, 2, 3, 4, 7, 9, 10, 12]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 12, 'v': 1}, {'u': 12, 'v': 2}, {'u': 12, 'v': 8}, {'u': 14, 'v': 10}, {'u': 11, 'v': 5}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 7}, {'u': 13, 'v': 9}, {'u': 8, 'v': 6}, {'u': 9, 'v': 4}, {'u': 6, 'v': 3}, {'u': 1, 'v': 10}, {'u': 3, 'v': 2}, {'u': 4, 'v': 2}, {'u': 10, 'v': 5}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0016.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0016.png'}","[3, 5]",2.0,"{'num_elements': 14, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [0, 1, 4, 6, 7, 8, 12, 13]}, {'id': 'S2', 'elements': [0, 1, 2, 6, 7, 11]}, {'id': 'S3', 'elements': [1, 3, 5, 7, 11]}, {'id': 'S4', 'elements': [1, 2, 3, 8]}, {'id': 'S5', 'elements': [9, 13]}, {'id': 'S6', 'elements': [1, 2, 5, 7, 11]}, {'id': 'S7', 'elements': [0, 1, 2, 7]}, {'id': 'S8', 'elements': [0, 1]}, {'id': 'S9', 'elements': [4, 9, 10, 12, 13]}, {'id': 'S10', 'elements': [1, 2, 3, 7, 9, 12]}, {'id': 'S11', 'elements': [0, 1, 2, 3, 6, 8, 9, 11]}]}","['S3', 'S5']",17,csv,0
SP,SP,"Someone at the festival office is sorting through block proposals and wants to lock in the largest possible set of blocks for the week. They can pick any of the ready blocks, but they must avoid picking two blocks that share the same film — a film can’t be scheduled twice. The quality of a plan is just how many blocks it contains, so just count selected blocks to compare options. The full list of blocks and films appears below.

{
  ""num_films_total"": 14,
  ""num_blocks_available"": 11,
  ""sets"": [
    {
      ""block_id"": ""S1"",
      ""films_in_block"": [
        0,
        1,
        9,
        10,
        13
      ]
    },
    {
      ""block_id"": ""S2"",
      ""films_in_block"": [
        0,
        1,
        10,
        13
      ]
    },
    {
      ""block_id"": ""S3"",
      ""films_in_block"": [
        3,
        5,
        8
      ]
    },
    {
      ""block_id"": ""S4"",
      ""films_in_block"": [
        0,
        4,
        9,
        12
      ]
    },
    {
      ""block_id"": ""S5"",
      ""films_in_block"": [
        7,
        8,
        11,
        12
      ]
    },
    {
      ""block_id"": ""S6"",
      ""films_in_block"": [
        7,
        11,
        12
      ]
    },
    {
      ""block_id"": ""S7"",
      ""films_in_block"": [
        0,
        1,
        3,
        4,
        5,
        6,
        7,
        9,
        11,
        13
      ]
    },
    {
      ""block_id"": ""S8"",
      ""films_in_block"": [
        0,
        2,
        3,
        4,
        8,
        9
      ]
    },
    {
      ""block_id"": ""S9"",
      ""films_in_block"": [
        0,
        1,
        8,
        13
      ]
    },
    {
      ""block_id"": ""S10"",
      ""films_in_block"": [
        6,
        7,
        8,
        11,
        12
      ]
    },
    {
      ""block_id"": ""S11"",
      ""films_in_block"": [
        0,
        4,
        6,
        9,
        11,
        12
      ]
    }
  ]
}

When you’re ready, just drop the chosen block IDs into a tiny JSON object like this — super simple, just a list of the blocks you want to lock in.

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

""solution"" is just the list of selected block identifiers (one per chosen block). Think of it like filling in a short form: put each block’s exact ID in that array. This JSON is just a sketch of the shape I need, not the final selection itself.

Please use the identifiers exactly as they appear in 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': 14, 'num_sets': 11, 'density': 0.35064935064935066, 'sets': [{'id': 1, 'elements': [1, 2, 10, 11, 14]}, {'id': 2, 'elements': [1, 2, 11, 14]}, {'id': 3, 'elements': [4, 6, 9]}, {'id': 4, 'elements': [1, 5, 10, 13]}, {'id': 5, 'elements': [8, 9, 12, 13]}, {'id': 6, 'elements': [8, 12, 13]}, {'id': 7, 'elements': [1, 2, 4, 5, 6, 7, 8, 10, 12, 14]}, {'id': 8, 'elements': [1, 3, 4, 5, 9, 10]}, {'id': 9, 'elements': [1, 2, 9, 14]}, {'id': 10, 'elements': [7, 8, 9, 12, 13]}, {'id': 11, 'elements': [1, 5, 7, 10, 12, 13]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 7, 'v': 13}, {'u': 8, 'v': 13}, {'u': 11, 'v': 1}, {'u': 13, 'v': 9}, {'u': 13, 'v': 12}, {'u': 1, 'v': 2}, {'u': 1, 'v': 9}, {'u': 1, 'v': 14}, {'u': 9, 'v': 5}, {'u': 9, 'v': 10}, {'u': 10, 'v': 4}, {'u': 10, 'v': 6}, {'u': 3, 'v': 4}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0017.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0017.png'}","[2, 3, 6]",3.0,"{'num_elements': 14, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [0, 1, 9, 10, 13]}, {'id': 'S2', 'elements': [0, 1, 10, 13]}, {'id': 'S3', 'elements': [3, 5, 8]}, {'id': 'S4', 'elements': [0, 4, 9, 12]}, {'id': 'S5', 'elements': [7, 8, 11, 12]}, {'id': 'S6', 'elements': [7, 11, 12]}, {'id': 'S7', 'elements': [0, 1, 3, 4, 5, 6, 7, 9, 11, 13]}, {'id': 'S8', 'elements': [0, 2, 3, 4, 8, 9]}, {'id': 'S9', 'elements': [0, 1, 8, 13]}, {'id': 'S10', 'elements': [6, 7, 8, 11, 12]}, {'id': 'S11', 'elements': [0, 4, 6, 9, 11, 12]}]}","['S2', 'S3', 'S6']",18,json,0
SP,SP,"On Saturday the parent wanted to hand out as many picnic baskets as possible to neighbors, but insisted that no food item be duplicated across the baskets that are actually given away. A better plan is the one that results in a greater number of baskets ready to go — the outcome is measured by counting those non-repeating baskets. The full details of each possible basket and its contents are listed below.

# total_unique_food_items=17
# total_baskets_available=16
basket_id,food_items
S1,0 3 8 12 15
S2,2 13
S3,1 2 8 13
S4,0 12
S5,4 5 6 7 10
S6,0 5 6 8 11 12
S7,5 11 16
S8,2 5 8 11 15
S9,11 14
S10,7 10
S11,0 5 6 7 8 9 11 14 15 16
S12,0 3 5 12
S13,1 2 5 8 13
S14,5 9 11 14
S15,8 15
S16,6 11 16

If you want to reply with the chosen baskets, a small JSON snippet like this works nicely — just put the IDs of the baskets you’d hand out in the list:

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

Here ""solution"" is the list of ready-to-go picnic baskets, and each ""basket_id"" is a placeholder for the exact basket identifier from the instance. Think of it like filling out a short form: list the baskets you’re actually giving, one ID per entry. This JSON is only a sketch of the shape I’m expecting, not the final answer itself.

Please use the exact identifiers from the problem instance — don’t rename them and don’t invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 16, 'density': 0.23529411764705882, 'sets': [{'id': 1, 'elements': [1, 4, 9, 13, 16]}, {'id': 2, 'elements': [3, 14]}, {'id': 3, 'elements': [2, 3, 9, 14]}, {'id': 4, 'elements': [1, 13]}, {'id': 5, 'elements': [5, 6, 7, 8, 11]}, {'id': 6, 'elements': [1, 6, 7, 9, 12, 13]}, {'id': 7, 'elements': [6, 12, 17]}, {'id': 8, 'elements': [3, 6, 9, 12, 16]}, {'id': 9, 'elements': [12, 15]}, {'id': 10, 'elements': [8, 11]}, {'id': 11, 'elements': [1, 6, 7, 8, 9, 10, 12, 15, 16, 17]}, {'id': 12, 'elements': [1, 4, 6, 13]}, {'id': 13, 'elements': [2, 3, 6, 9, 14]}, {'id': 14, 'elements': [6, 10, 12, 15]}, {'id': 15, 'elements': [9, 16]}, {'id': 16, 'elements': [7, 12, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 7, 'v': 12}, {'u': 7, 'v': 17}, {'u': 5, 'v': 8}, {'u': 5, 'v': 12}, {'u': 2, 'v': 3}, {'u': 14, 'v': 3}, {'u': 14, 'v': 9}, {'u': 16, 'v': 6}, {'u': 9, 'v': 6}, {'u': 12, 'v': 6}, {'u': 12, 'v': 15}, {'u': 1, 'v': 6}, {'u': 1, 'v': 13}, {'u': 15, 'v': 10}, {'u': 4, 'v': 13}, {'u': 8, 'v': 11}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0018.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0018.png'}","[2, 4, 7, 10, 15]",5.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [0, 3, 8, 12, 15]}, {'id': 'S2', 'elements': [2, 13]}, {'id': 'S3', 'elements': [1, 2, 8, 13]}, {'id': 'S4', 'elements': [0, 12]}, {'id': 'S5', 'elements': [4, 5, 6, 7, 10]}, {'id': 'S6', 'elements': [0, 5, 6, 8, 11, 12]}, {'id': 'S7', 'elements': [5, 11, 16]}, {'id': 'S8', 'elements': [2, 5, 8, 11, 15]}, {'id': 'S9', 'elements': [11, 14]}, {'id': 'S10', 'elements': [7, 10]}, {'id': 'S11', 'elements': [0, 5, 6, 7, 8, 9, 11, 14, 15, 16]}, {'id': 'S12', 'elements': [0, 3, 5, 12]}, {'id': 'S13', 'elements': [1, 2, 5, 8, 13]}, {'id': 'S14', 'elements': [5, 9, 11, 14]}, {'id': 'S15', 'elements': [8, 15]}, {'id': 'S16', 'elements': [6, 11, 16]}]}","['S2', 'S4', 'S7', 'S10', 'S15']",19,csv,0
SP,SP,"Someone running a boutique asked for help arranging window scenes—her brief is brief: create as many unique displays as possible while never putting the same item (bag, bracelet, hat, etc.) into two different windows. So the choice is which display proposals to use so they don’t overlap in accessories; the better choice is the one that gives the biggest count of chosen windows, and you figure that out simply by tallying them. The specific proposals and what each contains are listed below.

# total_accessories=13
# total_display_proposals=13
display_id,accessories
S1,A D H J
S2,B D H L M
S3,C D K
S4,A B H I L
S5,F I J
S6,E F G I L
S7,F G H
S8,A D G H J K L
S9,D E F I L
S10,A G H
S11,B C H K L
S12,B D F H K
S13,D M

When you send your pick back, just use a tiny JSON snippet like this so it's easy to read and check:

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

That's just a sketch: ""solution"" should be an array of the display proposals you choose, and each item in that array is the identifier for one proposal (replace the placeholder set_id with the actual ids from the instance). Think of it like a short form where you list which windows to use.

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': 13, 'num_sets': 13, 'density': 0.3254437869822485, 'sets': [{'id': 1, 'elements': [1, 4, 8, 10]}, {'id': 2, 'elements': [2, 4, 8, 12, 13]}, {'id': 3, 'elements': [3, 4, 11]}, {'id': 4, 'elements': [1, 2, 8, 9, 12]}, {'id': 5, 'elements': [6, 9, 10]}, {'id': 6, 'elements': [5, 6, 7, 9, 12]}, {'id': 7, 'elements': [6, 7, 8]}, {'id': 8, 'elements': [1, 4, 7, 8, 10, 11, 12]}, {'id': 9, 'elements': [4, 5, 6, 9, 12]}, {'id': 10, 'elements': [1, 7, 8]}, {'id': 11, 'elements': [2, 3, 8, 11, 12]}, {'id': 12, 'elements': [2, 4, 6, 8, 11]}, {'id': 13, 'elements': [4, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 7, 'v': 5}, {'u': 7, 'v': 10}, {'u': 13, 'v': 2}, {'u': 10, 'v': 8}, {'u': 8, 'v': 1}, {'u': 8, 'v': 4}, {'u': 4, 'v': 2}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 11, 'v': 3}, {'u': 5, 'v': 6}, {'u': 12, 'v': 9}, {'u': 6, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0019.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0019.png'}","[5, 10, 13]",3.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'H', 'J']}, {'id': 'S2', 'elements': ['B', 'D', 'H', 'L', 'M']}, {'id': 'S3', 'elements': ['C', 'D', 'K']}, {'id': 'S4', 'elements': ['A', 'B', 'H', 'I', 'L']}, {'id': 'S5', 'elements': ['F', 'I', 'J']}, {'id': 'S6', 'elements': ['E', 'F', 'G', 'I', 'L']}, {'id': 'S7', 'elements': ['F', 'G', 'H']}, {'id': 'S8', 'elements': ['A', 'D', 'G', 'H', 'J', 'K', 'L']}, {'id': 'S9', 'elements': ['D', 'E', 'F', 'I', 'L']}, {'id': 'S10', 'elements': ['A', 'G', 'H']}, {'id': 'S11', 'elements': ['B', 'C', 'H', 'K', 'L']}, {'id': 'S12', 'elements': ['B', 'D', 'F', 'H', 'K']}, {'id': 'S13', 'elements': ['D', 'M']}]}","['S5', 'S10', 'S13']",20,csv,names
SP,SP,"Someone in the library dreamed up a pile of themed shelf ideas, and each idea uses a specific group of books. The task is to bring out as many of those themed shelves as possible; the outcome is measured by how many shelves are actually put out, so count them to see how well it went. There’s a strict rule: a single book can’t be used on two different shelves, meaning chosen shelves can’t overlap in their books. The exact book groupings for each theme are shown below.

There are 17 themed shelf ideas that together span 18 distinct books.
Shelf S1 uses the books 0 6 10 13 16.
Shelf S2 uses the books 3 8 9 13 14 15 16.
Shelf S3 uses the books 2 17.
Shelf S4 uses the books 7 14.
Shelf S5 uses the books 2 4 8 17.
Shelf S6 uses the books 9 13.
Shelf S7 uses the books 3 11.
Shelf S8 uses the books 1 8 14 15.
Shelf S9 uses the books 0 1 9 16.
Shelf S10 uses the books 0 12 16.
Shelf S11 uses the books 3 7 11.
Shelf S12 uses the books 10 12 13.
Shelf S13 uses the books 0 1 6 9 10 12 13.
Shelf S14 uses the books 7 14 16.
Shelf S15 uses the books 1 4 8 14 17.
Shelf S16 uses the books 0 1 5 8 9 10 14 16.
Shelf S17 uses the books 4 15 17.
Place non-overlapping shelves and count how many of the 17 shelves you can put out.

Also, when you’re ready to give the final pick, just drop it into a tiny JSON object like this — nice and simple:

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

Think of ""solution"" as the list of shelf identifiers for the themed shelves you actually put out. Each item in that array should be the exact identifier for a shelf from the instance (this example just shows the shape, not your real answer).

Please 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': 18, 'num_sets': 17, 'density': 0.21895424836601307, 'sets': [{'id': 1, 'elements': [1, 7, 11, 14, 17]}, {'id': 2, 'elements': [4, 9, 10, 14, 15, 16, 17]}, {'id': 3, 'elements': [3, 18]}, {'id': 4, 'elements': [8, 15]}, {'id': 5, 'elements': [3, 5, 9, 18]}, {'id': 6, 'elements': [10, 14]}, {'id': 7, 'elements': [4, 12]}, {'id': 8, 'elements': [2, 9, 15, 16]}, {'id': 9, 'elements': [1, 2, 10, 17]}, {'id': 10, 'elements': [1, 13, 17]}, {'id': 11, 'elements': [4, 8, 12]}, {'id': 12, 'elements': [11, 13, 14]}, {'id': 13, 'elements': [1, 2, 7, 10, 11, 13, 14]}, {'id': 14, 'elements': [8, 15, 17]}, {'id': 15, 'elements': [2, 5, 9, 15, 18]}, {'id': 16, 'elements': [1, 2, 6, 9, 10, 11, 15, 17]}, {'id': 17, 'elements': [5, 16, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 6, 'v': 10}, {'u': 17, 'v': 2}, {'u': 17, 'v': 10}, {'u': 17, 'v': 14}, {'u': 7, 'v': 1}, {'u': 8, 'v': 4}, {'u': 8, 'v': 12}, {'u': 3, 'v': 5}, {'u': 18, 'v': 5}, {'u': 10, 'v': 1}, {'u': 14, 'v': 1}, {'u': 14, 'v': 11}, {'u': 2, 'v': 9}, {'u': 2, 'v': 15}, {'u': 4, 'v': 15}, {'u': 9, 'v': 15}, {'u': 9, 'v': 16}, {'u': 16, 'v': 5}, {'u': 13, 'v': 11}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0020.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0020.png'}","[3, 4, 6, 7, 10]",5.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [0, 6, 10, 13, 16]}, {'id': 'S2', 'elements': [3, 8, 9, 13, 14, 15, 16]}, {'id': 'S3', 'elements': [2, 17]}, {'id': 'S4', 'elements': [7, 14]}, {'id': 'S5', 'elements': [2, 4, 8, 17]}, {'id': 'S6', 'elements': [9, 13]}, {'id': 'S7', 'elements': [3, 11]}, {'id': 'S8', 'elements': [1, 8, 14, 15]}, {'id': 'S9', 'elements': [0, 1, 9, 16]}, {'id': 'S10', 'elements': [0, 12, 16]}, {'id': 'S11', 'elements': [3, 7, 11]}, {'id': 'S12', 'elements': [10, 12, 13]}, {'id': 'S13', 'elements': [0, 1, 6, 9, 10, 12, 13]}, {'id': 'S14', 'elements': [7, 14, 16]}, {'id': 'S15', 'elements': [1, 4, 8, 14, 17]}, {'id': 'S16', 'elements': [0, 1, 5, 8, 9, 10, 14, 16]}, {'id': 'S17', 'elements': [4, 15, 17]}]}","['S3', 'S4', 'S6', 'S7', 'S10']",21,nl,0
SP,SP,"For the launch, the curator’s challenge is to pick the largest possible set of playlists from a pool of options, while ensuring that no song appears in more than one of the playlists that are chosen. The way to tell which choice is better is simple: tally up how many playlists were selected — the bigger that number, the better the result. The rule to stick to is that tracks can’t be shared between any two selected playlists. The specific playlist options and their tracks are detailed below.

There are 18 distinct tracks in the curator's universe and 17 candidate playlists listed below.
Playlist S1: 1 4 5 10 12 14 15 16.
Playlist S2: 2 7 12.
Playlist S3: 3 8.
Playlist S4: 5 9 11 15.
Playlist S5: 8 17.
Playlist S6: 1 2 7 8 10 12 15.
Playlist S7: 3 6 14 17.
Playlist S8: 5 11 18.
Playlist S9: 1 7 10 12 13.
Playlist S10: 1 9 11 15.
Playlist S11: 2 7 10 12 14 17.
Playlist S12: 10 12.
Playlist S13: 8 12 14 17.
Playlist S14: 7 9 11 15 18.
Playlist S15: 2 4.
Playlist S16: 1 6 7 8 14 17.
Playlist S17: 9 11 15 18.
The curator's goal remains to select the largest possible collection of playlists with no shared tracks.

When you're ready to give your selection, just drop it back in this simple JSON shape so it's easy to check:

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

Think of ""solution"" as the field that holds your final picks, and the array is where you list the playlists you chose. The string ""playlist_id"" is a placeholder showing the format — replace it with the actual playlist identifiers from the instance (the ""..."" just means you can list as many as fit). This is just a sketch of the shape I expect, not the real answer.

Please make sure to use the identifiers exactly as they appear in 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': 18, 'num_sets': 17, 'density': 0.23202614379084968, 'sets': [{'id': 1, 'elements': [1, 4, 5, 10, 12, 14, 15, 16]}, {'id': 2, 'elements': [2, 7, 12]}, {'id': 3, 'elements': [3, 8]}, {'id': 4, 'elements': [5, 9, 11, 15]}, {'id': 5, 'elements': [8, 17]}, {'id': 6, 'elements': [1, 2, 7, 8, 10, 12, 15]}, {'id': 7, 'elements': [3, 6, 14, 17]}, {'id': 8, 'elements': [5, 11, 18]}, {'id': 9, 'elements': [1, 7, 10, 12, 13]}, {'id': 10, 'elements': [1, 9, 11, 15]}, {'id': 11, 'elements': [2, 7, 10, 12, 14, 17]}, {'id': 12, 'elements': [10, 12]}, {'id': 13, 'elements': [8, 12, 14, 17]}, {'id': 14, 'elements': [7, 9, 11, 15, 18]}, {'id': 15, 'elements': [2, 4]}, {'id': 16, 'elements': [1, 6, 7, 8, 14, 17]}, {'id': 17, 'elements': [9, 11, 15, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 6, 'v': 3}, {'u': 6, 'v': 8}, {'u': 5, 'v': 9}, {'u': 5, 'v': 11}, {'u': 5, 'v': 15}, {'u': 5, 'v': 18}, {'u': 1, 'v': 2}, {'u': 1, 'v': 7}, {'u': 1, 'v': 12}, {'u': 1, 'v': 15}, {'u': 7, 'v': 12}, {'u': 7, 'v': 14}, {'u': 7, 'v': 17}, {'u': 2, 'v': 4}, {'u': 2, 'v': 16}, {'u': 11, 'v': 9}, {'u': 11, 'v': 15}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 14, 'v': 17}, {'u': 17, 'v': 8}, {'u': 9, 'v': 18}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0021.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0021.png'}","[5, 10, 12, 15]",4.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [1, 4, 5, 10, 12, 14, 15, 16]}, {'id': 'S2', 'elements': [2, 7, 12]}, {'id': 'S3', 'elements': [3, 8]}, {'id': 'S4', 'elements': [5, 9, 11, 15]}, {'id': 'S5', 'elements': [8, 17]}, {'id': 'S6', 'elements': [1, 2, 7, 8, 10, 12, 15]}, {'id': 'S7', 'elements': [3, 6, 14, 17]}, {'id': 'S8', 'elements': [5, 11, 18]}, {'id': 'S9', 'elements': [1, 7, 10, 12, 13]}, {'id': 'S10', 'elements': [1, 9, 11, 15]}, {'id': 'S11', 'elements': [2, 7, 10, 12, 14, 17]}, {'id': 'S12', 'elements': [10, 12]}, {'id': 'S13', 'elements': [8, 12, 14, 17]}, {'id': 'S14', 'elements': [7, 9, 11, 15, 18]}, {'id': 'S15', 'elements': [2, 4]}, {'id': 'S16', 'elements': [1, 6, 7, 8, 14, 17]}, {'id': 'S17', 'elements': [9, 11, 15, 18]}]}","['S5', 'S10', 'S12', 'S15']",22,nl,1
SP,SP,"Recently the community center put together several outreach squads and now someone has to pick which squads to deploy. No volunteer can be on more than one deployed squad, and the aim is to deploy as many squads as possible — the performance of any deployment is measured by how many squads are sent. The concrete squad rosters are shown below.

{
  ""total_volunteers"": 17,
  ""total_squads"": 16,
  ""sets"": [
    {
      ""squad_id"": ""S1"",
      ""squad_roster"": [
        2,
        5
      ]
    },
    {
      ""squad_id"": ""S2"",
      ""squad_roster"": [
        1,
        8,
        9,
        11,
        12,
        13,
        14,
        16
      ]
    },
    {
      ""squad_id"": ""S3"",
      ""squad_roster"": [
        2,
        5,
        15
      ]
    },
    {
      ""squad_id"": ""S4"",
      ""squad_roster"": [
        3,
        4
      ]
    },
    {
      ""squad_id"": ""S5"",
      ""squad_roster"": [
        2,
        3,
        4,
        9,
        10,
        15
      ]
    },
    {
      ""squad_id"": ""S6"",
      ""squad_roster"": [
        0,
        2,
        4,
        6
      ]
    },
    {
      ""squad_id"": ""S7"",
      ""squad_roster"": [
        1,
        6,
        7,
        8,
        9,
        11,
        13,
        14
      ]
    },
    {
      ""squad_id"": ""S8"",
      ""squad_roster"": [
        6,
        7,
        8,
        14
      ]
    },
    {
      ""squad_id"": ""S9"",
      ""squad_roster"": [
        6,
        8,
        14,
        16
      ]
    },
    {
      ""squad_id"": ""S10"",
      ""squad_roster"": [
        1,
        4,
        6,
        9,
        10,
        14
      ]
    },
    {
      ""squad_id"": ""S11"",
      ""squad_roster"": [
        5,
        9,
        10
      ]
    },
    {
      ""squad_id"": ""S12"",
      ""squad_roster"": [
        12,
        16
      ]
    },
    {
      ""squad_id"": ""S13"",
      ""squad_roster"": [
        6,
        9,
        13,
        14
      ]
    },
    {
      ""squad_id"": ""S14"",
      ""squad_roster"": [
        1,
        7,
        8,
        9,
        13,
        14
      ]
    },
    {
      ""squad_id"": ""S15"",
      ""squad_roster"": [
        0,
        2,
        4
      ]
    },
    {
      ""squad_id"": ""S16"",
      ""squad_roster"": [
        6,
        8,
        11,
        16
      ]
    }
  ]
}

When you reply with which squads to send, just use this simple JSON shape so it's easy to read and validate:

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

Think of it like a little form: ""solution"" is the list of squads you'll deploy, and each entry in the list is the exact squad identifier from the instance (just the ID, nothing else). This JSON is only a sketch of the expected shape — don't treat the example entries as the real 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': 17, 'num_sets': 16, 'density': 0.2536764705882353, 'sets': [{'id': 1, 'elements': [3, 6]}, {'id': 2, 'elements': [2, 9, 10, 12, 13, 14, 15, 17]}, {'id': 3, 'elements': [3, 6, 16]}, {'id': 4, 'elements': [4, 5]}, {'id': 5, 'elements': [3, 4, 5, 10, 11, 16]}, {'id': 6, 'elements': [1, 3, 5, 7]}, {'id': 7, 'elements': [2, 7, 8, 9, 10, 12, 14, 15]}, {'id': 8, 'elements': [7, 8, 9, 15]}, {'id': 9, 'elements': [7, 9, 15, 17]}, {'id': 10, 'elements': [2, 5, 7, 10, 11, 15]}, {'id': 11, 'elements': [6, 10, 11]}, {'id': 12, 'elements': [13, 17]}, {'id': 13, 'elements': [7, 10, 14, 15]}, {'id': 14, 'elements': [2, 8, 9, 10, 14, 15]}, {'id': 15, 'elements': [1, 3, 5]}, {'id': 16, 'elements': [7, 9, 12, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 7, 'v': 2}, {'u': 7, 'v': 10}, {'u': 7, 'v': 14}, {'u': 7, 'v': 15}, {'u': 10, 'v': 6}, {'u': 11, 'v': 6}, {'u': 13, 'v': 9}, {'u': 13, 'v': 17}, {'u': 5, 'v': 1}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 16}, {'u': 2, 'v': 9}, {'u': 2, 'v': 12}, {'u': 2, 'v': 17}, {'u': 4, 'v': 16}, {'u': 8, 'v': 15}, {'u': 15, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0022.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0022.png'}","[4, 8, 11, 12]",4.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [2, 5]}, {'id': 'S2', 'elements': [1, 8, 9, 11, 12, 13, 14, 16]}, {'id': 'S3', 'elements': [2, 5, 15]}, {'id': 'S4', 'elements': [3, 4]}, {'id': 'S5', 'elements': [2, 3, 4, 9, 10, 15]}, {'id': 'S6', 'elements': [0, 2, 4, 6]}, {'id': 'S7', 'elements': [1, 6, 7, 8, 9, 11, 13, 14]}, {'id': 'S8', 'elements': [6, 7, 8, 14]}, {'id': 'S9', 'elements': [6, 8, 14, 16]}, {'id': 'S10', 'elements': [1, 4, 6, 9, 10, 14]}, {'id': 'S11', 'elements': [5, 9, 10]}, {'id': 'S12', 'elements': [12, 16]}, {'id': 'S13', 'elements': [6, 9, 13, 14]}, {'id': 'S14', 'elements': [1, 7, 8, 9, 13, 14]}, {'id': 'S15', 'elements': [0, 2, 4]}, {'id': 'S16', 'elements': [6, 8, 11, 16]}]}","['S4', 'S8', 'S11', 'S12']",23,json,0
SP,SP,"Recently the showroom decided to showcase multiple grouped looks, and the stylist’s puzzle is to pick the largest number of those looks that can coexist. The quality of any choice is measured by how many bundles are actually placed on the floor (just add them up), but a strict rule is that each piece of furniture may appear in only one chosen look, so there’s no double-booking of a sofa or lamp. The exact bundles and their contents follow below.

There are 16 predesigned bundles drawn from 16 distinct furniture pieces:
Bundle S1 contains the pieces 1 4 5 7 8 9 11 15.
Bundle S2 contains the pieces 1 2 8 11 14.
Bundle S3 contains the pieces 8 9 10 11.
Bundle S4 contains the pieces 1 3 9 11.
Bundle S5 contains the pieces 5 9 14 15.
Bundle S6 contains the pieces 2 6 15 16.
Bundle S7 contains the pieces 5 7 8 9.
Bundle S8 contains the pieces 2 3 5 7 8 9 11 12 15 16.
Bundle S9 contains the pieces 1 3 5 8 9 10.
Bundle S10 contains the pieces 2 3 9 10 11 13 14 16.
Bundle S11 contains the pieces 1 2 3 4 8 11 13 15.
Bundle S12 contains the pieces 8 12 14 15.
Bundle S13 contains the pieces 2 3 4 10 13.
Bundle S14 contains the pieces 5 6 8 10 14 15.
Bundle S15 contains the pieces 1 2 6 8 12 14 15.
Bundle S16 contains the pieces 2 6 8 10 14 16.
From these 16 candidates, the stylist will choose as many non-overlapping bundles as possible.

If you want to tell me which looks to place, just send back a tiny JSON snippet like the one below — it's the simple shape I expect:

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

Think of ""solution"" as the list of chosen looks to put on the floor, and each ""look_id"" is a placeholder for one of the bundle identifiers from the list I gave you. This is just a sketch of the format I want, not the actual answer.

Please use the exact identifiers from the instance input — don't rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 16, 'density': 0.36328125, 'sets': [{'id': 1, 'elements': [1, 4, 5, 7, 8, 9, 11, 15]}, {'id': 2, 'elements': [1, 2, 8, 11, 14]}, {'id': 3, 'elements': [8, 9, 10, 11]}, {'id': 4, 'elements': [1, 3, 9, 11]}, {'id': 5, 'elements': [5, 9, 14, 15]}, {'id': 6, 'elements': [2, 6, 15, 16]}, {'id': 7, 'elements': [5, 7, 8, 9]}, {'id': 8, 'elements': [2, 3, 5, 7, 8, 9, 11, 12, 15, 16]}, {'id': 9, 'elements': [1, 3, 5, 8, 9, 10]}, {'id': 10, 'elements': [2, 3, 9, 10, 11, 13, 14, 16]}, {'id': 11, 'elements': [1, 2, 3, 4, 8, 11, 13, 15]}, {'id': 12, 'elements': [8, 12, 14, 15]}, {'id': 13, 'elements': [2, 3, 4, 10, 13]}, {'id': 14, 'elements': [5, 6, 8, 10, 14, 15]}, {'id': 15, 'elements': [1, 2, 6, 8, 12, 14, 15]}, {'id': 16, 'elements': [2, 6, 8, 10, 14, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 11}, {'u': 8, 'v': 15}, {'u': 7, 'v': 1}, {'u': 13, 'v': 3}, {'u': 13, 'v': 10}, {'u': 1, 'v': 5}, {'u': 1, 'v': 9}, {'u': 15, 'v': 5}, {'u': 15, 'v': 12}, {'u': 15, 'v': 14}, {'u': 2, 'v': 10}, {'u': 2, 'v': 14}, {'u': 2, 'v': 16}, {'u': 14, 'v': 6}, {'u': 16, 'v': 6}, {'u': 3, 'v': 4}, {'u': 3, 'v': 11}, {'u': 4, 'v': 9}, {'u': 9, 'v': 11}, {'u': 10, 'v': 11}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0023.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0023.png'}","[4, 6]",2.0,"{'num_elements': 16, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [1, 4, 5, 7, 8, 9, 11, 15]}, {'id': 'S2', 'elements': [1, 2, 8, 11, 14]}, {'id': 'S3', 'elements': [8, 9, 10, 11]}, {'id': 'S4', 'elements': [1, 3, 9, 11]}, {'id': 'S5', 'elements': [5, 9, 14, 15]}, {'id': 'S6', 'elements': [2, 6, 15, 16]}, {'id': 'S7', 'elements': [5, 7, 8, 9]}, {'id': 'S8', 'elements': [2, 3, 5, 7, 8, 9, 11, 12, 15, 16]}, {'id': 'S9', 'elements': [1, 3, 5, 8, 9, 10]}, {'id': 'S10', 'elements': [2, 3, 9, 10, 11, 13, 14, 16]}, {'id': 'S11', 'elements': [1, 2, 3, 4, 8, 11, 13, 15]}, {'id': 'S12', 'elements': [8, 12, 14, 15]}, {'id': 'S13', 'elements': [2, 3, 4, 10, 13]}, {'id': 'S14', 'elements': [5, 6, 8, 10, 14, 15]}, {'id': 'S15', 'elements': [1, 2, 6, 8, 12, 14, 15]}, {'id': 'S16', 'elements': [2, 6, 8, 10, 14, 16]}]}","['S4', 'S6']",24,nl,1
SP,SP,"I’m juggling the production board this week, picking which batches to run so the plant actually gets more lines moving. The idea is simple: pick as many batches as possible to kick off — the ""score"" is just the count of batches that start — but any two chosen batches can’t both need the same machine at the same time. The specific batches and which machines they need are shown below.

I've got 13 candidate batches and 14 distinct machines listed below.
Batch S1 needs machines 1 2 3 4 10 11 12.
Batch S2 needs machines 2 3 4 10 11 14.
Batch S3 needs machines 1 2 5 10 11.
Batch S4 needs machines 2 4 7 13 14.
Batch S5 needs machines 3 5 9 10.
Batch S6 needs machines 2 11 14.
Batch S7 needs machines 2 4 7 10.
Batch S8 needs machines 10 11 14.
Batch S9 needs machines 3 9 10.
Batch S10 needs machines 2 3 4 5 7 8 13.
Batch S11 needs machines 2 3 6 10 11 14.
Batch S12 needs machines 4 10 12 13.
Batch S13 needs machines 2 7 8 10 11 14.
I'll try to kick off as many batches as I can without any machine clashes.

I'll return the selection in a tiny JSON snippet so it’s easy to plug into whatever you’ve got running.

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

Nothing fancy — ""solution"" is just the list of batches I’m picking to start, and each item in that array is a placeholder for a batch identifier (replace ""batch_id"" with the actual IDs from the instance). This is just a sketch of the shape I’ll use, not the actual final picks.

Also: 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': 14, 'num_sets': 13, 'density': 0.34615384615384615, 'sets': [{'id': 1, 'elements': [1, 2, 3, 4, 10, 11, 12]}, {'id': 2, 'elements': [2, 3, 4, 10, 11, 14]}, {'id': 3, 'elements': [1, 2, 5, 10, 11]}, {'id': 4, 'elements': [2, 4, 7, 13, 14]}, {'id': 5, 'elements': [3, 5, 9, 10]}, {'id': 6, 'elements': [2, 11, 14]}, {'id': 7, 'elements': [2, 4, 7, 10]}, {'id': 8, 'elements': [10, 11, 14]}, {'id': 9, 'elements': [3, 9, 10]}, {'id': 10, 'elements': [2, 3, 4, 5, 7, 8, 13]}, {'id': 11, 'elements': [2, 3, 6, 10, 11, 14]}, {'id': 12, 'elements': [4, 10, 12, 13]}, {'id': 13, 'elements': [2, 7, 8, 10, 11, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 13, 'v': 1}, {'u': 13, 'v': 12}, {'u': 3, 'v': 5}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 11}, {'u': 1, 'v': 4}, {'u': 6, 'v': 14}, {'u': 8, 'v': 11}, {'u': 11, 'v': 14}, {'u': 14, 'v': 2}, {'u': 2, 'v': 4}, {'u': 2, 'v': 7}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0024.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0024.png'}","[6, 9]",2.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [1, 2, 3, 4, 10, 11, 12]}, {'id': 'S2', 'elements': [2, 3, 4, 10, 11, 14]}, {'id': 'S3', 'elements': [1, 2, 5, 10, 11]}, {'id': 'S4', 'elements': [2, 4, 7, 13, 14]}, {'id': 'S5', 'elements': [3, 5, 9, 10]}, {'id': 'S6', 'elements': [2, 11, 14]}, {'id': 'S7', 'elements': [2, 4, 7, 10]}, {'id': 'S8', 'elements': [10, 11, 14]}, {'id': 'S9', 'elements': [3, 9, 10]}, {'id': 'S10', 'elements': [2, 3, 4, 5, 7, 8, 13]}, {'id': 'S11', 'elements': [2, 3, 6, 10, 11, 14]}, {'id': 'S12', 'elements': [4, 10, 12, 13]}, {'id': 'S13', 'elements': [2, 7, 8, 10, 11, 14]}]}","['S6', 'S9']",25,nl,1
SP,SP,"Recently the department sent over a long list of pre-formed student teams, and the task became selecting which of those teams to run this term. The decision boils down to approving as many teams as possible from that list. The winning selection is the one that yields the highest number of approved teams — success is measured by simply tallying the groups. The catch is that no student can appear in more than one approved team; students may be left unassigned but cannot be duplicated. The specific roster and team possibilities are shown below.

- **total_students**: 16
- **preformed_team_count**: 15

| team_id | students_in_team |
|---|---|
| S1 | 1 3 5 8 13 |
| S2 | 8 13 |
| S3 | 1 3 7 10 12 |
| S4 | 2 4 13 |
| S5 | 1 9 10 15 |
| S6 | 3 6 |
| S7 | 3 5 7 15 |
| S8 | 1 4 11 13 |
| S9 | 3 5 7 9 |
| S10 | 6 10 12 16 |
| S11 | 1 8 11 13 |
| S12 | 3 6 10 12 16 |
| S13 | 1 3 8 11 14 |
| S14 | 1 3 13 14 |
| S15 | 5 7 15 |

Also, when you send back which teams you want to approve, please put them in a tiny JSON object so it's easy to parse. Something simple like this will do:

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

Think of that as a form: the solution array should contain the IDs of the approved teams (one ID per entry). The ""team_id"" above is just a placeholder showing the format — replace those with the actual team identifiers from the instance. This sketch only shows the expected shape, not the real answer.

Please be sure to use the exact identifiers that 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': 16, 'num_sets': 15, 'density': 0.24166666666666667, 'sets': [{'id': 1, 'elements': [1, 3, 5, 8, 13]}, {'id': 2, 'elements': [8, 13]}, {'id': 3, 'elements': [1, 3, 7, 10, 12]}, {'id': 4, 'elements': [2, 4, 13]}, {'id': 5, 'elements': [1, 9, 10, 15]}, {'id': 6, 'elements': [3, 6]}, {'id': 7, 'elements': [3, 5, 7, 15]}, {'id': 8, 'elements': [1, 4, 11, 13]}, {'id': 9, 'elements': [3, 5, 7, 9]}, {'id': 10, 'elements': [6, 10, 12, 16]}, {'id': 11, 'elements': [1, 8, 11, 13]}, {'id': 12, 'elements': [3, 6, 10, 12, 16]}, {'id': 13, 'elements': [1, 3, 8, 11, 14]}, {'id': 14, 'elements': [1, 3, 13, 14]}, {'id': 15, 'elements': [5, 7, 15]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 12, 'v': 10}, {'u': 12, 'v': 16}, {'u': 3, 'v': 1}, {'u': 3, 'v': 5}, {'u': 3, 'v': 10}, {'u': 5, 'v': 7}, {'u': 5, 'v': 9}, {'u': 11, 'v': 13}, {'u': 4, 'v': 8}, {'u': 10, 'v': 6}, {'u': 13, 'v': 1}, {'u': 13, 'v': 8}, {'u': 14, 'v': 1}, {'u': 15, 'v': 7}, {'u': 2, 'v': 8}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0025.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0025.png'}","[4, 10, 13, 15]",4.0,"{'num_elements': 16, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [1, 3, 5, 8, 13]}, {'id': 'S2', 'elements': [8, 13]}, {'id': 'S3', 'elements': [1, 3, 7, 10, 12]}, {'id': 'S4', 'elements': [2, 4, 13]}, {'id': 'S5', 'elements': [1, 9, 10, 15]}, {'id': 'S6', 'elements': [3, 6]}, {'id': 'S7', 'elements': [3, 5, 7, 15]}, {'id': 'S8', 'elements': [1, 4, 11, 13]}, {'id': 'S9', 'elements': [3, 5, 7, 9]}, {'id': 'S10', 'elements': [6, 10, 12, 16]}, {'id': 'S11', 'elements': [1, 8, 11, 13]}, {'id': 'S12', 'elements': [3, 6, 10, 12, 16]}, {'id': 'S13', 'elements': [1, 3, 8, 11, 14]}, {'id': 'S14', 'elements': [1, 3, 13, 14]}, {'id': 'S15', 'elements': [5, 7, 15]}]}","['S4', 'S10', 'S13', 'S15']",26,markdown_table,1
SP,SP,"There’s a stack of themed shoot bundles on the table and a roster of models and props to match. The task is to arrange as many of those bundles as possible into the weekend, and the simple measure of success is how many bundles get scheduled — just tally them up. One hard rule: no prop or model can appear in two different scheduled bundles, so any picks that share someone or something have to be avoided. The specific shoots and their requirements are listed below.

- **total_resources**: 17
- **total_packages**: 16

| package_id | package_resources |
|---|---|
| S1 | 0 10 13 14 15 16 |
| S2 | 1 2 5 |
| S3 | 2 5 11 13 |
| S4 | 6 9 |
| S5 | 4 8 12 |
| S6 | 1 5 |
| S7 | 7 9 12 14 15 |
| S8 | 4 8 14 |
| S9 | 7 9 |
| S10 | 0 10 13 15 16 |
| S11 | 2 5 10 11 13 |
| S12 | 4 7 |
| S13 | 2 10 11 13 |
| S14 | 0 3 8 12 14 15 |
| S15 | 0 7 10 12 14 15 |
| S16 | 0 10 13 |

Oh, and when you send your picks back, just drop them into a tiny JSON snippet like this so it's easy to read and import:

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

Here ""solution"" is the list of bundles you want to schedule — put each bundle's identifier in there. This is just the shape I expect, a simple sketch, not the actual filled-in answer.

Please 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': 17, 'num_sets': 16, 'density': 0.22426470588235295, 'sets': [{'id': 1, 'elements': [1, 11, 14, 15, 16, 17]}, {'id': 2, 'elements': [2, 3, 6]}, {'id': 3, 'elements': [3, 6, 12, 14]}, {'id': 4, 'elements': [7, 10]}, {'id': 5, 'elements': [5, 9, 13]}, {'id': 6, 'elements': [2, 6]}, {'id': 7, 'elements': [8, 10, 13, 15, 16]}, {'id': 8, 'elements': [5, 9, 15]}, {'id': 9, 'elements': [8, 10]}, {'id': 10, 'elements': [1, 11, 14, 16, 17]}, {'id': 11, 'elements': [3, 6, 11, 12, 14]}, {'id': 12, 'elements': [5, 8]}, {'id': 13, 'elements': [3, 11, 12, 14]}, {'id': 14, 'elements': [1, 4, 9, 13, 15, 16]}, {'id': 15, 'elements': [1, 8, 11, 13, 15, 16]}, {'id': 16, 'elements': [1, 11, 14]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 15, 'v': 8}, {'u': 15, 'v': 13}, {'u': 15, 'v': 16}, {'u': 1, 'v': 11}, {'u': 1, 'v': 16}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 5, 'v': 9}, {'u': 7, 'v': 10}, {'u': 4, 'v': 8}, {'u': 4, 'v': 10}, {'u': 11, 'v': 14}, {'u': 11, 'v': 17}, {'u': 12, 'v': 3}, {'u': 12, 'v': 14}, {'u': 13, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0026.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0026.png'}","[4, 6, 12, 13, 14]",5.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [0, 10, 13, 14, 15, 16]}, {'id': 'S2', 'elements': [1, 2, 5]}, {'id': 'S3', 'elements': [2, 5, 11, 13]}, {'id': 'S4', 'elements': [6, 9]}, {'id': 'S5', 'elements': [4, 8, 12]}, {'id': 'S6', 'elements': [1, 5]}, {'id': 'S7', 'elements': [7, 9, 12, 14, 15]}, {'id': 'S8', 'elements': [4, 8, 14]}, {'id': 'S9', 'elements': [7, 9]}, {'id': 'S10', 'elements': [0, 10, 13, 15, 16]}, {'id': 'S11', 'elements': [2, 5, 10, 11, 13]}, {'id': 'S12', 'elements': [4, 7]}, {'id': 'S13', 'elements': [2, 10, 11, 13]}, {'id': 'S14', 'elements': [0, 3, 8, 12, 14, 15]}, {'id': 'S15', 'elements': [0, 7, 10, 12, 14, 15]}, {'id': 'S16', 'elements': [0, 10, 13]}]}","['S4', 'S6', 'S12', 'S13', 'S14']",27,markdown_table,0
SP,SP,"On a busy morning the boutique team is picking outfit combinations for the window to grab attention. The job is to pick as many of those combos as they can so the window feels full; compare options by counting how many outfits end up on display. One clear limitation: a single item cannot be used in two different showcased outfits, so selections must be item-disjoint. The specific outfits and items follow below.

There are 15 outfit combinations available and 15 distinct items in total.
Outfit S1: 0 6 7 11 12 14.
Outfit S2: 1 2 4 8 9 13.
Outfit S3: 2 3 5 8 12.
Outfit S4: 3 8 12.
Outfit S5: 1 2 4 7 9 11.
Outfit S6: 2 5 7 10 12.
Outfit S7: 0 4 6 9 14.
Outfit S8: 0 1 7 10 11 12 14.
Outfit S9: 1 3 8 11 12 13.
Outfit S10: 1 4 6 9 11.
Outfit S11: 5 11 12.
Outfit S12: 0 1 3 4 6 7 8 9 10 12 13.
Outfit S13: 0 5 7 8 11 12.
Outfit S14: 1 8 9 13.
Outfit S15: 0 4 7 14.
The goal is to showcase as many disjoint outfits as possible in the window display.

Oh, and one more practical thing — when you send your picks, please use this simple JSON shape so I can easily see which outfits you chose:

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

Think of ""solution"" as the list of outfit IDs you want in the window display. Each entry in the array should be one of the outfit identifiers from the instance. This JSON is just a sketch of the shape I expect, not your final answer — replace the placeholder(s) with the actual IDs.

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': 15, 'num_sets': 15, 'density': 0.36444444444444446, 'sets': [{'id': 1, 'elements': [1, 7, 8, 12, 13, 15]}, {'id': 2, 'elements': [2, 3, 5, 9, 10, 14]}, {'id': 3, 'elements': [3, 4, 6, 9, 13]}, {'id': 4, 'elements': [4, 9, 13]}, {'id': 5, 'elements': [2, 3, 5, 8, 10, 12]}, {'id': 6, 'elements': [3, 6, 8, 11, 13]}, {'id': 7, 'elements': [1, 5, 7, 10, 15]}, {'id': 8, 'elements': [1, 2, 8, 11, 12, 13, 15]}, {'id': 9, 'elements': [2, 4, 9, 12, 13, 14]}, {'id': 10, 'elements': [2, 5, 7, 10, 12]}, {'id': 11, 'elements': [6, 12, 13]}, {'id': 12, 'elements': [1, 2, 4, 5, 7, 8, 9, 10, 11, 13, 14]}, {'id': 13, 'elements': [1, 6, 8, 9, 12, 13]}, {'id': 14, 'elements': [2, 9, 10, 14]}, {'id': 15, 'elements': [1, 5, 8, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 13, 'v': 3}, {'u': 13, 'v': 6}, {'u': 13, 'v': 8}, {'u': 11, 'v': 6}, {'u': 11, 'v': 8}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 5}, {'u': 12, 'v': 8}, {'u': 7, 'v': 5}, {'u': 7, 'v': 15}, {'u': 8, 'v': 1}, {'u': 4, 'v': 3}, {'u': 5, 'v': 1}, {'u': 5, 'v': 10}, {'u': 10, 'v': 2}, {'u': 1, 'v': 15}, {'u': 14, 'v': 2}, {'u': 2, 'v': 9}, {'u': 3, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0027.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0027.png'}","[11, 14, 15]",3.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [0, 6, 7, 11, 12, 14]}, {'id': 'S2', 'elements': [1, 2, 4, 8, 9, 13]}, {'id': 'S3', 'elements': [2, 3, 5, 8, 12]}, {'id': 'S4', 'elements': [3, 8, 12]}, {'id': 'S5', 'elements': [1, 2, 4, 7, 9, 11]}, {'id': 'S6', 'elements': [2, 5, 7, 10, 12]}, {'id': 'S7', 'elements': [0, 4, 6, 9, 14]}, {'id': 'S8', 'elements': [0, 1, 7, 10, 11, 12, 14]}, {'id': 'S9', 'elements': [1, 3, 8, 11, 12, 13]}, {'id': 'S10', 'elements': [1, 4, 6, 9, 11]}, {'id': 'S11', 'elements': [5, 11, 12]}, {'id': 'S12', 'elements': [0, 1, 3, 4, 6, 7, 8, 9, 10, 12, 13]}, {'id': 'S13', 'elements': [0, 5, 7, 8, 11, 12]}, {'id': 'S14', 'elements': [1, 8, 9, 13]}, {'id': 'S15', 'elements': [0, 4, 7, 14]}]}","['S11', 'S14', 'S15']",28,nl,0
SP,SP,"Someone on the events team needs to choose panels so the program looks full, while making sure no one is booked into two different discussions. The clearer solution is the one that includes more panels — success equals the number of panels picked, simply summed up. Practically speaking, any plan that has a speaker in more than one chosen panel has to be discarded. The detailed proposals and speaker assignments are shown below.

{
  ""total_speakers"": 13,
  ""total_panel_proposals"": 12,
  ""sets"": [
    {
      ""panel_id"": ""S1"",
      ""panel_speakers"": [
        1,
        6,
        7,
        9,
        10
      ]
    },
    {
      ""panel_id"": ""S2"",
      ""panel_speakers"": [
        2,
        4,
        8
      ]
    },
    {
      ""panel_id"": ""S3"",
      ""panel_speakers"": [
        2,
        4,
        9
      ]
    },
    {
      ""panel_id"": ""S4"",
      ""panel_speakers"": [
        3,
        5,
        7,
        9,
        11
      ]
    },
    {
      ""panel_id"": ""S5"",
      ""panel_speakers"": [
        2,
        4,
        7,
        8
      ]
    },
    {
      ""panel_id"": ""S6"",
      ""panel_speakers"": [
        1,
        3,
        6,
        9,
        11
      ]
    },
    {
      ""panel_id"": ""S7"",
      ""panel_speakers"": [
        2,
        4,
        6,
        8
      ]
    },
    {
      ""panel_id"": ""S8"",
      ""panel_speakers"": [
        1,
        2,
        3,
        7,
        12
      ]
    },
    {
      ""panel_id"": ""S9"",
      ""panel_speakers"": [
        1,
        10,
        12,
        13
      ]
    },
    {
      ""panel_id"": ""S10"",
      ""panel_speakers"": [
        7,
        11
      ]
    },
    {
      ""panel_id"": ""S11"",
      ""panel_speakers"": [
        9,
        12
      ]
    },
    {
      ""panel_id"": ""S12"",
      ""panel_speakers"": [
        1,
        13
      ]
    }
  ]
}

Oh, and when you send back the chosen panels, just use this simple JSON shape so it's easy to read and parse:

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

""solution"" is just the list of the panel IDs you picked for the program. The ""panel_id"" entry above is a placeholder to show the format — swap it for the actual IDs from the instance (one per selected panel). This is only a sketch of the expected shape, not the actual answer.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. 
- for example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 12, 'density': 0.28205128205128205, 'sets': [{'id': 1, 'elements': [1, 6, 7, 9, 10]}, {'id': 2, 'elements': [2, 4, 8]}, {'id': 3, 'elements': [2, 4, 9]}, {'id': 4, 'elements': [3, 5, 7, 9, 11]}, {'id': 5, 'elements': [2, 4, 7, 8]}, {'id': 6, 'elements': [1, 3, 6, 9, 11]}, {'id': 7, 'elements': [2, 4, 6, 8]}, {'id': 8, 'elements': [1, 2, 3, 7, 12]}, {'id': 9, 'elements': [1, 10, 12, 13]}, {'id': 10, 'elements': [7, 11]}, {'id': 11, 'elements': [9, 12]}, {'id': 12, 'elements': [1, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 6, 'v': 2}, {'u': 6, 'v': 4}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 7, 'v': 3}, {'u': 7, 'v': 5}, {'u': 7, 'v': 9}, {'u': 11, 'v': 5}, {'u': 12, 'v': 1}, {'u': 9, 'v': 1}, {'u': 13, 'v': 10}, {'u': 10, 'v': 1}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0028.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0028.png'}","[2, 10, 11, 12]",4.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [1, 6, 7, 9, 10]}, {'id': 'S2', 'elements': [2, 4, 8]}, {'id': 'S3', 'elements': [2, 4, 9]}, {'id': 'S4', 'elements': [3, 5, 7, 9, 11]}, {'id': 'S5', 'elements': [2, 4, 7, 8]}, {'id': 'S6', 'elements': [1, 3, 6, 9, 11]}, {'id': 'S7', 'elements': [2, 4, 6, 8]}, {'id': 'S8', 'elements': [1, 2, 3, 7, 12]}, {'id': 'S9', 'elements': [1, 10, 12, 13]}, {'id': 'S10', 'elements': [7, 11]}, {'id': 'S11', 'elements': [9, 12]}, {'id': 'S12', 'elements': [1, 13]}]}","['S2', 'S10', 'S11', 'S12']",29,json,1
SP,SP,"Many neighbors brought in different planting plans for the community plot, so the challenge is to assemble a set of plans as large as possible while making sure no single species is planted in two of the chosen plans. The one that wins is the selection with the greatest number of plans; count the plans to get the result, and make sure species aren’t duplicated. The full details of each plan and its species are shown below.

- **total_species**: 14
- **total_plans**: 13

| plan_id | species_list |
|---|---|
| S1 | 0 2 7 12 13 |
| S2 | 1 8 10 13 |
| S3 | 0 2 4 |
| S4 | 5 12 |
| S5 | 0 2 4 6 8 |
| S6 | 3 5 8 11 12 |
| S7 | 0 4 6 |
| S8 | 0 2 7 |
| S9 | 1 2 4 8 11 12 13 |
| S10 | 1 13 |
| S11 | 5 8 9 |
| S12 | 0 8 12 13 |
| S13 | 0 8 10 12 13 |

Oh, and when you send back the chosen plans, please use this simple JSON shape so it's easy to read by both people and tools:

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

Here ""solution"" is just a list of the planting plans you picked (one string per plan). Each entry in that array should be the exact plan identifier from the instance — think of it like filling in a short form with the plan labels. This JSON is just a sketch of the shape I expect, not the real answer itself.

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': 14, 'num_sets': 13, 'density': 0.2802197802197802, 'sets': [{'id': 1, 'elements': [1, 3, 8, 13, 14]}, {'id': 2, 'elements': [2, 9, 11, 14]}, {'id': 3, 'elements': [1, 3, 5]}, {'id': 4, 'elements': [6, 13]}, {'id': 5, 'elements': [1, 3, 5, 7, 9]}, {'id': 6, 'elements': [4, 6, 9, 12, 13]}, {'id': 7, 'elements': [1, 5, 7]}, {'id': 8, 'elements': [1, 3, 8]}, {'id': 9, 'elements': [2, 3, 5, 9, 12, 13, 14]}, {'id': 10, 'elements': [2, 14]}, {'id': 11, 'elements': [6, 9, 10]}, {'id': 12, 'elements': [1, 9, 13, 14]}, {'id': 13, 'elements': [1, 9, 11, 13, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 4, 'v': 6}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 13, 'v': 6}, {'u': 13, 'v': 9}, {'u': 8, 'v': 3}, {'u': 3, 'v': 1}, {'u': 7, 'v': 5}, {'u': 1, 'v': 5}, {'u': 1, 'v': 9}, {'u': 11, 'v': 2}, {'u': 14, 'v': 2}, {'u': 14, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0029.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0029.png'}","[3, 10, 11]",3.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 2, 7, 12, 13]}, {'id': 'S2', 'elements': [1, 8, 10, 13]}, {'id': 'S3', 'elements': [0, 2, 4]}, {'id': 'S4', 'elements': [5, 12]}, {'id': 'S5', 'elements': [0, 2, 4, 6, 8]}, {'id': 'S6', 'elements': [3, 5, 8, 11, 12]}, {'id': 'S7', 'elements': [0, 4, 6]}, {'id': 'S8', 'elements': [0, 2, 7]}, {'id': 'S9', 'elements': [1, 2, 4, 8, 11, 12, 13]}, {'id': 'S10', 'elements': [1, 13]}, {'id': 'S11', 'elements': [5, 8, 9]}, {'id': 'S12', 'elements': [0, 8, 12, 13]}, {'id': 'S13', 'elements': [0, 8, 10, 12, 13]}]}","['S3', 'S10', 'S11']",30,markdown_table,0
SP,SP,"Recently the store decided to run a multi-bundle promotion, and the challenge is choosing which bundles to actually run so there are as many distinct bundles available as possible. The simple metric for a good decision is the number of bundles offered — just tally them. One practical constraint: a product can’t be used in more than one of the bundles we pick, so chosen bundles must not share products. The detailed bundle list appears below.

# total_products_universe=18
# total_bundles_available=17
bundle_id,bundle_products
S1,E G
S2,B O P
S3,C D
S4,C J L Q
S5,A E K M
S6,E G J
S7,A E G M
S8,H I J O P
S9,F H I J L O
S10,D F H I J Q
S11,E H K M O
S12,C I J N
S13,A E G K M O
S14,L N
S15,B H I K M P
S16,B H O P R
S17,J Q

Also, when you send back the chosen bundles, just pop them into this little JSON shape so it's easy to parse:

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

Very casual explanation: ""solution"" is the list of bundles we pick, and each entry is the bundle's identifier (that's why there's a placeholder like bundle_id above). Think of it like filling in a short form — which bundles did we choose? — not a strict data-export headache. This is just a sketch of the shape I want, not the actual answer.

Please make sure to use the exact identifiers 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': 18, 'num_sets': 17, 'density': 0.22549019607843138, 'sets': [{'id': 1, 'elements': [5, 7]}, {'id': 2, 'elements': [2, 15, 16]}, {'id': 3, 'elements': [3, 4]}, {'id': 4, 'elements': [3, 10, 12, 17]}, {'id': 5, 'elements': [1, 5, 11, 13]}, {'id': 6, 'elements': [5, 7, 10]}, {'id': 7, 'elements': [1, 5, 7, 13]}, {'id': 8, 'elements': [8, 9, 10, 15, 16]}, {'id': 9, 'elements': [6, 8, 9, 10, 12, 15]}, {'id': 10, 'elements': [4, 6, 8, 9, 10, 17]}, {'id': 11, 'elements': [5, 8, 11, 13, 15]}, {'id': 12, 'elements': [3, 9, 10, 14]}, {'id': 13, 'elements': [1, 5, 7, 11, 13, 15]}, {'id': 14, 'elements': [12, 14]}, {'id': 15, 'elements': [2, 8, 9, 11, 13, 16]}, {'id': 16, 'elements': [2, 8, 15, 16, 18]}, {'id': 17, 'elements': [10, 17]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 12, 'v': 4}, {'u': 12, 'v': 10}, {'u': 12, 'v': 17}, {'u': 13, 'v': 5}, {'u': 13, 'v': 11}, {'u': 5, 'v': 1}, {'u': 5, 'v': 7}, {'u': 6, 'v': 7}, {'u': 6, 'v': 9}, {'u': 17, 'v': 14}, {'u': 8, 'v': 9}, {'u': 8, 'v': 15}, {'u': 9, 'v': 10}, {'u': 3, 'v': 4}, {'u': 11, 'v': 15}, {'u': 15, 'v': 16}, {'u': 18, 'v': 2}, {'u': 2, 'v': 16}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0030.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0030.png'}","[1, 2, 3, 14, 17]",5.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': ['E', 'G']}, {'id': 'S2', 'elements': ['B', 'O', 'P']}, {'id': 'S3', 'elements': ['C', 'D']}, {'id': 'S4', 'elements': ['C', 'J', 'L', 'Q']}, {'id': 'S5', 'elements': ['A', 'E', 'K', 'M']}, {'id': 'S6', 'elements': ['E', 'G', 'J']}, {'id': 'S7', 'elements': ['A', 'E', 'G', 'M']}, {'id': 'S8', 'elements': ['H', 'I', 'J', 'O', 'P']}, {'id': 'S9', 'elements': ['F', 'H', 'I', 'J', 'L', 'O']}, {'id': 'S10', 'elements': ['D', 'F', 'H', 'I', 'J', 'Q']}, {'id': 'S11', 'elements': ['E', 'H', 'K', 'M', 'O']}, {'id': 'S12', 'elements': ['C', 'I', 'J', 'N']}, {'id': 'S13', 'elements': ['A', 'E', 'G', 'K', 'M', 'O']}, {'id': 'S14', 'elements': ['L', 'N']}, {'id': 'S15', 'elements': ['B', 'H', 'I', 'K', 'M', 'P']}, {'id': 'S16', 'elements': ['B', 'H', 'O', 'P', 'R']}, {'id': 'S17', 'elements': ['J', 'Q']}]}","['S1', 'S2', 'S3', 'S14', 'S17']",31,csv,names
SP,SP,"There’s a coach trying to pack a practice full of useful drills, but every drill pulls in certain athletes. The aim is to include the highest possible number of drills in the session, with the rule that any individual athlete can only appear in one of the drills you pick — if two drills share someone, pick only one of them. You measure success by counting the drills you actually run; higher count is better. The specific drills and the players for each are listed below.

{
  ""total_athletes"": 16,
  ""total_drills"": 15,
  ""sets"": [
    {
      ""drill_id"": ""S1"",
      ""athletes"": [
        ""C"",
        ""D"",
        ""E"",
        ""N"",
        ""P""
      ]
    },
    {
      ""drill_id"": ""S2"",
      ""athletes"": [
        ""A"",
        ""C"",
        ""D"",
        ""G"",
        ""P""
      ]
    },
    {
      ""drill_id"": ""S3"",
      ""athletes"": [
        ""A"",
        ""D"",
        ""G"",
        ""H"",
        ""P""
      ]
    },
    {
      ""drill_id"": ""S4"",
      ""athletes"": [
        ""E"",
        ""N""
      ]
    },
    {
      ""drill_id"": ""S5"",
      ""athletes"": [
        ""F"",
        ""I"",
        ""J""
      ]
    },
    {
      ""drill_id"": ""S6"",
      ""athletes"": [
        ""D"",
        ""H""
      ]
    },
    {
      ""drill_id"": ""S7"",
      ""athletes"": [
        ""B"",
        ""G"",
        ""H"",
        ""M""
      ]
    },
    {
      ""drill_id"": ""S8"",
      ""athletes"": [
        ""F"",
        ""I"",
        ""J"",
        ""K"",
        ""O"",
        ""P""
      ]
    },
    {
      ""drill_id"": ""S9"",
      ""athletes"": [
        ""F"",
        ""I"",
        ""J"",
        ""K"",
        ""O""
      ]
    },
    {
      ""drill_id"": ""S10"",
      ""athletes"": [
        ""J"",
        ""L"",
        ""O""
      ]
    },
    {
      ""drill_id"": ""S11"",
      ""athletes"": [
        ""K"",
        ""L""
      ]
    },
    {
      ""drill_id"": ""S12"",
      ""athletes"": [
        ""B"",
        ""H"",
        ""M""
      ]
    },
    {
      ""drill_id"": ""S13"",
      ""athletes"": [
        ""A"",
        ""C"",
        ""N""
      ]
    },
    {
      ""drill_id"": ""S14"",
      ""athletes"": [
        ""I"",
        ""K"",
        ""O"",
        ""P""
      ]
    },
    {
      ""drill_id"": ""S15"",
      ""athletes"": [
        ""A"",
        ""C"",
        ""D"",
        ""I"",
        ""O"",
        ""P""
      ]
    }
  ]
}

Oh, and when you're ready to tell me which drills made the cut, just send them in this little JSON shape so it's easy to parse:

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

Think of ""solution"" as the list of drills you'll run, and each ""drill_id"" is the identifier for one drill from the list above. It's just a template showing the expected shape, not the actual answer you need to pick.

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': 16, 'num_sets': 15, 'density': 0.24166666666666667, 'sets': [{'id': 1, 'elements': [3, 4, 5, 14, 16]}, {'id': 2, 'elements': [1, 3, 4, 7, 16]}, {'id': 3, 'elements': [1, 4, 7, 8, 16]}, {'id': 4, 'elements': [5, 14]}, {'id': 5, 'elements': [6, 9, 10]}, {'id': 6, 'elements': [4, 8]}, {'id': 7, 'elements': [2, 7, 8, 13]}, {'id': 8, 'elements': [6, 9, 10, 11, 15, 16]}, {'id': 9, 'elements': [6, 9, 10, 11, 15]}, {'id': 10, 'elements': [10, 12, 15]}, {'id': 11, 'elements': [11, 12]}, {'id': 12, 'elements': [2, 8, 13]}, {'id': 13, 'elements': [1, 3, 14]}, {'id': 14, 'elements': [9, 11, 15, 16]}, {'id': 15, 'elements': [1, 3, 4, 9, 15, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 5, 'v': 14}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 15}, {'u': 10, 'v': 6}, {'u': 11, 'v': 12}, {'u': 15, 'v': 16}, {'u': 1, 'v': 3}, {'u': 1, 'v': 14}, {'u': 2, 'v': 8}, {'u': 3, 'v': 4}, {'u': 3, 'v': 16}, {'u': 4, 'v': 7}, {'u': 8, 'v': 7}, {'u': 8, 'v': 13}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0031.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0031.png'}","[2, 4, 5, 11, 12]",5.0,"{'num_elements': 16, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': ['C', 'D', 'E', 'N', 'P']}, {'id': 'S2', 'elements': ['A', 'C', 'D', 'G', 'P']}, {'id': 'S3', 'elements': ['A', 'D', 'G', 'H', 'P']}, {'id': 'S4', 'elements': ['E', 'N']}, {'id': 'S5', 'elements': ['F', 'I', 'J']}, {'id': 'S6', 'elements': ['D', 'H']}, {'id': 'S7', 'elements': ['B', 'G', 'H', 'M']}, {'id': 'S8', 'elements': ['F', 'I', 'J', 'K', 'O', 'P']}, {'id': 'S9', 'elements': ['F', 'I', 'J', 'K', 'O']}, {'id': 'S10', 'elements': ['J', 'L', 'O']}, {'id': 'S11', 'elements': ['K', 'L']}, {'id': 'S12', 'elements': ['B', 'H', 'M']}, {'id': 'S13', 'elements': ['A', 'C', 'N']}, {'id': 'S14', 'elements': ['I', 'K', 'O', 'P']}, {'id': 'S15', 'elements': ['A', 'C', 'D', 'I', 'O', 'P']}]}","['S2', 'S4', 'S5', 'S11', 'S12']",32,json,names
SP,SP,"Many people underestimate how tricky picking which packed boxes to seal can be when moving; here the job is to choose a group of boxes to tape up today. What “doing well” means here is having as many sealed boxes as possible — you measure that by counting the sealed boxes — and at the same time ensuring that no personal item is included in more than one of those sealed boxes. It’s okay if some packed boxes aren’t sealed; just make sure the sealed ones don’t share belongings. The specific box-by-box contents are shown below.

- **total_distinct_belongings**: 15
- **total_boxes_available**: 14

| box_id | box_contents |
|---|---|
| S1 | 1 2 5 13 |
| S2 | 6 13 |
| S3 | 7 9 11 12 |
| S4 | 3 8 9 11 |
| S5 | 1 5 15 |
| S6 | 2 6 |
| S7 | 3 4 7 10 11 |
| S8 | 3 4 8 14 |
| S9 | 4 9 11 12 15 |
| S10 | 10 11 14 |
| S11 | 3 4 7 9 10 11 14 |
| S12 | 3 5 9 12 |
| S13 | 4 7 8 10 11 |
| S14 | 5 9 12 13 15 |

When you’re ready to reply, just drop the selection into a tiny JSON snippet so it’s easy to parse. For this moving story, it can look like this:

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

Think of ""solution"" as the list of boxes you’ll tape up today — each entry should be the exact box identifier from the instance. This snippet is just a sketch of the shape I expect, not the actual answer itself, so replace the placeholder(s) with the real box IDs.

Please use the identifiers exactly as they appear in the instance input — no renaming, 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': 15, 'num_sets': 14, 'density': 0.2714285714285714, 'sets': [{'id': 1, 'elements': [1, 2, 5, 13]}, {'id': 2, 'elements': [6, 13]}, {'id': 3, 'elements': [7, 9, 11, 12]}, {'id': 4, 'elements': [3, 8, 9, 11]}, {'id': 5, 'elements': [1, 5, 15]}, {'id': 6, 'elements': [2, 6]}, {'id': 7, 'elements': [3, 4, 7, 10, 11]}, {'id': 8, 'elements': [3, 4, 8, 14]}, {'id': 9, 'elements': [4, 9, 11, 12, 15]}, {'id': 10, 'elements': [10, 11, 14]}, {'id': 11, 'elements': [3, 4, 7, 9, 10, 11, 14]}, {'id': 12, 'elements': [3, 5, 9, 12]}, {'id': 13, 'elements': [4, 7, 8, 10, 11]}, {'id': 14, 'elements': [5, 9, 12, 13, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 15, 'v': 5}, {'u': 15, 'v': 12}, {'u': 3, 'v': 4}, {'u': 3, 'v': 9}, {'u': 3, 'v': 11}, {'u': 5, 'v': 13}, {'u': 2, 'v': 1}, {'u': 2, 'v': 6}, {'u': 14, 'v': 4}, {'u': 14, 'v': 7}, {'u': 13, 'v': 1}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 8, 'v': 4}, {'u': 12, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0032.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0032.png'}","[3, 5, 6, 8]",4.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [1, 2, 5, 13]}, {'id': 'S2', 'elements': [6, 13]}, {'id': 'S3', 'elements': [7, 9, 11, 12]}, {'id': 'S4', 'elements': [3, 8, 9, 11]}, {'id': 'S5', 'elements': [1, 5, 15]}, {'id': 'S6', 'elements': [2, 6]}, {'id': 'S7', 'elements': [3, 4, 7, 10, 11]}, {'id': 'S8', 'elements': [3, 4, 8, 14]}, {'id': 'S9', 'elements': [4, 9, 11, 12, 15]}, {'id': 'S10', 'elements': [10, 11, 14]}, {'id': 'S11', 'elements': [3, 4, 7, 9, 10, 11, 14]}, {'id': 'S12', 'elements': [3, 5, 9, 12]}, {'id': 'S13', 'elements': [4, 7, 8, 10, 11]}, {'id': 'S14', 'elements': [5, 9, 12, 13, 15]}]}","['S3', 'S5', 'S6', 'S8']",33,markdown_table,1
SP,SP,"Someone on the ad team is trying to put together the busiest, most effective season of influencer collaborations. The better the plan, the more collaborations it includes, so evaluation is just a matter of tallying selected collaborations. The practical restriction is that any individual influencer can only take part in one chosen collaboration, so plans that double-book people aren’t allowed. The full lineup details follow below.

{
  ""total_influencers"": 15,
  ""total_collaborations_offered"": 14,
  ""sets"": [
    {
      ""collaboration_id"": ""S1"",
      ""collaboration_influencers"": [
        ""A"",
        ""I""
      ]
    },
    {
      ""collaboration_id"": ""S2"",
      ""collaboration_influencers"": [
        ""B"",
        ""O""
      ]
    },
    {
      ""collaboration_id"": ""S3"",
      ""collaboration_influencers"": [
        ""C"",
        ""I"",
        ""K"",
        ""M""
      ]
    },
    {
      ""collaboration_id"": ""S4"",
      ""collaboration_influencers"": [
        ""D"",
        ""E"",
        ""N""
      ]
    },
    {
      ""collaboration_id"": ""S5"",
      ""collaboration_influencers"": [
        ""B"",
        ""F"",
        ""L""
      ]
    },
    {
      ""collaboration_id"": ""S6"",
      ""collaboration_influencers"": [
        ""A"",
        ""G"",
        ""J"",
        ""M""
      ]
    },
    {
      ""collaboration_id"": ""S7"",
      ""collaboration_influencers"": [
        ""I"",
        ""L"",
        ""O""
      ]
    },
    {
      ""collaboration_id"": ""S8"",
      ""collaboration_influencers"": [
        ""A"",
        ""H""
      ]
    },
    {
      ""collaboration_id"": ""S9"",
      ""collaboration_influencers"": [
        ""A"",
        ""C"",
        ""M""
      ]
    },
    {
      ""collaboration_id"": ""S10"",
      ""collaboration_influencers"": [
        ""H"",
        ""I""
      ]
    },
    {
      ""collaboration_id"": ""S11"",
      ""collaboration_influencers"": [
        ""B"",
        ""F"",
        ""N"",
        ""O""
      ]
    },
    {
      ""collaboration_id"": ""S12"",
      ""collaboration_influencers"": [
        ""A"",
        ""C"",
        ""G"",
        ""J"",
        ""M""
      ]
    },
    {
      ""collaboration_id"": ""S13"",
      ""collaboration_influencers"": [
        ""D"",
        ""E"",
        ""L"",
        ""N"",
        ""O""
      ]
    },
    {
      ""collaboration_id"": ""S14"",
      ""collaboration_influencers"": [
        ""B"",
        ""D"",
        ""H"",
        ""K"",
        ""L"",
        ""N"",
        ""O""
      ]
    }
  ]
}

When you send back the chosen plan, just drop it into a tiny JSON object like this — keeps things simple:

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

This just means: put the selected collaboration IDs in the ""solution"" list. ""collab_id"" is a placeholder showing the format — you'll replace those placeholders with the actual IDs from the instance. It's just a sketch of the shape I want, not the final answer itself.

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': 15, 'num_sets': 14, 'density': 0.23333333333333334, 'sets': [{'id': 1, 'elements': [1, 9]}, {'id': 2, 'elements': [2, 15]}, {'id': 3, 'elements': [3, 9, 11, 13]}, {'id': 4, 'elements': [4, 5, 14]}, {'id': 5, 'elements': [2, 6, 12]}, {'id': 6, 'elements': [1, 7, 10, 13]}, {'id': 7, 'elements': [9, 12, 15]}, {'id': 8, 'elements': [1, 8]}, {'id': 9, 'elements': [1, 3, 13]}, {'id': 10, 'elements': [8, 9]}, {'id': 11, 'elements': [2, 6, 14, 15]}, {'id': 12, 'elements': [1, 3, 7, 10, 13]}, {'id': 13, 'elements': [4, 5, 12, 14, 15]}, {'id': 14, 'elements': [2, 4, 8, 11, 12, 14, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 13, 'v': 1}, {'u': 9, 'v': 3}, {'u': 9, 'v': 11}, {'u': 4, 'v': 5}, {'u': 4, 'v': 14}, {'u': 11, 'v': 8}, {'u': 14, 'v': 15}, {'u': 15, 'v': 8}, {'u': 15, 'v': 12}, {'u': 2, 'v': 6}, {'u': 2, 'v': 12}, {'u': 1, 'v': 3}, {'u': 1, 'v': 7}, {'u': 1, 'v': 10}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0033.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0033.png'}","[2, 3, 4, 8]",4.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'I']}, {'id': 'S2', 'elements': ['B', 'O']}, {'id': 'S3', 'elements': ['C', 'I', 'K', 'M']}, {'id': 'S4', 'elements': ['D', 'E', 'N']}, {'id': 'S5', 'elements': ['B', 'F', 'L']}, {'id': 'S6', 'elements': ['A', 'G', 'J', 'M']}, {'id': 'S7', 'elements': ['I', 'L', 'O']}, {'id': 'S8', 'elements': ['A', 'H']}, {'id': 'S9', 'elements': ['A', 'C', 'M']}, {'id': 'S10', 'elements': ['H', 'I']}, {'id': 'S11', 'elements': ['B', 'F', 'N', 'O']}, {'id': 'S12', 'elements': ['A', 'C', 'G', 'J', 'M']}, {'id': 'S13', 'elements': ['D', 'E', 'L', 'N', 'O']}, {'id': 'S14', 'elements': ['B', 'D', 'H', 'K', 'L', 'N', 'O']}]}","['S2', 'S3', 'S4', 'S8']",34,json,names
SP,SP,"Someone at the depot needs to build tomorrow’s plan by selecting delivery runs, trying to cram in as many runs as possible. How to compare plans is straightforward: whichever plan has more runs wins — count the runs to see. The only practical rule is that no customer can be scheduled on more than one of the picked runs, so the runs must not share stops. The full list of runs and customer stops follows below.

# total_customers=14
# total_runs=13
run_id,run_customers
S1,J K
S2,A F K
S3,C G
S4,A B D J K
S5,C F H
S6,F N
S7,C F G J L
S8,C E F H M
S9,I N
S10,B D F K
S11,A J K
S12,C H
S13,B I J N

If you want the plan in a machine-friendly nibble, I'll hand it over in a tiny JSON shape like this:

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

Here ""solution"" is just the list of chosen runs (one entry per run). Think of each string in that array as the exact run label from the input — the stops in a run are implied by that label. This JSON is only a sketch of the expected shape, 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': 14, 'num_sets': 13, 'density': 0.23076923076923078, 'sets': [{'id': 1, 'elements': [10, 11]}, {'id': 2, 'elements': [1, 6, 11]}, {'id': 3, 'elements': [3, 7]}, {'id': 4, 'elements': [1, 2, 4, 10, 11]}, {'id': 5, 'elements': [3, 6, 8]}, {'id': 6, 'elements': [6, 14]}, {'id': 7, 'elements': [3, 6, 7, 10, 12]}, {'id': 8, 'elements': [3, 5, 6, 8, 13]}, {'id': 9, 'elements': [9, 14]}, {'id': 10, 'elements': [2, 4, 6, 11]}, {'id': 11, 'elements': [1, 10, 11]}, {'id': 12, 'elements': [3, 8]}, {'id': 13, 'elements': [2, 9, 10, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 13, 'v': 8}, {'u': 5, 'v': 3}, {'u': 11, 'v': 2}, {'u': 14, 'v': 9}, {'u': 14, 'v': 10}, {'u': 3, 'v': 6}, {'u': 3, 'v': 8}, {'u': 7, 'v': 6}, {'u': 7, 'v': 12}, {'u': 1, 'v': 2}, {'u': 2, 'v': 4}, {'u': 2, 'v': 10}, {'u': 10, 'v': 6}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0034.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0034.png'}","[1, 3, 9]",3.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['J', 'K']}, {'id': 'S2', 'elements': ['A', 'F', 'K']}, {'id': 'S3', 'elements': ['C', 'G']}, {'id': 'S4', 'elements': ['A', 'B', 'D', 'J', 'K']}, {'id': 'S5', 'elements': ['C', 'F', 'H']}, {'id': 'S6', 'elements': ['F', 'N']}, {'id': 'S7', 'elements': ['C', 'F', 'G', 'J', 'L']}, {'id': 'S8', 'elements': ['C', 'E', 'F', 'H', 'M']}, {'id': 'S9', 'elements': ['I', 'N']}, {'id': 'S10', 'elements': ['B', 'D', 'F', 'K']}, {'id': 'S11', 'elements': ['A', 'J', 'K']}, {'id': 'S12', 'elements': ['C', 'H']}, {'id': 'S13', 'elements': ['B', 'I', 'J', 'N']}]}","['S1', 'S3', 'S9']",35,csv,names
SP,SP,"There’s a challenge at the community center: choose which after-school activities to offer so the schedule has as many different groups as possible, but make sure no child ends up on two rosters from the selected list. The way to see how well this goes is to count how many groups are on the final schedule — that’s the score — and every chosen group’s participants must be entirely separate from the participants of every other chosen group. The concrete sign-ups and group rosters follow below.

There are 13 group rosters listing 14 distinct children in total.
Group S1 roster: I K L M.
Group S2 roster: C E H J M.
Group S3 roster: J M.
Group S4 roster: B E H.
Group S5 roster: F I K.
Group S6 roster: F G K.
Group S7 roster: D E H J M.
Group S8 roster: F G I K.
Group S9 roster: B C D H J M.
Group S10 roster: A G K L M N.
Group S11 roster: A K L.
Group S12 roster: B D J.
Group S13 roster: K N.
Choose groups so no child appears in more than one chosen roster; your score is the number of groups scheduled.

Just drop your final selection in that format so I can read it reliably — something small and tidy like this:

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

Here ""solution"" is the list of the after-school groups you want on the schedule, and each entry in the array is the ID of a chosen group. Think of it as the simple form I'd fill out for you: one field, a list of the groups to run. This JSON is just a sketch of the shape I need — not the actual answer itself.

Please use the exact identifiers from the sign-up sheet — 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': 14, 'num_sets': 13, 'density': 0.2692307692307692, 'sets': [{'id': 1, 'elements': [9, 11, 12, 13]}, {'id': 2, 'elements': [3, 5, 8, 10, 13]}, {'id': 3, 'elements': [10, 13]}, {'id': 4, 'elements': [2, 5, 8]}, {'id': 5, 'elements': [6, 9, 11]}, {'id': 6, 'elements': [6, 7, 11]}, {'id': 7, 'elements': [4, 5, 8, 10, 13]}, {'id': 8, 'elements': [6, 7, 9, 11]}, {'id': 9, 'elements': [2, 3, 4, 8, 10, 13]}, {'id': 10, 'elements': [1, 7, 11, 12, 13, 14]}, {'id': 11, 'elements': [1, 11, 12]}, {'id': 12, 'elements': [2, 4, 10]}, {'id': 13, 'elements': [11, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 7, 'v': 9}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 1, 'v': 11}, {'u': 11, 'v': 9}, {'u': 11, 'v': 12}, {'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 9, 'v': 6}, {'u': 14, 'v': 12}, {'u': 2, 'v': 4}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0035.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0035.png'}","[3, 4, 6]",3.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['I', 'K', 'L', 'M']}, {'id': 'S2', 'elements': ['C', 'E', 'H', 'J', 'M']}, {'id': 'S3', 'elements': ['J', 'M']}, {'id': 'S4', 'elements': ['B', 'E', 'H']}, {'id': 'S5', 'elements': ['F', 'I', 'K']}, {'id': 'S6', 'elements': ['F', 'G', 'K']}, {'id': 'S7', 'elements': ['D', 'E', 'H', 'J', 'M']}, {'id': 'S8', 'elements': ['F', 'G', 'I', 'K']}, {'id': 'S9', 'elements': ['B', 'C', 'D', 'H', 'J', 'M']}, {'id': 'S10', 'elements': ['A', 'G', 'K', 'L', 'M', 'N']}, {'id': 'S11', 'elements': ['A', 'K', 'L']}, {'id': 'S12', 'elements': ['B', 'D', 'J']}, {'id': 'S13', 'elements': ['K', 'N']}]}","['S3', 'S4', 'S6']",36,nl,names
SP,SP,"I’m running the reading circles at the library and have a pile of proposed book discussion sessions, each with its own list of signed-up patrons. The job is to pick as many of those whole sessions to run as possible — success is simply the total number of sessions offered (just count them). The catch is that if a patron appears on two different session sign-up lists, only one of those sessions can be chosen, and every chosen session must be run with all its listed attendees; no splitting or double-booking people. The exact sign-ups and session details are shown below.

# total_patrons=15
# total_sessions_proposed=14
session_id,patron_ids
S1,1 7 8
S2,7 10 12
S3,3 4 5 7 9 13
S4,1 3 4 6 7 13 14
S5,3 9 11
S6,6 8 14
S7,1 2 3 4 7 9 10
S8,1 4 6 8 14
S9,5 9 11
S10,7 12 15
S11,2 15
S12,3 7 12 15
S13,1 4 8
S14,10 15

When you’re ready to tell me which sessions to run, just send the choices back using a tiny JSON like this:

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

Think of ""solution"" as the form field where you list the session IDs you want to run. Each entry in the array is one whole session — use the exact session identifier from the input for each chosen session. This JSON is just a sketch of the shape I expect, not the actual 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 14, 'density': 0.2571428571428571, 'sets': [{'id': 1, 'elements': [1, 7, 8]}, {'id': 2, 'elements': [7, 10, 12]}, {'id': 3, 'elements': [3, 4, 5, 7, 9, 13]}, {'id': 4, 'elements': [1, 3, 4, 6, 7, 13, 14]}, {'id': 5, 'elements': [3, 9, 11]}, {'id': 6, 'elements': [6, 8, 14]}, {'id': 7, 'elements': [1, 2, 3, 4, 7, 9, 10]}, {'id': 8, 'elements': [1, 4, 6, 8, 14]}, {'id': 9, 'elements': [5, 9, 11]}, {'id': 10, 'elements': [7, 12, 15]}, {'id': 11, 'elements': [2, 15]}, {'id': 12, 'elements': [3, 7, 12, 15]}, {'id': 13, 'elements': [1, 4, 8]}, {'id': 14, 'elements': [10, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 5, 'v': 9}, {'u': 5, 'v': 11}, {'u': 2, 'v': 10}, {'u': 2, 'v': 12}, {'u': 2, 'v': 13}, {'u': 2, 'v': 15}, {'u': 3, 'v': 7}, {'u': 3, 'v': 9}, {'u': 1, 'v': 4}, {'u': 1, 'v': 6}, {'u': 1, 'v': 8}, {'u': 1, 'v': 14}, {'u': 7, 'v': 4}, {'u': 7, 'v': 13}, {'u': 10, 'v': 13}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0036.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0036.png'}","[2, 6, 9, 11]",4.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [1, 7, 8]}, {'id': 'S2', 'elements': [7, 10, 12]}, {'id': 'S3', 'elements': [3, 4, 5, 7, 9, 13]}, {'id': 'S4', 'elements': [1, 3, 4, 6, 7, 13, 14]}, {'id': 'S5', 'elements': [3, 9, 11]}, {'id': 'S6', 'elements': [6, 8, 14]}, {'id': 'S7', 'elements': [1, 2, 3, 4, 7, 9, 10]}, {'id': 'S8', 'elements': [1, 4, 6, 8, 14]}, {'id': 'S9', 'elements': [5, 9, 11]}, {'id': 'S10', 'elements': [7, 12, 15]}, {'id': 'S11', 'elements': [2, 15]}, {'id': 'S12', 'elements': [3, 7, 12, 15]}, {'id': 'S13', 'elements': [1, 4, 8]}, {'id': 'S14', 'elements': [10, 15]}]}","['S2', 'S6', 'S9', 'S11']",37,csv,1
SP,SP,"We on the activities committee have to sort out which club meetings actually happen next month. The idea is to get as many different clubs running as we can; progress is measured by counting how many meetings make it onto the final plan. That only works if no student appears in two of those chosen meetings — every chosen meeting needs its own distinct set of students. The exact club names and student lists are provided below.

# total_students=13
# total_clubs_available=12
club_id,students_in_club
S1,1 2 4 12
S2,2 6 12 13
S3,3 7 11 13
S4,1 4
S5,6 7 8 12 13
S6,6 8 9 12 13
S7,3 5 11 12
S8,5 6 8 9 12
S9,6 8 9 10
S10,8 9
S11,1 5 6 8 12 13
S12,3 5 6 7

Oh, and when you send the final plan back, please put it in this simple JSON shape so it's easy to read by whoever's compiling the schedule:

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

Think of it like a little form: ""solution"" is the list of meetings we want to run, and each entry is the identifier for one chosen meeting. The example above is just the shape I expect — not the real answer, just a sketch of how to format your reply.

Please use the meeting identifiers exactly as they appear in the instance input — no renaming, 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': 13, 'num_sets': 12, 'density': 0.3141025641025641, 'sets': [{'id': 1, 'elements': [1, 2, 4, 12]}, {'id': 2, 'elements': [2, 6, 12, 13]}, {'id': 3, 'elements': [3, 7, 11, 13]}, {'id': 4, 'elements': [1, 4]}, {'id': 5, 'elements': [6, 7, 8, 12, 13]}, {'id': 6, 'elements': [6, 8, 9, 12, 13]}, {'id': 7, 'elements': [3, 5, 11, 12]}, {'id': 8, 'elements': [5, 6, 8, 9, 12]}, {'id': 9, 'elements': [6, 8, 9, 10]}, {'id': 10, 'elements': [8, 9]}, {'id': 11, 'elements': [1, 5, 6, 8, 12, 13]}, {'id': 12, 'elements': [3, 5, 6, 7]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 2, 'v': 1}, {'u': 2, 'v': 12}, {'u': 1, 'v': 4}, {'u': 11, 'v': 3}, {'u': 3, 'v': 7}, {'u': 5, 'v': 6}, {'u': 5, 'v': 13}, {'u': 6, 'v': 8}, {'u': 6, 'v': 12}, {'u': 7, 'v': 13}, {'u': 12, 'v': 13}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0037.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0037.png'}","[2, 4, 10]",3.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [1, 2, 4, 12]}, {'id': 'S2', 'elements': [2, 6, 12, 13]}, {'id': 'S3', 'elements': [3, 7, 11, 13]}, {'id': 'S4', 'elements': [1, 4]}, {'id': 'S5', 'elements': [6, 7, 8, 12, 13]}, {'id': 'S6', 'elements': [6, 8, 9, 12, 13]}, {'id': 'S7', 'elements': [3, 5, 11, 12]}, {'id': 'S8', 'elements': [5, 6, 8, 9, 12]}, {'id': 'S9', 'elements': [6, 8, 9, 10]}, {'id': 'S10', 'elements': [8, 9]}, {'id': 'S11', 'elements': [1, 5, 6, 8, 12, 13]}, {'id': 'S12', 'elements': [3, 5, 6, 7]}]}","['S2', 'S4', 'S10']",38,csv,1
SP,SP,"Someone in the marketing department has a stack of targeted campaigns and wants to run as many as possible, but each campaign pulls in certain consumer segments. To keep things clean, no consumer segment may be included in more than one campaign that’s actually run, so overlapping campaigns can’t both be selected. The better the selection, the more separate campaigns are launched — simply count how many make the cut. The detailed campaign and segment info follows below.

# num_consumer_segments=13
# num_campaigns=11
campaign_id,target_segments
S1,0 2 7 8 10 11 12
S2,1 5 11
S3,0 1 3 7 11
S4,7 11
S5,3 4 6 11
S6,2 11
S7,0 2 7 9 11
S8,0 8 10 12
S9,0 8 11
S10,0 1 2 3 4 5 6 7 8 10 11 12
S11,8 12

If you want to hand me the final selection, just drop it in this simple JSON shape so I can pick it up cleanly:

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

Think of ""solution"" as the list of campaign IDs you want to run — one entry per chosen campaign. The example value ""campaign_id"" is just a placeholder to show the format; replace those with the actual campaign identifiers from the instance when you submit your answer. This block is just a sketch of the shape I expect, not the actual 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”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 11, 'density': 0.34265734265734266, 'sets': [{'id': 1, 'elements': [1, 3, 8, 9, 11, 12, 13]}, {'id': 2, 'elements': [2, 6, 12]}, {'id': 3, 'elements': [1, 2, 4, 8, 12]}, {'id': 4, 'elements': [8, 12]}, {'id': 5, 'elements': [4, 5, 7, 12]}, {'id': 6, 'elements': [3, 12]}, {'id': 7, 'elements': [1, 3, 8, 10, 12]}, {'id': 8, 'elements': [1, 9, 11, 13]}, {'id': 9, 'elements': [1, 9, 12]}, {'id': 10, 'elements': [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13]}, {'id': 11, 'elements': [9, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 3, 'v': 2}, {'u': 3, 'v': 6}, {'u': 3, 'v': 12}, {'u': 9, 'v': 1}, {'u': 13, 'v': 1}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 7, 'v': 4}, {'u': 8, 'v': 10}, {'u': 8, 'v': 12}, {'u': 12, 'v': 4}, {'u': 4, 'v': 5}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0038.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0038.png'}","[2, 11]",2.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [0, 2, 7, 8, 10, 11, 12]}, {'id': 'S2', 'elements': [1, 5, 11]}, {'id': 'S3', 'elements': [0, 1, 3, 7, 11]}, {'id': 'S4', 'elements': [7, 11]}, {'id': 'S5', 'elements': [3, 4, 6, 11]}, {'id': 'S6', 'elements': [2, 11]}, {'id': 'S7', 'elements': [0, 2, 7, 9, 11]}, {'id': 'S8', 'elements': [0, 8, 10, 12]}, {'id': 'S9', 'elements': [0, 8, 11]}, {'id': 'S10', 'elements': [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12]}, {'id': 'S11', 'elements': [8, 12]}]}","['S2', 'S11']",39,csv,0
SP,SP,"We have a stack of proposed care teams and a limited pool of nurses and aides, so the task is to decide which team combinations to put into service so that the most teams are active. Success is measured by how many teams get the green light — just count them. The catch is that nobody on the roster can be assigned to two active teams at once. The exact team rosters and details follow below.

- **total_staff_members**: 16
- **number_of_teams_proposed**: 15

| team_id | team_member_ids |
|---|---|
| S1 | D E G N |
| S2 | B E N P |
| S3 | C E F H |
| S4 | D J |
| S5 | C E F H I L N P |
| S6 | C E H L |
| S7 | G N |
| S8 | E F |
| S9 | A E I N |
| S10 | A D J |
| S11 | A O |
| S12 | B C F H N |
| S13 | K M |
| S14 | E G I L N O |
| S15 | E P |

Also, when you send the final selection, please use this simple JSON layout so it's easy to parse:

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

Think of ""solution"" as just a list of the team IDs you want to activate — one string per chosen team. This is only a sketch of the shape I expect, not the actual answer; replace the placeholders with the real IDs from the instance.

Please use the identifiers exactly as they appear in the instance input — no renaming, 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': 16, 'num_sets': 15, 'density': 0.225, 'sets': [{'id': 1, 'elements': [4, 5, 7, 14]}, {'id': 2, 'elements': [2, 5, 14, 16]}, {'id': 3, 'elements': [3, 5, 6, 8]}, {'id': 4, 'elements': [4, 10]}, {'id': 5, 'elements': [3, 5, 6, 8, 9, 12, 14, 16]}, {'id': 6, 'elements': [3, 5, 8, 12]}, {'id': 7, 'elements': [7, 14]}, {'id': 8, 'elements': [5, 6]}, {'id': 9, 'elements': [1, 5, 9, 14]}, {'id': 10, 'elements': [1, 4, 10]}, {'id': 11, 'elements': [1, 15]}, {'id': 12, 'elements': [2, 3, 6, 8, 14]}, {'id': 13, 'elements': [11, 13]}, {'id': 14, 'elements': [5, 7, 9, 12, 14, 15]}, {'id': 15, 'elements': [5, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 2, 'v': 5}, {'u': 2, 'v': 16}, {'u': 5, 'v': 12}, {'u': 5, 'v': 14}, {'u': 12, 'v': 3}, {'u': 12, 'v': 6}, {'u': 12, 'v': 8}, {'u': 1, 'v': 7}, {'u': 1, 'v': 14}, {'u': 1, 'v': 15}, {'u': 13, 'v': 15}, {'u': 4, 'v': 7}, {'u': 15, 'v': 11}, {'u': 10, 'v': 7}, {'u': 9, 'v': 14}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0039.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0039.png'}","[4, 7, 11, 13, 15]",5.0,"{'num_elements': 16, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': ['D', 'E', 'G', 'N']}, {'id': 'S2', 'elements': ['B', 'E', 'N', 'P']}, {'id': 'S3', 'elements': ['C', 'E', 'F', 'H']}, {'id': 'S4', 'elements': ['D', 'J']}, {'id': 'S5', 'elements': ['C', 'E', 'F', 'H', 'I', 'L', 'N', 'P']}, {'id': 'S6', 'elements': ['C', 'E', 'H', 'L']}, {'id': 'S7', 'elements': ['G', 'N']}, {'id': 'S8', 'elements': ['E', 'F']}, {'id': 'S9', 'elements': ['A', 'E', 'I', 'N']}, {'id': 'S10', 'elements': ['A', 'D', 'J']}, {'id': 'S11', 'elements': ['A', 'O']}, {'id': 'S12', 'elements': ['B', 'C', 'F', 'H', 'N']}, {'id': 'S13', 'elements': ['K', 'M']}, {'id': 'S14', 'elements': ['E', 'G', 'I', 'L', 'N', 'O']}, {'id': 'S15', 'elements': ['E', 'P']}]}","['S4', 'S7', 'S11', 'S13', 'S15']",40,markdown_table,names
SP,SP,"There’s a little puzzle at the travel desk: which guided excursions should be offered so the calendar is packed with as many different trips as possible? Each excursion visits a group of landmarks, and the rule is that once a landmark is assigned to a chosen excursion it can’t be part of any other chosen one — no overlaps allowed. A better decision is simply the one that results in the largest number of selected excursions (you can check this by counting them), and the full list of tours and their stops is shown below.

{
  ""total_landmarks"": 13,
  ""total_excursions"": 12,
  ""sets"": [
    {
      ""excursion_id"": ""S1"",
      ""landmarks_in_excursion"": [
        1,
        5
      ]
    },
    {
      ""excursion_id"": ""S2"",
      ""landmarks_in_excursion"": [
        2,
        8,
        10,
        12,
        13
      ]
    },
    {
      ""excursion_id"": ""S3"",
      ""landmarks_in_excursion"": [
        3,
        5,
        6
      ]
    },
    {
      ""excursion_id"": ""S4"",
      ""landmarks_in_excursion"": [
        1,
        4,
        5,
        6,
        7
      ]
    },
    {
      ""excursion_id"": ""S5"",
      ""landmarks_in_excursion"": [
        3,
        5,
        6,
        9
      ]
    },
    {
      ""excursion_id"": ""S6"",
      ""landmarks_in_excursion"": [
        2,
        7,
        9,
        12
      ]
    },
    {
      ""excursion_id"": ""S7"",
      ""landmarks_in_excursion"": [
        2,
        7,
        8,
        9,
        10,
        13
      ]
    },
    {
      ""excursion_id"": ""S8"",
      ""landmarks_in_excursion"": [
        6,
        7,
        8,
        9
      ]
    },
    {
      ""excursion_id"": ""S9"",
      ""landmarks_in_excursion"": [
        8,
        10,
        11,
        12,
        13
      ]
    },
    {
      ""excursion_id"": ""S10"",
      ""landmarks_in_excursion"": [
        8,
        11,
        12
      ]
    },
    {
      ""excursion_id"": ""S11"",
      ""landmarks_in_excursion"": [
        2,
        7,
        8,
        11,
        12
      ]
    },
    {
      ""excursion_id"": ""S12"",
      ""landmarks_in_excursion"": [
        2,
        8,
        13
      ]
    }
  ]
}

Just send back the selected tours in a tiny JSON snippet like this so it's easy to parse:

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

Think of ""solution"" as the form field that holds your choices — list the identifiers of the excursions you want to offer, one per entry in the array. This JSON is just a sketch of the shape I expect, not the actual answer.

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': 13, 'num_sets': 12, 'density': 0.3141025641025641, 'sets': [{'id': 1, 'elements': [1, 5]}, {'id': 2, 'elements': [2, 8, 10, 12, 13]}, {'id': 3, 'elements': [3, 5, 6]}, {'id': 4, 'elements': [1, 4, 5, 6, 7]}, {'id': 5, 'elements': [3, 5, 6, 9]}, {'id': 6, 'elements': [2, 7, 9, 12]}, {'id': 7, 'elements': [2, 7, 8, 9, 10, 13]}, {'id': 8, 'elements': [6, 7, 8, 9]}, {'id': 9, 'elements': [8, 10, 11, 12, 13]}, {'id': 10, 'elements': [8, 11, 12]}, {'id': 11, 'elements': [2, 7, 8, 11, 12]}, {'id': 12, 'elements': [2, 8, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 8, 'v': 2}, {'u': 8, 'v': 7}, {'u': 8, 'v': 12}, {'u': 10, 'v': 2}, {'u': 10, 'v': 12}, {'u': 5, 'v': 6}, {'u': 5, 'v': 9}, {'u': 12, 'v': 11}, {'u': 2, 'v': 13}, {'u': 4, 'v': 3}, {'u': 4, 'v': 6}, {'u': 7, 'v': 9}, {'u': 1, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0040.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0040.png'}","[1, 6]",2.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [1, 5]}, {'id': 'S2', 'elements': [2, 8, 10, 12, 13]}, {'id': 'S3', 'elements': [3, 5, 6]}, {'id': 'S4', 'elements': [1, 4, 5, 6, 7]}, {'id': 'S5', 'elements': [3, 5, 6, 9]}, {'id': 'S6', 'elements': [2, 7, 9, 12]}, {'id': 'S7', 'elements': [2, 7, 8, 9, 10, 13]}, {'id': 'S8', 'elements': [6, 7, 8, 9]}, {'id': 'S9', 'elements': [8, 10, 11, 12, 13]}, {'id': 'S10', 'elements': [8, 11, 12]}, {'id': 'S11', 'elements': [2, 7, 8, 11, 12]}, {'id': 'S12', 'elements': [2, 8, 13]}]}","['S1', 'S6']",41,json,1
SP,SP,"Our charity has a stack of suggested pickup routes and the planner’s job is to pick the most routes possible to actually run; the performance metric is the count of routes we end up scheduling. The non-negotiable rule is that a particular address cannot appear on more than one scheduled route, so any shared addresses mean only one of the conflicting routes can be selected. The concrete list of routes and their addresses is given below.

- **total_addresses**: 15
- **total_routes**: 15

| route_id | route_addresses |
|---|---|
| S1 | 0 3 8 13 |
| S2 | 1 4 12 |
| S3 | 2 3 12 14 |
| S4 | 0 8 13 14 |
| S5 | 1 4 6 12 |
| S6 | 5 7 9 10 11 |
| S7 | 1 6 12 |
| S8 | 2 7 9 12 14 |
| S9 | 0 3 8 14 |
| S10 | 5 7 10 11 |
| S11 | 5 7 10 |
| S12 | 5 11 |
| S13 | 1 6 7 12 14 |
| S14 | 0 3 13 |
| S15 | 0 7 8 14 |

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

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

This ""solution"" array is just the list of route IDs you want to run — one entry per scheduled route. The placeholder ""route_id"" just stands in for whatever route labels appear in the instance; treat the JSON above as a sketch of the shape I need, not the actual answer.

Please be sure to use the exact route identifiers 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': 15, 'num_sets': 15, 'density': 0.25333333333333335, 'sets': [{'id': 1, 'elements': [1, 4, 9, 14]}, {'id': 2, 'elements': [2, 5, 13]}, {'id': 3, 'elements': [3, 4, 13, 15]}, {'id': 4, 'elements': [1, 9, 14, 15]}, {'id': 5, 'elements': [2, 5, 7, 13]}, {'id': 6, 'elements': [6, 8, 10, 11, 12]}, {'id': 7, 'elements': [2, 7, 13]}, {'id': 8, 'elements': [3, 8, 10, 13, 15]}, {'id': 9, 'elements': [1, 4, 9, 15]}, {'id': 10, 'elements': [6, 8, 11, 12]}, {'id': 11, 'elements': [6, 8, 11]}, {'id': 12, 'elements': [6, 12]}, {'id': 13, 'elements': [2, 7, 8, 13, 15]}, {'id': 14, 'elements': [1, 4, 14]}, {'id': 15, 'elements': [1, 8, 9, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 1, 'v': 4}, {'u': 1, 'v': 14}, {'u': 8, 'v': 3}, {'u': 8, 'v': 10}, {'u': 9, 'v': 4}, {'u': 4, 'v': 15}, {'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 12, 'v': 6}, {'u': 7, 'v': 2}, {'u': 5, 'v': 2}, {'u': 15, 'v': 3}, {'u': 11, 'v': 10}, {'u': 10, 'v': 6}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0041.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0041.png'}","[2, 12, 14]",3.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [0, 3, 8, 13]}, {'id': 'S2', 'elements': [1, 4, 12]}, {'id': 'S3', 'elements': [2, 3, 12, 14]}, {'id': 'S4', 'elements': [0, 8, 13, 14]}, {'id': 'S5', 'elements': [1, 4, 6, 12]}, {'id': 'S6', 'elements': [5, 7, 9, 10, 11]}, {'id': 'S7', 'elements': [1, 6, 12]}, {'id': 'S8', 'elements': [2, 7, 9, 12, 14]}, {'id': 'S9', 'elements': [0, 3, 8, 14]}, {'id': 'S10', 'elements': [5, 7, 10, 11]}, {'id': 'S11', 'elements': [5, 7, 10]}, {'id': 'S12', 'elements': [5, 11]}, {'id': 'S13', 'elements': [1, 6, 7, 12, 14]}, {'id': 'S14', 'elements': [0, 3, 13]}, {'id': 'S15', 'elements': [0, 7, 8, 14]}]}","['S2', 'S12', 'S14']",42,markdown_table,0
SP,SP,"Recently the registrar’s team was handed dozens of elective seminar submissions and the task was to pick the largest possible set to run this semester. The measure of success is straightforward: how many seminars end up on the schedule — count them up. One real-world constraint is that no single instructor can be listed to teach more than one of the selected seminars, meaning two proposals that need the same person can’t both be approved. The exact proposals and instructor names follow below.

{
  ""total_instructors"": 15,
  ""total_proposals"": 13,
  ""sets"": [
    {
      ""proposal_id"": ""S1"",
      ""instructor_names"": [
        0,
        1,
        2,
        14
      ]
    },
    {
      ""proposal_id"": ""S2"",
      ""instructor_names"": [
        0,
        1,
        4,
        14
      ]
    },
    {
      ""proposal_id"": ""S3"",
      ""instructor_names"": [
        0,
        2,
        5,
        11,
        14
      ]
    },
    {
      ""proposal_id"": ""S4"",
      ""instructor_names"": [
        1,
        3,
        4,
        9,
        11
      ]
    },
    {
      ""proposal_id"": ""S5"",
      ""instructor_names"": [
        0,
        1,
        3,
        4
      ]
    },
    {
      ""proposal_id"": ""S6"",
      ""instructor_names"": [
        2,
        6,
        8,
        11,
        12
      ]
    },
    {
      ""proposal_id"": ""S7"",
      ""instructor_names"": [
        6,
        7,
        8,
        12,
        13
      ]
    },
    {
      ""proposal_id"": ""S8"",
      ""instructor_names"": [
        6,
        13
      ]
    },
    {
      ""proposal_id"": ""S9"",
      ""instructor_names"": [
        4,
        10,
        11
      ]
    },
    {
      ""proposal_id"": ""S10"",
      ""instructor_names"": [
        3,
        10,
        11
      ]
    },
    {
      ""proposal_id"": ""S11"",
      ""instructor_names"": [
        2,
        3,
        4,
        10,
        11
      ]
    },
    {
      ""proposal_id"": ""S12"",
      ""instructor_names"": [
        4,
        6,
        9,
        12,
        14
      ]
    },
    {
      ""proposal_id"": ""S13"",
      ""instructor_names"": [
        1,
        2,
        12
      ]
    }
  ]
}

When you send back your pick, just use a tiny JSON snippet so it's easy to parse. Something like this:

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

""solution"" is the list of the selected seminar identifiers (one entry per approved proposal). The ""seminar_id"" text is just a placeholder showing the shape — replace those placeholders with the actual IDs from the instance when you give the real answer. This JSON is only a sketch of the expected shape, not the actual selection.

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': 15, 'num_sets': 13, 'density': 0.2717948717948718, 'sets': [{'id': 1, 'elements': [1, 2, 3, 15]}, {'id': 2, 'elements': [1, 2, 5, 15]}, {'id': 3, 'elements': [1, 3, 6, 12, 15]}, {'id': 4, 'elements': [2, 4, 5, 10, 12]}, {'id': 5, 'elements': [1, 2, 4, 5]}, {'id': 6, 'elements': [3, 7, 9, 12, 13]}, {'id': 7, 'elements': [7, 8, 9, 13, 14]}, {'id': 8, 'elements': [7, 14]}, {'id': 9, 'elements': [5, 11, 12]}, {'id': 10, 'elements': [4, 11, 12]}, {'id': 11, 'elements': [3, 4, 5, 11, 12]}, {'id': 12, 'elements': [5, 7, 10, 13, 15]}, {'id': 13, 'elements': [2, 3, 13]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 13}, {'u': 7, 'v': 9}, {'u': 9, 'v': 14}, {'u': 10, 'v': 4}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 1, 'v': 2}, {'u': 1, 'v': 15}, {'u': 2, 'v': 5}, {'u': 12, 'v': 5}, {'u': 12, 'v': 13}, {'u': 13, 'v': 3}, {'u': 3, 'v': 15}, {'u': 4, 'v': 5}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0042.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0042.png'}","[1, 8, 10]",3.0,"{'num_elements': 15, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 1, 2, 14]}, {'id': 'S2', 'elements': [0, 1, 4, 14]}, {'id': 'S3', 'elements': [0, 2, 5, 11, 14]}, {'id': 'S4', 'elements': [1, 3, 4, 9, 11]}, {'id': 'S5', 'elements': [0, 1, 3, 4]}, {'id': 'S6', 'elements': [2, 6, 8, 11, 12]}, {'id': 'S7', 'elements': [6, 7, 8, 12, 13]}, {'id': 'S8', 'elements': [6, 13]}, {'id': 'S9', 'elements': [4, 10, 11]}, {'id': 'S10', 'elements': [3, 10, 11]}, {'id': 'S11', 'elements': [2, 3, 4, 10, 11]}, {'id': 'S12', 'elements': [4, 6, 9, 12, 14]}, {'id': 'S13', 'elements': [1, 2, 12]}]}","['S1', 'S8', 'S10']",43,json,0
SP,SP,"Recently the fundraising team was handed a batch of donor lists to action, and the coordinator needs to pick which ones to run. The simple metric is how many lists are picked and acted on — that number is what we try to maximize. The practical constraint is that no individual donor can appear on more than one of the picked lists, so each chosen list must contain completely different people. The full, concrete details are shown below.

- **total_donors**: 17
- **total_donor_lists**: 16

| list_id | donor_ids |
|---|---|
| S1 | B D H I L M Q |
| S2 | A B C D H L M O |
| S3 | C J M O P |
| S4 | B D E G H K L N |
| S5 | B D E K N O |
| S6 | D E G K O |
| S7 | B D H K N |
| S8 | A B C I J L M O P |
| S9 | C F M P |
| S10 | A D E H K Q |
| S11 | A B D E I L M |
| S12 | C E I J O Q |
| S13 | A D E G H I L N P |
| S14 | B C E F G I J M O P |
| S15 | C I J O P |
| S16 | B H I K |

Oh, and to keep things machine-friendly, please return your pick in this simple JSON shape:

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

Here ""solution"" is just the array of donor lists we decide to run, and each ""list_id"" is the identifier for one of those lists (a placeholder showing the kind of value I expect). This JSON is only a sketch of the expected shape — fill it with the actual list identifiers from the instance when you reply.

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': 17, 'num_sets': 16, 'density': 0.38235294117647056, 'sets': [{'id': 1, 'elements': [2, 4, 8, 9, 12, 13, 17]}, {'id': 2, 'elements': [1, 2, 3, 4, 8, 12, 13, 15]}, {'id': 3, 'elements': [3, 10, 13, 15, 16]}, {'id': 4, 'elements': [2, 4, 5, 7, 8, 11, 12, 14]}, {'id': 5, 'elements': [2, 4, 5, 11, 14, 15]}, {'id': 6, 'elements': [4, 5, 7, 11, 15]}, {'id': 7, 'elements': [2, 4, 8, 11, 14]}, {'id': 8, 'elements': [1, 2, 3, 9, 10, 12, 13, 15, 16]}, {'id': 9, 'elements': [3, 6, 13, 16]}, {'id': 10, 'elements': [1, 4, 5, 8, 11, 17]}, {'id': 11, 'elements': [1, 2, 4, 5, 9, 12, 13]}, {'id': 12, 'elements': [3, 5, 9, 10, 15, 17]}, {'id': 13, 'elements': [1, 4, 5, 7, 8, 9, 12, 14, 16]}, {'id': 14, 'elements': [2, 3, 5, 6, 7, 9, 10, 13, 15, 16]}, {'id': 15, 'elements': [3, 9, 10, 15, 16]}, {'id': 16, 'elements': [2, 8, 9, 11]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 9}, {'u': 14, 'v': 4}, {'u': 14, 'v': 5}, {'u': 14, 'v': 7}, {'u': 14, 'v': 11}, {'u': 12, 'v': 2}, {'u': 12, 'v': 4}, {'u': 12, 'v': 5}, {'u': 8, 'v': 1}, {'u': 8, 'v': 11}, {'u': 8, 'v': 17}, {'u': 6, 'v': 10}, {'u': 2, 'v': 1}, {'u': 2, 'v': 9}, {'u': 2, 'v': 17}, {'u': 10, 'v': 3}, {'u': 10, 'v': 15}, {'u': 4, 'v': 1}, {'u': 16, 'v': 7}, {'u': 16, 'v': 15}, {'u': 3, 'v': 15}, {'u': 5, 'v': 9}, {'u': 15, 'v': 9}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0043.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0043.png'}","[7, 9]",2.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['B', 'D', 'H', 'I', 'L', 'M', 'Q']}, {'id': 'S2', 'elements': ['A', 'B', 'C', 'D', 'H', 'L', 'M', 'O']}, {'id': 'S3', 'elements': ['C', 'J', 'M', 'O', 'P']}, {'id': 'S4', 'elements': ['B', 'D', 'E', 'G', 'H', 'K', 'L', 'N']}, {'id': 'S5', 'elements': ['B', 'D', 'E', 'K', 'N', 'O']}, {'id': 'S6', 'elements': ['D', 'E', 'G', 'K', 'O']}, {'id': 'S7', 'elements': ['B', 'D', 'H', 'K', 'N']}, {'id': 'S8', 'elements': ['A', 'B', 'C', 'I', 'J', 'L', 'M', 'O', 'P']}, {'id': 'S9', 'elements': ['C', 'F', 'M', 'P']}, {'id': 'S10', 'elements': ['A', 'D', 'E', 'H', 'K', 'Q']}, {'id': 'S11', 'elements': ['A', 'B', 'D', 'E', 'I', 'L', 'M']}, {'id': 'S12', 'elements': ['C', 'E', 'I', 'J', 'O', 'Q']}, {'id': 'S13', 'elements': ['A', 'D', 'E', 'G', 'H', 'I', 'L', 'N', 'P']}, {'id': 'S14', 'elements': ['B', 'C', 'E', 'F', 'G', 'I', 'J', 'M', 'O', 'P']}, {'id': 'S15', 'elements': ['C', 'I', 'J', 'O', 'P']}, {'id': 'S16', 'elements': ['B', 'H', 'I', 'K']}]}","['S7', 'S9']",44,markdown_table,names
SP,SP,"There’s a festival lineup puzzle: choose as many of the available time slots as will fit into the weekend, but every slot carries its own roster of performers and nobody can appear in more than one of the picked slots. Success is measured by how many slots end up filled — just count them — and any plan that has an artist showing up in two places gets tossed. The specific slot listings and performer rosters are shown below.

- **num_performers**: 15
- **num_slots**: 15

| slot_id | performers |
|---|---|
| S1 | 1 6 12 14 |
| S2 | 2 14 |
| S3 | 6 12 14 |
| S4 | 4 5 11 |
| S5 | 4 5 9 11 |
| S6 | 1 6 14 |
| S7 | 10 12 15 |
| S8 | 2 7 8 10 14 |
| S9 | 4 5 9 13 |
| S10 | 7 10 11 12 14 |
| S11 | 4 5 13 |
| S12 | 6 8 12 |
| S13 | 10 11 |
| S14 | 2 3 6 7 8 12 13 14 15 |
| S15 | 7 14 15 |

If you're going to send me a plan, just drop it in a tiny JSON object like this:

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

Think of ""solution"" as the list of festival slots you want to lock in. Each item in that array should be the exact slot identifier from the instance (this block is just a shape example, not your 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': 15, 'num_sets': 15, 'density': 0.24888888888888888, 'sets': [{'id': 1, 'elements': [1, 6, 12, 14]}, {'id': 2, 'elements': [2, 14]}, {'id': 3, 'elements': [6, 12, 14]}, {'id': 4, 'elements': [4, 5, 11]}, {'id': 5, 'elements': [4, 5, 9, 11]}, {'id': 6, 'elements': [1, 6, 14]}, {'id': 7, 'elements': [10, 12, 15]}, {'id': 8, 'elements': [2, 7, 8, 10, 14]}, {'id': 9, 'elements': [4, 5, 9, 13]}, {'id': 10, 'elements': [7, 10, 11, 12, 14]}, {'id': 11, 'elements': [4, 5, 13]}, {'id': 12, 'elements': [6, 8, 12]}, {'id': 13, 'elements': [10, 11]}, {'id': 14, 'elements': [2, 3, 6, 7, 8, 12, 13, 14, 15]}, {'id': 15, 'elements': [7, 14, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 11, 'v': 9}, {'u': 11, 'v': 13}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 3, 'v': 12}, {'u': 15, 'v': 7}, {'u': 14, 'v': 7}, {'u': 14, 'v': 8}, {'u': 14, 'v': 12}, {'u': 9, 'v': 4}, {'u': 9, 'v': 5}, {'u': 12, 'v': 1}, {'u': 12, 'v': 6}, {'u': 2, 'v': 8}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0044.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0044.png'}","[2, 11, 12, 13]",4.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [1, 6, 12, 14]}, {'id': 'S2', 'elements': [2, 14]}, {'id': 'S3', 'elements': [6, 12, 14]}, {'id': 'S4', 'elements': [4, 5, 11]}, {'id': 'S5', 'elements': [4, 5, 9, 11]}, {'id': 'S6', 'elements': [1, 6, 14]}, {'id': 'S7', 'elements': [10, 12, 15]}, {'id': 'S8', 'elements': [2, 7, 8, 10, 14]}, {'id': 'S9', 'elements': [4, 5, 9, 13]}, {'id': 'S10', 'elements': [7, 10, 11, 12, 14]}, {'id': 'S11', 'elements': [4, 5, 13]}, {'id': 'S12', 'elements': [6, 8, 12]}, {'id': 'S13', 'elements': [10, 11]}, {'id': 'S14', 'elements': [2, 3, 6, 7, 8, 12, 13, 14, 15]}, {'id': 'S15', 'elements': [7, 14, 15]}]}","['S2', 'S11', 'S12', 'S13']",45,markdown_table,1
SP,SP,"Recently I’ve been sorting through client proposals that each require a small crew of subcontractors. The job is to pick a set of proposals that leads to the biggest number of wins — success equals the number of projects I commit to, plain and simple. The real limitation is that no subcontractor can be committed to more than one of those chosen projects, so selections can’t share people. The detailed list of projects and crews is shown below.

# num_subcontractors=13
# num_projects=12
project_id,subcontractors
S1,A C K
S2,C F L
S3,A B J L
S4,E G
S5,D E I J M
S6,J M
S7,G H M
S8,E I J
S9,B C E G J K L
S10,B F J K L
S11,B J K L
S12,E G H

Also, when you send back your choice, tuck it into this little JSON shape so it's easy to read:

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

Here ""solution"" is just the list of proposals you're committing to, and each ""proposal_id"" is a placeholder for an actual proposal label from the instance. Think of it like filling in a simple form — the array is the chosen projects. This JSON is only a sketch of the expected shape, not the final answer itself.

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': 13, 'num_sets': 12, 'density': 0.28205128205128205, 'sets': [{'id': 1, 'elements': [1, 3, 11]}, {'id': 2, 'elements': [3, 6, 12]}, {'id': 3, 'elements': [1, 2, 10, 12]}, {'id': 4, 'elements': [5, 7]}, {'id': 5, 'elements': [4, 5, 9, 10, 13]}, {'id': 6, 'elements': [10, 13]}, {'id': 7, 'elements': [7, 8, 13]}, {'id': 8, 'elements': [5, 9, 10]}, {'id': 9, 'elements': [2, 3, 5, 7, 10, 11, 12]}, {'id': 10, 'elements': [2, 6, 10, 11, 12]}, {'id': 11, 'elements': [2, 10, 11, 12]}, {'id': 12, 'elements': [5, 7, 8]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 9, 'v': 5}, {'u': 8, 'v': 13}, {'u': 13, 'v': 7}, {'u': 12, 'v': 11}, {'u': 5, 'v': 7}, {'u': 5, 'v': 10}, {'u': 10, 'v': 11}, {'u': 6, 'v': 2}, {'u': 1, 'v': 3}, {'u': 3, 'v': 11}, {'u': 11, 'v': 2}, {'u': 7, 'v': 4}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0045.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0045.png'}","[1, 4, 6]",3.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'K']}, {'id': 'S2', 'elements': ['C', 'F', 'L']}, {'id': 'S3', 'elements': ['A', 'B', 'J', 'L']}, {'id': 'S4', 'elements': ['E', 'G']}, {'id': 'S5', 'elements': ['D', 'E', 'I', 'J', 'M']}, {'id': 'S6', 'elements': ['J', 'M']}, {'id': 'S7', 'elements': ['G', 'H', 'M']}, {'id': 'S8', 'elements': ['E', 'I', 'J']}, {'id': 'S9', 'elements': ['B', 'C', 'E', 'G', 'J', 'K', 'L']}, {'id': 'S10', 'elements': ['B', 'F', 'J', 'K', 'L']}, {'id': 'S11', 'elements': ['B', 'J', 'K', 'L']}, {'id': 'S12', 'elements': ['E', 'G', 'H']}]}","['S1', 'S4', 'S6']",46,csv,names
SP,SP,"Imagine running the app store picks and trying to cram the front page full of bundles — except every app is exclusive, so it can’t be used twice. The triumph is packing in as many bundles as possible without any shared apps; success is measured simply by the number of bundles that make the cut. The particular bundles and their contents are shown below.

# total_unique_apps=18
# total_bundles=16
bundle_id,bundle_apps
S1,2 3 4 8 11 13 14 16
S2,1 4 5 6 7 11 18
S3,3 9 13 15 17
S4,1 2 9 14 16
S5,2 3 5 8 15
S6,2 7 11
S7,1 2 3 5 6 8 11 18
S8,2 3 4 9 13 14 15
S9,4 10 12 13 14
S10,1 2 11 18
S11,10 12 14
S12,1 4 9 10 17
S13,1 4 9 10 12 16 17
S14,3 5 9 13 15
S15,1 16
S16,1 2 6 11 18

Also, when you give me the final pick, just send it in a tiny JSON object like this:

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

""solution"" is the array of bundles you chose for the front page — each entry is the ID of one bundle that made the cut. Think of it like filling out a quick form: list the bundle IDs you want shown, in whatever order you like.

This JSON is just a sketch of the shape I expect, not the actual answer — replace the placeholder entries with the real IDs from the instance.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.

For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 16, 'density': 0.2916666666666667, 'sets': [{'id': 1, 'elements': [2, 3, 4, 8, 11, 13, 14, 16]}, {'id': 2, 'elements': [1, 4, 5, 6, 7, 11, 18]}, {'id': 3, 'elements': [3, 9, 13, 15, 17]}, {'id': 4, 'elements': [1, 2, 9, 14, 16]}, {'id': 5, 'elements': [2, 3, 5, 8, 15]}, {'id': 6, 'elements': [2, 7, 11]}, {'id': 7, 'elements': [1, 2, 3, 5, 6, 8, 11, 18]}, {'id': 8, 'elements': [2, 3, 4, 9, 13, 14, 15]}, {'id': 9, 'elements': [4, 10, 12, 13, 14]}, {'id': 10, 'elements': [1, 2, 11, 18]}, {'id': 11, 'elements': [10, 12, 14]}, {'id': 12, 'elements': [1, 4, 9, 10, 17]}, {'id': 13, 'elements': [1, 4, 9, 10, 12, 16, 17]}, {'id': 14, 'elements': [3, 5, 9, 13, 15]}, {'id': 15, 'elements': [1, 16]}, {'id': 16, 'elements': [1, 2, 6, 11, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 17, 'v': 13}, {'u': 17, 'v': 15}, {'u': 6, 'v': 8}, {'u': 6, 'v': 18}, {'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 4, 'v': 1}, {'u': 4, 'v': 14}, {'u': 4, 'v': 16}, {'u': 9, 'v': 1}, {'u': 9, 'v': 3}, {'u': 9, 'v': 13}, {'u': 11, 'v': 2}, {'u': 11, 'v': 7}, {'u': 15, 'v': 3}, {'u': 13, 'v': 14}, {'u': 5, 'v': 3}, {'u': 1, 'v': 2}, {'u': 2, 'v': 18}, {'u': 10, 'v': 12}, {'u': 10, 'v': 14}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0046.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0046.png'}","[3, 6, 11, 15]",4.0,"{'num_elements': 18, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [2, 3, 4, 8, 11, 13, 14, 16]}, {'id': 'S2', 'elements': [1, 4, 5, 6, 7, 11, 18]}, {'id': 'S3', 'elements': [3, 9, 13, 15, 17]}, {'id': 'S4', 'elements': [1, 2, 9, 14, 16]}, {'id': 'S5', 'elements': [2, 3, 5, 8, 15]}, {'id': 'S6', 'elements': [2, 7, 11]}, {'id': 'S7', 'elements': [1, 2, 3, 5, 6, 8, 11, 18]}, {'id': 'S8', 'elements': [2, 3, 4, 9, 13, 14, 15]}, {'id': 'S9', 'elements': [4, 10, 12, 13, 14]}, {'id': 'S10', 'elements': [1, 2, 11, 18]}, {'id': 'S11', 'elements': [10, 12, 14]}, {'id': 'S12', 'elements': [1, 4, 9, 10, 17]}, {'id': 'S13', 'elements': [1, 4, 9, 10, 12, 16, 17]}, {'id': 'S14', 'elements': [3, 5, 9, 13, 15]}, {'id': 'S15', 'elements': [1, 16]}, {'id': 'S16', 'elements': [1, 2, 6, 11, 18]}]}","['S3', 'S6', 'S11', 'S15']",47,csv,1
SP,SP,"There’s a local watch coordinator trying to arrange tonight’s patrols by picking from several pre-made groups. The right plan is the one that sends out as many groups as possible — judge each plan by the total number of groups it uses. When a group is picked, all its members go on duty, and no resident can be on two of the selected groups at once. The detailed rosters appear below.

- **total_residents**: 16
- **total_patrol_groups**: 15

| patrol_id | member_ids |
|---|---|
| S1 | 3 6 13 |
| S2 | 2 6 14 15 16 |
| S3 | 6 9 13 14 |
| S4 | 4 9 |
| S5 | 5 7 11 |
| S6 | 1 2 3 4 9 13 14 16 |
| S7 | 8 10 12 15 16 |
| S8 | 3 6 8 10 16 |
| S9 | 9 10 12 16 |
| S10 | 5 13 14 |
| S11 | 8 10 12 |
| S12 | 1 3 5 6 13 14 |
| S13 | 2 3 6 14 15 |
| S14 | 2 4 6 10 12 14 15 16 |
| S15 | 5 6 8 9 10 11 13 14 15 16 |

If you want to tell me which groups to send, just return a little JSON object in this shape — nothing fancy. For this patrol story I’d use a tiny placeholder like this:

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

This means: put the identifiers of the selected groups in the solution list (one identifier per chosen group). It’s just a sketch of the shape I expect, not the actual answer — fill the list with the exact group labels from the instance.

Please make sure to use the identifiers exactly as they appear in the 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': 16, 'num_sets': 15, 'density': 0.30833333333333335, 'sets': [{'id': 1, 'elements': [3, 6, 13]}, {'id': 2, 'elements': [2, 6, 14, 15, 16]}, {'id': 3, 'elements': [6, 9, 13, 14]}, {'id': 4, 'elements': [4, 9]}, {'id': 5, 'elements': [5, 7, 11]}, {'id': 6, 'elements': [1, 2, 3, 4, 9, 13, 14, 16]}, {'id': 7, 'elements': [8, 10, 12, 15, 16]}, {'id': 8, 'elements': [3, 6, 8, 10, 16]}, {'id': 9, 'elements': [9, 10, 12, 16]}, {'id': 10, 'elements': [5, 13, 14]}, {'id': 11, 'elements': [8, 10, 12]}, {'id': 12, 'elements': [1, 3, 5, 6, 13, 14]}, {'id': 13, 'elements': [2, 3, 6, 14, 15]}, {'id': 14, 'elements': [2, 4, 6, 10, 12, 14, 15, 16]}, {'id': 15, 'elements': [5, 6, 8, 9, 10, 11, 13, 14, 15, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 3, 'v': 1}, {'u': 3, 'v': 6}, {'u': 3, 'v': 13}, {'u': 11, 'v': 14}, {'u': 6, 'v': 9}, {'u': 6, 'v': 16}, {'u': 15, 'v': 8}, {'u': 15, 'v': 9}, {'u': 15, 'v': 10}, {'u': 15, 'v': 16}, {'u': 9, 'v': 4}, {'u': 7, 'v': 5}, {'u': 10, 'v': 8}, {'u': 10, 'v': 12}, {'u': 5, 'v': 14}, {'u': 14, 'v': 13}, {'u': 14, 'v': 16}, {'u': 16, 'v': 2}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0047.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0047.png'}","[4, 5, 11, 13]",4.0,"{'num_elements': 16, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [3, 6, 13]}, {'id': 'S2', 'elements': [2, 6, 14, 15, 16]}, {'id': 'S3', 'elements': [6, 9, 13, 14]}, {'id': 'S4', 'elements': [4, 9]}, {'id': 'S5', 'elements': [5, 7, 11]}, {'id': 'S6', 'elements': [1, 2, 3, 4, 9, 13, 14, 16]}, {'id': 'S7', 'elements': [8, 10, 12, 15, 16]}, {'id': 'S8', 'elements': [3, 6, 8, 10, 16]}, {'id': 'S9', 'elements': [9, 10, 12, 16]}, {'id': 'S10', 'elements': [5, 13, 14]}, {'id': 'S11', 'elements': [8, 10, 12]}, {'id': 'S12', 'elements': [1, 3, 5, 6, 13, 14]}, {'id': 'S13', 'elements': [2, 3, 6, 14, 15]}, {'id': 'S14', 'elements': [2, 4, 6, 10, 12, 14, 15, 16]}, {'id': 'S15', 'elements': [5, 6, 8, 9, 10, 11, 13, 14, 15, 16]}]}","['S4', 'S5', 'S11', 'S13']",48,markdown_table,1
SP,SP,"Someone organizing the reception wanted the appetizer table to look abundant, so they tried to include as many platters as they could, but with one condition: each ingredient can only appear on one of the platters that actually make the cut. The practical decision is which platters to pick to get the biggest number of platters onto the table, countable by simply tallying the selected platters, and the full list of platter options and their ingredients appears below.

{
  ""total_ingredients_count"": 17,
  ""total_platters_count"": 16,
  ""sets"": [
    {
      ""platter_id"": ""S1"",
      ""platter_ingredients"": [
        1,
        2,
        8,
        12
      ]
    },
    {
      ""platter_id"": ""S2"",
      ""platter_ingredients"": [
        0,
        1,
        2,
        9,
        12
      ]
    },
    {
      ""platter_id"": ""S3"",
      ""platter_ingredients"": [
        0,
        1,
        2,
        3,
        8,
        10
      ]
    },
    {
      ""platter_id"": ""S4"",
      ""platter_ingredients"": [
        2,
        3,
        4,
        9,
        14,
        16
      ]
    },
    {
      ""platter_id"": ""S5"",
      ""platter_ingredients"": [
        2,
        4,
        5,
        6,
        9,
        10
      ]
    },
    {
      ""platter_id"": ""S6"",
      ""platter_ingredients"": [
        5,
        6,
        10,
        11,
        12
      ]
    },
    {
      ""platter_id"": ""S7"",
      ""platter_ingredients"": [
        4,
        6,
        7,
        10,
        14,
        16
      ]
    },
    {
      ""platter_id"": ""S8"",
      ""platter_ingredients"": [
        6,
        7,
        10,
        14
      ]
    },
    {
      ""platter_id"": ""S9"",
      ""platter_ingredients"": [
        0,
        2,
        4,
        10,
        12,
        16
      ]
    },
    {
      ""platter_id"": ""S10"",
      ""platter_ingredients"": [
        2,
        4,
        6,
        7,
        9,
        10,
        11,
        15
      ]
    },
    {
      ""platter_id"": ""S11"",
      ""platter_ingredients"": [
        5,
        11,
        12,
        13,
        15
      ]
    },
    {
      ""platter_id"": ""S12"",
      ""platter_ingredients"": [
        0,
        1,
        2,
        4,
        5,
        6,
        9,
        10,
        11
      ]
    },
    {
      ""platter_id"": ""S13"",
      ""platter_ingredients"": [
        5,
        11,
        13
      ]
    },
    {
      ""platter_id"": ""S14"",
      ""platter_ingredients"": [
        3,
        14,
        16
      ]
    },
    {
      ""platter_id"": ""S15"",
      ""platter_ingredients"": [
        5,
        11
      ]
    },
    {
      ""platter_id"": ""S16"",
      ""platter_ingredients"": [
        3,
        9,
        14,
        16
      ]
    }
  ]
}

If you want to tell me which platters to use, just send them back in a tiny JSON snippet like this:

{
  ""solution"": [""platter_id""]
}

The ""solution"" array is where you list the platters you pick — one entry per platter, using the exact platter identifiers from the instance. Think of this JSON as just a simple form: it shows the shape I expect, not the actual final list (so replace ""platter_id"" with the real ids and add as many as needed).

Please don't rename or invent identifiers — use them exactly as they appear in the input.  
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': 17, 'num_sets': 16, 'density': 0.3014705882352941, 'sets': [{'id': 1, 'elements': [2, 3, 9, 13]}, {'id': 2, 'elements': [1, 2, 3, 10, 13]}, {'id': 3, 'elements': [1, 2, 3, 4, 9, 11]}, {'id': 4, 'elements': [3, 4, 5, 10, 15, 17]}, {'id': 5, 'elements': [3, 5, 6, 7, 10, 11]}, {'id': 6, 'elements': [6, 7, 11, 12, 13]}, {'id': 7, 'elements': [5, 7, 8, 11, 15, 17]}, {'id': 8, 'elements': [7, 8, 11, 15]}, {'id': 9, 'elements': [1, 3, 5, 11, 13, 17]}, {'id': 10, 'elements': [3, 5, 7, 8, 10, 11, 12, 16]}, {'id': 11, 'elements': [6, 12, 13, 14, 16]}, {'id': 12, 'elements': [1, 2, 3, 5, 6, 7, 10, 11, 12]}, {'id': 13, 'elements': [6, 12, 14]}, {'id': 14, 'elements': [4, 15, 17]}, {'id': 15, 'elements': [6, 12]}, {'id': 16, 'elements': [4, 10, 15, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 10, 'v': 3}, {'u': 10, 'v': 4}, {'u': 10, 'v': 5}, {'u': 3, 'v': 1}, {'u': 3, 'v': 2}, {'u': 3, 'v': 13}, {'u': 14, 'v': 12}, {'u': 11, 'v': 5}, {'u': 11, 'v': 6}, {'u': 11, 'v': 7}, {'u': 11, 'v': 13}, {'u': 7, 'v': 8}, {'u': 7, 'v': 15}, {'u': 8, 'v': 15}, {'u': 16, 'v': 6}, {'u': 1, 'v': 9}, {'u': 17, 'v': 4}, {'u': 17, 'v': 15}, {'u': 12, 'v': 6}, {'u': 12, 'v': 13}]}, 'viz_instance': 'generated_data/SP/viz/SP_M/instance_0048.png', 'viz_solution': 'generated_data/SP/viz/SP_M/solution_0048.png'}","[2, 14, 15]",3.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [1, 2, 8, 12]}, {'id': 'S2', 'elements': [0, 1, 2, 9, 12]}, {'id': 'S3', 'elements': [0, 1, 2, 3, 8, 10]}, {'id': 'S4', 'elements': [2, 3, 4, 9, 14, 16]}, {'id': 'S5', 'elements': [2, 4, 5, 6, 9, 10]}, {'id': 'S6', 'elements': [5, 6, 10, 11, 12]}, {'id': 'S7', 'elements': [4, 6, 7, 10, 14, 16]}, {'id': 'S8', 'elements': [6, 7, 10, 14]}, {'id': 'S9', 'elements': [0, 2, 4, 10, 12, 16]}, {'id': 'S10', 'elements': [2, 4, 6, 7, 9, 10, 11, 15]}, {'id': 'S11', 'elements': [5, 11, 12, 13, 15]}, {'id': 'S12', 'elements': [0, 1, 2, 4, 5, 6, 9, 10, 11]}, {'id': 'S13', 'elements': [5, 11, 13]}, {'id': 'S14', 'elements': [3, 14, 16]}, {'id': 'S15', 'elements': [5, 11]}, {'id': 'S16', 'elements': [3, 9, 14, 16]}]}","['S2', 'S14', 'S15']",49,json,0
SP,SP,"Recently the counselor had to trim the list of after-school activities: every club has a roster and the counselor wants to keep as many clubs running as possible, but if a student is listed in more than one kept club, that plan won’t work. The way to compare different plans is straightforward: tally the number of clubs that would run under each plan — the larger the tally, the better — and the concrete club lists and student assignments are given below.

There are 12 available clubs and 13 distinct students; the club rosters are listed next.
Club S1: A D I
Club S2: B F I
Club S3: A D J L
Club S4: A C I L
Club S5: E H I J
Club S6: A B G I M
Club S7: B F G I M
Club S8: H J
Club S9: A B C I K L M
Club S10: A C E H I J
Club S11: C I K L
Club S12: C D K L
Compare plans by tallying how many clubs can run without any student appearing in more than one chosen club.

If you want to hand me a proposed plan, just drop it in a tiny JSON snippet like this so it's easy to read:

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

Here ""solution"" is the list of clubs you'd like to keep running — each item is the club's identifier. This is just a sketch of the shape I expect, not the actual answer.

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