MkC/MkC_M_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
MkC,MkC,"I run the neighborhood community center and have to pick a handful of weekly classes to put on the schedule. Each class attracts different groups of neighbors and some people would show up to more than one thing, so the trick is to choose the few classes that together bring in the biggest number of different residents. The way to judge a lineup is simple: for whatever set of classes is chosen, count how many unique people would be reached (don’t double-count someone who could attend two classes), and make sure not to offer more classes than the allowed number. The exact class options and who they reach are laid out below.

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

Also, when you send me your chosen lineup, it's easiest if you put it in a tiny JSON snippet like this so I can read it quickly:

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

This just means ""solution"" is a list of the classes you want to offer — each item is the identifier for one class from the instance. The ""class_id"" entry is a placeholder showing the shape; swap that out for the actual IDs from the instance. The JSON above is only a sketch of the expected shape, not the final answer itself.

Please use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 17, 'density': 0.32679738562091504, 'sets': [{'id': 1, 'elements': [2, 3, 11, 12, 13]}, {'id': 2, 'elements': [1, 3, 4, 5, 6, 11, 12, 13, 14]}, {'id': 3, 'elements': [1, 2, 3, 6, 10, 13, 14, 17]}, {'id': 4, 'elements': [2, 4, 5, 8, 12]}, {'id': 5, 'elements': [2, 3, 4, 7, 8, 13, 18]}, {'id': 6, 'elements': [4, 7, 8, 9, 14, 18]}, {'id': 7, 'elements': [2, 4, 6, 7, 16, 17, 18]}, {'id': 8, 'elements': [7, 9]}, {'id': 9, 'elements': [3, 6, 10, 11, 12, 15]}, {'id': 10, 'elements': [2, 3]}, {'id': 11, 'elements': [2, 4, 6, 8, 10, 12, 15, 16, 17]}, {'id': 12, 'elements': [1, 3, 6, 13, 14]}, {'id': 13, 'elements': [2, 3, 5, 6, 7, 9, 13, 14]}, {'id': 14, 'elements': [10, 12, 15, 17]}, {'id': 15, 'elements': [8, 16, 17]}, {'id': 16, 'elements': [3, 6, 7, 8, 10, 12, 16, 17, 18]}, {'id': 17, 'elements': [6, 8, 16, 17, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 18, 'v': 8}, {'u': 18, 'v': 16}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 15}, {'u': 11, 'v': 3}, {'u': 1, 'v': 3}, {'u': 1, 'v': 13}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 9}, {'u': 4, 'v': 14}, {'u': 5, 'v': 14}, {'u': 6, 'v': 2}, {'u': 6, 'v': 8}, {'u': 6, 'v': 12}, {'u': 12, 'v': 3}, {'u': 12, 'v': 17}, {'u': 13, 'v': 2}, {'u': 15, 'v': 17}, {'u': 14, 'v': 2}, {'u': 16, 'v': 17}, {'u': 17, 'v': 8}, {'u': 2, 'v': 3}, {'u': 7, 'v': 8}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0000.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0000.png'}","[2, 6, 11]",18.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [2, 3, 11, 12, 13]}, {'id': 'S2', 'elements': [1, 3, 4, 5, 6, 11, 12, 13, 14]}, {'id': 'S3', 'elements': [1, 2, 3, 6, 10, 13, 14, 17]}, {'id': 'S4', 'elements': [2, 4, 5, 8, 12]}, {'id': 'S5', 'elements': [2, 3, 4, 7, 8, 13, 18]}, {'id': 'S6', 'elements': [4, 7, 8, 9, 14, 18]}, {'id': 'S7', 'elements': [2, 4, 6, 7, 16, 17, 18]}, {'id': 'S8', 'elements': [7, 9]}, {'id': 'S9', 'elements': [3, 6, 10, 11, 12, 15]}, {'id': 'S10', 'elements': [2, 3]}, {'id': 'S11', 'elements': [2, 4, 6, 8, 10, 12, 15, 16, 17]}, {'id': 'S12', 'elements': [1, 3, 6, 13, 14]}, {'id': 'S13', 'elements': [2, 3, 5, 6, 7, 9, 13, 14]}, {'id': 'S14', 'elements': [10, 12, 15, 17]}, {'id': 'S15', 'elements': [8, 16, 17]}, {'id': 'S16', 'elements': [3, 6, 7, 8, 10, 12, 16, 17, 18]}, {'id': 'S17', 'elements': [6, 8, 16, 17, 18]}], 'budget_k': 3}","['S2', 'S6', 'S11']",1,json,1
MkC,MkC,"Someone in the school asked the librarian to pick, say, five clubs to host, and the challenge is to make sure as many different kids as possible end up in at least one of those five. The way to check a pick is to combine the membership lists of the chosen clubs and count each student only once — that number is the score for the selection. The rules are straightforward: only the allowed number of clubs can be selected, a club is either picked or not, and overlapping students don’t get counted multiple times. The actual club options and who would join are listed below.

{
  ""total_students"": 13,
  ""total_clubs_available"": 13,
  ""sets"": [
    {
      ""club_id"": ""S1"",
      ""club_members"": [
        ""A"",
        ""B"",
        ""C""
      ]
    },
    {
      ""club_id"": ""S2"",
      ""club_members"": [
        ""A"",
        ""B"",
        ""C"",
        ""I""
      ]
    },
    {
      ""club_id"": ""S3"",
      ""club_members"": [
        ""B"",
        ""C"",
        ""F"",
        ""I"",
        ""M""
      ]
    },
    {
      ""club_id"": ""S4"",
      ""club_members"": [
        ""D"",
        ""E"",
        ""J"",
        ""L""
      ]
    },
    {
      ""club_id"": ""S5"",
      ""club_members"": [
        ""D"",
        ""E"",
        ""J""
      ]
    },
    {
      ""club_id"": ""S6"",
      ""club_members"": [
        ""C"",
        ""F"",
        ""M""
      ]
    },
    {
      ""club_id"": ""S7"",
      ""club_members"": [
        ""D"",
        ""F"",
        ""G"",
        ""I"",
        ""L""
      ]
    },
    {
      ""club_id"": ""S8"",
      ""club_members"": [
        ""H"",
        ""I"",
        ""M""
      ]
    },
    {
      ""club_id"": ""S9"",
      ""club_members"": [
        ""C"",
        ""G"",
        ""I"",
        ""M""
      ]
    },
    {
      ""club_id"": ""S10"",
      ""club_members"": [
        ""D"",
        ""J"",
        ""K""
      ]
    },
    {
      ""club_id"": ""S11"",
      ""club_members"": [
        ""D"",
        ""E"",
        ""G"",
        ""J"",
        ""K"",
        ""L""
      ]
    },
    {
      ""club_id"": ""S12"",
      ""club_members"": [
        ""D"",
        ""E"",
        ""G"",
        ""J"",
        ""L""
      ]
    },
    {
      ""club_id"": ""S13"",
      ""club_members"": [
        ""C"",
        ""F"",
        ""H"",
        ""I""
      ]
    }
  ],
  ""clubs_to_host"": 2
}

Oh, and when you tell me which clubs you picked, please send it in a tiny JSON shape so it's easy to read and check. Something like this:

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

Here ""solution"" is just the list of the clubs you've chosen (one entry per club). I used ""club_id"" as a placeholder to match the story — you'll replace those placeholders with the actual club identifiers from the instance. This block is only a sketch of the expected shape, not the final answer itself.

Please make sure to use the exact identifiers shown 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': 13, 'num_sets': 13, 'density': 0.3076923076923077, 'sets': [{'id': 1, 'elements': [1, 2, 3]}, {'id': 2, 'elements': [1, 2, 3, 9]}, {'id': 3, 'elements': [2, 3, 6, 9, 13]}, {'id': 4, 'elements': [4, 5, 10, 12]}, {'id': 5, 'elements': [4, 5, 10]}, {'id': 6, 'elements': [3, 6, 13]}, {'id': 7, 'elements': [4, 6, 7, 9, 12]}, {'id': 8, 'elements': [8, 9, 13]}, {'id': 9, 'elements': [3, 7, 9, 13]}, {'id': 10, 'elements': [4, 10, 11]}, {'id': 11, 'elements': [4, 5, 7, 10, 11, 12]}, {'id': 12, 'elements': [4, 5, 7, 10, 12]}, {'id': 13, 'elements': [3, 6, 8, 9]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 4, 'v': 10}, {'u': 4, 'v': 12}, {'u': 6, 'v': 7}, {'u': 6, 'v': 9}, {'u': 5, 'v': 10}, {'u': 5, 'v': 11}, {'u': 9, 'v': 3}, {'u': 9, 'v': 13}, {'u': 11, 'v': 12}, {'u': 8, 'v': 13}, {'u': 3, 'v': 2}, {'u': 1, 'v': 2}, {'u': 12, 'v': 7}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0001.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0001.png'}","[3, 11]",11.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'C']}, {'id': 'S2', 'elements': ['A', 'B', 'C', 'I']}, {'id': 'S3', 'elements': ['B', 'C', 'F', 'I', 'M']}, {'id': 'S4', 'elements': ['D', 'E', 'J', 'L']}, {'id': 'S5', 'elements': ['D', 'E', 'J']}, {'id': 'S6', 'elements': ['C', 'F', 'M']}, {'id': 'S7', 'elements': ['D', 'F', 'G', 'I', 'L']}, {'id': 'S8', 'elements': ['H', 'I', 'M']}, {'id': 'S9', 'elements': ['C', 'G', 'I', 'M']}, {'id': 'S10', 'elements': ['D', 'J', 'K']}, {'id': 'S11', 'elements': ['D', 'E', 'G', 'J', 'K', 'L']}, {'id': 'S12', 'elements': ['D', 'E', 'G', 'J', 'L']}, {'id': 'S13', 'elements': ['C', 'F', 'H', 'I']}], 'budget_k': 2}","['S3', 'S11']",2,json,names
MkC,MkC,"Many people in the area could benefit from pop-up vaccinations, but resources only allow running a fixed number of clinics, so the coordinator has to choose which ones to hold. The measure of a good choice is straightforward: gather all the households that would be reached by the chosen clinics, count each household once even if multiple clinics could reach it, and aim for the biggest possible unique-household total. Nothing outside the chosen set counts, and the total number of clinics can’t be exceeded. The specifics of locations and the cap are listed below.

{
  ""total_households"": 13,
  ""available_popups_count"": 12,
  ""sets"": [
    {
      ""popup_id"": ""S1"",
      ""covered_households"": [
        4,
        9,
        11
      ]
    },
    {
      ""popup_id"": ""S2"",
      ""covered_households"": [
        1,
        2,
        9,
        10
      ]
    },
    {
      ""popup_id"": ""S3"",
      ""covered_households"": [
        1,
        2,
        3,
        4,
        8,
        9
      ]
    },
    {
      ""popup_id"": ""S4"",
      ""covered_households"": [
        2,
        3,
        8,
        9
      ]
    },
    {
      ""popup_id"": ""S5"",
      ""covered_households"": [
        0,
        2,
        4,
        6,
        9,
        11
      ]
    },
    {
      ""popup_id"": ""S6"",
      ""covered_households"": [
        4,
        5,
        11,
        12
      ]
    },
    {
      ""popup_id"": ""S7"",
      ""covered_households"": [
        4,
        6,
        7
      ]
    },
    {
      ""popup_id"": ""S8"",
      ""covered_households"": [
        5,
        6,
        7,
        11,
        12
      ]
    },
    {
      ""popup_id"": ""S9"",
      ""covered_households"": [
        2,
        3,
        9
      ]
    },
    {
      ""popup_id"": ""S10"",
      ""covered_households"": [
        1,
        2,
        3,
        4,
        9,
        10
      ]
    },
    {
      ""popup_id"": ""S11"",
      ""covered_households"": [
        0,
        4,
        5,
        6,
        7,
        9,
        12
      ]
    },
    {
      ""popup_id"": ""S12"",
      ""covered_households"": [
        5,
        7,
        11
      ]
    }
  ],
  ""max_popups_to_schedule"": 2
}

Also, when you reply, please use this simple JSON layout so it's easy to parse:

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

Here ""solution"" is just the list of clinics you choose to run — each entry is the identifier for a clinic (keep them as they appear in the instance). This is just a sketch of the shape I need, not the actual answer itself.

Please make sure to use the exact identifiers from 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': 13, 'num_sets': 12, 'density': 0.34615384615384615, 'sets': [{'id': 1, 'elements': [5, 10, 12]}, {'id': 2, 'elements': [2, 3, 10, 11]}, {'id': 3, 'elements': [2, 3, 4, 5, 9, 10]}, {'id': 4, 'elements': [3, 4, 9, 10]}, {'id': 5, 'elements': [1, 3, 5, 7, 10, 12]}, {'id': 6, 'elements': [5, 6, 12, 13]}, {'id': 7, 'elements': [5, 7, 8]}, {'id': 8, 'elements': [6, 7, 8, 12, 13]}, {'id': 9, 'elements': [3, 4, 10]}, {'id': 10, 'elements': [2, 3, 4, 5, 10, 11]}, {'id': 11, 'elements': [1, 5, 6, 7, 8, 10, 13]}, {'id': 12, 'elements': [6, 8, 12]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 6, 'v': 8}, {'u': 6, 'v': 12}, {'u': 6, 'v': 13}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 5}, {'u': 11, 'v': 2}, {'u': 12, 'v': 5}, {'u': 12, 'v': 7}, {'u': 3, 'v': 4}, {'u': 3, 'v': 9}, {'u': 5, 'v': 1}, {'u': 7, 'v': 8}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0002.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0002.png'}","[10, 11]",11.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [4, 9, 11]}, {'id': 'S2', 'elements': [1, 2, 9, 10]}, {'id': 'S3', 'elements': [1, 2, 3, 4, 8, 9]}, {'id': 'S4', 'elements': [2, 3, 8, 9]}, {'id': 'S5', 'elements': [0, 2, 4, 6, 9, 11]}, {'id': 'S6', 'elements': [4, 5, 11, 12]}, {'id': 'S7', 'elements': [4, 6, 7]}, {'id': 'S8', 'elements': [5, 6, 7, 11, 12]}, {'id': 'S9', 'elements': [2, 3, 9]}, {'id': 'S10', 'elements': [1, 2, 3, 4, 9, 10]}, {'id': 'S11', 'elements': [0, 4, 5, 6, 7, 9, 12]}, {'id': 'S12', 'elements': [5, 7, 11]}], 'budget_k': 2}","['S10', 'S11']",3,json,0
MkC,MkC,"Many people depend on neighborhood food pickups, and the coordinator has to pick a limited number of those pickups so the largest possible number of different families get food. Each potential pickup day brings in a defined group of families; the way to compare options is to count the unique families covered when the chosen days are combined, with repeats counting only once. There’s a hard cap on how many days can be selected, so choices must respect that limit. The full list of candidate pickups and their family lists is below.

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

Also, just to keep things tidy, please give your final choice in this simple JSON layout so it’s easy to read and process:

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

Think of ""solution"" as a list of the pickup IDs you want to run — just put each pickup’s identifier in that array. That JSON is only a sketch of the shape I expect, not the actual answer itself. Be 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': 18, 'num_sets': 18, 'density': 0.25925925925925924, 'sets': [{'id': 1, 'elements': [1, 2, 3, 4, 5, 6, 14, 17]}, {'id': 2, 'elements': [1, 18]}, {'id': 3, 'elements': [3, 5, 6, 8, 11, 14, 17]}, {'id': 4, 'elements': [2, 3, 4, 17, 18]}, {'id': 5, 'elements': [3, 6, 13, 15, 16]}, {'id': 6, 'elements': [3, 6, 14]}, {'id': 7, 'elements': [3, 7, 8, 9, 14]}, {'id': 8, 'elements': [5, 7, 8, 10, 11, 14]}, {'id': 9, 'elements': [9, 14]}, {'id': 10, 'elements': [8, 10, 11]}, {'id': 11, 'elements': [3, 5, 8, 10, 11, 12, 13, 14]}, {'id': 12, 'elements': [5, 11, 12, 13, 15, 16]}, {'id': 13, 'elements': [5, 8, 11, 13, 16]}, {'id': 14, 'elements': [1, 5, 6, 8, 10, 11, 14]}, {'id': 15, 'elements': [5, 12, 15, 16]}, {'id': 16, 'elements': [11, 12, 15]}, {'id': 17, 'elements': [1, 3, 4]}, {'id': 18, 'elements': [2, 4]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 12, 'v': 5}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 14}, {'u': 14, 'v': 3}, {'u': 14, 'v': 7}, {'u': 3, 'v': 1}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 1, 'v': 4}, {'u': 1, 'v': 17}, {'u': 5, 'v': 11}, {'u': 16, 'v': 13}, {'u': 18, 'v': 2}, {'u': 11, 'v': 13}, {'u': 7, 'v': 9}, {'u': 4, 'v': 2}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0003.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0003.png'}","[1, 7, 12]",16.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [0, 1, 2, 3, 4, 5, 13, 16]}, {'id': 'S2', 'elements': [0, 17]}, {'id': 'S3', 'elements': [2, 4, 5, 7, 10, 13, 16]}, {'id': 'S4', 'elements': [1, 2, 3, 16, 17]}, {'id': 'S5', 'elements': [2, 5, 12, 14, 15]}, {'id': 'S6', 'elements': [2, 5, 13]}, {'id': 'S7', 'elements': [2, 6, 7, 8, 13]}, {'id': 'S8', 'elements': [4, 6, 7, 9, 10, 13]}, {'id': 'S9', 'elements': [8, 13]}, {'id': 'S10', 'elements': [7, 9, 10]}, {'id': 'S11', 'elements': [2, 4, 7, 9, 10, 11, 12, 13]}, {'id': 'S12', 'elements': [4, 10, 11, 12, 14, 15]}, {'id': 'S13', 'elements': [4, 7, 10, 12, 15]}, {'id': 'S14', 'elements': [0, 4, 5, 7, 9, 10, 13]}, {'id': 'S15', 'elements': [4, 11, 14, 15]}, {'id': 'S16', 'elements': [10, 11, 14]}, {'id': 'S17', 'elements': [0, 2, 3]}, {'id': 'S18', 'elements': [1, 3]}], 'budget_k': 3}","['S1', 'S7', 'S12']",4,json,0
MkC,MkC,"Someone on the growth team has to pick just a handful of audience groups for an email push and wants to avoid wasting sends on the same people. The decision is all about which groups to pick so the total reach — measured by the number of distinct customers touched when you combine the chosen lists and ignore duplicates — is biggest. Since there’s a strict cap on how many groups can be chosen, the goal is to cover as many new people as possible with each pick. The concrete segment lists and counts are shown below.

{
  ""total_customers_in_universe"": 14,
  ""total_segments_available"": 12,
  ""sets"": [
    {
      ""segment_id"": ""S1"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""D"",
        ""F"",
        ""G"",
        ""I"",
        ""M""
      ]
    },
    {
      ""segment_id"": ""S2"",
      ""customer_ids_in_segment"": [
        ""B"",
        ""D"",
        ""I""
      ]
    },
    {
      ""segment_id"": ""S3"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""C"",
        ""D"",
        ""I""
      ]
    },
    {
      ""segment_id"": ""S4"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""B"",
        ""C"",
        ""I""
      ]
    },
    {
      ""segment_id"": ""S5"",
      ""customer_ids_in_segment"": [
        ""E"",
        ""F"",
        ""K"",
        ""L""
      ]
    },
    {
      ""segment_id"": ""S6"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""E"",
        ""F"",
        ""I"",
        ""K"",
        ""M"",
        ""N""
      ]
    },
    {
      ""segment_id"": ""S7"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""H"",
        ""M""
      ]
    },
    {
      ""segment_id"": ""S8"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""C""
      ]
    },
    {
      ""segment_id"": ""S9"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""E"",
        ""F"",
        ""K"",
        ""L"",
        ""N""
      ]
    },
    {
      ""segment_id"": ""S10"",
      ""customer_ids_in_segment"": [
        ""E"",
        ""J""
      ]
    },
    {
      ""segment_id"": ""S11"",
      ""customer_ids_in_segment"": [
        ""F"",
        ""G"",
        ""H"",
        ""I"",
        ""M""
      ]
    },
    {
      ""segment_id"": ""S12"",
      ""customer_ids_in_segment"": [
        ""A"",
        ""F"",
        ""N""
      ]
    }
  ],
  ""max_segments_to_select"": 2
}

If you want the pick back in a tidy, machine-friendly form, here's the simple JSON shape I'd use for the reply:

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

Pretty much: ""solution"" is the array where I'll list the chosen audience group identifiers. The placeholder ""segment_id"" just stands in for whatever actual IDs appear in the instance — it's a sketch, not the actual selection.

Quick note: when I fill this in for real, I will use the exact identifiers from the 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""
- a capital letter followed by digits like ""A1"" or ""X7""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 12, 'density': 0.2916666666666667, 'sets': [{'id': 1, 'elements': [1, 4, 6, 7, 9, 13]}, {'id': 2, 'elements': [2, 4, 9]}, {'id': 3, 'elements': [1, 3, 4, 9]}, {'id': 4, 'elements': [1, 2, 3, 9]}, {'id': 5, 'elements': [5, 6, 11, 12]}, {'id': 6, 'elements': [1, 5, 6, 9, 11, 13, 14]}, {'id': 7, 'elements': [1, 8, 13]}, {'id': 8, 'elements': [1, 3]}, {'id': 9, 'elements': [1, 5, 6, 11, 12, 14]}, {'id': 10, 'elements': [5, 10]}, {'id': 11, 'elements': [6, 7, 8, 9, 13]}, {'id': 12, 'elements': [1, 6, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 9, 'v': 1}, {'u': 9, 'v': 3}, {'u': 9, 'v': 4}, {'u': 8, 'v': 7}, {'u': 6, 'v': 1}, {'u': 6, 'v': 11}, {'u': 6, 'v': 14}, {'u': 11, 'v': 5}, {'u': 12, 'v': 5}, {'u': 12, 'v': 10}, {'u': 4, 'v': 2}, {'u': 13, 'v': 1}, {'u': 13, 'v': 7}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0004.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0004.png'}","[9, 11]",10.0,"{'num_elements': 14, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'F', 'G', 'I', 'M']}, {'id': 'S2', 'elements': ['B', 'D', 'I']}, {'id': 'S3', 'elements': ['A', 'C', 'D', 'I']}, {'id': 'S4', 'elements': ['A', 'B', 'C', 'I']}, {'id': 'S5', 'elements': ['E', 'F', 'K', 'L']}, {'id': 'S6', 'elements': ['A', 'E', 'F', 'I', 'K', 'M', 'N']}, {'id': 'S7', 'elements': ['A', 'H', 'M']}, {'id': 'S8', 'elements': ['A', 'C']}, {'id': 'S9', 'elements': ['A', 'E', 'F', 'K', 'L', 'N']}, {'id': 'S10', 'elements': ['E', 'J']}, {'id': 'S11', 'elements': ['F', 'G', 'H', 'I', 'M']}, {'id': 'S12', 'elements': ['A', 'F', 'N']}], 'budget_k': 2}","['S9', 'S11']",5,json,names
MkC,MkC,"We have a limited slate to fill this year: the curator can only greenlight a handful of exhibition themes. The job is to pick which few to go ahead with so that, when counting every unique visitor who’d attend at least one of the chosen shows, that headcount is maximized — overlaps between shows shouldn’t be double-counted. A better choice is simply the one that brings in the most different people overall, given the cap on how many themes we can run. The concrete theme options and their expected audiences are listed below.

# total_potential_visitors=14
# total_themes_available=14
# selection_cap=2
theme_id,expected_visitor_ids
S1,A M
S2,A B C L
S3,A C H L M
S4,F G M
S5,C H N
S6,D F H I J M
S7,G K
S8,C E F H L N
S9,B F I K N
S10,F H J N
S11,G I K
S12,B C L
S13,A B D F I M
S14,C E F I N

Also, when you send back which themes to greenlight, a neat little JSON like this is perfect:

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

Think of ""solution"" as just the list of theme IDs you're choosing — replace ""theme_id"" and the ""..."" with the actual IDs from the instance. This is just a sketch of the shape I need, not the final picks themselves.

Please use the exact identifiers shown 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': 14, 'density': 0.29081632653061223, 'sets': [{'id': 1, 'elements': [1, 13]}, {'id': 2, 'elements': [1, 2, 3, 12]}, {'id': 3, 'elements': [1, 3, 8, 12, 13]}, {'id': 4, 'elements': [6, 7, 13]}, {'id': 5, 'elements': [3, 8, 14]}, {'id': 6, 'elements': [4, 6, 8, 9, 10, 13]}, {'id': 7, 'elements': [7, 11]}, {'id': 8, 'elements': [3, 5, 6, 8, 12, 14]}, {'id': 9, 'elements': [2, 6, 9, 11, 14]}, {'id': 10, 'elements': [6, 8, 10, 14]}, {'id': 11, 'elements': [7, 9, 11]}, {'id': 12, 'elements': [2, 3, 12]}, {'id': 13, 'elements': [1, 2, 4, 6, 9, 13]}, {'id': 14, 'elements': [3, 5, 6, 9, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 12, 'v': 3}, {'u': 6, 'v': 9}, {'u': 6, 'v': 14}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 13}, {'u': 8, 'v': 3}, {'u': 8, 'v': 5}, {'u': 8, 'v': 14}, {'u': 11, 'v': 4}, {'u': 11, 'v': 7}, {'u': 10, 'v': 14}, {'u': 9, 'v': 4}, {'u': 9, 'v': 13}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0005.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0005.png'}","[8, 13]",11.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'M']}, {'id': 'S2', 'elements': ['A', 'B', 'C', 'L']}, {'id': 'S3', 'elements': ['A', 'C', 'H', 'L', 'M']}, {'id': 'S4', 'elements': ['F', 'G', 'M']}, {'id': 'S5', 'elements': ['C', 'H', 'N']}, {'id': 'S6', 'elements': ['D', 'F', 'H', 'I', 'J', 'M']}, {'id': 'S7', 'elements': ['G', 'K']}, {'id': 'S8', 'elements': ['C', 'E', 'F', 'H', 'L', 'N']}, {'id': 'S9', 'elements': ['B', 'F', 'I', 'K', 'N']}, {'id': 'S10', 'elements': ['F', 'H', 'J', 'N']}, {'id': 'S11', 'elements': ['G', 'I', 'K']}, {'id': 'S12', 'elements': ['B', 'C', 'L']}, {'id': 'S13', 'elements': ['A', 'B', 'D', 'F', 'I', 'M']}, {'id': 'S14', 'elements': ['C', 'E', 'F', 'I', 'N']}], 'budget_k': 2}","['S8', 'S13']",6,csv,names
MkC,MkC,"Many people depend on a traveling bookmobile that can only visit a handful of places in one outing, so the driver has to decide which stops to include to meet the most different readers. The outcome is measured by tallying the unique readers covered by the chosen stops — duplicates don’t increase the total, and the number of stops picked can’t exceed the allowed number. The concrete details about stops and the maximum picks follow below.

{
  ""total_unique_readers"": 14,
  ""total_candidate_stops"": 13,
  ""sets"": [
    {
      ""stop_id"": ""S1"",
      ""stop_reader_ids"": [
        ""A"",
        ""G"",
        ""I""
      ]
    },
    {
      ""stop_id"": ""S2"",
      ""stop_reader_ids"": [
        ""B"",
        ""H"",
        ""L""
      ]
    },
    {
      ""stop_id"": ""S3"",
      ""stop_reader_ids"": [
        ""H"",
        ""K"",
        ""L""
      ]
    },
    {
      ""stop_id"": ""S4"",
      ""stop_reader_ids"": [
        ""D"",
        ""F"",
        ""J"",
        ""K"",
        ""M""
      ]
    },
    {
      ""stop_id"": ""S5"",
      ""stop_reader_ids"": [
        ""E"",
        ""J"",
        ""M"",
        ""N""
      ]
    },
    {
      ""stop_id"": ""S6"",
      ""stop_reader_ids"": [
        ""D"",
        ""M""
      ]
    },
    {
      ""stop_id"": ""S7"",
      ""stop_reader_ids"": [
        ""C"",
        ""G"",
        ""I"",
        ""K"",
        ""M""
      ]
    },
    {
      ""stop_id"": ""S8"",
      ""stop_reader_ids"": [
        ""B"",
        ""C"",
        ""H"",
        ""L""
      ]
    },
    {
      ""stop_id"": ""S9"",
      ""stop_reader_ids"": [
        ""D"",
        ""E"",
        ""M"",
        ""N""
      ]
    },
    {
      ""stop_id"": ""S10"",
      ""stop_reader_ids"": [
        ""A"",
        ""C"",
        ""D"",
        ""G"",
        ""K"",
        ""M""
      ]
    },
    {
      ""stop_id"": ""S11"",
      ""stop_reader_ids"": [
        ""B"",
        ""C"",
        ""K"",
        ""L""
      ]
    },
    {
      ""stop_id"": ""S12"",
      ""stop_reader_ids"": [
        ""C"",
        ""E"",
        ""F"",
        ""G"",
        ""J"",
        ""K"",
        ""M""
      ]
    },
    {
      ""stop_id"": ""S13"",
      ""stop_reader_ids"": [
        ""E"",
        ""J"",
        ""N""
      ]
    }
  ],
  ""max_stops_per_outing"": 2
}

If it helps, you can just send the chosen stops back in a tiny JSON snippet like this:

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

Think of ""solution"" as just a list of the stops the bookmobile will visit — replace each placeholder with the actual stop identifier from the instance input. This JSON is only a sketch of the shape I expect, not the final answer itself.

Please make sure you 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': 14, 'num_sets': 13, 'density': 0.29120879120879123, 'sets': [{'id': 1, 'elements': [1, 7, 9]}, {'id': 2, 'elements': [2, 8, 12]}, {'id': 3, 'elements': [8, 11, 12]}, {'id': 4, 'elements': [4, 6, 10, 11, 13]}, {'id': 5, 'elements': [5, 10, 13, 14]}, {'id': 6, 'elements': [4, 13]}, {'id': 7, 'elements': [3, 7, 9, 11, 13]}, {'id': 8, 'elements': [2, 3, 8, 12]}, {'id': 9, 'elements': [4, 5, 13, 14]}, {'id': 10, 'elements': [1, 3, 4, 7, 11, 13]}, {'id': 11, 'elements': [2, 3, 11, 12]}, {'id': 12, 'elements': [3, 5, 6, 7, 10, 11, 13]}, {'id': 13, 'elements': [5, 10, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 11, 'v': 3}, {'u': 11, 'v': 7}, {'u': 11, 'v': 13}, {'u': 4, 'v': 6}, {'u': 4, 'v': 13}, {'u': 7, 'v': 1}, {'u': 8, 'v': 12}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 14, 'v': 5}, {'u': 13, 'v': 10}, {'u': 1, 'v': 9}, {'u': 5, 'v': 10}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0006.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0006.png'}","[8, 12]",10.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': ['A', 'G', 'I']}, {'id': 'S2', 'elements': ['B', 'H', 'L']}, {'id': 'S3', 'elements': ['H', 'K', 'L']}, {'id': 'S4', 'elements': ['D', 'F', 'J', 'K', 'M']}, {'id': 'S5', 'elements': ['E', 'J', 'M', 'N']}, {'id': 'S6', 'elements': ['D', 'M']}, {'id': 'S7', 'elements': ['C', 'G', 'I', 'K', 'M']}, {'id': 'S8', 'elements': ['B', 'C', 'H', 'L']}, {'id': 'S9', 'elements': ['D', 'E', 'M', 'N']}, {'id': 'S10', 'elements': ['A', 'C', 'D', 'G', 'K', 'M']}, {'id': 'S11', 'elements': ['B', 'C', 'K', 'L']}, {'id': 'S12', 'elements': ['C', 'E', 'F', 'G', 'J', 'K', 'M']}, {'id': 'S13', 'elements': ['E', 'J', 'N']}], 'budget_k': 2}","['S8', 'S12']",7,json,names
MkC,MkC,"We run a small events team with limited sponsorship slots, so we have to choose a handful of community fairs to support. The goal is simple: pick those fairs so the total number of different people exposed to the organizer’s activities is as big as possible. Practically that means listing who comes to each fair, combining the lists for the chosen fairs, and counting unique names — if the same person visits multiple fairs they only count one time. The team can’t exceed the sponsorship limit and can’t duplicate the same fair, and the specific fair line-up and attendance info follow below.

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

When you’re ready to send back your pick, just give it in a tiny JSON snippet like this so it’s easy to parse:

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

Here ""solution"" is the list of fairs we’ll sponsor, and each entry in the array is the identifier for one fair (just plug in the exact IDs from the instance). This is just a sketch of the shape I need — not the actual answer itself.

Please make sure to use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels. 
- for example: ""1"" or ""23"", ""A"" or ""B"", or ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 18, 'density': 0.2993827160493827, 'sets': [{'id': 1, 'elements': [4, 12, 13, 15]}, {'id': 2, 'elements': [7, 9, 14]}, {'id': 3, 'elements': [11, 14]}, {'id': 4, 'elements': [4, 15, 17]}, {'id': 5, 'elements': [7, 9, 11, 12, 17]}, {'id': 6, 'elements': [1, 6, 9, 12, 13, 15, 16]}, {'id': 7, 'elements': [2, 5, 7, 9, 11, 14]}, {'id': 8, 'elements': [5, 7, 9, 16]}, {'id': 9, 'elements': [7, 8, 9, 12, 13, 14, 15, 18]}, {'id': 10, 'elements': [1, 3, 6, 12, 18]}, {'id': 11, 'elements': [2, 3, 9, 11, 12, 14, 15]}, {'id': 12, 'elements': [3, 5, 6, 9, 11, 12, 14, 15]}, {'id': 13, 'elements': [1, 17]}, {'id': 14, 'elements': [2, 3, 7, 9, 11, 18]}, {'id': 15, 'elements': [1, 4, 5, 6, 10, 11, 13, 15, 16, 17]}, {'id': 16, 'elements': [4, 5, 6, 9, 13, 17]}, {'id': 17, 'elements': [4, 5, 13, 15, 17]}, {'id': 18, 'elements': [3, 6, 10, 12, 14, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 17, 'v': 4}, {'u': 17, 'v': 16}, {'u': 15, 'v': 6}, {'u': 15, 'v': 9}, {'u': 15, 'v': 13}, {'u': 15, 'v': 16}, {'u': 8, 'v': 5}, {'u': 13, 'v': 1}, {'u': 13, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 11}, {'u': 16, 'v': 5}, {'u': 9, 'v': 5}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 18, 'v': 3}, {'u': 18, 'v': 10}, {'u': 18, 'v': 12}, {'u': 2, 'v': 11}, {'u': 6, 'v': 1}, {'u': 6, 'v': 10}, {'u': 6, 'v': 12}, {'u': 14, 'v': 3}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0007.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0007.png'}","[9, 14, 15]",18.0,"{'num_elements': 18, 'num_sets': 18, 'sets': [{'id': 'S1', 'elements': [3, 11, 12, 14]}, {'id': 'S2', 'elements': [6, 8, 13]}, {'id': 'S3', 'elements': [10, 13]}, {'id': 'S4', 'elements': [3, 14, 16]}, {'id': 'S5', 'elements': [6, 8, 10, 11, 16]}, {'id': 'S6', 'elements': [0, 5, 8, 11, 12, 14, 15]}, {'id': 'S7', 'elements': [1, 4, 6, 8, 10, 13]}, {'id': 'S8', 'elements': [4, 6, 8, 15]}, {'id': 'S9', 'elements': [6, 7, 8, 11, 12, 13, 14, 17]}, {'id': 'S10', 'elements': [0, 2, 5, 11, 17]}, {'id': 'S11', 'elements': [1, 2, 8, 10, 11, 13, 14]}, {'id': 'S12', 'elements': [2, 4, 5, 8, 10, 11, 13, 14]}, {'id': 'S13', 'elements': [0, 16]}, {'id': 'S14', 'elements': [1, 2, 6, 8, 10, 17]}, {'id': 'S15', 'elements': [0, 3, 4, 5, 9, 10, 12, 14, 15, 16]}, {'id': 'S16', 'elements': [3, 4, 5, 8, 12, 16]}, {'id': 'S17', 'elements': [3, 4, 12, 14, 16]}, {'id': 'S18', 'elements': [2, 5, 9, 11, 13, 17]}], 'budget_k': 3}","['S9', 'S14', 'S15']",8,csv,0
MkC,MkC,"Recently the team realized there are more cleanup ideas than we can staff, so a leader has to lock in just a few locations. The decision is made by checking, for any group of chosen sites, how many distinct volunteers would be covered if those sites run (if a volunteer would appear at more than one site, they only increase the total once). The better pick is the one with the highest number of different volunteers; the data for each site is right below.

# total_unique_volunteers=13
# total_cleanup_sites_available=11
# max_sites_to_commit=2
site_id,site_volunteer_ids
S1,1 2 5 10 11 12 13
S2,2 3 6 8 13
S3,4 5 9 13
S4,3 4 5 8 10 12
S5,6 8
S6,4 7 9 13
S7,3 5 6
S8,1 5 10
S9,2 12
S10,5 10 11
S11,2 3 4 7

If you want to hand me the chosen sites in a tidy way, just use this JSON shape — nothing fancy:

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

Think of it like a tiny form: ""solution"" is the list of sites you decided to run, and each item in the array is the identifier for one selected site. The ""site_id"" above is just a placeholder to show the format — I won't be using that literal value, it's only a sketch of the shape I expect.

Please make sure to use the exact identifiers from the instance input — no renaming and no inventing new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 11, 'density': 0.3006993006993007, 'sets': [{'id': 1, 'elements': [1, 2, 5, 10, 11, 12, 13]}, {'id': 2, 'elements': [2, 3, 6, 8, 13]}, {'id': 3, 'elements': [4, 5, 9, 13]}, {'id': 4, 'elements': [3, 4, 5, 8, 10, 12]}, {'id': 5, 'elements': [6, 8]}, {'id': 6, 'elements': [4, 7, 9, 13]}, {'id': 7, 'elements': [3, 5, 6]}, {'id': 8, 'elements': [1, 5, 10]}, {'id': 9, 'elements': [2, 12]}, {'id': 10, 'elements': [5, 10, 11]}, {'id': 11, 'elements': [2, 3, 4, 7]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 8, 'v': 3}, {'u': 8, 'v': 6}, {'u': 11, 'v': 12}, {'u': 7, 'v': 4}, {'u': 7, 'v': 9}, {'u': 1, 'v': 10}, {'u': 13, 'v': 4}, {'u': 13, 'v': 5}, {'u': 2, 'v': 5}, {'u': 2, 'v': 10}, {'u': 2, 'v': 12}, {'u': 3, 'v': 5}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0008.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0008.png'}","[1, 6]",10.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [1, 2, 5, 10, 11, 12, 13]}, {'id': 'S2', 'elements': [2, 3, 6, 8, 13]}, {'id': 'S3', 'elements': [4, 5, 9, 13]}, {'id': 'S4', 'elements': [3, 4, 5, 8, 10, 12]}, {'id': 'S5', 'elements': [6, 8]}, {'id': 'S6', 'elements': [4, 7, 9, 13]}, {'id': 'S7', 'elements': [3, 5, 6]}, {'id': 'S8', 'elements': [1, 5, 10]}, {'id': 'S9', 'elements': [2, 12]}, {'id': 'S10', 'elements': [5, 10, 11]}, {'id': 'S11', 'elements': [2, 3, 4, 7]}], 'budget_k': 2}","['S1', 'S6']",9,csv,1
MkC,MkC,"Down the street a coffee shop is prepping a few promotional bundles but can only have a set number on the menu. The owner must decide which bundles to run so that the combined selection covers as many different customers as possible. You gauge success by counting distinct customers reached by the chosen bundles (someone who’d buy two different bundles still only counts once), and you cannot go over the bundle cap or offer the same bundle twice. The concrete options and the cap appear below.

- **total_customers**: 18
- **total_bundles_available**: 16
- **bundle_cap**: 3

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

Oh, and when you return your chosen bundles, just drop them into this simple JSON shape so I can read it easily:

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

Think of this like a tiny form: ""solution"" holds a list of the bundles you want on the menu, and each item in that list should be the exact bundle identifier from the instance. The JSON above is only a sketch of the shape I expect — you'll replace the placeholder(s) with the real bundle ids for your final answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
- Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 16, 'density': 0.2326388888888889, 'sets': [{'id': 1, 'elements': [17, 18]}, {'id': 2, 'elements': [2, 4, 5, 7, 11]}, {'id': 3, 'elements': [11, 12]}, {'id': 4, 'elements': [4, 8, 11, 14]}, {'id': 5, 'elements': [2, 5, 7, 11, 15]}, {'id': 6, 'elements': [6, 10, 12, 18]}, {'id': 7, 'elements': [2, 3, 5, 7, 11, 18]}, {'id': 8, 'elements': [16, 18]}, {'id': 9, 'elements': [2, 3, 4, 5, 7, 8, 11, 12, 15]}, {'id': 10, 'elements': [3, 6, 7, 12, 17, 18]}, {'id': 11, 'elements': [5, 13, 15]}, {'id': 12, 'elements': [4, 8, 14]}, {'id': 13, 'elements': [5, 11, 13, 15]}, {'id': 14, 'elements': [6, 18]}, {'id': 15, 'elements': [1, 6, 9, 17, 18]}, {'id': 16, 'elements': [6, 7, 9, 10, 16]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 10, 'v': 6}, {'u': 15, 'v': 5}, {'u': 15, 'v': 13}, {'u': 1, 'v': 17}, {'u': 7, 'v': 3}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 4, 'v': 2}, {'u': 4, 'v': 8}, {'u': 11, 'v': 2}, {'u': 11, 'v': 5}, {'u': 12, 'v': 18}, {'u': 17, 'v': 9}, {'u': 17, 'v': 18}, {'u': 8, 'v': 2}, {'u': 8, 'v': 14}, {'u': 6, 'v': 16}, {'u': 6, 'v': 18}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0009.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0009.png'}","[9, 15, 16]",16.0,"{'num_elements': 18, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['Q', 'R']}, {'id': 'S2', 'elements': ['B', 'D', 'E', 'G', 'K']}, {'id': 'S3', 'elements': ['K', 'L']}, {'id': 'S4', 'elements': ['D', 'H', 'K', 'N']}, {'id': 'S5', 'elements': ['B', 'E', 'G', 'K', 'O']}, {'id': 'S6', 'elements': ['F', 'J', 'L', 'R']}, {'id': 'S7', 'elements': ['B', 'C', 'E', 'G', 'K', 'R']}, {'id': 'S8', 'elements': ['P', 'R']}, {'id': 'S9', 'elements': ['B', 'C', 'D', 'E', 'G', 'H', 'K', 'L', 'O']}, {'id': 'S10', 'elements': ['C', 'F', 'G', 'L', 'Q', 'R']}, {'id': 'S11', 'elements': ['E', 'M', 'O']}, {'id': 'S12', 'elements': ['D', 'H', 'N']}, {'id': 'S13', 'elements': ['E', 'K', 'M', 'O']}, {'id': 'S14', 'elements': ['F', 'R']}, {'id': 'S15', 'elements': ['A', 'F', 'I', 'Q', 'R']}, {'id': 'S16', 'elements': ['F', 'G', 'I', 'J', 'P']}], 'budget_k': 3}","['S9', 'S15', 'S16']",10,markdown_table,names
MkC,MkC,"On a busy morning the city needs to decide which bulletin boards from a pre-set list will carry public notices, but there’s a hard limit on how many boards they can use. What matters is reaching the most different people, so the best set of boards is the one whose combined audience — counted once per person even if they walk past several boards — is largest. The planner can’t choose more spots than allowed and can only pick from the supplied options. The detailed locations and selection limit are shown below.

There are 18 distinct passersby in the planner's universe, 17 candidate bulletin boards listed, and at most 3 boards may be selected.
Board S1 is seen by passersby A F N O P.
Board S2 is seen by passersby B O R.
Board S3 is seen by passersby J O P.
Board S4 is seen by passersby D K L M N.
Board S5 is seen by passersby D E G H K L M.
Board S6 is seen by passersby A F I O P R.
Board S7 is seen by passersby H K.
Board S8 is seen by passersby D E H L.
Board S9 is seen by passersby F Q.
Board S10 is seen by passersby C J P.
Board S11 is seen by passersby A D O.
Board S12 is seen by passersby D E M N.
Board S13 is seen by passersby L M.
Board S14 is seen by passersby D E G H K N.
Board S15 is seen by passersby A B C K O P Q R.
Board S16 is seen by passersby A C F J.
Board S17 is seen by passersby F O Q.
Select no more than 3 boards to cover as many of the 18 distinct passersby as possible.

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

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

""solution"" should be a list of the bulletin-board identifiers you pick (the example shows the placeholder ""board_id"" — replace that with the real IDs). Think of it like filling out a quick form: the array contains the chosen boards, and nothing else. This is just a sketch of the expected shape, not the actual answer you should submit.

Please be careful to use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""1"" or ""23"", ""A"" or ""B"", or ""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, 14, 15, 16]}, {'id': 2, 'elements': [2, 15, 18]}, {'id': 3, 'elements': [10, 15, 16]}, {'id': 4, 'elements': [4, 11, 12, 13, 14]}, {'id': 5, 'elements': [4, 5, 7, 8, 11, 12, 13]}, {'id': 6, 'elements': [1, 6, 9, 15, 16, 18]}, {'id': 7, 'elements': [8, 11]}, {'id': 8, 'elements': [4, 5, 8, 12]}, {'id': 9, 'elements': [6, 17]}, {'id': 10, 'elements': [3, 10, 16]}, {'id': 11, 'elements': [1, 4, 15]}, {'id': 12, 'elements': [4, 5, 13, 14]}, {'id': 13, 'elements': [12, 13]}, {'id': 14, 'elements': [4, 5, 7, 8, 11, 14]}, {'id': 15, 'elements': [1, 2, 3, 11, 15, 16, 17, 18]}, {'id': 16, 'elements': [1, 3, 6, 10]}, {'id': 17, 'elements': [6, 15, 17]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 8, 'v': 5}, {'u': 8, 'v': 7}, {'u': 1, 'v': 11}, {'u': 1, 'v': 15}, {'u': 16, 'v': 3}, {'u': 16, 'v': 10}, {'u': 16, 'v': 15}, {'u': 18, 'v': 2}, {'u': 18, 'v': 15}, {'u': 11, 'v': 4}, {'u': 11, 'v': 14}, {'u': 13, 'v': 4}, {'u': 13, 'v': 12}, {'u': 4, 'v': 5}, {'u': 5, 'v': 12}, {'u': 5, 'v': 14}, {'u': 9, 'v': 17}, {'u': 14, 'v': 7}, {'u': 17, 'v': 6}, {'u': 6, 'v': 15}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0010.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0010.png'}","[5, 15, 16]",16.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': ['A', 'F', 'N', 'O', 'P']}, {'id': 'S2', 'elements': ['B', 'O', 'R']}, {'id': 'S3', 'elements': ['J', 'O', 'P']}, {'id': 'S4', 'elements': ['D', 'K', 'L', 'M', 'N']}, {'id': 'S5', 'elements': ['D', 'E', 'G', 'H', 'K', 'L', 'M']}, {'id': 'S6', 'elements': ['A', 'F', 'I', 'O', 'P', 'R']}, {'id': 'S7', 'elements': ['H', 'K']}, {'id': 'S8', 'elements': ['D', 'E', 'H', 'L']}, {'id': 'S9', 'elements': ['F', 'Q']}, {'id': 'S10', 'elements': ['C', 'J', 'P']}, {'id': 'S11', 'elements': ['A', 'D', 'O']}, {'id': 'S12', 'elements': ['D', 'E', 'M', 'N']}, {'id': 'S13', 'elements': ['L', 'M']}, {'id': 'S14', 'elements': ['D', 'E', 'G', 'H', 'K', 'N']}, {'id': 'S15', 'elements': ['A', 'B', 'C', 'K', 'O', 'P', 'Q', 'R']}, {'id': 'S16', 'elements': ['A', 'C', 'F', 'J']}, {'id': 'S17', 'elements': ['F', 'O', 'Q']}], 'budget_k': 3}","['S5', 'S15', 'S16']",11,nl,names
MkC,MkC,"There’s a charity trying to get the most bang for its outreach buck with a fixed number of teams. The team selection problem is choosing which neighborhoods to visit so the sum of distinct households contacted is maximized — count each household once even if it appears in multiple neighborhood lists, and don’t assign more teams than the allotment allows. In short, pick the neighborhoods that together bring in the largest number of different households; the concrete details are shown below.

# total_households=17
# num_neighborhoods=16
# teams_available=3
neighborhood_id,neighborhood_households
S1,A K M N
S2,A B C M
S3,D E F G
S4,C D F H
S5,C E F G M
S6,D E G
S7,C E F
S8,D F H
S9,A I K
S10,A J O P
S11,A I K N O
S12,L N Q
S13,B M N O
S14,K M O Q
S15,A M N O P
S16,A Q

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

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

This just means ""solution"" is a list of the neighborhoods (by their ids) you want to visit. Think of each item in that array as the exact label for a neighborhood from the instance file — nothing fancy required, just the IDs. The JSON above is only the expected shape, not the actual answer you must give.

Please make sure to use the identifiers exactly as they appear in the instance input — do not rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 16, 'density': 0.22058823529411764, 'sets': [{'id': 1, 'elements': [1, 11, 13, 14]}, {'id': 2, 'elements': [1, 2, 3, 13]}, {'id': 3, 'elements': [4, 5, 6, 7]}, {'id': 4, 'elements': [3, 4, 6, 8]}, {'id': 5, 'elements': [3, 5, 6, 7, 13]}, {'id': 6, 'elements': [4, 5, 7]}, {'id': 7, 'elements': [3, 5, 6]}, {'id': 8, 'elements': [4, 6, 8]}, {'id': 9, 'elements': [1, 9, 11]}, {'id': 10, 'elements': [1, 10, 15, 16]}, {'id': 11, 'elements': [1, 9, 11, 14, 15]}, {'id': 12, 'elements': [12, 14, 17]}, {'id': 13, 'elements': [2, 13, 14, 15]}, {'id': 14, 'elements': [11, 13, 15, 17]}, {'id': 15, 'elements': [1, 13, 14, 15, 16]}, {'id': 16, 'elements': [1, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 11, 'v': 1}, {'u': 11, 'v': 9}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 1, 'v': 13}, {'u': 1, 'v': 14}, {'u': 1, 'v': 15}, {'u': 2, 'v': 13}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 14, 'v': 17}, {'u': 3, 'v': 7}, {'u': 15, 'v': 10}, {'u': 17, 'v': 12}, {'u': 16, 'v': 10}, {'u': 8, 'v': 4}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0011.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0011.png'}","[4, 5, 11]",12.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['A', 'K', 'M', 'N']}, {'id': 'S2', 'elements': ['A', 'B', 'C', 'M']}, {'id': 'S3', 'elements': ['D', 'E', 'F', 'G']}, {'id': 'S4', 'elements': ['C', 'D', 'F', 'H']}, {'id': 'S5', 'elements': ['C', 'E', 'F', 'G', 'M']}, {'id': 'S6', 'elements': ['D', 'E', 'G']}, {'id': 'S7', 'elements': ['C', 'E', 'F']}, {'id': 'S8', 'elements': ['D', 'F', 'H']}, {'id': 'S9', 'elements': ['A', 'I', 'K']}, {'id': 'S10', 'elements': ['A', 'J', 'O', 'P']}, {'id': 'S11', 'elements': ['A', 'I', 'K', 'N', 'O']}, {'id': 'S12', 'elements': ['L', 'N', 'Q']}, {'id': 'S13', 'elements': ['B', 'M', 'N', 'O']}, {'id': 'S14', 'elements': ['K', 'M', 'O', 'Q']}, {'id': 'S15', 'elements': ['A', 'M', 'N', 'O', 'P']}, {'id': 'S16', 'elements': ['A', 'Q']}], 'budget_k': 3}","['S4', 'S5', 'S11']",12,csv,names
MkC,MkC,"Back at the office the rollout coordinator has to pick a compact list of installation hubs from a long list of candidates. The decision boils down to this: pick the allowed number of hubs so their combined service area includes as many distinct addresses as possible — overlapping coverage doesn’t multiply an address, it still counts once. The constraint is firm: only that many hubs can be chosen, so the final selection should maximize the count of unique addresses covered. The exact candidates, which addresses each covers, and the selection limit are listed below.

There are 13 distinct addresses in the rollout area, 11 candidate hubs available, and the coordinator must select exactly 2 hubs.
Candidate hub S1 covers A B C.
Candidate hub S2 covers A C D G.
Candidate hub S3 covers B C.
Candidate hub S4 covers F G.
Candidate hub S5 covers E I M.
Candidate hub S6 covers E H.
Candidate hub S7 covers D E F G.
Candidate hub S8 covers F J.
Candidate hub S9 covers F I M.
Candidate hub S10 covers K L.
Candidate hub S11 covers F I J L M.
The coordinator will select 2 hubs to maximize the number of unique addresses covered.

Also, when you send the final picks, just drop them into a tiny JSON object so it's easy to read and process. For this case, it should look like:

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

Here ""solution"" is the list and each item in the array is the identifier of a chosen installation hub (one entry per hub). Think of it like filling out a short form where you list the hubs you want opened. This JSON is just the shape I expect — not the actual answer itself.

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': 13, 'num_sets': 11, 'density': 0.22377622377622378, 'sets': [{'id': 1, 'elements': [1, 2, 3]}, {'id': 2, 'elements': [1, 3, 4, 7]}, {'id': 3, 'elements': [2, 3]}, {'id': 4, 'elements': [6, 7]}, {'id': 5, 'elements': [5, 9, 13]}, {'id': 6, 'elements': [5, 8]}, {'id': 7, 'elements': [4, 5, 6, 7]}, {'id': 8, 'elements': [6, 10]}, {'id': 9, 'elements': [6, 9, 13]}, {'id': 10, 'elements': [11, 12]}, {'id': 11, 'elements': [6, 9, 10, 12, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 1, 'v': 2}, {'u': 2, 'v': 3}, {'u': 3, 'v': 4}, {'u': 4, 'v': 7}, {'u': 10, 'v': 9}, {'u': 5, 'v': 6}, {'u': 5, 'v': 8}, {'u': 6, 'v': 13}, {'u': 7, 'v': 8}, {'u': 9, 'v': 13}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0012.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0012.png'}","[2, 11]",9.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'C']}, {'id': 'S2', 'elements': ['A', 'C', 'D', 'G']}, {'id': 'S3', 'elements': ['B', 'C']}, {'id': 'S4', 'elements': ['F', 'G']}, {'id': 'S5', 'elements': ['E', 'I', 'M']}, {'id': 'S6', 'elements': ['E', 'H']}, {'id': 'S7', 'elements': ['D', 'E', 'F', 'G']}, {'id': 'S8', 'elements': ['F', 'J']}, {'id': 'S9', 'elements': ['F', 'I', 'M']}, {'id': 'S10', 'elements': ['K', 'L']}, {'id': 'S11', 'elements': ['F', 'I', 'J', 'L', 'M']}], 'budget_k': 2}","['S2', 'S11']",13,nl,names
MkC,MkC,"Someone at the center needs to pick a few subject sessions to run, and resources only allow a limited number of offerings. The goal is simple: choose which sessions so that, when combining the attendees from those sessions and counting each student only once, the total distinct students served is as large as possible. Session rosters are fixed, students shouldn’t be double-counted, and the selection can’t go past the allowed number of sessions. The exact session choices and who would attend are listed below.

There are 17 distinct students in total, 17 sessions available, and at most 3 sessions can be run.
Session S1: student IDs 6 12 14.
Session S2: student IDs 2 3 9.
Session S3: student IDs 2 3 4 8 9 16.
Session S4: student IDs 2 3 4 6 8 10 11.
Session S5: student IDs 5 6 7 10 13 15.
Session S6: student IDs 1 2 10 13 14.
Session S7: student IDs 4 5 10 15.
Session S8: student IDs 2 3 8 9 10 11 17.
Session S9: student IDs 3 11 16 17.
Session S10: student IDs 6 7 8 10 11.
Session S11: student IDs 2 4 6 9 10 11 13 14.
Session S12: student IDs 1 12 15.
Session S13: student IDs 5 10 11 13 14.
Session S14: student IDs 1 6 12 13 14 15.
Session S15: student IDs 7 12 14.
Session S16: student IDs 2 3 9 16.
Session S17: student IDs 3 8 9 17.
They can select up to 3 sessions to maximize coverage of the 17 students.

Oh, and when you send back your final pick, a little JSON snippet like this keeps things tidy:

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

Here ""solution"" is just the list of sessions you want to run — each entry is one session identifier (one per chosen session). Think of it like filling out a simple form: list the session IDs you picked, and that’s it. This is just a sketch of the shape I’m expecting, not the actual answer you need to compute.

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': 17, 'num_sets': 17, 'density': 0.28719723183391005, 'sets': [{'id': 1, 'elements': [6, 12, 14]}, {'id': 2, 'elements': [2, 3, 9]}, {'id': 3, 'elements': [2, 3, 4, 8, 9, 16]}, {'id': 4, 'elements': [2, 3, 4, 6, 8, 10, 11]}, {'id': 5, 'elements': [5, 6, 7, 10, 13, 15]}, {'id': 6, 'elements': [1, 2, 10, 13, 14]}, {'id': 7, 'elements': [4, 5, 10, 15]}, {'id': 8, 'elements': [2, 3, 8, 9, 10, 11, 17]}, {'id': 9, 'elements': [3, 11, 16, 17]}, {'id': 10, 'elements': [6, 7, 8, 10, 11]}, {'id': 11, 'elements': [2, 4, 6, 9, 10, 11, 13, 14]}, {'id': 12, 'elements': [1, 12, 15]}, {'id': 13, 'elements': [5, 10, 11, 13, 14]}, {'id': 14, 'elements': [1, 6, 12, 13, 14, 15]}, {'id': 15, 'elements': [7, 12, 14]}, {'id': 16, 'elements': [2, 3, 9, 16]}, {'id': 17, 'elements': [3, 8, 9, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 7, 'v': 5}, {'u': 7, 'v': 10}, {'u': 16, 'v': 9}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 3, 'v': 17}, {'u': 5, 'v': 13}, {'u': 5, 'v': 15}, {'u': 6, 'v': 11}, {'u': 6, 'v': 13}, {'u': 6, 'v': 14}, {'u': 10, 'v': 13}, {'u': 11, 'v': 2}, {'u': 1, 'v': 14}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0013.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0013.png'}","[7, 8, 14]",15.0,"{'num_elements': 17, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [6, 12, 14]}, {'id': 'S2', 'elements': [2, 3, 9]}, {'id': 'S3', 'elements': [2, 3, 4, 8, 9, 16]}, {'id': 'S4', 'elements': [2, 3, 4, 6, 8, 10, 11]}, {'id': 'S5', 'elements': [5, 6, 7, 10, 13, 15]}, {'id': 'S6', 'elements': [1, 2, 10, 13, 14]}, {'id': 'S7', 'elements': [4, 5, 10, 15]}, {'id': 'S8', 'elements': [2, 3, 8, 9, 10, 11, 17]}, {'id': 'S9', 'elements': [3, 11, 16, 17]}, {'id': 'S10', 'elements': [6, 7, 8, 10, 11]}, {'id': 'S11', 'elements': [2, 4, 6, 9, 10, 11, 13, 14]}, {'id': 'S12', 'elements': [1, 12, 15]}, {'id': 'S13', 'elements': [5, 10, 11, 13, 14]}, {'id': 'S14', 'elements': [1, 6, 12, 13, 14, 15]}, {'id': 'S15', 'elements': [7, 12, 14]}, {'id': 'S16', 'elements': [2, 3, 9, 16]}, {'id': 'S17', 'elements': [3, 8, 9, 17]}], 'budget_k': 3}","['S7', 'S8', 'S14']",14,nl,1
MkC,MkC,"A volunteer coordinator is sketching out a schedule and has to pick a limited roster of phone banks to run this cycle. They’ll judge each possible roster by how many distinct households it reaches — tallying unique households across the chosen banks and avoiding double-counting any household, while keeping the total number of staffed banks within the cap. The full, concrete breakdown is shown below.

# total_households=16
# available_phone_banks=16
# max_staffed_banks=3
phone_bank_id,household_ids
S1,A B C P
S2,A C G I
S3,G M N
S4,A B C D F G I J O
S5,C E F N
S6,A D E F K L N P
S7,B C D H I J
S8,G J M
S9,B C I J N
S10,D G I J O P
S11,F K N O P
S12,E F K L N P
S13,C H K M N O
S14,C F I L M P
S15,D J M O P
S16,C D F J M N O P

If you'd like the final roster as data I can hand it back in a tiny JSON snippet — just the chosen phone-bank ids in an array under ""solution"". Here's the shape I'll follow:

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

Here ""solution"" is the list of phone banks we pick for the cycle, and each entry (like ""bank_id"") is a placeholder for a phone-bank identifier from the instance. Think of it like filling out a short form: the array lists which banks are staffed.

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

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 16, 'density': 0.34375, 'sets': [{'id': 1, 'elements': [1, 2, 3, 16]}, {'id': 2, 'elements': [1, 3, 7, 9]}, {'id': 3, 'elements': [7, 13, 14]}, {'id': 4, 'elements': [1, 2, 3, 4, 6, 7, 9, 10, 15]}, {'id': 5, 'elements': [3, 5, 6, 14]}, {'id': 6, 'elements': [1, 4, 5, 6, 11, 12, 14, 16]}, {'id': 7, 'elements': [2, 3, 4, 8, 9, 10]}, {'id': 8, 'elements': [7, 10, 13]}, {'id': 9, 'elements': [2, 3, 9, 10, 14]}, {'id': 10, 'elements': [4, 7, 9, 10, 15, 16]}, {'id': 11, 'elements': [6, 11, 14, 15, 16]}, {'id': 12, 'elements': [5, 6, 11, 12, 14, 16]}, {'id': 13, 'elements': [3, 8, 11, 13, 14, 15]}, {'id': 14, 'elements': [3, 6, 9, 12, 13, 16]}, {'id': 15, 'elements': [4, 10, 13, 15, 16]}, {'id': 16, 'elements': [3, 4, 6, 10, 13, 14, 15, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 2, 'v': 4}, {'u': 5, 'v': 6}, {'u': 5, 'v': 12}, {'u': 3, 'v': 4}, {'u': 3, 'v': 6}, {'u': 3, 'v': 16}, {'u': 13, 'v': 11}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 9, 'v': 4}, {'u': 9, 'v': 10}, {'u': 9, 'v': 15}, {'u': 9, 'v': 16}, {'u': 14, 'v': 6}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 14, 'v': 16}, {'u': 15, 'v': 8}, {'u': 7, 'v': 4}, {'u': 7, 'v': 10}, {'u': 8, 'v': 10}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0014.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0014.png'}","[4, 6, 13]",16.0,"{'num_elements': 16, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'C', 'P']}, {'id': 'S2', 'elements': ['A', 'C', 'G', 'I']}, {'id': 'S3', 'elements': ['G', 'M', 'N']}, {'id': 'S4', 'elements': ['A', 'B', 'C', 'D', 'F', 'G', 'I', 'J', 'O']}, {'id': 'S5', 'elements': ['C', 'E', 'F', 'N']}, {'id': 'S6', 'elements': ['A', 'D', 'E', 'F', 'K', 'L', 'N', 'P']}, {'id': 'S7', 'elements': ['B', 'C', 'D', 'H', 'I', 'J']}, {'id': 'S8', 'elements': ['G', 'J', 'M']}, {'id': 'S9', 'elements': ['B', 'C', 'I', 'J', 'N']}, {'id': 'S10', 'elements': ['D', 'G', 'I', 'J', 'O', 'P']}, {'id': 'S11', 'elements': ['F', 'K', 'N', 'O', 'P']}, {'id': 'S12', 'elements': ['E', 'F', 'K', 'L', 'N', 'P']}, {'id': 'S13', 'elements': ['C', 'H', 'K', 'M', 'N', 'O']}, {'id': 'S14', 'elements': ['C', 'F', 'I', 'L', 'M', 'P']}, {'id': 'S15', 'elements': ['D', 'J', 'M', 'O', 'P']}, {'id': 'S16', 'elements': ['C', 'D', 'F', 'J', 'M', 'N', 'O', 'P']}], 'budget_k': 3}","['S4', 'S6', 'S13']",15,csv,names
MkC,MkC,"We have a merchandising team member choosing which displays to deploy across the store, but there’s a hard cap on how many displays can go out. The idea is to pick a handful of displays that, as a group, expose the largest number of different customers to the promoted items. To judge a choice, you tally every distinct shopper reached by the selected displays (each shopper counts only once even if they’d see multiple displays), and you must stay within the allowed number of displays and not duplicate any placement. The concrete display choices and limits are listed below.

- **total_shoppers**: 13
- **total_displays_available**: 12
- **display_cap**: 2

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

Also, when you give the final choice, please put it in a tiny JSON object like this so it’s easy to read and parse:

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

Think of ""solution"" as the box where you list the displays you want to deploy — just the IDs, in an array. The example above is just a sketch of the shape I expect, not your final answer.

Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new ones.
- for example: “1” or “23”, “A” or “B”, “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 12, 'density': 0.3076923076923077, 'sets': [{'id': 1, 'elements': [1, 8]}, {'id': 2, 'elements': [2, 4, 7]}, {'id': 3, 'elements': [3, 6, 10]}, {'id': 4, 'elements': [2, 4, 7, 10, 13]}, {'id': 5, 'elements': [5, 7, 8]}, {'id': 6, 'elements': [4, 5, 8]}, {'id': 7, 'elements': [2, 3, 5, 7, 11, 13]}, {'id': 8, 'elements': [1, 6, 10]}, {'id': 9, 'elements': [3, 4, 6, 8, 9, 10, 11, 12]}, {'id': 10, 'elements': [7, 8, 9, 10, 11]}, {'id': 11, 'elements': [10, 11, 12]}, {'id': 12, 'elements': [2, 4, 7, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 5, 'v': 6}, {'u': 2, 'v': 4}, {'u': 11, 'v': 9}, {'u': 11, 'v': 10}, {'u': 11, 'v': 12}, {'u': 8, 'v': 1}, {'u': 8, 'v': 6}, {'u': 8, 'v': 10}, {'u': 10, 'v': 7}, {'u': 3, 'v': 7}, {'u': 4, 'v': 7}, {'u': 4, 'v': 13}, {'u': 6, 'v': 7}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0015.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0015.png'}","[7, 9]",12.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [0, 7]}, {'id': 'S2', 'elements': [1, 3, 6]}, {'id': 'S3', 'elements': [2, 5, 9]}, {'id': 'S4', 'elements': [1, 3, 6, 9, 12]}, {'id': 'S5', 'elements': [4, 6, 7]}, {'id': 'S6', 'elements': [3, 4, 7]}, {'id': 'S7', 'elements': [1, 2, 4, 6, 10, 12]}, {'id': 'S8', 'elements': [0, 5, 9]}, {'id': 'S9', 'elements': [2, 3, 5, 7, 8, 9, 10, 11]}, {'id': 'S10', 'elements': [6, 7, 8, 9, 10]}, {'id': 'S11', 'elements': [9, 10, 11]}, {'id': 'S12', 'elements': [1, 3, 6, 12]}], 'budget_k': 2}","['S7', 'S9']",16,markdown_table,0
MkC,MkC,"I’m a travel agent trying to make the most of a small stack of tour flyers: there’s a shortlist of different tour leaflets to hand out, but only a limited number of copies can go out. The job is to pick which flyers to push so that, once they’re handed out around town, the greatest number of different tourists end up with at least one flyer — success is just the count of distinct tourists who receive at least one flyer. Copies are limited, and giving the same person multiple flyers doesn’t increase that count, so choices matter. The exact list of flyers, limits, and who each flyer reaches are shown below.

{
  ""total_tourists"": 13,
  ""total_flyer_types"": 13,
  ""sets"": [
    {
      ""flyer_id"": ""S1"",
      ""tourist_ids_reached"": [
        0,
        11,
        12
      ]
    },
    {
      ""flyer_id"": ""S2"",
      ""tourist_ids_reached"": [
        2,
        3,
        7,
        12
      ]
    },
    {
      ""flyer_id"": ""S3"",
      ""tourist_ids_reached"": [
        3,
        5,
        7,
        8
      ]
    },
    {
      ""flyer_id"": ""S4"",
      ""tourist_ids_reached"": [
        1,
        2,
        3,
        8,
        9,
        11
      ]
    },
    {
      ""flyer_id"": ""S5"",
      ""tourist_ids_reached"": [
        4,
        6,
        10,
        12
      ]
    },
    {
      ""flyer_id"": ""S6"",
      ""tourist_ids_reached"": [
        1,
        3
      ]
    },
    {
      ""flyer_id"": ""S7"",
      ""tourist_ids_reached"": [
        6,
        7,
        11,
        12
      ]
    },
    {
      ""flyer_id"": ""S8"",
      ""tourist_ids_reached"": [
        2,
        5,
        6,
        12
      ]
    },
    {
      ""flyer_id"": ""S9"",
      ""tourist_ids_reached"": [
        2,
        3,
        8,
        9
      ]
    },
    {
      ""flyer_id"": ""S10"",
      ""tourist_ids_reached"": [
        0,
        8,
        9,
        11,
        12
      ]
    },
    {
      ""flyer_id"": ""S11"",
      ""tourist_ids_reached"": [
        4,
        6,
        10
      ]
    },
    {
      ""flyer_id"": ""S12"",
      ""tourist_ids_reached"": [
        0,
        6,
        7,
        9
      ]
    },
    {
      ""flyer_id"": ""S13"",
      ""tourist_ids_reached"": [
        0,
        1,
        4,
        7,
        9,
        12
      ]
    }
  ],
  ""max_flyer_selection"": 2
}

Also, when you tell me which flyers to push, please return it in this simple JSON shape so I can read it automatically:

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

This just means ""solution"" holds a list of the flyer identifiers you picked. Think of ""flyer_id"" as a placeholder for whatever flyer labels appear in the instance (it's not a real flyer name, just showing the shape). The JSON is just a sketch of the expected format — don't treat it as the final pick itself.

Please be careful to use the exact identifiers from the instance input — no renaming, no extra labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.3136094674556213, 'sets': [{'id': 1, 'elements': [1, 12, 13]}, {'id': 2, 'elements': [3, 4, 8, 13]}, {'id': 3, 'elements': [4, 6, 8, 9]}, {'id': 4, 'elements': [2, 3, 4, 9, 10, 12]}, {'id': 5, 'elements': [5, 7, 11, 13]}, {'id': 6, 'elements': [2, 4]}, {'id': 7, 'elements': [7, 8, 12, 13]}, {'id': 8, 'elements': [3, 6, 7, 13]}, {'id': 9, 'elements': [3, 4, 9, 10]}, {'id': 10, 'elements': [1, 9, 10, 12, 13]}, {'id': 11, 'elements': [5, 7, 11]}, {'id': 12, 'elements': [1, 7, 8, 10]}, {'id': 13, 'elements': [1, 2, 5, 8, 10, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 9, 'v': 4}, {'u': 2, 'v': 3}, {'u': 2, 'v': 8}, {'u': 12, 'v': 1}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 8, 'v': 13}, {'u': 13, 'v': 7}, {'u': 5, 'v': 7}, {'u': 5, 'v': 11}, {'u': 4, 'v': 3}, {'u': 4, 'v': 10}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0016.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0016.png'}","[4, 13]",10.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 11, 12]}, {'id': 'S2', 'elements': [2, 3, 7, 12]}, {'id': 'S3', 'elements': [3, 5, 7, 8]}, {'id': 'S4', 'elements': [1, 2, 3, 8, 9, 11]}, {'id': 'S5', 'elements': [4, 6, 10, 12]}, {'id': 'S6', 'elements': [1, 3]}, {'id': 'S7', 'elements': [6, 7, 11, 12]}, {'id': 'S8', 'elements': [2, 5, 6, 12]}, {'id': 'S9', 'elements': [2, 3, 8, 9]}, {'id': 'S10', 'elements': [0, 8, 9, 11, 12]}, {'id': 'S11', 'elements': [4, 6, 10]}, {'id': 'S12', 'elements': [0, 6, 7, 9]}, {'id': 'S13', 'elements': [0, 1, 4, 7, 9, 12]}], 'budget_k': 2}","['S4', 'S13']",17,json,0
MkC,MkC,"There’s an extension officer planning demo plots across a district with only so much time and staff. Several demos are on the table, and each has its own crowd of local farmers who would likely show up. The officer needs to choose a small set of those demos — up to the coordination limit — so that the number of different farmers who get exposed to the techniques is as high as possible. They’ll measure success by compiling all attendee lists for the chosen demos, eliminating duplicate names, and counting the unique farmers reached. The officer can’t run more demos than allowed, and each site either runs or doesn’t run. The concrete setup and lists are shown below.

There are 12 proposed demos across the district, 13 distinct farmers in total, and the officer can run at most 2 demos.
Demo S1 would likely attract these farmers: 1 2 3 4 5 8 9.
Demo S2 would likely attract these farmers: 1 4 7.
Demo S3 would likely attract these farmers: 1 4.
Demo S4 would likely attract these farmers: 4 5 7.
Demo S5 would likely attract these farmers: 1 2 4 5 7 9 10 12.
Demo S6 would likely attract these farmers: 6 9 13.
Demo S7 would likely attract these farmers: 1 5 8.
Demo S8 would likely attract these farmers: 1 5 9 11 13.
Demo S9 would likely attract these farmers: 5 9 12.
Demo S10 would likely attract these farmers: 10 11.
Demo S11 would likely attract these farmers: 5 6 9 10 13.
Demo S12 would likely attract these farmers: 9 13.
The officer should select up to 2 of the 12 demos to maximize unique reach among the 13 farmers.

Oh, and when you’re ready to tell me which demos to run, just drop them in a tiny JSON like this — super simple, no ceremony:

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

""solution"" should be a list of the demo/site IDs you pick (up to the allowed number). The example value ""demo_id"" is just a placeholder showing the shape — replace those with the actual IDs from the instance. This JSON is only a sketch of the expected shape, not the real answer itself.

Please make sure to use the exact identifiers 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.2948717948717949, 'sets': [{'id': 1, 'elements': [1, 2, 3, 4, 5, 8, 9]}, {'id': 2, 'elements': [1, 4, 7]}, {'id': 3, 'elements': [1, 4]}, {'id': 4, 'elements': [4, 5, 7]}, {'id': 5, 'elements': [1, 2, 4, 5, 7, 9, 10, 12]}, {'id': 6, 'elements': [6, 9, 13]}, {'id': 7, 'elements': [1, 5, 8]}, {'id': 8, 'elements': [1, 5, 9, 11, 13]}, {'id': 9, 'elements': [5, 9, 12]}, {'id': 10, 'elements': [10, 11]}, {'id': 11, 'elements': [5, 6, 9, 10, 13]}, {'id': 12, 'elements': [9, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 12, 'v': 6}, {'u': 12, 'v': 9}, {'u': 12, 'v': 13}, {'u': 1, 'v': 2}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 7}, {'u': 3, 'v': 4}, {'u': 5, 'v': 9}, {'u': 9, 'v': 10}, {'u': 10, 'v': 11}, {'u': 7, 'v': 8}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0017.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0017.png'}","[1, 5]",10.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [1, 2, 3, 4, 5, 8, 9]}, {'id': 'S2', 'elements': [1, 4, 7]}, {'id': 'S3', 'elements': [1, 4]}, {'id': 'S4', 'elements': [4, 5, 7]}, {'id': 'S5', 'elements': [1, 2, 4, 5, 7, 9, 10, 12]}, {'id': 'S6', 'elements': [6, 9, 13]}, {'id': 'S7', 'elements': [1, 5, 8]}, {'id': 'S8', 'elements': [1, 5, 9, 11, 13]}, {'id': 'S9', 'elements': [5, 9, 12]}, {'id': 'S10', 'elements': [10, 11]}, {'id': 'S11', 'elements': [5, 6, 9, 10, 13]}, {'id': 'S12', 'elements': [9, 13]}], 'budget_k': 2}","['S1', 'S5']",18,nl,1
MkC,MkC,"I work with a school nurse who has a list of possible screening days and a hard cap on how many of those days she can actually run. She needs to pick which days to hold screenings so the biggest number of different students get checked — if the same kid would come to two of the chosen days, that child only counts once. The better choice is the one that reaches more unique pupils when you combine the student lists from the selected days, and she can’t pick more days than the cap allows. The concrete details of available days and which students are on each day are shown below.

{
  ""total_unique_pupils"": 14,
  ""total_candidate_screening_days"": 12,
  ""sets"": [
    {
      ""screening_day_id"": ""S1"",
      ""pupil_ids_on_day"": [
        1,
        2,
        10,
        11
      ]
    },
    {
      ""screening_day_id"": ""S2"",
      ""pupil_ids_on_day"": [
        1,
        2
      ]
    },
    {
      ""screening_day_id"": ""S3"",
      ""pupil_ids_on_day"": [
        3,
        5,
        8,
        9
      ]
    },
    {
      ""screening_day_id"": ""S4"",
      ""pupil_ids_on_day"": [
        7,
        8,
        10,
        11,
        12,
        14
      ]
    },
    {
      ""screening_day_id"": ""S5"",
      ""pupil_ids_on_day"": [
        3,
        5,
        7,
        9
      ]
    },
    {
      ""screening_day_id"": ""S6"",
      ""pupil_ids_on_day"": [
        4,
        7,
        8
      ]
    },
    {
      ""screening_day_id"": ""S7"",
      ""pupil_ids_on_day"": [
        3,
        5
      ]
    },
    {
      ""screening_day_id"": ""S8"",
      ""pupil_ids_on_day"": [
        1,
        2,
        4,
        6,
        7,
        10,
        11,
        13,
        14
      ]
    },
    {
      ""screening_day_id"": ""S9"",
      ""pupil_ids_on_day"": [
        1,
        2,
        4,
        11,
        12,
        14
      ]
    },
    {
      ""screening_day_id"": ""S10"",
      ""pupil_ids_on_day"": [
        4,
        6,
        11,
        12,
        14
      ]
    },
    {
      ""screening_day_id"": ""S11"",
      ""pupil_ids_on_day"": [
        10,
        13,
        14
      ]
    },
    {
      ""screening_day_id"": ""S12"",
      ""pupil_ids_on_day"": [
        4,
        10,
        12,
        13
      ]
    }
  ],
  ""max_screening_days_allowed"": 2
}

Also, when you send back which days to run, just stick to a tiny JSON snippet like this so it's easy to parse:

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

Here ""solution"" is the list of the chosen screening days — replace the placeholder(s) with the actual day identifiers from the instance (that's the list of IDs you see in the problem). This is just a sketch of the shape I need, not the final answer itself.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels. 
- ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 12, 'density': 0.30952380952380953, 'sets': [{'id': 1, 'elements': [1, 2, 10, 11]}, {'id': 2, 'elements': [1, 2]}, {'id': 3, 'elements': [3, 5, 8, 9]}, {'id': 4, 'elements': [7, 8, 10, 11, 12, 14]}, {'id': 5, 'elements': [3, 5, 7, 9]}, {'id': 6, 'elements': [4, 7, 8]}, {'id': 7, 'elements': [3, 5]}, {'id': 8, 'elements': [1, 2, 4, 6, 7, 10, 11, 13, 14]}, {'id': 9, 'elements': [1, 2, 4, 11, 12, 14]}, {'id': 10, 'elements': [4, 6, 11, 12, 14]}, {'id': 11, 'elements': [10, 13, 14]}, {'id': 12, 'elements': [4, 10, 12, 13]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 8, 'v': 5}, {'u': 8, 'v': 7}, {'u': 1, 'v': 11}, {'u': 3, 'v': 5}, {'u': 3, 'v': 9}, {'u': 2, 'v': 11}, {'u': 4, 'v': 7}, {'u': 4, 'v': 10}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 14}, {'u': 12, 'v': 6}, {'u': 13, 'v': 14}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0018.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0018.png'}","[3, 8]",13.0,"{'num_elements': 14, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [1, 2, 10, 11]}, {'id': 'S2', 'elements': [1, 2]}, {'id': 'S3', 'elements': [3, 5, 8, 9]}, {'id': 'S4', 'elements': [7, 8, 10, 11, 12, 14]}, {'id': 'S5', 'elements': [3, 5, 7, 9]}, {'id': 'S6', 'elements': [4, 7, 8]}, {'id': 'S7', 'elements': [3, 5]}, {'id': 'S8', 'elements': [1, 2, 4, 6, 7, 10, 11, 13, 14]}, {'id': 'S9', 'elements': [1, 2, 4, 11, 12, 14]}, {'id': 'S10', 'elements': [4, 6, 11, 12, 14]}, {'id': 'S11', 'elements': [10, 13, 14]}, {'id': 'S12', 'elements': [4, 10, 12, 13]}], 'budget_k': 2}","['S3', 'S8']",19,json,1
MkC,MkC,"There’s a product lead juggling a bunch of preview ideas with only a few release slots to spare. Each preview will be seen by certain testers, so the task is choosing which previews to include so that, when you combine them, the most unique testers get touched. Count each tester once — if someone appears in two previews they still count as one — and don’t go over the cap on how many previews can be released. The concrete previews and their tester groups appear below.

# total_testers=14
# total_previews_available=13
# release_slot_limit=2
preview_id,tester_ids
S1,0 1 3
S2,1 2 11
S3,1 2 6 13
S4,0 4 8 9 10
S5,3 5 8 9 12
S6,4 5 9
S7,10 11
S8,3 4 5 9 12
S9,3 4 5 8 9
S10,3 7 10
S11,1 2 7 10
S12,8 9
S13,2 6 11

Also, when you send your final pick, please follow this simple JSON layout so it’s easy to check automatically — just a single key with a list of preview IDs:

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

Think of it like a tiny form: ""solution"" is the list of previews you want to release, and each item in the array is the identifier for one preview. This is just a sketch of the shape I expect — don’t treat the placeholder as the real answer.

Please make sure you use the exact identifiers from the instance input (no renaming, no new labels). Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 13, 'density': 0.25824175824175827, 'sets': [{'id': 1, 'elements': [1, 2, 4]}, {'id': 2, 'elements': [2, 3, 12]}, {'id': 3, 'elements': [2, 3, 7, 14]}, {'id': 4, 'elements': [1, 5, 9, 10, 11]}, {'id': 5, 'elements': [4, 6, 9, 10, 13]}, {'id': 6, 'elements': [5, 6, 10]}, {'id': 7, 'elements': [11, 12]}, {'id': 8, 'elements': [4, 5, 6, 10, 13]}, {'id': 9, 'elements': [4, 5, 6, 9, 10]}, {'id': 10, 'elements': [4, 8, 11]}, {'id': 11, 'elements': [2, 3, 8, 11]}, {'id': 12, 'elements': [9, 10]}, {'id': 13, 'elements': [3, 7, 12]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 9, 'v': 5}, {'u': 9, 'v': 13}, {'u': 13, 'v': 10}, {'u': 8, 'v': 2}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 5, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 11, 'v': 1}, {'u': 12, 'v': 3}, {'u': 4, 'v': 1}, {'u': 7, 'v': 14}, {'u': 3, 'v': 14}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0019.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0019.png'}","[8, 11]",9.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 1, 3]}, {'id': 'S2', 'elements': [1, 2, 11]}, {'id': 'S3', 'elements': [1, 2, 6, 13]}, {'id': 'S4', 'elements': [0, 4, 8, 9, 10]}, {'id': 'S5', 'elements': [3, 5, 8, 9, 12]}, {'id': 'S6', 'elements': [4, 5, 9]}, {'id': 'S7', 'elements': [10, 11]}, {'id': 'S8', 'elements': [3, 4, 5, 9, 12]}, {'id': 'S9', 'elements': [3, 4, 5, 8, 9]}, {'id': 'S10', 'elements': [3, 7, 10]}, {'id': 'S11', 'elements': [1, 2, 7, 10]}, {'id': 'S12', 'elements': [8, 9]}, {'id': 'S13', 'elements': [2, 6, 11]}], 'budget_k': 2}","['S8', 'S11']",20,csv,0
MkC,MkC,"Back when the expansion was being planned, the core question was straightforward: pick a small set of docking locations so bikes reach the widest spread of neighborhoods. The decision is which sites to install given the cap on how many docks are allowed. Success is simply reaching more unique neighborhoods — tally the neighborhoods that have at least one dock to see how well a choice performs. Each spot is either chosen or not, and repeating coverage for a neighborhood won’t increase the overall reach. The specific site list and the number of docks permitted are shown below.

- **total_neighborhoods**: 17
- **total_candidate_sites**: 17
- **max_installable_sites**: 3

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

Also, when you send your pick back, it'd be great if you used a tiny JSON snippet like this so it's easy to parse:

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

Think of this as a simple form: ""solution"" is the list of docking sites you choose, and each entry in that list should be the exact ID for a site (replace the placeholder ""dock_id"" with the real IDs from the instance). This is just a sketch of the expected shape — not the actual 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”.""

Keep it simple and literal: drop the real IDs into that array and you're set.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 17, 'density': 0.2422145328719723, 'sets': [{'id': 1, 'elements': [1, 13, 17]}, {'id': 2, 'elements': [6, 11, 17]}, {'id': 3, 'elements': [5, 14]}, {'id': 4, 'elements': [4, 7, 8]}, {'id': 5, 'elements': [3, 5, 8, 13]}, {'id': 6, 'elements': [5, 6, 8, 13, 17]}, {'id': 7, 'elements': [4, 7]}, {'id': 8, 'elements': [4, 5, 6, 8, 13, 15, 16, 17]}, {'id': 9, 'elements': [9, 15, 16]}, {'id': 10, 'elements': [4, 7, 10, 15]}, {'id': 11, 'elements': [2, 6, 11]}, {'id': 12, 'elements': [9, 12, 15]}, {'id': 13, 'elements': [1, 6, 8, 13, 17]}, {'id': 14, 'elements': [3, 5, 14, 17]}, {'id': 15, 'elements': [4, 8, 9, 10, 12, 15, 16]}, {'id': 16, 'elements': [4, 8, 9, 12, 15]}, {'id': 17, 'elements': [1, 3, 11, 13, 14, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 5, 'v': 3}, {'u': 5, 'v': 14}, {'u': 5, 'v': 17}, {'u': 17, 'v': 6}, {'u': 17, 'v': 8}, {'u': 17, 'v': 13}, {'u': 10, 'v': 4}, {'u': 10, 'v': 7}, {'u': 6, 'v': 2}, {'u': 6, 'v': 11}, {'u': 13, 'v': 1}, {'u': 9, 'v': 16}, {'u': 12, 'v': 16}, {'u': 8, 'v': 15}, {'u': 15, 'v': 4}, {'u': 15, 'v': 16}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0020.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0020.png'}","[11, 15, 17]",15.0,"{'num_elements': 17, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': ['A', 'M', 'Q']}, {'id': 'S2', 'elements': ['F', 'K', 'Q']}, {'id': 'S3', 'elements': ['E', 'N']}, {'id': 'S4', 'elements': ['D', 'G', 'H']}, {'id': 'S5', 'elements': ['C', 'E', 'H', 'M']}, {'id': 'S6', 'elements': ['E', 'F', 'H', 'M', 'Q']}, {'id': 'S7', 'elements': ['D', 'G']}, {'id': 'S8', 'elements': ['D', 'E', 'F', 'H', 'M', 'O', 'P', 'Q']}, {'id': 'S9', 'elements': ['I', 'O', 'P']}, {'id': 'S10', 'elements': ['D', 'G', 'J', 'O']}, {'id': 'S11', 'elements': ['B', 'F', 'K']}, {'id': 'S12', 'elements': ['I', 'L', 'O']}, {'id': 'S13', 'elements': ['A', 'F', 'H', 'M', 'Q']}, {'id': 'S14', 'elements': ['C', 'E', 'N', 'Q']}, {'id': 'S15', 'elements': ['D', 'H', 'I', 'J', 'L', 'O', 'P']}, {'id': 'S16', 'elements': ['D', 'H', 'I', 'L', 'O']}, {'id': 'S17', 'elements': ['A', 'C', 'K', 'M', 'N', 'Q']}], 'budget_k': 3}","['S11', 'S15', 'S17']",21,markdown_table,names
MkC,MkC,"I’m the principal trying to figure out which after-school clubs to run next term. The idea is to pick only a handful of club options so that, together, they touch as many different student interests as possible — count each interest only once even if multiple clubs appeal to the same kids. There’s a strict cap on how many clubs can be offered, and duplicates don’t help, so the better choice is the set of clubs that together cover the widest variety of interests. Concrete club lists and the limit are shown below.

# total_interests=17
# total_club_options=16
# max_clubs_offered=3
club_id,club_interests
S1,A D E I M O Q
S2,B D F H
S3,F M
S4,A D F L N
S5,E I J O Q
S6,B C D F G H K L M
S7,D F G N
S8,B C H J K M P
S9,A E I Q
S10,E H K M Q
S11,E H J K L O P
S12,D F G K
S13,C D F J K M P Q
S14,A E K O
S15,H K M P
S16,E I M Q

Also, when you send back your pick, could you use this simple JSON shape so it's easy to check?

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

""solution"" is just the list of club identifiers you want to run next term — one entry per club. Think of it like filling in a form: replace those placeholders with the actual club labels from the instance. This snippet is only a sketch of the shape I need, not the final answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 16, 'density': 0.30514705882352944, 'sets': [{'id': 1, 'elements': [1, 4, 5, 9, 13, 15, 17]}, {'id': 2, 'elements': [2, 4, 6, 8]}, {'id': 3, 'elements': [6, 13]}, {'id': 4, 'elements': [1, 4, 6, 12, 14]}, {'id': 5, 'elements': [5, 9, 10, 15, 17]}, {'id': 6, 'elements': [2, 3, 4, 6, 7, 8, 11, 12, 13]}, {'id': 7, 'elements': [4, 6, 7, 14]}, {'id': 8, 'elements': [2, 3, 8, 10, 11, 13, 16]}, {'id': 9, 'elements': [1, 5, 9, 17]}, {'id': 10, 'elements': [5, 8, 11, 13, 17]}, {'id': 11, 'elements': [5, 8, 10, 11, 12, 15, 16]}, {'id': 12, 'elements': [4, 6, 7, 11]}, {'id': 13, 'elements': [3, 4, 6, 10, 11, 13, 16, 17]}, {'id': 14, 'elements': [1, 5, 11, 15]}, {'id': 15, 'elements': [8, 11, 13, 16]}, {'id': 16, 'elements': [5, 9, 13, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 17, 'v': 5}, {'u': 17, 'v': 10}, {'u': 12, 'v': 4}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 11}, {'u': 6, 'v': 2}, {'u': 6, 'v': 8}, {'u': 5, 'v': 1}, {'u': 5, 'v': 9}, {'u': 7, 'v': 14}, {'u': 15, 'v': 1}, {'u': 13, 'v': 8}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 13, 'v': 16}, {'u': 1, 'v': 11}, {'u': 8, 'v': 3}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0021.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0021.png'}","[1, 7, 8]",16.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'E', 'I', 'M', 'O', 'Q']}, {'id': 'S2', 'elements': ['B', 'D', 'F', 'H']}, {'id': 'S3', 'elements': ['F', 'M']}, {'id': 'S4', 'elements': ['A', 'D', 'F', 'L', 'N']}, {'id': 'S5', 'elements': ['E', 'I', 'J', 'O', 'Q']}, {'id': 'S6', 'elements': ['B', 'C', 'D', 'F', 'G', 'H', 'K', 'L', 'M']}, {'id': 'S7', 'elements': ['D', 'F', 'G', 'N']}, {'id': 'S8', 'elements': ['B', 'C', 'H', 'J', 'K', 'M', 'P']}, {'id': 'S9', 'elements': ['A', 'E', 'I', 'Q']}, {'id': 'S10', 'elements': ['E', 'H', 'K', 'M', 'Q']}, {'id': 'S11', 'elements': ['E', 'H', 'J', 'K', 'L', 'O', 'P']}, {'id': 'S12', 'elements': ['D', 'F', 'G', 'K']}, {'id': 'S13', 'elements': ['C', 'D', 'F', 'J', 'K', 'M', 'P', 'Q']}, {'id': 'S14', 'elements': ['A', 'E', 'K', 'O']}, {'id': 'S15', 'elements': ['H', 'K', 'M', 'P']}, {'id': 'S16', 'elements': ['E', 'I', 'M', 'Q']}], 'budget_k': 3}","['S1', 'S7', 'S8']",22,csv,names
MkC,MkC,"We own a cozy neighborhood café and are trying to decide which rotating specials to feature so the menu appeals widely. The decision is simply which limited set of specials to run at a time — the best set is the one that, together, satisfies the largest number of different dietary preferences. When tallying success, add up the distinct dietary categories covered across the chosen specials (don’t double-count the same category), and remember there’s only room for a few picks. The specific menu choices and labels are listed below.

{
  ""total_dietary_categories"": 13,
  ""total_specials_available"": 11,
  ""sets"": [
    {
      ""special_id"": ""S1"",
      ""covered_dietary_categories"": [
        1,
        3,
        5,
        6,
        11
      ]
    },
    {
      ""special_id"": ""S2"",
      ""covered_dietary_categories"": [
        2,
        5
      ]
    },
    {
      ""special_id"": ""S3"",
      ""covered_dietary_categories"": [
        1,
        8,
        11
      ]
    },
    {
      ""special_id"": ""S4"",
      ""covered_dietary_categories"": [
        1,
        2,
        6,
        7
      ]
    },
    {
      ""special_id"": ""S5"",
      ""covered_dietary_categories"": [
        2,
        13
      ]
    },
    {
      ""special_id"": ""S6"",
      ""covered_dietary_categories"": [
        3,
        7,
        11
      ]
    },
    {
      ""special_id"": ""S7"",
      ""covered_dietary_categories"": [
        3,
        8,
        9
      ]
    },
    {
      ""special_id"": ""S8"",
      ""covered_dietary_categories"": [
        3,
        7,
        8,
        9
      ]
    },
    {
      ""special_id"": ""S9"",
      ""covered_dietary_categories"": [
        1,
        4,
        5,
        6,
        10,
        12
      ]
    },
    {
      ""special_id"": ""S10"",
      ""covered_dietary_categories"": [
        4,
        5,
        10,
        12
      ]
    },
    {
      ""special_id"": ""S11"",
      ""covered_dietary_categories"": [
        2,
        6,
        13
      ]
    }
  ],
  ""max_specials_to_feature"": 2
}

If you want to tell me which specials to run, just put them in a tiny JSON list like this — nice and simple:

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

""solution"" should contain the IDs of the specials you pick (one per entry). Think of it like filling out a short form — this is just the shape I expect, 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': 13, 'num_sets': 11, 'density': 0.2727272727272727, 'sets': [{'id': 1, 'elements': [1, 3, 5, 6, 11]}, {'id': 2, 'elements': [2, 5]}, {'id': 3, 'elements': [1, 8, 11]}, {'id': 4, 'elements': [1, 2, 6, 7]}, {'id': 5, 'elements': [2, 13]}, {'id': 6, 'elements': [3, 7, 11]}, {'id': 7, 'elements': [3, 8, 9]}, {'id': 8, 'elements': [3, 7, 8, 9]}, {'id': 9, 'elements': [1, 4, 5, 6, 10, 12]}, {'id': 10, 'elements': [4, 5, 10, 12]}, {'id': 11, 'elements': [2, 6, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 8, 'v': 3}, {'u': 5, 'v': 1}, {'u': 5, 'v': 6}, {'u': 5, 'v': 10}, {'u': 6, 'v': 2}, {'u': 2, 'v': 13}, {'u': 9, 'v': 3}, {'u': 10, 'v': 12}, {'u': 12, 'v': 4}, {'u': 1, 'v': 7}, {'u': 11, 'v': 7}, {'u': 3, 'v': 7}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0022.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0022.png'}","[8, 9]",10.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [1, 3, 5, 6, 11]}, {'id': 'S2', 'elements': [2, 5]}, {'id': 'S3', 'elements': [1, 8, 11]}, {'id': 'S4', 'elements': [1, 2, 6, 7]}, {'id': 'S5', 'elements': [2, 13]}, {'id': 'S6', 'elements': [3, 7, 11]}, {'id': 'S7', 'elements': [3, 8, 9]}, {'id': 'S8', 'elements': [3, 7, 8, 9]}, {'id': 'S9', 'elements': [1, 4, 5, 6, 10, 12]}, {'id': 'S10', 'elements': [4, 5, 10, 12]}, {'id': 'S11', 'elements': [2, 6, 13]}], 'budget_k': 2}","['S8', 'S9']",23,json,1
MkC,MkC,"We run the weekly feature and have to choose only a small number of playlists to highlight, aiming to give listeners the widest possible mix of artists and musical styles. Success is measured by adding up the unique artists and genres across whatever playlists we pick — repeated artists don’t increase the variety — and we must stay within the allowed number of promotions. The exact playlist choices and the limits are listed below.

- **total_unique_artists_and_genres**: 14
- **total_playlists_available**: 14
- **max_playlists_to_promote**: 2

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

Oh, and when you send back the actual picks, please use this simple JSON layout so it's easy to parse:

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

""solution"" is just the list of playlist identifiers for the playlists you want to highlight. Treat each entry like a checkbox — put the exact playlist id from the instance input into the array. The JSON above is only a sketch of the expected shape, not the actual answer you should submit.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 14, 'density': 0.29591836734693877, 'sets': [{'id': 1, 'elements': [1, 8, 11]}, {'id': 2, 'elements': [2, 4, 5, 6, 8, 10, 12, 14]}, {'id': 3, 'elements': [3, 7, 8]}, {'id': 4, 'elements': [2, 5, 6, 14]}, {'id': 5, 'elements': [4, 5, 6, 11, 12, 13]}, {'id': 6, 'elements': [2, 4, 5, 10, 12]}, {'id': 7, 'elements': [3, 7, 8, 11, 13]}, {'id': 8, 'elements': [1, 2, 3, 5, 7, 8, 11, 13]}, {'id': 9, 'elements': [8, 9]}, {'id': 10, 'elements': [2, 6, 10]}, {'id': 11, 'elements': [1, 5, 8, 11]}, {'id': 12, 'elements': [2, 6, 12]}, {'id': 13, 'elements': [7, 11]}, {'id': 14, 'elements': [2, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 1, 'v': 11}, {'u': 3, 'v': 7}, {'u': 6, 'v': 2}, {'u': 6, 'v': 10}, {'u': 11, 'v': 8}, {'u': 7, 'v': 8}, {'u': 14, 'v': 4}, {'u': 5, 'v': 2}, {'u': 5, 'v': 8}, {'u': 12, 'v': 2}, {'u': 4, 'v': 2}, {'u': 9, 'v': 13}, {'u': 8, 'v': 13}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0023.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0023.png'}","[2, 8]",13.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'H', 'K']}, {'id': 'S2', 'elements': ['B', 'D', 'E', 'F', 'H', 'J', 'L', 'N']}, {'id': 'S3', 'elements': ['C', 'G', 'H']}, {'id': 'S4', 'elements': ['B', 'E', 'F', 'N']}, {'id': 'S5', 'elements': ['D', 'E', 'F', 'K', 'L', 'M']}, {'id': 'S6', 'elements': ['B', 'D', 'E', 'J', 'L']}, {'id': 'S7', 'elements': ['C', 'G', 'H', 'K', 'M']}, {'id': 'S8', 'elements': ['A', 'B', 'C', 'E', 'G', 'H', 'K', 'M']}, {'id': 'S9', 'elements': ['H', 'I']}, {'id': 'S10', 'elements': ['B', 'F', 'J']}, {'id': 'S11', 'elements': ['A', 'E', 'H', 'K']}, {'id': 'S12', 'elements': ['B', 'F', 'L']}, {'id': 'S13', 'elements': ['G', 'K']}, {'id': 'S14', 'elements': ['B', 'N']}], 'budget_k': 2}","['S2', 'S8']",24,markdown_table,names
MkC,MkC,"There’s a season coming up and the plan is to pick which crop types to sow so the farm hosts as many different pollinator species as possible. The trick is there’s a hard cap on how many distinct varieties can be planted. One selection beats another if, after combining all fields, it yields a higher tally of unique pollinators; overlap doesn’t increase the tally because each species is counted only once even if it visits several crops. No more varieties than the cap and no repeated entries of the same variety are allowed. Concrete details are shown below.

{
  ""total_pollinator_species"": 18,
  ""available_crop_varieties"": 16,
  ""sets"": [
    {
      ""variety_id"": ""S1"",
      ""attracted_pollinator_ids"": [
        ""A"",
        ""E"",
        ""K"",
        ""N""
      ]
    },
    {
      ""variety_id"": ""S2"",
      ""attracted_pollinator_ids"": [
        ""B"",
        ""J"",
        ""O"",
        ""P""
      ]
    },
    {
      ""variety_id"": ""S3"",
      ""attracted_pollinator_ids"": [
        ""C"",
        ""D"",
        ""E"",
        ""N""
      ]
    },
    {
      ""variety_id"": ""S4"",
      ""attracted_pollinator_ids"": [
        ""D"",
        ""E"",
        ""N""
      ]
    },
    {
      ""variety_id"": ""S5"",
      ""attracted_pollinator_ids"": [
        ""M"",
        ""R""
      ]
    },
    {
      ""variety_id"": ""S6"",
      ""attracted_pollinator_ids"": [
        ""G"",
        ""H"",
        ""R""
      ]
    },
    {
      ""variety_id"": ""S7"",
      ""attracted_pollinator_ids"": [
        ""H"",
        ""J"",
        ""R""
      ]
    },
    {
      ""variety_id"": ""S8"",
      ""attracted_pollinator_ids"": [
        ""F"",
        ""I"",
        ""M""
      ]
    },
    {
      ""variety_id"": ""S9"",
      ""attracted_pollinator_ids"": [
        ""B"",
        ""G"",
        ""H"",
        ""J"",
        ""N"",
        ""O""
      ]
    },
    {
      ""variety_id"": ""S10"",
      ""attracted_pollinator_ids"": [
        ""B"",
        ""P"",
        ""Q""
      ]
    },
    {
      ""variety_id"": ""S11"",
      ""attracted_pollinator_ids"": [
        ""I"",
        ""M""
      ]
    },
    {
      ""variety_id"": ""S12"",
      ""attracted_pollinator_ids"": [
        ""B"",
        ""C"",
        ""D"",
        ""E"",
        ""J"",
        ""K"",
        ""N"",
        ""O""
      ]
    },
    {
      ""variety_id"": ""S13"",
      ""attracted_pollinator_ids"": [
        ""A"",
        ""B"",
        ""H"",
        ""J"",
        ""N""
      ]
    },
    {
      ""variety_id"": ""S14"",
      ""attracted_pollinator_ids"": [
        ""B"",
        ""L"",
        ""O"",
        ""P"",
        ""Q""
      ]
    },
    {
      ""variety_id"": ""S15"",
      ""attracted_pollinator_ids"": [
        ""B"",
        ""L""
      ]
    },
    {
      ""variety_id"": ""S16"",
      ""attracted_pollinator_ids"": [
        ""H"",
        ""M""
      ]
    }
  ],
  ""max_varieties_to_plant"": 3
}

Also, when you send back which varieties to plant, just use a tiny JSON layout so it's easy to check automatically. For example:

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

Here ""solution"" is the list of crop variety identifiers you're choosing — one entry per variety. Think of ""crop_id"" as a placeholder for each variety label from the instance; swap it out for the actual IDs when you reply. This JSON is just a sketch of the shape I need, 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. 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.2048611111111111, 'sets': [{'id': 1, 'elements': [1, 5, 11, 14]}, {'id': 2, 'elements': [2, 10, 15, 16]}, {'id': 3, 'elements': [3, 4, 5, 14]}, {'id': 4, 'elements': [4, 5, 14]}, {'id': 5, 'elements': [13, 18]}, {'id': 6, 'elements': [7, 8, 18]}, {'id': 7, 'elements': [8, 10, 18]}, {'id': 8, 'elements': [6, 9, 13]}, {'id': 9, 'elements': [2, 7, 8, 10, 14, 15]}, {'id': 10, 'elements': [2, 16, 17]}, {'id': 11, 'elements': [9, 13]}, {'id': 12, 'elements': [2, 3, 4, 5, 10, 11, 14, 15]}, {'id': 13, 'elements': [1, 2, 8, 10, 14]}, {'id': 14, 'elements': [2, 12, 15, 16, 17]}, {'id': 15, 'elements': [2, 12]}, {'id': 16, 'elements': [8, 13]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 4, 'v': 5}, {'u': 9, 'v': 6}, {'u': 17, 'v': 16}, {'u': 18, 'v': 7}, {'u': 18, 'v': 13}, {'u': 13, 'v': 6}, {'u': 16, 'v': 2}, {'u': 16, 'v': 12}, {'u': 1, 'v': 11}, {'u': 1, 'v': 14}, {'u': 7, 'v': 8}, {'u': 8, 'v': 10}, {'u': 2, 'v': 15}, {'u': 15, 'v': 10}, {'u': 15, 'v': 14}, {'u': 5, 'v': 3}, {'u': 5, 'v': 14}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0024.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0024.png'}","[8, 12, 14]",14.0,"{'num_elements': 18, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': ['A', 'E', 'K', 'N']}, {'id': 'S2', 'elements': ['B', 'J', 'O', 'P']}, {'id': 'S3', 'elements': ['C', 'D', 'E', 'N']}, {'id': 'S4', 'elements': ['D', 'E', 'N']}, {'id': 'S5', 'elements': ['M', 'R']}, {'id': 'S6', 'elements': ['G', 'H', 'R']}, {'id': 'S7', 'elements': ['H', 'J', 'R']}, {'id': 'S8', 'elements': ['F', 'I', 'M']}, {'id': 'S9', 'elements': ['B', 'G', 'H', 'J', 'N', 'O']}, {'id': 'S10', 'elements': ['B', 'P', 'Q']}, {'id': 'S11', 'elements': ['I', 'M']}, {'id': 'S12', 'elements': ['B', 'C', 'D', 'E', 'J', 'K', 'N', 'O']}, {'id': 'S13', 'elements': ['A', 'B', 'H', 'J', 'N']}, {'id': 'S14', 'elements': ['B', 'L', 'O', 'P', 'Q']}, {'id': 'S15', 'elements': ['B', 'L']}, {'id': 'S16', 'elements': ['H', 'M']}], 'budget_k': 3}","['S8', 'S12', 'S14']",25,json,names
MkC,MkC,"At the campaign office the outreach planner is faced with a limited schedule and a long list of neighborhoods to consider. The task is to pick which ones to visit so that, when their household rolls are merged, the total number of different households reached is as high as possible — count each household once even if it shows up in multiple neighborhoods. Because there’s a fixed limit on how many neighborhoods can be visited, the best choice is the set that produces the largest unique-household total. The exact neighborhood items and overlaps are shown below.

{
  ""total_households"": 18,
  ""total_neighborhoods"": 14,
  ""sets"": [
    {
      ""neighborhood_id"": ""S1"",
      ""household_ids"": [
        3,
        6,
        9,
        10,
        15
      ]
    },
    {
      ""neighborhood_id"": ""S2"",
      ""household_ids"": [
        1,
        15
      ]
    },
    {
      ""neighborhood_id"": ""S3"",
      ""household_ids"": [
        0,
        1,
        3,
        5,
        7,
        8,
        10,
        11,
        15
      ]
    },
    {
      ""neighborhood_id"": ""S4"",
      ""household_ids"": [
        4,
        10,
        11,
        14
      ]
    },
    {
      ""neighborhood_id"": ""S5"",
      ""household_ids"": [
        1,
        2,
        3,
        5,
        12,
        15,
        16
      ]
    },
    {
      ""neighborhood_id"": ""S6"",
      ""household_ids"": [
        6,
        8,
        9
      ]
    },
    {
      ""neighborhood_id"": ""S7"",
      ""household_ids"": [
        3,
        7,
        10,
        17
      ]
    },
    {
      ""neighborhood_id"": ""S8"",
      ""household_ids"": [
        0,
        6,
        9
      ]
    },
    {
      ""neighborhood_id"": ""S9"",
      ""household_ids"": [
        7,
        11,
        13,
        14,
        15
      ]
    },
    {
      ""neighborhood_id"": ""S10"",
      ""household_ids"": [
        3,
        7,
        10,
        11
      ]
    },
    {
      ""neighborhood_id"": ""S11"",
      ""household_ids"": [
        13,
        17
      ]
    },
    {
      ""neighborhood_id"": ""S12"",
      ""household_ids"": [
        0,
        1,
        3,
        5,
        10,
        15,
        16
      ]
    },
    {
      ""neighborhood_id"": ""S13"",
      ""household_ids"": [
        2,
        16
      ]
    },
    {
      ""neighborhood_id"": ""S14"",
      ""household_ids"": [
        7,
        13,
        17
      ]
    }
  ],
  ""max_neighborhoods_to_visit"": 2
}

Also, when you send the final pick, please stick to this simple JSON shape so it’s easy to read by both people and machines:

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

Here ""solution"" is just a list of the neighborhood identifiers you’d choose to visit — each entry is the exact ID for a neighborhood from the instance. Think of it like filling in a form field called ""solution"" with the list of neighborhoods you picked. This JSON is just a sketch of the expected shape, not the actual answer.

Please be sure to use the identifiers exactly as they appear in the instance input — 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': 14, 'density': 0.23809523809523808, 'sets': [{'id': 1, 'elements': [4, 7, 10, 11, 16]}, {'id': 2, 'elements': [2, 16]}, {'id': 3, 'elements': [1, 2, 4, 6, 8, 9, 11, 12, 16]}, {'id': 4, 'elements': [5, 11, 12, 15]}, {'id': 5, 'elements': [2, 3, 4, 6, 13, 16, 17]}, {'id': 6, 'elements': [7, 9, 10]}, {'id': 7, 'elements': [4, 8, 11, 18]}, {'id': 8, 'elements': [1, 7, 10]}, {'id': 9, 'elements': [8, 12, 14, 15, 16]}, {'id': 10, 'elements': [4, 8, 11, 12]}, {'id': 11, 'elements': [14, 18]}, {'id': 12, 'elements': [1, 2, 4, 6, 11, 16, 17]}, {'id': 13, 'elements': [3, 17]}, {'id': 14, 'elements': [8, 14, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 1, 'v': 4}, {'u': 1, 'v': 9}, {'u': 4, 'v': 11}, {'u': 4, 'v': 16}, {'u': 10, 'v': 9}, {'u': 14, 'v': 8}, {'u': 14, 'v': 18}, {'u': 17, 'v': 6}, {'u': 17, 'v': 13}, {'u': 16, 'v': 2}, {'u': 16, 'v': 6}, {'u': 15, 'v': 12}, {'u': 9, 'v': 7}, {'u': 5, 'v': 12}, {'u': 6, 'v': 3}, {'u': 8, 'v': 11}, {'u': 11, 'v': 12}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0025.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0025.png'}","[3, 5]",12.0,"{'num_elements': 18, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [3, 6, 9, 10, 15]}, {'id': 'S2', 'elements': [1, 15]}, {'id': 'S3', 'elements': [0, 1, 3, 5, 7, 8, 10, 11, 15]}, {'id': 'S4', 'elements': [4, 10, 11, 14]}, {'id': 'S5', 'elements': [1, 2, 3, 5, 12, 15, 16]}, {'id': 'S6', 'elements': [6, 8, 9]}, {'id': 'S7', 'elements': [3, 7, 10, 17]}, {'id': 'S8', 'elements': [0, 6, 9]}, {'id': 'S9', 'elements': [7, 11, 13, 14, 15]}, {'id': 'S10', 'elements': [3, 7, 10, 11]}, {'id': 'S11', 'elements': [13, 17]}, {'id': 'S12', 'elements': [0, 1, 3, 5, 10, 15, 16]}, {'id': 'S13', 'elements': [2, 16]}, {'id': 'S14', 'elements': [7, 13, 17]}], 'budget_k': 2}","['S3', 'S5']",26,json,0
MkC,MkC,"I was thinking about a buyer at a small shop who can only bring in a handful of product lines and wants the shelves to appeal to as many different customer tastes as possible. The buyer has to pick which lines to carry, knowing each line attracts certain kinds of shoppers, and a better pick is simply the one that ends up satisfying the most distinct tastes — count each taste once even if it’s covered by several lines. Nothing can be carried twice and only the limited number of lines allowed can be chosen. The exact product options and customer taste details are shown below.

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

Oh, and when you send back the picks, a neat little JSON like this is all I need — just the list of chosen product lines in that shape.

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

""solution"" should hold the product lines the buyer decides to carry — one identifier per entry. Think of it like filling out a tiny form: put the IDs of the lines you want on the shelves in that array. This is just the expected shape (a sketch of the answer format), not the actual choice itself.

Please be sure to use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 17, 'num_sets': 16, 'density': 0.23161764705882354, 'sets': [{'id': 1, 'elements': [1, 5, 6, 10, 15, 17]}, {'id': 2, 'elements': [2, 4, 7, 12, 14]}, {'id': 3, 'elements': [3, 15]}, {'id': 4, 'elements': [4, 12]}, {'id': 5, 'elements': [1, 3, 9, 15]}, {'id': 6, 'elements': [1, 6, 8, 10, 17]}, {'id': 7, 'elements': [2, 5, 7, 9, 14, 15]}, {'id': 8, 'elements': [6, 13]}, {'id': 9, 'elements': [5, 7, 9, 15]}, {'id': 10, 'elements': [1, 6, 10, 11, 17]}, {'id': 11, 'elements': [10, 11, 16, 17]}, {'id': 12, 'elements': [6, 8, 17]}, {'id': 13, 'elements': [2, 7, 12, 14]}, {'id': 14, 'elements': [1, 3, 5, 7, 9, 15]}, {'id': 15, 'elements': [10, 16]}, {'id': 16, 'elements': [1, 5, 10]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 3, 'v': 5}, {'u': 16, 'v': 11}, {'u': 17, 'v': 1}, {'u': 17, 'v': 6}, {'u': 17, 'v': 10}, {'u': 15, 'v': 5}, {'u': 15, 'v': 7}, {'u': 15, 'v': 9}, {'u': 2, 'v': 7}, {'u': 2, 'v': 12}, {'u': 2, 'v': 14}, {'u': 4, 'v': 12}, {'u': 13, 'v': 6}, {'u': 13, 'v': 8}, {'u': 5, 'v': 1}, {'u': 10, 'v': 11}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0026.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0026.png'}","[2, 11, 14]",14.0,"{'num_elements': 17, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [0, 4, 5, 9, 14, 16]}, {'id': 'S2', 'elements': [1, 3, 6, 11, 13]}, {'id': 'S3', 'elements': [2, 14]}, {'id': 'S4', 'elements': [3, 11]}, {'id': 'S5', 'elements': [0, 2, 8, 14]}, {'id': 'S6', 'elements': [0, 5, 7, 9, 16]}, {'id': 'S7', 'elements': [1, 4, 6, 8, 13, 14]}, {'id': 'S8', 'elements': [5, 12]}, {'id': 'S9', 'elements': [4, 6, 8, 14]}, {'id': 'S10', 'elements': [0, 5, 9, 10, 16]}, {'id': 'S11', 'elements': [9, 10, 15, 16]}, {'id': 'S12', 'elements': [5, 7, 16]}, {'id': 'S13', 'elements': [1, 6, 11, 13]}, {'id': 'S14', 'elements': [0, 2, 4, 6, 8, 14]}, {'id': 'S15', 'elements': [9, 15]}, {'id': 'S16', 'elements': [0, 4, 9]}], 'budget_k': 3}","['S2', 'S11', 'S14']",27,csv,0
MkC,MkC,"On a quiet afternoon in the studio the plan was to pull together a small sampler of work that feels diverse. The decision is to choose only a certain number of images, and the winning set is the one that covers the most different subjects and moods — evaluate any set by counting the distinct subjects represented. No repeats allowed, and the limit on picks stands; the full details of available pictures and the cap are listed below.

- **total_subjects**: 14
- **total_images**: 13
- **max_images_to_select**: 2

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

If you'd like, send your selection back in this relaxed little format so it's easy to read and parse:

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

Think of ""solution"" as the short list of picture IDs you picked for the sampler — just the identifiers, nothing else. The JSON above is just a sketch of the shape I expect, not the actual answer you need to submit.

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': 14, 'num_sets': 13, 'density': 0.3241758241758242, 'sets': [{'id': 1, 'elements': [1, 2, 4, 13]}, {'id': 2, 'elements': [1, 4, 7, 13]}, {'id': 3, 'elements': [5, 8]}, {'id': 4, 'elements': [1, 4, 13]}, {'id': 5, 'elements': [5, 7, 8, 14]}, {'id': 6, 'elements': [3, 5, 6, 8, 11]}, {'id': 7, 'elements': [2, 5, 6, 7, 8, 9, 10, 11, 14]}, {'id': 8, 'elements': [3, 5, 7, 8]}, {'id': 9, 'elements': [3, 7, 9, 10, 12]}, {'id': 10, 'elements': [7, 9, 11, 12]}, {'id': 11, 'elements': [3, 6, 7, 9, 11, 12]}, {'id': 12, 'elements': [3, 10, 11, 12]}, {'id': 13, 'elements': [2, 5, 9, 13, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 9, 'v': 7}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 4}, {'u': 6, 'v': 3}, {'u': 6, 'v': 5}, {'u': 6, 'v': 8}, {'u': 10, 'v': 12}, {'u': 2, 'v': 14}, {'u': 14, 'v': 7}, {'u': 7, 'v': 5}, {'u': 11, 'v': 3}, {'u': 11, 'v': 12}, {'u': 5, 'v': 8}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0027.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0027.png'}","[1, 7]",12.0,"{'num_elements': 14, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [1, 2, 4, 13]}, {'id': 'S2', 'elements': [1, 4, 7, 13]}, {'id': 'S3', 'elements': [5, 8]}, {'id': 'S4', 'elements': [1, 4, 13]}, {'id': 'S5', 'elements': [5, 7, 8, 14]}, {'id': 'S6', 'elements': [3, 5, 6, 8, 11]}, {'id': 'S7', 'elements': [2, 5, 6, 7, 8, 9, 10, 11, 14]}, {'id': 'S8', 'elements': [3, 5, 7, 8]}, {'id': 'S9', 'elements': [3, 7, 9, 10, 12]}, {'id': 'S10', 'elements': [7, 9, 11, 12]}, {'id': 'S11', 'elements': [3, 6, 7, 9, 11, 12]}, {'id': 'S12', 'elements': [3, 10, 11, 12]}, {'id': 'S13', 'elements': [2, 5, 9, 13, 14]}], 'budget_k': 2}","['S1', 'S7']",28,markdown_table,1
MkC,MkC,"Someone at the museum has been asked to design a small, diverse display using only a limited number of artifacts, aiming to reflect as many different times and places as possible. The quality of any chosen lineup comes down to how many unique historical periods and cultures show up when those artifacts are counted — each new period or culture adds to the tally, while repeating the same one doesn’t help. Practical constraints are simple: every slot must be filled, each exhibit can be used once, and the cap on selections can’t be broken. Details about the available items and the selection limit follow below.

- **total_periods_and_cultures**: 16
- **total_artifacts_available**: 14
- **display_limit_k**: 2

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

Oh, and when you send back the chosen lineup, please use this simple JSON shape so the curator's spreadsheet can read it easily:

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

Here ""solution"" is just the list of artifacts you want in the mini-display — each entry is an artifact identifier from the instance input. This block is just a sketch of the shape I need, not the final selection itself.

Please be sure to use the exact identifiers from the instance input — don't rename anything 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': 16, 'num_sets': 14, 'density': 0.25892857142857145, 'sets': [{'id': 1, 'elements': [1, 4, 10, 11, 15]}, {'id': 2, 'elements': [2, 10, 16]}, {'id': 3, 'elements': [5, 9, 12, 14]}, {'id': 4, 'elements': [1, 4, 10, 15]}, {'id': 5, 'elements': [3, 5, 6, 12]}, {'id': 6, 'elements': [12, 15]}, {'id': 7, 'elements': [3, 5, 9, 12, 13]}, {'id': 8, 'elements': [1, 2, 4, 10]}, {'id': 9, 'elements': [1, 7, 8, 11, 15]}, {'id': 10, 'elements': [3, 5, 7, 9, 12, 14]}, {'id': 11, 'elements': [9, 13, 14]}, {'id': 12, 'elements': [3, 5, 6, 8, 9, 13, 14]}, {'id': 13, 'elements': [1, 4, 7, 15]}, {'id': 14, 'elements': [2, 16]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 1, 'v': 4}, {'u': 1, 'v': 15}, {'u': 10, 'v': 4}, {'u': 10, 'v': 16}, {'u': 12, 'v': 8}, {'u': 12, 'v': 14}, {'u': 8, 'v': 7}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 3, 'v': 14}, {'u': 15, 'v': 11}, {'u': 11, 'v': 7}, {'u': 14, 'v': 5}, {'u': 6, 'v': 5}, {'u': 2, 'v': 16}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0028.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0028.png'}","[1, 12]",12.0,"{'num_elements': 16, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'J', 'K', 'O']}, {'id': 'S2', 'elements': ['B', 'J', 'P']}, {'id': 'S3', 'elements': ['E', 'I', 'L', 'N']}, {'id': 'S4', 'elements': ['A', 'D', 'J', 'O']}, {'id': 'S5', 'elements': ['C', 'E', 'F', 'L']}, {'id': 'S6', 'elements': ['L', 'O']}, {'id': 'S7', 'elements': ['C', 'E', 'I', 'L', 'M']}, {'id': 'S8', 'elements': ['A', 'B', 'D', 'J']}, {'id': 'S9', 'elements': ['A', 'G', 'H', 'K', 'O']}, {'id': 'S10', 'elements': ['C', 'E', 'G', 'I', 'L', 'N']}, {'id': 'S11', 'elements': ['I', 'M', 'N']}, {'id': 'S12', 'elements': ['C', 'E', 'F', 'H', 'I', 'M', 'N']}, {'id': 'S13', 'elements': ['A', 'D', 'G', 'O']}, {'id': 'S14', 'elements': ['B', 'P']}], 'budget_k': 2}","['S1', 'S12']",29,markdown_table,names
MkC,MkC,"There’s a situation at the SOC: a limited number of deployments are available this quarter, and each security product on the shelf defends against a particular mix of threat types. The decision is which products to roll out so the count of different threat types defended against is as large as it can be — overlapping defenses only count once, and the deployment limit can’t be exceeded. The concrete options and the deployment limit follow below.

# total_threat_types=17
# total_security_products=17
# max_deployments=3
product_id,covered_threat_types
S1,A C J M Q
S2,B D E F H I J K L O P
S3,A C D M
S4,B C H I J Q
S5,B E F I O P
S6,B E F H K N O P
S7,F G H N
S8,B D E F G K
S9,D E I L
S10,A B C H J N Q
S11,B D F G H J L N Q
S12,D I K L P
S13,A C Q
S14,A J K Q
S15,B E F G O
S16,B E F K P
S17,A C D J K L M

Also, when you send the picks back, do it in this little JSON shape so it’s easy to parse:

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

Here, ""solution"" is just the list of product IDs you want to deploy this quarter — one ID per chosen product. The ""product_id"" bit is a placeholder for the real IDs from the instance; treat this as a sketch of the expected shape, not the actual answer.

Please be sure to use the exact identifiers shown 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': 17, 'num_sets': 17, 'density': 0.34256055363321797, 'sets': [{'id': 1, 'elements': [1, 3, 10, 13, 17]}, {'id': 2, 'elements': [2, 4, 5, 6, 8, 9, 10, 11, 12, 15, 16]}, {'id': 3, 'elements': [1, 3, 4, 13]}, {'id': 4, 'elements': [2, 3, 8, 9, 10, 17]}, {'id': 5, 'elements': [2, 5, 6, 9, 15, 16]}, {'id': 6, 'elements': [2, 5, 6, 8, 11, 14, 15, 16]}, {'id': 7, 'elements': [6, 7, 8, 14]}, {'id': 8, 'elements': [2, 4, 5, 6, 7, 11]}, {'id': 9, 'elements': [4, 5, 9, 12]}, {'id': 10, 'elements': [1, 2, 3, 8, 10, 14, 17]}, {'id': 11, 'elements': [2, 4, 6, 7, 8, 10, 12, 14, 17]}, {'id': 12, 'elements': [4, 9, 11, 12, 16]}, {'id': 13, 'elements': [1, 3, 17]}, {'id': 14, 'elements': [1, 10, 11, 17]}, {'id': 15, 'elements': [2, 5, 6, 7, 15]}, {'id': 16, 'elements': [2, 5, 6, 11, 16]}, {'id': 17, 'elements': [1, 3, 4, 10, 11, 12, 13]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 11, 'v': 2}, {'u': 11, 'v': 4}, {'u': 11, 'v': 8}, {'u': 11, 'v': 10}, {'u': 4, 'v': 12}, {'u': 4, 'v': 17}, {'u': 2, 'v': 6}, {'u': 2, 'v': 12}, {'u': 2, 'v': 16}, {'u': 1, 'v': 3}, {'u': 1, 'v': 10}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 14}, {'u': 3, 'v': 13}, {'u': 3, 'v': 17}, {'u': 7, 'v': 15}, {'u': 14, 'v': 10}, {'u': 16, 'v': 5}, {'u': 16, 'v': 9}, {'u': 15, 'v': 6}, {'u': 9, 'v': 12}, {'u': 6, 'v': 5}, {'u': 17, 'v': 10}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0029.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0029.png'}","[1, 2, 11]",17.0,"{'num_elements': 17, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': ['A', 'C', 'J', 'M', 'Q']}, {'id': 'S2', 'elements': ['B', 'D', 'E', 'F', 'H', 'I', 'J', 'K', 'L', 'O', 'P']}, {'id': 'S3', 'elements': ['A', 'C', 'D', 'M']}, {'id': 'S4', 'elements': ['B', 'C', 'H', 'I', 'J', 'Q']}, {'id': 'S5', 'elements': ['B', 'E', 'F', 'I', 'O', 'P']}, {'id': 'S6', 'elements': ['B', 'E', 'F', 'H', 'K', 'N', 'O', 'P']}, {'id': 'S7', 'elements': ['F', 'G', 'H', 'N']}, {'id': 'S8', 'elements': ['B', 'D', 'E', 'F', 'G', 'K']}, {'id': 'S9', 'elements': ['D', 'E', 'I', 'L']}, {'id': 'S10', 'elements': ['A', 'B', 'C', 'H', 'J', 'N', 'Q']}, {'id': 'S11', 'elements': ['B', 'D', 'F', 'G', 'H', 'J', 'L', 'N', 'Q']}, {'id': 'S12', 'elements': ['D', 'I', 'K', 'L', 'P']}, {'id': 'S13', 'elements': ['A', 'C', 'Q']}, {'id': 'S14', 'elements': ['A', 'J', 'K', 'Q']}, {'id': 'S15', 'elements': ['B', 'E', 'F', 'G', 'O']}, {'id': 'S16', 'elements': ['B', 'E', 'F', 'K', 'P']}, {'id': 'S17', 'elements': ['A', 'C', 'D', 'J', 'K', 'L', 'M']}], 'budget_k': 3}","['S1', 'S2', 'S11']",30,csv,names
MkC,MkC,"Picture this: an organizer with a short schedule and dozens of workshop proposals needs to choose which ones to run. The aim is to assemble a lineup that covers as many different attendees’ interests as possible — total up how many unique people would be happy with at least one of the selected workshops, and don’t double-count folks who’d be covered by multiple sessions. There are only so many session slots and no session gets repeated, so the selections have to fit those limits. The concrete list of workshop options and who cares about them is below.

# num_attendees=15
# num_workshop_options=13
# session_slots=2
workshop_id,interested_attendees
S1,0 6 7 11 12
S2,8 13
S3,2 12
S4,6 8
S5,10 13 14
S6,0 3 6 8
S7,0 7 8 12
S8,0 5 6 7 8 9 12
S9,2 8 12
S10,4 13 14
S11,0 1 7 8 11 12
S12,0 2 7
S13,4 11 13 14

Also, when you send back the chosen lineup, just toss it into a tiny JSON object like this so it’s easy to read by a program or a person:

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

Think of ""solution"" as the field that holds the list of selected workshop IDs. The ""workshop_id"" entry is just a placeholder showing the shape — in your actual reply you’ll replace those placeholders with the real IDs of the workshops you picked. This block is just a sketch of the expected shape, not the actual answer.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 13, 'density': 0.24615384615384617, 'sets': [{'id': 1, 'elements': [1, 7, 8, 12, 13]}, {'id': 2, 'elements': [9, 14]}, {'id': 3, 'elements': [3, 13]}, {'id': 4, 'elements': [7, 9]}, {'id': 5, 'elements': [11, 14, 15]}, {'id': 6, 'elements': [1, 4, 7, 9]}, {'id': 7, 'elements': [1, 8, 9, 13]}, {'id': 8, 'elements': [1, 6, 7, 8, 9, 10, 13]}, {'id': 9, 'elements': [3, 9, 13]}, {'id': 10, 'elements': [5, 14, 15]}, {'id': 11, 'elements': [1, 2, 8, 9, 12, 13]}, {'id': 12, 'elements': [1, 3, 8]}, {'id': 13, 'elements': [5, 12, 14, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 2, 'v': 12}, {'u': 2, 'v': 14}, {'u': 6, 'v': 8}, {'u': 3, 'v': 10}, {'u': 14, 'v': 5}, {'u': 11, 'v': 5}, {'u': 8, 'v': 9}, {'u': 9, 'v': 1}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 1, 'v': 4}, {'u': 1, 'v': 7}, {'u': 15, 'v': 5}, {'u': 10, 'v': 13}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0030.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0030.png'}","[8, 13]",11.0,"{'num_elements': 15, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 6, 7, 11, 12]}, {'id': 'S2', 'elements': [8, 13]}, {'id': 'S3', 'elements': [2, 12]}, {'id': 'S4', 'elements': [6, 8]}, {'id': 'S5', 'elements': [10, 13, 14]}, {'id': 'S6', 'elements': [0, 3, 6, 8]}, {'id': 'S7', 'elements': [0, 7, 8, 12]}, {'id': 'S8', 'elements': [0, 5, 6, 7, 8, 9, 12]}, {'id': 'S9', 'elements': [2, 8, 12]}, {'id': 'S10', 'elements': [4, 13, 14]}, {'id': 'S11', 'elements': [0, 1, 7, 8, 11, 12]}, {'id': 'S12', 'elements': [0, 2, 7]}, {'id': 'S13', 'elements': [4, 11, 13, 14]}], 'budget_k': 2}","['S8', 'S13']",31,csv,0
MkC,MkC,"Recently the team decided to spotlight only a few hotel amenities in an ad campaign, and now the question is which few to pick to appeal to the most kinds of travelers. The idea is to select a capped number of amenities and then see how many unique traveler types would be covered by those selections — only count each traveler type once, even if they’d like several of the amenities, and don’t pick more items than the cap. The detailed options and the exact selection limit can be found below.

- **total_traveler_profiles**: 13
- **total_amenities_available**: 11
- **max_amenities_to_advertise**: 2

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

When you send back your chosen amenities, please use this simple JSON layout so I can parse it easily.

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

""solution"" is the list of amenity identifiers you're picking for the ad — one entry per chosen amenity. This JSON is just a sketch of the shape I expect, not the actual answer; replace the placeholder(s) with the real amenity IDs from the instance.

Important: 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': 11, 'density': 0.2727272727272727, 'sets': [{'id': 1, 'elements': [1, 10]}, {'id': 2, 'elements': [2, 3, 8, 13]}, {'id': 3, 'elements': [2, 4, 6, 12]}, {'id': 4, 'elements': [1, 3, 4, 6, 10]}, {'id': 5, 'elements': [2, 3, 5, 6]}, {'id': 6, 'elements': [5, 6, 7, 10]}, {'id': 7, 'elements': [6, 7, 9]}, {'id': 8, 'elements': [2, 8, 13]}, {'id': 9, 'elements': [6, 10]}, {'id': 10, 'elements': [3, 11, 12]}, {'id': 11, 'elements': [3, 5, 6, 11, 12]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 9, 'v': 6}, {'u': 9, 'v': 7}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 3, 'v': 6}, {'u': 3, 'v': 12}, {'u': 12, 'v': 11}, {'u': 1, 'v': 4}, {'u': 10, 'v': 4}, {'u': 8, 'v': 13}, {'u': 2, 'v': 13}, {'u': 4, 'v': 6}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0031.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0031.png'}","[2, 4]",8.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [1, 10]}, {'id': 'S2', 'elements': [2, 3, 8, 13]}, {'id': 'S3', 'elements': [2, 4, 6, 12]}, {'id': 'S4', 'elements': [1, 3, 4, 6, 10]}, {'id': 'S5', 'elements': [2, 3, 5, 6]}, {'id': 'S6', 'elements': [5, 6, 7, 10]}, {'id': 'S7', 'elements': [6, 7, 9]}, {'id': 'S8', 'elements': [2, 8, 13]}, {'id': 'S9', 'elements': [6, 10]}, {'id': 'S10', 'elements': [3, 11, 12]}, {'id': 'S11', 'elements': [3, 5, 6, 11, 12]}], 'budget_k': 2}","['S2', 'S4']",32,markdown_table,1
MkC,MkC,"We have a handful of clinic slots to fill, and the job is to pick which sites to open so the greatest number of distinct neighborhoods get access to vaccines; overlapping coverage doesn’t multiply credit, so the count is of unique neighborhoods reached, and the total number of clinics can’t exceed the set limit. The concrete location options and limits are listed below.

{
  ""total_neighborhoods"": 18,
  ""total_candidate_sites"": 15,
  ""sets"": [
    {
      ""site_id"": ""S1"",
      ""covered_neighborhoods"": [
        1,
        2,
        3,
        10,
        12,
        17
      ]
    },
    {
      ""site_id"": ""S2"",
      ""covered_neighborhoods"": [
        1,
        2,
        3,
        5,
        8,
        9
      ]
    },
    {
      ""site_id"": ""S3"",
      ""covered_neighborhoods"": [
        3,
        8,
        12,
        13
      ]
    },
    {
      ""site_id"": ""S4"",
      ""covered_neighborhoods"": [
        3,
        4,
        8,
        13
      ]
    },
    {
      ""site_id"": ""S5"",
      ""covered_neighborhoods"": [
        6,
        7,
        10,
        15
      ]
    },
    {
      ""site_id"": ""S6"",
      ""covered_neighborhoods"": [
        6,
        7,
        10,
        12
      ]
    },
    {
      ""site_id"": ""S7"",
      ""covered_neighborhoods"": [
        1,
        3,
        4,
        13
      ]
    },
    {
      ""site_id"": ""S8"",
      ""covered_neighborhoods"": [
        1,
        6,
        7,
        10,
        17
      ]
    },
    {
      ""site_id"": ""S9"",
      ""covered_neighborhoods"": [
        0,
        11,
        17
      ]
    },
    {
      ""site_id"": ""S10"",
      ""covered_neighborhoods"": [
        1,
        7,
        10,
        12,
        14,
        17
      ]
    },
    {
      ""site_id"": ""S11"",
      ""covered_neighborhoods"": [
        3,
        4,
        16
      ]
    },
    {
      ""site_id"": ""S12"",
      ""covered_neighborhoods"": [
        0,
        14,
        17
      ]
    },
    {
      ""site_id"": ""S13"",
      ""covered_neighborhoods"": [
        6,
        15
      ]
    },
    {
      ""site_id"": ""S14"",
      ""covered_neighborhoods"": [
        13,
        16
      ]
    },
    {
      ""site_id"": ""S15"",
      ""covered_neighborhoods"": [
        0,
        10,
        11,
        12,
        14,
        17
      ]
    }
  ],
  ""clinic_slot_limit"": 3
}

Also, when you send back the chosen sites, please stick them into a tiny JSON object like this so it's easy to read and parse:

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

Think of ""solution"" as just the list of sites you want to open — each entry should be the exact site identifier from the instance (this block is only a sketch of the shape, not the actual answer). Use the same identifiers shown in the problem input; don’t rename them or invent new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 18, 'num_sets': 15, 'density': 0.22962962962962963, 'sets': [{'id': 1, 'elements': [2, 3, 4, 11, 13, 18]}, {'id': 2, 'elements': [2, 3, 4, 6, 9, 10]}, {'id': 3, 'elements': [4, 9, 13, 14]}, {'id': 4, 'elements': [4, 5, 9, 14]}, {'id': 5, 'elements': [7, 8, 11, 16]}, {'id': 6, 'elements': [7, 8, 11, 13]}, {'id': 7, 'elements': [2, 4, 5, 14]}, {'id': 8, 'elements': [2, 7, 8, 11, 18]}, {'id': 9, 'elements': [1, 12, 18]}, {'id': 10, 'elements': [2, 8, 11, 13, 15, 18]}, {'id': 11, 'elements': [4, 5, 17]}, {'id': 12, 'elements': [1, 15, 18]}, {'id': 13, 'elements': [7, 16]}, {'id': 14, 'elements': [14, 17]}, {'id': 15, 'elements': [1, 11, 12, 13, 15, 18]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 9}, {'u': 2, 'v': 13}, {'u': 8, 'v': 11}, {'u': 18, 'v': 13}, {'u': 18, 'v': 15}, {'u': 3, 'v': 6}, {'u': 9, 'v': 5}, {'u': 9, 'v': 14}, {'u': 6, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 16}, {'u': 13, 'v': 11}, {'u': 14, 'v': 17}, {'u': 1, 'v': 15}, {'u': 15, 'v': 12}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0032.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0032.png'}","[2, 5, 15]",15.0,"{'num_elements': 18, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [1, 2, 3, 10, 12, 17]}, {'id': 'S2', 'elements': [1, 2, 3, 5, 8, 9]}, {'id': 'S3', 'elements': [3, 8, 12, 13]}, {'id': 'S4', 'elements': [3, 4, 8, 13]}, {'id': 'S5', 'elements': [6, 7, 10, 15]}, {'id': 'S6', 'elements': [6, 7, 10, 12]}, {'id': 'S7', 'elements': [1, 3, 4, 13]}, {'id': 'S8', 'elements': [1, 6, 7, 10, 17]}, {'id': 'S9', 'elements': [0, 11, 17]}, {'id': 'S10', 'elements': [1, 7, 10, 12, 14, 17]}, {'id': 'S11', 'elements': [3, 4, 16]}, {'id': 'S12', 'elements': [0, 14, 17]}, {'id': 'S13', 'elements': [6, 15]}, {'id': 'S14', 'elements': [13, 16]}, {'id': 'S15', 'elements': [0, 10, 11, 12, 14, 17]}], 'budget_k': 3}","['S2', 'S5', 'S15']",33,json,0
MkC,MkC,"At school, the plan is to assign only a handful of homework types but still make sure the students practice lots of different skills. That means choosing a limited number of formats, noting every learning objective each chosen format covers, crossing off any repeats so each objective is counted a single time, and then counting the unique objectives — the selection with the greatest count wins. The same format can’t be used more than once to pad the count, and the specific options and limits are given below.

# total_learning_objectives=16
# available_formats_count=15
# max_formats_to_assign=3
format_id,covered_objectives
S1,3 4 5 10 13 14
S2,1 3 15
S3,1 2 14 15
S4,0 1 2 10 15
S5,0 13 14
S6,0 2 5 6 7 9
S7,0 6 7 8 9
S8,5 6 7 9
S9,6 8 9 11
S10,5 6 8 9 13
S11,0 2 3 10 12
S12,8 13 14
S13,2 10 12
S14,0 8 9 11 14
S15,0 2 4 8 11 13 14

If you want to send the chosen formats back in a tidy way, a little JSON sketch like this is perfect:

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

Here ""solution"" is just the list where you put the IDs of the homework formats you picked (one ID per chosen format). Think of it like filling out a short form — the array holds the formats you want included. This is only the expected shape of the reply, not the actual answer.

Please use the exact identifiers from the instance input — don't rename them or invent new labels.  
Valid identifiers look like:
- plain numbers such as “1” or “23”
- single capital letters like “A” or “B”
- 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.2833333333333333, 'sets': [{'id': 1, 'elements': [4, 5, 6, 11, 14, 15]}, {'id': 2, 'elements': [2, 4, 16]}, {'id': 3, 'elements': [2, 3, 15, 16]}, {'id': 4, 'elements': [1, 2, 3, 11, 16]}, {'id': 5, 'elements': [1, 14, 15]}, {'id': 6, 'elements': [1, 3, 6, 7, 8, 10]}, {'id': 7, 'elements': [1, 7, 8, 9, 10]}, {'id': 8, 'elements': [6, 7, 8, 10]}, {'id': 9, 'elements': [7, 9, 10, 12]}, {'id': 10, 'elements': [6, 7, 9, 10, 14]}, {'id': 11, 'elements': [1, 3, 4, 11, 13]}, {'id': 12, 'elements': [9, 14, 15]}, {'id': 13, 'elements': [3, 11, 13]}, {'id': 14, 'elements': [1, 9, 10, 12, 15]}, {'id': 15, 'elements': [1, 3, 5, 9, 12, 14, 15]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 7}, {'u': 13, 'v': 11}, {'u': 7, 'v': 8}, {'u': 7, 'v': 10}, {'u': 11, 'v': 3}, {'u': 10, 'v': 9}, {'u': 12, 'v': 14}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 4, 'v': 2}, {'u': 4, 'v': 16}, {'u': 1, 'v': 15}, {'u': 14, 'v': 9}, {'u': 14, 'v': 15}, {'u': 5, 'v': 15}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0033.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0033.png'}","[6, 11, 15]",14.0,"{'num_elements': 16, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [3, 4, 5, 10, 13, 14]}, {'id': 'S2', 'elements': [1, 3, 15]}, {'id': 'S3', 'elements': [1, 2, 14, 15]}, {'id': 'S4', 'elements': [0, 1, 2, 10, 15]}, {'id': 'S5', 'elements': [0, 13, 14]}, {'id': 'S6', 'elements': [0, 2, 5, 6, 7, 9]}, {'id': 'S7', 'elements': [0, 6, 7, 8, 9]}, {'id': 'S8', 'elements': [5, 6, 7, 9]}, {'id': 'S9', 'elements': [6, 8, 9, 11]}, {'id': 'S10', 'elements': [5, 6, 8, 9, 13]}, {'id': 'S11', 'elements': [0, 2, 3, 10, 12]}, {'id': 'S12', 'elements': [8, 13, 14]}, {'id': 'S13', 'elements': [2, 10, 12]}, {'id': 'S14', 'elements': [0, 8, 9, 11, 14]}, {'id': 'S15', 'elements': [0, 2, 4, 8, 11, 13, 14]}], 'budget_k': 3}","['S6', 'S11', 'S15']",34,csv,0
MkC,MkC,"As host, the plan is to choose a small batch of episode themes so the series touches the widest possible range of listener interests, even though only a few shows can be scheduled. The choice is which themes to slot in; the best lineup is the one whose combined topics cover the most distinct interests. Practically, that means taking the chosen themes, listing every listener interest they address, and counting each unique interest once—overlaps don’t add extra points. The episode count is limited and repeated topics aren’t helpful, so picks must respect that. The specific themes and interest breakdowns are shown below.

# total_listener_interests=14
# total_themes_available=14
# max_episodes_allowed=2
theme_id,covered_interest_ids
S1,A F I K
S2,B G K
S3,C D F H
S4,C D G H J
S5,C E F K
S6,A C E F H I K M
S7,B I J
S8,C G H M
S9,B F G I J K
S10,D I J
S11,A B C G I
S12,L N
S13,C F H L M N
S14,C L N

Also, if you prefer to send your pick list in a machine-friendly way, a tiny JSON snippet like this works great—just a relaxed list of the theme IDs you picked:

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

Here ""solution"" is simply the list of episode theme identifiers you want to schedule — think of it like ticking boxes on a form. This JSON is just a sketch of the shape I expect, not your final answer.

Please use the exact identifiers from the instance input when you fill that list — 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': 14, 'num_sets': 14, 'density': 0.30612244897959184, 'sets': [{'id': 1, 'elements': [1, 6, 9, 11]}, {'id': 2, 'elements': [2, 7, 11]}, {'id': 3, 'elements': [3, 4, 6, 8]}, {'id': 4, 'elements': [3, 4, 7, 8, 10]}, {'id': 5, 'elements': [3, 5, 6, 11]}, {'id': 6, 'elements': [1, 3, 5, 6, 8, 9, 11, 13]}, {'id': 7, 'elements': [2, 9, 10]}, {'id': 8, 'elements': [3, 7, 8, 13]}, {'id': 9, 'elements': [2, 6, 7, 9, 10, 11]}, {'id': 10, 'elements': [4, 9, 10]}, {'id': 11, 'elements': [1, 2, 3, 7, 9]}, {'id': 12, 'elements': [12, 14]}, {'id': 13, 'elements': [3, 6, 8, 12, 13, 14]}, {'id': 14, 'elements': [3, 12, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 13, 'v': 3}, {'u': 13, 'v': 14}, {'u': 14, 'v': 12}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 6, 'v': 3}, {'u': 6, 'v': 5}, {'u': 6, 'v': 11}, {'u': 2, 'v': 9}, {'u': 9, 'v': 7}, {'u': 9, 'v': 11}, {'u': 7, 'v': 4}, {'u': 7, 'v': 10}, {'u': 1, 'v': 11}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0034.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0034.png'}","[9, 13]",11.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'F', 'I', 'K']}, {'id': 'S2', 'elements': ['B', 'G', 'K']}, {'id': 'S3', 'elements': ['C', 'D', 'F', 'H']}, {'id': 'S4', 'elements': ['C', 'D', 'G', 'H', 'J']}, {'id': 'S5', 'elements': ['C', 'E', 'F', 'K']}, {'id': 'S6', 'elements': ['A', 'C', 'E', 'F', 'H', 'I', 'K', 'M']}, {'id': 'S7', 'elements': ['B', 'I', 'J']}, {'id': 'S8', 'elements': ['C', 'G', 'H', 'M']}, {'id': 'S9', 'elements': ['B', 'F', 'G', 'I', 'J', 'K']}, {'id': 'S10', 'elements': ['D', 'I', 'J']}, {'id': 'S11', 'elements': ['A', 'B', 'C', 'G', 'I']}, {'id': 'S12', 'elements': ['L', 'N']}, {'id': 'S13', 'elements': ['C', 'F', 'H', 'L', 'M', 'N']}, {'id': 'S14', 'elements': ['C', 'L', 'N']}], 'budget_k': 2}","['S9', 'S13']",35,csv,names
MkC,MkC,"I’m juggling a new outdoor campaign and have to pick a handful of billboard spots so the ads pop up on as many different commuter routes and audience pockets as possible. The choice is which exact locations to buy — there’s a strict limit on how many sites I can use — and a better choice is one that results in the largest number of distinct routes and audience groups seeing the ads. To figure out how well a selection works, add up every unique route and audience reached by those chosen billboards (don’t double-count a route that shows up from two signs). Each site can only be picked once and the total number of sites can’t exceed the cap. The specific site options and their route/audience details are listed below.

- **total_unique_routes_and_audiences**: 14
- **total_billboard_sites_available**: 14
- **site_selection_limit**: 2

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

You can just return the chosen billboard locations in a tiny JSON object — nothing fancy. For this story it looks like:

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

This means ""solution"" should be an array of the site identifiers you pick (one entry per chosen billboard). The JSON above is just the shape I expect — a quick sketch, not the actual selection.

Please make sure every identifier you use matches exactly what's in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 14, 'num_sets': 14, 'density': 0.28061224489795916, 'sets': [{'id': 1, 'elements': [1, 2, 6, 9, 13]}, {'id': 2, 'elements': [1, 2, 4, 7]}, {'id': 3, 'elements': [2, 3, 4]}, {'id': 4, 'elements': [2, 4, 7, 8, 12]}, {'id': 5, 'elements': [1, 5, 8, 9]}, {'id': 6, 'elements': [1, 5, 6, 8, 9]}, {'id': 7, 'elements': [2, 7]}, {'id': 8, 'elements': [1, 3, 4, 5, 8, 10, 11, 13]}, {'id': 9, 'elements': [1, 5]}, {'id': 10, 'elements': [10, 14]}, {'id': 11, 'elements': [8, 10, 11, 14]}, {'id': 12, 'elements': [4, 7, 12]}, {'id': 13, 'elements': [5, 6, 8, 13]}, {'id': 14, 'elements': [1, 10, 11, 14]}], 'graph': {'num_nodes': 14, 'edges': [{'u': 12, 'v': 3}, {'u': 12, 'v': 4}, {'u': 6, 'v': 1}, {'u': 6, 'v': 9}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 14}, {'u': 9, 'v': 5}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 3, 'v': 2}, {'u': 7, 'v': 4}, {'u': 13, 'v': 1}, {'u': 5, 'v': 1}, {'u': 2, 'v': 4}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0035.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0035.png'}","[4, 8]",11.0,"{'num_elements': 14, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': ['A', 'B', 'F', 'I', 'M']}, {'id': 'S2', 'elements': ['A', 'B', 'D', 'G']}, {'id': 'S3', 'elements': ['B', 'C', 'D']}, {'id': 'S4', 'elements': ['B', 'D', 'G', 'H', 'L']}, {'id': 'S5', 'elements': ['A', 'E', 'H', 'I']}, {'id': 'S6', 'elements': ['A', 'E', 'F', 'H', 'I']}, {'id': 'S7', 'elements': ['B', 'G']}, {'id': 'S8', 'elements': ['A', 'C', 'D', 'E', 'H', 'J', 'K', 'M']}, {'id': 'S9', 'elements': ['A', 'E']}, {'id': 'S10', 'elements': ['J', 'N']}, {'id': 'S11', 'elements': ['H', 'J', 'K', 'N']}, {'id': 'S12', 'elements': ['D', 'G', 'L']}, {'id': 'S13', 'elements': ['E', 'F', 'H', 'M']}, {'id': 'S14', 'elements': ['A', 'J', 'K', 'N']}], 'budget_k': 2}","['S4', 'S8']",36,markdown_table,names
MkC,MkC,"At the start of service the kitchen must pick a compact specials roster of featured ingredients so that as many diners as possible find something they want. The decision is which handful of ingredients to spotlight; a stronger selection is one that collectively satisfies more distinct taste preferences. Measure that by tallying every different preference met by the chosen ingredients and using that count as the measure — repeated coverage of the same preference doesn’t add extra, and the number of featured ingredients is capped. The concrete instance details are below.

{
  ""total_distinct_preferences"": 15,
  ""total_available_ingredients"": 14,
  ""sets"": [
    {
      ""ingredient_id"": ""S1"",
      ""satisfied_preferences"": [
        1,
        8,
        15
      ]
    },
    {
      ""ingredient_id"": ""S2"",
      ""satisfied_preferences"": [
        3,
        11
      ]
    },
    {
      ""ingredient_id"": ""S3"",
      ""satisfied_preferences"": [
        2,
        3,
        6,
        7,
        13,
        14
      ]
    },
    {
      ""ingredient_id"": ""S4"",
      ""satisfied_preferences"": [
        4,
        7
      ]
    },
    {
      ""ingredient_id"": ""S5"",
      ""satisfied_preferences"": [
        5,
        9,
        12
      ]
    },
    {
      ""ingredient_id"": ""S6"",
      ""satisfied_preferences"": [
        3,
        9,
        12
      ]
    },
    {
      ""ingredient_id"": ""S7"",
      ""satisfied_preferences"": [
        4,
        14,
        15
      ]
    },
    {
      ""ingredient_id"": ""S8"",
      ""satisfied_preferences"": [
        8,
        14,
        15
      ]
    },
    {
      ""ingredient_id"": ""S9"",
      ""satisfied_preferences"": [
        5,
        6,
        9,
        13
      ]
    },
    {
      ""ingredient_id"": ""S10"",
      ""satisfied_preferences"": [
        2,
        11,
        14
      ]
    },
    {
      ""ingredient_id"": ""S11"",
      ""satisfied_preferences"": [
        5,
        6,
        9,
        12
      ]
    },
    {
      ""ingredient_id"": ""S12"",
      ""satisfied_preferences"": [
        3,
        6,
        9,
        11,
        13,
        14
      ]
    },
    {
      ""ingredient_id"": ""S13"",
      ""satisfied_preferences"": [
        1,
        3,
        8,
        10,
        11,
        13,
        14,
        15
      ]
    },
    {
      ""ingredient_id"": ""S14"",
      ""satisfied_preferences"": [
        1,
        3,
        7,
        8,
        15
      ]
    }
  ],
  ""max_featured_ingredients"": 2
}

Oh — and when you give the final pick, please put it in a tiny JSON snippet like this so it's easy to read and parse:

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

Here ""solution"" is just the list of ingredient IDs we're featuring for the specials — one string per ingredient. Think of it like ticking off which ingredients go on the board; the placeholder ""ingredient_id"" stands in for whatever exact IDs the instance uses. This block is just a sketch of the shape I need, not the actual answer.

Please make sure you use the ingredient identifiers exactly as they appear in the instance input — no renaming and no invented labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 14, 'density': 0.2619047619047619, 'sets': [{'id': 1, 'elements': [1, 8, 15]}, {'id': 2, 'elements': [3, 11]}, {'id': 3, 'elements': [2, 3, 6, 7, 13, 14]}, {'id': 4, 'elements': [4, 7]}, {'id': 5, 'elements': [5, 9, 12]}, {'id': 6, 'elements': [3, 9, 12]}, {'id': 7, 'elements': [4, 14, 15]}, {'id': 8, 'elements': [8, 14, 15]}, {'id': 9, 'elements': [5, 6, 9, 13]}, {'id': 10, 'elements': [2, 11, 14]}, {'id': 11, 'elements': [5, 6, 9, 12]}, {'id': 12, 'elements': [3, 6, 9, 11, 13, 14]}, {'id': 13, 'elements': [1, 3, 8, 10, 11, 13, 14, 15]}, {'id': 14, 'elements': [1, 3, 7, 8, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 3, 'v': 11}, {'u': 3, 'v': 13}, {'u': 3, 'v': 14}, {'u': 11, 'v': 2}, {'u': 5, 'v': 12}, {'u': 6, 'v': 9}, {'u': 6, 'v': 13}, {'u': 9, 'v': 12}, {'u': 10, 'v': 4}, {'u': 10, 'v': 7}, {'u': 15, 'v': 1}, {'u': 15, 'v': 8}, {'u': 15, 'v': 14}, {'u': 14, 'v': 7}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0036.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0036.png'}","[11, 13]",12.0,"{'num_elements': 15, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [1, 8, 15]}, {'id': 'S2', 'elements': [3, 11]}, {'id': 'S3', 'elements': [2, 3, 6, 7, 13, 14]}, {'id': 'S4', 'elements': [4, 7]}, {'id': 'S5', 'elements': [5, 9, 12]}, {'id': 'S6', 'elements': [3, 9, 12]}, {'id': 'S7', 'elements': [4, 14, 15]}, {'id': 'S8', 'elements': [8, 14, 15]}, {'id': 'S9', 'elements': [5, 6, 9, 13]}, {'id': 'S10', 'elements': [2, 11, 14]}, {'id': 'S11', 'elements': [5, 6, 9, 12]}, {'id': 'S12', 'elements': [3, 6, 9, 11, 13, 14]}, {'id': 'S13', 'elements': [1, 3, 8, 10, 11, 13, 14, 15]}, {'id': 'S14', 'elements': [1, 3, 7, 8, 15]}], 'budget_k': 2}","['S11', 'S13']",37,json,1
MkC,MkC,"After months of juggling requests, the coordinator needs to commit to a tiny set of volunteer roles to handle community needs. The decision is which roles to lock in so the group addresses the most different needs possible. To compare options, put together every need covered by the chosen roles, cross off duplicates so each need is only counted once, and respect the cap on how many roles can be selected. The concrete roles and needs are listed below.

- **total_needs**: 13
- **total_roles_available**: 13
- **max_roles_to_recruit**: 2

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

Also, when you send back which roles you want to lock in, please follow this simple JSON layout so it's easy to check automatically:

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

Here ""solution"" is the array of the chosen role identifiers. Replace each ""role_id"" with the exact identifier for a role from the instance (this block is just a sketch of the shape I want, not the actual answer). Use the identifiers exactly as they appear in the problem input — do not rename them or invent new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 13, 'density': 0.33136094674556216, 'sets': [{'id': 1, 'elements': [1, 2, 8, 12]}, {'id': 2, 'elements': [1, 12]}, {'id': 3, 'elements': [5, 10]}, {'id': 4, 'elements': [4, 7, 11]}, {'id': 5, 'elements': [3, 4, 7, 9, 10, 11, 12]}, {'id': 6, 'elements': [4, 5, 6, 9, 11]}, {'id': 7, 'elements': [4, 5, 7, 10]}, {'id': 8, 'elements': [2, 8, 10, 12, 13]}, {'id': 9, 'elements': [5, 6, 9, 11]}, {'id': 10, 'elements': [3, 4, 5, 8, 10, 12, 13]}, {'id': 11, 'elements': [4, 6, 9, 11]}, {'id': 12, 'elements': [1, 3, 5, 8, 13]}, {'id': 13, 'elements': [8, 10, 12, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 10, 'v': 3}, {'u': 10, 'v': 5}, {'u': 10, 'v': 12}, {'u': 11, 'v': 4}, {'u': 1, 'v': 8}, {'u': 2, 'v': 8}, {'u': 12, 'v': 8}, {'u': 12, 'v': 13}, {'u': 9, 'v': 4}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 5, 'v': 7}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0037.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0037.png'}","[5, 12]",11.0,"{'num_elements': 13, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [0, 1, 7, 11]}, {'id': 'S2', 'elements': [0, 11]}, {'id': 'S3', 'elements': [4, 9]}, {'id': 'S4', 'elements': [3, 6, 10]}, {'id': 'S5', 'elements': [2, 3, 6, 8, 9, 10, 11]}, {'id': 'S6', 'elements': [3, 4, 5, 8, 10]}, {'id': 'S7', 'elements': [3, 4, 6, 9]}, {'id': 'S8', 'elements': [1, 7, 9, 11, 12]}, {'id': 'S9', 'elements': [4, 5, 8, 10]}, {'id': 'S10', 'elements': [2, 3, 4, 7, 9, 11, 12]}, {'id': 'S11', 'elements': [3, 5, 8, 10]}, {'id': 'S12', 'elements': [0, 2, 4, 7, 12]}, {'id': 'S13', 'elements': [7, 9, 11, 12]}], 'budget_k': 2}","['S5', 'S12']",38,markdown_table,0
MkC,MkC,"Recently the roadmap got trimmed and only a few feature slots remain, so the product manager has to be picky. The aim is to fill those slots with features that, together, address the highest number of different user complaints — more distinct fixes beat overlap. You measure a choice by counting unique complaints fixed by the chosen features (if two features both touch the same complaint it still counts as one), and you must stay within the limited number of features allowed. The detailed instance information is shown below.

- **total_complaints**: 13
- **total_features**: 12
- **feature_slots**: 2

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

Oh, and when you send back the chosen features, please use a tiny JSON snippet like this so it's easy to read:

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

""solution"" is just the list of feature IDs you want to pick for the remaining roadmap slots — each entry is one feature (use the exact ID from the instance). This is only a sketch of the expected shape, not the actual answer.

Also, 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': 13, 'num_sets': 12, 'density': 0.27564102564102566, 'sets': [{'id': 1, 'elements': [1, 3, 8]}, {'id': 2, 'elements': [2, 12]}, {'id': 3, 'elements': [1, 4]}, {'id': 4, 'elements': [1, 2, 4, 9]}, {'id': 5, 'elements': [5, 7, 10, 13]}, {'id': 6, 'elements': [5, 6, 7, 10, 13]}, {'id': 7, 'elements': [5, 6, 7, 13]}, {'id': 8, 'elements': [1, 3, 4, 8]}, {'id': 9, 'elements': [4, 5, 9, 10, 11]}, {'id': 10, 'elements': [5, 9]}, {'id': 11, 'elements': [3, 4, 10, 11, 12]}, {'id': 12, 'elements': [2, 3, 11]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 3, 'v': 8}, {'u': 5, 'v': 6}, {'u': 5, 'v': 10}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 6, 'v': 7}, {'u': 6, 'v': 13}, {'u': 12, 'v': 2}, {'u': 12, 'v': 4}, {'u': 4, 'v': 11}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0038.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0038.png'}","[6, 8]",9.0,"{'num_elements': 13, 'num_sets': 12, 'sets': [{'id': 'S1', 'elements': [0, 2, 7]}, {'id': 'S2', 'elements': [1, 11]}, {'id': 'S3', 'elements': [0, 3]}, {'id': 'S4', 'elements': [0, 1, 3, 8]}, {'id': 'S5', 'elements': [4, 6, 9, 12]}, {'id': 'S6', 'elements': [4, 5, 6, 9, 12]}, {'id': 'S7', 'elements': [4, 5, 6, 12]}, {'id': 'S8', 'elements': [0, 2, 3, 7]}, {'id': 'S9', 'elements': [3, 4, 8, 9, 10]}, {'id': 'S10', 'elements': [4, 8]}, {'id': 'S11', 'elements': [2, 3, 9, 10, 11]}, {'id': 'S12', 'elements': [1, 2, 10]}], 'budget_k': 2}","['S6', 'S8']",39,markdown_table,0
MkC,MkC,"Picture this: a small number of tasting tables, a busy weekend, and a manager trying to make those tables show off as many different product kinds as possible. The sensible move is to choose the limited number of stations whose combined category list is the longest — to compare options, merge the categories from the chosen demos and count how many unique categories appear (don’t double-count repeats). The selection must not exceed the available demo slots, and the detailed list of stations and categories is provided below.

There are 14 available demo stations; you may run up to 2 at once, aiming to cover as many of the 16 distinct categories as possible.
Station S1 exposes shoppers to: 1 5 14
Station S2 exposes shoppers to: 2 3 6 7 14
Station S3 exposes shoppers to: 2 3 6
Station S4 exposes shoppers to: 1 5 6 9 10 11 13 14
Station S5 exposes shoppers to: 3 4 5 6 7 11 13 14
Station S6 exposes shoppers to: 2 6 7 8 11 14
Station S7 exposes shoppers to: 7 8 11 13 14 16
Station S8 exposes shoppers to: 1 10 14
Station S9 exposes shoppers to: 5 10
Station S10 exposes shoppers to: 5 7 8 11 14 15 16
Station S11 exposes shoppers to: 5 6 13 14 16
Station S12 exposes shoppers to: 2 5 6 7 8 9 11 14 16
Station S13 exposes shoppers to: 11 12 15 16
Station S14 exposes shoppers to: 11 12 15
Scan the list and select up to 2 stations whose merged categories cover the most unique categories toward the 16 total.

Also, to keep things tidy when you send back your pick, please use this little JSON shape so I can read it easily:

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

Here ""solution"" is just the list of tasting tables you want to set up — each entry is the identifier for a table from the instance. This snippet is only a sketch of the shape I expect, not your final answer; when you fill it in, replace the placeholder entries with the actual IDs from the instance.

- 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”.""

Please use the identifiers exactly as they appear in the input — no renaming and no inventing new labels.","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 16, 'num_sets': 14, 'density': 0.32142857142857145, 'sets': [{'id': 1, 'elements': [1, 5, 14]}, {'id': 2, 'elements': [2, 3, 6, 7, 14]}, {'id': 3, 'elements': [2, 3, 6]}, {'id': 4, 'elements': [1, 5, 6, 9, 10, 11, 13, 14]}, {'id': 5, 'elements': [3, 4, 5, 6, 7, 11, 13, 14]}, {'id': 6, 'elements': [2, 6, 7, 8, 11, 14]}, {'id': 7, 'elements': [7, 8, 11, 13, 14, 16]}, {'id': 8, 'elements': [1, 10, 14]}, {'id': 9, 'elements': [5, 10]}, {'id': 10, 'elements': [5, 7, 8, 11, 14, 15, 16]}, {'id': 11, 'elements': [5, 6, 13, 14, 16]}, {'id': 12, 'elements': [2, 5, 6, 7, 8, 9, 11, 14, 16]}, {'id': 13, 'elements': [11, 12, 15, 16]}, {'id': 14, 'elements': [11, 12, 15]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 10, 'v': 9}, {'u': 15, 'v': 16}, {'u': 4, 'v': 2}, {'u': 2, 'v': 3}, {'u': 2, 'v': 6}, {'u': 11, 'v': 8}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 11, 'v': 16}, {'u': 12, 'v': 16}, {'u': 13, 'v': 14}, {'u': 14, 'v': 5}, {'u': 14, 'v': 6}, {'u': 9, 'v': 5}, {'u': 5, 'v': 1}, {'u': 6, 'v': 7}, {'u': 7, 'v': 8}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0039.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0039.png'}","[4, 12]",12.0,"{'num_elements': 16, 'num_sets': 14, 'sets': [{'id': 'S1', 'elements': [1, 5, 14]}, {'id': 'S2', 'elements': [2, 3, 6, 7, 14]}, {'id': 'S3', 'elements': [2, 3, 6]}, {'id': 'S4', 'elements': [1, 5, 6, 9, 10, 11, 13, 14]}, {'id': 'S5', 'elements': [3, 4, 5, 6, 7, 11, 13, 14]}, {'id': 'S6', 'elements': [2, 6, 7, 8, 11, 14]}, {'id': 'S7', 'elements': [7, 8, 11, 13, 14, 16]}, {'id': 'S8', 'elements': [1, 10, 14]}, {'id': 'S9', 'elements': [5, 10]}, {'id': 'S10', 'elements': [5, 7, 8, 11, 14, 15, 16]}, {'id': 'S11', 'elements': [5, 6, 13, 14, 16]}, {'id': 'S12', 'elements': [2, 5, 6, 7, 8, 9, 11, 14, 16]}, {'id': 'S13', 'elements': [11, 12, 15, 16]}, {'id': 'S14', 'elements': [11, 12, 15]}], 'budget_k': 2}","['S4', 'S12']",40,nl,1
MkC,MkC,"Someone in the outreach team suggested we only post on a few neighborhood boards to save time, which means deciding which ones to use. The best choice is the set of boards that together touch the most different neighborhoods; measure that by counting distinct neighborhoods covered (if a neighborhood shows up on more than one board it still only counts once), and don’t go over the number of boards we’re allowed to post on. The full list of boards and which neighborhoods they link to appears below.

{
  ""total_neighborhoods"": 13,
  ""total_bulletin_boards"": 10,
  ""sets"": [
    {
      ""board_id"": ""S1"",
      ""board_neighborhoods"": [
        0,
        7,
        10
      ]
    },
    {
      ""board_id"": ""S2"",
      ""board_neighborhoods"": [
        6,
        9,
        10,
        11
      ]
    },
    {
      ""board_id"": ""S3"",
      ""board_neighborhoods"": [
        1,
        2,
        3,
        10
      ]
    },
    {
      ""board_id"": ""S4"",
      ""board_neighborhoods"": [
        4,
        5
      ]
    },
    {
      ""board_id"": ""S5"",
      ""board_neighborhoods"": [
        0,
        1,
        3,
        4,
        6,
        8,
        9,
        10
      ]
    },
    {
      ""board_id"": ""S6"",
      ""board_neighborhoods"": [
        1,
        3,
        4,
        5,
        6,
        10
      ]
    },
    {
      ""board_id"": ""S7"",
      ""board_neighborhoods"": [
        7,
        9,
        11
      ]
    },
    {
      ""board_id"": ""S8"",
      ""board_neighborhoods"": [
        0,
        5,
        8,
        9,
        10,
        11,
        12
      ]
    },
    {
      ""board_id"": ""S9"",
      ""board_neighborhoods"": [
        1,
        3,
        5,
        9
      ]
    },
    {
      ""board_id"": ""S10"",
      ""board_neighborhoods"": [
        1,
        7,
        9,
        10,
        11
      ]
    }
  ],
  ""max_boards_to_post"": 2
}

Also, when you send back the chosen boards, it'd be great to stick them in a tiny JSON snippet so it's easy to read and check. Something like this:

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

""solution"" is just the list of board identifiers you pick (the boards we’ll post on). Think of each item in that array as the exact name or ID of a board from the instance — swap in the real IDs there. This block is only a sketch of the shape I want, 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.

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': 10, 'density': 0.35384615384615387, 'sets': [{'id': 1, 'elements': [1, 8, 11]}, {'id': 2, 'elements': [7, 10, 11, 12]}, {'id': 3, 'elements': [2, 3, 4, 11]}, {'id': 4, 'elements': [5, 6]}, {'id': 5, 'elements': [1, 2, 4, 5, 7, 9, 10, 11]}, {'id': 6, 'elements': [2, 4, 5, 6, 7, 11]}, {'id': 7, 'elements': [8, 10, 12]}, {'id': 8, 'elements': [1, 6, 9, 10, 11, 12, 13]}, {'id': 9, 'elements': [2, 4, 6, 10]}, {'id': 10, 'elements': [2, 8, 10, 11, 12]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 1, 'v': 11}, {'u': 4, 'v': 3}, {'u': 4, 'v': 6}, {'u': 6, 'v': 2}, {'u': 6, 'v': 7}, {'u': 6, 'v': 11}, {'u': 11, 'v': 8}, {'u': 11, 'v': 10}, {'u': 7, 'v': 5}, {'u': 12, 'v': 8}, {'u': 12, 'v': 10}, {'u': 2, 'v': 9}, {'u': 2, 'v': 10}, {'u': 2, 'v': 13}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0040.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0040.png'}","[6, 8]",11.0,"{'num_elements': 13, 'num_sets': 10, 'sets': [{'id': 'S1', 'elements': [0, 7, 10]}, {'id': 'S2', 'elements': [6, 9, 10, 11]}, {'id': 'S3', 'elements': [1, 2, 3, 10]}, {'id': 'S4', 'elements': [4, 5]}, {'id': 'S5', 'elements': [0, 1, 3, 4, 6, 8, 9, 10]}, {'id': 'S6', 'elements': [1, 3, 4, 5, 6, 10]}, {'id': 'S7', 'elements': [7, 9, 11]}, {'id': 'S8', 'elements': [0, 5, 8, 9, 10, 11, 12]}, {'id': 'S9', 'elements': [1, 3, 5, 9]}, {'id': 'S10', 'elements': [1, 7, 9, 10, 11]}], 'budget_k': 2}","['S6', 'S8']",41,json,0
MkC,MkC,"Recently the city has been planning a set of short-term clinics but there’s only budget for a limited number, so the team needs to pick sites that reach the biggest number of different households. For each possible selection, add up the households each chosen clinic would serve, then count distinct households once (don’t double-count overlaps); the number of clinics selected must stay within the cap. The full list of candidate sites and which households they cover appears below.

# total_households=15
# candidate_clinics=13
# max_clinics_open=2
clinic_id,household_ids
S1,5 11 15
S2,6 9 15
S3,5 7 10 15
S4,1 5 15
S5,2 9 13
S6,8 14 15
S7,1 3 9 12
S8,8 10
S9,1 3 11 15
S10,6 9 12
S11,6 12
S12,4 8 14
S13,1 3 4 5 8 11 14 15

When you’re ready to give the chosen sites, just reply with a tiny JSON object in this shape — super simple:

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

Think of it like a quick form: ""solution"" is the list of clinic sites you pick (each entry is the site identifier as shown in the instance). The ""site_id"" above is just a placeholder to show the format — replace each placeholder with the actual IDs from the input. This block is only a sketch of the shape I expect, not the actual answer.

Please use the identifiers exactly as they appear in the instance input — no renaming, no extra labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 15, 'num_sets': 13, 'density': 0.23076923076923078, 'sets': [{'id': 1, 'elements': [5, 11, 15]}, {'id': 2, 'elements': [6, 9, 15]}, {'id': 3, 'elements': [5, 7, 10, 15]}, {'id': 4, 'elements': [1, 5, 15]}, {'id': 5, 'elements': [2, 9, 13]}, {'id': 6, 'elements': [8, 14, 15]}, {'id': 7, 'elements': [1, 3, 9, 12]}, {'id': 8, 'elements': [8, 10]}, {'id': 9, 'elements': [1, 3, 11, 15]}, {'id': 10, 'elements': [6, 9, 12]}, {'id': 11, 'elements': [6, 12]}, {'id': 12, 'elements': [4, 8, 14]}, {'id': 13, 'elements': [1, 3, 4, 5, 8, 11, 14, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 3, 'v': 1}, {'u': 3, 'v': 9}, {'u': 10, 'v': 8}, {'u': 8, 'v': 4}, {'u': 7, 'v': 14}, {'u': 11, 'v': 1}, {'u': 5, 'v': 15}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 9, 'v': 6}, {'u': 2, 'v': 6}, {'u': 15, 'v': 1}, {'u': 12, 'v': 6}, {'u': 12, 'v': 13}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0041.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0041.png'}","[5, 13]",11.0,"{'num_elements': 15, 'num_sets': 13, 'sets': [{'id': 'S1', 'elements': [5, 11, 15]}, {'id': 'S2', 'elements': [6, 9, 15]}, {'id': 'S3', 'elements': [5, 7, 10, 15]}, {'id': 'S4', 'elements': [1, 5, 15]}, {'id': 'S5', 'elements': [2, 9, 13]}, {'id': 'S6', 'elements': [8, 14, 15]}, {'id': 'S7', 'elements': [1, 3, 9, 12]}, {'id': 'S8', 'elements': [8, 10]}, {'id': 'S9', 'elements': [1, 3, 11, 15]}, {'id': 'S10', 'elements': [6, 9, 12]}, {'id': 'S11', 'elements': [6, 12]}, {'id': 'S12', 'elements': [4, 8, 14]}, {'id': 'S13', 'elements': [1, 3, 4, 5, 8, 11, 14, 15]}], 'budget_k': 2}","['S5', 'S13']",42,csv,1
MkC,MkC,"There’s a stack of field reports and a map of posts, and the rangers need to decide which towers to fill for the week. Every post overlooks a mix of habitat patches, and because the crew is small, only a limited number of those posts will be staffed. The goal is straightforward: choose the posts so the total number of distinct habitat types observed is as large as possible. To check how well a choice does, count each habitat type covered by the chosen posts only once (do not double-count overlaps), and stay within the staffing cap. The detailed instance info is shown below.

Instance details: 15 distinct habitat types, 15 observation posts, and a staffing cap of 3 posts.
Post S1 overlooks habitats: 1 5 6 8 9 13 15.
Post S2 overlooks habitats: 2 3 4 10 12.
Post S3 overlooks habitats: 2 5 10 12 15.
Post S4 overlooks habitats: 2 7 14.
Post S5 overlooks habitats: 3 6 15.
Post S6 overlooks habitats: 1 6 9 10 13 15.
Post S7 overlooks habitats: 7 12 14.
Post S8 overlooks habitats: 6 8 10 11 15.
Post S9 overlooks habitats: 1 5 6 9 13.
Post S10 overlooks habitats: 2 6 8 13 15.
Post S11 overlooks habitats: 1 8 11 15.
Post S12 overlooks habitats: 2 3 4 7 12.
Post S13 overlooks habitats: 1 5 6 8 9 10 15.
Post S14 overlooks habitats: 4 7.
Post S15 overlooks habitats: 1 6 8 10 11 15.
Choose up to 3 posts so the rangers cover as many of the 15 habitat types as possible.

Oh, and when you send back the chosen posts, please use this simple JSON layout so it's easy to read and process:

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

Think of ""solution"" as just a list of the posts (tower/post IDs) you want staffed for the week. Each item in the list is one post identifier — that's it. This block is just a sketch of the expected shape, not the actual answer you should submit.

Please use the exact identifiers from the instance input — don't rename them or invent new ones. No renaming and no new labels, okay?
- 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.31555555555555553, 'sets': [{'id': 1, 'elements': [1, 5, 6, 8, 9, 13, 15]}, {'id': 2, 'elements': [2, 3, 4, 10, 12]}, {'id': 3, 'elements': [2, 5, 10, 12, 15]}, {'id': 4, 'elements': [2, 7, 14]}, {'id': 5, 'elements': [3, 6, 15]}, {'id': 6, 'elements': [1, 6, 9, 10, 13, 15]}, {'id': 7, 'elements': [7, 12, 14]}, {'id': 8, 'elements': [6, 8, 10, 11, 15]}, {'id': 9, 'elements': [1, 5, 6, 9, 13]}, {'id': 10, 'elements': [2, 6, 8, 13, 15]}, {'id': 11, 'elements': [1, 8, 11, 15]}, {'id': 12, 'elements': [2, 3, 4, 7, 12]}, {'id': 13, 'elements': [1, 5, 6, 8, 9, 10, 15]}, {'id': 14, 'elements': [4, 7]}, {'id': 15, 'elements': [1, 6, 8, 10, 11, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 14, 'v': 7}, {'u': 4, 'v': 7}, {'u': 4, 'v': 12}, {'u': 15, 'v': 6}, {'u': 15, 'v': 8}, {'u': 15, 'v': 10}, {'u': 10, 'v': 3}, {'u': 10, 'v': 5}, {'u': 8, 'v': 1}, {'u': 8, 'v': 11}, {'u': 1, 'v': 6}, {'u': 1, 'v': 13}, {'u': 12, 'v': 2}, {'u': 3, 'v': 2}, {'u': 5, 'v': 6}, {'u': 5, 'v': 13}, {'u': 9, 'v': 13}, {'u': 6, 'v': 13}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0042.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0042.png'}","[1, 12, 15]",14.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [1, 5, 6, 8, 9, 13, 15]}, {'id': 'S2', 'elements': [2, 3, 4, 10, 12]}, {'id': 'S3', 'elements': [2, 5, 10, 12, 15]}, {'id': 'S4', 'elements': [2, 7, 14]}, {'id': 'S5', 'elements': [3, 6, 15]}, {'id': 'S6', 'elements': [1, 6, 9, 10, 13, 15]}, {'id': 'S7', 'elements': [7, 12, 14]}, {'id': 'S8', 'elements': [6, 8, 10, 11, 15]}, {'id': 'S9', 'elements': [1, 5, 6, 9, 13]}, {'id': 'S10', 'elements': [2, 6, 8, 13, 15]}, {'id': 'S11', 'elements': [1, 8, 11, 15]}, {'id': 'S12', 'elements': [2, 3, 4, 7, 12]}, {'id': 'S13', 'elements': [1, 5, 6, 8, 9, 10, 15]}, {'id': 'S14', 'elements': [4, 7]}, {'id': 'S15', 'elements': [1, 6, 8, 10, 11, 15]}], 'budget_k': 3}","['S1', 'S12', 'S15']",43,nl,1
MkC,MkC,"Recently the cafe had to trim its delivery program down to a handful of routes. The owner will pick those routes so the union of their streets gives the broadest possible reach — count every street once even if multiple routes pass through it — and no more than the allowed number of routes can be chosen. The full set of candidate routes and the selection limit are presented below.

# total_streets=17
# total_routes=15
# max_routes_allowed=3
route_id,route_streets
S1,0 7 14 16
S2,1 2
S3,1 2 12
S4,11 12
S5,4 11 12 15
S6,3 7 9 14
S7,5 14
S8,0 5 8 14 16
S9,6 7 8 16
S10,5 8 9
S11,10 12
S12,1 3 4 12 15
S13,2 3 4 10 11 15
S14,0 3 5 6 7 13 15 16
S15,1 3 4 14 15

If you could send the picked routes back in a little machine-friendly note, use this simple JSON shape.

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

Think of it like a tiny form: ""solution"" holds a list of the routes you want to keep active. The ""route_id"" bit is just a placeholder showing where each chosen route's identifier goes — swap those placeholders for the actual IDs from the instance.

This is just the expected shape, not the actual answer — please replace the placeholder(s) with the real route IDs from the problem input.

Important: 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': 15, 'density': 0.23137254901960785, 'sets': [{'id': 1, 'elements': [1, 8, 15, 17]}, {'id': 2, 'elements': [2, 3]}, {'id': 3, 'elements': [2, 3, 13]}, {'id': 4, 'elements': [12, 13]}, {'id': 5, 'elements': [5, 12, 13, 16]}, {'id': 6, 'elements': [4, 8, 10, 15]}, {'id': 7, 'elements': [6, 15]}, {'id': 8, 'elements': [1, 6, 9, 15, 17]}, {'id': 9, 'elements': [7, 8, 9, 17]}, {'id': 10, 'elements': [6, 9, 10]}, {'id': 11, 'elements': [11, 13]}, {'id': 12, 'elements': [2, 4, 5, 13, 16]}, {'id': 13, 'elements': [3, 4, 5, 11, 12, 16]}, {'id': 14, 'elements': [1, 4, 6, 7, 8, 14, 16, 17]}, {'id': 15, 'elements': [2, 4, 5, 15, 16]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 2, 'v': 3}, {'u': 2, 'v': 11}, {'u': 2, 'v': 13}, {'u': 14, 'v': 6}, {'u': 15, 'v': 4}, {'u': 15, 'v': 6}, {'u': 15, 'v': 8}, {'u': 16, 'v': 4}, {'u': 16, 'v': 12}, {'u': 16, 'v': 13}, {'u': 17, 'v': 8}, {'u': 17, 'v': 9}, {'u': 6, 'v': 7}, {'u': 7, 'v': 10}, {'u': 8, 'v': 1}, {'u': 9, 'v': 10}, {'u': 5, 'v': 12}, {'u': 12, 'v': 13}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0043.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0043.png'}","[12, 13, 14]",14.0,"{'num_elements': 17, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [0, 7, 14, 16]}, {'id': 'S2', 'elements': [1, 2]}, {'id': 'S3', 'elements': [1, 2, 12]}, {'id': 'S4', 'elements': [11, 12]}, {'id': 'S5', 'elements': [4, 11, 12, 15]}, {'id': 'S6', 'elements': [3, 7, 9, 14]}, {'id': 'S7', 'elements': [5, 14]}, {'id': 'S8', 'elements': [0, 5, 8, 14, 16]}, {'id': 'S9', 'elements': [6, 7, 8, 16]}, {'id': 'S10', 'elements': [5, 8, 9]}, {'id': 'S11', 'elements': [10, 12]}, {'id': 'S12', 'elements': [1, 3, 4, 12, 15]}, {'id': 'S13', 'elements': [2, 3, 4, 10, 11, 15]}, {'id': 'S14', 'elements': [0, 3, 5, 6, 7, 13, 15, 16]}, {'id': 'S15', 'elements': [1, 3, 4, 14, 15]}], 'budget_k': 3}","['S12', 'S13', 'S14']",44,csv,0
MkC,MkC,"Many teams run into this: a short trial window and a tight feature budget. The smart move is to select the limited number of features that, when combined, address the largest number of different user needs — the score is simply the number of unique needs covered by the chosen set, with overlaps only counting once. There’s no exceeding the allowed feature count and no repeating a feature, so the job is to balance breadth against the cap. The specific features and the selection limit are shown below.

# total_user_needs=15
# total_features_available=15
# feature_budget_k=3
feature_id,covered_needs
S1,A D J O
S2,C D E G M
S3,C L
S4,A D G L N O
S5,B E I M
S6,B E F I
S7,B D L
S8,C H K
S9,B E F I M
S10,J N
S11,C H
S12,A B C D G L M O
S13,F I L M
S14,A D
S15,A O

Oh, and when you send back the chosen features, please use this simple JSON layout so it’s easy to parse:

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

Think of it like a tiny form: put all the feature identifiers you’re selecting inside the ""solution"" list, in the same order (or any order) you prefer. The JSON above is just a sketch of the shape I expect — not your final choice.

Please make sure every identifier you use matches exactly what’s in the instance input — don’t rename anything 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': 15, 'num_sets': 15, 'density': 0.24888888888888888, 'sets': [{'id': 1, 'elements': [1, 4, 10, 15]}, {'id': 2, 'elements': [3, 4, 5, 7, 13]}, {'id': 3, 'elements': [3, 12]}, {'id': 4, 'elements': [1, 4, 7, 12, 14, 15]}, {'id': 5, 'elements': [2, 5, 9, 13]}, {'id': 6, 'elements': [2, 5, 6, 9]}, {'id': 7, 'elements': [2, 4, 12]}, {'id': 8, 'elements': [3, 8, 11]}, {'id': 9, 'elements': [2, 5, 6, 9, 13]}, {'id': 10, 'elements': [10, 14]}, {'id': 11, 'elements': [3, 8]}, {'id': 12, 'elements': [1, 2, 3, 4, 7, 12, 13, 15]}, {'id': 13, 'elements': [6, 9, 12, 13]}, {'id': 14, 'elements': [1, 4]}, {'id': 15, 'elements': [1, 15]}], 'graph': {'num_nodes': 15, 'edges': [{'u': 8, 'v': 11}, {'u': 14, 'v': 1}, {'u': 14, 'v': 10}, {'u': 9, 'v': 13}, {'u': 1, 'v': 4}, {'u': 5, 'v': 13}, {'u': 2, 'v': 3}, {'u': 2, 'v': 12}, {'u': 2, 'v': 13}, {'u': 15, 'v': 4}, {'u': 12, 'v': 4}, {'u': 12, 'v': 7}, {'u': 13, 'v': 6}, {'u': 3, 'v': 11}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0044.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0044.png'}","[4, 8, 9]",14.0,"{'num_elements': 15, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': ['A', 'D', 'J', 'O']}, {'id': 'S2', 'elements': ['C', 'D', 'E', 'G', 'M']}, {'id': 'S3', 'elements': ['C', 'L']}, {'id': 'S4', 'elements': ['A', 'D', 'G', 'L', 'N', 'O']}, {'id': 'S5', 'elements': ['B', 'E', 'I', 'M']}, {'id': 'S6', 'elements': ['B', 'E', 'F', 'I']}, {'id': 'S7', 'elements': ['B', 'D', 'L']}, {'id': 'S8', 'elements': ['C', 'H', 'K']}, {'id': 'S9', 'elements': ['B', 'E', 'F', 'I', 'M']}, {'id': 'S10', 'elements': ['J', 'N']}, {'id': 'S11', 'elements': ['C', 'H']}, {'id': 'S12', 'elements': ['A', 'B', 'C', 'D', 'G', 'L', 'M', 'O']}, {'id': 'S13', 'elements': ['F', 'I', 'L', 'M']}, {'id': 'S14', 'elements': ['A', 'D']}, {'id': 'S15', 'elements': ['A', 'O']}], 'budget_k': 3}","['S4', 'S8', 'S9']",45,csv,names
MkC,MkC,"Someone suggested having neighbors host signup stations, but space and volunteers are limited. The task is to pick which neighbors will run the stations so that the biggest number of different households gets visited—overlaps between volunteers don’t boost the count, so a household reached by two hosts still counts just once. The selection has to respect the cap on hosts, and the household lists for each volunteer are provided below.

- **total_households**: 13
- **total_volunteers**: 11
- **max_hosts_allowed**: 2

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

When you’re ready, just send the chosen hosts back in a tiny JSON snippet like this:

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

Here ""solution"" is the list of neighbors you picked to run signup stations, and each item in that array should be the exact identifier for a neighbor from the instance (one id per chosen host). Think of it like filling in a short form: the array is where you list the people you want to sign up.

This JSON is just a sketch of the shape I expect, not the actual answer—use it to format your final reply.

Please use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'source_file': 'road_central.mtx', 'k_hop': 2, 'num_elements': 13, 'num_sets': 11, 'density': 0.32167832167832167, 'sets': [{'id': 1, 'elements': [1, 2, 4, 7, 9, 12]}, {'id': 2, 'elements': [2, 9, 10]}, {'id': 3, 'elements': [5, 7]}, {'id': 4, 'elements': [4, 7, 10, 12]}, {'id': 5, 'elements': [3, 6, 7, 8]}, {'id': 6, 'elements': [6, 13]}, {'id': 7, 'elements': [1, 2, 3, 4, 5, 7, 9, 11, 12]}, {'id': 8, 'elements': [3, 5, 6, 9, 10]}, {'id': 9, 'elements': [1, 2, 4, 9, 10]}, {'id': 10, 'elements': [1, 4, 7, 10]}, {'id': 11, 'elements': [5, 13]}], 'graph': {'num_nodes': 13, 'edges': [{'u': 3, 'v': 9}, {'u': 5, 'v': 6}, {'u': 5, 'v': 9}, {'u': 6, 'v': 8}, {'u': 6, 'v': 13}, {'u': 2, 'v': 7}, {'u': 2, 'v': 11}, {'u': 10, 'v': 7}, {'u': 10, 'v': 12}, {'u': 12, 'v': 4}, {'u': 4, 'v': 1}, {'u': 9, 'v': 7}, {'u': 7, 'v': 1}]}, 'budget_k': 2, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0045.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0045.png'}","[5, 7]",11.0,"{'num_elements': 13, 'num_sets': 11, 'sets': [{'id': 'S1', 'elements': [1, 2, 4, 7, 9, 12]}, {'id': 'S2', 'elements': [2, 9, 10]}, {'id': 'S3', 'elements': [5, 7]}, {'id': 'S4', 'elements': [4, 7, 10, 12]}, {'id': 'S5', 'elements': [3, 6, 7, 8]}, {'id': 'S6', 'elements': [6, 13]}, {'id': 'S7', 'elements': [1, 2, 3, 4, 5, 7, 9, 11, 12]}, {'id': 'S8', 'elements': [3, 5, 6, 9, 10]}, {'id': 'S9', 'elements': [1, 2, 4, 9, 10]}, {'id': 'S10', 'elements': [1, 4, 7, 10]}, {'id': 'S11', 'elements': [5, 13]}], 'budget_k': 2}","['S5', 'S7']",46,markdown_table,1
MkC,MkC,"Someone in charge of the weekend market needs to decide which suppliers get a stall because only a set number of spots are available. What makes one decision better than another is simply how many different ingredient types shoppers will find across the chosen stalls. The way to judge a lineup is to gather all the items the selected stalls sell, filter out duplicates so each ingredient type is counted a single time, and tally those unique types. The full breakdown of stalls and their offerings is shown below.

- **total_ingredient_types**: 18
- **total_supplier_stalls**: 17
- **stall_spots_limit**: 3

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

If it helps, just send back the chosen stalls in a tiny JSON snippet so it's clear and easy to read. Here's the shape I'd expect:

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

Think of this as a simple form: ""solution"" is the list of stalls you want to give market spots to, and each item in the array should be the exact stall identifier from the instance (the ""stall_id"" above is just a placeholder showing the format). This JSON is only a sketch of the expected shape — not the real answer.

Please use the identifiers exactly as they appear in the instance input — 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': 17, 'density': 0.1830065359477124, 'sets': [{'id': 1, 'elements': [1, 11, 18]}, {'id': 2, 'elements': [2, 13]}, {'id': 3, 'elements': [8, 14, 17]}, {'id': 4, 'elements': [5, 13, 15]}, {'id': 5, 'elements': [2, 9, 13]}, {'id': 6, 'elements': [6, 7]}, {'id': 7, 'elements': [1, 6, 7, 18]}, {'id': 8, 'elements': [8, 11]}, {'id': 9, 'elements': [4, 9, 10, 14, 15]}, {'id': 10, 'elements': [9, 10, 15]}, {'id': 11, 'elements': [1, 7, 8, 11, 12, 18]}, {'id': 12, 'elements': [11, 16, 18]}, {'id': 13, 'elements': [5, 13]}, {'id': 14, 'elements': [9, 17]}, {'id': 15, 'elements': [4, 9]}, {'id': 16, 'elements': [3, 4, 9, 14, 17]}, {'id': 17, 'elements': [1, 7, 8, 11, 12, 14]}], 'graph': {'num_nodes': 18, 'edges': [{'u': 18, 'v': 8}, {'u': 18, 'v': 11}, {'u': 18, 'v': 12}, {'u': 15, 'v': 9}, {'u': 15, 'v': 10}, {'u': 16, 'v': 12}, {'u': 11, 'v': 1}, {'u': 11, 'v': 7}, {'u': 17, 'v': 9}, {'u': 17, 'v': 14}, {'u': 6, 'v': 7}, {'u': 4, 'v': 5}, {'u': 4, 'v': 9}, {'u': 5, 'v': 13}, {'u': 14, 'v': 3}, {'u': 14, 'v': 8}, {'u': 2, 'v': 13}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0046.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0046.png'}","[4, 11, 16]",14.0,"{'num_elements': 18, 'num_sets': 17, 'sets': [{'id': 'S1', 'elements': [1, 11, 18]}, {'id': 'S2', 'elements': [2, 13]}, {'id': 'S3', 'elements': [8, 14, 17]}, {'id': 'S4', 'elements': [5, 13, 15]}, {'id': 'S5', 'elements': [2, 9, 13]}, {'id': 'S6', 'elements': [6, 7]}, {'id': 'S7', 'elements': [1, 6, 7, 18]}, {'id': 'S8', 'elements': [8, 11]}, {'id': 'S9', 'elements': [4, 9, 10, 14, 15]}, {'id': 'S10', 'elements': [9, 10, 15]}, {'id': 'S11', 'elements': [1, 7, 8, 11, 12, 18]}, {'id': 'S12', 'elements': [11, 16, 18]}, {'id': 'S13', 'elements': [5, 13]}, {'id': 'S14', 'elements': [9, 17]}, {'id': 'S15', 'elements': [4, 9]}, {'id': 'S16', 'elements': [3, 4, 9, 14, 17]}, {'id': 'S17', 'elements': [1, 7, 8, 11, 12, 14]}], 'budget_k': 3}","['S4', 'S11', 'S16']",47,markdown_table,1
MkC,MkC,"We’re putting together a small workshop schedule for students and only have room for a few topics. Each workshop addresses a set of student concerns — social anxiety, study habits, time management, etc. The trick is to choose the limited number of sessions so that, when looked at as a group, they address as many different worries as possible. The tally is simple: list every unique concern covered by the chosen sessions and count them (overlapping topics aren’t double-counted). The specific session list and the limit on how many can be run are given below.

We have 15 workshop options that together mention 16 distinct student concerns, and we can schedule up to 3 sessions.
Workshop S1 addresses 12 16.
Workshop S2 addresses 3 4 6 8 10 15.
Workshop S3 addresses 2 4 8 9.
Workshop S4 addresses 5 7 12 16.
Workshop S5 addresses 2 3 4 6 10 11 13.
Workshop S6 addresses 6 7 11 13 14.
Workshop S7 addresses 3 4 14 15.
Workshop S8 addresses 8 9.
Workshop S9 addresses 3 6 15.
Workshop S10 addresses 5 7 11 16.
Workshop S11 addresses 1 5 12.
Workshop S12 addresses 6 7.
Workshop S13 addresses 2 4 6 8.
Workshop S14 addresses 6 7 8 10 14 15.
Workshop S15 addresses 5 12.
Let's pick up to 3 sessions so we cover as many distinct worries as possible.

Oh, and when you reply, please use this simple JSON layout so it's easy to read by the tool:

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

""solution"" should be an array listing the session IDs you want to run — just drop in the exact IDs from the instance (the placeholder session_id is just showing the shape). This is just a sketch of the shape I need, not the actual answer.

Please be sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- 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': [12, 16]}, {'id': 2, 'elements': [3, 4, 6, 8, 10, 15]}, {'id': 3, 'elements': [2, 4, 8, 9]}, {'id': 4, 'elements': [5, 7, 12, 16]}, {'id': 5, 'elements': [2, 3, 4, 6, 10, 11, 13]}, {'id': 6, 'elements': [6, 7, 11, 13, 14]}, {'id': 7, 'elements': [3, 4, 14, 15]}, {'id': 8, 'elements': [8, 9]}, {'id': 9, 'elements': [3, 6, 15]}, {'id': 10, 'elements': [5, 7, 11, 16]}, {'id': 11, 'elements': [1, 5, 12]}, {'id': 12, 'elements': [6, 7]}, {'id': 13, 'elements': [2, 4, 6, 8]}, {'id': 14, 'elements': [6, 7, 8, 10, 14, 15]}, {'id': 15, 'elements': [5, 12]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 12, 'v': 1}, {'u': 12, 'v': 16}, {'u': 5, 'v': 11}, {'u': 5, 'v': 16}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 6, 'v': 7}, {'u': 6, 'v': 14}, {'u': 6, 'v': 15}, {'u': 3, 'v': 15}, {'u': 9, 'v': 4}, {'u': 11, 'v': 7}, {'u': 7, 'v': 13}, {'u': 4, 'v': 14}, {'u': 15, 'v': 10}, {'u': 14, 'v': 2}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0047.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0047.png'}","[5, 11, 14]",14.0,"{'num_elements': 16, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [12, 16]}, {'id': 'S2', 'elements': [3, 4, 6, 8, 10, 15]}, {'id': 'S3', 'elements': [2, 4, 8, 9]}, {'id': 'S4', 'elements': [5, 7, 12, 16]}, {'id': 'S5', 'elements': [2, 3, 4, 6, 10, 11, 13]}, {'id': 'S6', 'elements': [6, 7, 11, 13, 14]}, {'id': 'S7', 'elements': [3, 4, 14, 15]}, {'id': 'S8', 'elements': [8, 9]}, {'id': 'S9', 'elements': [3, 6, 15]}, {'id': 'S10', 'elements': [5, 7, 11, 16]}, {'id': 'S11', 'elements': [1, 5, 12]}, {'id': 'S12', 'elements': [6, 7]}, {'id': 'S13', 'elements': [2, 4, 6, 8]}, {'id': 'S14', 'elements': [6, 7, 8, 10, 14, 15]}, {'id': 'S15', 'elements': [5, 12]}], 'budget_k': 3}","['S5', 'S11', 'S14']",48,nl,1
MkC,MkC,"Out in the suburbs a small team is mapping which open houses to push in the next email blast, but the blast can only include a limited number of locations. The plan is to select the locations that together reach the largest group of distinct potential buyers — count each person once if they’d see any of the ads, and respect the cap on how many locations can be included. The concrete list of houses, audience overlaps, and the maximum number allowed are shown below.

# total_potential_buyers=17
# total_open_house_locations=15
# max_ad_locations=3
house_id,reachable_buyers
S1,0 14
S2,1 7 11
S3,2 3 4 5 11
S4,2 3 5 11 14 16
S5,2 4 6 9 13
S6,2 10 11 14
S7,2 4 6 9
S8,1 5 7 11 12
S9,2 4 5 6 8 13
S10,10 11 15
S11,2 3 5 7 10 11
S12,1 7 10 15
S13,0 3 5
S14,12 15
S15,0 3 14 16

Oh, and when you send back the selection, please use a tiny JSON snippet so it's easy to pick up automatically. Something like this shows the shape I expect:

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

This just means ""solution"" should be an array of the house identifiers you choose for the email blast. The example value house_id is a placeholder showing the format — in your reply each item should be one of the real IDs from the instance (don’t invent or rename them). The JSON above is only a sketch of the expected shape, not the actual answer.

Please make sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 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.24313725490196078, 'sets': [{'id': 1, 'elements': [1, 15]}, {'id': 2, 'elements': [2, 8, 12]}, {'id': 3, 'elements': [3, 4, 5, 6, 12]}, {'id': 4, 'elements': [3, 4, 6, 12, 15, 17]}, {'id': 5, 'elements': [3, 5, 7, 10, 14]}, {'id': 6, 'elements': [3, 11, 12, 15]}, {'id': 7, 'elements': [3, 5, 7, 10]}, {'id': 8, 'elements': [2, 6, 8, 12, 13]}, {'id': 9, 'elements': [3, 5, 6, 7, 9, 14]}, {'id': 10, 'elements': [11, 12, 16]}, {'id': 11, 'elements': [3, 4, 6, 8, 11, 12]}, {'id': 12, 'elements': [2, 8, 11, 16]}, {'id': 13, 'elements': [1, 4, 6]}, {'id': 14, 'elements': [13, 16]}, {'id': 15, 'elements': [1, 4, 15, 17]}], 'graph': {'num_nodes': 17, 'edges': [{'u': 13, 'v': 2}, {'u': 13, 'v': 16}, {'u': 9, 'v': 7}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 6, 'v': 12}, {'u': 15, 'v': 4}, {'u': 15, 'v': 17}, {'u': 17, 'v': 1}, {'u': 7, 'v': 10}, {'u': 2, 'v': 8}, {'u': 3, 'v': 10}, {'u': 5, 'v': 10}, {'u': 5, 'v': 14}, {'u': 12, 'v': 8}, {'u': 12, 'v': 11}, {'u': 16, 'v': 11}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0048.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0048.png'}","[9, 12, 15]",14.0,"{'num_elements': 17, 'num_sets': 15, 'sets': [{'id': 'S1', 'elements': [0, 14]}, {'id': 'S2', 'elements': [1, 7, 11]}, {'id': 'S3', 'elements': [2, 3, 4, 5, 11]}, {'id': 'S4', 'elements': [2, 3, 5, 11, 14, 16]}, {'id': 'S5', 'elements': [2, 4, 6, 9, 13]}, {'id': 'S6', 'elements': [2, 10, 11, 14]}, {'id': 'S7', 'elements': [2, 4, 6, 9]}, {'id': 'S8', 'elements': [1, 5, 7, 11, 12]}, {'id': 'S9', 'elements': [2, 4, 5, 6, 8, 13]}, {'id': 'S10', 'elements': [10, 11, 15]}, {'id': 'S11', 'elements': [2, 3, 5, 7, 10, 11]}, {'id': 'S12', 'elements': [1, 7, 10, 15]}, {'id': 'S13', 'elements': [0, 3, 5]}, {'id': 'S14', 'elements': [12, 15]}, {'id': 'S15', 'elements': [0, 3, 14, 16]}], 'budget_k': 3}","['S9', 'S12', 'S15']",49,csv,0
MkC,MkC,"Someone on duty has to pick, say, N camera positions to turn on so the facility is watched as thoroughly as possible; one selection beats another if it covers more unique rooms and walkways, and that coverage is computed simply by counting every distinct area covered (no counting overlaps twice), while respecting the fixed limit on activations. The exact floor plan and camera coverage details follow below.

- **total_areas**: 16
- **total_cameras**: 16
- **activation_limit**: 3

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

If you want the answer in an easily-parseable form, I'll give it as a tiny JSON snippet like this:

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

Here ""solution"" is just a list of the camera positions you'd turn on — each entry is the exact camera identifier from the instance (I'm using camera_id as the placeholder name to match the story). Think of it like filling out a short form: put the IDs of the N cameras you choose in that array.

This is only a sketch of the expected shape, not the actual selection — I'll fill in the real IDs when I see 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': 16, 'num_sets': 16, 'density': 0.33203125, 'sets': [{'id': 1, 'elements': [1, 3, 8, 10, 11, 16]}, {'id': 2, 'elements': [6, 7, 14]}, {'id': 3, 'elements': [1, 3, 8, 9, 11, 16]}, {'id': 4, 'elements': [4, 7, 9, 12, 14]}, {'id': 5, 'elements': [2, 5, 12, 14]}, {'id': 6, 'elements': [6, 8, 10, 11, 15]}, {'id': 7, 'elements': [2, 4, 9, 12, 15]}, {'id': 8, 'elements': [10, 11]}, {'id': 9, 'elements': [3, 4, 6, 7, 12, 13, 14]}, {'id': 10, 'elements': [1, 6, 10, 11, 13, 15]}, {'id': 11, 'elements': [1, 3, 6, 10, 11, 13, 16]}, {'id': 12, 'elements': [2, 4, 5, 9, 12, 14]}, {'id': 13, 'elements': [7, 8, 9, 10, 11, 13, 14, 16]}, {'id': 14, 'elements': [4, 5, 12, 13, 14, 16]}, {'id': 15, 'elements': [7, 10, 13, 15]}, {'id': 16, 'elements': [1, 3, 11, 13, 14]}], 'graph': {'num_nodes': 16, 'edges': [{'u': 8, 'v': 11}, {'u': 8, 'v': 13}, {'u': 8, 'v': 16}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 9, 'v': 16}, {'u': 12, 'v': 2}, {'u': 12, 'v': 5}, {'u': 12, 'v': 14}, {'u': 3, 'v': 1}, {'u': 3, 'v': 16}, {'u': 4, 'v': 14}, {'u': 10, 'v': 6}, {'u': 10, 'v': 11}, {'u': 6, 'v': 7}, {'u': 6, 'v': 13}, {'u': 6, 'v': 15}, {'u': 11, 'v': 1}, {'u': 14, 'v': 7}, {'u': 2, 'v': 7}]}, 'budget_k': 3, 'budget_ratio': 0.2, 'budget_mode': 'ratio', 'viz_instance': 'generated_data/MkC/viz/MkC_M/instance_0049.png', 'viz_solution': 'generated_data/MkC/viz/MkC_M/solution_0049.png'}","[11, 12, 15]",15.0,"{'num_elements': 16, 'num_sets': 16, 'sets': [{'id': 'S1', 'elements': [1, 3, 8, 10, 11, 16]}, {'id': 'S2', 'elements': [6, 7, 14]}, {'id': 'S3', 'elements': [1, 3, 8, 9, 11, 16]}, {'id': 'S4', 'elements': [4, 7, 9, 12, 14]}, {'id': 'S5', 'elements': [2, 5, 12, 14]}, {'id': 'S6', 'elements': [6, 8, 10, 11, 15]}, {'id': 'S7', 'elements': [2, 4, 9, 12, 15]}, {'id': 'S8', 'elements': [10, 11]}, {'id': 'S9', 'elements': [3, 4, 6, 7, 12, 13, 14]}, {'id': 'S10', 'elements': [1, 6, 10, 11, 13, 15]}, {'id': 'S11', 'elements': [1, 3, 6, 10, 11, 13, 16]}, {'id': 'S12', 'elements': [2, 4, 5, 9, 12, 14]}, {'id': 'S13', 'elements': [7, 8, 9, 10, 11, 13, 14, 16]}, {'id': 'S14', 'elements': [4, 5, 12, 13, 14, 16]}, {'id': 'S15', 'elements': [7, 10, 13, 15]}, {'id': 'S16', 'elements': [1, 3, 11, 13, 14]}], 'budget_k': 3}","['S11', 'S12', 'S15']",50,markdown_table,1