GCP/GCP_M_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
GCP,GCP,"There’s a little puzzle in the club: give every student a single badge color, but if two students teamed up on a project they must have different colors. The aim is to keep the palette tiny — the best solution is the one with the smallest number of distinct badge colors, which you can measure by counting how many different colors appear — and no student gets left without a badge or more than one. The full list of who worked together is shown below.

{
  ""total_students"": 17,
  ""total_collaborations"": 84,
  ""edges"": [
    {
      ""student_a_id"": 14,
      ""student_b_id"": 15
    },
    {
      ""student_a_id"": 14,
      ""student_b_id"": 16
    },
    {
      ""student_a_id"": 15,
      ""student_b_id"": 16
    },
    {
      ""student_a_id"": 16,
      ""student_b_id"": 8
    },
    {
      ""student_a_id"": 16,
      ""student_b_id"": 17
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 5
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 6
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 7
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 9
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 10
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 11
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 13
    },
    {
      ""student_a_id"": 8,
      ""student_b_id"": 17
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 5
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 6
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 9
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 10
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 11
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 7,
      ""student_b_id"": 13
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 5
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 6
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 9
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 11
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 10,
      ""student_b_id"": 13
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 5
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 6
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 9
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 11,
      ""student_b_id"": 13
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 6
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 9
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 5,
      ""student_b_id"": 13
    },
    {
      ""student_a_id"": 9,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 9,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 9,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 9,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 9,
      ""student_b_id"": 6
    },
    {
      ""student_a_id"": 9,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 9,
      ""student_b_id"": 13
    },
    {
      ""student_a_id"": 6,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 6,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 6,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 6,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 6,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 6,
      ""student_b_id"": 13
    },
    {
      ""student_a_id"": 13,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 13,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 13,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 13,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 13,
      ""student_b_id"": 12
    },
    {
      ""student_a_id"": 12,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 12,
      ""student_b_id"": 2
    },
    {
      ""student_a_id"": 12,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 12,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 2,
      ""student_b_id"": 1
    },
    {
      ""student_a_id"": 2,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 2,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 1,
      ""student_b_id"": 3
    },
    {
      ""student_a_id"": 1,
      ""student_b_id"": 4
    },
    {
      ""student_a_id"": 3,
      ""student_b_id"": 4
    }
  ]
}

If you want to hand me the solution in a tidy, machine-friendly way, just use a JSON object with this shape — nothing fancy, just a list of groups that share the same badge color:

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

Think of ""solution"" as a list of color buckets: each inner array is all the students who get the same badge color. The placeholder ""student_id"" stands in for whatever exact identifiers your instance uses. This JSON is only a sketch of the shape I expect, not the final answer — fill it with the real identifiers from the instance.

Please use the identifiers exactly as they appear in the input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 84, 'edges': [{'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 15, 'v': 16}, {'u': 16, 'v': 8}, {'u': 16, 'v': 17}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 8, 'v': 17}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 6}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 4}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 9}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 11, 'v': 1}, {'u': 11, 'v': 2}, {'u': 11, 'v': 3}, {'u': 11, 'v': 4}, {'u': 11, 'v': 5}, {'u': 11, 'v': 6}, {'u': 11, 'v': 9}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 5, 'v': 9}, {'u': 5, 'v': 12}, {'u': 5, 'v': 13}, {'u': 9, 'v': 1}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 4}, {'u': 9, 'v': 6}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 6, 'v': 12}, {'u': 6, 'v': 13}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 4}, {'u': 13, 'v': 12}, {'u': 12, 'v': 1}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 4}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 3, 'v': 4}], 'source_file': 'coPapersDBLP.mtx', 'density': 0.6176470588235294, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0000.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0000.png', 'edge_connectivity': 2}","[[10, 16], [1], [11], [6], [7], [5], [4], [8], [9], [12, 15], [2], [13, 17], [3, 14]]",13.0,"{'num_nodes': 17, 'num_edges': 84, 'edges': [{'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 15, 'v': 16}, {'u': 16, 'v': 8}, {'u': 16, 'v': 17}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 8, 'v': 17}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 6}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 4}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 9}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 11, 'v': 1}, {'u': 11, 'v': 2}, {'u': 11, 'v': 3}, {'u': 11, 'v': 4}, {'u': 11, 'v': 5}, {'u': 11, 'v': 6}, {'u': 11, 'v': 9}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 5, 'v': 9}, {'u': 5, 'v': 12}, {'u': 5, 'v': 13}, {'u': 9, 'v': 1}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 4}, {'u': 9, 'v': 6}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 6, 'v': 12}, {'u': 6, 'v': 13}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 4}, {'u': 13, 'v': 12}, {'u': 12, 'v': 1}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 4}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 3, 'v': 4}]}","[[10, 16], [1], [11], [6], [7], [5], [4], [8], [9], [12, 15], [2], [13, 17], [3, 14]]",1,json,1
GCP,GCP,"Many people in the cul-de-sac rely on simple handheld radios, and it’s become a little art to assign channels so conversations don’t collide. The plan is to pick a channel for each radio, ensure any pair that can cause interference are on different channels, and try to minimize how many different channel numbers the whole street ends up using — you can determine which plan is better by tallying the unique channels. No device may be skipped and conflicting pairs must not share a channel. The concrete details follow below.

Here are the 40 interfering pairs among the 17 radios:
Radio A must use a different channel than radio B.
Radio A must use a different channel than radio C.
Radio A must use a different channel than radio D.
Radio A must use a different channel than radio E.
Radio A must use a different channel than radio F.
Radio B must use a different channel than radio C.
Radio B must use a different channel than radio D.
Radio B must use a different channel than radio E.
Radio B must use a different channel than radio F.
Radio C must use a different channel than radio D.
Radio C must use a different channel than radio E.
Radio C must use a different channel than radio F.
Radio D must use a different channel than radio E.
Radio D must use a different channel than radio F.
Radio D must use a different channel than radio G.
Radio D must use a different channel than radio H.
Radio D must use a different channel than radio I.
Radio D must use a different channel than radio J.
Radio D must use a different channel than radio K.
Radio D must use a different channel than radio L.
Radio D must use a different channel than radio M.
Radio D must use a different channel than radio N.
Radio D must use a different channel than radio O.
Radio D must use a different channel than radio P.
Radio D must use a different channel than radio Q.
Radio E must use a different channel than radio F.
Radio F must use a different channel than radio G.
Radio F must use a different channel than radio H.
Radio F must use a different channel than radio I.
Radio J must use a different channel than radio K.
Radio J must use a different channel than radio L.
Radio J must use a different channel than radio M.
Radio J must use a different channel than radio N.
Radio K must use a different channel than radio M.
Radio O must use a different channel than radio P.
Radio O must use a different channel than radio Q.
Radio P must use a different channel than radio Q.
Radio G must use a different channel than radio H.
Radio G must use a different channel than radio I.
Radio H must use a different channel than radio I.
These 40 constraints apply to all 17 radios; aim to minimize the number of distinct channels used.

Oh, and when you send back your channel plan, it helps to keep it in a little JSON shape like this so it's easy to read and check:

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

Each inner list is a group of radios that share the same channel (so none of those pairs should interfere with each other). Think of each inner array as “channel A has these radios, channel B has those radios,” and so on. This is just a sketch of the shape I’m expecting, not the actual answer — replace the placeholders with the real radio identifiers from the instance.

Please use the identifiers exactly as they appear in the instance input — don’t rename them or make up new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 40, 'edges': [{'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 4, 'v': 13}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 4, 'v': 16}, {'u': 4, 'v': 17}, {'u': 5, 'v': 6}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 11, 'v': 13}, {'u': 15, 'v': 16}, {'u': 15, 'v': 17}, {'u': 16, 'v': 17}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 8, 'v': 9}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.29411764705882354, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0001.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0001.png', 'edge_connectivity': 2}","[[4], [2, 10], [3, 9], [5, 7, 17], [6, 11, 12, 14, 15], [1, 8, 13, 16]]",6.0,"{'num_nodes': 17, 'num_edges': 40, 'edges': [{'u': 'A', 'v': 'B'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'D'}, {'u': 'A', 'v': 'E'}, {'u': 'A', 'v': 'F'}, {'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'D'}, {'u': 'B', 'v': 'E'}, {'u': 'B', 'v': 'F'}, {'u': 'C', 'v': 'D'}, {'u': 'C', 'v': 'E'}, {'u': 'C', 'v': 'F'}, {'u': 'D', 'v': 'E'}, {'u': 'D', 'v': 'F'}, {'u': 'D', 'v': 'G'}, {'u': 'D', 'v': 'H'}, {'u': 'D', 'v': 'I'}, {'u': 'D', 'v': 'J'}, {'u': 'D', 'v': 'K'}, {'u': 'D', 'v': 'L'}, {'u': 'D', 'v': 'M'}, {'u': 'D', 'v': 'N'}, {'u': 'D', 'v': 'O'}, {'u': 'D', 'v': 'P'}, {'u': 'D', 'v': 'Q'}, {'u': 'E', 'v': 'F'}, {'u': 'F', 'v': 'G'}, {'u': 'F', 'v': 'H'}, {'u': 'F', 'v': 'I'}, {'u': 'J', 'v': 'K'}, {'u': 'J', 'v': 'L'}, {'u': 'J', 'v': 'M'}, {'u': 'J', 'v': 'N'}, {'u': 'K', 'v': 'M'}, {'u': 'O', 'v': 'P'}, {'u': 'O', 'v': 'Q'}, {'u': 'P', 'v': 'Q'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'I'}, {'u': 'H', 'v': 'I'}]}","[['D'], ['B', 'J'], ['C', 'I'], ['E', 'G', 'Q'], ['F', 'K', 'L', 'N', 'O'], ['A', 'H', 'M', 'P']]",2,nl,names
GCP,GCP,"I was helping the facilities crew pick paint swatches for every conference room in the building. The rule is simple: every room gets exactly one swatch, and if two rooms share a doorway they can’t be finished in the same swatch. The better plans are the ones that use fewer different swatches overall — you judge that by counting how many distinct swatches end up being used. Nothing can be skipped or double-covered: every room needs a single swatch and no pair of adjacent rooms may match. The concrete room-and-door layout is shown below.

# total_rooms=17
# total_doorways=72
room_a_id,room_b_id
K,C
K,G
K,H
K,I
K,J
K,L
K,M
K,N
K,P
L,C
L,G
L,H
L,I
L,J
L,M
L,N
L,P
M,C
M,G
M,H
M,I
M,J
M,N
M,P
I,C
I,G
I,H
I,J
I,N
I,P
N,C
N,G
N,H
N,J
N,P
D,A
D,B
D,C
D,E
D,F
D,O
O,A
O,B
O,C
O,E
O,F
O,Q
G,C
G,H
G,J
G,P
B,A
B,C
B,E
B,F
B,Q
E,A
E,C
E,F
E,Q
P,C
P,H
P,J
Q,A
Q,C
Q,F
A,C
A,F
F,C
H,C
H,J
C,J

Oh, and when you send the plan back, please follow this simple JSON layout so it's easy to read and check:

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

Think of each inner list as one paint swatch and the room IDs inside it as the rooms that get that swatch. The outer list is just the collection of swatches you used. This is only a sketch of the shape I want — not the final assignment.

Please make sure to use the exact room identifiers from the instance input — don’t rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 72, 'edges': [{'u': 11, 'v': 3}, {'u': 11, 'v': 7}, {'u': 11, 'v': 8}, {'u': 11, 'v': 9}, {'u': 11, 'v': 10}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 11, 'v': 16}, {'u': 12, 'v': 3}, {'u': 12, 'v': 7}, {'u': 12, 'v': 8}, {'u': 12, 'v': 9}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 16}, {'u': 13, 'v': 3}, {'u': 13, 'v': 7}, {'u': 13, 'v': 8}, {'u': 13, 'v': 9}, {'u': 13, 'v': 10}, {'u': 13, 'v': 14}, {'u': 13, 'v': 16}, {'u': 9, 'v': 3}, {'u': 9, 'v': 7}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 14}, {'u': 9, 'v': 16}, {'u': 14, 'v': 3}, {'u': 14, 'v': 7}, {'u': 14, 'v': 8}, {'u': 14, 'v': 10}, {'u': 14, 'v': 16}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 15}, {'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 3}, {'u': 15, 'v': 5}, {'u': 15, 'v': 6}, {'u': 15, 'v': 17}, {'u': 7, 'v': 3}, {'u': 7, 'v': 8}, {'u': 7, 'v': 10}, {'u': 7, 'v': 16}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 17}, {'u': 5, 'v': 1}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 17}, {'u': 16, 'v': 3}, {'u': 16, 'v': 8}, {'u': 16, 'v': 10}, {'u': 17, 'v': 1}, {'u': 17, 'v': 3}, {'u': 17, 'v': 6}, {'u': 1, 'v': 3}, {'u': 1, 'v': 6}, {'u': 6, 'v': 3}, {'u': 8, 'v': 3}, {'u': 8, 'v': 10}, {'u': 3, 'v': 10}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.5294117647058824, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0002.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0002.png', 'edge_connectivity': 6}","[[5, 12], [6, 11], [9], [1, 13], [10, 15], [2, 8], [4, 14, 17], [7], [16], [3]]",10.0,"{'num_nodes': 17, 'num_edges': 72, 'edges': [{'u': 'K', 'v': 'C'}, {'u': 'K', 'v': 'G'}, {'u': 'K', 'v': 'H'}, {'u': 'K', 'v': 'I'}, {'u': 'K', 'v': 'J'}, {'u': 'K', 'v': 'L'}, {'u': 'K', 'v': 'M'}, {'u': 'K', 'v': 'N'}, {'u': 'K', 'v': 'P'}, {'u': 'L', 'v': 'C'}, {'u': 'L', 'v': 'G'}, {'u': 'L', 'v': 'H'}, {'u': 'L', 'v': 'I'}, {'u': 'L', 'v': 'J'}, {'u': 'L', 'v': 'M'}, {'u': 'L', 'v': 'N'}, {'u': 'L', 'v': 'P'}, {'u': 'M', 'v': 'C'}, {'u': 'M', 'v': 'G'}, {'u': 'M', 'v': 'H'}, {'u': 'M', 'v': 'I'}, {'u': 'M', 'v': 'J'}, {'u': 'M', 'v': 'N'}, {'u': 'M', 'v': 'P'}, {'u': 'I', 'v': 'C'}, {'u': 'I', 'v': 'G'}, {'u': 'I', 'v': 'H'}, {'u': 'I', 'v': 'J'}, {'u': 'I', 'v': 'N'}, {'u': 'I', 'v': 'P'}, {'u': 'N', 'v': 'C'}, {'u': 'N', 'v': 'G'}, {'u': 'N', 'v': 'H'}, {'u': 'N', 'v': 'J'}, {'u': 'N', 'v': 'P'}, {'u': 'D', 'v': 'A'}, {'u': 'D', 'v': 'B'}, {'u': 'D', 'v': 'C'}, {'u': 'D', 'v': 'E'}, {'u': 'D', 'v': 'F'}, {'u': 'D', 'v': 'O'}, {'u': 'O', 'v': 'A'}, {'u': 'O', 'v': 'B'}, {'u': 'O', 'v': 'C'}, {'u': 'O', 'v': 'E'}, {'u': 'O', 'v': 'F'}, {'u': 'O', 'v': 'Q'}, {'u': 'G', 'v': 'C'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'J'}, {'u': 'G', 'v': 'P'}, {'u': 'B', 'v': 'A'}, {'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'E'}, {'u': 'B', 'v': 'F'}, {'u': 'B', 'v': 'Q'}, {'u': 'E', 'v': 'A'}, {'u': 'E', 'v': 'C'}, {'u': 'E', 'v': 'F'}, {'u': 'E', 'v': 'Q'}, {'u': 'P', 'v': 'C'}, {'u': 'P', 'v': 'H'}, {'u': 'P', 'v': 'J'}, {'u': 'Q', 'v': 'A'}, {'u': 'Q', 'v': 'C'}, {'u': 'Q', 'v': 'F'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'F'}, {'u': 'F', 'v': 'C'}, {'u': 'H', 'v': 'C'}, {'u': 'H', 'v': 'J'}, {'u': 'C', 'v': 'J'}]}","[['E', 'L'], ['F', 'K'], ['I'], ['A', 'M'], ['J', 'O'], ['B', 'H'], ['D', 'N', 'Q'], ['G'], ['P'], ['C']]",3,csv,names
GCP,GCP,"Someone at the shop suggested recoloring uniforms so that teammates standing next to each other never blend together, so the plan was to assign exactly one color to each employee and make sure adjacent coworkers have different colors. What makes one coloring better than another is how many separate colors the store needs — the smaller that count of distinct colors, the better the solution. The full list of counters, employees, and the concrete details are shown below.

There are 18 num employees in total and 71 num adjacent pairs.

| employee_u_id | employee_v_id |
|---|---|
| 1 | 2 |
| 1 | 3 |
| 1 | 4 |
| 1 | 5 |
| 1 | 6 |
| 1 | 7 |
| 1 | 8 |
| 1 | 9 |
| 1 | 10 |
| 2 | 3 |
| 2 | 4 |
| 2 | 5 |
| 2 | 6 |
| 2 | 7 |
| 2 | 8 |
| 2 | 9 |
| 2 | 10 |
| 11 | 12 |
| 12 | 10 |
| 12 | 13 |
| 12 | 14 |
| 12 | 15 |
| 12 | 16 |
| 12 | 17 |
| 12 | 18 |
| 4 | 3 |
| 4 | 5 |
| 4 | 6 |
| 4 | 7 |
| 4 | 8 |
| 4 | 9 |
| 4 | 10 |
| 5 | 3 |
| 5 | 6 |
| 5 | 7 |
| 5 | 8 |
| 5 | 9 |
| 5 | 10 |
| 6 | 3 |
| 6 | 7 |
| 6 | 8 |
| 6 | 9 |
| 6 | 10 |
| 7 | 3 |
| 7 | 8 |
| 7 | 9 |
| 7 | 10 |
| 16 | 10 |
| 16 | 14 |
| 16 | 15 |
| 16 | 17 |
| 16 | 18 |
| 17 | 10 |
| 17 | 14 |
| 17 | 15 |
| 17 | 18 |
| 10 | 3 |
| 10 | 8 |
| 10 | 9 |
| 10 | 13 |
| 10 | 14 |
| 10 | 15 |
| 10 | 18 |
| 18 | 14 |
| 18 | 15 |
| 8 | 3 |
| 8 | 9 |
| 9 | 3 |
| 13 | 14 |
| 13 | 15 |
| 14 | 15 |

Also, when you send the actual coloring back, please follow this simple JSON layout so it's easy to read and check. Here's a quick sketch of the shape I expect:

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

Each inner list is one color class — a list of employees who all share the same color (so nobody standing next to each other should be in the same inner list). This is just the shape I want, not the real answer.

One more thing: use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 18, 'num_edges': 71, 'edges': [{'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 2, 'v': 10}, {'u': 11, 'v': 12}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 12, 'v': 17}, {'u': 12, 'v': 18}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 4, 'v': 10}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 5, 'v': 9}, {'u': 5, 'v': 10}, {'u': 6, 'v': 3}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 7, 'v': 3}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 16, 'v': 10}, {'u': 16, 'v': 14}, {'u': 16, 'v': 15}, {'u': 16, 'v': 17}, {'u': 16, 'v': 18}, {'u': 17, 'v': 10}, {'u': 17, 'v': 14}, {'u': 17, 'v': 15}, {'u': 17, 'v': 18}, {'u': 10, 'v': 3}, {'u': 10, 'v': 8}, {'u': 10, 'v': 9}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 10, 'v': 18}, {'u': 18, 'v': 14}, {'u': 18, 'v': 15}, {'u': 8, 'v': 3}, {'u': 8, 'v': 9}, {'u': 9, 'v': 3}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 14, 'v': 15}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.46405228758169936, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0003.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0003.png', 'edge_connectivity': 1}","[[4, 11, 13, 17], [1, 14], [6], [3, 18], [10], [5, 12], [2, 16], [8], [9, 15], [7]]",10.0,"{'num_nodes': 18, 'num_edges': 71, 'edges': [{'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 2, 'v': 10}, {'u': 11, 'v': 12}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 12, 'v': 17}, {'u': 12, 'v': 18}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 4, 'v': 10}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 5, 'v': 9}, {'u': 5, 'v': 10}, {'u': 6, 'v': 3}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 7, 'v': 3}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 16, 'v': 10}, {'u': 16, 'v': 14}, {'u': 16, 'v': 15}, {'u': 16, 'v': 17}, {'u': 16, 'v': 18}, {'u': 17, 'v': 10}, {'u': 17, 'v': 14}, {'u': 17, 'v': 15}, {'u': 17, 'v': 18}, {'u': 10, 'v': 3}, {'u': 10, 'v': 8}, {'u': 10, 'v': 9}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 10, 'v': 18}, {'u': 18, 'v': 14}, {'u': 18, 'v': 15}, {'u': 8, 'v': 3}, {'u': 8, 'v': 9}, {'u': 9, 'v': 3}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 14, 'v': 15}]}","[[4, 11, 13, 17], [1, 14], [6], [3, 18], [10], [5, 12], [2, 16], [8], [9, 15], [7]]",4,markdown_table,1
GCP,GCP,"On our board, each task gets a colored tag and the rule is that any task linked as a dependency must have a different tag than the one it depends on. The goal is to keep the variety of tags low — evaluate this by counting the number of different tag colors used across the whole board, and aim for that count to be as small as possible. Leave no card untagged and never give the same tag to dependent pairs. The concrete details will be shown below.

# total_tasks=14
# total_dependencies=43
task_a_id,task_b_id
G,B
G,D
G,E
G,I
G,L
G,N
M,B
M,C
M,D
M,E
M,F
M,I
B,A
B,C
B,E
B,F
B,H
B,J
B,K
B,L
B,N
A,I
J,C
J,E
J,I
N,D
N,E
N,I
D,C
D,F
D,L
E,C
E,F
E,I
E,L
L,I
F,C
F,H
F,K
H,C
I,C
I,K
K,C

Also, just to keep things simple, please structure your reply to follow this little JSON layout.

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

Think of each inner list as one tag color: a list of tasks that all get the same colored tag. The first list is all tasks with one tag, the next list is another tag, and so on. This block is just a sketch of the shape I expect — not the actual tagging result.

One important note: use the exact identifiers from the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 43, 'edges': [{'u': 7, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 9}, {'u': 7, 'v': 12}, {'u': 7, 'v': 14}, {'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 4}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 9}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 8}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 2, 'v': 14}, {'u': 1, 'v': 9}, {'u': 10, 'v': 3}, {'u': 10, 'v': 5}, {'u': 10, 'v': 9}, {'u': 14, 'v': 4}, {'u': 14, 'v': 5}, {'u': 14, 'v': 9}, {'u': 4, 'v': 3}, {'u': 4, 'v': 6}, {'u': 4, 'v': 12}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 9}, {'u': 5, 'v': 12}, {'u': 12, 'v': 9}, {'u': 6, 'v': 3}, {'u': 6, 'v': 8}, {'u': 6, 'v': 11}, {'u': 8, 'v': 3}, {'u': 9, 'v': 3}, {'u': 9, 'v': 11}, {'u': 11, 'v': 3}], 'source_file': 'citationCiteseer.mtx', 'density': 0.4725274725274725, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0004.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0004.png', 'edge_connectivity': 2}","[[1, 3, 12, 14], [2, 4, 9], [5, 11], [6], [7, 8, 10, 13]]",5.0,"{'num_nodes': 14, 'num_edges': 43, 'edges': [{'u': 'G', 'v': 'B'}, {'u': 'G', 'v': 'D'}, {'u': 'G', 'v': 'E'}, {'u': 'G', 'v': 'I'}, {'u': 'G', 'v': 'L'}, {'u': 'G', 'v': 'N'}, {'u': 'M', 'v': 'B'}, {'u': 'M', 'v': 'C'}, {'u': 'M', 'v': 'D'}, {'u': 'M', 'v': 'E'}, {'u': 'M', 'v': 'F'}, {'u': 'M', 'v': 'I'}, {'u': 'B', 'v': 'A'}, {'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'E'}, {'u': 'B', 'v': 'F'}, {'u': 'B', 'v': 'H'}, {'u': 'B', 'v': 'J'}, {'u': 'B', 'v': 'K'}, {'u': 'B', 'v': 'L'}, {'u': 'B', 'v': 'N'}, {'u': 'A', 'v': 'I'}, {'u': 'J', 'v': 'C'}, {'u': 'J', 'v': 'E'}, {'u': 'J', 'v': 'I'}, {'u': 'N', 'v': 'D'}, {'u': 'N', 'v': 'E'}, {'u': 'N', 'v': 'I'}, {'u': 'D', 'v': 'C'}, {'u': 'D', 'v': 'F'}, {'u': 'D', 'v': 'L'}, {'u': 'E', 'v': 'C'}, {'u': 'E', 'v': 'F'}, {'u': 'E', 'v': 'I'}, {'u': 'E', 'v': 'L'}, {'u': 'L', 'v': 'I'}, {'u': 'F', 'v': 'C'}, {'u': 'F', 'v': 'H'}, {'u': 'F', 'v': 'K'}, {'u': 'H', 'v': 'C'}, {'u': 'I', 'v': 'C'}, {'u': 'I', 'v': 'K'}, {'u': 'K', 'v': 'C'}]}","[['A', 'C', 'L', 'N'], ['B', 'D', 'I'], ['E', 'K'], ['F'], ['G', 'H', 'J', 'M']]",5,csv,names
GCP,GCP,"There’s a shop display with mannequins arranged in a pattern, and the task is to give each mannequin a garment color in a way that any pair of mannequins next to one another wear different colors. Nothing can be left undecided — each mannequin needs exactly one color — and the aim is to make the whole display look coordinated by using as few different colors as possible. One way to judge which dressing plan wins is to count how many distinct colors were used; the smaller that count, the better. The specific arrangement and numbers are shown below.

There are 16 mannequins in total and 41 adjacent pairs count.

| mannequin_a_id | mannequin_b_id |
|---|---|
| 5 | 2 |
| 5 | 3 |
| 5 | 4 |
| 9 | 2 |
| 9 | 10 |
| 9 | 11 |
| 9 | 12 |
| 9 | 13 |
| 9 | 14 |
| 9 | 15 |
| 0 | 2 |
| 10 | 2 |
| 10 | 11 |
| 10 | 12 |
| 10 | 13 |
| 10 | 14 |
| 10 | 15 |
| 6 | 2 |
| 6 | 7 |
| 7 | 2 |
| 11 | 2 |
| 11 | 12 |
| 11 | 13 |
| 11 | 14 |
| 11 | 15 |
| 12 | 2 |
| 12 | 13 |
| 12 | 14 |
| 12 | 15 |
| 13 | 2 |
| 13 | 14 |
| 13 | 15 |
| 14 | 2 |
| 14 | 15 |
| 15 | 2 |
| 1 | 2 |
| 1 | 8 |
| 8 | 2 |
| 2 | 3 |
| 2 | 4 |
| 3 | 4 |

If you want to send the dressing plan in a simple, predictable way, just use a little JSON sketch like this:

{
  ""solution"": [
    [""mannequin_id"", ""mannequin_id"", ""mannequin_id""],
    [""mannequin_id"", ""mannequin_id""],
    [""mannequin_id""]
  ]
}

Super casual explanation: ""solution"" is a list of color groups, and each inner list contains the mannequins that would wear the same color. Think of each inner array as one color bucket — list the mannequin identifiers that share that color. This block is only a sketch of the expected shape, not the actual answer.

Please make sure to use the exact identifiers from the instance input — do not rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 41, 'edges': [{'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 10, 'v': 3}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 10, 'v': 16}, {'u': 1, 'v': 3}, {'u': 11, 'v': 3}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 11, 'v': 15}, {'u': 11, 'v': 16}, {'u': 7, 'v': 3}, {'u': 7, 'v': 8}, {'u': 8, 'v': 3}, {'u': 12, 'v': 3}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 13, 'v': 3}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 14, 'v': 3}, {'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 15, 'v': 3}, {'u': 15, 'v': 16}, {'u': 16, 'v': 3}, {'u': 2, 'v': 3}, {'u': 2, 'v': 9}, {'u': 9, 'v': 3}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 4, 'v': 5}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.3416666666666667, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0005.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0005.png', 'edge_connectivity': 1}","[[1, 6, 7, 9, 13], [5, 10], [11], [3], [14], [16], [12], [2, 4, 8, 15]]",8.0,"{'num_nodes': 16, 'num_edges': 41, 'edges': [{'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 4}, {'u': 9, 'v': 2}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 9, 'v': 15}, {'u': 0, 'v': 2}, {'u': 10, 'v': 2}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 6, 'v': 2}, {'u': 6, 'v': 7}, {'u': 7, 'v': 2}, {'u': 11, 'v': 2}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 11, 'v': 15}, {'u': 12, 'v': 2}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 13, 'v': 2}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 14, 'v': 2}, {'u': 14, 'v': 15}, {'u': 15, 'v': 2}, {'u': 1, 'v': 2}, {'u': 1, 'v': 8}, {'u': 8, 'v': 2}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 3, 'v': 4}]}","[[0, 5, 6, 8, 12], [4, 9], [10], [2], [13], [15], [11], [1, 3, 7, 14]]",6,markdown_table,0
GCP,GCP,"Recently a small team was given a drawn map made of touching regions and told to assign a single marker hue to each region so that touching regions don’t match. Each region must get one hue and only one, and the winning approach is the one that ends up using the fewest distinct hues — just count how many different colors are on the paper. The full map and its regions are shown below.

# total_regions=14
# total_adjacencies=26
region_id_a,region_id_b
5,3
5,4
5,6
5,7
5,11
11,7
11,13
11,14
6,3
6,4
14,4
9,4
9,10
10,4
7,1
7,2
7,3
7,8
7,12
8,2
8,3
12,1
1,2
1,3
2,3
3,4

If you want to give the coloring back in a predictable layout, just use a little JSON sketch like this:

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

Think of ""solution"" as a list of groups, and each inner list is the set of regions that get the same hue (so each inner list is one color on the map). The strings are placeholders for the region identifiers from the map. This block is just the expected shape — a sketch of the format, not the actual coloring.

Please make sure you use the exact region identifiers from the instance input — don't rename them or invent new labels. For example: ""1"", ""23"", ""A"", ""B"", ""A1"", ""X7"".","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 26, 'edges': [{'u': 5, 'v': 3}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 11}, {'u': 11, 'v': 7}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 14, 'v': 4}, {'u': 9, 'v': 4}, {'u': 9, 'v': 10}, {'u': 10, 'v': 4}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 8}, {'u': 7, 'v': 12}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 12, 'v': 1}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 2, 'v': 3}, {'u': 3, 'v': 4}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.2857142857142857, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0006.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0006.png', 'edge_connectivity': 1}","[[1, 6, 8, 10, 11], [3, 9, 12], [2, 5, 14], [4, 7, 13]]",4.0,"{'num_nodes': 14, 'num_edges': 26, 'edges': [{'u': 5, 'v': 3}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 11}, {'u': 11, 'v': 7}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 14, 'v': 4}, {'u': 9, 'v': 4}, {'u': 9, 'v': 10}, {'u': 10, 'v': 4}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 8}, {'u': 7, 'v': 12}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 12, 'v': 1}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 2, 'v': 3}, {'u': 3, 'v': 4}]}","[[1, 6, 8, 10, 11], [3, 9, 12], [2, 5, 14], [4, 7, 13]]",7,csv,1
GCP,GCP,"Imagine a grid of radio masts that all need a channel: the rule was simple — each mast gets one frequency, and if two mast coverages touch, they must be on different frequencies. Better solutions use fewer distinct frequencies; to see how good a setup is, count all the different frequencies actually used. Don’t skip any mast or give any mast multiple frequencies, and only reuse a frequency when overlapping isn’t an issue. The detailed instance is below.

This instance has 17 masts and 39 overlapping pairs:
Mast 1 overlaps with mast 2; they must be assigned different frequencies.
Mast 1 overlaps with mast 7; they must be assigned different frequencies.
Mast 1 overlaps with mast 9; they must be assigned different frequencies.
Mast 1 overlaps with mast 10; they must be assigned different frequencies.
Mast 1 overlaps with mast 11; they must be assigned different frequencies.
Mast 2 overlaps with mast 4; they must be assigned different frequencies.
Mast 2 overlaps with mast 7; they must be assigned different frequencies.
Mast 2 overlaps with mast 8; they must be assigned different frequencies.
Mast 2 overlaps with mast 9; they must be assigned different frequencies.
Mast 2 overlaps with mast 10; they must be assigned different frequencies.
Mast 2 overlaps with mast 11; they must be assigned different frequencies.
Mast 2 overlaps with mast 12; they must be assigned different frequencies.
Mast 5 overlaps with mast 6; they must be assigned different frequencies.
Mast 5 overlaps with mast 14; they must be assigned different frequencies.
Mast 5 overlaps with mast 15; they must be assigned different frequencies.
Mast 5 overlaps with mast 16; they must be assigned different frequencies.
Mast 13 overlaps with mast 17; they must be assigned different frequencies.
Mast 3 overlaps with mast 4; they must be assigned different frequencies.
Mast 3 overlaps with mast 8; they must be assigned different frequencies.
Mast 3 overlaps with mast 10; they must be assigned different frequencies.
Mast 3 overlaps with mast 11; they must be assigned different frequencies.
Mast 3 overlaps with mast 12; they must be assigned different frequencies.
Mast 4 overlaps with mast 8; they must be assigned different frequencies.
Mast 4 overlaps with mast 10; they must be assigned different frequencies.
Mast 4 overlaps with mast 11; they must be assigned different frequencies.
Mast 4 overlaps with mast 12; they must be assigned different frequencies.
Mast 10 overlaps with mast 7; they must be assigned different frequencies.
Mast 10 overlaps with mast 8; they must be assigned different frequencies.
Mast 10 overlaps with mast 9; they must be assigned different frequencies.
Mast 10 overlaps with mast 11; they must be assigned different frequencies.
Mast 10 overlaps with mast 12; they must be assigned different frequencies.
Mast 8 overlaps with mast 11; they must be assigned different frequencies.
Mast 16 overlaps with mast 11; they must be assigned different frequencies.
Mast 16 overlaps with mast 17; they must be assigned different frequencies.
Mast 11 overlaps with mast 7; they must be assigned different frequencies.
Mast 11 overlaps with mast 9; they must be assigned different frequencies.
Mast 11 overlaps with mast 12; they must be assigned different frequencies.
Mast 11 overlaps with mast 17; they must be assigned different frequencies.
Mast 9 overlaps with mast 7; they must be assigned different frequencies.
Assign exactly one frequency per mast and respect all 39 overlap constraints among the 17 masts.

If you want to hand me an answer, just stick to this simple JSON shape so I can read it easily — nothing fancy, just a list of groups. For this radio-mast story I tweaked the placeholder names to match the setting.

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

Think of each inner list as all the masts that share the same frequency (so each list is one channel), and the outer list collects all the different channels you used. It's just a sketch of the shape I expect, not the real assignment — you'll fill in the actual mast identifiers from the instance.

Please use the exact identifiers from the instance input — don't rename them and don't invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 39, 'edges': [{'u': 1, 'v': 2}, {'u': 1, 'v': 7}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 2, 'v': 4}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 5, 'v': 6}, {'u': 5, 'v': 14}, {'u': 5, 'v': 15}, {'u': 5, 'v': 16}, {'u': 13, 'v': 17}, {'u': 3, 'v': 4}, {'u': 3, 'v': 8}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 4, 'v': 8}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 9}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 8, 'v': 11}, {'u': 16, 'v': 11}, {'u': 16, 'v': 17}, {'u': 11, 'v': 7}, {'u': 11, 'v': 9}, {'u': 11, 'v': 12}, {'u': 11, 'v': 17}, {'u': 9, 'v': 7}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.2867647058823529, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0007.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0007.png', 'edge_connectivity': 1}","[[4, 5, 7, 17], [11], [1, 13], [10], [6, 8, 9, 12, 14, 15, 16], [2, 3]]",6.0,"{'num_nodes': 17, 'num_edges': 39, 'edges': [{'u': 1, 'v': 2}, {'u': 1, 'v': 7}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 2, 'v': 4}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 5, 'v': 6}, {'u': 5, 'v': 14}, {'u': 5, 'v': 15}, {'u': 5, 'v': 16}, {'u': 13, 'v': 17}, {'u': 3, 'v': 4}, {'u': 3, 'v': 8}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 4, 'v': 8}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 9}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 8, 'v': 11}, {'u': 16, 'v': 11}, {'u': 16, 'v': 17}, {'u': 11, 'v': 7}, {'u': 11, 'v': 9}, {'u': 11, 'v': 12}, {'u': 11, 'v': 17}, {'u': 9, 'v': 7}]}","[[4, 5, 7, 17], [11], [1, 13], [10], [6, 8, 9, 12, 14, 15, 16], [2, 3]]",8,nl,1
GCP,GCP,"There’s a small challenge in the backroom: label every category on a shelf with a color, but whenever two categories sit next to one another they must have different colors. A good labeling uses as few different colors as possible — simply count how many distinct colors appear, and aim for that to be as low as it can go. Nothing can be skipped; every category needs one label, and reuse is allowed only when categories aren’t adjacent. The detailed instance (who sits where) appears below.

{
  ""num_categories"": 15,
  ""num_adjacent_pairs"": 33,
  ""edges"": [
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""A""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""B""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""E""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""G""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""H""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""I""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""J""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""K""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""L""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""M""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""N""
    },
    {
      ""category_a_id"": ""C"",
      ""category_b_id"": ""O""
    },
    {
      ""category_a_id"": ""H"",
      ""category_b_id"": ""E""
    },
    {
      ""category_a_id"": ""H"",
      ""category_b_id"": ""G""
    },
    {
      ""category_a_id"": ""H"",
      ""category_b_id"": ""I""
    },
    {
      ""category_a_id"": ""H"",
      ""category_b_id"": ""M""
    },
    {
      ""category_a_id"": ""F"",
      ""category_b_id"": ""A""
    },
    {
      ""category_a_id"": ""J"",
      ""category_b_id"": ""K""
    },
    {
      ""category_a_id"": ""J"",
      ""category_b_id"": ""L""
    },
    {
      ""category_a_id"": ""K"",
      ""category_b_id"": ""L""
    },
    {
      ""category_a_id"": ""L"",
      ""category_b_id"": ""A""
    },
    {
      ""category_a_id"": ""L"",
      ""category_b_id"": ""N""
    },
    {
      ""category_a_id"": ""L"",
      ""category_b_id"": ""O""
    },
    {
      ""category_a_id"": ""A"",
      ""category_b_id"": ""D""
    },
    {
      ""category_a_id"": ""A"",
      ""category_b_id"": ""N""
    },
    {
      ""category_a_id"": ""A"",
      ""category_b_id"": ""O""
    },
    {
      ""category_a_id"": ""E"",
      ""category_b_id"": ""G""
    },
    {
      ""category_a_id"": ""E"",
      ""category_b_id"": ""I""
    },
    {
      ""category_a_id"": ""E"",
      ""category_b_id"": ""M""
    },
    {
      ""category_a_id"": ""G"",
      ""category_b_id"": ""I""
    },
    {
      ""category_a_id"": ""G"",
      ""category_b_id"": ""M""
    },
    {
      ""category_a_id"": ""M"",
      ""category_b_id"": ""I""
    },
    {
      ""category_a_id"": ""N"",
      ""category_b_id"": ""O""
    }
  ]
}

Also, when you send back the labeling, please use this JSON layout so it's easy to read and check:

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

Pretty simple: ""solution"" is a list of color groups, and each inner list contains the category IDs that all share the same color on the shelf. Think of each inner array as one color’s set of labels. This block is just a sketch of the expected shape — not the actual answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.

""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 33, 'edges': [{'u': 3, 'v': 1}, {'u': 3, 'v': 2}, {'u': 3, 'v': 5}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 3, 'v': 13}, {'u': 3, 'v': 14}, {'u': 3, 'v': 15}, {'u': 8, 'v': 5}, {'u': 8, 'v': 7}, {'u': 8, 'v': 9}, {'u': 8, 'v': 13}, {'u': 6, 'v': 1}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 11, 'v': 12}, {'u': 12, 'v': 1}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 1, 'v': 4}, {'u': 1, 'v': 14}, {'u': 1, 'v': 15}, {'u': 5, 'v': 7}, {'u': 5, 'v': 9}, {'u': 5, 'v': 13}, {'u': 7, 'v': 9}, {'u': 7, 'v': 13}, {'u': 13, 'v': 9}, {'u': 14, 'v': 15}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.3142857142857143, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0008.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0008.png', 'edge_connectivity': 1}","[[2, 4, 6, 11, 13, 14], [3], [7], [9, 12], [1, 5], [8, 10, 15]]",6.0,"{'num_nodes': 15, 'num_edges': 33, 'edges': [{'u': 'C', 'v': 'A'}, {'u': 'C', 'v': 'B'}, {'u': 'C', 'v': 'E'}, {'u': 'C', 'v': 'G'}, {'u': 'C', 'v': 'H'}, {'u': 'C', 'v': 'I'}, {'u': 'C', 'v': 'J'}, {'u': 'C', 'v': 'K'}, {'u': 'C', 'v': 'L'}, {'u': 'C', 'v': 'M'}, {'u': 'C', 'v': 'N'}, {'u': 'C', 'v': 'O'}, {'u': 'H', 'v': 'E'}, {'u': 'H', 'v': 'G'}, {'u': 'H', 'v': 'I'}, {'u': 'H', 'v': 'M'}, {'u': 'F', 'v': 'A'}, {'u': 'J', 'v': 'K'}, {'u': 'J', 'v': 'L'}, {'u': 'K', 'v': 'L'}, {'u': 'L', 'v': 'A'}, {'u': 'L', 'v': 'N'}, {'u': 'L', 'v': 'O'}, {'u': 'A', 'v': 'D'}, {'u': 'A', 'v': 'N'}, {'u': 'A', 'v': 'O'}, {'u': 'E', 'v': 'G'}, {'u': 'E', 'v': 'I'}, {'u': 'E', 'v': 'M'}, {'u': 'G', 'v': 'I'}, {'u': 'G', 'v': 'M'}, {'u': 'M', 'v': 'I'}, {'u': 'N', 'v': 'O'}]}","[['B', 'D', 'F', 'K', 'M', 'N'], ['C'], ['G'], ['I', 'L'], ['A', 'E'], ['H', 'J', 'O']]",9,json,names
GCP,GCP,"At a cozy café, the staff needs to pick a pattern for each chair so that any chairs that touch don’t share the same pattern, and no chair is skipped or double-covered. The goal is to keep the number of different patterns as small as possible, and that is judged by tallying up the unique patterns used across all the chairs. The concrete seating layout and details are shown below.

There are 15 chairs in total and 52 touching pairs count.

| chair_id_u | chair_id_v |
|---|---|
| 2 | 1 |
| 2 | 3 |
| 2 | 4 |
| 2 | 5 |
| 2 | 6 |
| 2 | 7 |
| 2 | 10 |
| 2 | 11 |
| 2 | 12 |
| 2 | 13 |
| 3 | 1 |
| 3 | 4 |
| 3 | 5 |
| 3 | 6 |
| 3 | 7 |
| 3 | 8 |
| 3 | 9 |
| 3 | 10 |
| 3 | 11 |
| 3 | 12 |
| 3 | 13 |
| 3 | 14 |
| 3 | 15 |
| 5 | 4 |
| 5 | 7 |
| 5 | 13 |
| 6 | 4 |
| 6 | 7 |
| 6 | 10 |
| 6 | 11 |
| 6 | 12 |
| 8 | 9 |
| 8 | 10 |
| 13 | 1 |
| 13 | 4 |
| 13 | 7 |
| 13 | 10 |
| 13 | 14 |
| 13 | 15 |
| 14 | 10 |
| 14 | 15 |
| 15 | 10 |
| 4 | 7 |
| 4 | 10 |
| 4 | 11 |
| 4 | 12 |
| 11 | 7 |
| 11 | 10 |
| 11 | 12 |
| 12 | 7 |
| 12 | 10 |
| 7 | 10 |

Also, if you want to hand me a candidate seating plan, just drop it in this simple JSON shape so I can read it easily:

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

Think of each inner list as one pattern — a group of chairs that all share the same pattern. Replace the ""chair_id"" placeholders with the actual chair labels from the seating instance. This is just a sketch of the shape I expect, not the real answer itself.

Please be sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 52, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 2, 'v': 13}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 3, 'v': 13}, {'u': 3, 'v': 14}, {'u': 3, 'v': 15}, {'u': 5, 'v': 4}, {'u': 5, 'v': 7}, {'u': 5, 'v': 13}, {'u': 6, 'v': 4}, {'u': 6, 'v': 7}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 6, 'v': 12}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 13, 'v': 1}, {'u': 13, 'v': 4}, {'u': 13, 'v': 7}, {'u': 13, 'v': 10}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 14, 'v': 10}, {'u': 14, 'v': 15}, {'u': 15, 'v': 10}, {'u': 4, 'v': 7}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 11, 'v': 7}, {'u': 11, 'v': 10}, {'u': 11, 'v': 12}, {'u': 12, 'v': 7}, {'u': 12, 'v': 10}, {'u': 7, 'v': 10}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.49523809523809526, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0009.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0009.png', 'edge_connectivity': 2}","[[11, 13], [12], [1, 10], [4, 14], [3], [7], [5, 6, 9, 15], [2, 8]]",8.0,"{'num_nodes': 15, 'num_edges': 52, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 2, 'v': 13}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 3, 'v': 13}, {'u': 3, 'v': 14}, {'u': 3, 'v': 15}, {'u': 5, 'v': 4}, {'u': 5, 'v': 7}, {'u': 5, 'v': 13}, {'u': 6, 'v': 4}, {'u': 6, 'v': 7}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 6, 'v': 12}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 13, 'v': 1}, {'u': 13, 'v': 4}, {'u': 13, 'v': 7}, {'u': 13, 'v': 10}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 14, 'v': 10}, {'u': 14, 'v': 15}, {'u': 15, 'v': 10}, {'u': 4, 'v': 7}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 11, 'v': 7}, {'u': 11, 'v': 10}, {'u': 11, 'v': 12}, {'u': 12, 'v': 7}, {'u': 12, 'v': 10}, {'u': 7, 'v': 10}]}","[[11, 13], [12], [1, 10], [4, 14], [3], [7], [5, 6, 9, 15], [2, 8]]",10,markdown_table,1
GCP,GCP,"At a small festival the organizers needed to pick colors for volunteer badges so partners on a shift don’t match and no volunteer is skipped or given multiple colors. The choice is to assign one color per person under that no-same-color-for-teammates rule, while trying not to introduce more color types than necessary. You can judge a setup by counting how many distinct colors it uses — the fewer the better. The concrete volunteer list and who works with whom are coming up below.

{
  ""total_volunteers"": 13,
  ""total_shift_pairs"": 23,
  ""edges"": [
    {
      ""volunteer_a_id"": ""H"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""H"",
      ""volunteer_b_id"": ""E""
    },
    {
      ""volunteer_a_id"": ""H"",
      ""volunteer_b_id"": ""F""
    },
    {
      ""volunteer_a_id"": ""H"",
      ""volunteer_b_id"": ""G""
    },
    {
      ""volunteer_a_id"": ""L"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""L"",
      ""volunteer_b_id"": ""M""
    },
    {
      ""volunteer_a_id"": ""M"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""I"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""I"",
      ""volunteer_b_id"": ""J""
    },
    {
      ""volunteer_a_id"": ""I"",
      ""volunteer_b_id"": ""K""
    },
    {
      ""volunteer_a_id"": ""J"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""J"",
      ""volunteer_b_id"": ""K""
    },
    {
      ""volunteer_a_id"": ""K"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""C"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""C"",
      ""volunteer_b_id"": ""D""
    },
    {
      ""volunteer_a_id"": ""D"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""B"",
      ""volunteer_b_id"": ""A""
    },
    {
      ""volunteer_a_id"": ""A"",
      ""volunteer_b_id"": ""E""
    },
    {
      ""volunteer_a_id"": ""A"",
      ""volunteer_b_id"": ""F""
    },
    {
      ""volunteer_a_id"": ""A"",
      ""volunteer_b_id"": ""G""
    },
    {
      ""volunteer_a_id"": ""E"",
      ""volunteer_b_id"": ""F""
    },
    {
      ""volunteer_a_id"": ""E"",
      ""volunteer_b_id"": ""G""
    },
    {
      ""volunteer_a_id"": ""F"",
      ""volunteer_b_id"": ""G""
    }
  ]
}

Oh, and when you send back the badge assignment, please use this simple JSON layout so it's easy to check:

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

Here ""solution"" is a list of color groups. Each inner array is a set of volunteers who all get the same badge color (so teammates should never appear together in the same inner array). Think of each inner array as one color bucket where you list the volunteer identifiers who share that color. This block is just a sketch of the shape I expect — not the actual answer.

Please make sure you use the exact volunteer identifiers given in the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 13, 'num_edges': 23, 'edges': [{'u': 8, 'v': 1}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 12, 'v': 1}, {'u': 12, 'v': 13}, {'u': 13, 'v': 1}, {'u': 9, 'v': 1}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 10, 'v': 1}, {'u': 10, 'v': 11}, {'u': 11, 'v': 1}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 4, 'v': 1}, {'u': 2, 'v': 1}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 6, 'v': 7}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.2948717948717949, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0010.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0010.png', 'edge_connectivity': 1}","[[2, 4, 6, 9, 13], [1], [8, 10], [5], [3, 7, 11, 12]]",5.0,"{'num_nodes': 13, 'num_edges': 23, 'edges': [{'u': 'H', 'v': 'A'}, {'u': 'H', 'v': 'E'}, {'u': 'H', 'v': 'F'}, {'u': 'H', 'v': 'G'}, {'u': 'L', 'v': 'A'}, {'u': 'L', 'v': 'M'}, {'u': 'M', 'v': 'A'}, {'u': 'I', 'v': 'A'}, {'u': 'I', 'v': 'J'}, {'u': 'I', 'v': 'K'}, {'u': 'J', 'v': 'A'}, {'u': 'J', 'v': 'K'}, {'u': 'K', 'v': 'A'}, {'u': 'C', 'v': 'A'}, {'u': 'C', 'v': 'D'}, {'u': 'D', 'v': 'A'}, {'u': 'B', 'v': 'A'}, {'u': 'A', 'v': 'E'}, {'u': 'A', 'v': 'F'}, {'u': 'A', 'v': 'G'}, {'u': 'E', 'v': 'F'}, {'u': 'E', 'v': 'G'}, {'u': 'F', 'v': 'G'}]}","[['B', 'D', 'F', 'I', 'M'], ['A'], ['H', 'J'], ['E'], ['C', 'G', 'K', 'L']]",11,json,names
GCP,GCP,"There’s a block of flats that needs painting, and the puzzle is to give each apartment a single finish so that any two apartments with a common wall are painted differently, while keeping the total number of different finishes to a minimum. The practical question is which finish to put on each apartment; a plan that uses fewer different finishes is preferable. To evaluate a setup, count how many unique finishes appear in the building — the fewer unique finishes, the better — and don’t forget every unit must get one finish and adjacent units can’t be the same. The concrete details follow below.

There are 18 apartments and 41 shared walls.
Apartment N shares a wall with apartment G; they must be painted with different finishes.
Apartment N shares a wall with apartment I; they must be painted with different finishes.
Apartment N shares a wall with apartment J; they must be painted with different finishes.
Apartment N shares a wall with apartment K; they must be painted with different finishes.
Apartment N shares a wall with apartment L; they must be painted with different finishes.
Apartment N shares a wall with apartment M; they must be painted with different finishes.
Apartment H shares a wall with apartment A; they must be painted with different finishes.
Apartment H shares a wall with apartment D; they must be painted with different finishes.
Apartment H shares a wall with apartment G; they must be painted with different finishes.
Apartment H shares a wall with apartment O; they must be painted with different finishes.
Apartment H shares a wall with apartment R; they must be painted with different finishes.
Apartment D shares a wall with apartment A; they must be painted with different finishes.
Apartment D shares a wall with apartment B; they must be painted with different finishes.
Apartment D shares a wall with apartment C; they must be painted with different finishes.
Apartment D shares a wall with apartment G; they must be painted with different finishes.
Apartment D shares a wall with apartment O; they must be painted with different finishes.
Apartment D shares a wall with apartment R; they must be painted with different finishes.
Apartment A shares a wall with apartment O; they must be painted with different finishes.
Apartment J shares a wall with apartment G; they must be painted with different finishes.
Apartment J shares a wall with apartment I; they must be painted with different finishes.
Apartment J shares a wall with apartment K; they must be painted with different finishes.
Apartment J shares a wall with apartment L; they must be painted with different finishes.
Apartment J shares a wall with apartment M; they must be painted with different finishes.
Apartment I shares a wall with apartment G; they must be painted with different finishes.
Apartment I shares a wall with apartment K; they must be painted with different finishes.
Apartment I shares a wall with apartment L; they must be painted with different finishes.
Apartment I shares a wall with apartment M; they must be painted with different finishes.
Apartment K shares a wall with apartment G; they must be painted with different finishes.
Apartment K shares a wall with apartment L; they must be painted with different finishes.
Apartment K shares a wall with apartment M; they must be painted with different finishes.
Apartment B shares a wall with apartment C; they must be painted with different finishes.
Apartment E shares a wall with apartment F; they must be painted with different finishes.
Apartment E shares a wall with apartment G; they must be painted with different finishes.
Apartment F shares a wall with apartment G; they must be painted with different finishes.
Apartment G shares a wall with apartment L; they must be painted with different finishes.
Apartment G shares a wall with apartment M; they must be painted with different finishes.
Apartment G shares a wall with apartment R; they must be painted with different finishes.
Apartment P shares a wall with apartment Q; they must be painted with different finishes.
Apartment P shares a wall with apartment R; they must be painted with different finishes.
Apartment Q shares a wall with apartment R; they must be painted with different finishes.
Apartment L shares a wall with apartment M; they must be painted with different finishes.
Each apartment must receive one finish; adjacent apartments cannot have the same finish, and the aim is to minimize the number of distinct finishes used.

Also, when you send the solution back, please follow this simple JSON layout so I can read it easily — something like:

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

Think of each inner list as one finish (one color) and the apartment_id strings inside as the apartments that get that finish. This block is just a sketch of the shape I expect, not the actual assignment.

Please make sure you use the apartment (vertex) identifiers exactly as they appear in the instance input — do not rename them or introduce any new labels. 
- for example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 18, 'num_edges': 41, 'edges': [{'u': 14, 'v': 7}, {'u': 14, 'v': 9}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 14, 'v': 13}, {'u': 8, 'v': 1}, {'u': 8, 'v': 4}, {'u': 8, 'v': 7}, {'u': 8, 'v': 15}, {'u': 8, 'v': 18}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 7}, {'u': 4, 'v': 15}, {'u': 4, 'v': 18}, {'u': 1, 'v': 15}, {'u': 10, 'v': 7}, {'u': 10, 'v': 9}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 9, 'v': 7}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 11, 'v': 7}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 2, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 6, 'v': 7}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 7, 'v': 18}, {'u': 16, 'v': 17}, {'u': 16, 'v': 18}, {'u': 17, 'v': 18}, {'u': 12, 'v': 13}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.2679738562091503, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0011.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0011.png', 'edge_connectivity': 2}","[[10, 17], [7, 16], [1, 12, 18], [3, 14], [4, 9], [2, 6, 11, 15], [5, 8, 13]]",7.0,"{'num_nodes': 18, 'num_edges': 41, 'edges': [{'u': 'N', 'v': 'G'}, {'u': 'N', 'v': 'I'}, {'u': 'N', 'v': 'J'}, {'u': 'N', 'v': 'K'}, {'u': 'N', 'v': 'L'}, {'u': 'N', 'v': 'M'}, {'u': 'H', 'v': 'A'}, {'u': 'H', 'v': 'D'}, {'u': 'H', 'v': 'G'}, {'u': 'H', 'v': 'O'}, {'u': 'H', 'v': 'R'}, {'u': 'D', 'v': 'A'}, {'u': 'D', 'v': 'B'}, {'u': 'D', 'v': 'C'}, {'u': 'D', 'v': 'G'}, {'u': 'D', 'v': 'O'}, {'u': 'D', 'v': 'R'}, {'u': 'A', 'v': 'O'}, {'u': 'J', 'v': 'G'}, {'u': 'J', 'v': 'I'}, {'u': 'J', 'v': 'K'}, {'u': 'J', 'v': 'L'}, {'u': 'J', 'v': 'M'}, {'u': 'I', 'v': 'G'}, {'u': 'I', 'v': 'K'}, {'u': 'I', 'v': 'L'}, {'u': 'I', 'v': 'M'}, {'u': 'K', 'v': 'G'}, {'u': 'K', 'v': 'L'}, {'u': 'K', 'v': 'M'}, {'u': 'B', 'v': 'C'}, {'u': 'E', 'v': 'F'}, {'u': 'E', 'v': 'G'}, {'u': 'F', 'v': 'G'}, {'u': 'G', 'v': 'L'}, {'u': 'G', 'v': 'M'}, {'u': 'G', 'v': 'R'}, {'u': 'P', 'v': 'Q'}, {'u': 'P', 'v': 'R'}, {'u': 'Q', 'v': 'R'}, {'u': 'L', 'v': 'M'}]}","[['J', 'Q'], ['G', 'P'], ['A', 'L', 'R'], ['C', 'N'], ['D', 'I'], ['B', 'F', 'K', 'O'], ['E', 'H', 'M']]",12,nl,names
GCP,GCP,"In the office it came up that the archive needed consistent categories: each file gets a single label, and whenever two files reference each other they have to be labeled differently. The task is to work out which label goes on which file. A labeling is preferable if it keeps the number of different labels small — check this by counting the distinct labels used — while making sure no file is left without a label and no file ends up with more than one, and linked files never share a label. The specific file map is shown below.

There are 17 files in total and 72 cross references.

| file_id_1 | file_id_2 |
|---|---|
| 9 | 6 |
| 9 | 10 |
| 9 | 11 |
| 9 | 12 |
| 9 | 13 |
| 9 | 14 |
| 9 | 15 |
| 9 | 16 |
| 10 | 6 |
| 10 | 11 |
| 10 | 12 |
| 10 | 13 |
| 10 | 14 |
| 10 | 15 |
| 10 | 16 |
| 11 | 6 |
| 11 | 12 |
| 11 | 13 |
| 11 | 14 |
| 11 | 15 |
| 11 | 16 |
| 12 | 6 |
| 12 | 13 |
| 12 | 14 |
| 12 | 15 |
| 12 | 16 |
| 13 | 6 |
| 13 | 14 |
| 13 | 15 |
| 13 | 16 |
| 14 | 6 |
| 14 | 15 |
| 14 | 16 |
| 15 | 6 |
| 15 | 16 |
| 16 | 6 |
| 4 | 0 |
| 4 | 1 |
| 4 | 2 |
| 4 | 3 |
| 4 | 5 |
| 4 | 6 |
| 4 | 7 |
| 4 | 8 |
| 0 | 1 |
| 0 | 2 |
| 0 | 3 |
| 0 | 5 |
| 0 | 6 |
| 0 | 7 |
| 0 | 8 |
| 1 | 2 |
| 1 | 3 |
| 1 | 5 |
| 1 | 6 |
| 1 | 7 |
| 1 | 8 |
| 2 | 3 |
| 2 | 5 |
| 2 | 6 |
| 2 | 7 |
| 2 | 8 |
| 5 | 3 |
| 5 | 6 |
| 5 | 7 |
| 5 | 8 |
| 6 | 3 |
| 6 | 7 |
| 6 | 8 |
| 3 | 7 |
| 3 | 8 |
| 7 | 8 |

Oh, and when you send the solution back, just use a simple JSON layout like this so it's easy to read and parse:

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

Here, ""solution"" is a list of groups; each inner list is a set of files that share the same label (so files listed together get the same category). Think of it as a quick form: one row per label, and the file IDs that belong to that label listed next to it. This is just the shape I expect — not the actual filled-in answer.

Please make sure you use the exact file identifiers from the instance input, no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 72, 'edges': [{'u': 10, 'v': 7}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 10, 'v': 16}, {'u': 10, 'v': 17}, {'u': 11, 'v': 7}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 11, 'v': 15}, {'u': 11, 'v': 16}, {'u': 11, 'v': 17}, {'u': 12, 'v': 7}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 12, 'v': 17}, {'u': 13, 'v': 7}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 13, 'v': 17}, {'u': 14, 'v': 7}, {'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 14, 'v': 17}, {'u': 15, 'v': 7}, {'u': 15, 'v': 16}, {'u': 15, 'v': 17}, {'u': 16, 'v': 7}, {'u': 16, 'v': 17}, {'u': 17, 'v': 7}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 4}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 5, 'v': 9}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 3, 'v': 4}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 9}, {'u': 6, 'v': 4}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 7, 'v': 4}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 8, 'v': 9}], 'source_file': 'coPapersCiteseer.mtx', 'density': 0.5294117647058824, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0012.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0012.png', 'edge_connectivity': 8}","[[8, 17], [2, 12], [1, 15], [7], [6, 13], [9, 11], [3, 14], [5, 16], [4, 10]]",9.0,"{'num_nodes': 17, 'num_edges': 72, 'edges': [{'u': 9, 'v': 6}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 9, 'v': 15}, {'u': 9, 'v': 16}, {'u': 10, 'v': 6}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 10, 'v': 16}, {'u': 11, 'v': 6}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 11, 'v': 15}, {'u': 11, 'v': 16}, {'u': 12, 'v': 6}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 13, 'v': 6}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 14, 'v': 6}, {'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 15, 'v': 6}, {'u': 15, 'v': 16}, {'u': 16, 'v': 6}, {'u': 4, 'v': 0}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 0, 'v': 1}, {'u': 0, 'v': 2}, {'u': 0, 'v': 3}, {'u': 0, 'v': 5}, {'u': 0, 'v': 6}, {'u': 0, 'v': 7}, {'u': 0, 'v': 8}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 2, 'v': 3}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 6, 'v': 3}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 7, 'v': 8}]}","[[7, 16], [1, 11], [0, 14], [6], [5, 12], [8, 10], [2, 13], [4, 15], [3, 9]]",13,markdown_table,0
GCP,GCP,"There’s a plan to refresh the park’s lanes and the crew wants a tidy, simple palette. That means assigning a color to every path, making sure that whenever two lanes meet they have different colors, and keeping the palette minimal so the fewest distinct shades are used across the whole park. How to tell which plan is better: just count the different colors used — the smaller the number, the better — and don’t forget every lane needs a color and touching lanes can’t share one. The exact lane map is shown below.

There are 17 lanes in total and 40 touching pairs.

| lane_a_id | lane_b_id |
|---|---|
| 15 | 1 |
| 15 | 2 |
| 15 | 7 |
| 17 | 3 |
| 17 | 5 |
| 17 | 6 |
| 17 | 11 |
| 17 | 12 |
| 17 | 14 |
| 17 | 16 |
| 4 | 2 |
| 7 | 1 |
| 7 | 2 |
| 7 | 8 |
| 7 | 9 |
| 7 | 10 |
| 7 | 13 |
| 7 | 14 |
| 1 | 12 |
| 1 | 14 |
| 14 | 2 |
| 12 | 3 |
| 12 | 5 |
| 12 | 6 |
| 12 | 11 |
| 12 | 16 |
| 13 | 6 |
| 13 | 8 |
| 5 | 6 |
| 5 | 11 |
| 5 | 16 |
| 8 | 3 |
| 8 | 10 |
| 6 | 9 |
| 6 | 10 |
| 6 | 11 |
| 3 | 9 |
| 3 | 11 |
| 11 | 16 |
| 2 | 9 |

Oh, and to make handing the plan back easy, just follow this little JSON shape when you send the coloring — nothing fancy, just a simple list of groups:

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

Each inner array is a group of lanes that get the same shade — think of each list as one color's worth of paths. This JSON is just a sketch of the format I need, not the actual coloring for the park.

Also be sure to use the exact lane identifiers from the instance input — don't rename them or make up new ones.

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 40, 'edges': [{'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 7}, {'u': 17, 'v': 3}, {'u': 17, 'v': 5}, {'u': 17, 'v': 6}, {'u': 17, 'v': 11}, {'u': 17, 'v': 12}, {'u': 17, 'v': 14}, {'u': 17, 'v': 16}, {'u': 4, 'v': 2}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 13}, {'u': 7, 'v': 14}, {'u': 1, 'v': 12}, {'u': 1, 'v': 14}, {'u': 14, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 5}, {'u': 12, 'v': 6}, {'u': 12, 'v': 11}, {'u': 12, 'v': 16}, {'u': 13, 'v': 6}, {'u': 13, 'v': 8}, {'u': 5, 'v': 6}, {'u': 5, 'v': 11}, {'u': 5, 'v': 16}, {'u': 8, 'v': 3}, {'u': 8, 'v': 10}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 3, 'v': 9}, {'u': 3, 'v': 11}, {'u': 11, 'v': 16}, {'u': 2, 'v': 9}], 'source_file': 'citationCiteseer.mtx', 'density': 0.29411764705882354, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0013.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0013.png', 'edge_connectivity': 1}","[[4, 9, 10, 12, 13, 14, 15], [3, 5, 7], [17], [1, 6, 16], [2, 8, 11]]",5.0,"{'num_nodes': 17, 'num_edges': 40, 'edges': [{'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 7}, {'u': 17, 'v': 3}, {'u': 17, 'v': 5}, {'u': 17, 'v': 6}, {'u': 17, 'v': 11}, {'u': 17, 'v': 12}, {'u': 17, 'v': 14}, {'u': 17, 'v': 16}, {'u': 4, 'v': 2}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 13}, {'u': 7, 'v': 14}, {'u': 1, 'v': 12}, {'u': 1, 'v': 14}, {'u': 14, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 5}, {'u': 12, 'v': 6}, {'u': 12, 'v': 11}, {'u': 12, 'v': 16}, {'u': 13, 'v': 6}, {'u': 13, 'v': 8}, {'u': 5, 'v': 6}, {'u': 5, 'v': 11}, {'u': 5, 'v': 16}, {'u': 8, 'v': 3}, {'u': 8, 'v': 10}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 3, 'v': 9}, {'u': 3, 'v': 11}, {'u': 11, 'v': 16}, {'u': 2, 'v': 9}]}","[[4, 9, 10, 12, 13, 14, 15], [3, 5, 7], [17], [1, 6, 16], [2, 8, 11]]",14,markdown_table,1
GCP,GCP,"There’s a little design puzzle at work: match a theme to every dev team so that teams that meet or exchange work don’t end up with the same theme, and try to use as few different themes across the board. Concretely, each team gets one theme, teams that interact can’t share that theme, and success is measured by counting the distinct themes you ended up using — lower count wins. The specific layout is shown below.

{
  ""num_teams"": 18,
  ""num_team_interactions"": 43,
  ""edges"": [
    {
      ""team_a_id"": 9,
      ""team_b_id"": 12
    },
    {
      ""team_a_id"": 9,
      ""team_b_id"": 15
    },
    {
      ""team_a_id"": 7,
      ""team_b_id"": 11
    },
    {
      ""team_a_id"": 7,
      ""team_b_id"": 12
    },
    {
      ""team_a_id"": 10,
      ""team_b_id"": 11
    },
    {
      ""team_a_id"": 10,
      ""team_b_id"": 12
    },
    {
      ""team_a_id"": 10,
      ""team_b_id"": 13
    },
    {
      ""team_a_id"": 10,
      ""team_b_id"": 14
    },
    {
      ""team_a_id"": 11,
      ""team_b_id"": 12
    },
    {
      ""team_a_id"": 11,
      ""team_b_id"": 13
    },
    {
      ""team_a_id"": 11,
      ""team_b_id"": 14
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 0
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 1
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 5
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 8
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 13
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 14
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 15
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 16
    },
    {
      ""team_a_id"": 12,
      ""team_b_id"": 17
    },
    {
      ""team_a_id"": 13,
      ""team_b_id"": 14
    },
    {
      ""team_a_id"": 8,
      ""team_b_id"": 0
    },
    {
      ""team_a_id"": 8,
      ""team_b_id"": 1
    },
    {
      ""team_a_id"": 8,
      ""team_b_id"": 5
    },
    {
      ""team_a_id"": 5,
      ""team_b_id"": 0
    },
    {
      ""team_a_id"": 5,
      ""team_b_id"": 1
    },
    {
      ""team_a_id"": 15,
      ""team_b_id"": 0
    },
    {
      ""team_a_id"": 15,
      ""team_b_id"": 16
    },
    {
      ""team_a_id"": 15,
      ""team_b_id"": 17
    },
    {
      ""team_a_id"": 16,
      ""team_b_id"": 0
    },
    {
      ""team_a_id"": 16,
      ""team_b_id"": 17
    },
    {
      ""team_a_id"": 0,
      ""team_b_id"": 1
    },
    {
      ""team_a_id"": 0,
      ""team_b_id"": 2
    },
    {
      ""team_a_id"": 0,
      ""team_b_id"": 3
    },
    {
      ""team_a_id"": 0,
      ""team_b_id"": 4
    },
    {
      ""team_a_id"": 0,
      ""team_b_id"": 6
    },
    {
      ""team_a_id"": 2,
      ""team_b_id"": 1
    },
    {
      ""team_a_id"": 2,
      ""team_b_id"": 3
    },
    {
      ""team_a_id"": 2,
      ""team_b_id"": 4
    },
    {
      ""team_a_id"": 3,
      ""team_b_id"": 1
    },
    {
      ""team_a_id"": 3,
      ""team_b_id"": 4
    },
    {
      ""team_a_id"": 3,
      ""team_b_id"": 6
    },
    {
      ""team_a_id"": 4,
      ""team_b_id"": 6
    }
  ]
}

If you want the outcome in a neat, predictable shape, just send it in this simple JSON sketch — nothing fancy, just a quick map of which teams share a theme:

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

Each inner array is one theme group: list the team identifiers that get the same theme (so teams inside the same sub-array must not conflict with each other). This is just the expected shape — a sketch of the format, not the actual assignment.

Please make sure you use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 18, 'num_edges': 43, 'edges': [{'u': 10, 'v': 13}, {'u': 10, 'v': 16}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 11, 'v': 15}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 6}, {'u': 13, 'v': 9}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 13, 'v': 17}, {'u': 13, 'v': 18}, {'u': 14, 'v': 15}, {'u': 9, 'v': 1}, {'u': 9, 'v': 2}, {'u': 9, 'v': 6}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 16, 'v': 1}, {'u': 16, 'v': 17}, {'u': 16, 'v': 18}, {'u': 17, 'v': 1}, {'u': 17, 'v': 18}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 7}, {'u': 3, 'v': 2}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 4, 'v': 2}, {'u': 4, 'v': 5}, {'u': 4, 'v': 7}, {'u': 5, 'v': 7}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.28104575163398693, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0014.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0014.png', 'edge_connectivity': 2}","[[4, 9, 10, 12, 17], [3, 6, 7, 11], [2, 14, 16], [5, 13], [1, 8, 15, 18]]",5.0,"{'num_nodes': 18, 'num_edges': 43, 'edges': [{'u': 9, 'v': 12}, {'u': 9, 'v': 15}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 11, 'v': 14}, {'u': 12, 'v': 0}, {'u': 12, 'v': 1}, {'u': 12, 'v': 5}, {'u': 12, 'v': 8}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 12, 'v': 17}, {'u': 13, 'v': 14}, {'u': 8, 'v': 0}, {'u': 8, 'v': 1}, {'u': 8, 'v': 5}, {'u': 5, 'v': 0}, {'u': 5, 'v': 1}, {'u': 15, 'v': 0}, {'u': 15, 'v': 16}, {'u': 15, 'v': 17}, {'u': 16, 'v': 0}, {'u': 16, 'v': 17}, {'u': 0, 'v': 1}, {'u': 0, 'v': 2}, {'u': 0, 'v': 3}, {'u': 0, 'v': 4}, {'u': 0, 'v': 6}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 3, 'v': 6}, {'u': 4, 'v': 6}]}","[[3, 8, 9, 11, 16], [2, 5, 6, 10], [1, 13, 15], [4, 12], [0, 7, 14, 17]]",15,json,0
GCP,GCP,"On the day of the ceremony the team wants the ribbons to look tidy: each recipient gets one ribbon, and anyone who’s tied to someone else through a joint achievement shouldn’t have the same color. The challenge is to pick colors so that linked people are different and the ceremony ends up using as few different ribbon colors as possible. Measure how good a choice is by counting the number of different colors used — the smaller that number, the better. Nobody can be left out or given multiple ribbons, and all linked pairs must be colored differently. The specific assignments to consider are shown below.

# total_recipients=15
# total_joint_achievements=37
recipient_a,recipient_b
B,C
B,G
B,I
B,L
L,A
L,C
L,E
L,G
L,I
L,N
A,C
A,G
A,I
G,C
G,D
G,E
G,F
G,H
G,I
G,J
G,K
G,M
G,N
G,O
K,I
K,J
I,C
I,D
I,E
I,F
I,H
I,J
I,M
I,N
I,O
C,E
J,F

If you want to send me a candidate assignment, a simple JSON sketch like the one below is perfect — just list groups of recipients that share the same ribbon color.

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

Each inner list is a single ribbon color and contains the identifiers of everyone who gets that color. Think of it like filling out a form: each row is one color and the names in that row all match that ribbon.

This JSON is just the expected shape — a sketch of how to format your reply, not the actual coloring for the instance.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 37, 'edges': [{'u': 2, 'v': 3}, {'u': 2, 'v': 7}, {'u': 2, 'v': 9}, {'u': 2, 'v': 12}, {'u': 12, 'v': 1}, {'u': 12, 'v': 3}, {'u': 12, 'v': 5}, {'u': 12, 'v': 7}, {'u': 12, 'v': 9}, {'u': 12, 'v': 14}, {'u': 1, 'v': 3}, {'u': 1, 'v': 7}, {'u': 1, 'v': 9}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 6}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 13}, {'u': 7, 'v': 14}, {'u': 7, 'v': 15}, {'u': 11, 'v': 9}, {'u': 11, 'v': 10}, {'u': 9, 'v': 3}, {'u': 9, 'v': 4}, {'u': 9, 'v': 5}, {'u': 9, 'v': 6}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 9, 'v': 15}, {'u': 3, 'v': 5}, {'u': 10, 'v': 6}], 'source_file': 'citationCiteseer.mtx', 'density': 0.3523809523809524, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0015.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0015.png', 'edge_connectivity': 2}","[[3, 4, 8, 10, 13, 14, 15], [7], [6, 11, 12], [1, 2, 5], [9]]",5.0,"{'num_nodes': 15, 'num_edges': 37, 'edges': [{'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'G'}, {'u': 'B', 'v': 'I'}, {'u': 'B', 'v': 'L'}, {'u': 'L', 'v': 'A'}, {'u': 'L', 'v': 'C'}, {'u': 'L', 'v': 'E'}, {'u': 'L', 'v': 'G'}, {'u': 'L', 'v': 'I'}, {'u': 'L', 'v': 'N'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'G'}, {'u': 'A', 'v': 'I'}, {'u': 'G', 'v': 'C'}, {'u': 'G', 'v': 'D'}, {'u': 'G', 'v': 'E'}, {'u': 'G', 'v': 'F'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'I'}, {'u': 'G', 'v': 'J'}, {'u': 'G', 'v': 'K'}, {'u': 'G', 'v': 'M'}, {'u': 'G', 'v': 'N'}, {'u': 'G', 'v': 'O'}, {'u': 'K', 'v': 'I'}, {'u': 'K', 'v': 'J'}, {'u': 'I', 'v': 'C'}, {'u': 'I', 'v': 'D'}, {'u': 'I', 'v': 'E'}, {'u': 'I', 'v': 'F'}, {'u': 'I', 'v': 'H'}, {'u': 'I', 'v': 'J'}, {'u': 'I', 'v': 'M'}, {'u': 'I', 'v': 'N'}, {'u': 'I', 'v': 'O'}, {'u': 'C', 'v': 'E'}, {'u': 'J', 'v': 'F'}]}","[['C', 'D', 'H', 'J', 'M', 'N', 'O'], ['G'], ['F', 'K', 'L'], ['A', 'B', 'E'], ['I']]",16,csv,names
GCP,GCP,"Back at the data center there was a clean-up task: choose a color for every cord so that any two cords that plug into the same set of ports are not the same color. Nothing could be left uncolored or given multiple colors, and the winning arrangements are those that squeeze the palette down to as few different colors as possible — simply count how many unique colors show up to see how compact it is. The detailed rack diagram and connections are shown below.

There are 15 num cords in total and 44 num conflicting pairs.

| cord_endpoint_u | cord_endpoint_v |
|---|---|
| 12 | 0 |
| 12 | 1 |
| 12 | 7 |
| 12 | 9 |
| 12 | 10 |
| 12 | 13 |
| 12 | 14 |
| 2 | 1 |
| 2 | 3 |
| 2 | 4 |
| 2 | 5 |
| 13 | 7 |
| 11 | 14 |
| 8 | 1 |
| 8 | 5 |
| 8 | 7 |
| 9 | 0 |
| 9 | 1 |
| 9 | 4 |
| 9 | 6 |
| 9 | 7 |
| 9 | 10 |
| 7 | 0 |
| 7 | 1 |
| 7 | 3 |
| 7 | 4 |
| 7 | 5 |
| 7 | 6 |
| 7 | 10 |
| 7 | 14 |
| 4 | 0 |
| 4 | 1 |
| 4 | 5 |
| 4 | 6 |
| 10 | 1 |
| 10 | 5 |
| 1 | 0 |
| 1 | 5 |
| 1 | 6 |
| 1 | 14 |
| 5 | 0 |
| 5 | 6 |
| 6 | 0 |
| 6 | 3 |

Oh, and when you hand me the result, please use a tiny JSON shape like this so it's easy to parse:

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

Think of it like a form: ""solution"" is the whole coloring, and each inner list is one color class — a group of cords that all share the same color. Each string in those lists is a cord identifier from the rack diagram. This block is just a sketch of the expected shape, not the actual coloring itself.

Please make sure all identifiers in your real answer match exactly what appears 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”.","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 44, 'edges': [{'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 8}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 3, 'v': 2}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 14, 'v': 8}, {'u': 12, 'v': 15}, {'u': 9, 'v': 2}, {'u': 9, 'v': 6}, {'u': 9, 'v': 8}, {'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 5}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 4}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 11}, {'u': 8, 'v': 15}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 11, 'v': 2}, {'u': 11, 'v': 6}, {'u': 2, 'v': 1}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 15}, {'u': 6, 'v': 1}, {'u': 6, 'v': 7}, {'u': 7, 'v': 1}, {'u': 7, 'v': 4}], 'source_file': 'citationCiteseer.mtx', 'density': 0.41904761904761906, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0016.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0016.png', 'edge_connectivity': 1}","[[8], [5, 13], [1], [2, 4, 12], [6, 10, 15], [3, 7, 9, 11, 14]]",6.0,"{'num_nodes': 15, 'num_edges': 44, 'edges': [{'u': 12, 'v': 0}, {'u': 12, 'v': 1}, {'u': 12, 'v': 7}, {'u': 12, 'v': 9}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 13, 'v': 7}, {'u': 11, 'v': 14}, {'u': 8, 'v': 1}, {'u': 8, 'v': 5}, {'u': 8, 'v': 7}, {'u': 9, 'v': 0}, {'u': 9, 'v': 1}, {'u': 9, 'v': 4}, {'u': 9, 'v': 6}, {'u': 9, 'v': 7}, {'u': 9, 'v': 10}, {'u': 7, 'v': 0}, {'u': 7, 'v': 1}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 6}, {'u': 7, 'v': 10}, {'u': 7, 'v': 14}, {'u': 4, 'v': 0}, {'u': 4, 'v': 1}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 10, 'v': 1}, {'u': 10, 'v': 5}, {'u': 1, 'v': 0}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 14}, {'u': 5, 'v': 0}, {'u': 5, 'v': 6}, {'u': 6, 'v': 0}, {'u': 6, 'v': 3}]}","[[7], [4, 12], [0], [1, 3, 11], [5, 9, 14], [2, 6, 8, 10, 13]]",17,markdown_table,0
GCP,GCP,"I was helping plan a big banquet and needed to pick napkin colors for every table so neighboring tables didn’t end up with the same color. The job was to give each table exactly one napkin color (no table left without a color and none with two), make sure any two tables next to each other use different colors, and try to keep the total number of different colors as small as possible — you just count how many distinct colors show up and the fewer, the better. The exact seating layout and table neighbors are shown below.

{
  ""num_tables"": 14,
  ""num_adjacent_table_pairs"": 46,
  ""edges"": [
    {
      ""table_u_id"": 10,
      ""table_v_id"": 13
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 1
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 2
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 3
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 4
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 5
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 7
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 8
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 9
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 11
    },
    {
      ""table_u_id"": 0,
      ""table_v_id"": 12
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 3
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 4
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 5
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 6
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 8
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 9
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 11
    },
    {
      ""table_u_id"": 2,
      ""table_v_id"": 12
    },
    {
      ""table_u_id"": 1,
      ""table_v_id"": 5
    },
    {
      ""table_u_id"": 1,
      ""table_v_id"": 8
    },
    {
      ""table_u_id"": 1,
      ""table_v_id"": 11
    },
    {
      ""table_u_id"": 8,
      ""table_v_id"": 3
    },
    {
      ""table_u_id"": 8,
      ""table_v_id"": 4
    },
    {
      ""table_u_id"": 8,
      ""table_v_id"": 5
    },
    {
      ""table_u_id"": 8,
      ""table_v_id"": 6
    },
    {
      ""table_u_id"": 8,
      ""table_v_id"": 7
    },
    {
      ""table_u_id"": 8,
      ""table_v_id"": 9
    },
    {
      ""table_u_id"": 8,
      ""table_v_id"": 11
    },
    {
      ""table_u_id"": 3,
      ""table_v_id"": 4
    },
    {
      ""table_u_id"": 3,
      ""table_v_id"": 6
    },
    {
      ""table_u_id"": 3,
      ""table_v_id"": 11
    },
    {
      ""table_u_id"": 7,
      ""table_v_id"": 11
    },
    {
      ""table_u_id"": 5,
      ""table_v_id"": 4
    },
    {
      ""table_u_id"": 5,
      ""table_v_id"": 9
    },
    {
      ""table_u_id"": 5,
      ""table_v_id"": 11
    },
    {
      ""table_u_id"": 5,
      ""table_v_id"": 12
    },
    {
      ""table_u_id"": 5,
      ""table_v_id"": 13
    },
    {
      ""table_u_id"": 11,
      ""table_v_id"": 6
    },
    {
      ""table_u_id"": 11,
      ""table_v_id"": 9
    },
    {
      ""table_u_id"": 12,
      ""table_v_id"": 4
    },
    {
      ""table_u_id"": 12,
      ""table_v_id"": 6
    },
    {
      ""table_u_id"": 4,
      ""table_v_id"": 6
    },
    {
      ""table_u_id"": 4,
      ""table_v_id"": 9
    },
    {
      ""table_u_id"": 4,
      ""table_v_id"": 13
    },
    {
      ""table_u_id"": 9,
      ""table_v_id"": 6
    }
  ]
}

If you could send the napkin-coloring back in a simple JSON shape, that would be perfect — nothing fancy, just an array of groups that share the same color. Here’s the shape I expect:

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

Pretty much: each inner list is one napkin color and lists the table IDs that get that color. This block is just a sketch of the shape I want, not the actual coloring.

Please use the exact table identifiers from the instance input — don’t rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 46, 'edges': [{'u': 11, 'v': 14}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 12}, {'u': 1, 'v': 13}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 12}, {'u': 3, 'v': 13}, {'u': 2, 'v': 6}, {'u': 2, 'v': 9}, {'u': 2, 'v': 12}, {'u': 9, 'v': 4}, {'u': 9, 'v': 5}, {'u': 9, 'v': 6}, {'u': 9, 'v': 7}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 12}, {'u': 4, 'v': 5}, {'u': 4, 'v': 7}, {'u': 4, 'v': 12}, {'u': 8, 'v': 12}, {'u': 6, 'v': 5}, {'u': 6, 'v': 10}, {'u': 6, 'v': 12}, {'u': 6, 'v': 13}, {'u': 6, 'v': 14}, {'u': 12, 'v': 7}, {'u': 12, 'v': 10}, {'u': 13, 'v': 5}, {'u': 13, 'v': 7}, {'u': 5, 'v': 7}, {'u': 5, 'v': 10}, {'u': 5, 'v': 14}, {'u': 10, 'v': 7}], 'source_file': 'citationCiteseer.mtx', 'density': 0.5054945054945055, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0017.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0017.png', 'edge_connectivity': 1}","[[2, 10], [3, 14], [1, 7], [5, 12], [9, 13], [4, 6, 8, 11]]",6.0,"{'num_nodes': 14, 'num_edges': 46, 'edges': [{'u': 10, 'v': 13}, {'u': 0, 'v': 1}, {'u': 0, 'v': 2}, {'u': 0, 'v': 3}, {'u': 0, 'v': 4}, {'u': 0, 'v': 5}, {'u': 0, 'v': 7}, {'u': 0, 'v': 8}, {'u': 0, 'v': 9}, {'u': 0, 'v': 11}, {'u': 0, 'v': 12}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 1, 'v': 5}, {'u': 1, 'v': 8}, {'u': 1, 'v': 11}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 9}, {'u': 8, 'v': 11}, {'u': 3, 'v': 4}, {'u': 3, 'v': 6}, {'u': 3, 'v': 11}, {'u': 7, 'v': 11}, {'u': 5, 'v': 4}, {'u': 5, 'v': 9}, {'u': 5, 'v': 11}, {'u': 5, 'v': 12}, {'u': 5, 'v': 13}, {'u': 11, 'v': 6}, {'u': 11, 'v': 9}, {'u': 12, 'v': 4}, {'u': 12, 'v': 6}, {'u': 4, 'v': 6}, {'u': 4, 'v': 9}, {'u': 4, 'v': 13}, {'u': 9, 'v': 6}]}","[[1, 9], [2, 13], [0, 6], [4, 11], [8, 12], [3, 5, 7, 10]]",18,json,0
GCP,GCP,"Recently the visual merchandiser was coloring book covers for a display, making sure every side-by-side pair looked different. What makes one choice better than another is simply how few distinct colors end up on the whole rack — it’s obvious by counting the unique colors. Every single book needs one, and only one, color, and the full layout of which books are next to each other follows below.

{
  ""total_books"": 14,
  ""total_adjacent_pairs"": 37,
  ""edges"": [
    {
      ""book_a"": ""B"",
      ""book_b"": ""A""
    },
    {
      ""book_a"": ""B"",
      ""book_b"": ""E""
    },
    {
      ""book_a"": ""B"",
      ""book_b"": ""F""
    },
    {
      ""book_a"": ""B"",
      ""book_b"": ""J""
    },
    {
      ""book_a"": ""B"",
      ""book_b"": ""K""
    },
    {
      ""book_a"": ""B"",
      ""book_b"": ""M""
    },
    {
      ""book_a"": ""H"",
      ""book_b"": ""A""
    },
    {
      ""book_a"": ""H"",
      ""book_b"": ""D""
    },
    {
      ""book_a"": ""H"",
      ""book_b"": ""F""
    },
    {
      ""book_a"": ""H"",
      ""book_b"": ""I""
    },
    {
      ""book_a"": ""H"",
      ""book_b"": ""L""
    },
    {
      ""book_a"": ""H"",
      ""book_b"": ""N""
    },
    {
      ""book_a"": ""J"",
      ""book_b"": ""A""
    },
    {
      ""book_a"": ""J"",
      ""book_b"": ""C""
    },
    {
      ""book_a"": ""J"",
      ""book_b"": ""G""
    },
    {
      ""book_a"": ""J"",
      ""book_b"": ""I""
    },
    {
      ""book_a"": ""M"",
      ""book_b"": ""A""
    },
    {
      ""book_a"": ""M"",
      ""book_b"": ""G""
    },
    {
      ""book_a"": ""M"",
      ""book_b"": ""I""
    },
    {
      ""book_a"": ""N"",
      ""book_b"": ""D""
    },
    {
      ""book_a"": ""N"",
      ""book_b"": ""K""
    },
    {
      ""book_a"": ""N"",
      ""book_b"": ""L""
    },
    {
      ""book_a"": ""K"",
      ""book_b"": ""A""
    },
    {
      ""book_a"": ""K"",
      ""book_b"": ""C""
    },
    {
      ""book_a"": ""K"",
      ""book_b"": ""G""
    },
    {
      ""book_a"": ""K"",
      ""book_b"": ""I""
    },
    {
      ""book_a"": ""C"",
      ""book_b"": ""F""
    },
    {
      ""book_a"": ""C"",
      ""book_b"": ""G""
    },
    {
      ""book_a"": ""I"",
      ""book_b"": ""E""
    },
    {
      ""book_a"": ""I"",
      ""book_b"": ""F""
    },
    {
      ""book_a"": ""I"",
      ""book_b"": ""L""
    },
    {
      ""book_a"": ""E"",
      ""book_b"": ""A""
    },
    {
      ""book_a"": ""E"",
      ""book_b"": ""F""
    },
    {
      ""book_a"": ""A"",
      ""book_b"": ""D""
    },
    {
      ""book_a"": ""A"",
      ""book_b"": ""F""
    },
    {
      ""book_a"": ""L"",
      ""book_b"": ""F""
    },
    {
      ""book_a"": ""F"",
      ""book_b"": ""D""
    }
  ]
}

Oh, and when you send the coloring back, just stick to this simple JSON shape so I can read it easily:

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

Think of each inner list as one color group — a little cluster of side-by-side books that all share the same cover color. The first list would be everything painted with color #1, the second list color #2, and so on. This is just a sketch of the shape I expect, not the actual coloring.

Please be sure to use the exact identifiers from the instance input — don’t rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 37, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 13}, {'u': 8, 'v': 1}, {'u': 8, 'v': 4}, {'u': 8, 'v': 6}, {'u': 8, 'v': 9}, {'u': 8, 'v': 12}, {'u': 8, 'v': 14}, {'u': 10, 'v': 1}, {'u': 10, 'v': 3}, {'u': 10, 'v': 7}, {'u': 10, 'v': 9}, {'u': 13, 'v': 1}, {'u': 13, 'v': 7}, {'u': 13, 'v': 9}, {'u': 14, 'v': 4}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 11, 'v': 1}, {'u': 11, 'v': 3}, {'u': 11, 'v': 7}, {'u': 11, 'v': 9}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 9, 'v': 5}, {'u': 9, 'v': 6}, {'u': 9, 'v': 12}, {'u': 5, 'v': 1}, {'u': 5, 'v': 6}, {'u': 1, 'v': 4}, {'u': 1, 'v': 6}, {'u': 12, 'v': 6}, {'u': 6, 'v': 4}], 'source_file': 'citationCiteseer.mtx', 'density': 0.4065934065934066, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0018.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0018.png', 'edge_connectivity': 4}","[[1, 3, 9, 14], [4, 5, 11, 12, 13], [2, 7, 8], [6, 10]]",4.0,"{'num_nodes': 14, 'num_edges': 37, 'edges': [{'u': 'B', 'v': 'A'}, {'u': 'B', 'v': 'E'}, {'u': 'B', 'v': 'F'}, {'u': 'B', 'v': 'J'}, {'u': 'B', 'v': 'K'}, {'u': 'B', 'v': 'M'}, {'u': 'H', 'v': 'A'}, {'u': 'H', 'v': 'D'}, {'u': 'H', 'v': 'F'}, {'u': 'H', 'v': 'I'}, {'u': 'H', 'v': 'L'}, {'u': 'H', 'v': 'N'}, {'u': 'J', 'v': 'A'}, {'u': 'J', 'v': 'C'}, {'u': 'J', 'v': 'G'}, {'u': 'J', 'v': 'I'}, {'u': 'M', 'v': 'A'}, {'u': 'M', 'v': 'G'}, {'u': 'M', 'v': 'I'}, {'u': 'N', 'v': 'D'}, {'u': 'N', 'v': 'K'}, {'u': 'N', 'v': 'L'}, {'u': 'K', 'v': 'A'}, {'u': 'K', 'v': 'C'}, {'u': 'K', 'v': 'G'}, {'u': 'K', 'v': 'I'}, {'u': 'C', 'v': 'F'}, {'u': 'C', 'v': 'G'}, {'u': 'I', 'v': 'E'}, {'u': 'I', 'v': 'F'}, {'u': 'I', 'v': 'L'}, {'u': 'E', 'v': 'A'}, {'u': 'E', 'v': 'F'}, {'u': 'A', 'v': 'D'}, {'u': 'A', 'v': 'F'}, {'u': 'L', 'v': 'F'}, {'u': 'F', 'v': 'D'}]}","[['A', 'C', 'I', 'N'], ['D', 'E', 'K', 'L', 'M'], ['B', 'G', 'H'], ['F', 'J']]",19,json,names
GCP,GCP,"I was picturing a youth league scrimmage where every player needs a helmet color so teammates and opponents can be told apart — the tricky bit is that any two players who line up across from each other on the field can't wear the same color. The job is to give each player one helmet color (no player left without a color, and nobody gets two different colors) in a way that avoids same-colored helmets for every pair that face one another. Better setups are the ones that use fewer different helmet colors overall — you just count how many distinct colors end up being used, and the lower that number, the better. The concrete matchups and player list are shown below.

{
  ""total_players"": 14,
  ""total_facing_pairs"": 29,
  ""edges"": [
    {
      ""player_a_id"": 2,
      ""player_b_id"": 1
    },
    {
      ""player_a_id"": 2,
      ""player_b_id"": 3
    },
    {
      ""player_a_id"": 2,
      ""player_b_id"": 4
    },
    {
      ""player_a_id"": 2,
      ""player_b_id"": 5
    },
    {
      ""player_a_id"": 2,
      ""player_b_id"": 6
    },
    {
      ""player_a_id"": 3,
      ""player_b_id"": 1
    },
    {
      ""player_a_id"": 3,
      ""player_b_id"": 4
    },
    {
      ""player_a_id"": 3,
      ""player_b_id"": 5
    },
    {
      ""player_a_id"": 3,
      ""player_b_id"": 6
    },
    {
      ""player_a_id"": 9,
      ""player_b_id"": 7
    },
    {
      ""player_a_id"": 9,
      ""player_b_id"": 8
    },
    {
      ""player_a_id"": 9,
      ""player_b_id"": 10
    },
    {
      ""player_a_id"": 9,
      ""player_b_id"": 11
    },
    {
      ""player_a_id"": 9,
      ""player_b_id"": 13
    },
    {
      ""player_a_id"": 9,
      ""player_b_id"": 14
    },
    {
      ""player_a_id"": 4,
      ""player_b_id"": 1
    },
    {
      ""player_a_id"": 4,
      ""player_b_id"": 5
    },
    {
      ""player_a_id"": 4,
      ""player_b_id"": 6
    },
    {
      ""player_a_id"": 11,
      ""player_b_id"": 7
    },
    {
      ""player_a_id"": 11,
      ""player_b_id"": 14
    },
    {
      ""player_a_id"": 5,
      ""player_b_id"": 1
    },
    {
      ""player_a_id"": 5,
      ""player_b_id"": 6
    },
    {
      ""player_a_id"": 6,
      ""player_b_id"": 1
    },
    {
      ""player_a_id"": 6,
      ""player_b_id"": 10
    },
    {
      ""player_a_id"": 6,
      ""player_b_id"": 12
    },
    {
      ""player_a_id"": 12,
      ""player_b_id"": 10
    },
    {
      ""player_a_id"": 13,
      ""player_b_id"": 10
    },
    {
      ""player_a_id"": 7,
      ""player_b_id"": 14
    },
    {
      ""player_a_id"": 8,
      ""player_b_id"": 10
    }
  ]
}

I'll keep the answer in a small, easy JSON layout so it's straightforward to check and reuse. Below is the shape I expect:

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

Think of each inner array as one helmet color group — the player identifiers listed together all get the same color. This is just a sketch of the expected shape, not the actual assignment.

Please use the exact identifiers from the instance input — do not rename or invent labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 29, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 9, 'v': 7}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 4, 'v': 1}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 11, 'v': 7}, {'u': 11, 'v': 14}, {'u': 5, 'v': 1}, {'u': 5, 'v': 6}, {'u': 6, 'v': 1}, {'u': 6, 'v': 10}, {'u': 6, 'v': 12}, {'u': 12, 'v': 10}, {'u': 13, 'v': 10}, {'u': 7, 'v': 14}, {'u': 8, 'v': 10}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.31868131868131866, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0019.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0019.png', 'edge_connectivity': 2}","[[3, 8, 12, 13, 14], [2], [4, 7, 10], [6], [5, 9], [1, 11]]",6.0,"{'num_nodes': 14, 'num_edges': 29, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 9, 'v': 7}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 4, 'v': 1}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 11, 'v': 7}, {'u': 11, 'v': 14}, {'u': 5, 'v': 1}, {'u': 5, 'v': 6}, {'u': 6, 'v': 1}, {'u': 6, 'v': 10}, {'u': 6, 'v': 12}, {'u': 12, 'v': 10}, {'u': 13, 'v': 10}, {'u': 7, 'v': 14}, {'u': 8, 'v': 10}]}","[[3, 8, 12, 13, 14], [2], [4, 7, 10], [6], [5, 9], [1, 11]]",20,json,1
GCP,GCP,"My cousin runs events and wanted each table dressed in one color while making sure any pair of tables connected by guest walkways never wore the same cloth. The choice is which single color goes on each table, with the best outcome using as few different colors as possible — measured by counting the distinct cloth colors used. Nothing can be skipped or double-covered, and the full map of tables and adjacencies is shown below.

{
  ""total_tables"": 16,
  ""total_adjacent_pairs"": 45,
  ""edges"": [
    {
      ""table_id_a"": 8,
      ""table_id_b"": 2
    },
    {
      ""table_id_a"": 8,
      ""table_id_b"": 5
    },
    {
      ""table_id_a"": 8,
      ""table_id_b"": 9
    },
    {
      ""table_id_a"": 8,
      ""table_id_b"": 10
    },
    {
      ""table_id_a"": 8,
      ""table_id_b"": 11
    },
    {
      ""table_id_a"": 8,
      ""table_id_b"": 12
    },
    {
      ""table_id_a"": 8,
      ""table_id_b"": 13
    },
    {
      ""table_id_a"": 9,
      ""table_id_b"": 2
    },
    {
      ""table_id_a"": 9,
      ""table_id_b"": 5
    },
    {
      ""table_id_a"": 9,
      ""table_id_b"": 10
    },
    {
      ""table_id_a"": 9,
      ""table_id_b"": 11
    },
    {
      ""table_id_a"": 9,
      ""table_id_b"": 12
    },
    {
      ""table_id_a"": 9,
      ""table_id_b"": 13
    },
    {
      ""table_id_a"": 10,
      ""table_id_b"": 2
    },
    {
      ""table_id_a"": 10,
      ""table_id_b"": 5
    },
    {
      ""table_id_a"": 10,
      ""table_id_b"": 11
    },
    {
      ""table_id_a"": 10,
      ""table_id_b"": 12
    },
    {
      ""table_id_a"": 10,
      ""table_id_b"": 13
    },
    {
      ""table_id_a"": 11,
      ""table_id_b"": 2
    },
    {
      ""table_id_a"": 11,
      ""table_id_b"": 5
    },
    {
      ""table_id_a"": 11,
      ""table_id_b"": 12
    },
    {
      ""table_id_a"": 11,
      ""table_id_b"": 13
    },
    {
      ""table_id_a"": 12,
      ""table_id_b"": 2
    },
    {
      ""table_id_a"": 12,
      ""table_id_b"": 5
    },
    {
      ""table_id_a"": 12,
      ""table_id_b"": 13
    },
    {
      ""table_id_a"": 3,
      ""table_id_b"": 4
    },
    {
      ""table_id_a"": 3,
      ""table_id_b"": 5
    },
    {
      ""table_id_a"": 3,
      ""table_id_b"": 6
    },
    {
      ""table_id_a"": 3,
      ""table_id_b"": 7
    },
    {
      ""table_id_a"": 4,
      ""table_id_b"": 5
    },
    {
      ""table_id_a"": 4,
      ""table_id_b"": 6
    },
    {
      ""table_id_a"": 4,
      ""table_id_b"": 7
    },
    {
      ""table_id_a"": 4,
      ""table_id_b"": 14
    },
    {
      ""table_id_a"": 4,
      ""table_id_b"": 15
    },
    {
      ""table_id_a"": 4,
      ""table_id_b"": 16
    },
    {
      ""table_id_a"": 5,
      ""table_id_b"": 2
    },
    {
      ""table_id_a"": 5,
      ""table_id_b"": 6
    },
    {
      ""table_id_a"": 5,
      ""table_id_b"": 7
    },
    {
      ""table_id_a"": 5,
      ""table_id_b"": 13
    },
    {
      ""table_id_a"": 6,
      ""table_id_b"": 1
    },
    {
      ""table_id_a"": 6,
      ""table_id_b"": 7
    },
    {
      ""table_id_a"": 14,
      ""table_id_b"": 15
    },
    {
      ""table_id_a"": 14,
      ""table_id_b"": 16
    },
    {
      ""table_id_a"": 13,
      ""table_id_b"": 2
    },
    {
      ""table_id_a"": 15,
      ""table_id_b"": 16
    }
  ]
}

If you want to give me the table-coloring itself, just drop it in this simple JSON shape so I can read it easily:

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

Think of ""solution"" as a list of color groups: each inner array is one color and lists the table identifiers (which tables get that same cloth). The ""table_id"" bits are just placeholders standing in for the real table names from the instance — replace them with the exact identifiers from the input.

This JSON is only a sketch of the shape I expect, not the actual answer — please fill in the real table IDs from the instance. All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.

For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 45, 'edges': [{'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 9, 'v': 2}, {'u': 9, 'v': 5}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 10, 'v': 2}, {'u': 10, 'v': 5}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 11, 'v': 2}, {'u': 11, 'v': 5}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 12, 'v': 2}, {'u': 12, 'v': 5}, {'u': 12, 'v': 13}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 4, 'v': 16}, {'u': 5, 'v': 2}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 13}, {'u': 6, 'v': 1}, {'u': 6, 'v': 7}, {'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 13, 'v': 2}, {'u': 15, 'v': 16}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.375, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0020.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0020.png', 'edge_connectivity': 1}","[[1, 5, 14], [11], [13], [2], [7, 12, 16], [6, 10, 15], [4, 9], [3, 8]]",8.0,"{'num_nodes': 16, 'num_edges': 45, 'edges': [{'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 9, 'v': 2}, {'u': 9, 'v': 5}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 10, 'v': 2}, {'u': 10, 'v': 5}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 11, 'v': 2}, {'u': 11, 'v': 5}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 12, 'v': 2}, {'u': 12, 'v': 5}, {'u': 12, 'v': 13}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 4, 'v': 16}, {'u': 5, 'v': 2}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 13}, {'u': 6, 'v': 1}, {'u': 6, 'v': 7}, {'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 13, 'v': 2}, {'u': 15, 'v': 16}]}","[[1, 5, 14], [11], [13], [2], [7, 12, 16], [6, 10, 15], [4, 9], [3, 8]]",21,json,1
GCP,GCP,"Many people on the scheduling team were asked to pick a single color for each exam room so adjacent rooms (those with a common wall) don’t end up matching. Every room needs one and only one sign, and the cleaner solution is the one that uses the fewest different colors — just count the unique colors to see which one wins. The exact room info appears below.

There are 17 exam rooms in total and 37 shared walls.

| room_a_id | room_b_id |
|---|---|
| 17 | 7 |
| 17 | 8 |
| 17 | 16 |
| 12 | 4 |
| 12 | 8 |
| 12 | 13 |
| 12 | 16 |
| 10 | 2 |
| 10 | 7 |
| 10 | 8 |
| 10 | 11 |
| 10 | 16 |
| 14 | 8 |
| 14 | 16 |
| 3 | 8 |
| 3 | 16 |
| 8 | 1 |
| 8 | 2 |
| 8 | 5 |
| 8 | 6 |
| 8 | 7 |
| 8 | 11 |
| 8 | 15 |
| 5 | 7 |
| 5 | 16 |
| 16 | 1 |
| 16 | 2 |
| 16 | 6 |
| 16 | 7 |
| 16 | 9 |
| 16 | 11 |
| 16 | 15 |
| 7 | 2 |
| 7 | 9 |
| 1 | 11 |
| 2 | 9 |
| 11 | 15 |

Also, when you hand the answers back, just use this simple JSON layout so it's easy to read and parse:

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

Pretty straightforward: ""solution"" is a list of groups, and each inner list is the set of room IDs that share the same colored sign. Think of each inner list as one color — all rooms in that list get the same sign. This JSON is just a sketch of the shape I expect, not the actual assignment.

Please use the room 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"".

- ""1""
- ""23""
- ""A""
- ""B""
- ""A1""
- ""X7""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 37, 'edges': [{'u': 17, 'v': 7}, {'u': 17, 'v': 8}, {'u': 17, 'v': 16}, {'u': 12, 'v': 4}, {'u': 12, 'v': 8}, {'u': 12, 'v': 13}, {'u': 12, 'v': 16}, {'u': 10, 'v': 2}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 10, 'v': 16}, {'u': 14, 'v': 8}, {'u': 14, 'v': 16}, {'u': 3, 'v': 8}, {'u': 3, 'v': 16}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 11}, {'u': 8, 'v': 15}, {'u': 5, 'v': 7}, {'u': 5, 'v': 16}, {'u': 16, 'v': 1}, {'u': 16, 'v': 2}, {'u': 16, 'v': 6}, {'u': 16, 'v': 7}, {'u': 16, 'v': 9}, {'u': 16, 'v': 11}, {'u': 16, 'v': 15}, {'u': 7, 'v': 2}, {'u': 7, 'v': 9}, {'u': 1, 'v': 11}, {'u': 2, 'v': 9}, {'u': 11, 'v': 15}], 'source_file': 'citationCiteseer.mtx', 'density': 0.27205882352941174, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0021.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0021.png', 'edge_connectivity': 1}","[[4, 8, 13, 16], [1, 2, 15], [7, 11, 12], [3, 5, 6, 9, 10, 14, 17]]",4.0,"{'num_nodes': 17, 'num_edges': 37, 'edges': [{'u': 17, 'v': 7}, {'u': 17, 'v': 8}, {'u': 17, 'v': 16}, {'u': 12, 'v': 4}, {'u': 12, 'v': 8}, {'u': 12, 'v': 13}, {'u': 12, 'v': 16}, {'u': 10, 'v': 2}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 10, 'v': 16}, {'u': 14, 'v': 8}, {'u': 14, 'v': 16}, {'u': 3, 'v': 8}, {'u': 3, 'v': 16}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 11}, {'u': 8, 'v': 15}, {'u': 5, 'v': 7}, {'u': 5, 'v': 16}, {'u': 16, 'v': 1}, {'u': 16, 'v': 2}, {'u': 16, 'v': 6}, {'u': 16, 'v': 7}, {'u': 16, 'v': 9}, {'u': 16, 'v': 11}, {'u': 16, 'v': 15}, {'u': 7, 'v': 2}, {'u': 7, 'v': 9}, {'u': 1, 'v': 11}, {'u': 2, 'v': 9}, {'u': 11, 'v': 15}]}","[[4, 8, 13, 16], [1, 2, 15], [7, 11, 12], [3, 5, 6, 9, 10, 14, 17]]",22,markdown_table,1
GCP,GCP,"On a quiet afternoon the ops team sketched out all the transmitters and decided each one needed its own channel tag, with the catch that any two whose blobs of coverage intersect can’t share the same tag. Every transmitter must have a single tag and no overlaps can be given the same tag, and a simpler plan is one that uses as few different tags as possible — just tally the distinct tags to see how many were used. The detailed instance is shown below.

{
  ""total_transmitters"": 15,
  ""total_overlapping_pairs"": 49,
  ""edges"": [
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""A""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""B""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""C""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""D""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""E""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""F""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""G""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""H""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""I""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""K""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""L""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""M""
    },
    {
      ""transmitter_a_id"": ""J"",
      ""transmitter_b_id"": ""N""
    },
    {
      ""transmitter_a_id"": ""M"",
      ""transmitter_b_id"": ""C""
    },
    {
      ""transmitter_a_id"": ""M"",
      ""transmitter_b_id"": ""N""
    },
    {
      ""transmitter_a_id"": ""N"",
      ""transmitter_b_id"": ""C""
    },
    {
      ""transmitter_a_id"": ""N"",
      ""transmitter_b_id"": ""O""
    },
    {
      ""transmitter_a_id"": ""K"",
      ""transmitter_b_id"": ""C""
    },
    {
      ""transmitter_a_id"": ""K"",
      ""transmitter_b_id"": ""F""
    },
    {
      ""transmitter_a_id"": ""K"",
      ""transmitter_b_id"": ""G""
    },
    {
      ""transmitter_a_id"": ""K"",
      ""transmitter_b_id"": ""I""
    },
    {
      ""transmitter_a_id"": ""L"",
      ""transmitter_b_id"": ""B""
    },
    {
      ""transmitter_a_id"": ""L"",
      ""transmitter_b_id"": ""C""
    },
    {
      ""transmitter_a_id"": ""L"",
      ""transmitter_b_id"": ""D""
    },
    {
      ""transmitter_a_id"": ""L"",
      ""transmitter_b_id"": ""F""
    },
    {
      ""transmitter_a_id"": ""L"",
      ""transmitter_b_id"": ""G""
    },
    {
      ""transmitter_a_id"": ""L"",
      ""transmitter_b_id"": ""H""
    },
    {
      ""transmitter_a_id"": ""B"",
      ""transmitter_b_id"": ""A""
    },
    {
      ""transmitter_a_id"": ""B"",
      ""transmitter_b_id"": ""C""
    },
    {
      ""transmitter_a_id"": ""B"",
      ""transmitter_b_id"": ""D""
    },
    {
      ""transmitter_a_id"": ""B"",
      ""transmitter_b_id"": ""F""
    },
    {
      ""transmitter_a_id"": ""B"",
      ""transmitter_b_id"": ""G""
    },
    {
      ""transmitter_a_id"": ""B"",
      ""transmitter_b_id"": ""H""
    },
    {
      ""transmitter_a_id"": ""B"",
      ""transmitter_b_id"": ""I""
    },
    {
      ""transmitter_a_id"": ""C"",
      ""transmitter_b_id"": ""A""
    },
    {
      ""transmitter_a_id"": ""C"",
      ""transmitter_b_id"": ""D""
    },
    {
      ""transmitter_a_id"": ""C"",
      ""transmitter_b_id"": ""E""
    },
    {
      ""transmitter_a_id"": ""C"",
      ""transmitter_b_id"": ""F""
    },
    {
      ""transmitter_a_id"": ""C"",
      ""transmitter_b_id"": ""G""
    },
    {
      ""transmitter_a_id"": ""C"",
      ""transmitter_b_id"": ""H""
    },
    {
      ""transmitter_a_id"": ""C"",
      ""transmitter_b_id"": ""I""
    },
    {
      ""transmitter_a_id"": ""D"",
      ""transmitter_b_id"": ""F""
    },
    {
      ""transmitter_a_id"": ""D"",
      ""transmitter_b_id"": ""G""
    },
    {
      ""transmitter_a_id"": ""D"",
      ""transmitter_b_id"": ""H""
    },
    {
      ""transmitter_a_id"": ""A"",
      ""transmitter_b_id"": ""I""
    },
    {
      ""transmitter_a_id"": ""G"",
      ""transmitter_b_id"": ""F""
    },
    {
      ""transmitter_a_id"": ""G"",
      ""transmitter_b_id"": ""H""
    },
    {
      ""transmitter_a_id"": ""G"",
      ""transmitter_b_id"": ""I""
    },
    {
      ""transmitter_a_id"": ""H"",
      ""transmitter_b_id"": ""F""
    }
  ]
}

If you prefer to hand me the answer in a neat, machine-friendly way, just follow this little JSON sketch for the shape of the reply.

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

Here ""solution"" is a list of channels (each inner list is a group of transmitters that share the same tag). Think of each inner array as a single tag listing which transmitters get it. This is just a template showing the shape I expect — not the actual assignment.

Please make sure you use the exact identifiers from the instance input — do not rename any of them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 49, 'edges': [{'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 4}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 9}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 13, 'v': 3}, {'u': 13, 'v': 14}, {'u': 14, 'v': 3}, {'u': 14, 'v': 15}, {'u': 11, 'v': 3}, {'u': 11, 'v': 6}, {'u': 11, 'v': 7}, {'u': 11, 'v': 9}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 4}, {'u': 12, 'v': 6}, {'u': 12, 'v': 7}, {'u': 12, 'v': 8}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 3, 'v': 1}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 9}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 1, 'v': 9}, {'u': 7, 'v': 6}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 8, 'v': 6}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.4666666666666667, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0022.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0022.png', 'edge_connectivity': 1}","[[3], [4], [1, 5, 12], [8, 9, 15], [6, 13], [7], [10], [2, 11, 14]]",8.0,"{'num_nodes': 15, 'num_edges': 49, 'edges': [{'u': 'J', 'v': 'A'}, {'u': 'J', 'v': 'B'}, {'u': 'J', 'v': 'C'}, {'u': 'J', 'v': 'D'}, {'u': 'J', 'v': 'E'}, {'u': 'J', 'v': 'F'}, {'u': 'J', 'v': 'G'}, {'u': 'J', 'v': 'H'}, {'u': 'J', 'v': 'I'}, {'u': 'J', 'v': 'K'}, {'u': 'J', 'v': 'L'}, {'u': 'J', 'v': 'M'}, {'u': 'J', 'v': 'N'}, {'u': 'M', 'v': 'C'}, {'u': 'M', 'v': 'N'}, {'u': 'N', 'v': 'C'}, {'u': 'N', 'v': 'O'}, {'u': 'K', 'v': 'C'}, {'u': 'K', 'v': 'F'}, {'u': 'K', 'v': 'G'}, {'u': 'K', 'v': 'I'}, {'u': 'L', 'v': 'B'}, {'u': 'L', 'v': 'C'}, {'u': 'L', 'v': 'D'}, {'u': 'L', 'v': 'F'}, {'u': 'L', 'v': 'G'}, {'u': 'L', 'v': 'H'}, {'u': 'B', 'v': 'A'}, {'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'D'}, {'u': 'B', 'v': 'F'}, {'u': 'B', 'v': 'G'}, {'u': 'B', 'v': 'H'}, {'u': 'B', 'v': 'I'}, {'u': 'C', 'v': 'A'}, {'u': 'C', 'v': 'D'}, {'u': 'C', 'v': 'E'}, {'u': 'C', 'v': 'F'}, {'u': 'C', 'v': 'G'}, {'u': 'C', 'v': 'H'}, {'u': 'C', 'v': 'I'}, {'u': 'D', 'v': 'F'}, {'u': 'D', 'v': 'G'}, {'u': 'D', 'v': 'H'}, {'u': 'A', 'v': 'I'}, {'u': 'G', 'v': 'F'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'I'}, {'u': 'H', 'v': 'F'}]}","[['C'], ['D'], ['A', 'E', 'L'], ['H', 'I', 'O'], ['F', 'M'], ['G'], ['J'], ['B', 'K', 'N']]",23,json,names
GCP,GCP,"We’ve got a display wall covered in poster spots and it’s time to give each spot a background color. The choice to make is which hue goes on which poster board, with the idea that boards sitting side-by-side shouldn’t have the same background. The notion of “better” here means using fewer unique hues overall, so performance is tracked by counting how many different hues end up used. No board can be left without a hue, and any pair of adjacent boards must be different. The concrete details of the layout are shown below.

There are 18 poster boards in total and 65 adjacent board pairs.

| board_u_id | board_v_id |
|---|---|
| 4 | 0 |
| 4 | 5 |
| 4 | 6 |
| 4 | 7 |
| 4 | 8 |
| 5 | 0 |
| 5 | 1 |
| 5 | 6 |
| 5 | 7 |
| 5 | 8 |
| 5 | 9 |
| 5 | 10 |
| 5 | 17 |
| 12 | 0 |
| 12 | 1 |
| 12 | 2 |
| 12 | 10 |
| 12 | 11 |
| 12 | 13 |
| 12 | 14 |
| 12 | 15 |
| 12 | 16 |
| 7 | 6 |
| 8 | 0 |
| 8 | 1 |
| 8 | 3 |
| 2 | 0 |
| 2 | 1 |
| 2 | 10 |
| 2 | 11 |
| 2 | 13 |
| 2 | 14 |
| 2 | 15 |
| 2 | 16 |
| 15 | 0 |
| 15 | 1 |
| 15 | 10 |
| 15 | 11 |
| 15 | 13 |
| 15 | 14 |
| 15 | 16 |
| 1 | 0 |
| 1 | 3 |
| 1 | 9 |
| 1 | 10 |
| 1 | 11 |
| 1 | 13 |
| 1 | 14 |
| 1 | 16 |
| 16 | 0 |
| 16 | 10 |
| 16 | 11 |
| 16 | 13 |
| 16 | 14 |
| 14 | 0 |
| 14 | 10 |
| 14 | 11 |
| 14 | 13 |
| 13 | 0 |
| 13 | 10 |
| 13 | 11 |
| 17 | 10 |
| 0 | 10 |
| 0 | 11 |
| 10 | 11 |

Also, to keep things tidy, please send the coloring back in this JSON shape so I know which posters share a hue:

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

The ""solution"" array is just a list of color buckets — each inner list is the set of poster spots that all get the same background color. Treat each inner list as one hue assignment. This is just a sketch of the expected shape, not the actual answer.

Please make sure to use the exact identifiers from the instance input — don't rename them and don't invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'problem_type': 'GCP', 'num_nodes': 18, 'num_edges': 65, 'edges': [{'u': 5, 'v': 1}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 5, 'v': 9}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 6, 'v': 18}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 11}, {'u': 13, 'v': 12}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 13, 'v': 17}, {'u': 8, 'v': 7}, {'u': 9, 'v': 1}, {'u': 9, 'v': 2}, {'u': 9, 'v': 4}, {'u': 3, 'v': 1}, {'u': 3, 'v': 2}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 3, 'v': 14}, {'u': 3, 'v': 15}, {'u': 3, 'v': 16}, {'u': 3, 'v': 17}, {'u': 16, 'v': 1}, {'u': 16, 'v': 2}, {'u': 16, 'v': 11}, {'u': 16, 'v': 12}, {'u': 16, 'v': 14}, {'u': 16, 'v': 15}, {'u': 16, 'v': 17}, {'u': 2, 'v': 1}, {'u': 2, 'v': 4}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 2, 'v': 14}, {'u': 2, 'v': 15}, {'u': 2, 'v': 17}, {'u': 17, 'v': 1}, {'u': 17, 'v': 11}, {'u': 17, 'v': 12}, {'u': 17, 'v': 14}, {'u': 17, 'v': 15}, {'u': 15, 'v': 1}, {'u': 15, 'v': 11}, {'u': 15, 'v': 12}, {'u': 15, 'v': 14}, {'u': 14, 'v': 1}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 18, 'v': 11}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 11, 'v': 12}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.42483660130718953, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0023.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0023.png', 'edge_connectivity': 2}","[[3, 6], [10, 15], [4, 13, 18], [16], [1, 8], [12], [11], [14], [7, 9, 17], [2, 5]]",10.0,"{'num_nodes': 18, 'num_edges': 65, 'edges': [{'u': 4, 'v': 0}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 5, 'v': 0}, {'u': 5, 'v': 1}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 5, 'v': 9}, {'u': 5, 'v': 10}, {'u': 5, 'v': 17}, {'u': 12, 'v': 0}, {'u': 12, 'v': 1}, {'u': 12, 'v': 2}, {'u': 12, 'v': 10}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 7, 'v': 6}, {'u': 8, 'v': 0}, {'u': 8, 'v': 1}, {'u': 8, 'v': 3}, {'u': 2, 'v': 0}, {'u': 2, 'v': 1}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 13}, {'u': 2, 'v': 14}, {'u': 2, 'v': 15}, {'u': 2, 'v': 16}, {'u': 15, 'v': 0}, {'u': 15, 'v': 1}, {'u': 15, 'v': 10}, {'u': 15, 'v': 11}, {'u': 15, 'v': 13}, {'u': 15, 'v': 14}, {'u': 15, 'v': 16}, {'u': 1, 'v': 0}, {'u': 1, 'v': 3}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 1, 'v': 13}, {'u': 1, 'v': 14}, {'u': 1, 'v': 16}, {'u': 16, 'v': 0}, {'u': 16, 'v': 10}, {'u': 16, 'v': 11}, {'u': 16, 'v': 13}, {'u': 16, 'v': 14}, {'u': 14, 'v': 0}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 14, 'v': 13}, {'u': 13, 'v': 0}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 17, 'v': 10}, {'u': 0, 'v': 10}, {'u': 0, 'v': 11}, {'u': 10, 'v': 11}]}","[[2, 5], [9, 14], [3, 12, 17], [15], [0, 7], [11], [10], [13], [6, 8, 16], [1, 4]]",24,markdown_table,0
GCP,GCP,"Someone on the operations team has to mark every storage rack with a colored dot so that when two racks face each other across a forklift lane they’re never the same color. The task is picking a single color for each rack, under the rule that linked racks can’t share that color. Better plans use a smaller palette overall; the simple way to judge a plan is to count how many different colors are used — the lower the count, the better. No rack is allowed to be unmarked and no rack gets more than one color. The exact instance details are below.

# total_racks=14
# aisle_connections=29
rack_a_id,rack_b_id
1,3
1,4
1,8
1,9
1,11
1,13
1,14
4,14
12,3
12,8
12,11
12,13
12,14
13,2
13,3
13,5
13,6
13,7
13,14
9,2
9,3
9,14
7,8
7,10
10,3
2,8
6,8
14,8
8,3

If you want to return the plan in a machine-friendly way, you can just use this little JSON shape — it’s an easy way to list which racks get the same colored dot.

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

Think of ""solution"" as a list of groups: each inner list is a set of racks that all get the same color dot. It's just a sketch of the shape I expect here, not the actual coloring — you'll replace those placeholders with the real rack identifiers from the instance.

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”.""","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 29, 'edges': [{'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 11}, {'u': 1, 'v': 13}, {'u': 1, 'v': 14}, {'u': 4, 'v': 14}, {'u': 12, 'v': 3}, {'u': 12, 'v': 8}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 7}, {'u': 13, 'v': 14}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 14}, {'u': 7, 'v': 8}, {'u': 7, 'v': 10}, {'u': 10, 'v': 3}, {'u': 2, 'v': 8}, {'u': 6, 'v': 8}, {'u': 14, 'v': 8}, {'u': 8, 'v': 3}], 'source_file': 'citationCiteseer.mtx', 'density': 0.31868131868131866, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0024.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0024.png', 'edge_connectivity': 1}","[[4, 8, 9, 10, 11, 13], [1, 12], [2, 3, 5, 6, 7, 14]]",3.0,"{'num_nodes': 14, 'num_edges': 29, 'edges': [{'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 11}, {'u': 1, 'v': 13}, {'u': 1, 'v': 14}, {'u': 4, 'v': 14}, {'u': 12, 'v': 3}, {'u': 12, 'v': 8}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 13, 'v': 2}, {'u': 13, 'v': 3}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 7}, {'u': 13, 'v': 14}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 14}, {'u': 7, 'v': 8}, {'u': 7, 'v': 10}, {'u': 10, 'v': 3}, {'u': 2, 'v': 8}, {'u': 6, 'v': 8}, {'u': 14, 'v': 8}, {'u': 8, 'v': 3}]}","[[4, 8, 9, 10, 11, 13], [1, 12], [2, 3, 5, 6, 7, 14]]",25,csv,1
GCP,GCP,"Recently the city decided to tag every crosswalk with a paint design code, under the simple rule that crosswalks converging at one intersection must all look different. Every crosswalk must receive one code, no exceptions, and the objective is to make the palette as small as possible — just count how many unique codes appear to see how compact the solution is. The detailed map and example cases follow below.

There are 16 crosswalks and 33 pairs of adjacent crosswalks on the map.
Crosswalk 3 meets crosswalk 2 at an intersection and therefore must receive a different paint design code.
Crosswalk 3 meets crosswalk 13 at an intersection and therefore must receive a different paint design code.
Crosswalk 15 meets crosswalk 13 at an intersection and therefore must receive a different paint design code.
Crosswalk 7 meets crosswalk 9 at an intersection and therefore must receive a different paint design code.
Crosswalk 7 meets crosswalk 10 at an intersection and therefore must receive a different paint design code.
Crosswalk 7 meets crosswalk 13 at an intersection and therefore must receive a different paint design code.
Crosswalk 14 meets crosswalk 9 at an intersection and therefore must receive a different paint design code.
Crosswalk 14 meets crosswalk 13 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 0 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 1 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 2 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 4 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 5 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 6 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 8 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 9 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 10 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 11 at an intersection and therefore must receive a different paint design code.
Crosswalk 13 meets crosswalk 12 at an intersection and therefore must receive a different paint design code.
Crosswalk 11 meets crosswalk 2 at an intersection and therefore must receive a different paint design code.
Crosswalk 11 meets crosswalk 5 at an intersection and therefore must receive a different paint design code.
Crosswalk 11 meets crosswalk 8 at an intersection and therefore must receive a different paint design code.
Crosswalk 11 meets crosswalk 10 at an intersection and therefore must receive a different paint design code.
Crosswalk 2 meets crosswalk 5 at an intersection and therefore must receive a different paint design code.
Crosswalk 2 meets crosswalk 8 at an intersection and therefore must receive a different paint design code.
Crosswalk 2 meets crosswalk 10 at an intersection and therefore must receive a different paint design code.
Crosswalk 12 meets crosswalk 4 at an intersection and therefore must receive a different paint design code.
Crosswalk 1 meets crosswalk 9 at an intersection and therefore must receive a different paint design code.
Crosswalk 1 meets crosswalk 10 at an intersection and therefore must receive a different paint design code.
Crosswalk 6 meets crosswalk 9 at an intersection and therefore must receive a different paint design code.
Crosswalk 8 meets crosswalk 10 at an intersection and therefore must receive a different paint design code.
Crosswalk 5 meets crosswalk 10 at an intersection and therefore must receive a different paint design code.
Crosswalk 10 meets crosswalk 9 at an intersection and therefore must receive a different paint design code.
Every crosswalk must be coded; minimize the number of unique paint codes used.

If you want to hand me the results in a machine-friendly way, just follow this little JSON shape:

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

Each inner list is one paint design code and lists the crosswalk IDs that get that same code. The outer array collects all the different codes used. This is just a sketch of the expected shape—not the actual assignment.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 33, 'edges': [{'u': 4, 'v': 3}, {'u': 4, 'v': 14}, {'u': 16, 'v': 14}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 14}, {'u': 15, 'v': 10}, {'u': 15, 'v': 14}, {'u': 14, 'v': 1}, {'u': 14, 'v': 2}, {'u': 14, 'v': 3}, {'u': 14, 'v': 5}, {'u': 14, 'v': 6}, {'u': 14, 'v': 7}, {'u': 14, 'v': 9}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 14, 'v': 13}, {'u': 12, 'v': 3}, {'u': 12, 'v': 6}, {'u': 12, 'v': 9}, {'u': 12, 'v': 11}, {'u': 3, 'v': 6}, {'u': 3, 'v': 9}, {'u': 3, 'v': 11}, {'u': 13, 'v': 5}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 7, 'v': 10}, {'u': 9, 'v': 11}, {'u': 6, 'v': 11}, {'u': 11, 'v': 10}], 'source_file': 'citationCiteseer.mtx', 'density': 0.275, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0025.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0025.png', 'edge_connectivity': 1}","[[1, 2, 4, 7, 8, 12, 13, 15, 16], [3], [11], [14], [5, 6, 9, 10]]",5.0,"{'num_nodes': 16, 'num_edges': 33, 'edges': [{'u': 3, 'v': 2}, {'u': 3, 'v': 13}, {'u': 15, 'v': 13}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 13}, {'u': 14, 'v': 9}, {'u': 14, 'v': 13}, {'u': 13, 'v': 0}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 4}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 8}, {'u': 13, 'v': 9}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 13, 'v': 12}, {'u': 11, 'v': 2}, {'u': 11, 'v': 5}, {'u': 11, 'v': 8}, {'u': 11, 'v': 10}, {'u': 2, 'v': 5}, {'u': 2, 'v': 8}, {'u': 2, 'v': 10}, {'u': 12, 'v': 4}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 6, 'v': 9}, {'u': 8, 'v': 10}, {'u': 5, 'v': 10}, {'u': 10, 'v': 9}]}","[[0, 1, 3, 6, 7, 11, 12, 14, 15], [2], [10], [13], [4, 5, 8, 9]]",26,nl,0
GCP,GCP,"Someone organized teams for a school event and needed to assign a shirt color to every team, with the rule that teams seated alongside one another can’t wear the same color. What makes one assignment better than another is how many different colors end up being used — lower is better, and you can compute that by counting the different colors used across all teams. Every team must have exactly one color and adjacency pairs must be different. The specific seating arrangement and team list are given below.

{
  ""total_groups"": 14,
  ""adjacent_group_pairs"": 42,
  ""edges"": [
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""D""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""E""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""G""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""H""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""I""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""J""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""K""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""L""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""M""
    },
    {
      ""group_a_id"": ""F"",
      ""group_b_id"": ""N""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""D""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""E""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""H""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""I""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""J""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""K""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""L""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""M""
    },
    {
      ""group_a_id"": ""G"",
      ""group_b_id"": ""N""
    },
    {
      ""group_a_id"": ""H"",
      ""group_b_id"": ""E""
    },
    {
      ""group_a_id"": ""H"",
      ""group_b_id"": ""I""
    },
    {
      ""group_a_id"": ""H"",
      ""group_b_id"": ""K""
    },
    {
      ""group_a_id"": ""H"",
      ""group_b_id"": ""L""
    },
    {
      ""group_a_id"": ""H"",
      ""group_b_id"": ""N""
    },
    {
      ""group_a_id"": ""I"",
      ""group_b_id"": ""C""
    },
    {
      ""group_a_id"": ""I"",
      ""group_b_id"": ""E""
    },
    {
      ""group_a_id"": ""I"",
      ""group_b_id"": ""K""
    },
    {
      ""group_a_id"": ""I"",
      ""group_b_id"": ""L""
    },
    {
      ""group_a_id"": ""I"",
      ""group_b_id"": ""N""
    },
    {
      ""group_a_id"": ""J"",
      ""group_b_id"": ""D""
    },
    {
      ""group_a_id"": ""J"",
      ""group_b_id"": ""M""
    },
    {
      ""group_a_id"": ""K"",
      ""group_b_id"": ""C""
    },
    {
      ""group_a_id"": ""K"",
      ""group_b_id"": ""E""
    },
    {
      ""group_a_id"": ""K"",
      ""group_b_id"": ""L""
    },
    {
      ""group_a_id"": ""K"",
      ""group_b_id"": ""N""
    },
    {
      ""group_a_id"": ""L"",
      ""group_b_id"": ""E""
    },
    {
      ""group_a_id"": ""L"",
      ""group_b_id"": ""N""
    },
    {
      ""group_a_id"": ""D"",
      ""group_b_id"": ""M""
    },
    {
      ""group_a_id"": ""N"",
      ""group_b_id"": ""E""
    },
    {
      ""group_a_id"": ""B"",
      ""group_b_id"": ""A""
    },
    {
      ""group_a_id"": ""B"",
      ""group_b_id"": ""C""
    },
    {
      ""group_a_id"": ""A"",
      ""group_b_id"": ""C""
    }
  ]
}

Also, when you send the solution back, please stick to this simple JSON layout so it's easy to read and check:

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

This JSON is just a friendly sketch: ""solution"" is the list of color groups, and each inner list contains the team identifiers that get the same shirt color. Think of each inner array as one color and the team IDs inside it as who wears that color. It's a template, not the actual coloring — just the shape I need.

One important note: use the exact identifiers from the instance input — do not rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 42, 'edges': [{'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 6, 'v': 12}, {'u': 6, 'v': 13}, {'u': 6, 'v': 14}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 7, 'v': 14}, {'u': 8, 'v': 5}, {'u': 8, 'v': 9}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 8, 'v': 14}, {'u': 9, 'v': 3}, {'u': 9, 'v': 5}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 14}, {'u': 10, 'v': 4}, {'u': 10, 'v': 13}, {'u': 11, 'v': 3}, {'u': 11, 'v': 5}, {'u': 11, 'v': 12}, {'u': 11, 'v': 14}, {'u': 12, 'v': 5}, {'u': 12, 'v': 14}, {'u': 4, 'v': 13}, {'u': 14, 'v': 5}, {'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 1, 'v': 3}], 'source_file': 'coPapersCiteseer.mtx', 'density': 0.46153846153846156, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0026.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0026.png', 'edge_connectivity': 2}","[[3, 4, 14], [8, 13], [1, 6], [2, 5], [7], [11], [9], [10, 12]]",8.0,"{'num_nodes': 14, 'num_edges': 42, 'edges': [{'u': 'F', 'v': 'D'}, {'u': 'F', 'v': 'E'}, {'u': 'F', 'v': 'G'}, {'u': 'F', 'v': 'H'}, {'u': 'F', 'v': 'I'}, {'u': 'F', 'v': 'J'}, {'u': 'F', 'v': 'K'}, {'u': 'F', 'v': 'L'}, {'u': 'F', 'v': 'M'}, {'u': 'F', 'v': 'N'}, {'u': 'G', 'v': 'D'}, {'u': 'G', 'v': 'E'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'I'}, {'u': 'G', 'v': 'J'}, {'u': 'G', 'v': 'K'}, {'u': 'G', 'v': 'L'}, {'u': 'G', 'v': 'M'}, {'u': 'G', 'v': 'N'}, {'u': 'H', 'v': 'E'}, {'u': 'H', 'v': 'I'}, {'u': 'H', 'v': 'K'}, {'u': 'H', 'v': 'L'}, {'u': 'H', 'v': 'N'}, {'u': 'I', 'v': 'C'}, {'u': 'I', 'v': 'E'}, {'u': 'I', 'v': 'K'}, {'u': 'I', 'v': 'L'}, {'u': 'I', 'v': 'N'}, {'u': 'J', 'v': 'D'}, {'u': 'J', 'v': 'M'}, {'u': 'K', 'v': 'C'}, {'u': 'K', 'v': 'E'}, {'u': 'K', 'v': 'L'}, {'u': 'K', 'v': 'N'}, {'u': 'L', 'v': 'E'}, {'u': 'L', 'v': 'N'}, {'u': 'D', 'v': 'M'}, {'u': 'N', 'v': 'E'}, {'u': 'B', 'v': 'A'}, {'u': 'B', 'v': 'C'}, {'u': 'A', 'v': 'C'}]}","[['C', 'D', 'N'], ['H', 'M'], ['A', 'F'], ['B', 'E'], ['G'], ['K'], ['I'], ['J', 'L']]",27,json,names
GCP,GCP,"Many people at the allotment want tidy-looking edges, so the plan was: assign one border color to every bed, make sure any beds that touch along a path don’t match, and keep the paint box as small as possible — the better plan uses fewer distinct colors, counted across all beds. The concrete details will be shown below.

{
  ""total_beds"": 14,
  ""total_touching_pairs"": 53,
  ""edges"": [
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 0
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 1
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 7
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 9
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 10
    },
    {
      ""adjacent_bed_a"": 6,
      ""adjacent_bed_b"": 11
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 1
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 4
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 7
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 8
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 9
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 10
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 11
    },
    {
      ""adjacent_bed_a"": 0,
      ""adjacent_bed_b"": 12
    },
    {
      ""adjacent_bed_a"": 7,
      ""adjacent_bed_b"": 1
    },
    {
      ""adjacent_bed_a"": 7,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 7,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 7,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 7,
      ""adjacent_bed_b"": 9
    },
    {
      ""adjacent_bed_a"": 7,
      ""adjacent_bed_b"": 10
    },
    {
      ""adjacent_bed_a"": 7,
      ""adjacent_bed_b"": 11
    },
    {
      ""adjacent_bed_a"": 8,
      ""adjacent_bed_b"": 1
    },
    {
      ""adjacent_bed_a"": 8,
      ""adjacent_bed_b"": 4
    },
    {
      ""adjacent_bed_a"": 9,
      ""adjacent_bed_b"": 1
    },
    {
      ""adjacent_bed_a"": 9,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 9,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 9,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 9,
      ""adjacent_bed_b"": 10
    },
    {
      ""adjacent_bed_a"": 9,
      ""adjacent_bed_b"": 11
    },
    {
      ""adjacent_bed_a"": 10,
      ""adjacent_bed_b"": 1
    },
    {
      ""adjacent_bed_a"": 10,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 10,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 10,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 10,
      ""adjacent_bed_b"": 11
    },
    {
      ""adjacent_bed_a"": 11,
      ""adjacent_bed_b"": 1
    },
    {
      ""adjacent_bed_a"": 11,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 11,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 11,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 1,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 1,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 1,
      ""adjacent_bed_b"": 4
    },
    {
      ""adjacent_bed_a"": 1,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 12,
      ""adjacent_bed_b"": 2
    },
    {
      ""adjacent_bed_a"": 13,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 2,
      ""adjacent_bed_b"": 3
    },
    {
      ""adjacent_bed_a"": 2,
      ""adjacent_bed_b"": 5
    },
    {
      ""adjacent_bed_a"": 3,
      ""adjacent_bed_b"": 5
    }
  ]
}

Also, when you send the coloring back, just use this little JSON layout so it's easy to read:

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

Each inner array is one paint color — list the bed IDs that share that border color together. The outer array is just the collection of all those color groups. This is only a sketch of the shape I want, not the actual filled-in answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.

- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 53, 'edges': [{'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 7, 'v': 6}, {'u': 7, 'v': 8}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 1, 'v': 13}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 6}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 9, 'v': 2}, {'u': 9, 'v': 5}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 4}, {'u': 10, 'v': 6}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 11, 'v': 2}, {'u': 11, 'v': 3}, {'u': 11, 'v': 4}, {'u': 11, 'v': 6}, {'u': 11, 'v': 12}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 4}, {'u': 12, 'v': 6}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 13, 'v': 3}, {'u': 14, 'v': 6}, {'u': 3, 'v': 4}, {'u': 3, 'v': 6}, {'u': 4, 'v': 6}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.5824175824175825, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0027.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0027.png', 'edge_connectivity': 1}","[[10], [6], [2, 13], [4], [1], [8, 14], [11], [7, 9], [5, 12], [3]]",10.0,"{'num_nodes': 14, 'num_edges': 53, 'edges': [{'u': 6, 'v': 0}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 6, 'v': 5}, {'u': 6, 'v': 7}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 0, 'v': 1}, {'u': 0, 'v': 2}, {'u': 0, 'v': 3}, {'u': 0, 'v': 4}, {'u': 0, 'v': 5}, {'u': 0, 'v': 7}, {'u': 0, 'v': 8}, {'u': 0, 'v': 9}, {'u': 0, 'v': 10}, {'u': 0, 'v': 11}, {'u': 0, 'v': 12}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 5}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 8, 'v': 1}, {'u': 8, 'v': 4}, {'u': 9, 'v': 1}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 5}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 5}, {'u': 10, 'v': 11}, {'u': 11, 'v': 1}, {'u': 11, 'v': 2}, {'u': 11, 'v': 3}, {'u': 11, 'v': 5}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 12, 'v': 2}, {'u': 13, 'v': 5}, {'u': 2, 'v': 3}, {'u': 2, 'v': 5}, {'u': 3, 'v': 5}]}","[[9], [5], [1, 12], [3], [0], [7, 13], [10], [6, 8], [4, 11], [2]]",28,json,0
GCP,GCP,"There’s a busy concourse where every gate needs to be fitted with a curtain, but gates that touch via jet bridges can’t have matching curtains. The idea is to assign one color to each gate so no neighboring gates share a color, and to keep the total variety of colors as low as possible — just count how many different colors end up being used to see how well that went. Nothing can be skipped: each gate needs exactly one curtain and adjacent gates must differ. The concrete layout and instance details follow below.

This instance has 17 gates and 39 jet-bridge adjacencies:
Gate 12 and gate 5 share a jet bridge, so their curtains must be different.
Gate 12 and gate 6 share a jet bridge, so their curtains must be different.
Gate 12 and gate 7 share a jet bridge, so their curtains must be different.
Gate 16 and gate 2 share a jet bridge, so their curtains must be different.
Gate 16 and gate 5 share a jet bridge, so their curtains must be different.
Gate 16 and gate 6 share a jet bridge, so their curtains must be different.
Gate 9 and gate 1 share a jet bridge, so their curtains must be different.
Gate 9 and gate 4 share a jet bridge, so their curtains must be different.
Gate 9 and gate 5 share a jet bridge, so their curtains must be different.
Gate 9 and gate 13 share a jet bridge, so their curtains must be different.
Gate 9 and gate 17 share a jet bridge, so their curtains must be different.
Gate 7 and gate 2 share a jet bridge, so their curtains must be different.
Gate 7 and gate 4 share a jet bridge, so their curtains must be different.
Gate 7 and gate 6 share a jet bridge, so their curtains must be different.
Gate 1 and gate 4 share a jet bridge, so their curtains must be different.
Gate 1 and gate 6 share a jet bridge, so their curtains must be different.
Gate 17 and gate 5 share a jet bridge, so their curtains must be different.
Gate 17 and gate 6 share a jet bridge, so their curtains must be different.
Gate 14 and gate 2 share a jet bridge, so their curtains must be different.
Gate 14 and gate 8 share a jet bridge, so their curtains must be different.
Gate 11 and gate 2 share a jet bridge, so their curtains must be different.
Gate 11 and gate 5 share a jet bridge, so their curtains must be different.
Gate 11 and gate 6 share a jet bridge, so their curtains must be different.
Gate 8 and gate 2 share a jet bridge, so their curtains must be different.
Gate 8 and gate 3 share a jet bridge, so their curtains must be different.
Gate 15 and gate 2 share a jet bridge, so their curtains must be different.
Gate 15 and gate 6 share a jet bridge, so their curtains must be different.
Gate 13 and gate 2 share a jet bridge, so their curtains must be different.
Gate 13 and gate 4 share a jet bridge, so their curtains must be different.
Gate 13 and gate 5 share a jet bridge, so their curtains must be different.
Gate 13 and gate 6 share a jet bridge, so their curtains must be different.
Gate 3 and gate 2 share a jet bridge, so their curtains must be different.
Gate 6 and gate 2 share a jet bridge, so their curtains must be different.
Gate 6 and gate 4 share a jet bridge, so their curtains must be different.
Gate 6 and gate 5 share a jet bridge, so their curtains must be different.
Gate 6 and gate 10 share a jet bridge, so their curtains must be different.
Gate 4 and gate 2 share a jet bridge, so their curtains must be different.
Gate 4 and gate 10 share a jet bridge, so their curtains must be different.
Gate 2 and gate 5 share a jet bridge, so their curtains must be different.
Assign exactly one curtain to each gate so every adjacent pair uses different colors; aim to minimize the number of distinct colors.

If you want to hand the curtain plan back in a compact, machine-friendly way, just follow this simple JSON shape for the answer.

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

Think of each inner list as a group of gates that all get the same curtain color (so no two touching gates should end up in the same inner list). The outer list is just the collection of those color-groups. This is just a template showing the expected shape, not the actual assignment.

Please make sure to use the exact gate identifiers from the instance input — do not rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 39, 'edges': [{'u': 12, 'v': 5}, {'u': 12, 'v': 6}, {'u': 12, 'v': 7}, {'u': 16, 'v': 2}, {'u': 16, 'v': 5}, {'u': 16, 'v': 6}, {'u': 9, 'v': 1}, {'u': 9, 'v': 4}, {'u': 9, 'v': 5}, {'u': 9, 'v': 13}, {'u': 9, 'v': 17}, {'u': 7, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 6}, {'u': 1, 'v': 4}, {'u': 1, 'v': 6}, {'u': 17, 'v': 5}, {'u': 17, 'v': 6}, {'u': 14, 'v': 2}, {'u': 14, 'v': 8}, {'u': 11, 'v': 2}, {'u': 11, 'v': 5}, {'u': 11, 'v': 6}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 15, 'v': 2}, {'u': 15, 'v': 6}, {'u': 13, 'v': 2}, {'u': 13, 'v': 4}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 3, 'v': 2}, {'u': 6, 'v': 2}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 10}, {'u': 4, 'v': 2}, {'u': 4, 'v': 10}, {'u': 2, 'v': 5}], 'source_file': 'citationCiteseer.mtx', 'density': 0.2867647058823529, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0028.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0028.png', 'edge_connectivity': 2}","[[7, 10, 11, 13, 14, 15, 16, 17], [3, 4, 5], [6, 8, 9], [1, 2, 12]]",4.0,"{'num_nodes': 17, 'num_edges': 39, 'edges': [{'u': 12, 'v': 5}, {'u': 12, 'v': 6}, {'u': 12, 'v': 7}, {'u': 16, 'v': 2}, {'u': 16, 'v': 5}, {'u': 16, 'v': 6}, {'u': 9, 'v': 1}, {'u': 9, 'v': 4}, {'u': 9, 'v': 5}, {'u': 9, 'v': 13}, {'u': 9, 'v': 17}, {'u': 7, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 6}, {'u': 1, 'v': 4}, {'u': 1, 'v': 6}, {'u': 17, 'v': 5}, {'u': 17, 'v': 6}, {'u': 14, 'v': 2}, {'u': 14, 'v': 8}, {'u': 11, 'v': 2}, {'u': 11, 'v': 5}, {'u': 11, 'v': 6}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 15, 'v': 2}, {'u': 15, 'v': 6}, {'u': 13, 'v': 2}, {'u': 13, 'v': 4}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 3, 'v': 2}, {'u': 6, 'v': 2}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 10}, {'u': 4, 'v': 2}, {'u': 4, 'v': 10}, {'u': 2, 'v': 5}]}","[[7, 10, 11, 13, 14, 15, 16, 17], [3, 4, 5], [6, 8, 9], [1, 2, 12]]",29,nl,1
GCP,GCP,"Imagine a shelf where every magazine gets a colored sleeve, and the rule is that any two magazines touching side by side must wear different colors. The job is to assign one color to each magazine (no magazine without a sleeve and none with two), and to avoid matching colors on neighbors. The neatest solution is the one that ends up with the fewest different sleeve colors — look at all sleeves, count the unique colors, and minimize that count. The full details of which magazines are next to each other are listed below.

{
  ""num_magazines"": 17,
  ""adjacent_pairs_count"": 48,
  ""edges"": [
    {
      ""magazine_one_id"": 13,
      ""magazine_two_id"": 6
    },
    {
      ""magazine_one_id"": 13,
      ""magazine_two_id"": 8
    },
    {
      ""magazine_one_id"": 13,
      ""magazine_two_id"": 10
    },
    {
      ""magazine_one_id"": 13,
      ""magazine_two_id"": 14
    },
    {
      ""magazine_one_id"": 2,
      ""magazine_two_id"": 7
    },
    {
      ""magazine_one_id"": 2,
      ""magazine_two_id"": 8
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 1
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 4
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 5
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 6
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 9
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 12
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 15
    },
    {
      ""magazine_one_id"": 10,
      ""magazine_two_id"": 17
    },
    {
      ""magazine_one_id"": 17,
      ""magazine_two_id"": 1
    },
    {
      ""magazine_one_id"": 17,
      ""magazine_two_id"": 9
    },
    {
      ""magazine_one_id"": 17,
      ""magazine_two_id"": 12
    },
    {
      ""magazine_one_id"": 17,
      ""magazine_two_id"": 16
    },
    {
      ""magazine_one_id"": 1,
      ""magazine_two_id"": 4
    },
    {
      ""magazine_one_id"": 1,
      ""magazine_two_id"": 5
    },
    {
      ""magazine_one_id"": 1,
      ""magazine_two_id"": 9
    },
    {
      ""magazine_one_id"": 1,
      ""magazine_two_id"": 11
    },
    {
      ""magazine_one_id"": 1,
      ""magazine_two_id"": 15
    },
    {
      ""magazine_one_id"": 1,
      ""magazine_two_id"": 16
    },
    {
      ""magazine_one_id"": 14,
      ""magazine_two_id"": 3
    },
    {
      ""magazine_one_id"": 14,
      ""magazine_two_id"": 6
    },
    {
      ""magazine_one_id"": 14,
      ""magazine_two_id"": 11
    },
    {
      ""magazine_one_id"": 14,
      ""magazine_two_id"": 12
    },
    {
      ""magazine_one_id"": 16,
      ""magazine_two_id"": 6
    },
    {
      ""magazine_one_id"": 16,
      ""magazine_two_id"": 9
    },
    {
      ""magazine_one_id"": 16,
      ""magazine_two_id"": 11
    },
    {
      ""magazine_one_id"": 16,
      ""magazine_two_id"": 15
    },
    {
      ""magazine_one_id"": 9,
      ""magazine_two_id"": 4
    },
    {
      ""magazine_one_id"": 9,
      ""magazine_two_id"": 6
    },
    {
      ""magazine_one_id"": 9,
      ""magazine_two_id"": 15
    },
    {
      ""magazine_one_id"": 12,
      ""magazine_two_id"": 6
    },
    {
      ""magazine_one_id"": 12,
      ""magazine_two_id"": 8
    },
    {
      ""magazine_one_id"": 7,
      ""magazine_two_id"": 8
    },
    {
      ""magazine_one_id"": 6,
      ""magazine_two_id"": 4
    },
    {
      ""magazine_one_id"": 6,
      ""magazine_two_id"": 5
    },
    {
      ""magazine_one_id"": 6,
      ""magazine_two_id"": 11
    },
    {
      ""magazine_one_id"": 6,
      ""magazine_two_id"": 15
    },
    {
      ""magazine_one_id"": 11,
      ""magazine_two_id"": 5
    },
    {
      ""magazine_one_id"": 11,
      ""magazine_two_id"": 8
    },
    {
      ""magazine_one_id"": 11,
      ""magazine_two_id"": 15
    },
    {
      ""magazine_one_id"": 15,
      ""magazine_two_id"": 4
    },
    {
      ""magazine_one_id"": 15,
      ""magazine_two_id"": 5
    },
    {
      ""magazine_one_id"": 8,
      ""magazine_two_id"": 4
    }
  ]
}

Also, when you reply with your proposed grouping of sleeves, please use this simple JSON layout so it's easy to parse.

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

The ""solution"" array is just a list of groups — each inner list contains the magazine identifiers that share the same sleeve color. Think of each inner list as one sleeve color and the strings as the magazine labels to put inside that sleeve. This block is just a sketch of the shape I need, not the actual answer.

Please be sure to use the exact identifiers from the instance input — don’t rename them or invent new ones. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 48, 'edges': [{'u': 13, 'v': 6}, {'u': 13, 'v': 8}, {'u': 13, 'v': 10}, {'u': 13, 'v': 14}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 10, 'v': 1}, {'u': 10, 'v': 4}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 9}, {'u': 10, 'v': 12}, {'u': 10, 'v': 15}, {'u': 10, 'v': 17}, {'u': 17, 'v': 1}, {'u': 17, 'v': 9}, {'u': 17, 'v': 12}, {'u': 17, 'v': 16}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 9}, {'u': 1, 'v': 11}, {'u': 1, 'v': 15}, {'u': 1, 'v': 16}, {'u': 14, 'v': 3}, {'u': 14, 'v': 6}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 16, 'v': 6}, {'u': 16, 'v': 9}, {'u': 16, 'v': 11}, {'u': 16, 'v': 15}, {'u': 9, 'v': 4}, {'u': 9, 'v': 6}, {'u': 9, 'v': 15}, {'u': 12, 'v': 6}, {'u': 12, 'v': 8}, {'u': 7, 'v': 8}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 11}, {'u': 6, 'v': 15}, {'u': 11, 'v': 5}, {'u': 11, 'v': 8}, {'u': 11, 'v': 15}, {'u': 15, 'v': 4}, {'u': 15, 'v': 5}, {'u': 8, 'v': 4}], 'source_file': 'citationCiteseer.mtx', 'density': 0.35294117647058826, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0029.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0029.png', 'edge_connectivity': 1}","[[9, 11, 12, 13], [2, 15, 17], [4, 5, 16], [8, 10, 14], [1, 3, 6, 7]]",5.0,"{'num_nodes': 17, 'num_edges': 48, 'edges': [{'u': 13, 'v': 6}, {'u': 13, 'v': 8}, {'u': 13, 'v': 10}, {'u': 13, 'v': 14}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 10, 'v': 1}, {'u': 10, 'v': 4}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 9}, {'u': 10, 'v': 12}, {'u': 10, 'v': 15}, {'u': 10, 'v': 17}, {'u': 17, 'v': 1}, {'u': 17, 'v': 9}, {'u': 17, 'v': 12}, {'u': 17, 'v': 16}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 9}, {'u': 1, 'v': 11}, {'u': 1, 'v': 15}, {'u': 1, 'v': 16}, {'u': 14, 'v': 3}, {'u': 14, 'v': 6}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 16, 'v': 6}, {'u': 16, 'v': 9}, {'u': 16, 'v': 11}, {'u': 16, 'v': 15}, {'u': 9, 'v': 4}, {'u': 9, 'v': 6}, {'u': 9, 'v': 15}, {'u': 12, 'v': 6}, {'u': 12, 'v': 8}, {'u': 7, 'v': 8}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 11}, {'u': 6, 'v': 15}, {'u': 11, 'v': 5}, {'u': 11, 'v': 8}, {'u': 11, 'v': 15}, {'u': 15, 'v': 4}, {'u': 15, 'v': 5}, {'u': 8, 'v': 4}]}","[[9, 11, 12, 13], [2, 15, 17], [4, 5, 16], [8, 10, 14], [1, 3, 6, 7]]",30,json,1
GCP,GCP,"Someone on the design team said it best: give each exhibit a single accent, never give the same accent to two exhibits that are connected by visitor routes, and don’t leave any exhibit unaccented or slap more than one on the same exhibit. Success is just using the smallest number of different accents — you can see how well that worked by counting the unique colors used. The specific map and data are shown below.

There are 13 exhibits in total and 29 visitor routes.

| exhibit_a | exhibit_b |
|---|---|
| 1 | 0 |
| 1 | 2 |
| 1 | 3 |
| 1 | 4 |
| 1 | 5 |
| 1 | 6 |
| 1 | 7 |
| 1 | 8 |
| 1 | 9 |
| 1 | 10 |
| 1 | 11 |
| 1 | 12 |
| 2 | 3 |
| 4 | 0 |
| 4 | 5 |
| 4 | 7 |
| 0 | 5 |
| 0 | 6 |
| 0 | 7 |
| 0 | 8 |
| 10 | 8 |
| 10 | 11 |
| 10 | 12 |
| 11 | 8 |
| 12 | 8 |
| 5 | 6 |
| 5 | 7 |
| 5 | 8 |
| 6 | 8 |

Oh — and when you send the final assignment, just stick to this simple JSON shape so it's easy to check automatically:

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

Here each inner list is one accent/color group — basically a list of the exhibits that share the same accent — and the outer list is the collection of those groups. Think of it as a handful of buckets: put each exhibit ID into exactly one bucket. This is just the expected shape, not the actual coloring answer.

Please make sure every identifier you list matches the instance input exactly — no renaming and no extra labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 13, 'num_edges': 29, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 9}, {'u': 2, 'v': 10}, {'u': 2, 'v': 11}, {'u': 2, 'v': 12}, {'u': 2, 'v': 13}, {'u': 3, 'v': 4}, {'u': 5, 'v': 1}, {'u': 5, 'v': 6}, {'u': 5, 'v': 8}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 11, 'v': 9}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 12, 'v': 9}, {'u': 13, 'v': 9}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 7, 'v': 9}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.3717948717948718, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0030.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0030.png', 'edge_connectivity': 1}","[[3, 7, 8, 11], [2], [6], [1, 4, 10, 12, 13], [5, 9]]",5.0,"{'num_nodes': 13, 'num_edges': 29, 'edges': [{'u': 1, 'v': 0}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 2, 'v': 3}, {'u': 4, 'v': 0}, {'u': 4, 'v': 5}, {'u': 4, 'v': 7}, {'u': 0, 'v': 5}, {'u': 0, 'v': 6}, {'u': 0, 'v': 7}, {'u': 0, 'v': 8}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 11, 'v': 8}, {'u': 12, 'v': 8}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 6, 'v': 8}]}","[[2, 6, 7, 10], [1], [5], [0, 3, 9, 11, 12], [4, 8]]",31,markdown_table,0
GCP,GCP,"Someone on the release team is sorting modules into colored channels so dependencies don’t collide: every module gets one color, but if one module depends on another they must have different colors. The better the arrangement, the fewer total colors you use — evaluate it by counting the distinct colors assigned. Make sure nothing is left uncolored and no directly dependent pair shares a color. The full list of modules and their links appears below.

There are 13 num modules in total and 21 num dependency links.

| module_a | module_b |
|---|---|
| L | C |
| L | G |
| L | M |
| D | B |
| B | F |
| I | F |
| I | J |
| I | M |
| C | A |
| C | G |
| C | K |
| C | M |
| F | E |
| F | J |
| F | M |
| E | H |
| G | A |
| G | K |
| G | M |
| M | J |
| M | K |

Also, when you send the arrangement back, please stick to this JSON layout so it's easy to parse:

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

Each inner list is one color channel — just list the modules that share that color together. Make sure every module appears exactly once and that no module appears in the same inner list as one of its direct dependencies. This JSON is just a sketch of the shape I need, not the actual answer.

Also, use the exact identifiers given 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”"".","{'problem_type': 'GCP', 'num_nodes': 13, 'num_edges': 21, 'edges': [{'u': 12, 'v': 3}, {'u': 12, 'v': 7}, {'u': 12, 'v': 13}, {'u': 4, 'v': 2}, {'u': 2, 'v': 6}, {'u': 9, 'v': 6}, {'u': 9, 'v': 10}, {'u': 9, 'v': 13}, {'u': 3, 'v': 1}, {'u': 3, 'v': 7}, {'u': 3, 'v': 11}, {'u': 3, 'v': 13}, {'u': 6, 'v': 5}, {'u': 6, 'v': 10}, {'u': 6, 'v': 13}, {'u': 5, 'v': 8}, {'u': 7, 'v': 1}, {'u': 7, 'v': 11}, {'u': 7, 'v': 13}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}], 'source_file': 'citationCiteseer.mtx', 'density': 0.2692307692307692, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0031.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0031.png', 'edge_connectivity': 1}","[[4, 7, 8, 10], [3, 6], [5, 13], [1, 2, 9, 11, 12]]",4.0,"{'num_nodes': 13, 'num_edges': 21, 'edges': [{'u': 'L', 'v': 'C'}, {'u': 'L', 'v': 'G'}, {'u': 'L', 'v': 'M'}, {'u': 'D', 'v': 'B'}, {'u': 'B', 'v': 'F'}, {'u': 'I', 'v': 'F'}, {'u': 'I', 'v': 'J'}, {'u': 'I', 'v': 'M'}, {'u': 'C', 'v': 'A'}, {'u': 'C', 'v': 'G'}, {'u': 'C', 'v': 'K'}, {'u': 'C', 'v': 'M'}, {'u': 'F', 'v': 'E'}, {'u': 'F', 'v': 'J'}, {'u': 'F', 'v': 'M'}, {'u': 'E', 'v': 'H'}, {'u': 'G', 'v': 'A'}, {'u': 'G', 'v': 'K'}, {'u': 'G', 'v': 'M'}, {'u': 'M', 'v': 'J'}, {'u': 'M', 'v': 'K'}]}","[['D', 'G', 'H', 'J'], ['C', 'F'], ['E', 'M'], ['A', 'B', 'I', 'K', 'L']]",32,markdown_table,names
GCP,GCP,"Back when the neighborhood decided to coordinate mailbox colors, the rule became: paint every box, don’t let any two side-by-side boxes share the same paint, and try to do it with the fewest different paints you can manage. That requires picking one color per mailbox, avoiding identical colors on adjacent boxes, and minimizing the total count of unique colors — the fewer unique paints, the better, and that count is what’s tracked. The concrete mailbox map appears below.

There are 16 mailboxes in total and 30 adjacent mailbox pairs.

| mailbox_one_id | mailbox_two_id |
|---|---|
| 15 | 16 |
| 9 | 12 |
| 9 | 16 |
| 12 | 3 |
| 12 | 5 |
| 12 | 7 |
| 12 | 8 |
| 12 | 10 |
| 12 | 13 |
| 3 | 2 |
| 3 | 4 |
| 3 | 14 |
| 3 | 16 |
| 2 | 5 |
| 2 | 14 |
| 2 | 16 |
| 8 | 16 |
| 1 | 6 |
| 1 | 7 |
| 1 | 11 |
| 14 | 4 |
| 14 | 5 |
| 14 | 16 |
| 5 | 16 |
| 7 | 6 |
| 7 | 11 |
| 7 | 16 |
| 10 | 4 |
| 10 | 16 |
| 16 | 13 |

Also, to keep things simple for me to check your answer, please put the assignment into a little JSON sketch like this:

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

Think of each inner list as a group of mailboxes that all get the same paint color — one list per paint. The outer array is just the collection of those paint-groups. This is just a template showing the shape I expect, not the actual painted map.

Please make sure you use the exact identifiers from the instance input — do not rename them or invent new ones. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 30, 'edges': [{'u': 15, 'v': 16}, {'u': 9, 'v': 12}, {'u': 9, 'v': 16}, {'u': 12, 'v': 3}, {'u': 12, 'v': 5}, {'u': 12, 'v': 7}, {'u': 12, 'v': 8}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 3, 'v': 2}, {'u': 3, 'v': 4}, {'u': 3, 'v': 14}, {'u': 3, 'v': 16}, {'u': 2, 'v': 5}, {'u': 2, 'v': 14}, {'u': 2, 'v': 16}, {'u': 8, 'v': 16}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 11}, {'u': 14, 'v': 4}, {'u': 14, 'v': 5}, {'u': 14, 'v': 16}, {'u': 5, 'v': 16}, {'u': 7, 'v': 6}, {'u': 7, 'v': 11}, {'u': 7, 'v': 16}, {'u': 10, 'v': 4}, {'u': 10, 'v': 16}, {'u': 16, 'v': 13}], 'source_file': 'citationCiteseer.mtx', 'density': 0.25, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0032.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0032.png', 'edge_connectivity': 1}","[[1, 12, 14, 15], [16], [2, 4, 6, 11], [3, 5, 7, 8, 9, 10, 13]]",4.0,"{'num_nodes': 16, 'num_edges': 30, 'edges': [{'u': 15, 'v': 16}, {'u': 9, 'v': 12}, {'u': 9, 'v': 16}, {'u': 12, 'v': 3}, {'u': 12, 'v': 5}, {'u': 12, 'v': 7}, {'u': 12, 'v': 8}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 3, 'v': 2}, {'u': 3, 'v': 4}, {'u': 3, 'v': 14}, {'u': 3, 'v': 16}, {'u': 2, 'v': 5}, {'u': 2, 'v': 14}, {'u': 2, 'v': 16}, {'u': 8, 'v': 16}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 11}, {'u': 14, 'v': 4}, {'u': 14, 'v': 5}, {'u': 14, 'v': 16}, {'u': 5, 'v': 16}, {'u': 7, 'v': 6}, {'u': 7, 'v': 11}, {'u': 7, 'v': 16}, {'u': 10, 'v': 4}, {'u': 10, 'v': 16}, {'u': 16, 'v': 13}]}","[[1, 12, 14, 15], [16], [2, 4, 6, 11], [3, 5, 7, 8, 9, 10, 13]]",33,markdown_table,1
GCP,GCP,"There’s a little puzzle backstage: every musician’s mark needs a spotlight gel and any two neighboring marks must look different under the lights. The task is to pick one gel for each mark so that adjacent areas never share the same gel, and a neat solution is one that reuses the same few gel colors everywhere. To see how good a setup is, just count the distinct gel colors in use — fewer distinct colors means a nicer solution. Every spot gets exactly one gel and none of the adjacent spots can match. The exact map of positions is shown below.

The map shows 15 positions and 34 adjacency pairs:
Position 10 is adjacent to position 0; those two marks must use different gels.
Position 10 is adjacent to position 2; those two marks must use different gels.
Position 10 is adjacent to position 5; those two marks must use different gels.
Position 10 is adjacent to position 6; those two marks must use different gels.
Position 10 is adjacent to position 9; those two marks must use different gels.
Position 14 is adjacent to position 0; those two marks must use different gels.
Position 14 is adjacent to position 1; those two marks must use different gels.
Position 14 is adjacent to position 5; those two marks must use different gels.
Position 14 is adjacent to position 9; those two marks must use different gels.
Position 14 is adjacent to position 13; those two marks must use different gels.
Position 9 is adjacent to position 0; those two marks must use different gels.
Position 9 is adjacent to position 5; those two marks must use different gels.
Position 4 is adjacent to position 0; those two marks must use different gels.
Position 4 is adjacent to position 1; those two marks must use different gels.
Position 4 is adjacent to position 3; those two marks must use different gels.
Position 0 is adjacent to position 2; those two marks must use different gels.
Position 0 is adjacent to position 3; those two marks must use different gels.
Position 0 is adjacent to position 5; those two marks must use different gels.
Position 0 is adjacent to position 6; those two marks must use different gels.
Position 0 is adjacent to position 7; those two marks must use different gels.
Position 0 is adjacent to position 8; those two marks must use different gels.
Position 0 is adjacent to position 11; those two marks must use different gels.
Position 0 is adjacent to position 12; those two marks must use different gels.
Position 0 is adjacent to position 13; those two marks must use different gels.
Position 8 is adjacent to position 1; those two marks must use different gels.
Position 7 is adjacent to position 5; those two marks must use different gels.
Position 7 is adjacent to position 13; those two marks must use different gels.
Position 6 is adjacent to position 5; those two marks must use different gels.
Position 1 is adjacent to position 12; those two marks must use different gels.
Position 13 is adjacent to position 2; those two marks must use different gels.
Position 13 is adjacent to position 5; those two marks must use different gels.
Position 13 is adjacent to position 11; those two marks must use different gels.
Position 5 is adjacent to position 2; those two marks must use different gels.
Position 5 is adjacent to position 3; those two marks must use different gels.
Fewer distinct gels across the 15 spots makes for a tidier lighting plan.

If you want to hand me the coloring in a tidy, machine-friendly way, just follow this little JSON shape:

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

Each inner array is one gel color: list the mark IDs that get that same gel. The first array is all the marks using the first gel, the second array the marks using the second gel, and so on. Think of it as just a simple form to fill out — this sketch shows the shape I expect, not the final coloring 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”. ""","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 34, 'edges': [{'u': 11, 'v': 1}, {'u': 11, 'v': 3}, {'u': 11, 'v': 6}, {'u': 11, 'v': 7}, {'u': 11, 'v': 10}, {'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 6}, {'u': 15, 'v': 10}, {'u': 15, 'v': 14}, {'u': 10, 'v': 1}, {'u': 10, 'v': 6}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 4}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 12}, {'u': 1, 'v': 13}, {'u': 1, 'v': 14}, {'u': 9, 'v': 2}, {'u': 8, 'v': 6}, {'u': 8, 'v': 14}, {'u': 7, 'v': 6}, {'u': 2, 'v': 13}, {'u': 14, 'v': 3}, {'u': 14, 'v': 6}, {'u': 14, 'v': 12}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}], 'source_file': 'citationCiteseer.mtx', 'density': 0.3238095238095238, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0033.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0033.png', 'edge_connectivity': 2}","[[4, 8, 11, 15], [1, 2], [3], [6, 9, 12, 13], [5, 7, 10, 14]]",5.0,"{'num_nodes': 15, 'num_edges': 34, 'edges': [{'u': 10, 'v': 0}, {'u': 10, 'v': 2}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 9}, {'u': 14, 'v': 0}, {'u': 14, 'v': 1}, {'u': 14, 'v': 5}, {'u': 14, 'v': 9}, {'u': 14, 'v': 13}, {'u': 9, 'v': 0}, {'u': 9, 'v': 5}, {'u': 4, 'v': 0}, {'u': 4, 'v': 1}, {'u': 4, 'v': 3}, {'u': 0, 'v': 2}, {'u': 0, 'v': 3}, {'u': 0, 'v': 5}, {'u': 0, 'v': 6}, {'u': 0, 'v': 7}, {'u': 0, 'v': 8}, {'u': 0, 'v': 11}, {'u': 0, 'v': 12}, {'u': 0, 'v': 13}, {'u': 8, 'v': 1}, {'u': 7, 'v': 5}, {'u': 7, 'v': 13}, {'u': 6, 'v': 5}, {'u': 1, 'v': 12}, {'u': 13, 'v': 2}, {'u': 13, 'v': 5}, {'u': 13, 'v': 11}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}]}","[[3, 7, 10, 14], [0, 1], [2], [5, 8, 11, 12], [4, 6, 9, 13]]",34,nl,0
GCP,GCP,"Recently the maintenance crew had to pick backgrounds for a set of signs, and the only tricky bit was avoiding identical backgrounds for signs a driver can see together from one approach. The task is to give every sign a background color, never using the same one on two signs that are visible simultaneously. A smarter pick uses as few different colors as possible — the score is simply the count of distinct backgrounds used. The full sign arrangement is shown below.

{
  ""total_signs"": 15,
  ""total_visibility_conflicts"": 49,
  ""edges"": [
    {
      ""sign_a_id"": 6,
      ""sign_b_id"": 1
    },
    {
      ""sign_a_id"": 6,
      ""sign_b_id"": 4
    },
    {
      ""sign_a_id"": 6,
      ""sign_b_id"": 5
    },
    {
      ""sign_a_id"": 6,
      ""sign_b_id"": 14
    },
    {
      ""sign_a_id"": 6,
      ""sign_b_id"": 15
    },
    {
      ""sign_a_id"": 13,
      ""sign_b_id"": 8
    },
    {
      ""sign_a_id"": 13,
      ""sign_b_id"": 12
    },
    {
      ""sign_a_id"": 13,
      ""sign_b_id"": 14
    },
    {
      ""sign_a_id"": 13,
      ""sign_b_id"": 15
    },
    {
      ""sign_a_id"": 12,
      ""sign_b_id"": 8
    },
    {
      ""sign_a_id"": 12,
      ""sign_b_id"": 14
    },
    {
      ""sign_a_id"": 12,
      ""sign_b_id"": 15
    },
    {
      ""sign_a_id"": 3,
      ""sign_b_id"": 2
    },
    {
      ""sign_a_id"": 3,
      ""sign_b_id"": 9
    },
    {
      ""sign_a_id"": 3,
      ""sign_b_id"": 10
    },
    {
      ""sign_a_id"": 3,
      ""sign_b_id"": 11
    },
    {
      ""sign_a_id"": 3,
      ""sign_b_id"": 14
    },
    {
      ""sign_a_id"": 3,
      ""sign_b_id"": 15
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 1
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 2
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 4
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 5
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 9
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 10
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 11
    },
    {
      ""sign_a_id"": 14,
      ""sign_b_id"": 15
    },
    {
      ""sign_a_id"": 15,
      ""sign_b_id"": 1
    },
    {
      ""sign_a_id"": 15,
      ""sign_b_id"": 2
    },
    {
      ""sign_a_id"": 15,
      ""sign_b_id"": 4
    },
    {
      ""sign_a_id"": 15,
      ""sign_b_id"": 5
    },
    {
      ""sign_a_id"": 15,
      ""sign_b_id"": 9
    },
    {
      ""sign_a_id"": 15,
      ""sign_b_id"": 10
    },
    {
      ""sign_a_id"": 15,
      ""sign_b_id"": 11
    },
    {
      ""sign_a_id"": 9,
      ""sign_b_id"": 2
    },
    {
      ""sign_a_id"": 9,
      ""sign_b_id"": 7
    },
    {
      ""sign_a_id"": 9,
      ""sign_b_id"": 8
    },
    {
      ""sign_a_id"": 9,
      ""sign_b_id"": 10
    },
    {
      ""sign_a_id"": 9,
      ""sign_b_id"": 11
    },
    {
      ""sign_a_id"": 10,
      ""sign_b_id"": 2
    },
    {
      ""sign_a_id"": 10,
      ""sign_b_id"": 7
    },
    {
      ""sign_a_id"": 10,
      ""sign_b_id"": 8
    },
    {
      ""sign_a_id"": 10,
      ""sign_b_id"": 11
    },
    {
      ""sign_a_id"": 11,
      ""sign_b_id"": 2
    },
    {
      ""sign_a_id"": 11,
      ""sign_b_id"": 7
    },
    {
      ""sign_a_id"": 11,
      ""sign_b_id"": 8
    },
    {
      ""sign_a_id"": 8,
      ""sign_b_id"": 7
    },
    {
      ""sign_a_id"": 5,
      ""sign_b_id"": 1
    },
    {
      ""sign_a_id"": 5,
      ""sign_b_id"": 4
    },
    {
      ""sign_a_id"": 1,
      ""sign_b_id"": 4
    }
  ]
}

If you want to hand me the answer in a machine-friendly way, a compact JSON sketch like the one below is perfect — just a list of groups, where each inner list holds the signs that share the same background.

{
  ""solution"": [
    [""sign_id"", ""sign_id""],
    [""sign_id"", ""sign_id""],
    [""sign_id""]
  ]
}

Pretty simple: ""solution"" is a list of background groups, and each inner list is the set of sign identifiers that get the same background color. Think of each inner list as one background choice and the strings inside as the sign labels you'd put on a form. This is just the shape I need, not the actual final assignment.

Please be sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 49, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 14}, {'u': 6, 'v': 15}, {'u': 13, 'v': 8}, {'u': 13, 'v': 12}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 12, 'v': 8}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 3, 'v': 2}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 14}, {'u': 3, 'v': 15}, {'u': 14, 'v': 1}, {'u': 14, 'v': 2}, {'u': 14, 'v': 4}, {'u': 14, 'v': 5}, {'u': 14, 'v': 9}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 14, 'v': 15}, {'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 4}, {'u': 15, 'v': 5}, {'u': 15, 'v': 9}, {'u': 15, 'v': 10}, {'u': 15, 'v': 11}, {'u': 9, 'v': 2}, {'u': 9, 'v': 7}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 10, 'v': 2}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 11, 'v': 2}, {'u': 11, 'v': 7}, {'u': 11, 'v': 8}, {'u': 8, 'v': 7}, {'u': 5, 'v': 1}, {'u': 5, 'v': 4}, {'u': 1, 'v': 4}], 'source_file': 'coPapersCiteseer.mtx', 'density': 0.4666666666666667, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0034.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0034.png', 'edge_connectivity': 4}","[[7, 14], [1, 2, 8], [15], [5, 9], [6, 11], [10, 13], [3, 4, 12]]",7.0,"{'num_nodes': 15, 'num_edges': 49, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 14}, {'u': 6, 'v': 15}, {'u': 13, 'v': 8}, {'u': 13, 'v': 12}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 12, 'v': 8}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 3, 'v': 2}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 14}, {'u': 3, 'v': 15}, {'u': 14, 'v': 1}, {'u': 14, 'v': 2}, {'u': 14, 'v': 4}, {'u': 14, 'v': 5}, {'u': 14, 'v': 9}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 14, 'v': 15}, {'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 4}, {'u': 15, 'v': 5}, {'u': 15, 'v': 9}, {'u': 15, 'v': 10}, {'u': 15, 'v': 11}, {'u': 9, 'v': 2}, {'u': 9, 'v': 7}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 10, 'v': 2}, {'u': 10, 'v': 7}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 11, 'v': 2}, {'u': 11, 'v': 7}, {'u': 11, 'v': 8}, {'u': 8, 'v': 7}, {'u': 5, 'v': 1}, {'u': 5, 'v': 4}, {'u': 1, 'v': 4}]}","[[7, 14], [1, 2, 8], [15], [5, 9], [6, 11], [10, 13], [3, 4, 12]]",35,json,1
GCP,GCP,"Many people who manage multiple tanks end up labeling each aquarium so filter-linked tanks are easy to tell apart; here the task is to choose one stripe per tank and avoid matching stripes on tanks that share a filtration connection. A better labeling uses fewer overall stripe colors — just count how many different stripe colors appear and smaller counts are preferable. It’s required that every tank gets exactly one stripe and no two connected tanks have the same stripe, with nothing omitted or duplicated on a single tank. The full layout and connection list are shown below.

There are 17 tanks in total and 49 filtration connections.

| tank_u_id | tank_v_id |
|---|---|
| 3 | 14 |
| 3 | 16 |
| 10 | 1 |
| 10 | 5 |
| 10 | 6 |
| 10 | 8 |
| 10 | 9 |
| 10 | 13 |
| 10 | 15 |
| 10 | 17 |
| 4 | 1 |
| 4 | 5 |
| 4 | 9 |
| 4 | 13 |
| 2 | 1 |
| 2 | 6 |
| 2 | 8 |
| 2 | 14 |
| 2 | 16 |
| 2 | 17 |
| 6 | 8 |
| 6 | 9 |
| 6 | 17 |
| 15 | 5 |
| 15 | 8 |
| 15 | 14 |
| 15 | 16 |
| 15 | 17 |
| 14 | 5 |
| 14 | 7 |
| 14 | 9 |
| 14 | 11 |
| 14 | 12 |
| 14 | 13 |
| 14 | 17 |
| 11 | 7 |
| 11 | 16 |
| 5 | 9 |
| 5 | 16 |
| 12 | 7 |
| 9 | 1 |
| 9 | 8 |
| 9 | 13 |
| 9 | 16 |
| 1 | 13 |
| 1 | 17 |
| 13 | 16 |
| 7 | 16 |
| 16 | 17 |

Also, when you give the stripe grouping, please use this simple JSON layout — just a list of stripe groups, nothing fancy:

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

Each inner list is a single stripe color (so all the tanks in that list share one stripe), the first list would be stripe color 1, the second stripe color 2, and so on. Think of it as putting tanks into piles by stripe — every tank should appear in exactly one pile. This JSON is only a sketch of the shape I need, not the actual assignment.

Please make sure you use the exact identifiers from the instance input — don’t rename them or invent new ones.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 49, 'edges': [{'u': 3, 'v': 14}, {'u': 3, 'v': 16}, {'u': 10, 'v': 1}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 8}, {'u': 10, 'v': 9}, {'u': 10, 'v': 13}, {'u': 10, 'v': 15}, {'u': 10, 'v': 17}, {'u': 4, 'v': 1}, {'u': 4, 'v': 5}, {'u': 4, 'v': 9}, {'u': 4, 'v': 13}, {'u': 2, 'v': 1}, {'u': 2, 'v': 6}, {'u': 2, 'v': 8}, {'u': 2, 'v': 14}, {'u': 2, 'v': 16}, {'u': 2, 'v': 17}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 17}, {'u': 15, 'v': 5}, {'u': 15, 'v': 8}, {'u': 15, 'v': 14}, {'u': 15, 'v': 16}, {'u': 15, 'v': 17}, {'u': 14, 'v': 5}, {'u': 14, 'v': 7}, {'u': 14, 'v': 9}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 14, 'v': 13}, {'u': 14, 'v': 17}, {'u': 11, 'v': 7}, {'u': 11, 'v': 16}, {'u': 5, 'v': 9}, {'u': 5, 'v': 16}, {'u': 12, 'v': 7}, {'u': 9, 'v': 1}, {'u': 9, 'v': 8}, {'u': 9, 'v': 13}, {'u': 9, 'v': 16}, {'u': 1, 'v': 13}, {'u': 1, 'v': 17}, {'u': 13, 'v': 16}, {'u': 7, 'v': 16}, {'u': 16, 'v': 17}], 'source_file': 'citationCiteseer.mtx', 'density': 0.3602941176470588, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0035.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0035.png', 'edge_connectivity': 2}","[[2, 7, 9, 15], [1, 6], [4, 10, 14, 16], [3, 5, 8, 11, 12, 13, 17]]",4.0,"{'num_nodes': 17, 'num_edges': 49, 'edges': [{'u': 3, 'v': 14}, {'u': 3, 'v': 16}, {'u': 10, 'v': 1}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 8}, {'u': 10, 'v': 9}, {'u': 10, 'v': 13}, {'u': 10, 'v': 15}, {'u': 10, 'v': 17}, {'u': 4, 'v': 1}, {'u': 4, 'v': 5}, {'u': 4, 'v': 9}, {'u': 4, 'v': 13}, {'u': 2, 'v': 1}, {'u': 2, 'v': 6}, {'u': 2, 'v': 8}, {'u': 2, 'v': 14}, {'u': 2, 'v': 16}, {'u': 2, 'v': 17}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 17}, {'u': 15, 'v': 5}, {'u': 15, 'v': 8}, {'u': 15, 'v': 14}, {'u': 15, 'v': 16}, {'u': 15, 'v': 17}, {'u': 14, 'v': 5}, {'u': 14, 'v': 7}, {'u': 14, 'v': 9}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 14, 'v': 13}, {'u': 14, 'v': 17}, {'u': 11, 'v': 7}, {'u': 11, 'v': 16}, {'u': 5, 'v': 9}, {'u': 5, 'v': 16}, {'u': 12, 'v': 7}, {'u': 9, 'v': 1}, {'u': 9, 'v': 8}, {'u': 9, 'v': 13}, {'u': 9, 'v': 16}, {'u': 1, 'v': 13}, {'u': 1, 'v': 17}, {'u': 13, 'v': 16}, {'u': 7, 'v': 16}, {'u': 16, 'v': 17}]}","[[2, 7, 9, 15], [1, 6], [4, 10, 14, 16], [3, 5, 8, 11, 12, 13, 17]]",36,markdown_table,1
GCP,GCP,"We’ve got a bunch of bookshelves lined up and someone suggested color-coding the ends of each shelf. In practice that means choosing one color label for each shelf, making sure any shelves that meet side by side don’t end up with the same color, and making sure each shelf gets one label only. The trick is to make the whole setup look tidy by using as few different label colors as possible — evaluate a setup by counting how many unique colors appear. The concrete shelf map is shown below.

There are 18 shelves and 92 touching pairs in the map below.
Shelves 7 and 4 touch side by side.
Shelves 7 and 5 touch side by side.
Shelves 7 and 6 touch side by side.
Shelves 7 and 10 touch side by side.
Shelves 7 and 11 touch side by side.
Shelves 7 and 12 touch side by side.
Shelves 7 and 13 touch side by side.
Shelves 7 and 14 touch side by side.
Shelves 7 and 15 touch side by side.
Shelves 7 and 16 touch side by side.
Shelves 7 and 17 touch side by side.
Shelves 7 and 18 touch side by side.
Shelves 12 and 1 touch side by side.
Shelves 12 and 2 touch side by side.
Shelves 12 and 3 touch side by side.
Shelves 12 and 4 touch side by side.
Shelves 12 and 8 touch side by side.
Shelves 12 and 9 touch side by side.
Shelves 12 and 10 touch side by side.
Shelves 12 and 11 touch side by side.
Shelves 12 and 13 touch side by side.
Shelves 12 and 14 touch side by side.
Shelves 12 and 15 touch side by side.
Shelves 12 and 16 touch side by side.
Shelves 12 and 17 touch side by side.
Shelves 12 and 18 touch side by side.
Shelves 4 and 5 touch side by side.
Shelves 4 and 6 touch side by side.
Shelves 4 and 10 touch side by side.
Shelves 4 and 11 touch side by side.
Shelves 4 and 13 touch side by side.
Shelves 4 and 14 touch side by side.
Shelves 4 and 15 touch side by side.
Shelves 4 and 16 touch side by side.
Shelves 4 and 17 touch side by side.
Shelves 4 and 18 touch side by side.
Shelves 13 and 5 touch side by side.
Shelves 13 and 6 touch side by side.
Shelves 13 and 10 touch side by side.
Shelves 13 and 11 touch side by side.
Shelves 13 and 14 touch side by side.
Shelves 13 and 15 touch side by side.
Shelves 13 and 16 touch side by side.
Shelves 13 and 17 touch side by side.
Shelves 13 and 18 touch side by side.
Shelves 14 and 1 touch side by side.
Shelves 14 and 2 touch side by side.
Shelves 14 and 3 touch side by side.
Shelves 14 and 10 touch side by side.
Shelves 14 and 11 touch side by side.
Shelves 14 and 15 touch side by side.
Shelves 14 and 16 touch side by side.
Shelves 14 and 17 touch side by side.
Shelves 14 and 18 touch side by side.
Shelves 9 and 8 touch side by side.
Shelves 9 and 10 touch side by side.
Shelves 9 and 11 touch side by side.
Shelves 15 and 1 touch side by side.
Shelves 15 and 2 touch side by side.
Shelves 15 and 3 touch side by side.
Shelves 15 and 10 touch side by side.
Shelves 15 and 11 touch side by side.
Shelves 15 and 16 touch side by side.
Shelves 15 and 17 touch side by side.
Shelves 15 and 18 touch side by side.
Shelves 16 and 1 touch side by side.
Shelves 16 and 2 touch side by side.
Shelves 16 and 3 touch side by side.
Shelves 16 and 10 touch side by side.
Shelves 16 and 11 touch side by side.
Shelves 16 and 17 touch side by side.
Shelves 16 and 18 touch side by side.
Shelves 17 and 5 touch side by side.
Shelves 17 and 6 touch side by side.
Shelves 17 and 10 touch side by side.
Shelves 17 and 11 touch side by side.
Shelves 17 and 18 touch side by side.
Shelves 18 and 10 touch side by side.
Shelves 18 and 11 touch side by side.
Shelves 10 and 1 touch side by side.
Shelves 10 and 2 touch side by side.
Shelves 10 and 3 touch side by side.
Shelves 10 and 8 touch side by side.
Shelves 10 and 11 touch side by side.
Shelves 11 and 1 touch side by side.
Shelves 11 and 2 touch side by side.
Shelves 11 and 3 touch side by side.
Shelves 11 and 8 touch side by side.
Shelves 5 and 6 touch side by side.
Shelves 1 and 2 touch side by side.
Shelves 1 and 3 touch side by side.
Shelves 2 and 3 touch side by side.
That's the full shelf map — let's aim to use as few different label colors as possible.

If you're going to send the coloring back, keep it in a simple JSON shape so it's easy to check. Something like this works fine:

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

Each inner list is one color group — a list of the shelf IDs that all get the same label color. The outer array is just all the color groups together. This is just a sketch of the shape I expect, not the actual coloring.

Quick reminder: use the exact identifiers from the instance input — don't rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 18, 'num_edges': 92, 'edges': [{'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 6}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 7, 'v': 14}, {'u': 7, 'v': 15}, {'u': 7, 'v': 16}, {'u': 7, 'v': 17}, {'u': 7, 'v': 18}, {'u': 12, 'v': 1}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 4}, {'u': 12, 'v': 8}, {'u': 12, 'v': 9}, {'u': 12, 'v': 10}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 12, 'v': 17}, {'u': 12, 'v': 18}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 13}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 4, 'v': 16}, {'u': 4, 'v': 17}, {'u': 4, 'v': 18}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 13, 'v': 17}, {'u': 13, 'v': 18}, {'u': 14, 'v': 1}, {'u': 14, 'v': 2}, {'u': 14, 'v': 3}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 14, 'v': 17}, {'u': 14, 'v': 18}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 3}, {'u': 15, 'v': 10}, {'u': 15, 'v': 11}, {'u': 15, 'v': 16}, {'u': 15, 'v': 17}, {'u': 15, 'v': 18}, {'u': 16, 'v': 1}, {'u': 16, 'v': 2}, {'u': 16, 'v': 3}, {'u': 16, 'v': 10}, {'u': 16, 'v': 11}, {'u': 16, 'v': 17}, {'u': 16, 'v': 18}, {'u': 17, 'v': 5}, {'u': 17, 'v': 6}, {'u': 17, 'v': 10}, {'u': 17, 'v': 11}, {'u': 17, 'v': 18}, {'u': 18, 'v': 10}, {'u': 18, 'v': 11}, {'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 11, 'v': 1}, {'u': 11, 'v': 2}, {'u': 11, 'v': 3}, {'u': 11, 'v': 8}, {'u': 5, 'v': 6}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 2, 'v': 3}], 'source_file': 'coPapersCiteseer.mtx', 'density': 0.6013071895424836, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0036.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0036.png', 'edge_connectivity': 4}","[[6, 10], [15], [1, 7], [11], [17], [2, 4], [14], [13], [8, 16], [5, 12], [3, 9, 18]]",11.0,"{'num_nodes': 18, 'num_edges': 92, 'edges': [{'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 6}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 7, 'v': 14}, {'u': 7, 'v': 15}, {'u': 7, 'v': 16}, {'u': 7, 'v': 17}, {'u': 7, 'v': 18}, {'u': 12, 'v': 1}, {'u': 12, 'v': 2}, {'u': 12, 'v': 3}, {'u': 12, 'v': 4}, {'u': 12, 'v': 8}, {'u': 12, 'v': 9}, {'u': 12, 'v': 10}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 12, 'v': 16}, {'u': 12, 'v': 17}, {'u': 12, 'v': 18}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 13}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 4, 'v': 16}, {'u': 4, 'v': 17}, {'u': 4, 'v': 18}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 13, 'v': 16}, {'u': 13, 'v': 17}, {'u': 13, 'v': 18}, {'u': 14, 'v': 1}, {'u': 14, 'v': 2}, {'u': 14, 'v': 3}, {'u': 14, 'v': 10}, {'u': 14, 'v': 11}, {'u': 14, 'v': 15}, {'u': 14, 'v': 16}, {'u': 14, 'v': 17}, {'u': 14, 'v': 18}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 15, 'v': 1}, {'u': 15, 'v': 2}, {'u': 15, 'v': 3}, {'u': 15, 'v': 10}, {'u': 15, 'v': 11}, {'u': 15, 'v': 16}, {'u': 15, 'v': 17}, {'u': 15, 'v': 18}, {'u': 16, 'v': 1}, {'u': 16, 'v': 2}, {'u': 16, 'v': 3}, {'u': 16, 'v': 10}, {'u': 16, 'v': 11}, {'u': 16, 'v': 17}, {'u': 16, 'v': 18}, {'u': 17, 'v': 5}, {'u': 17, 'v': 6}, {'u': 17, 'v': 10}, {'u': 17, 'v': 11}, {'u': 17, 'v': 18}, {'u': 18, 'v': 10}, {'u': 18, 'v': 11}, {'u': 10, 'v': 1}, {'u': 10, 'v': 2}, {'u': 10, 'v': 3}, {'u': 10, 'v': 8}, {'u': 10, 'v': 11}, {'u': 11, 'v': 1}, {'u': 11, 'v': 2}, {'u': 11, 'v': 3}, {'u': 11, 'v': 8}, {'u': 5, 'v': 6}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 2, 'v': 3}]}","[[6, 10], [15], [1, 7], [11], [17], [2, 4], [14], [13], [8, 16], [5, 12], [3, 9, 18]]",37,nl,1
GCP,GCP,"Many people face the same tricky decorating puzzle: color every room so adjoining rooms don’t end up the same. The task is to assign one paint to each room (no room skipped, and touching rooms must differ) while trying to keep the palette small. The quality of a plan is judged by how many different paints it uses — simply count the unique colors to see which plan is better. The full layout and details are provided below.

There are 15 rooms and 41 shared walls to consider:
Room 12 shares a wall with room 6, so they must be painted different colors.
Room 12 shares a wall with room 13, so they must be painted different colors.
Room 12 shares a wall with room 14, so they must be painted different colors.
Room 12 shares a wall with room 15, so they must be painted different colors.
Room 13 shares a wall with room 6, so they must be painted different colors.
Room 13 shares a wall with room 14, so they must be painted different colors.
Room 13 shares a wall with room 15, so they must be painted different colors.
Room 14 shares a wall with room 6, so they must be painted different colors.
Room 14 shares a wall with room 15, so they must be painted different colors.
Room 15 shares a wall with room 6, so they must be painted different colors.
Room 4 shares a wall with room 1, so they must be painted different colors.
Room 4 shares a wall with room 2, so they must be painted different colors.
Room 4 shares a wall with room 3, so they must be painted different colors.
Room 4 shares a wall with room 5, so they must be painted different colors.
Room 4 shares a wall with room 6, so they must be painted different colors.
Room 4 shares a wall with room 7, so they must be painted different colors.
Room 5 shares a wall with room 1, so they must be painted different colors.
Room 5 shares a wall with room 2, so they must be painted different colors.
Room 5 shares a wall with room 3, so they must be painted different colors.
Room 5 shares a wall with room 6, so they must be painted different colors.
Room 5 shares a wall with room 7, so they must be painted different colors.
Room 6 shares a wall with room 1, so they must be painted different colors.
Room 6 shares a wall with room 2, so they must be painted different colors.
Room 6 shares a wall with room 3, so they must be painted different colors.
Room 6 shares a wall with room 7, so they must be painted different colors.
Room 6 shares a wall with room 8, so they must be painted different colors.
Room 6 shares a wall with room 9, so they must be painted different colors.
Room 6 shares a wall with room 10, so they must be painted different colors.
Room 6 shares a wall with room 11, so they must be painted different colors.
Room 7 shares a wall with room 1, so they must be painted different colors.
Room 7 shares a wall with room 2, so they must be painted different colors.
Room 7 shares a wall with room 3, so they must be painted different colors.
Room 1 shares a wall with room 2, so they must be painted different colors.
Room 1 shares a wall with room 3, so they must be painted different colors.
Room 3 shares a wall with room 2, so they must be painted different colors.
Room 9 shares a wall with room 8, so they must be painted different colors.
Room 9 shares a wall with room 10, so they must be painted different colors.
Room 9 shares a wall with room 11, so they must be painted different colors.
Room 8 shares a wall with room 10, so they must be painted different colors.
Room 8 shares a wall with room 11, so they must be painted different colors.
Room 10 shares a wall with room 11, so they must be painted different colors.
Keep the palette as small as possible and count the distinct paints across the 15 rooms to judge a plan.

Oh, and one more practical thing — when you reply, please follow this simple JSON layout so it's easy to check automatically. Just stick to the shape below:

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

Think of each inner list as one paint color: it lists the rooms that get that same color (rooms in the same list must not share a wall in the actual layout). The outer array is just the collection of all those color groups. This JSON is just a sketch of the shape I need, not the final coloring — you'll fill it with the exact room identifiers from the instance.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 15, 'num_edges': 41, 'edges': [{'u': 12, 'v': 6}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 13, 'v': 6}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 14, 'v': 6}, {'u': 14, 'v': 15}, {'u': 15, 'v': 6}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 3, 'v': 2}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 10, 'v': 11}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.3904761904761905, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0037.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0037.png', 'edge_connectivity': 4}","[[7, 10, 13], [6], [2, 8], [1, 9, 14], [3, 11, 15], [4], [5, 12]]",7.0,"{'num_nodes': 15, 'num_edges': 41, 'edges': [{'u': 12, 'v': 6}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 15}, {'u': 13, 'v': 6}, {'u': 13, 'v': 14}, {'u': 13, 'v': 15}, {'u': 14, 'v': 6}, {'u': 14, 'v': 15}, {'u': 15, 'v': 6}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 7}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 3, 'v': 2}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 10, 'v': 11}]}","[[7, 10, 13], [6], [2, 8], [1, 9, 14], [3, 11, 15], [4], [5, 12]]",38,nl,1
GCP,GCP,"There’s a small neighborhood of wireless hotspots and the job is to label each hotspot’s channel so neighbors with overlapping ranges don’t share the same label. That means deciding a channel for every hotspot (no hotspot left unlabeled and no hotspot with more than one label) and making sure overlapping pairs are on different channels. The better setups are the ones that get by with the smallest set of different channel names — tally the distinct labels to compare. The exact instance is shown below.

# total_hotspots=14
# overlap_pair_count=26
hotspot_a_id,hotspot_b_id
B,A
B,C
B,D
A,C
A,D
A,E
A,F
A,G
A,H
A,I
A,J
A,K
A,L
A,M
A,N
E,H
C,D
C,K
D,K
G,H
G,I
G,J
H,I
H,J
I,J
L,M

Also, when you send the answer, please follow this simple JSON shape so it's easy to check automatically:

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

Each inner list is a group of hotspots that share the same channel (so each group is one channel), and the outer list is just the collection of those channels. Think of it like filling out a form: each row is a channel and you list the hotspot identifiers assigned to it. This JSON is just the expected shape — a sketch, not the actual labeling.

Please use the exact identifiers from the instance input — do not rename them or invent new ones. To be clear, valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 26, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 7}, {'u': 1, 'v': 8}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 1, 'v': 13}, {'u': 1, 'v': 14}, {'u': 5, 'v': 8}, {'u': 3, 'v': 4}, {'u': 3, 'v': 11}, {'u': 4, 'v': 11}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 9, 'v': 10}, {'u': 12, 'v': 13}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.2857142857142857, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0038.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0038.png', 'edge_connectivity': 1}","[[2, 6, 8, 11, 13, 14], [7, 12], [1], [4, 9], [3, 5, 10]]",5.0,"{'num_nodes': 14, 'num_edges': 26, 'edges': [{'u': 'B', 'v': 'A'}, {'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'D'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'D'}, {'u': 'A', 'v': 'E'}, {'u': 'A', 'v': 'F'}, {'u': 'A', 'v': 'G'}, {'u': 'A', 'v': 'H'}, {'u': 'A', 'v': 'I'}, {'u': 'A', 'v': 'J'}, {'u': 'A', 'v': 'K'}, {'u': 'A', 'v': 'L'}, {'u': 'A', 'v': 'M'}, {'u': 'A', 'v': 'N'}, {'u': 'E', 'v': 'H'}, {'u': 'C', 'v': 'D'}, {'u': 'C', 'v': 'K'}, {'u': 'D', 'v': 'K'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'I'}, {'u': 'G', 'v': 'J'}, {'u': 'H', 'v': 'I'}, {'u': 'H', 'v': 'J'}, {'u': 'I', 'v': 'J'}, {'u': 'L', 'v': 'M'}]}","[['B', 'F', 'H', 'K', 'M', 'N'], ['G', 'L'], ['A'], ['D', 'I'], ['C', 'E', 'J']]",39,csv,names
GCP,GCP,"In a tiny secondhand bookstore the owner wanted each shelf cubby labeled with a colored dot, but insisted that any cubbies that touch can’t wear the same color. The winning layouts are those that make do with the smallest number of distinct colors — you can check by listing all the colors that appear and counting them, with a lower count being better. Every cubby must have one tag and adjacent cubbies must differ; the specific arrangement is shown below.

{
  ""total_cubbies"": 14,
  ""touching_pairs"": 36,
  ""edges"": [
    {
      ""cubby_u"": 9,
      ""cubby_v"": 5
    },
    {
      ""cubby_u"": 9,
      ""cubby_v"": 6
    },
    {
      ""cubby_u"": 9,
      ""cubby_v"": 10
    },
    {
      ""cubby_u"": 10,
      ""cubby_v"": 5
    },
    {
      ""cubby_u"": 10,
      ""cubby_v"": 6
    },
    {
      ""cubby_u"": 10,
      ""cubby_v"": 13
    },
    {
      ""cubby_u"": 6,
      ""cubby_v"": 2
    },
    {
      ""cubby_u"": 6,
      ""cubby_v"": 4
    },
    {
      ""cubby_u"": 6,
      ""cubby_v"": 5
    },
    {
      ""cubby_u"": 6,
      ""cubby_v"": 7
    },
    {
      ""cubby_u"": 6,
      ""cubby_v"": 8
    },
    {
      ""cubby_u"": 5,
      ""cubby_v"": 2
    },
    {
      ""cubby_u"": 5,
      ""cubby_v"": 4
    },
    {
      ""cubby_u"": 5,
      ""cubby_v"": 7
    },
    {
      ""cubby_u"": 5,
      ""cubby_v"": 8
    },
    {
      ""cubby_u"": 5,
      ""cubby_v"": 13
    },
    {
      ""cubby_u"": 8,
      ""cubby_v"": 1
    },
    {
      ""cubby_u"": 8,
      ""cubby_v"": 2
    },
    {
      ""cubby_u"": 8,
      ""cubby_v"": 3
    },
    {
      ""cubby_u"": 8,
      ""cubby_v"": 4
    },
    {
      ""cubby_u"": 8,
      ""cubby_v"": 7
    },
    {
      ""cubby_u"": 8,
      ""cubby_v"": 11
    },
    {
      ""cubby_u"": 8,
      ""cubby_v"": 14
    },
    {
      ""cubby_u"": 7,
      ""cubby_v"": 2
    },
    {
      ""cubby_u"": 7,
      ""cubby_v"": 4
    },
    {
      ""cubby_u"": 7,
      ""cubby_v"": 11
    },
    {
      ""cubby_u"": 7,
      ""cubby_v"": 12
    },
    {
      ""cubby_u"": 7,
      ""cubby_v"": 14
    },
    {
      ""cubby_u"": 4,
      ""cubby_v"": 2
    },
    {
      ""cubby_u"": 3,
      ""cubby_v"": 1
    },
    {
      ""cubby_u"": 3,
      ""cubby_v"": 2
    },
    {
      ""cubby_u"": 3,
      ""cubby_v"": 11
    },
    {
      ""cubby_u"": 1,
      ""cubby_v"": 11
    },
    {
      ""cubby_u"": 14,
      ""cubby_v"": 2
    },
    {
      ""cubby_u"": 14,
      ""cubby_v"": 11
    },
    {
      ""cubby_u"": 11,
      ""cubby_v"": 2
    }
  ]
}

If you want to hand the answer back in a tidy way, just follow this little JSON shape — it's the form I expect to see.

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

Think of ""solution"" as a list of color groups: each inner list is the set of cubby IDs that get the same colored dot. It's just a sketch of the shape I need, not the actual assignment.

Please be sure to use the exact identifiers from the instance input — don't rename or invent labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 36, 'edges': [{'u': 9, 'v': 5}, {'u': 9, 'v': 6}, {'u': 9, 'v': 10}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 13}, {'u': 6, 'v': 2}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 5, 'v': 2}, {'u': 5, 'v': 4}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 5, 'v': 13}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 7}, {'u': 8, 'v': 11}, {'u': 8, 'v': 14}, {'u': 7, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 14}, {'u': 4, 'v': 2}, {'u': 3, 'v': 1}, {'u': 3, 'v': 2}, {'u': 3, 'v': 11}, {'u': 1, 'v': 11}, {'u': 14, 'v': 2}, {'u': 14, 'v': 11}, {'u': 11, 'v': 2}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.3956043956043956, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0039.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0039.png', 'edge_connectivity': 1}","[[3, 4, 10, 14], [8], [1, 7, 13], [6, 11], [5], [2, 9, 12]]",6.0,"{'num_nodes': 14, 'num_edges': 36, 'edges': [{'u': 9, 'v': 5}, {'u': 9, 'v': 6}, {'u': 9, 'v': 10}, {'u': 10, 'v': 5}, {'u': 10, 'v': 6}, {'u': 10, 'v': 13}, {'u': 6, 'v': 2}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 5, 'v': 2}, {'u': 5, 'v': 4}, {'u': 5, 'v': 7}, {'u': 5, 'v': 8}, {'u': 5, 'v': 13}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 7}, {'u': 8, 'v': 11}, {'u': 8, 'v': 14}, {'u': 7, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 14}, {'u': 4, 'v': 2}, {'u': 3, 'v': 1}, {'u': 3, 'v': 2}, {'u': 3, 'v': 11}, {'u': 1, 'v': 11}, {'u': 14, 'v': 2}, {'u': 14, 'v': 11}, {'u': 11, 'v': 2}]}","[[3, 4, 10, 14], [8], [1, 7, 13], [6, 11], [5], [2, 9, 12]]",40,json,1
GCP,GCP,"Many people on the block want a tidy look, so the plan is to pick one color for each façade, making sure neighbors that touch don’t share a color. The task is to assign a single color to every building (no skips, no doubles) while keeping the number of different paints as low as possible — check by counting unique colors used. The specific building list and layout will be shown below.

There are 14 buildings and 23 touching pairs listed below.
Building 13 touches building 0, so they must not share the same color.
Building 13 touches building 1, so they must not share the same color.
Building 13 touches building 2, so they must not share the same color.
Building 13 touches building 6, so they must not share the same color.
Building 13 touches building 9, so they must not share the same color.
Building 12 touches building 0, so they must not share the same color.
Building 12 touches building 6, so they must not share the same color.
Building 12 touches building 9, so they must not share the same color.
Building 12 touches building 11, so they must not share the same color.
Building 6 touches building 3, so they must not share the same color.
Building 6 touches building 4, so they must not share the same color.
Building 6 touches building 7, so they must not share the same color.
Building 6 touches building 8, so they must not share the same color.
Building 6 touches building 9, so they must not share the same color.
Building 5 touches building 2, so they must not share the same color.
Building 5 touches building 3, so they must not share the same color.
Building 5 touches building 7, so they must not share the same color.
Building 9 touches building 8, so they must not share the same color.
Building 4 touches building 7, so they must not share the same color.
Building 4 touches building 10, so they must not share the same color.
Building 3 touches building 7, so they must not share the same color.
Building 3 touches building 8, so they must not share the same color.
Building 10 touches building 8, so they must not share the same color.
The palette should be as small as possible across all 14 façades.

Just so we're on the same page, please return the colouring as a simple JSON list of groups — each inner list is the buildings that share the same paint (i.e., the same color). Here’s the shape I expect:

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

Each inner array is one color group (all those building IDs get the same color). The top-level ""solution"" array just holds all the color groups together. This is only a sketch of the expected shape, not the actual colouring — fill it in with the real building identifiers from the instance.

Please use the exact identifiers from the instance input with no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 23, 'edges': [{'u': 14, 'v': 1}, {'u': 14, 'v': 2}, {'u': 14, 'v': 3}, {'u': 14, 'v': 7}, {'u': 14, 'v': 10}, {'u': 13, 'v': 1}, {'u': 13, 'v': 7}, {'u': 13, 'v': 10}, {'u': 13, 'v': 12}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 6, 'v': 8}, {'u': 10, 'v': 9}, {'u': 5, 'v': 8}, {'u': 5, 'v': 11}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 11, 'v': 9}], 'source_file': 'citationCiteseer.mtx', 'density': 0.25274725274725274, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0040.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0040.png', 'edge_connectivity': 1}","[[8, 9, 13, 14], [6, 7, 11], [1, 2, 3, 4, 5, 10, 12]]",3.0,"{'num_nodes': 14, 'num_edges': 23, 'edges': [{'u': 13, 'v': 0}, {'u': 13, 'v': 1}, {'u': 13, 'v': 2}, {'u': 13, 'v': 6}, {'u': 13, 'v': 9}, {'u': 12, 'v': 0}, {'u': 12, 'v': 6}, {'u': 12, 'v': 9}, {'u': 12, 'v': 11}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 9}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 7}, {'u': 9, 'v': 8}, {'u': 4, 'v': 7}, {'u': 4, 'v': 10}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 10, 'v': 8}]}","[[7, 8, 12, 13], [5, 6, 10], [0, 1, 2, 3, 4, 9, 11]]",41,nl,0
GCP,GCP,"I was helping organize the community garden and the job turned out to be picking colored name-plates for every raised bed so that next to each other there aren’t two beds with the same color sign. Every bed gets one sign, and beds that touch have to wear different colors, and the whole idea is to do that while using as few different sign colors as possible — the “score” is just how many unique colors end up on the beds, fewer is better. The exact layout and which beds are next to which are shown below.

Below I show the 14 beds and the 24 adjacent pairs.
Bed L touches bed C, so I require different sign colors for them.
Bed L touches bed K, so I require different sign colors for them.
Bed M touches bed A, so I require different sign colors for them.
Bed M touches bed C, so I require different sign colors for them.
Bed M touches bed N, so I require different sign colors for them.
Bed A touches bed C, so I require different sign colors for them.
Bed A touches bed N, so I require different sign colors for them.
Bed N touches bed C, so I require different sign colors for them.
Bed J touches bed C, so I require different sign colors for them.
Bed C touches bed B, so I require different sign colors for them.
Bed C touches bed D, so I require different sign colors for them.
Bed C touches bed E, so I require different sign colors for them.
Bed C touches bed F, so I require different sign colors for them.
Bed C touches bed G, so I require different sign colors for them.
Bed C touches bed H, so I require different sign colors for them.
Bed C touches bed I, so I require different sign colors for them.
Bed C touches bed K, so I require different sign colors for them.
Bed G touches bed H, so I require different sign colors for them.
Bed B touches bed D, so I require different sign colors for them.
Bed B touches bed E, so I require different sign colors for them.
Bed B touches bed F, so I require different sign colors for them.
Bed D touches bed E, so I require different sign colors for them.
Bed D touches bed F, so I require different sign colors for them.
Bed E touches bed F, so I require different sign colors for them.
That's the complete list of touching bed pairs.

Oh, and I'll put the result in a tiny JSON sketch like this so it's easy to read and check:

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

Each inner list is the set of beds that get the same sign color — the first list would be color 1, the next list color 2, and so on. It's just a template showing the shape I'll use, not the actual assignment.

Please make sure I use the exact bed 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”
- a capital letter followed by digits like “A1” or “X7”","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 24, 'edges': [{'u': 12, 'v': 3}, {'u': 12, 'v': 11}, {'u': 13, 'v': 1}, {'u': 13, 'v': 3}, {'u': 13, 'v': 14}, {'u': 1, 'v': 3}, {'u': 1, 'v': 14}, {'u': 14, 'v': 3}, {'u': 10, 'v': 3}, {'u': 3, 'v': 2}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 9}, {'u': 3, 'v': 11}, {'u': 7, 'v': 8}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 5, 'v': 6}], 'source_file': 'coAuthorsCiteseer.mtx', 'density': 0.26373626373626374, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0041.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0041.png', 'edge_connectivity': 1}","[[6, 8, 9, 10, 12, 13], [1, 4, 7, 11], [2], [5, 14], [3]]",5.0,"{'num_nodes': 14, 'num_edges': 24, 'edges': [{'u': 'L', 'v': 'C'}, {'u': 'L', 'v': 'K'}, {'u': 'M', 'v': 'A'}, {'u': 'M', 'v': 'C'}, {'u': 'M', 'v': 'N'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'N'}, {'u': 'N', 'v': 'C'}, {'u': 'J', 'v': 'C'}, {'u': 'C', 'v': 'B'}, {'u': 'C', 'v': 'D'}, {'u': 'C', 'v': 'E'}, {'u': 'C', 'v': 'F'}, {'u': 'C', 'v': 'G'}, {'u': 'C', 'v': 'H'}, {'u': 'C', 'v': 'I'}, {'u': 'C', 'v': 'K'}, {'u': 'G', 'v': 'H'}, {'u': 'B', 'v': 'D'}, {'u': 'B', 'v': 'E'}, {'u': 'B', 'v': 'F'}, {'u': 'D', 'v': 'E'}, {'u': 'D', 'v': 'F'}, {'u': 'E', 'v': 'F'}]}","[['F', 'H', 'I', 'J', 'L', 'M'], ['A', 'D', 'G', 'K'], ['B'], ['E', 'N'], ['C']]",42,nl,names
GCP,GCP,"We put together a line-up of photo booths and needed to choose a backdrop for each one: adjacent booths must have different backdrops, every booth must get one, and a better plan is simply the one that uses fewer different backdrop tones across the whole area. To see which plan is better, just count how many unique backdrop colors were used — lower is better — while never letting two booths that share a side match. The concrete booth map and details follow below.

{
  ""total_booths"": 16,
  ""side_by_side_pairs"": 30,
  ""edges"": [
    {
      ""booth_endpoint_a"": ""M"",
      ""booth_endpoint_b"": ""A""
    },
    {
      ""booth_endpoint_a"": ""M"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""M"",
      ""booth_endpoint_b"": ""F""
    },
    {
      ""booth_endpoint_a"": ""M"",
      ""booth_endpoint_b"": ""N""
    },
    {
      ""booth_endpoint_a"": ""N"",
      ""booth_endpoint_b"": ""A""
    },
    {
      ""booth_endpoint_a"": ""N"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""N"",
      ""booth_endpoint_b"": ""F""
    },
    {
      ""booth_endpoint_a"": ""O"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""O"",
      ""booth_endpoint_b"": ""K""
    },
    {
      ""booth_endpoint_a"": ""P"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""P"",
      ""booth_endpoint_b"": ""L""
    },
    {
      ""booth_endpoint_a"": ""A"",
      ""booth_endpoint_b"": ""C""
    },
    {
      ""booth_endpoint_a"": ""A"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""A"",
      ""booth_endpoint_b"": ""F""
    },
    {
      ""booth_endpoint_a"": ""G"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""G"",
      ""booth_endpoint_b"": ""H""
    },
    {
      ""booth_endpoint_a"": ""G"",
      ""booth_endpoint_b"": ""I""
    },
    {
      ""booth_endpoint_a"": ""F"",
      ""booth_endpoint_b"": ""C""
    },
    {
      ""booth_endpoint_a"": ""F"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""F"",
      ""booth_endpoint_b"": ""J""
    },
    {
      ""booth_endpoint_a"": ""H"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""H"",
      ""booth_endpoint_b"": ""I""
    },
    {
      ""booth_endpoint_a"": ""I"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""B"",
      ""booth_endpoint_b"": ""E""
    },
    {
      ""booth_endpoint_a"": ""E"",
      ""booth_endpoint_b"": ""C""
    },
    {
      ""booth_endpoint_a"": ""E"",
      ""booth_endpoint_b"": ""D""
    },
    {
      ""booth_endpoint_a"": ""E"",
      ""booth_endpoint_b"": ""J""
    },
    {
      ""booth_endpoint_a"": ""E"",
      ""booth_endpoint_b"": ""K""
    },
    {
      ""booth_endpoint_a"": ""E"",
      ""booth_endpoint_b"": ""L""
    },
    {
      ""booth_endpoint_a"": ""J"",
      ""booth_endpoint_b"": ""D""
    }
  ]
}

If you want to hand in a plan, keep it in this simple JSON shape so it's easy to read and check:

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

Think of each inner list as one backdrop tone: list the booths that share that tone together, and each list is another tone. It's just a sketch of the shape I expect—don't treat these placeholder names as the real booths.

Please use the exact identifiers from the instance input when you fill this in — no renaming, no made-up labels, and keep capitalization exactly the same.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 30, 'edges': [{'u': 13, 'v': 1}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 14}, {'u': 14, 'v': 1}, {'u': 14, 'v': 5}, {'u': 14, 'v': 6}, {'u': 15, 'v': 5}, {'u': 15, 'v': 11}, {'u': 16, 'v': 5}, {'u': 16, 'v': 12}, {'u': 1, 'v': 3}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 7, 'v': 5}, {'u': 7, 'v': 8}, {'u': 7, 'v': 9}, {'u': 6, 'v': 3}, {'u': 6, 'v': 5}, {'u': 6, 'v': 10}, {'u': 8, 'v': 5}, {'u': 8, 'v': 9}, {'u': 9, 'v': 5}, {'u': 2, 'v': 5}, {'u': 5, 'v': 3}, {'u': 5, 'v': 4}, {'u': 5, 'v': 10}, {'u': 5, 'v': 11}, {'u': 5, 'v': 12}, {'u': 10, 'v': 4}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.25, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0042.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0042.png', 'edge_connectivity': 1}","[[2, 3, 9, 10, 11, 13, 16], [6], [1, 4, 8, 12, 15], [7, 14], [5]]",5.0,"{'num_nodes': 16, 'num_edges': 30, 'edges': [{'u': 'M', 'v': 'A'}, {'u': 'M', 'v': 'E'}, {'u': 'M', 'v': 'F'}, {'u': 'M', 'v': 'N'}, {'u': 'N', 'v': 'A'}, {'u': 'N', 'v': 'E'}, {'u': 'N', 'v': 'F'}, {'u': 'O', 'v': 'E'}, {'u': 'O', 'v': 'K'}, {'u': 'P', 'v': 'E'}, {'u': 'P', 'v': 'L'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'E'}, {'u': 'A', 'v': 'F'}, {'u': 'G', 'v': 'E'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'I'}, {'u': 'F', 'v': 'C'}, {'u': 'F', 'v': 'E'}, {'u': 'F', 'v': 'J'}, {'u': 'H', 'v': 'E'}, {'u': 'H', 'v': 'I'}, {'u': 'I', 'v': 'E'}, {'u': 'B', 'v': 'E'}, {'u': 'E', 'v': 'C'}, {'u': 'E', 'v': 'D'}, {'u': 'E', 'v': 'J'}, {'u': 'E', 'v': 'K'}, {'u': 'E', 'v': 'L'}, {'u': 'J', 'v': 'D'}]}","[['B', 'C', 'I', 'J', 'K', 'M', 'P'], ['F'], ['A', 'D', 'H', 'L', 'O'], ['G', 'N'], ['E']]",43,json,names
GCP,GCP,"We’ve got a cluster of connected exhibit rooms and the brief is simple: assign one accent color to each room, never give the same color to rooms that sit next to each other, and try to do it with the fewest distinct colors you can. In practice that means every room must be colored, nearby rooms must be different, and you can measure success by the number of different colors used — smaller is better. The exact layout and room adjacencies appear below.

# total_rooms=16
# total_adjacencies=33
room_a,room_b
D,G
D,H
D,N
D,O
P,K
P,M
H,N
H,O
C,A
C,B
C,G
C,J
C,K
C,O
N,E
N,F
N,I
N,K
N,M
N,O
G,B
G,K
G,M
B,F
M,K
M,L
E,F
E,I
K,J
K,L
J,L
O,A
I,F

Think of the JSON below as the simple form I’ll want back — one key called ""solution"" whose value is a list of color groups, and each color group is a list of room identifiers that all share the same accent.

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

Super casual explanation: each inner list is one accent color and the entries inside are the room IDs that get that color. The JSON here is just a sketch of the shape I expect, not the actual coloring — you'll replace those placeholders with the real room IDs from the instance.

Please be sure to use the room identifiers exactly as they appear in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 33, 'edges': [{'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 16, 'v': 11}, {'u': 16, 'v': 13}, {'u': 8, 'v': 14}, {'u': 8, 'v': 15}, {'u': 3, 'v': 1}, {'u': 3, 'v': 2}, {'u': 3, 'v': 7}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 15}, {'u': 14, 'v': 5}, {'u': 14, 'v': 6}, {'u': 14, 'v': 9}, {'u': 14, 'v': 11}, {'u': 14, 'v': 13}, {'u': 14, 'v': 15}, {'u': 7, 'v': 2}, {'u': 7, 'v': 11}, {'u': 7, 'v': 13}, {'u': 2, 'v': 6}, {'u': 13, 'v': 11}, {'u': 13, 'v': 12}, {'u': 5, 'v': 6}, {'u': 5, 'v': 9}, {'u': 11, 'v': 10}, {'u': 11, 'v': 12}, {'u': 10, 'v': 12}, {'u': 15, 'v': 1}, {'u': 9, 'v': 6}], 'source_file': 'coAuthorsDBLP.mtx', 'density': 0.275, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0043.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0043.png', 'edge_connectivity': 2}","[[1, 2, 4, 9, 11], [5, 7, 10, 15, 16], [12, 14], [3, 6, 8, 13]]",4.0,"{'num_nodes': 16, 'num_edges': 33, 'edges': [{'u': 'D', 'v': 'G'}, {'u': 'D', 'v': 'H'}, {'u': 'D', 'v': 'N'}, {'u': 'D', 'v': 'O'}, {'u': 'P', 'v': 'K'}, {'u': 'P', 'v': 'M'}, {'u': 'H', 'v': 'N'}, {'u': 'H', 'v': 'O'}, {'u': 'C', 'v': 'A'}, {'u': 'C', 'v': 'B'}, {'u': 'C', 'v': 'G'}, {'u': 'C', 'v': 'J'}, {'u': 'C', 'v': 'K'}, {'u': 'C', 'v': 'O'}, {'u': 'N', 'v': 'E'}, {'u': 'N', 'v': 'F'}, {'u': 'N', 'v': 'I'}, {'u': 'N', 'v': 'K'}, {'u': 'N', 'v': 'M'}, {'u': 'N', 'v': 'O'}, {'u': 'G', 'v': 'B'}, {'u': 'G', 'v': 'K'}, {'u': 'G', 'v': 'M'}, {'u': 'B', 'v': 'F'}, {'u': 'M', 'v': 'K'}, {'u': 'M', 'v': 'L'}, {'u': 'E', 'v': 'F'}, {'u': 'E', 'v': 'I'}, {'u': 'K', 'v': 'J'}, {'u': 'K', 'v': 'L'}, {'u': 'J', 'v': 'L'}, {'u': 'O', 'v': 'A'}, {'u': 'I', 'v': 'F'}]}","[['A', 'B', 'D', 'I', 'K'], ['E', 'G', 'J', 'O', 'P'], ['L', 'N'], ['C', 'F', 'H', 'M']]",44,csv,names
GCP,GCP,"Many people working on the festival’s sound setup label each wireless mic with a band name, making sure that any two mics that might interfere are labeled differently. A smarter labeling uses fewer distinct band names overall — the score is simply the number of unique names assigned. Each microphone must be labeled exactly once and overlapping mics cannot share a label. The specific instance is given below.

# num_microphones=17
# num_interference_pairs=50
mic_id_u,mic_id_v
1,0
1,5
1,7
8,3
8,5
8,7
8,9
8,10
8,11
8,12
8,13
8,14
3,5
3,7
3,9
3,10
3,11
3,12
3,13
3,14
7,2
7,4
7,5
7,6
7,9
7,10
7,11
7,12
7,13
7,14
7,16
4,5
16,5
11,2
11,5
11,6
9,0
9,10
9,15
12,0
12,10
12,15
10,0
10,13
10,14
10,15
15,14
13,0
6,5
14,0

If you'd like to return the answer in a tidy, machine-friendly form, here's the little JSON sketch I expect—just showing the shape of the reply, not the real assignment:

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

Think of each inner list as one band name (all the mics in that list share the same label), and the outer list as the full set of different band names you're using. This is only a template for the format I want you to follow, not the actual labeling.

Please use the identifiers exactly as they appear in the instance input — do not rename them or invent new ones. Valid identifiers look like:
- ""1"" or ""23""
- ""A"" or ""B""
- ""A1"" or ""X7""","{'problem_type': 'GCP', 'num_nodes': 17, 'num_edges': 50, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 6}, {'u': 2, 'v': 8}, {'u': 9, 'v': 4}, {'u': 9, 'v': 6}, {'u': 9, 'v': 8}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 9, 'v': 15}, {'u': 4, 'v': 6}, {'u': 4, 'v': 8}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 4, 'v': 13}, {'u': 4, 'v': 14}, {'u': 4, 'v': 15}, {'u': 8, 'v': 3}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 8, 'v': 14}, {'u': 8, 'v': 15}, {'u': 8, 'v': 17}, {'u': 5, 'v': 6}, {'u': 17, 'v': 6}, {'u': 12, 'v': 3}, {'u': 12, 'v': 6}, {'u': 12, 'v': 7}, {'u': 10, 'v': 1}, {'u': 10, 'v': 11}, {'u': 10, 'v': 16}, {'u': 13, 'v': 1}, {'u': 13, 'v': 11}, {'u': 13, 'v': 16}, {'u': 11, 'v': 1}, {'u': 11, 'v': 14}, {'u': 11, 'v': 15}, {'u': 11, 'v': 16}, {'u': 16, 'v': 15}, {'u': 14, 'v': 1}, {'u': 7, 'v': 6}, {'u': 15, 'v': 1}], 'source_file': 'citationCiteseer.mtx', 'density': 0.36764705882352944, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0044.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0044.png', 'edge_connectivity': 2}","[[2, 5, 10, 12, 13, 14, 15, 17], [1, 8], [4], [6, 11], [3, 7, 9, 16]]",5.0,"{'num_nodes': 17, 'num_edges': 50, 'edges': [{'u': 1, 'v': 0}, {'u': 1, 'v': 5}, {'u': 1, 'v': 7}, {'u': 8, 'v': 3}, {'u': 8, 'v': 5}, {'u': 8, 'v': 7}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 8, 'v': 11}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 8, 'v': 14}, {'u': 3, 'v': 5}, {'u': 3, 'v': 7}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 3, 'v': 13}, {'u': 3, 'v': 14}, {'u': 7, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 6}, {'u': 7, 'v': 9}, {'u': 7, 'v': 10}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 13}, {'u': 7, 'v': 14}, {'u': 7, 'v': 16}, {'u': 4, 'v': 5}, {'u': 16, 'v': 5}, {'u': 11, 'v': 2}, {'u': 11, 'v': 5}, {'u': 11, 'v': 6}, {'u': 9, 'v': 0}, {'u': 9, 'v': 10}, {'u': 9, 'v': 15}, {'u': 12, 'v': 0}, {'u': 12, 'v': 10}, {'u': 12, 'v': 15}, {'u': 10, 'v': 0}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 15, 'v': 14}, {'u': 13, 'v': 0}, {'u': 6, 'v': 5}, {'u': 14, 'v': 0}]}","[[1, 4, 9, 11, 12, 13, 14, 16], [0, 7], [3], [5, 10], [2, 6, 8, 15]]",45,csv,0
GCP,GCP,"There’s a workshop challenge to glaze a mosaic where touching tiles must look different, so the job is to pick a glaze for each tile without repeating a glaze on neighboring pieces. What makes one choice better than another is obvious: the one that gets the whole mosaic done with the fewest distinct glaze colors wins, and you check that by counting the unique glazes. Every tile needs exactly one glaze and adjacent tiles can’t match. The specific mosaic layout follows below.

{
  ""total_tiles"": 13,
  ""adjacent_tile_pairs"": 42,
  ""edges"": [
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""A""
    },
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""B""
    },
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""C""
    },
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""D""
    },
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""E""
    },
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""G""
    },
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""H""
    },
    {
      ""tile_a_id"": ""F"",
      ""tile_b_id"": ""M""
    },
    {
      ""tile_a_id"": ""G"",
      ""tile_b_id"": ""A""
    },
    {
      ""tile_a_id"": ""G"",
      ""tile_b_id"": ""B""
    },
    {
      ""tile_a_id"": ""G"",
      ""tile_b_id"": ""C""
    },
    {
      ""tile_a_id"": ""G"",
      ""tile_b_id"": ""D""
    },
    {
      ""tile_a_id"": ""G"",
      ""tile_b_id"": ""E""
    },
    {
      ""tile_a_id"": ""G"",
      ""tile_b_id"": ""H""
    },
    {
      ""tile_a_id"": ""G"",
      ""tile_b_id"": ""M""
    },
    {
      ""tile_a_id"": ""H"",
      ""tile_b_id"": ""A""
    },
    {
      ""tile_a_id"": ""H"",
      ""tile_b_id"": ""B""
    },
    {
      ""tile_a_id"": ""H"",
      ""tile_b_id"": ""C""
    },
    {
      ""tile_a_id"": ""H"",
      ""tile_b_id"": ""D""
    },
    {
      ""tile_a_id"": ""H"",
      ""tile_b_id"": ""E""
    },
    {
      ""tile_a_id"": ""H"",
      ""tile_b_id"": ""M""
    },
    {
      ""tile_a_id"": ""I"",
      ""tile_b_id"": ""J""
    },
    {
      ""tile_a_id"": ""I"",
      ""tile_b_id"": ""K""
    },
    {
      ""tile_a_id"": ""I"",
      ""tile_b_id"": ""L""
    },
    {
      ""tile_a_id"": ""I"",
      ""tile_b_id"": ""M""
    },
    {
      ""tile_a_id"": ""K"",
      ""tile_b_id"": ""J""
    },
    {
      ""tile_a_id"": ""K"",
      ""tile_b_id"": ""L""
    },
    {
      ""tile_a_id"": ""K"",
      ""tile_b_id"": ""M""
    },
    {
      ""tile_a_id"": ""L"",
      ""tile_b_id"": ""J""
    },
    {
      ""tile_a_id"": ""L"",
      ""tile_b_id"": ""M""
    },
    {
      ""tile_a_id"": ""M"",
      ""tile_b_id"": ""A""
    },
    {
      ""tile_a_id"": ""M"",
      ""tile_b_id"": ""C""
    },
    {
      ""tile_a_id"": ""M"",
      ""tile_b_id"": ""D""
    },
    {
      ""tile_a_id"": ""M"",
      ""tile_b_id"": ""J""
    },
    {
      ""tile_a_id"": ""A"",
      ""tile_b_id"": ""C""
    },
    {
      ""tile_a_id"": ""A"",
      ""tile_b_id"": ""D""
    },
    {
      ""tile_a_id"": ""B"",
      ""tile_b_id"": ""C""
    },
    {
      ""tile_a_id"": ""B"",
      ""tile_b_id"": ""D""
    },
    {
      ""tile_a_id"": ""B"",
      ""tile_b_id"": ""E""
    },
    {
      ""tile_a_id"": ""C"",
      ""tile_b_id"": ""D""
    },
    {
      ""tile_a_id"": ""C"",
      ""tile_b_id"": ""E""
    },
    {
      ""tile_a_id"": ""D"",
      ""tile_b_id"": ""E""
    }
  ]
}

Also, when you hand me the glazing plan, please stick to this JSON shape so it's easy to check:

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

Think of ""solution"" as a list of glaze buckets — each inner array is the set of tiles that get the same glaze color, and each string is a tile identifier from the mosaic layout. This is just a sketch of the expected shape, not the actual glazing assignment.

Please use identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 13, 'num_edges': 42, 'edges': [{'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 6, 'v': 4}, {'u': 6, 'v': 5}, {'u': 6, 'v': 7}, {'u': 6, 'v': 8}, {'u': 6, 'v': 13}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 3}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 8}, {'u': 7, 'v': 13}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 4}, {'u': 8, 'v': 5}, {'u': 8, 'v': 13}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 11, 'v': 10}, {'u': 11, 'v': 12}, {'u': 11, 'v': 13}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 13, 'v': 1}, {'u': 13, 'v': 3}, {'u': 13, 'v': 4}, {'u': 13, 'v': 10}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 4, 'v': 5}], 'source_file': 'coPapersDBLP.mtx', 'density': 0.5384615384615384, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0045.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0045.png', 'edge_connectivity': 4}","[[6, 11], [7, 9], [4], [8], [5, 13], [1, 2, 10], [3, 12]]",7.0,"{'num_nodes': 13, 'num_edges': 42, 'edges': [{'u': 'F', 'v': 'A'}, {'u': 'F', 'v': 'B'}, {'u': 'F', 'v': 'C'}, {'u': 'F', 'v': 'D'}, {'u': 'F', 'v': 'E'}, {'u': 'F', 'v': 'G'}, {'u': 'F', 'v': 'H'}, {'u': 'F', 'v': 'M'}, {'u': 'G', 'v': 'A'}, {'u': 'G', 'v': 'B'}, {'u': 'G', 'v': 'C'}, {'u': 'G', 'v': 'D'}, {'u': 'G', 'v': 'E'}, {'u': 'G', 'v': 'H'}, {'u': 'G', 'v': 'M'}, {'u': 'H', 'v': 'A'}, {'u': 'H', 'v': 'B'}, {'u': 'H', 'v': 'C'}, {'u': 'H', 'v': 'D'}, {'u': 'H', 'v': 'E'}, {'u': 'H', 'v': 'M'}, {'u': 'I', 'v': 'J'}, {'u': 'I', 'v': 'K'}, {'u': 'I', 'v': 'L'}, {'u': 'I', 'v': 'M'}, {'u': 'K', 'v': 'J'}, {'u': 'K', 'v': 'L'}, {'u': 'K', 'v': 'M'}, {'u': 'L', 'v': 'J'}, {'u': 'L', 'v': 'M'}, {'u': 'M', 'v': 'A'}, {'u': 'M', 'v': 'C'}, {'u': 'M', 'v': 'D'}, {'u': 'M', 'v': 'J'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'D'}, {'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'D'}, {'u': 'B', 'v': 'E'}, {'u': 'C', 'v': 'D'}, {'u': 'C', 'v': 'E'}, {'u': 'D', 'v': 'E'}]}","[['F', 'K'], ['G', 'I'], ['D'], ['H'], ['E', 'M'], ['A', 'B', 'J'], ['C', 'L']]",46,json,names
GCP,GCP,"Someone’s got the job of assigning jerseys for the tournament: each team gets one color, and whenever two teams are scheduled to meet they cannot wear the same color. The goal is to keep the wardrobe tight by using the fewest different colors overall — judge a solution by how many distinct colors end up being used, found by counting unique colors across teams. No team can be skipped or assigned multiple colors, and the full schedule appears below.

There are 18 teams in total and 49 scheduled matches.

| team_a_id | team_b_id |
|---|---|
| B | A |
| B | C |
| B | D |
| B | E |
| B | F |
| B | G |
| B | H |
| B | K |
| B | P |
| B | R |
| J | E |
| J | L |
| J | M |
| J | N |
| J | O |
| D | E |
| D | H |
| C | E |
| C | F |
| C | G |
| C | H |
| P | A |
| P | E |
| P | N |
| M | I |
| A | K |
| A | L |
| A | N |
| A | O |
| A | R |
| K | E |
| K | G |
| K | N |
| K | O |
| H | F |
| H | G |
| G | E |
| G | R |
| N | E |
| N | I |
| N | L |
| N | O |
| N | Q |
| N | R |
| F | E |
| I | E |
| R | E |
| L | E |
| E | O |

If you want to hand the coloring back in a tidy way, just follow this little JSON sketch for the shape of the answer.

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

Pretty straightforward: ""solution"" is a list of color groups, and each inner list is the set of teams that share the same jersey color. Treat it like a simple form — each array is one color, and the teams listed together wear that same color. This JSON is just a sketch of the expected shape, not the actual coloring answer.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 18, 'num_edges': 49, 'edges': [{'u': 2, 'v': 1}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 6}, {'u': 2, 'v': 7}, {'u': 2, 'v': 8}, {'u': 2, 'v': 11}, {'u': 2, 'v': 16}, {'u': 2, 'v': 18}, {'u': 10, 'v': 5}, {'u': 10, 'v': 12}, {'u': 10, 'v': 13}, {'u': 10, 'v': 14}, {'u': 10, 'v': 15}, {'u': 4, 'v': 5}, {'u': 4, 'v': 8}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 16, 'v': 1}, {'u': 16, 'v': 5}, {'u': 16, 'v': 14}, {'u': 13, 'v': 9}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 1, 'v': 14}, {'u': 1, 'v': 15}, {'u': 1, 'v': 18}, {'u': 11, 'v': 5}, {'u': 11, 'v': 7}, {'u': 11, 'v': 14}, {'u': 11, 'v': 15}, {'u': 8, 'v': 6}, {'u': 8, 'v': 7}, {'u': 7, 'v': 5}, {'u': 7, 'v': 18}, {'u': 14, 'v': 5}, {'u': 14, 'v': 9}, {'u': 14, 'v': 12}, {'u': 14, 'v': 15}, {'u': 14, 'v': 17}, {'u': 14, 'v': 18}, {'u': 6, 'v': 5}, {'u': 9, 'v': 5}, {'u': 18, 'v': 5}, {'u': 12, 'v': 5}, {'u': 5, 'v': 15}], 'source_file': 'citationCiteseer.mtx', 'density': 0.3202614379084967, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0046.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0046.png', 'edge_connectivity': 1}","[[1, 5, 8, 13, 17], [4, 6, 7, 14], [3, 10, 11, 16, 18], [2, 9, 12, 15]]",4.0,"{'num_nodes': 18, 'num_edges': 49, 'edges': [{'u': 'B', 'v': 'A'}, {'u': 'B', 'v': 'C'}, {'u': 'B', 'v': 'D'}, {'u': 'B', 'v': 'E'}, {'u': 'B', 'v': 'F'}, {'u': 'B', 'v': 'G'}, {'u': 'B', 'v': 'H'}, {'u': 'B', 'v': 'K'}, {'u': 'B', 'v': 'P'}, {'u': 'B', 'v': 'R'}, {'u': 'J', 'v': 'E'}, {'u': 'J', 'v': 'L'}, {'u': 'J', 'v': 'M'}, {'u': 'J', 'v': 'N'}, {'u': 'J', 'v': 'O'}, {'u': 'D', 'v': 'E'}, {'u': 'D', 'v': 'H'}, {'u': 'C', 'v': 'E'}, {'u': 'C', 'v': 'F'}, {'u': 'C', 'v': 'G'}, {'u': 'C', 'v': 'H'}, {'u': 'P', 'v': 'A'}, {'u': 'P', 'v': 'E'}, {'u': 'P', 'v': 'N'}, {'u': 'M', 'v': 'I'}, {'u': 'A', 'v': 'K'}, {'u': 'A', 'v': 'L'}, {'u': 'A', 'v': 'N'}, {'u': 'A', 'v': 'O'}, {'u': 'A', 'v': 'R'}, {'u': 'K', 'v': 'E'}, {'u': 'K', 'v': 'G'}, {'u': 'K', 'v': 'N'}, {'u': 'K', 'v': 'O'}, {'u': 'H', 'v': 'F'}, {'u': 'H', 'v': 'G'}, {'u': 'G', 'v': 'E'}, {'u': 'G', 'v': 'R'}, {'u': 'N', 'v': 'E'}, {'u': 'N', 'v': 'I'}, {'u': 'N', 'v': 'L'}, {'u': 'N', 'v': 'O'}, {'u': 'N', 'v': 'Q'}, {'u': 'N', 'v': 'R'}, {'u': 'F', 'v': 'E'}, {'u': 'I', 'v': 'E'}, {'u': 'R', 'v': 'E'}, {'u': 'L', 'v': 'E'}, {'u': 'E', 'v': 'O'}]}","[['A', 'E', 'H', 'M', 'Q'], ['D', 'F', 'G', 'N'], ['C', 'J', 'K', 'P', 'R'], ['B', 'I', 'L', 'O']]",47,markdown_table,names
GCP,GCP,"Picture a dining hall where someone needs to assign a placemat to every table, making sure every pair of neighboring tables wears different colors, while keeping the overall color mix as small as possible. The better the plan, the fewer different colors it uses — simply count the different placemat colors to see which plan wins. Every table must get one placemat, and adjacent tables must not share a color. The concrete instance details are shown below.

There are 14 tables in total and 49 adjacent table pairs.

| table_u_id | table_v_id |
|---|---|
| 3 | 0 |
| 3 | 1 |
| 3 | 2 |
| 3 | 4 |
| 3 | 5 |
| 3 | 6 |
| 3 | 7 |
| 3 | 8 |
| 3 | 9 |
| 3 | 10 |
| 3 | 11 |
| 3 | 12 |
| 3 | 13 |
| 7 | 0 |
| 7 | 1 |
| 7 | 2 |
| 7 | 4 |
| 7 | 5 |
| 7 | 8 |
| 12 | 6 |
| 12 | 9 |
| 12 | 10 |
| 12 | 11 |
| 12 | 13 |
| 4 | 0 |
| 4 | 1 |
| 4 | 2 |
| 4 | 5 |
| 4 | 8 |
| 8 | 0 |
| 8 | 1 |
| 8 | 2 |
| 8 | 5 |
| 5 | 0 |
| 5 | 1 |
| 5 | 2 |
| 0 | 1 |
| 0 | 2 |
| 1 | 2 |
| 9 | 6 |
| 9 | 10 |
| 9 | 11 |
| 9 | 13 |
| 6 | 10 |
| 6 | 11 |
| 6 | 13 |
| 13 | 10 |
| 13 | 11 |
| 10 | 11 |

Oh, and one more thing — when you reply with a coloring plan, please use this simple JSON layout so it's easy to check:

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

Each inner list is a group of tables that all get the same placemat color (the first list = color 1, the second = color 2, and so on). Think of it as a quick form: each row is one color and lists the table IDs that share that color. This JSON is just the expected shape — not the actual answer.

Important: use the exact identifiers from the instance input — no renaming, no made-up labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 14, 'num_edges': 49, 'edges': [{'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 4, 'v': 10}, {'u': 4, 'v': 11}, {'u': 4, 'v': 12}, {'u': 4, 'v': 13}, {'u': 4, 'v': 14}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 3}, {'u': 8, 'v': 5}, {'u': 8, 'v': 6}, {'u': 8, 'v': 9}, {'u': 13, 'v': 7}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 13, 'v': 12}, {'u': 13, 'v': 14}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 9}, {'u': 9, 'v': 1}, {'u': 9, 'v': 2}, {'u': 9, 'v': 3}, {'u': 9, 'v': 6}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 2, 'v': 3}, {'u': 10, 'v': 7}, {'u': 10, 'v': 11}, {'u': 10, 'v': 12}, {'u': 10, 'v': 14}, {'u': 7, 'v': 11}, {'u': 7, 'v': 12}, {'u': 7, 'v': 14}, {'u': 14, 'v': 11}, {'u': 14, 'v': 12}, {'u': 11, 'v': 12}], 'source_file': 'coPapersDBLP.mtx', 'density': 0.5384615384615384, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0047.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0047.png', 'edge_connectivity': 6}","[[2, 14], [1, 7], [9, 11], [3, 12], [5], [8, 13], [4], [6, 10]]",8.0,"{'num_nodes': 14, 'num_edges': 49, 'edges': [{'u': 3, 'v': 0}, {'u': 3, 'v': 1}, {'u': 3, 'v': 2}, {'u': 3, 'v': 4}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 9}, {'u': 3, 'v': 10}, {'u': 3, 'v': 11}, {'u': 3, 'v': 12}, {'u': 3, 'v': 13}, {'u': 7, 'v': 0}, {'u': 7, 'v': 1}, {'u': 7, 'v': 2}, {'u': 7, 'v': 4}, {'u': 7, 'v': 5}, {'u': 7, 'v': 8}, {'u': 12, 'v': 6}, {'u': 12, 'v': 9}, {'u': 12, 'v': 10}, {'u': 12, 'v': 11}, {'u': 12, 'v': 13}, {'u': 4, 'v': 0}, {'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 5}, {'u': 4, 'v': 8}, {'u': 8, 'v': 0}, {'u': 8, 'v': 1}, {'u': 8, 'v': 2}, {'u': 8, 'v': 5}, {'u': 5, 'v': 0}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 0, 'v': 1}, {'u': 0, 'v': 2}, {'u': 1, 'v': 2}, {'u': 9, 'v': 6}, {'u': 9, 'v': 10}, {'u': 9, 'v': 11}, {'u': 9, 'v': 13}, {'u': 6, 'v': 10}, {'u': 6, 'v': 11}, {'u': 6, 'v': 13}, {'u': 13, 'v': 10}, {'u': 13, 'v': 11}, {'u': 10, 'v': 11}]}","[[1, 13], [0, 6], [8, 10], [2, 11], [4], [7, 12], [3], [5, 9]]",48,markdown_table,0
GCP,GCP,"Someone on the team asked for help coloring a navigation list so that no two adjacent entries share the same highlight, while also keeping the total number of different highlights small. What separates a good coloring from a messy one is simply how many different colors show up overall — fewer distinct highlights is better, and that’s determined by tallying the unique colors used. Make sure every entry gets one color and don’t give the same color to neighbors. The concrete details are shown below.

There are 16 num menu items in total and 62 num adjacent pairs.

| adjacent_menu_item_a | adjacent_menu_item_b |
|---|---|
| D | A |
| D | B |
| D | C |
| D | E |
| D | F |
| E | A |
| E | B |
| E | C |
| E | F |
| E | K |
| H | A |
| H | G |
| H | I |
| H | J |
| H | L |
| H | M |
| H | N |
| H | O |
| H | P |
| O | A |
| O | G |
| O | I |
| O | J |
| O | L |
| O | M |
| O | N |
| O | P |
| F | A |
| F | B |
| F | C |
| A | B |
| A | C |
| A | G |
| A | I |
| A | J |
| A | K |
| A | L |
| A | M |
| A | N |
| A | P |
| I | G |
| I | J |
| I | L |
| I | M |
| I | N |
| I | P |
| L | G |
| L | J |
| L | M |
| L | N |
| L | P |
| M | G |
| M | J |
| M | N |
| M | P |
| B | C |
| J | G |
| J | N |
| J | P |
| N | G |
| N | P |
| P | G |

Also, when you send the coloring back, please follow this simple JSON shape so it’s easy to parse:

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

Each inner list is a group of navigation entries that share the same highlight (so each list is one color). Think of it like filling out a form: put every entry’s identifier into exactly one of the lists, and each list represents all items painted that same color. This JSON is just a sketch of the expected shape — don’t treat the placeholders as the actual answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels. 
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 62, 'edges': [{'u': 4, 'v': 1}, {'u': 4, 'v': 2}, {'u': 4, 'v': 3}, {'u': 4, 'v': 5}, {'u': 4, 'v': 6}, {'u': 5, 'v': 1}, {'u': 5, 'v': 2}, {'u': 5, 'v': 3}, {'u': 5, 'v': 6}, {'u': 5, 'v': 11}, {'u': 8, 'v': 1}, {'u': 8, 'v': 7}, {'u': 8, 'v': 9}, {'u': 8, 'v': 10}, {'u': 8, 'v': 12}, {'u': 8, 'v': 13}, {'u': 8, 'v': 14}, {'u': 8, 'v': 15}, {'u': 8, 'v': 16}, {'u': 15, 'v': 1}, {'u': 15, 'v': 7}, {'u': 15, 'v': 9}, {'u': 15, 'v': 10}, {'u': 15, 'v': 12}, {'u': 15, 'v': 13}, {'u': 15, 'v': 14}, {'u': 15, 'v': 16}, {'u': 6, 'v': 1}, {'u': 6, 'v': 2}, {'u': 6, 'v': 3}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 7}, {'u': 1, 'v': 9}, {'u': 1, 'v': 10}, {'u': 1, 'v': 11}, {'u': 1, 'v': 12}, {'u': 1, 'v': 13}, {'u': 1, 'v': 14}, {'u': 1, 'v': 16}, {'u': 9, 'v': 7}, {'u': 9, 'v': 10}, {'u': 9, 'v': 12}, {'u': 9, 'v': 13}, {'u': 9, 'v': 14}, {'u': 9, 'v': 16}, {'u': 12, 'v': 7}, {'u': 12, 'v': 10}, {'u': 12, 'v': 13}, {'u': 12, 'v': 14}, {'u': 12, 'v': 16}, {'u': 13, 'v': 7}, {'u': 13, 'v': 10}, {'u': 13, 'v': 14}, {'u': 13, 'v': 16}, {'u': 2, 'v': 3}, {'u': 10, 'v': 7}, {'u': 10, 'v': 14}, {'u': 10, 'v': 16}, {'u': 14, 'v': 7}, {'u': 14, 'v': 16}, {'u': 16, 'v': 7}], 'source_file': 'coPapersDBLP.mtx', 'density': 0.5166666666666667, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0048.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0048.png', 'edge_connectivity': 2}","[[11, 12], [3, 8], [7], [15], [5, 14], [1], [6, 10], [9], [2, 16], [4, 13]]",10.0,"{'num_nodes': 16, 'num_edges': 62, 'edges': [{'u': 'D', 'v': 'A'}, {'u': 'D', 'v': 'B'}, {'u': 'D', 'v': 'C'}, {'u': 'D', 'v': 'E'}, {'u': 'D', 'v': 'F'}, {'u': 'E', 'v': 'A'}, {'u': 'E', 'v': 'B'}, {'u': 'E', 'v': 'C'}, {'u': 'E', 'v': 'F'}, {'u': 'E', 'v': 'K'}, {'u': 'H', 'v': 'A'}, {'u': 'H', 'v': 'G'}, {'u': 'H', 'v': 'I'}, {'u': 'H', 'v': 'J'}, {'u': 'H', 'v': 'L'}, {'u': 'H', 'v': 'M'}, {'u': 'H', 'v': 'N'}, {'u': 'H', 'v': 'O'}, {'u': 'H', 'v': 'P'}, {'u': 'O', 'v': 'A'}, {'u': 'O', 'v': 'G'}, {'u': 'O', 'v': 'I'}, {'u': 'O', 'v': 'J'}, {'u': 'O', 'v': 'L'}, {'u': 'O', 'v': 'M'}, {'u': 'O', 'v': 'N'}, {'u': 'O', 'v': 'P'}, {'u': 'F', 'v': 'A'}, {'u': 'F', 'v': 'B'}, {'u': 'F', 'v': 'C'}, {'u': 'A', 'v': 'B'}, {'u': 'A', 'v': 'C'}, {'u': 'A', 'v': 'G'}, {'u': 'A', 'v': 'I'}, {'u': 'A', 'v': 'J'}, {'u': 'A', 'v': 'K'}, {'u': 'A', 'v': 'L'}, {'u': 'A', 'v': 'M'}, {'u': 'A', 'v': 'N'}, {'u': 'A', 'v': 'P'}, {'u': 'I', 'v': 'G'}, {'u': 'I', 'v': 'J'}, {'u': 'I', 'v': 'L'}, {'u': 'I', 'v': 'M'}, {'u': 'I', 'v': 'N'}, {'u': 'I', 'v': 'P'}, {'u': 'L', 'v': 'G'}, {'u': 'L', 'v': 'J'}, {'u': 'L', 'v': 'M'}, {'u': 'L', 'v': 'N'}, {'u': 'L', 'v': 'P'}, {'u': 'M', 'v': 'G'}, {'u': 'M', 'v': 'J'}, {'u': 'M', 'v': 'N'}, {'u': 'M', 'v': 'P'}, {'u': 'B', 'v': 'C'}, {'u': 'J', 'v': 'G'}, {'u': 'J', 'v': 'N'}, {'u': 'J', 'v': 'P'}, {'u': 'N', 'v': 'G'}, {'u': 'N', 'v': 'P'}, {'u': 'P', 'v': 'G'}]}","[['K', 'L'], ['C', 'H'], ['G'], ['O'], ['E', 'N'], ['A'], ['F', 'J'], ['I'], ['B', 'P'], ['D', 'M']]",49,markdown_table,names
GCP,GCP,"A friend organizing a party asked for help picking ribbon shades for all the centerpieces so nothing clashes side-by-side. Every centerpiece needs one ribbon and any two that touch can’t share a color, so the cleanest solution is the one that uses the fewest different colors overall — you can check that by tallying the unique ribbons used. The exact list of centerpieces and their neighbors is provided below.

{
  ""total_centerpieces"": 16,
  ""total_adjacent_pairs"": 33,
  ""edges"": [
    {
      ""centerpiece_a"": 0,
      ""centerpiece_b"": 3
    },
    {
      ""centerpiece_a"": 0,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 0,
      ""centerpiece_b"": 5
    },
    {
      ""centerpiece_a"": 0,
      ""centerpiece_b"": 13
    },
    {
      ""centerpiece_a"": 1,
      ""centerpiece_b"": 2
    },
    {
      ""centerpiece_a"": 1,
      ""centerpiece_b"": 3
    },
    {
      ""centerpiece_a"": 1,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 1,
      ""centerpiece_b"": 13
    },
    {
      ""centerpiece_a"": 13,
      ""centerpiece_b"": 5
    },
    {
      ""centerpiece_a"": 13,
      ""centerpiece_b"": 6
    },
    {
      ""centerpiece_a"": 13,
      ""centerpiece_b"": 7
    },
    {
      ""centerpiece_a"": 13,
      ""centerpiece_b"": 8
    },
    {
      ""centerpiece_a"": 13,
      ""centerpiece_b"": 11
    },
    {
      ""centerpiece_a"": 13,
      ""centerpiece_b"": 14
    },
    {
      ""centerpiece_a"": 3,
      ""centerpiece_b"": 2
    },
    {
      ""centerpiece_a"": 3,
      ""centerpiece_b"": 5
    },
    {
      ""centerpiece_a"": 3,
      ""centerpiece_b"": 6
    },
    {
      ""centerpiece_a"": 3,
      ""centerpiece_b"": 7
    },
    {
      ""centerpiece_a"": 3,
      ""centerpiece_b"": 8
    },
    {
      ""centerpiece_a"": 3,
      ""centerpiece_b"": 11
    },
    {
      ""centerpiece_a"": 3,
      ""centerpiece_b"": 14
    },
    {
      ""centerpiece_a"": 2,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 5,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 5,
      ""centerpiece_b"": 14
    },
    {
      ""centerpiece_a"": 14,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 8,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 8,
      ""centerpiece_b"": 10
    },
    {
      ""centerpiece_a"": 8,
      ""centerpiece_b"": 12
    },
    {
      ""centerpiece_a"": 9,
      ""centerpiece_b"": 12
    },
    {
      ""centerpiece_a"": 9,
      ""centerpiece_b"": 15
    },
    {
      ""centerpiece_a"": 6,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 11,
      ""centerpiece_b"": 4
    },
    {
      ""centerpiece_a"": 7,
      ""centerpiece_b"": 4
    }
  ]
}

Also, when you send the ribbon plan back, keep it in this simple JSON shape so it's easy to check automatically — nothing fancy, just a list of groups:

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

Each inner list is one ribbon shade (a group of centerpieces that all use the same ribbon). Think of each array as a little column on the packing list: all those centerpieces get the same ribbon color. The JSON above is just a sketch of the layout I need, not the actual coloring.

Please use the exact identifiers from the instance input — don't rename any of them or invent new labels. 

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'GCP', 'num_nodes': 16, 'num_edges': 33, 'edges': [{'u': 1, 'v': 4}, {'u': 1, 'v': 5}, {'u': 1, 'v': 6}, {'u': 1, 'v': 14}, {'u': 2, 'v': 3}, {'u': 2, 'v': 4}, {'u': 2, 'v': 5}, {'u': 2, 'v': 14}, {'u': 14, 'v': 6}, {'u': 14, 'v': 7}, {'u': 14, 'v': 8}, {'u': 14, 'v': 9}, {'u': 14, 'v': 12}, {'u': 14, 'v': 15}, {'u': 4, 'v': 3}, {'u': 4, 'v': 6}, {'u': 4, 'v': 7}, {'u': 4, 'v': 8}, {'u': 4, 'v': 9}, {'u': 4, 'v': 12}, {'u': 4, 'v': 15}, {'u': 3, 'v': 5}, {'u': 6, 'v': 5}, {'u': 6, 'v': 15}, {'u': 15, 'v': 5}, {'u': 9, 'v': 5}, {'u': 9, 'v': 11}, {'u': 9, 'v': 13}, {'u': 10, 'v': 13}, {'u': 10, 'v': 16}, {'u': 7, 'v': 5}, {'u': 12, 'v': 5}, {'u': 8, 'v': 5}], 'source_file': 'citationCiteseer.mtx', 'density': 0.275, 'viz_instance': 'generated_data/GCP/viz/GCP_M/instance_0049.png', 'viz_solution': 'generated_data/GCP/viz/GCP_M/solution_0049.png', 'edge_connectivity': 1}","[[4, 5, 11, 13, 14, 16], [3, 6, 7, 8, 9, 12], [1, 2, 10, 15]]",3.0,"{'num_nodes': 16, 'num_edges': 33, 'edges': [{'u': 0, 'v': 3}, {'u': 0, 'v': 4}, {'u': 0, 'v': 5}, {'u': 0, 'v': 13}, {'u': 1, 'v': 2}, {'u': 1, 'v': 3}, {'u': 1, 'v': 4}, {'u': 1, 'v': 13}, {'u': 13, 'v': 5}, {'u': 13, 'v': 6}, {'u': 13, 'v': 7}, {'u': 13, 'v': 8}, {'u': 13, 'v': 11}, {'u': 13, 'v': 14}, {'u': 3, 'v': 2}, {'u': 3, 'v': 5}, {'u': 3, 'v': 6}, {'u': 3, 'v': 7}, {'u': 3, 'v': 8}, {'u': 3, 'v': 11}, {'u': 3, 'v': 14}, {'u': 2, 'v': 4}, {'u': 5, 'v': 4}, {'u': 5, 'v': 14}, {'u': 14, 'v': 4}, {'u': 8, 'v': 4}, {'u': 8, 'v': 10}, {'u': 8, 'v': 12}, {'u': 9, 'v': 12}, {'u': 9, 'v': 15}, {'u': 6, 'v': 4}, {'u': 11, 'v': 4}, {'u': 7, 'v': 4}]}","[[3, 4, 10, 12, 13, 15], [2, 5, 6, 7, 8, 11], [0, 1, 9, 14]]",50,json,0