AP3/AP3_S_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
AP3,AP3,"Many people depend on a tidy schedule at the courier shop: each rider takes on one restaurant and one delivery patch, and every restaurant and every patch must be taken by exactly one rider — no overlaps, no gaps. Each rider’s trip length for their restaurant-plus-zone choice is known, and the best overall plan is simply the one with the smallest sum of those trip lengths across all riders. The exact restaurants, zones, riders, and measured distances are shown below.

{
  ""num_couriers"": 5,
  ""index_ids"": [
    1,
    2,
    3,
    4,
    5
  ]
}

# Meaning: costs form a 3D tensor. For each fixed rider_id=i, you are given a restaurant_id×delivery_zone_id matrix whose entry at row restaurant_id=j and column delivery_zone_id=k equals riding_distance(i,j,k). You must pick exactly one (j,k) for every i, with all restaurant_id and all delivery_zone_id used exactly once.
# riding_distance_tensor (per-rider_id markdown matrices)

## rider_id=1
| restaurant_id\delivery_zone_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 89 | 9 | 90 | 88 | 40 |
| 2 | 68 | 22 | 2 | 63 | 0 |
| 3 | 48 | 94 | 80 | 85 | 51 |
| 4 | 84 | 82 | 51 | 46 | 16 |
| 5 | 70 | 63 | 68 | 25 | 76 |

## rider_id=2
| restaurant_id\delivery_zone_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 16 | 91 | 3 | 17 | 81 |
| 2 | 59 | 36 | 15 | 89 | 33 |
| 3 | 20 | 28 | 60 | 24 | 5 |
| 4 | 8 | 31 | 53 | 37 | 52 |
| 5 | 49 | 69 | 50 | 17 | 16 |

## rider_id=3
| restaurant_id\delivery_zone_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 24 | 19 | 85 | 28 | 61 |
| 2 | 66 | 40 | 93 | 67 | 90 |
| 3 | 46 | 78 | 56 | 84 | 16 |
| 4 | 51 | 83 | 56 | 43 | 60 |
| 5 | 83 | 93 | 31 | 85 | 38 |

## rider_id=4
| restaurant_id\delivery_zone_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 38 | 13 | 99 | 55 | 77 |
| 2 | 73 | 30 | 32 | 57 | 60 |
| 3 | 98 | 30 | 95 | 57 | 89 |
| 4 | 2 | 65 | 98 | 55 | 2 |
| 5 | 17 | 24 | 68 | 65 | 91 |

## rider_id=5
| restaurant_id\delivery_zone_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 27 | 74 | 63 | 74 | 8 |
| 2 | 86 | 0 | 0 | 62 | 52 |
| 3 | 90 | 67 | 49 | 65 | 53 |
| 4 | 0 | 50 | 99 | 55 | 13 |
| 5 | 6 | 40 | 2 | 78 | 19 |

I'll keep the final plan tidy in a small JSON sketch like this — just the shape of what I'll return:

{
  ""solution"": [
    [<i_id>, <j_id>, <k_id>],
    ...
  ]
}

This means ""solution"" is a list of triples. Each triple picks one rider (first entry), one restaurant (second entry), and one delivery patch (third entry). Think of each triple as one rider's assigned restaurant-and-patch pair. This block is only a sketch of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[89, 9, 90, 88, 40], [68, 22, 2, 63, 0], [48, 94, 80, 85, 51], [84, 82, 51, 46, 16], [70, 63, 68, 25, 76]], [[16, 91, 3, 17, 81], [59, 36, 15, 89, 33], [20, 28, 60, 24, 5], [8, 31, 53, 37, 52], [49, 69, 50, 17, 16]], [[24, 19, 85, 28, 61], [66, 40, 93, 67, 90], [46, 78, 56, 84, 16], [51, 83, 56, 43, 60], [83, 93, 31, 85, 38]], [[38, 13, 99, 55, 77], [73, 30, 32, 57, 60], [98, 30, 95, 57, 89], [2, 65, 98, 55, 2], [17, 24, 68, 65, 91]], [[27, 74, 63, 74, 8], [86, 0, 0, 62, 52], [90, 67, 49, 65, 53], [0, 50, 99, 55, 13], [6, 40, 2, 78, 19]]], 'objective': 44.0}","[[0, 0, 1], [1, 4, 3], [2, 2, 4], [3, 3, 0], [4, 1, 2]]",44.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [1, 2, 3, 4, 5], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 89}, {'i': 1, 'j': 1, 'k': 2, 'cost': 9}, {'i': 1, 'j': 1, 'k': 3, 'cost': 90}, {'i': 1, 'j': 1, 'k': 4, 'cost': 88}, {'i': 1, 'j': 1, 'k': 5, 'cost': 40}, {'i': 1, 'j': 2, 'k': 1, 'cost': 68}, {'i': 1, 'j': 2, 'k': 2, 'cost': 22}, {'i': 1, 'j': 2, 'k': 3, 'cost': 2}, {'i': 1, 'j': 2, 'k': 4, 'cost': 63}, {'i': 1, 'j': 2, 'k': 5, 'cost': 0}, {'i': 1, 'j': 3, 'k': 1, 'cost': 48}, {'i': 1, 'j': 3, 'k': 2, 'cost': 94}, {'i': 1, 'j': 3, 'k': 3, 'cost': 80}, {'i': 1, 'j': 3, 'k': 4, 'cost': 85}, {'i': 1, 'j': 3, 'k': 5, 'cost': 51}, {'i': 1, 'j': 4, 'k': 1, 'cost': 84}, {'i': 1, 'j': 4, 'k': 2, 'cost': 82}, {'i': 1, 'j': 4, 'k': 3, 'cost': 51}, {'i': 1, 'j': 4, 'k': 4, 'cost': 46}, {'i': 1, 'j': 4, 'k': 5, 'cost': 16}, {'i': 1, 'j': 5, 'k': 1, 'cost': 70}, {'i': 1, 'j': 5, 'k': 2, 'cost': 63}, {'i': 1, 'j': 5, 'k': 3, 'cost': 68}, {'i': 1, 'j': 5, 'k': 4, 'cost': 25}, {'i': 1, 'j': 5, 'k': 5, 'cost': 76}, {'i': 2, 'j': 1, 'k': 1, 'cost': 16}, {'i': 2, 'j': 1, 'k': 2, 'cost': 91}, {'i': 2, 'j': 1, 'k': 3, 'cost': 3}, {'i': 2, 'j': 1, 'k': 4, 'cost': 17}, {'i': 2, 'j': 1, 'k': 5, 'cost': 81}, {'i': 2, 'j': 2, 'k': 1, 'cost': 59}, {'i': 2, 'j': 2, 'k': 2, 'cost': 36}, {'i': 2, 'j': 2, 'k': 3, 'cost': 15}, {'i': 2, 'j': 2, 'k': 4, 'cost': 89}, {'i': 2, 'j': 2, 'k': 5, 'cost': 33}, {'i': 2, 'j': 3, 'k': 1, 'cost': 20}, {'i': 2, 'j': 3, 'k': 2, 'cost': 28}, {'i': 2, 'j': 3, 'k': 3, 'cost': 60}, {'i': 2, 'j': 3, 'k': 4, 'cost': 24}, {'i': 2, 'j': 3, 'k': 5, 'cost': 5}, {'i': 2, 'j': 4, 'k': 1, 'cost': 8}, {'i': 2, 'j': 4, 'k': 2, 'cost': 31}, {'i': 2, 'j': 4, 'k': 3, 'cost': 53}, {'i': 2, 'j': 4, 'k': 4, 'cost': 37}, {'i': 2, 'j': 4, 'k': 5, 'cost': 52}, {'i': 2, 'j': 5, 'k': 1, 'cost': 49}, {'i': 2, 'j': 5, 'k': 2, 'cost': 69}, {'i': 2, 'j': 5, 'k': 3, 'cost': 50}, {'i': 2, 'j': 5, 'k': 4, 'cost': 17}, {'i': 2, 'j': 5, 'k': 5, 'cost': 16}, {'i': 3, 'j': 1, 'k': 1, 'cost': 24}, {'i': 3, 'j': 1, 'k': 2, 'cost': 19}, {'i': 3, 'j': 1, 'k': 3, 'cost': 85}, {'i': 3, 'j': 1, 'k': 4, 'cost': 28}, {'i': 3, 'j': 1, 'k': 5, 'cost': 61}, {'i': 3, 'j': 2, 'k': 1, 'cost': 66}, {'i': 3, 'j': 2, 'k': 2, 'cost': 40}, {'i': 3, 'j': 2, 'k': 3, 'cost': 93}, {'i': 3, 'j': 2, 'k': 4, 'cost': 67}, {'i': 3, 'j': 2, 'k': 5, 'cost': 90}, {'i': 3, 'j': 3, 'k': 1, 'cost': 46}, {'i': 3, 'j': 3, 'k': 2, 'cost': 78}, {'i': 3, 'j': 3, 'k': 3, 'cost': 56}, {'i': 3, 'j': 3, 'k': 4, 'cost': 84}, {'i': 3, 'j': 3, 'k': 5, 'cost': 16}, {'i': 3, 'j': 4, 'k': 1, 'cost': 51}, {'i': 3, 'j': 4, 'k': 2, 'cost': 83}, {'i': 3, 'j': 4, 'k': 3, 'cost': 56}, {'i': 3, 'j': 4, 'k': 4, 'cost': 43}, {'i': 3, 'j': 4, 'k': 5, 'cost': 60}, {'i': 3, 'j': 5, 'k': 1, 'cost': 83}, {'i': 3, 'j': 5, 'k': 2, 'cost': 93}, {'i': 3, 'j': 5, 'k': 3, 'cost': 31}, {'i': 3, 'j': 5, 'k': 4, 'cost': 85}, {'i': 3, 'j': 5, 'k': 5, 'cost': 38}, {'i': 4, 'j': 1, 'k': 1, 'cost': 38}, {'i': 4, 'j': 1, 'k': 2, 'cost': 13}, {'i': 4, 'j': 1, 'k': 3, 'cost': 99}, {'i': 4, 'j': 1, 'k': 4, 'cost': 55}, {'i': 4, 'j': 1, 'k': 5, 'cost': 77}, {'i': 4, 'j': 2, 'k': 1, 'cost': 73}, {'i': 4, 'j': 2, 'k': 2, 'cost': 30}, {'i': 4, 'j': 2, 'k': 3, 'cost': 32}, {'i': 4, 'j': 2, 'k': 4, 'cost': 57}, {'i': 4, 'j': 2, 'k': 5, 'cost': 60}, {'i': 4, 'j': 3, 'k': 1, 'cost': 98}, {'i': 4, 'j': 3, 'k': 2, 'cost': 30}, {'i': 4, 'j': 3, 'k': 3, 'cost': 95}, {'i': 4, 'j': 3, 'k': 4, 'cost': 57}, {'i': 4, 'j': 3, 'k': 5, 'cost': 89}, {'i': 4, 'j': 4, 'k': 1, 'cost': 2}, {'i': 4, 'j': 4, 'k': 2, 'cost': 65}, {'i': 4, 'j': 4, 'k': 3, 'cost': 98}, {'i': 4, 'j': 4, 'k': 4, 'cost': 55}, {'i': 4, 'j': 4, 'k': 5, 'cost': 2}, {'i': 4, 'j': 5, 'k': 1, 'cost': 17}, {'i': 4, 'j': 5, 'k': 2, 'cost': 24}, {'i': 4, 'j': 5, 'k': 3, 'cost': 68}, {'i': 4, 'j': 5, 'k': 4, 'cost': 65}, {'i': 4, 'j': 5, 'k': 5, 'cost': 91}, {'i': 5, 'j': 1, 'k': 1, 'cost': 27}, {'i': 5, 'j': 1, 'k': 2, 'cost': 74}, {'i': 5, 'j': 1, 'k': 3, 'cost': 63}, {'i': 5, 'j': 1, 'k': 4, 'cost': 74}, {'i': 5, 'j': 1, 'k': 5, 'cost': 8}, {'i': 5, 'j': 2, 'k': 1, 'cost': 86}, {'i': 5, 'j': 2, 'k': 2, 'cost': 0}, {'i': 5, 'j': 2, 'k': 3, 'cost': 0}, {'i': 5, 'j': 2, 'k': 4, 'cost': 62}, {'i': 5, 'j': 2, 'k': 5, 'cost': 52}, {'i': 5, 'j': 3, 'k': 1, 'cost': 90}, {'i': 5, 'j': 3, 'k': 2, 'cost': 67}, {'i': 5, 'j': 3, 'k': 3, 'cost': 49}, {'i': 5, 'j': 3, 'k': 4, 'cost': 65}, {'i': 5, 'j': 3, 'k': 5, 'cost': 53}, {'i': 5, 'j': 4, 'k': 1, 'cost': 0}, {'i': 5, 'j': 4, 'k': 2, 'cost': 50}, {'i': 5, 'j': 4, 'k': 3, 'cost': 99}, {'i': 5, 'j': 4, 'k': 4, 'cost': 55}, {'i': 5, 'j': 4, 'k': 5, 'cost': 13}, {'i': 5, 'j': 5, 'k': 1, 'cost': 6}, {'i': 5, 'j': 5, 'k': 2, 'cost': 40}, {'i': 5, 'j': 5, 'k': 3, 'cost': 2}, {'i': 5, 'j': 5, 'k': 4, 'cost': 78}, {'i': 5, 'j': 5, 'k': 5, 'cost': 19}]}","[[1, 1, 2], [2, 5, 4], [3, 3, 5], [4, 4, 1], [5, 2, 3]]",1,json,1
AP3,AP3,"We had a stack of speaker bios, a list of rooms, and a list of time slots — and the task was to match each speaker with exactly one room and one slot so every room and every slot ends up with a single speaker. Someone assigned a cost to each possible speaker-room-time combo, and the idea was to pick the lineup whose costs add up to the least amount overall. Nothing could be duplicated or skipped: one speaker, one room, one slot each. The concrete details are shown below.

We had 5 keynote speakers, the same number of rooms and time slots, labeled 0, 1, 2, 3, 4.
Meaning: costs form a 3D tensor. For each fixed speaker_id=i, you are given a room_id×time_slot_id matrix whose entry at row room_id=j and column time_slot_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all room_id and all time_slot_id used exactly once.
assignment_cost_tensor (per-speaker_id markdown matrices):
## speaker_id=0
| room_id\time_slot_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 24 | 40 | 62 | 69 | 57 |
| 1 | 14 | 98 | 0 | 45 | 71 |
| 2 | 41 | 87 | 87 | 7 | 15 |
| 3 | 11 | 68 | 91 | 81 | 71 |
| 4 | 90 | 88 | 24 | 53 | 54 |

## speaker_id=1
| room_id\time_slot_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 91 | 72 | 12 | 84 | 14 |
| 1 | 94 | 70 | 17 | 55 | 79 |
| 2 | 58 | 41 | 17 | 26 | 8 |
| 3 | 74 | 95 | 19 | 72 | 38 |
| 4 | 2 | 8 | 26 | 32 | 2 |

## speaker_id=2
| room_id\time_slot_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 78 | 62 | 64 | 59 | 41 |
| 1 | 75 | 74 | 40 | 97 | 92 |
| 2 | 64 | 34 | 95 | 49 | 76 |
| 3 | 32 | 35 | 10 | 39 | 20 |
| 4 | 30 | 37 | 48 | 49 | 22 |

## speaker_id=3
| room_id\time_slot_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 79 | 95 | 37 | 49 | 85 |
| 1 | 65 | 37 | 93 | 29 | 66 |
| 2 | 99 | 53 | 89 | 10 | 0 |
| 3 | 30 | 92 | 5 | 14 | 33 |
| 4 | 4 | 14 | 31 | 89 | 39 |

## speaker_id=4
| room_id\time_slot_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 6 | 6 | 73 | 75 | 49 |
| 1 | 12 | 21 | 1 | 70 | 22 |
| 2 | 52 | 48 | 10 | 30 | 9 |
| 3 | 46 | 64 | 66 | 62 | 87 |
| 4 | 57 | 53 | 89 | 97 | 85 |
We then selected 5 of these triples so every speaker, room, and time slot was used exactly once.

I'll show the shape of the reply I need in a quick JSON sketch so it's clear how to return the matchings.

{
  ""solution"": [
    [<speaker_id>, <room_id>, <slot_id>],
    ...
  ]
}

Here ""solution"" is a list of triples — one triple per speaker — and each triple is the speaker identifier, the room identifier, and the time-slot identifier in that order. Think of it like filling out a little form: each row says which room and which slot a given speaker gets.

This JSON block is just an example of the shape I want, not the actual assignment.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'cost_tensor': [[[24, 40, 62, 69, 57], [14, 98, 0, 45, 71], [41, 87, 87, 7, 15], [11, 68, 91, 81, 71], [90, 88, 24, 53, 54]], [[91, 72, 12, 84, 14], [94, 70, 17, 55, 79], [58, 41, 17, 26, 8], [74, 95, 19, 72, 38], [2, 8, 26, 32, 2]], [[78, 62, 64, 59, 41], [75, 74, 40, 97, 92], [64, 34, 95, 49, 76], [32, 35, 10, 39, 20], [30, 37, 48, 49, 22]], [[79, 95, 37, 49, 85], [65, 37, 93, 29, 66], [99, 53, 89, 10, 0], [30, 92, 5, 14, 33], [4, 14, 31, 89, 39]], [[6, 6, 73, 75, 49], [12, 21, 1, 70, 22], [52, 48, 10, 30, 9], [46, 64, 66, 62, 87], [57, 53, 89, 97, 85]]], 'objective': 38.0}","[[0, 1, 2], [1, 4, 0], [2, 3, 4], [3, 2, 3], [4, 0, 1]]",38.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [0, 1, 2, 3, 4], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 24}, {'i': 0, 'j': 0, 'k': 1, 'cost': 40}, {'i': 0, 'j': 0, 'k': 2, 'cost': 62}, {'i': 0, 'j': 0, 'k': 3, 'cost': 69}, {'i': 0, 'j': 0, 'k': 4, 'cost': 57}, {'i': 0, 'j': 1, 'k': 0, 'cost': 14}, {'i': 0, 'j': 1, 'k': 1, 'cost': 98}, {'i': 0, 'j': 1, 'k': 2, 'cost': 0}, {'i': 0, 'j': 1, 'k': 3, 'cost': 45}, {'i': 0, 'j': 1, 'k': 4, 'cost': 71}, {'i': 0, 'j': 2, 'k': 0, 'cost': 41}, {'i': 0, 'j': 2, 'k': 1, 'cost': 87}, {'i': 0, 'j': 2, 'k': 2, 'cost': 87}, {'i': 0, 'j': 2, 'k': 3, 'cost': 7}, {'i': 0, 'j': 2, 'k': 4, 'cost': 15}, {'i': 0, 'j': 3, 'k': 0, 'cost': 11}, {'i': 0, 'j': 3, 'k': 1, 'cost': 68}, {'i': 0, 'j': 3, 'k': 2, 'cost': 91}, {'i': 0, 'j': 3, 'k': 3, 'cost': 81}, {'i': 0, 'j': 3, 'k': 4, 'cost': 71}, {'i': 0, 'j': 4, 'k': 0, 'cost': 90}, {'i': 0, 'j': 4, 'k': 1, 'cost': 88}, {'i': 0, 'j': 4, 'k': 2, 'cost': 24}, {'i': 0, 'j': 4, 'k': 3, 'cost': 53}, {'i': 0, 'j': 4, 'k': 4, 'cost': 54}, {'i': 1, 'j': 0, 'k': 0, 'cost': 91}, {'i': 1, 'j': 0, 'k': 1, 'cost': 72}, {'i': 1, 'j': 0, 'k': 2, 'cost': 12}, {'i': 1, 'j': 0, 'k': 3, 'cost': 84}, {'i': 1, 'j': 0, 'k': 4, 'cost': 14}, {'i': 1, 'j': 1, 'k': 0, 'cost': 94}, {'i': 1, 'j': 1, 'k': 1, 'cost': 70}, {'i': 1, 'j': 1, 'k': 2, 'cost': 17}, {'i': 1, 'j': 1, 'k': 3, 'cost': 55}, {'i': 1, 'j': 1, 'k': 4, 'cost': 79}, {'i': 1, 'j': 2, 'k': 0, 'cost': 58}, {'i': 1, 'j': 2, 'k': 1, 'cost': 41}, {'i': 1, 'j': 2, 'k': 2, 'cost': 17}, {'i': 1, 'j': 2, 'k': 3, 'cost': 26}, {'i': 1, 'j': 2, 'k': 4, 'cost': 8}, {'i': 1, 'j': 3, 'k': 0, 'cost': 74}, {'i': 1, 'j': 3, 'k': 1, 'cost': 95}, {'i': 1, 'j': 3, 'k': 2, 'cost': 19}, {'i': 1, 'j': 3, 'k': 3, 'cost': 72}, {'i': 1, 'j': 3, 'k': 4, 'cost': 38}, {'i': 1, 'j': 4, 'k': 0, 'cost': 2}, {'i': 1, 'j': 4, 'k': 1, 'cost': 8}, {'i': 1, 'j': 4, 'k': 2, 'cost': 26}, {'i': 1, 'j': 4, 'k': 3, 'cost': 32}, {'i': 1, 'j': 4, 'k': 4, 'cost': 2}, {'i': 2, 'j': 0, 'k': 0, 'cost': 78}, {'i': 2, 'j': 0, 'k': 1, 'cost': 62}, {'i': 2, 'j': 0, 'k': 2, 'cost': 64}, {'i': 2, 'j': 0, 'k': 3, 'cost': 59}, {'i': 2, 'j': 0, 'k': 4, 'cost': 41}, {'i': 2, 'j': 1, 'k': 0, 'cost': 75}, {'i': 2, 'j': 1, 'k': 1, 'cost': 74}, {'i': 2, 'j': 1, 'k': 2, 'cost': 40}, {'i': 2, 'j': 1, 'k': 3, 'cost': 97}, {'i': 2, 'j': 1, 'k': 4, 'cost': 92}, {'i': 2, 'j': 2, 'k': 0, 'cost': 64}, {'i': 2, 'j': 2, 'k': 1, 'cost': 34}, {'i': 2, 'j': 2, 'k': 2, 'cost': 95}, {'i': 2, 'j': 2, 'k': 3, 'cost': 49}, {'i': 2, 'j': 2, 'k': 4, 'cost': 76}, {'i': 2, 'j': 3, 'k': 0, 'cost': 32}, {'i': 2, 'j': 3, 'k': 1, 'cost': 35}, {'i': 2, 'j': 3, 'k': 2, 'cost': 10}, {'i': 2, 'j': 3, 'k': 3, 'cost': 39}, {'i': 2, 'j': 3, 'k': 4, 'cost': 20}, {'i': 2, 'j': 4, 'k': 0, 'cost': 30}, {'i': 2, 'j': 4, 'k': 1, 'cost': 37}, {'i': 2, 'j': 4, 'k': 2, 'cost': 48}, {'i': 2, 'j': 4, 'k': 3, 'cost': 49}, {'i': 2, 'j': 4, 'k': 4, 'cost': 22}, {'i': 3, 'j': 0, 'k': 0, 'cost': 79}, {'i': 3, 'j': 0, 'k': 1, 'cost': 95}, {'i': 3, 'j': 0, 'k': 2, 'cost': 37}, {'i': 3, 'j': 0, 'k': 3, 'cost': 49}, {'i': 3, 'j': 0, 'k': 4, 'cost': 85}, {'i': 3, 'j': 1, 'k': 0, 'cost': 65}, {'i': 3, 'j': 1, 'k': 1, 'cost': 37}, {'i': 3, 'j': 1, 'k': 2, 'cost': 93}, {'i': 3, 'j': 1, 'k': 3, 'cost': 29}, {'i': 3, 'j': 1, 'k': 4, 'cost': 66}, {'i': 3, 'j': 2, 'k': 0, 'cost': 99}, {'i': 3, 'j': 2, 'k': 1, 'cost': 53}, {'i': 3, 'j': 2, 'k': 2, 'cost': 89}, {'i': 3, 'j': 2, 'k': 3, 'cost': 10}, {'i': 3, 'j': 2, 'k': 4, 'cost': 0}, {'i': 3, 'j': 3, 'k': 0, 'cost': 30}, {'i': 3, 'j': 3, 'k': 1, 'cost': 92}, {'i': 3, 'j': 3, 'k': 2, 'cost': 5}, {'i': 3, 'j': 3, 'k': 3, 'cost': 14}, {'i': 3, 'j': 3, 'k': 4, 'cost': 33}, {'i': 3, 'j': 4, 'k': 0, 'cost': 4}, {'i': 3, 'j': 4, 'k': 1, 'cost': 14}, {'i': 3, 'j': 4, 'k': 2, 'cost': 31}, {'i': 3, 'j': 4, 'k': 3, 'cost': 89}, {'i': 3, 'j': 4, 'k': 4, 'cost': 39}, {'i': 4, 'j': 0, 'k': 0, 'cost': 6}, {'i': 4, 'j': 0, 'k': 1, 'cost': 6}, {'i': 4, 'j': 0, 'k': 2, 'cost': 73}, {'i': 4, 'j': 0, 'k': 3, 'cost': 75}, {'i': 4, 'j': 0, 'k': 4, 'cost': 49}, {'i': 4, 'j': 1, 'k': 0, 'cost': 12}, {'i': 4, 'j': 1, 'k': 1, 'cost': 21}, {'i': 4, 'j': 1, 'k': 2, 'cost': 1}, {'i': 4, 'j': 1, 'k': 3, 'cost': 70}, {'i': 4, 'j': 1, 'k': 4, 'cost': 22}, {'i': 4, 'j': 2, 'k': 0, 'cost': 52}, {'i': 4, 'j': 2, 'k': 1, 'cost': 48}, {'i': 4, 'j': 2, 'k': 2, 'cost': 10}, {'i': 4, 'j': 2, 'k': 3, 'cost': 30}, {'i': 4, 'j': 2, 'k': 4, 'cost': 9}, {'i': 4, 'j': 3, 'k': 0, 'cost': 46}, {'i': 4, 'j': 3, 'k': 1, 'cost': 64}, {'i': 4, 'j': 3, 'k': 2, 'cost': 66}, {'i': 4, 'j': 3, 'k': 3, 'cost': 62}, {'i': 4, 'j': 3, 'k': 4, 'cost': 87}, {'i': 4, 'j': 4, 'k': 0, 'cost': 57}, {'i': 4, 'j': 4, 'k': 1, 'cost': 53}, {'i': 4, 'j': 4, 'k': 2, 'cost': 89}, {'i': 4, 'j': 4, 'k': 3, 'cost': 97}, {'i': 4, 'j': 4, 'k': 4, 'cost': 85}]}","[[0, 1, 2], [1, 4, 0], [2, 3, 4], [3, 2, 3], [4, 0, 1]]",2,nl,0
AP3,AP3,"A plant manager faces a tidy constraint: assign every product to one machine and one shift, don’t let machines or shifts be reused, and don’t leave any machine or shift empty. Each product+machine+shift choice has a specific cost attached, so the practical way to compare plans is to add up those costs for the chosen assignments and pick the set that results in the lowest total spend. The exact options and numbers are listed below.

There are 3 products, machines and shifts labeled 1, 2, 3.
Meaning: costs form a 3D tensor. For each fixed product_id=i, you are given a machine_id×shift_id matrix whose entry at row machine_id=j and column shift_id=k equals production_cost(i,j,k). You must pick exactly one (j,k) for every i, with all machine_id and all shift_id used exactly once.
production_cost_tensor (per-product_id markdown matrices):
## product_id=1
| machine_id\shift_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 44 | 96 | 96 |
| 2 | 37 | 89 | 39 |
| 3 | 75 | 81 | 80 |

## product_id=2
| machine_id\shift_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 15 | 79 | 75 |
| 2 | 87 | 47 | 14 |
| 3 | 71 | 22 | 27 |

## product_id=3
| machine_id\shift_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 11 | 43 | 18 |
| 2 | 1 | 73 | 70 |
| 3 | 71 | 85 | 47 |
The manager will choose the set of assignments that uses each machine and each shift exactly once and minimizes the total cost.

If you want to give the plan in a machine-friendly way, just use a little JSON like this one — nothing fancy, just a list of triples showing which product goes to which machine and which shift:

{
  ""solution"": [
    [<i_id>, <j_id>, <k_id>],
    ...
  ]
}

Think of each inner triple as [product_id, machine_id, shift_id] — one triple for each product, in plain, human terms. This JSON is just a sketch of the shape I expect, not the actual answer.

Please make sure you use the identifiers exactly as they appear in 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”.","{'cost_tensor': [[[44, 96, 96], [37, 89, 39], [75, 81, 80]], [[15, 79, 75], [87, 47, 14], [71, 22, 27]], [[11, 43, 18], [1, 73, 70], [71, 85, 47]]], 'objective': 72.0}","[[0, 1, 2], [1, 2, 1], [2, 0, 0]]",72.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [1, 2, 3], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 44}, {'i': 1, 'j': 1, 'k': 2, 'cost': 96}, {'i': 1, 'j': 1, 'k': 3, 'cost': 96}, {'i': 1, 'j': 2, 'k': 1, 'cost': 37}, {'i': 1, 'j': 2, 'k': 2, 'cost': 89}, {'i': 1, 'j': 2, 'k': 3, 'cost': 39}, {'i': 1, 'j': 3, 'k': 1, 'cost': 75}, {'i': 1, 'j': 3, 'k': 2, 'cost': 81}, {'i': 1, 'j': 3, 'k': 3, 'cost': 80}, {'i': 2, 'j': 1, 'k': 1, 'cost': 15}, {'i': 2, 'j': 1, 'k': 2, 'cost': 79}, {'i': 2, 'j': 1, 'k': 3, 'cost': 75}, {'i': 2, 'j': 2, 'k': 1, 'cost': 87}, {'i': 2, 'j': 2, 'k': 2, 'cost': 47}, {'i': 2, 'j': 2, 'k': 3, 'cost': 14}, {'i': 2, 'j': 3, 'k': 1, 'cost': 71}, {'i': 2, 'j': 3, 'k': 2, 'cost': 22}, {'i': 2, 'j': 3, 'k': 3, 'cost': 27}, {'i': 3, 'j': 1, 'k': 1, 'cost': 11}, {'i': 3, 'j': 1, 'k': 2, 'cost': 43}, {'i': 3, 'j': 1, 'k': 3, 'cost': 18}, {'i': 3, 'j': 2, 'k': 1, 'cost': 1}, {'i': 3, 'j': 2, 'k': 2, 'cost': 73}, {'i': 3, 'j': 2, 'k': 3, 'cost': 70}, {'i': 3, 'j': 3, 'k': 1, 'cost': 71}, {'i': 3, 'j': 3, 'k': 2, 'cost': 85}, {'i': 3, 'j': 3, 'k': 3, 'cost': 47}]}","[[1, 2, 3], [2, 3, 2], [3, 1, 1]]",3,nl,1
AP3,AP3,"Many people on the placement panel are deciding who works on what and under whom: every student must be matched to one project and one supervisor, and every project and supervisor must go to only one student. Each choice comes with a mismatch penalty, and the committee judges a full matching by summing those penalties for all students—the lower that total sum, the better the outcome. Assignments can’t be reused or skipped; it’s a strict one-to-one pairing across the three groups. The concrete list and penalties are provided below.

# num_students=5
# index_ids=0, 1, 2, 3, 4

# Meaning: costs form a 3D tensor. For each fixed student_id=i, you are given a project_id×supervisor_id matrix whose entry at row project_id=j and column supervisor_id=k equals mismatch_penalty(i,j,k). You must pick exactly one (j,k) for every i, with all project_id and all supervisor_id used exactly once.
# mismatch_penalty_tensor (per-student_id markdown matrices)

## student_id=0
| project_id\supervisor_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 93 | 51 | 27 | 35 | 54 |
| 1 | 30 | 46 | 57 | 78 | 97 |
| 2 | 14 | 38 | 92 | 14 | 40 |
| 3 | 47 | 40 | 91 | 17 | 95 |
| 4 | 70 | 88 | 28 | 30 | 44 |

## student_id=1
| project_id\supervisor_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 38 | 93 | 96 | 67 | 38 |
| 1 | 85 | 53 | 86 | 92 | 59 |
| 2 | 33 | 76 | 5 | 81 | 17 |
| 3 | 19 | 99 | 95 | 23 | 99 |
| 4 | 11 | 47 | 38 | 11 | 3 |

## student_id=2
| project_id\supervisor_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 37 | 2 | 20 | 80 | 16 |
| 1 | 33 | 16 | 8 | 38 | 1 |
| 2 | 92 | 89 | 42 | 72 | 88 |
| 3 | 10 | 4 | 99 | 53 | 74 |
| 4 | 33 | 65 | 51 | 57 | 74 |

## student_id=3
| project_id\supervisor_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 69 | 60 | 99 | 32 | 46 |
| 1 | 43 | 39 | 40 | 11 | 15 |
| 2 | 78 | 11 | 33 | 44 | 48 |
| 3 | 20 | 0 | 16 | 70 | 22 |
| 4 | 58 | 82 | 42 | 5 | 51 |

## student_id=4
| project_id\supervisor_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 45 | 4 | 76 | 85 | 39 |
| 1 | 31 | 78 | 47 | 99 | 61 |
| 2 | 78 | 42 | 50 | 54 | 72 |
| 3 | 45 | 60 | 29 | 62 | 95 |
| 4 | 23 | 47 | 9 | 82 | 90 |

If you want to hand back a matching, just use this simple JSON shape — it's the format I expect for a proposed assignment:

{
  ""solution"": [
    [<student_id>, <project_id>, <supervisor_id>],
    ...
  ]
}

Each inner list is one complete choice: the student, then the project they get, then the supervisor. The ""solution"" array is just the full list of those triples for everyone. This is only a sketch of the shape I want — replace the placeholders with the actual IDs from the instance when you submit a real matching.

Please make sure all identifiers are used exactly as they appear in the instance input — no renaming and no new labels.

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[93, 51, 27, 35, 54], [30, 46, 57, 78, 97], [14, 38, 92, 14, 40], [47, 40, 91, 17, 95], [70, 88, 28, 30, 44]], [[38, 93, 96, 67, 38], [85, 53, 86, 92, 59], [33, 76, 5, 81, 17], [19, 99, 95, 23, 99], [11, 47, 38, 11, 3]], [[37, 2, 20, 80, 16], [33, 16, 8, 38, 1], [92, 89, 42, 72, 88], [10, 4, 99, 53, 74], [33, 65, 51, 57, 74]], [[69, 60, 99, 32, 46], [43, 39, 40, 11, 15], [78, 11, 33, 44, 48], [20, 0, 16, 70, 22], [58, 82, 42, 5, 51]], [[45, 4, 76, 85, 39], [31, 78, 47, 99, 61], [78, 42, 50, 54, 72], [45, 60, 29, 62, 95], [23, 47, 9, 82, 90]]], 'objective': 46.0}","[[0, 2, 0], [1, 4, 3], [2, 1, 4], [3, 3, 2], [4, 0, 1]]",46.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [0, 1, 2, 3, 4], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 93}, {'i': 0, 'j': 0, 'k': 1, 'cost': 51}, {'i': 0, 'j': 0, 'k': 2, 'cost': 27}, {'i': 0, 'j': 0, 'k': 3, 'cost': 35}, {'i': 0, 'j': 0, 'k': 4, 'cost': 54}, {'i': 0, 'j': 1, 'k': 0, 'cost': 30}, {'i': 0, 'j': 1, 'k': 1, 'cost': 46}, {'i': 0, 'j': 1, 'k': 2, 'cost': 57}, {'i': 0, 'j': 1, 'k': 3, 'cost': 78}, {'i': 0, 'j': 1, 'k': 4, 'cost': 97}, {'i': 0, 'j': 2, 'k': 0, 'cost': 14}, {'i': 0, 'j': 2, 'k': 1, 'cost': 38}, {'i': 0, 'j': 2, 'k': 2, 'cost': 92}, {'i': 0, 'j': 2, 'k': 3, 'cost': 14}, {'i': 0, 'j': 2, 'k': 4, 'cost': 40}, {'i': 0, 'j': 3, 'k': 0, 'cost': 47}, {'i': 0, 'j': 3, 'k': 1, 'cost': 40}, {'i': 0, 'j': 3, 'k': 2, 'cost': 91}, {'i': 0, 'j': 3, 'k': 3, 'cost': 17}, {'i': 0, 'j': 3, 'k': 4, 'cost': 95}, {'i': 0, 'j': 4, 'k': 0, 'cost': 70}, {'i': 0, 'j': 4, 'k': 1, 'cost': 88}, {'i': 0, 'j': 4, 'k': 2, 'cost': 28}, {'i': 0, 'j': 4, 'k': 3, 'cost': 30}, {'i': 0, 'j': 4, 'k': 4, 'cost': 44}, {'i': 1, 'j': 0, 'k': 0, 'cost': 38}, {'i': 1, 'j': 0, 'k': 1, 'cost': 93}, {'i': 1, 'j': 0, 'k': 2, 'cost': 96}, {'i': 1, 'j': 0, 'k': 3, 'cost': 67}, {'i': 1, 'j': 0, 'k': 4, 'cost': 38}, {'i': 1, 'j': 1, 'k': 0, 'cost': 85}, {'i': 1, 'j': 1, 'k': 1, 'cost': 53}, {'i': 1, 'j': 1, 'k': 2, 'cost': 86}, {'i': 1, 'j': 1, 'k': 3, 'cost': 92}, {'i': 1, 'j': 1, 'k': 4, 'cost': 59}, {'i': 1, 'j': 2, 'k': 0, 'cost': 33}, {'i': 1, 'j': 2, 'k': 1, 'cost': 76}, {'i': 1, 'j': 2, 'k': 2, 'cost': 5}, {'i': 1, 'j': 2, 'k': 3, 'cost': 81}, {'i': 1, 'j': 2, 'k': 4, 'cost': 17}, {'i': 1, 'j': 3, 'k': 0, 'cost': 19}, {'i': 1, 'j': 3, 'k': 1, 'cost': 99}, {'i': 1, 'j': 3, 'k': 2, 'cost': 95}, {'i': 1, 'j': 3, 'k': 3, 'cost': 23}, {'i': 1, 'j': 3, 'k': 4, 'cost': 99}, {'i': 1, 'j': 4, 'k': 0, 'cost': 11}, {'i': 1, 'j': 4, 'k': 1, 'cost': 47}, {'i': 1, 'j': 4, 'k': 2, 'cost': 38}, {'i': 1, 'j': 4, 'k': 3, 'cost': 11}, {'i': 1, 'j': 4, 'k': 4, 'cost': 3}, {'i': 2, 'j': 0, 'k': 0, 'cost': 37}, {'i': 2, 'j': 0, 'k': 1, 'cost': 2}, {'i': 2, 'j': 0, 'k': 2, 'cost': 20}, {'i': 2, 'j': 0, 'k': 3, 'cost': 80}, {'i': 2, 'j': 0, 'k': 4, 'cost': 16}, {'i': 2, 'j': 1, 'k': 0, 'cost': 33}, {'i': 2, 'j': 1, 'k': 1, 'cost': 16}, {'i': 2, 'j': 1, 'k': 2, 'cost': 8}, {'i': 2, 'j': 1, 'k': 3, 'cost': 38}, {'i': 2, 'j': 1, 'k': 4, 'cost': 1}, {'i': 2, 'j': 2, 'k': 0, 'cost': 92}, {'i': 2, 'j': 2, 'k': 1, 'cost': 89}, {'i': 2, 'j': 2, 'k': 2, 'cost': 42}, {'i': 2, 'j': 2, 'k': 3, 'cost': 72}, {'i': 2, 'j': 2, 'k': 4, 'cost': 88}, {'i': 2, 'j': 3, 'k': 0, 'cost': 10}, {'i': 2, 'j': 3, 'k': 1, 'cost': 4}, {'i': 2, 'j': 3, 'k': 2, 'cost': 99}, {'i': 2, 'j': 3, 'k': 3, 'cost': 53}, {'i': 2, 'j': 3, 'k': 4, 'cost': 74}, {'i': 2, 'j': 4, 'k': 0, 'cost': 33}, {'i': 2, 'j': 4, 'k': 1, 'cost': 65}, {'i': 2, 'j': 4, 'k': 2, 'cost': 51}, {'i': 2, 'j': 4, 'k': 3, 'cost': 57}, {'i': 2, 'j': 4, 'k': 4, 'cost': 74}, {'i': 3, 'j': 0, 'k': 0, 'cost': 69}, {'i': 3, 'j': 0, 'k': 1, 'cost': 60}, {'i': 3, 'j': 0, 'k': 2, 'cost': 99}, {'i': 3, 'j': 0, 'k': 3, 'cost': 32}, {'i': 3, 'j': 0, 'k': 4, 'cost': 46}, {'i': 3, 'j': 1, 'k': 0, 'cost': 43}, {'i': 3, 'j': 1, 'k': 1, 'cost': 39}, {'i': 3, 'j': 1, 'k': 2, 'cost': 40}, {'i': 3, 'j': 1, 'k': 3, 'cost': 11}, {'i': 3, 'j': 1, 'k': 4, 'cost': 15}, {'i': 3, 'j': 2, 'k': 0, 'cost': 78}, {'i': 3, 'j': 2, 'k': 1, 'cost': 11}, {'i': 3, 'j': 2, 'k': 2, 'cost': 33}, {'i': 3, 'j': 2, 'k': 3, 'cost': 44}, {'i': 3, 'j': 2, 'k': 4, 'cost': 48}, {'i': 3, 'j': 3, 'k': 0, 'cost': 20}, {'i': 3, 'j': 3, 'k': 1, 'cost': 0}, {'i': 3, 'j': 3, 'k': 2, 'cost': 16}, {'i': 3, 'j': 3, 'k': 3, 'cost': 70}, {'i': 3, 'j': 3, 'k': 4, 'cost': 22}, {'i': 3, 'j': 4, 'k': 0, 'cost': 58}, {'i': 3, 'j': 4, 'k': 1, 'cost': 82}, {'i': 3, 'j': 4, 'k': 2, 'cost': 42}, {'i': 3, 'j': 4, 'k': 3, 'cost': 5}, {'i': 3, 'j': 4, 'k': 4, 'cost': 51}, {'i': 4, 'j': 0, 'k': 0, 'cost': 45}, {'i': 4, 'j': 0, 'k': 1, 'cost': 4}, {'i': 4, 'j': 0, 'k': 2, 'cost': 76}, {'i': 4, 'j': 0, 'k': 3, 'cost': 85}, {'i': 4, 'j': 0, 'k': 4, 'cost': 39}, {'i': 4, 'j': 1, 'k': 0, 'cost': 31}, {'i': 4, 'j': 1, 'k': 1, 'cost': 78}, {'i': 4, 'j': 1, 'k': 2, 'cost': 47}, {'i': 4, 'j': 1, 'k': 3, 'cost': 99}, {'i': 4, 'j': 1, 'k': 4, 'cost': 61}, {'i': 4, 'j': 2, 'k': 0, 'cost': 78}, {'i': 4, 'j': 2, 'k': 1, 'cost': 42}, {'i': 4, 'j': 2, 'k': 2, 'cost': 50}, {'i': 4, 'j': 2, 'k': 3, 'cost': 54}, {'i': 4, 'j': 2, 'k': 4, 'cost': 72}, {'i': 4, 'j': 3, 'k': 0, 'cost': 45}, {'i': 4, 'j': 3, 'k': 1, 'cost': 60}, {'i': 4, 'j': 3, 'k': 2, 'cost': 29}, {'i': 4, 'j': 3, 'k': 3, 'cost': 62}, {'i': 4, 'j': 3, 'k': 4, 'cost': 95}, {'i': 4, 'j': 4, 'k': 0, 'cost': 23}, {'i': 4, 'j': 4, 'k': 1, 'cost': 47}, {'i': 4, 'j': 4, 'k': 2, 'cost': 9}, {'i': 4, 'j': 4, 'k': 3, 'cost': 82}, {'i': 4, 'j': 4, 'k': 4, 'cost': 90}]}","[[0, 2, 0], [1, 4, 3], [2, 1, 4], [3, 3, 2], [4, 0, 1]]",4,csv,0
AP3,AP3,"Recently the studio scheduled a lineup of shoots and needed to match each model with one photographer and one backdrop, ensuring no photographer or backdrop handled more than one model. Every pairing came with a predicted retouch time, and the total retouch time for the day is simply the sum of the chosen pairings’ times — the team wanted that total to be as low as possible. The concrete options and numbers follow below.

# num_models=5
# model_ids=0, 1, 2, 3, 4

# Meaning: costs form a 3D tensor. For each fixed model_id=i, you are given a photographer_id×backdrop_id matrix whose entry at row photographer_id=j and column backdrop_id=k equals expected_retouch_time(i,j,k). You must pick exactly one (j,k) for every i, with all photographer_id and all backdrop_id used exactly once.
# expected_retouch_time_tensor (per-model_id markdown matrices)

## model_id=0
| photographer_id\backdrop_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 58 | 59 | 91 | 53 | 90 |
| 1 | 85 | 19 | 11 | 7 | 8 |
| 2 | 32 | 68 | 43 | 32 | 22 |
| 3 | 40 | 31 | 2 | 75 | 92 |
| 4 | 26 | 83 | 7 | 90 | 60 |

## model_id=1
| photographer_id\backdrop_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 12 | 79 | 14 | 4 | 87 |
| 1 | 16 | 21 | 12 | 37 | 23 |
| 2 | 21 | 48 | 24 | 94 | 32 |
| 3 | 39 | 78 | 70 | 76 | 71 |
| 4 | 65 | 56 | 33 | 71 | 38 |

## model_id=2
| photographer_id\backdrop_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 93 | 77 | 79 | 0 | 38 |
| 1 | 31 | 7 | 85 | 14 | 7 |
| 2 | 80 | 36 | 12 | 66 | 15 |
| 3 | 49 | 63 | 61 | 53 | 32 |
| 4 | 44 | 79 | 88 | 31 | 1 |

## model_id=3
| photographer_id\backdrop_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 15 | 51 | 11 | 23 | 49 |
| 1 | 34 | 83 | 59 | 82 | 50 |
| 2 | 18 | 17 | 74 | 36 | 2 |
| 3 | 51 | 71 | 30 | 34 | 28 |
| 4 | 8 | 62 | 38 | 57 | 71 |

## model_id=4
| photographer_id\backdrop_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 42 | 60 | 68 | 39 | 15 |
| 1 | 50 | 86 | 57 | 89 | 46 |
| 2 | 48 | 5 | 33 | 32 | 0 |
| 3 | 97 | 81 | 7 | 75 | 51 |
| 4 | 7 | 11 | 35 | 91 | 6 |

If you want to give the final plan, just stick to a tiny JSON layout like this — super simple and easy to read:

{
  ""solution"": [
    [<model_id>, <photographer_id>, <backdrop_id>],
    ...
  ]
}

Here ""solution"" is a list of triples. Each triple is the chosen model, the chosen photographer, and the chosen backdrop for that model (in that order). Think of it like filling out a short form: one row per model with the three ids you picked. This JSON is just a sketch showing the shape I expect, not the actual answer.

Please make sure every identifier you use matches exactly what appears in the instance input — no renaming, no made-up labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[58, 59, 91, 53, 90], [85, 19, 11, 7, 8], [32, 68, 43, 32, 22], [40, 31, 2, 75, 92], [26, 83, 7, 90, 60]], [[12, 79, 14, 4, 87], [16, 21, 12, 37, 23], [21, 48, 24, 94, 32], [39, 78, 70, 76, 71], [65, 56, 33, 71, 38]], [[93, 77, 79, 0, 38], [31, 7, 85, 14, 7], [80, 36, 12, 66, 15], [49, 63, 61, 53, 32], [44, 79, 88, 31, 1]], [[15, 51, 11, 23, 49], [34, 83, 59, 82, 50], [18, 17, 74, 36, 2], [51, 71, 30, 34, 28], [8, 62, 38, 57, 71]], [[42, 60, 68, 39, 15], [50, 86, 57, 89, 46], [48, 5, 33, 32, 0], [97, 81, 7, 75, 51], [7, 11, 35, 91, 6]]], 'objective': 21.0}","[[0, 3, 2], [1, 0, 3], [2, 1, 1], [3, 4, 0], [4, 2, 4]]",21.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [0, 1, 2, 3, 4], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 58}, {'i': 0, 'j': 0, 'k': 1, 'cost': 59}, {'i': 0, 'j': 0, 'k': 2, 'cost': 91}, {'i': 0, 'j': 0, 'k': 3, 'cost': 53}, {'i': 0, 'j': 0, 'k': 4, 'cost': 90}, {'i': 0, 'j': 1, 'k': 0, 'cost': 85}, {'i': 0, 'j': 1, 'k': 1, 'cost': 19}, {'i': 0, 'j': 1, 'k': 2, 'cost': 11}, {'i': 0, 'j': 1, 'k': 3, 'cost': 7}, {'i': 0, 'j': 1, 'k': 4, 'cost': 8}, {'i': 0, 'j': 2, 'k': 0, 'cost': 32}, {'i': 0, 'j': 2, 'k': 1, 'cost': 68}, {'i': 0, 'j': 2, 'k': 2, 'cost': 43}, {'i': 0, 'j': 2, 'k': 3, 'cost': 32}, {'i': 0, 'j': 2, 'k': 4, 'cost': 22}, {'i': 0, 'j': 3, 'k': 0, 'cost': 40}, {'i': 0, 'j': 3, 'k': 1, 'cost': 31}, {'i': 0, 'j': 3, 'k': 2, 'cost': 2}, {'i': 0, 'j': 3, 'k': 3, 'cost': 75}, {'i': 0, 'j': 3, 'k': 4, 'cost': 92}, {'i': 0, 'j': 4, 'k': 0, 'cost': 26}, {'i': 0, 'j': 4, 'k': 1, 'cost': 83}, {'i': 0, 'j': 4, 'k': 2, 'cost': 7}, {'i': 0, 'j': 4, 'k': 3, 'cost': 90}, {'i': 0, 'j': 4, 'k': 4, 'cost': 60}, {'i': 1, 'j': 0, 'k': 0, 'cost': 12}, {'i': 1, 'j': 0, 'k': 1, 'cost': 79}, {'i': 1, 'j': 0, 'k': 2, 'cost': 14}, {'i': 1, 'j': 0, 'k': 3, 'cost': 4}, {'i': 1, 'j': 0, 'k': 4, 'cost': 87}, {'i': 1, 'j': 1, 'k': 0, 'cost': 16}, {'i': 1, 'j': 1, 'k': 1, 'cost': 21}, {'i': 1, 'j': 1, 'k': 2, 'cost': 12}, {'i': 1, 'j': 1, 'k': 3, 'cost': 37}, {'i': 1, 'j': 1, 'k': 4, 'cost': 23}, {'i': 1, 'j': 2, 'k': 0, 'cost': 21}, {'i': 1, 'j': 2, 'k': 1, 'cost': 48}, {'i': 1, 'j': 2, 'k': 2, 'cost': 24}, {'i': 1, 'j': 2, 'k': 3, 'cost': 94}, {'i': 1, 'j': 2, 'k': 4, 'cost': 32}, {'i': 1, 'j': 3, 'k': 0, 'cost': 39}, {'i': 1, 'j': 3, 'k': 1, 'cost': 78}, {'i': 1, 'j': 3, 'k': 2, 'cost': 70}, {'i': 1, 'j': 3, 'k': 3, 'cost': 76}, {'i': 1, 'j': 3, 'k': 4, 'cost': 71}, {'i': 1, 'j': 4, 'k': 0, 'cost': 65}, {'i': 1, 'j': 4, 'k': 1, 'cost': 56}, {'i': 1, 'j': 4, 'k': 2, 'cost': 33}, {'i': 1, 'j': 4, 'k': 3, 'cost': 71}, {'i': 1, 'j': 4, 'k': 4, 'cost': 38}, {'i': 2, 'j': 0, 'k': 0, 'cost': 93}, {'i': 2, 'j': 0, 'k': 1, 'cost': 77}, {'i': 2, 'j': 0, 'k': 2, 'cost': 79}, {'i': 2, 'j': 0, 'k': 3, 'cost': 0}, {'i': 2, 'j': 0, 'k': 4, 'cost': 38}, {'i': 2, 'j': 1, 'k': 0, 'cost': 31}, {'i': 2, 'j': 1, 'k': 1, 'cost': 7}, {'i': 2, 'j': 1, 'k': 2, 'cost': 85}, {'i': 2, 'j': 1, 'k': 3, 'cost': 14}, {'i': 2, 'j': 1, 'k': 4, 'cost': 7}, {'i': 2, 'j': 2, 'k': 0, 'cost': 80}, {'i': 2, 'j': 2, 'k': 1, 'cost': 36}, {'i': 2, 'j': 2, 'k': 2, 'cost': 12}, {'i': 2, 'j': 2, 'k': 3, 'cost': 66}, {'i': 2, 'j': 2, 'k': 4, 'cost': 15}, {'i': 2, 'j': 3, 'k': 0, 'cost': 49}, {'i': 2, 'j': 3, 'k': 1, 'cost': 63}, {'i': 2, 'j': 3, 'k': 2, 'cost': 61}, {'i': 2, 'j': 3, 'k': 3, 'cost': 53}, {'i': 2, 'j': 3, 'k': 4, 'cost': 32}, {'i': 2, 'j': 4, 'k': 0, 'cost': 44}, {'i': 2, 'j': 4, 'k': 1, 'cost': 79}, {'i': 2, 'j': 4, 'k': 2, 'cost': 88}, {'i': 2, 'j': 4, 'k': 3, 'cost': 31}, {'i': 2, 'j': 4, 'k': 4, 'cost': 1}, {'i': 3, 'j': 0, 'k': 0, 'cost': 15}, {'i': 3, 'j': 0, 'k': 1, 'cost': 51}, {'i': 3, 'j': 0, 'k': 2, 'cost': 11}, {'i': 3, 'j': 0, 'k': 3, 'cost': 23}, {'i': 3, 'j': 0, 'k': 4, 'cost': 49}, {'i': 3, 'j': 1, 'k': 0, 'cost': 34}, {'i': 3, 'j': 1, 'k': 1, 'cost': 83}, {'i': 3, 'j': 1, 'k': 2, 'cost': 59}, {'i': 3, 'j': 1, 'k': 3, 'cost': 82}, {'i': 3, 'j': 1, 'k': 4, 'cost': 50}, {'i': 3, 'j': 2, 'k': 0, 'cost': 18}, {'i': 3, 'j': 2, 'k': 1, 'cost': 17}, {'i': 3, 'j': 2, 'k': 2, 'cost': 74}, {'i': 3, 'j': 2, 'k': 3, 'cost': 36}, {'i': 3, 'j': 2, 'k': 4, 'cost': 2}, {'i': 3, 'j': 3, 'k': 0, 'cost': 51}, {'i': 3, 'j': 3, 'k': 1, 'cost': 71}, {'i': 3, 'j': 3, 'k': 2, 'cost': 30}, {'i': 3, 'j': 3, 'k': 3, 'cost': 34}, {'i': 3, 'j': 3, 'k': 4, 'cost': 28}, {'i': 3, 'j': 4, 'k': 0, 'cost': 8}, {'i': 3, 'j': 4, 'k': 1, 'cost': 62}, {'i': 3, 'j': 4, 'k': 2, 'cost': 38}, {'i': 3, 'j': 4, 'k': 3, 'cost': 57}, {'i': 3, 'j': 4, 'k': 4, 'cost': 71}, {'i': 4, 'j': 0, 'k': 0, 'cost': 42}, {'i': 4, 'j': 0, 'k': 1, 'cost': 60}, {'i': 4, 'j': 0, 'k': 2, 'cost': 68}, {'i': 4, 'j': 0, 'k': 3, 'cost': 39}, {'i': 4, 'j': 0, 'k': 4, 'cost': 15}, {'i': 4, 'j': 1, 'k': 0, 'cost': 50}, {'i': 4, 'j': 1, 'k': 1, 'cost': 86}, {'i': 4, 'j': 1, 'k': 2, 'cost': 57}, {'i': 4, 'j': 1, 'k': 3, 'cost': 89}, {'i': 4, 'j': 1, 'k': 4, 'cost': 46}, {'i': 4, 'j': 2, 'k': 0, 'cost': 48}, {'i': 4, 'j': 2, 'k': 1, 'cost': 5}, {'i': 4, 'j': 2, 'k': 2, 'cost': 33}, {'i': 4, 'j': 2, 'k': 3, 'cost': 32}, {'i': 4, 'j': 2, 'k': 4, 'cost': 0}, {'i': 4, 'j': 3, 'k': 0, 'cost': 97}, {'i': 4, 'j': 3, 'k': 1, 'cost': 81}, {'i': 4, 'j': 3, 'k': 2, 'cost': 7}, {'i': 4, 'j': 3, 'k': 3, 'cost': 75}, {'i': 4, 'j': 3, 'k': 4, 'cost': 51}, {'i': 4, 'j': 4, 'k': 0, 'cost': 7}, {'i': 4, 'j': 4, 'k': 1, 'cost': 11}, {'i': 4, 'j': 4, 'k': 2, 'cost': 35}, {'i': 4, 'j': 4, 'k': 3, 'cost': 91}, {'i': 4, 'j': 4, 'k': 4, 'cost': 6}]}","[[0, 3, 2], [1, 0, 3], [2, 1, 1], [3, 4, 0], [4, 2, 4]]",5,csv,0
AP3,AP3,"There’s a little catering puzzle at hand: match each table with one appetizer vendor and one dessert vendor, making sure no vendor is assigned to more than one table and no table is left without its two servers. What makes one arrangement nicer than another is the total price — just add each table’s appetizer cost and dessert cost, then add those totals — and the goal is to keep that final sum as small as possible. The specific tables, vendors, and costs appear below.

Here are the 4 tables (IDs 1, 2, 3, 4):

*Meaning: costs form a 3D tensor. For each fixed table_id=i, you are given a appetizer_vendor_id×dessert_vendor_id matrix whose entry at row appetizer_vendor_id=j and column dessert_vendor_id=k equals catering_cost(i,j,k). You must pick exactly one (j,k) for every i, with all appetizer_vendor_id and all dessert_vendor_id used exactly once.*

**catering_cost_tensor (per-table_id markdown matrices)**

## table_id=1
| appetizer_vendor_id\dessert_vendor_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 83 | 10 | 8 | 45 |
| 2 | 82 | 51 | 12 | 37 |
| 3 | 26 | 9 | 20 | 35 |
| 4 | 28 | 93 | 77 | 61 |

## table_id=2
| appetizer_vendor_id\dessert_vendor_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 39 | 52 | 98 | 74 |
| 2 | 3 | 8 | 8 | 95 |
| 3 | 69 | 46 | 25 | 76 |
| 4 | 74 | 10 | 79 | 34 |

## table_id=3
| appetizer_vendor_id\dessert_vendor_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 35 | 28 | 42 | 55 |
| 2 | 88 | 18 | 28 | 59 |
| 3 | 9 | 37 | 55 | 60 |
| 4 | 79 | 18 | 93 | 32 |

## table_id=4
| appetizer_vendor_id\dessert_vendor_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 34 | 9 | 52 | 54 |
| 2 | 15 | 9 | 11 | 8 |
| 3 | 14 | 48 | 84 | 5 |
| 4 | 0 | 67 | 21 | 20 |

Aim to minimize the total cost across all 4 tables.

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

{
  ""solution"": [
    [<table_id>, <appetizer_id>, <dessert_id>],
    ...
  ]
}

Each inner array is one trio: the table, its appetizer vendor, and its dessert vendor. Think of it as a quick form — list one triple per table. This JSON is just a sketch of the shape we want, not the actual answer.

Please be sure to use the exact identifiers from the instance input — no renaming and no new labels.  
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[83, 10, 8, 45], [82, 51, 12, 37], [26, 9, 20, 35], [28, 93, 77, 61]], [[39, 52, 98, 74], [3, 8, 8, 95], [69, 46, 25, 76], [74, 10, 79, 34]], [[35, 28, 42, 55], [88, 18, 28, 59], [9, 37, 55, 60], [79, 18, 93, 32]], [[34, 9, 52, 54], [15, 9, 11, 8], [14, 48, 84, 5], [0, 67, 21, 20]]], 'objective': 34.0}","[[0, 0, 2], [1, 1, 0], [2, 3, 1], [3, 2, 3]]",34.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 83}, {'i': 1, 'j': 1, 'k': 2, 'cost': 10}, {'i': 1, 'j': 1, 'k': 3, 'cost': 8}, {'i': 1, 'j': 1, 'k': 4, 'cost': 45}, {'i': 1, 'j': 2, 'k': 1, 'cost': 82}, {'i': 1, 'j': 2, 'k': 2, 'cost': 51}, {'i': 1, 'j': 2, 'k': 3, 'cost': 12}, {'i': 1, 'j': 2, 'k': 4, 'cost': 37}, {'i': 1, 'j': 3, 'k': 1, 'cost': 26}, {'i': 1, 'j': 3, 'k': 2, 'cost': 9}, {'i': 1, 'j': 3, 'k': 3, 'cost': 20}, {'i': 1, 'j': 3, 'k': 4, 'cost': 35}, {'i': 1, 'j': 4, 'k': 1, 'cost': 28}, {'i': 1, 'j': 4, 'k': 2, 'cost': 93}, {'i': 1, 'j': 4, 'k': 3, 'cost': 77}, {'i': 1, 'j': 4, 'k': 4, 'cost': 61}, {'i': 2, 'j': 1, 'k': 1, 'cost': 39}, {'i': 2, 'j': 1, 'k': 2, 'cost': 52}, {'i': 2, 'j': 1, 'k': 3, 'cost': 98}, {'i': 2, 'j': 1, 'k': 4, 'cost': 74}, {'i': 2, 'j': 2, 'k': 1, 'cost': 3}, {'i': 2, 'j': 2, 'k': 2, 'cost': 8}, {'i': 2, 'j': 2, 'k': 3, 'cost': 8}, {'i': 2, 'j': 2, 'k': 4, 'cost': 95}, {'i': 2, 'j': 3, 'k': 1, 'cost': 69}, {'i': 2, 'j': 3, 'k': 2, 'cost': 46}, {'i': 2, 'j': 3, 'k': 3, 'cost': 25}, {'i': 2, 'j': 3, 'k': 4, 'cost': 76}, {'i': 2, 'j': 4, 'k': 1, 'cost': 74}, {'i': 2, 'j': 4, 'k': 2, 'cost': 10}, {'i': 2, 'j': 4, 'k': 3, 'cost': 79}, {'i': 2, 'j': 4, 'k': 4, 'cost': 34}, {'i': 3, 'j': 1, 'k': 1, 'cost': 35}, {'i': 3, 'j': 1, 'k': 2, 'cost': 28}, {'i': 3, 'j': 1, 'k': 3, 'cost': 42}, {'i': 3, 'j': 1, 'k': 4, 'cost': 55}, {'i': 3, 'j': 2, 'k': 1, 'cost': 88}, {'i': 3, 'j': 2, 'k': 2, 'cost': 18}, {'i': 3, 'j': 2, 'k': 3, 'cost': 28}, {'i': 3, 'j': 2, 'k': 4, 'cost': 59}, {'i': 3, 'j': 3, 'k': 1, 'cost': 9}, {'i': 3, 'j': 3, 'k': 2, 'cost': 37}, {'i': 3, 'j': 3, 'k': 3, 'cost': 55}, {'i': 3, 'j': 3, 'k': 4, 'cost': 60}, {'i': 3, 'j': 4, 'k': 1, 'cost': 79}, {'i': 3, 'j': 4, 'k': 2, 'cost': 18}, {'i': 3, 'j': 4, 'k': 3, 'cost': 93}, {'i': 3, 'j': 4, 'k': 4, 'cost': 32}, {'i': 4, 'j': 1, 'k': 1, 'cost': 34}, {'i': 4, 'j': 1, 'k': 2, 'cost': 9}, {'i': 4, 'j': 1, 'k': 3, 'cost': 52}, {'i': 4, 'j': 1, 'k': 4, 'cost': 54}, {'i': 4, 'j': 2, 'k': 1, 'cost': 15}, {'i': 4, 'j': 2, 'k': 2, 'cost': 9}, {'i': 4, 'j': 2, 'k': 3, 'cost': 11}, {'i': 4, 'j': 2, 'k': 4, 'cost': 8}, {'i': 4, 'j': 3, 'k': 1, 'cost': 14}, {'i': 4, 'j': 3, 'k': 2, 'cost': 48}, {'i': 4, 'j': 3, 'k': 3, 'cost': 84}, {'i': 4, 'j': 3, 'k': 4, 'cost': 5}, {'i': 4, 'j': 4, 'k': 1, 'cost': 0}, {'i': 4, 'j': 4, 'k': 2, 'cost': 67}, {'i': 4, 'j': 4, 'k': 3, 'cost': 21}, {'i': 4, 'j': 4, 'k': 4, 'cost': 20}]}","[[1, 1, 3], [2, 2, 1], [3, 4, 2], [4, 3, 4]]",6,markdown_table,1
AP3,AP3,"I watched the loading crew puzzle over a stack of pallets and a list of trucks and routes — each pallet needs exactly one truck and exactly one delivery route. The trick is that no truck can take more than one pallet and no route gets used twice, so everything has to line up one-for-one. What makes one way better than another is simple: how much fuel all the trips will eat up. For every pallet, check the fuel that truck would use on the chosen route, add those fuel numbers together, and the arrangement with the smallest total fuel is the one to pick. The actual trucks, routes, and fuel numbers are shown below.

# num_pallets=4
# pallet_truck_route_identifiers=0, 1, 2, 3

# Meaning: costs form a 3D tensor. For each fixed pallet_id=i, you are given a truck_id×route_id matrix whose entry at row truck_id=j and column route_id=k equals fuel_cost(i,j,k). You must pick exactly one (j,k) for every i, with all truck_id and all route_id used exactly once.
# fuel_cost_tensor (per-pallet_id markdown matrices)

## pallet_id=0
| truck_id\route_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 70 | 7 | 17 | 62 |
| 1 | 88 | 32 | 69 | 45 |
| 2 | 41 | 90 | 17 | 21 |
| 3 | 92 | 75 | 40 | 55 |

## pallet_id=1
| truck_id\route_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 39 | 37 | 0 | 18 |
| 1 | 25 | 31 | 91 | 14 |
| 2 | 43 | 44 | 98 | 88 |
| 3 | 83 | 10 | 44 | 54 |

## pallet_id=2
| truck_id\route_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 74 | 29 | 40 | 12 |
| 1 | 45 | 82 | 32 | 60 |
| 2 | 34 | 83 | 95 | 78 |
| 3 | 24 | 41 | 2 | 9 |

## pallet_id=3
| truck_id\route_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 90 | 16 | 67 | 98 |
| 1 | 54 | 95 | 57 | 63 |
| 2 | 20 | 19 | 7 | 63 |
| 3 | 6 | 48 | 39 | 83 |

If you want to hand me the matching in a neat, machine-friendly way, just use a tiny JSON snippet like this:

{
  ""solution"": [
    [""<pallet_id>"", ""<truck_id>"", ""<route_id>""],
    ...
  ]
}

Each inner array is one selected triple: the pallet, the truck assigned to it, and the route chosen for that truck. Think of it like a simple form: one line per pallet saying which truck and which route go with it. This JSON is just a sketch of the shape I expect — not the actual answer.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new 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”.""","{'cost_tensor': [[[70, 7, 17, 62], [88, 32, 69, 45], [41, 90, 17, 21], [92, 75, 40, 55]], [[39, 37, 0, 18], [25, 31, 91, 14], [43, 44, 98, 88], [83, 10, 44, 54]], [[74, 29, 40, 12], [45, 82, 32, 60], [34, 83, 95, 78], [24, 41, 2, 9]], [[90, 16, 67, 98], [54, 95, 57, 63], [20, 19, 7, 63], [6, 48, 39, 83]]], 'objective': 43.0}","[[0, 0, 1], [1, 1, 3], [2, 3, 2], [3, 2, 0]]",43.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [0, 1, 2, 3], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 70}, {'i': 0, 'j': 0, 'k': 1, 'cost': 7}, {'i': 0, 'j': 0, 'k': 2, 'cost': 17}, {'i': 0, 'j': 0, 'k': 3, 'cost': 62}, {'i': 0, 'j': 1, 'k': 0, 'cost': 88}, {'i': 0, 'j': 1, 'k': 1, 'cost': 32}, {'i': 0, 'j': 1, 'k': 2, 'cost': 69}, {'i': 0, 'j': 1, 'k': 3, 'cost': 45}, {'i': 0, 'j': 2, 'k': 0, 'cost': 41}, {'i': 0, 'j': 2, 'k': 1, 'cost': 90}, {'i': 0, 'j': 2, 'k': 2, 'cost': 17}, {'i': 0, 'j': 2, 'k': 3, 'cost': 21}, {'i': 0, 'j': 3, 'k': 0, 'cost': 92}, {'i': 0, 'j': 3, 'k': 1, 'cost': 75}, {'i': 0, 'j': 3, 'k': 2, 'cost': 40}, {'i': 0, 'j': 3, 'k': 3, 'cost': 55}, {'i': 1, 'j': 0, 'k': 0, 'cost': 39}, {'i': 1, 'j': 0, 'k': 1, 'cost': 37}, {'i': 1, 'j': 0, 'k': 2, 'cost': 0}, {'i': 1, 'j': 0, 'k': 3, 'cost': 18}, {'i': 1, 'j': 1, 'k': 0, 'cost': 25}, {'i': 1, 'j': 1, 'k': 1, 'cost': 31}, {'i': 1, 'j': 1, 'k': 2, 'cost': 91}, {'i': 1, 'j': 1, 'k': 3, 'cost': 14}, {'i': 1, 'j': 2, 'k': 0, 'cost': 43}, {'i': 1, 'j': 2, 'k': 1, 'cost': 44}, {'i': 1, 'j': 2, 'k': 2, 'cost': 98}, {'i': 1, 'j': 2, 'k': 3, 'cost': 88}, {'i': 1, 'j': 3, 'k': 0, 'cost': 83}, {'i': 1, 'j': 3, 'k': 1, 'cost': 10}, {'i': 1, 'j': 3, 'k': 2, 'cost': 44}, {'i': 1, 'j': 3, 'k': 3, 'cost': 54}, {'i': 2, 'j': 0, 'k': 0, 'cost': 74}, {'i': 2, 'j': 0, 'k': 1, 'cost': 29}, {'i': 2, 'j': 0, 'k': 2, 'cost': 40}, {'i': 2, 'j': 0, 'k': 3, 'cost': 12}, {'i': 2, 'j': 1, 'k': 0, 'cost': 45}, {'i': 2, 'j': 1, 'k': 1, 'cost': 82}, {'i': 2, 'j': 1, 'k': 2, 'cost': 32}, {'i': 2, 'j': 1, 'k': 3, 'cost': 60}, {'i': 2, 'j': 2, 'k': 0, 'cost': 34}, {'i': 2, 'j': 2, 'k': 1, 'cost': 83}, {'i': 2, 'j': 2, 'k': 2, 'cost': 95}, {'i': 2, 'j': 2, 'k': 3, 'cost': 78}, {'i': 2, 'j': 3, 'k': 0, 'cost': 24}, {'i': 2, 'j': 3, 'k': 1, 'cost': 41}, {'i': 2, 'j': 3, 'k': 2, 'cost': 2}, {'i': 2, 'j': 3, 'k': 3, 'cost': 9}, {'i': 3, 'j': 0, 'k': 0, 'cost': 90}, {'i': 3, 'j': 0, 'k': 1, 'cost': 16}, {'i': 3, 'j': 0, 'k': 2, 'cost': 67}, {'i': 3, 'j': 0, 'k': 3, 'cost': 98}, {'i': 3, 'j': 1, 'k': 0, 'cost': 54}, {'i': 3, 'j': 1, 'k': 1, 'cost': 95}, {'i': 3, 'j': 1, 'k': 2, 'cost': 57}, {'i': 3, 'j': 1, 'k': 3, 'cost': 63}, {'i': 3, 'j': 2, 'k': 0, 'cost': 20}, {'i': 3, 'j': 2, 'k': 1, 'cost': 19}, {'i': 3, 'j': 2, 'k': 2, 'cost': 7}, {'i': 3, 'j': 2, 'k': 3, 'cost': 63}, {'i': 3, 'j': 3, 'k': 0, 'cost': 6}, {'i': 3, 'j': 3, 'k': 1, 'cost': 48}, {'i': 3, 'j': 3, 'k': 2, 'cost': 39}, {'i': 3, 'j': 3, 'k': 3, 'cost': 83}]}","[[0, 0, 1], [1, 1, 3], [2, 3, 2], [3, 2, 0]]",7,csv,0
AP3,AP3,"Picture this: a closet of outfits and a drawer of accessories, and a team of clients who each need one of each, with each outfit and accessory going to exactly one person. Every possible assignment carries a price for each client (outfit plus accessory), and the final cost is the sum of all those client costs — the aim is to make that grand total as small as possible while still giving everyone one outfit and one accessory. No sharing, no extras left behind. The specific items and their costs are shown below.

# num_clients=4
# index_ids=1, 2, 3, 4

# Meaning: costs form a 3D tensor. For each fixed client_id=i, you are given a outfit_id×accessory_id matrix whose entry at row outfit_id=j and column accessory_id=k equals combined_cost(i,j,k). You must pick exactly one (j,k) for every i, with all outfit_id and all accessory_id used exactly once.
# combined_cost_tensor (per-client_id markdown matrices)

## client_id=1
| outfit_id\accessory_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 41 | 68 | 31 | 2 |
| 2 | 5 | 2 | 38 | 8 |
| 3 | 84 | 62 | 2 | 99 |
| 4 | 84 | 5 | 58 | 55 |

## client_id=2
| outfit_id\accessory_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 16 | 73 | 59 | 90 |
| 2 | 35 | 68 | 95 | 78 |
| 3 | 31 | 38 | 36 | 86 |
| 4 | 22 | 81 | 87 | 57 |

## client_id=3
| outfit_id\accessory_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 1 | 96 | 77 | 86 |
| 2 | 6 | 61 | 66 | 1 |
| 3 | 20 | 49 | 17 | 29 |
| 4 | 0 | 58 | 97 | 57 |

## client_id=4
| outfit_id\accessory_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 98 | 1 | 99 | 98 |
| 2 | 0 | 24 | 70 | 53 |
| 3 | 49 | 53 | 90 | 21 |
| 4 | 97 | 16 | 11 | 68 |

Oh, and one more thing — when you send the assignment back, it's handy if you use a tiny JSON sketch like this so everything's clean and easy to check:

{
  ""solution"": [
    [<client_id>, <outfit_id>, <accessory_id>]
  ]
}

It's just a simple list of triples: each inner array is one client with their chosen outfit and accessory. The ""solution"" array should contain one triple for each client. This is only the shape I expect — not the actual answer.

Please make sure you use the exact identifiers from the instance input, without renaming or inventing new labels. To be clear:
- 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”.""","{'cost_tensor': [[[41, 68, 31, 2], [5, 2, 38, 8], [84, 62, 2, 99], [84, 5, 58, 55]], [[16, 73, 59, 90], [35, 68, 95, 78], [31, 38, 36, 86], [22, 81, 87, 57]], [[1, 96, 77, 86], [6, 61, 66, 1], [20, 49, 17, 29], [0, 58, 97, 57]], [[98, 1, 99, 98], [0, 24, 70, 53], [49, 53, 90, 21], [97, 16, 11, 68]]], 'objective': 26.0}","[[0, 2, 2], [1, 3, 0], [2, 1, 3], [3, 0, 1]]",26.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 41}, {'i': 1, 'j': 1, 'k': 2, 'cost': 68}, {'i': 1, 'j': 1, 'k': 3, 'cost': 31}, {'i': 1, 'j': 1, 'k': 4, 'cost': 2}, {'i': 1, 'j': 2, 'k': 1, 'cost': 5}, {'i': 1, 'j': 2, 'k': 2, 'cost': 2}, {'i': 1, 'j': 2, 'k': 3, 'cost': 38}, {'i': 1, 'j': 2, 'k': 4, 'cost': 8}, {'i': 1, 'j': 3, 'k': 1, 'cost': 84}, {'i': 1, 'j': 3, 'k': 2, 'cost': 62}, {'i': 1, 'j': 3, 'k': 3, 'cost': 2}, {'i': 1, 'j': 3, 'k': 4, 'cost': 99}, {'i': 1, 'j': 4, 'k': 1, 'cost': 84}, {'i': 1, 'j': 4, 'k': 2, 'cost': 5}, {'i': 1, 'j': 4, 'k': 3, 'cost': 58}, {'i': 1, 'j': 4, 'k': 4, 'cost': 55}, {'i': 2, 'j': 1, 'k': 1, 'cost': 16}, {'i': 2, 'j': 1, 'k': 2, 'cost': 73}, {'i': 2, 'j': 1, 'k': 3, 'cost': 59}, {'i': 2, 'j': 1, 'k': 4, 'cost': 90}, {'i': 2, 'j': 2, 'k': 1, 'cost': 35}, {'i': 2, 'j': 2, 'k': 2, 'cost': 68}, {'i': 2, 'j': 2, 'k': 3, 'cost': 95}, {'i': 2, 'j': 2, 'k': 4, 'cost': 78}, {'i': 2, 'j': 3, 'k': 1, 'cost': 31}, {'i': 2, 'j': 3, 'k': 2, 'cost': 38}, {'i': 2, 'j': 3, 'k': 3, 'cost': 36}, {'i': 2, 'j': 3, 'k': 4, 'cost': 86}, {'i': 2, 'j': 4, 'k': 1, 'cost': 22}, {'i': 2, 'j': 4, 'k': 2, 'cost': 81}, {'i': 2, 'j': 4, 'k': 3, 'cost': 87}, {'i': 2, 'j': 4, 'k': 4, 'cost': 57}, {'i': 3, 'j': 1, 'k': 1, 'cost': 1}, {'i': 3, 'j': 1, 'k': 2, 'cost': 96}, {'i': 3, 'j': 1, 'k': 3, 'cost': 77}, {'i': 3, 'j': 1, 'k': 4, 'cost': 86}, {'i': 3, 'j': 2, 'k': 1, 'cost': 6}, {'i': 3, 'j': 2, 'k': 2, 'cost': 61}, {'i': 3, 'j': 2, 'k': 3, 'cost': 66}, {'i': 3, 'j': 2, 'k': 4, 'cost': 1}, {'i': 3, 'j': 3, 'k': 1, 'cost': 20}, {'i': 3, 'j': 3, 'k': 2, 'cost': 49}, {'i': 3, 'j': 3, 'k': 3, 'cost': 17}, {'i': 3, 'j': 3, 'k': 4, 'cost': 29}, {'i': 3, 'j': 4, 'k': 1, 'cost': 0}, {'i': 3, 'j': 4, 'k': 2, 'cost': 58}, {'i': 3, 'j': 4, 'k': 3, 'cost': 97}, {'i': 3, 'j': 4, 'k': 4, 'cost': 57}, {'i': 4, 'j': 1, 'k': 1, 'cost': 98}, {'i': 4, 'j': 1, 'k': 2, 'cost': 1}, {'i': 4, 'j': 1, 'k': 3, 'cost': 99}, {'i': 4, 'j': 1, 'k': 4, 'cost': 98}, {'i': 4, 'j': 2, 'k': 1, 'cost': 0}, {'i': 4, 'j': 2, 'k': 2, 'cost': 24}, {'i': 4, 'j': 2, 'k': 3, 'cost': 70}, {'i': 4, 'j': 2, 'k': 4, 'cost': 53}, {'i': 4, 'j': 3, 'k': 1, 'cost': 49}, {'i': 4, 'j': 3, 'k': 2, 'cost': 53}, {'i': 4, 'j': 3, 'k': 3, 'cost': 90}, {'i': 4, 'j': 3, 'k': 4, 'cost': 21}, {'i': 4, 'j': 4, 'k': 1, 'cost': 97}, {'i': 4, 'j': 4, 'k': 2, 'cost': 16}, {'i': 4, 'j': 4, 'k': 3, 'cost': 11}, {'i': 4, 'j': 4, 'k': 4, 'cost': 68}]}","[[1, 3, 3], [2, 4, 1], [3, 2, 4], [4, 1, 2]]",8,csv,1
AP3,AP3,"I remember helping put together a tiny music festival where every band needed exactly one stage and exactly one time slot, and every stage and every time had to host just one band—no double bookings and no empty spots. The job was to pick which stage-and-time pair each band gets so that, when looking at the expected clash for each band, the total of those clash costs (just add up each band's expected conflict cost for its assigned stage and time) is as small as possible. The concrete lineup and the numbers for those expected clashes are shown below.

I remember helping put together that tiny festival for 5 bands (and the same number of stages and time slots); the ordered identifiers are 1, 2, 3, 4, 5.

*Meaning: costs form a 3D tensor. For each fixed band_id=i, you are given a stage_id×time_slot_id matrix whose entry at row stage_id=j and column time_slot_id=k equals expected_conflict_cost(i,j,k). You must pick exactly one (j,k) for every i, with all stage_id and all time_slot_id used exactly once.*

**expected_conflict_cost_tensor (per-band_id markdown matrices)**

## band_id=1
| stage_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 25 | 8 | 95 | 0 | 51 |
| 2 | 37 | 6 | 2 | 24 | 34 |
| 3 | 71 | 76 | 58 | 68 | 40 |
| 4 | 37 | 34 | 29 | 7 | 22 |
| 5 | 73 | 9 | 94 | 29 | 90 |

## band_id=2
| stage_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 58 | 56 | 79 | 45 | 33 |
| 2 | 49 | 55 | 65 | 48 | 54 |
| 3 | 62 | 61 | 16 | 87 | 31 |
| 4 | 60 | 16 | 56 | 8 | 53 |
| 5 | 5 | 63 | 94 | 68 | 10 |

## band_id=3
| stage_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 74 | 12 | 1 | 90 | 99 |
| 2 | 98 | 65 | 21 | 85 | 75 |
| 3 | 38 | 42 | 89 | 21 | 14 |
| 4 | 20 | 25 | 94 | 39 | 69 |
| 5 | 35 | 91 | 99 | 99 | 30 |

## band_id=4
| stage_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 94 | 53 | 96 | 35 | 44 |
| 2 | 47 | 67 | 77 | 16 | 55 |
| 3 | 68 | 97 | 14 | 32 | 39 |
| 4 | 92 | 90 | 26 | 32 | 12 |
| 5 | 29 | 34 | 95 | 36 | 11 |

## band_id=5
| stage_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 43 | 2 | 65 | 34 | 79 |
| 2 | 81 | 48 | 73 | 57 | 18 |
| 3 | 67 | 98 | 12 | 21 | 87 |
| 4 | 28 | 4 | 68 | 54 | 28 |
| 5 | 73 | 29 | 51 | 63 | 61 |

I then used these numbers to assign exactly one stage-and-time pair to each band so the sum of expected conflict costs is as small as possible.

And to keep things tidy when you send the final assignment back, here’s the little JSON shape I like to use — just a quick sketch of what your answer should look like.

{
  ""solution"": [
    [<band_id>, <stage_id>, <time_slot_id>],
    ...
  ]
}

The ""solution"" entry is just a list of triples: each inner list picks one band, the stage they play on, and the time slot they get. Think of each triple as ""band goes to this stage at this time."" This block is only a sketch of the expected shape, not the actual answer.

Please make sure you use the exact identifiers from the instance input — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[25, 8, 95, 0, 51], [37, 6, 2, 24, 34], [71, 76, 58, 68, 40], [37, 34, 29, 7, 22], [73, 9, 94, 29, 90]], [[58, 56, 79, 45, 33], [49, 55, 65, 48, 54], [62, 61, 16, 87, 31], [60, 16, 56, 8, 53], [5, 63, 94, 68, 10]], [[74, 12, 1, 90, 99], [98, 65, 21, 85, 75], [38, 42, 89, 21, 14], [20, 25, 94, 39, 69], [35, 91, 99, 99, 30]], [[94, 53, 96, 35, 44], [47, 67, 77, 16, 55], [68, 97, 14, 32, 39], [92, 90, 26, 32, 12], [29, 34, 95, 36, 11]], [[43, 2, 65, 34, 79], [81, 48, 73, 57, 18], [67, 98, 12, 21, 87], [28, 4, 68, 54, 28], [73, 29, 51, 63, 61]]], 'objective': 42.0}","[[0, 1, 2], [1, 4, 0], [2, 2, 3], [3, 3, 4], [4, 0, 1]]",42.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [1, 2, 3, 4, 5], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 25}, {'i': 1, 'j': 1, 'k': 2, 'cost': 8}, {'i': 1, 'j': 1, 'k': 3, 'cost': 95}, {'i': 1, 'j': 1, 'k': 4, 'cost': 0}, {'i': 1, 'j': 1, 'k': 5, 'cost': 51}, {'i': 1, 'j': 2, 'k': 1, 'cost': 37}, {'i': 1, 'j': 2, 'k': 2, 'cost': 6}, {'i': 1, 'j': 2, 'k': 3, 'cost': 2}, {'i': 1, 'j': 2, 'k': 4, 'cost': 24}, {'i': 1, 'j': 2, 'k': 5, 'cost': 34}, {'i': 1, 'j': 3, 'k': 1, 'cost': 71}, {'i': 1, 'j': 3, 'k': 2, 'cost': 76}, {'i': 1, 'j': 3, 'k': 3, 'cost': 58}, {'i': 1, 'j': 3, 'k': 4, 'cost': 68}, {'i': 1, 'j': 3, 'k': 5, 'cost': 40}, {'i': 1, 'j': 4, 'k': 1, 'cost': 37}, {'i': 1, 'j': 4, 'k': 2, 'cost': 34}, {'i': 1, 'j': 4, 'k': 3, 'cost': 29}, {'i': 1, 'j': 4, 'k': 4, 'cost': 7}, {'i': 1, 'j': 4, 'k': 5, 'cost': 22}, {'i': 1, 'j': 5, 'k': 1, 'cost': 73}, {'i': 1, 'j': 5, 'k': 2, 'cost': 9}, {'i': 1, 'j': 5, 'k': 3, 'cost': 94}, {'i': 1, 'j': 5, 'k': 4, 'cost': 29}, {'i': 1, 'j': 5, 'k': 5, 'cost': 90}, {'i': 2, 'j': 1, 'k': 1, 'cost': 58}, {'i': 2, 'j': 1, 'k': 2, 'cost': 56}, {'i': 2, 'j': 1, 'k': 3, 'cost': 79}, {'i': 2, 'j': 1, 'k': 4, 'cost': 45}, {'i': 2, 'j': 1, 'k': 5, 'cost': 33}, {'i': 2, 'j': 2, 'k': 1, 'cost': 49}, {'i': 2, 'j': 2, 'k': 2, 'cost': 55}, {'i': 2, 'j': 2, 'k': 3, 'cost': 65}, {'i': 2, 'j': 2, 'k': 4, 'cost': 48}, {'i': 2, 'j': 2, 'k': 5, 'cost': 54}, {'i': 2, 'j': 3, 'k': 1, 'cost': 62}, {'i': 2, 'j': 3, 'k': 2, 'cost': 61}, {'i': 2, 'j': 3, 'k': 3, 'cost': 16}, {'i': 2, 'j': 3, 'k': 4, 'cost': 87}, {'i': 2, 'j': 3, 'k': 5, 'cost': 31}, {'i': 2, 'j': 4, 'k': 1, 'cost': 60}, {'i': 2, 'j': 4, 'k': 2, 'cost': 16}, {'i': 2, 'j': 4, 'k': 3, 'cost': 56}, {'i': 2, 'j': 4, 'k': 4, 'cost': 8}, {'i': 2, 'j': 4, 'k': 5, 'cost': 53}, {'i': 2, 'j': 5, 'k': 1, 'cost': 5}, {'i': 2, 'j': 5, 'k': 2, 'cost': 63}, {'i': 2, 'j': 5, 'k': 3, 'cost': 94}, {'i': 2, 'j': 5, 'k': 4, 'cost': 68}, {'i': 2, 'j': 5, 'k': 5, 'cost': 10}, {'i': 3, 'j': 1, 'k': 1, 'cost': 74}, {'i': 3, 'j': 1, 'k': 2, 'cost': 12}, {'i': 3, 'j': 1, 'k': 3, 'cost': 1}, {'i': 3, 'j': 1, 'k': 4, 'cost': 90}, {'i': 3, 'j': 1, 'k': 5, 'cost': 99}, {'i': 3, 'j': 2, 'k': 1, 'cost': 98}, {'i': 3, 'j': 2, 'k': 2, 'cost': 65}, {'i': 3, 'j': 2, 'k': 3, 'cost': 21}, {'i': 3, 'j': 2, 'k': 4, 'cost': 85}, {'i': 3, 'j': 2, 'k': 5, 'cost': 75}, {'i': 3, 'j': 3, 'k': 1, 'cost': 38}, {'i': 3, 'j': 3, 'k': 2, 'cost': 42}, {'i': 3, 'j': 3, 'k': 3, 'cost': 89}, {'i': 3, 'j': 3, 'k': 4, 'cost': 21}, {'i': 3, 'j': 3, 'k': 5, 'cost': 14}, {'i': 3, 'j': 4, 'k': 1, 'cost': 20}, {'i': 3, 'j': 4, 'k': 2, 'cost': 25}, {'i': 3, 'j': 4, 'k': 3, 'cost': 94}, {'i': 3, 'j': 4, 'k': 4, 'cost': 39}, {'i': 3, 'j': 4, 'k': 5, 'cost': 69}, {'i': 3, 'j': 5, 'k': 1, 'cost': 35}, {'i': 3, 'j': 5, 'k': 2, 'cost': 91}, {'i': 3, 'j': 5, 'k': 3, 'cost': 99}, {'i': 3, 'j': 5, 'k': 4, 'cost': 99}, {'i': 3, 'j': 5, 'k': 5, 'cost': 30}, {'i': 4, 'j': 1, 'k': 1, 'cost': 94}, {'i': 4, 'j': 1, 'k': 2, 'cost': 53}, {'i': 4, 'j': 1, 'k': 3, 'cost': 96}, {'i': 4, 'j': 1, 'k': 4, 'cost': 35}, {'i': 4, 'j': 1, 'k': 5, 'cost': 44}, {'i': 4, 'j': 2, 'k': 1, 'cost': 47}, {'i': 4, 'j': 2, 'k': 2, 'cost': 67}, {'i': 4, 'j': 2, 'k': 3, 'cost': 77}, {'i': 4, 'j': 2, 'k': 4, 'cost': 16}, {'i': 4, 'j': 2, 'k': 5, 'cost': 55}, {'i': 4, 'j': 3, 'k': 1, 'cost': 68}, {'i': 4, 'j': 3, 'k': 2, 'cost': 97}, {'i': 4, 'j': 3, 'k': 3, 'cost': 14}, {'i': 4, 'j': 3, 'k': 4, 'cost': 32}, {'i': 4, 'j': 3, 'k': 5, 'cost': 39}, {'i': 4, 'j': 4, 'k': 1, 'cost': 92}, {'i': 4, 'j': 4, 'k': 2, 'cost': 90}, {'i': 4, 'j': 4, 'k': 3, 'cost': 26}, {'i': 4, 'j': 4, 'k': 4, 'cost': 32}, {'i': 4, 'j': 4, 'k': 5, 'cost': 12}, {'i': 4, 'j': 5, 'k': 1, 'cost': 29}, {'i': 4, 'j': 5, 'k': 2, 'cost': 34}, {'i': 4, 'j': 5, 'k': 3, 'cost': 95}, {'i': 4, 'j': 5, 'k': 4, 'cost': 36}, {'i': 4, 'j': 5, 'k': 5, 'cost': 11}, {'i': 5, 'j': 1, 'k': 1, 'cost': 43}, {'i': 5, 'j': 1, 'k': 2, 'cost': 2}, {'i': 5, 'j': 1, 'k': 3, 'cost': 65}, {'i': 5, 'j': 1, 'k': 4, 'cost': 34}, {'i': 5, 'j': 1, 'k': 5, 'cost': 79}, {'i': 5, 'j': 2, 'k': 1, 'cost': 81}, {'i': 5, 'j': 2, 'k': 2, 'cost': 48}, {'i': 5, 'j': 2, 'k': 3, 'cost': 73}, {'i': 5, 'j': 2, 'k': 4, 'cost': 57}, {'i': 5, 'j': 2, 'k': 5, 'cost': 18}, {'i': 5, 'j': 3, 'k': 1, 'cost': 67}, {'i': 5, 'j': 3, 'k': 2, 'cost': 98}, {'i': 5, 'j': 3, 'k': 3, 'cost': 12}, {'i': 5, 'j': 3, 'k': 4, 'cost': 21}, {'i': 5, 'j': 3, 'k': 5, 'cost': 87}, {'i': 5, 'j': 4, 'k': 1, 'cost': 28}, {'i': 5, 'j': 4, 'k': 2, 'cost': 4}, {'i': 5, 'j': 4, 'k': 3, 'cost': 68}, {'i': 5, 'j': 4, 'k': 4, 'cost': 54}, {'i': 5, 'j': 4, 'k': 5, 'cost': 28}, {'i': 5, 'j': 5, 'k': 1, 'cost': 73}, {'i': 5, 'j': 5, 'k': 2, 'cost': 29}, {'i': 5, 'j': 5, 'k': 3, 'cost': 51}, {'i': 5, 'j': 5, 'k': 4, 'cost': 63}, {'i': 5, 'j': 5, 'k': 5, 'cost': 61}]}","[[1, 2, 3], [2, 5, 1], [3, 3, 4], [4, 4, 5], [5, 1, 2]]",9,markdown_table,1
AP3,AP3,"We joked that it was like seating people for a dinner — every document needs a single translator and a single language combination at the table. Each possible match has a fee, and the whole idea is to make the final bill as small as it can be by summing the fees for all chosen matches. Rules of the dinner: every document gets one seat, every translator gets one seat, and every language pair is used only once. The exact list of documents, translators, language pairs, and their costs follows below.

{
  ""num_documents"": 5,
  ""index_identifiers"": [
    ""A"",
    ""B"",
    ""C"",
    ""D"",
    ""E""
  ]
}

# Meaning: costs form a 3D tensor. For each fixed document_id=i, you are given a translator_id×language_pair_id matrix whose entry at row translator_id=j and column language_pair_id=k equals translation_fee(i,j,k). You must pick exactly one (j,k) for every i, with all translator_id and all language_pair_id used exactly once.
# translation_fee_tensor (per-document_id markdown matrices)

## document_id=A
| translator_id\language_pair_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 19 | 58 | 16 | 12 | 56 |
| B | 33 | 90 | 66 | 84 | 62 |
| C | 18 | 76 | 85 | 51 | 24 |
| D | 58 | 30 | 1 | 32 | 56 |
| E | 37 | 94 | 14 | 63 | 15 |

## document_id=B
| translator_id\language_pair_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 7 | 28 | 25 | 83 | 92 |
| B | 6 | 20 | 19 | 4 | 69 |
| C | 30 | 2 | 31 | 23 | 9 |
| D | 25 | 58 | 80 | 53 | 37 |
| E | 98 | 26 | 33 | 42 | 19 |

## document_id=C
| translator_id\language_pair_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 36 | 21 | 65 | 21 | 91 |
| B | 67 | 81 | 84 | 71 | 34 |
| C | 28 | 47 | 32 | 37 | 75 |
| D | 63 | 92 | 75 | 63 | 35 |
| E | 33 | 94 | 85 | 83 | 32 |

## document_id=D
| translator_id\language_pair_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 35 | 32 | 96 | 49 | 70 |
| B | 10 | 11 | 42 | 13 | 80 |
| C | 94 | 84 | 90 | 49 | 40 |
| D | 59 | 63 | 72 | 19 | 29 |
| E | 11 | 58 | 53 | 29 | 58 |

## document_id=E
| translator_id\language_pair_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 69 | 11 | 65 | 88 | 88 |
| B | 56 | 80 | 43 | 66 | 71 |
| C | 12 | 72 | 82 | 68 | 29 |
| D | 98 | 36 | 34 | 66 | 50 |
| E | 82 | 48 | 43 | 38 | 86 |

I'll keep the final answer in a simple JSON shape so it's easy to check automatically. Here’s the sketch of how I want the solution formatted:

{
  ""solution"": [
    [<doc_id>, <translator_id>, <langpair_id>],
    ...
  ]
}

This says ""solution"" is a list of triples. Each triple is one document matched with one translator and one language pair (in that order). It's just a quick form — the JSON above is the expected shape, not the actual assignment itself.

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”.""","{'cost_tensor': [[[19, 58, 16, 12, 56], [33, 90, 66, 84, 62], [18, 76, 85, 51, 24], [58, 30, 1, 32, 56], [37, 94, 14, 63, 15]], [[7, 28, 25, 83, 92], [6, 20, 19, 4, 69], [30, 2, 31, 23, 9], [25, 58, 80, 53, 37], [98, 26, 33, 42, 19]], [[36, 21, 65, 21, 91], [67, 81, 84, 71, 34], [28, 47, 32, 37, 75], [63, 92, 75, 63, 35], [33, 94, 85, 83, 32]], [[35, 32, 96, 49, 70], [10, 11, 42, 13, 80], [94, 84, 90, 49, 40], [59, 63, 72, 19, 29], [11, 58, 53, 29, 58]], [[69, 11, 65, 88, 88], [56, 80, 43, 66, 71], [12, 72, 82, 68, 29], [98, 36, 34, 66, 50], [82, 48, 43, 38, 86]]], 'objective': 64.0}","[[0, 3, 2], [1, 4, 4], [2, 0, 3], [3, 1, 1], [4, 2, 0]]",64.0,"{'problem_type': 'AP3', 'n': 5, 'ids': ['A', 'B', 'C', 'D', 'E'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 19}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 58}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 16}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 12}, {'i': 'A', 'j': 'A', 'k': 'E', 'cost': 56}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 33}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 90}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 66}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 84}, {'i': 'A', 'j': 'B', 'k': 'E', 'cost': 62}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 18}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 76}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 85}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 51}, {'i': 'A', 'j': 'C', 'k': 'E', 'cost': 24}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 58}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 30}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 1}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 32}, {'i': 'A', 'j': 'D', 'k': 'E', 'cost': 56}, {'i': 'A', 'j': 'E', 'k': 'A', 'cost': 37}, {'i': 'A', 'j': 'E', 'k': 'B', 'cost': 94}, {'i': 'A', 'j': 'E', 'k': 'C', 'cost': 14}, {'i': 'A', 'j': 'E', 'k': 'D', 'cost': 63}, {'i': 'A', 'j': 'E', 'k': 'E', 'cost': 15}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 7}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 28}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 25}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 83}, {'i': 'B', 'j': 'A', 'k': 'E', 'cost': 92}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 6}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 20}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 19}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 4}, {'i': 'B', 'j': 'B', 'k': 'E', 'cost': 69}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 30}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 2}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 31}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 23}, {'i': 'B', 'j': 'C', 'k': 'E', 'cost': 9}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 25}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 58}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 80}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 53}, {'i': 'B', 'j': 'D', 'k': 'E', 'cost': 37}, {'i': 'B', 'j': 'E', 'k': 'A', 'cost': 98}, {'i': 'B', 'j': 'E', 'k': 'B', 'cost': 26}, {'i': 'B', 'j': 'E', 'k': 'C', 'cost': 33}, {'i': 'B', 'j': 'E', 'k': 'D', 'cost': 42}, {'i': 'B', 'j': 'E', 'k': 'E', 'cost': 19}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 36}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 21}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 65}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 21}, {'i': 'C', 'j': 'A', 'k': 'E', 'cost': 91}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 67}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 81}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 84}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 71}, {'i': 'C', 'j': 'B', 'k': 'E', 'cost': 34}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 28}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 47}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 32}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 37}, {'i': 'C', 'j': 'C', 'k': 'E', 'cost': 75}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 63}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 92}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 75}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 63}, {'i': 'C', 'j': 'D', 'k': 'E', 'cost': 35}, {'i': 'C', 'j': 'E', 'k': 'A', 'cost': 33}, {'i': 'C', 'j': 'E', 'k': 'B', 'cost': 94}, {'i': 'C', 'j': 'E', 'k': 'C', 'cost': 85}, {'i': 'C', 'j': 'E', 'k': 'D', 'cost': 83}, {'i': 'C', 'j': 'E', 'k': 'E', 'cost': 32}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 35}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 32}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 96}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 49}, {'i': 'D', 'j': 'A', 'k': 'E', 'cost': 70}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 10}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 11}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 42}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 13}, {'i': 'D', 'j': 'B', 'k': 'E', 'cost': 80}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 94}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 84}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 90}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 49}, {'i': 'D', 'j': 'C', 'k': 'E', 'cost': 40}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 59}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 63}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 72}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 19}, {'i': 'D', 'j': 'D', 'k': 'E', 'cost': 29}, {'i': 'D', 'j': 'E', 'k': 'A', 'cost': 11}, {'i': 'D', 'j': 'E', 'k': 'B', 'cost': 58}, {'i': 'D', 'j': 'E', 'k': 'C', 'cost': 53}, {'i': 'D', 'j': 'E', 'k': 'D', 'cost': 29}, {'i': 'D', 'j': 'E', 'k': 'E', 'cost': 58}, {'i': 'E', 'j': 'A', 'k': 'A', 'cost': 69}, {'i': 'E', 'j': 'A', 'k': 'B', 'cost': 11}, {'i': 'E', 'j': 'A', 'k': 'C', 'cost': 65}, {'i': 'E', 'j': 'A', 'k': 'D', 'cost': 88}, {'i': 'E', 'j': 'A', 'k': 'E', 'cost': 88}, {'i': 'E', 'j': 'B', 'k': 'A', 'cost': 56}, {'i': 'E', 'j': 'B', 'k': 'B', 'cost': 80}, {'i': 'E', 'j': 'B', 'k': 'C', 'cost': 43}, {'i': 'E', 'j': 'B', 'k': 'D', 'cost': 66}, {'i': 'E', 'j': 'B', 'k': 'E', 'cost': 71}, {'i': 'E', 'j': 'C', 'k': 'A', 'cost': 12}, {'i': 'E', 'j': 'C', 'k': 'B', 'cost': 72}, {'i': 'E', 'j': 'C', 'k': 'C', 'cost': 82}, {'i': 'E', 'j': 'C', 'k': 'D', 'cost': 68}, {'i': 'E', 'j': 'C', 'k': 'E', 'cost': 29}, {'i': 'E', 'j': 'D', 'k': 'A', 'cost': 98}, {'i': 'E', 'j': 'D', 'k': 'B', 'cost': 36}, {'i': 'E', 'j': 'D', 'k': 'C', 'cost': 34}, {'i': 'E', 'j': 'D', 'k': 'D', 'cost': 66}, {'i': 'E', 'j': 'D', 'k': 'E', 'cost': 50}, {'i': 'E', 'j': 'E', 'k': 'A', 'cost': 82}, {'i': 'E', 'j': 'E', 'k': 'B', 'cost': 48}, {'i': 'E', 'j': 'E', 'k': 'C', 'cost': 43}, {'i': 'E', 'j': 'E', 'k': 'D', 'cost': 38}, {'i': 'E', 'j': 'E', 'k': 'E', 'cost': 86}]}","[['A', 'D', 'C'], ['B', 'E', 'E'], ['C', 'A', 'D'], ['D', 'B', 'B'], ['E', 'C', 'A']]",10,json,names
AP3,AP3,"There’s a morning rush at a print shop: a stack of customer jobs, a row of printers, and a row of finishing stations. The trick is to pair each job with one printer and one finishing station, making sure every printer is used by exactly one job and every finisher by exactly one job — nothing gets assigned twice or left out. One plan is better than another if it gets all the work done sooner; you can tell by adding each job’s printing time and its finishing time and summing those up for the whole batch, then choosing the assignment with the lowest total. The specific job times and machine options appear below.

They are listed here for the 4 orders 0, 1, 2, 3.

*Meaning: costs form a 3D tensor. For each fixed order_id=i, you are given a printer_id×finisher_id matrix whose entry at row printer_id=j and column finisher_id=k equals total_processing_time(i,j,k). You must pick exactly one (j,k) for every i, with all printer_id and all finisher_id used exactly once.*

**total_processing_time_tensor (per-order_id markdown matrices)**

## order_id=0
| printer_id\finisher_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 98 | 79 | 2 | 48 |
| 1 | 43 | 50 | 60 | 60 |
| 2 | 91 | 80 | 53 | 30 |
| 3 | 25 | 19 | 84 | 88 |

## order_id=1
| printer_id\finisher_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 48 | 70 | 18 | 58 |
| 1 | 19 | 44 | 91 | 98 |
| 2 | 42 | 7 | 52 | 41 |
| 3 | 6 | 0 | 68 | 16 |

## order_id=2
| printer_id\finisher_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 7 | 0 | 0 | 74 |
| 1 | 1 | 58 | 44 | 77 |
| 2 | 11 | 91 | 92 | 34 |
| 3 | 99 | 26 | 56 | 85 |

## order_id=3
| printer_id\finisher_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 90 | 70 | 34 | 37 |
| 1 | 0 | 33 | 0 | 15 |
| 2 | 72 | 57 | 31 | 69 |
| 3 | 87 | 55 | 0 | 11 |

Compare these entries to identify the assignment with the lowest total processing time across all 4 orders.

If you want to send me the final pairing in a neat, machine-friendly way, just use a small JSON snippet like this — nothing fancy, just a list of the chosen triples.

{
  ""solution"": [
    [<i_id>, <j_id>, <k_id>],
    ...
  ]
}

This shows the shape I expect: ""solution"" holds an array of triples, and each triple is one job matched to one printer and one finisher. Think of each inner list as ""job i goes to printer j and finisher k"" — super simple, like filling out a form.

This JSON is just a sketch of the shape I need, not the actual answer. Please be sure to use the identifiers exactly as they appear in the instance input — 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”.""","{'cost_tensor': [[[98, 79, 2, 48], [43, 50, 60, 60], [91, 80, 53, 30], [25, 19, 84, 88]], [[48, 70, 18, 58], [19, 44, 91, 98], [42, 7, 52, 41], [6, 0, 68, 16]], [[7, 0, 0, 74], [1, 58, 44, 77], [11, 91, 92, 34], [99, 26, 56, 85]], [[90, 70, 34, 37], [0, 33, 0, 15], [72, 57, 31, 69], [87, 55, 0, 11]]], 'objective': 21.0}","[[0, 0, 2], [1, 2, 1], [2, 1, 0], [3, 3, 3]]",21.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [0, 1, 2, 3], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 98}, {'i': 0, 'j': 0, 'k': 1, 'cost': 79}, {'i': 0, 'j': 0, 'k': 2, 'cost': 2}, {'i': 0, 'j': 0, 'k': 3, 'cost': 48}, {'i': 0, 'j': 1, 'k': 0, 'cost': 43}, {'i': 0, 'j': 1, 'k': 1, 'cost': 50}, {'i': 0, 'j': 1, 'k': 2, 'cost': 60}, {'i': 0, 'j': 1, 'k': 3, 'cost': 60}, {'i': 0, 'j': 2, 'k': 0, 'cost': 91}, {'i': 0, 'j': 2, 'k': 1, 'cost': 80}, {'i': 0, 'j': 2, 'k': 2, 'cost': 53}, {'i': 0, 'j': 2, 'k': 3, 'cost': 30}, {'i': 0, 'j': 3, 'k': 0, 'cost': 25}, {'i': 0, 'j': 3, 'k': 1, 'cost': 19}, {'i': 0, 'j': 3, 'k': 2, 'cost': 84}, {'i': 0, 'j': 3, 'k': 3, 'cost': 88}, {'i': 1, 'j': 0, 'k': 0, 'cost': 48}, {'i': 1, 'j': 0, 'k': 1, 'cost': 70}, {'i': 1, 'j': 0, 'k': 2, 'cost': 18}, {'i': 1, 'j': 0, 'k': 3, 'cost': 58}, {'i': 1, 'j': 1, 'k': 0, 'cost': 19}, {'i': 1, 'j': 1, 'k': 1, 'cost': 44}, {'i': 1, 'j': 1, 'k': 2, 'cost': 91}, {'i': 1, 'j': 1, 'k': 3, 'cost': 98}, {'i': 1, 'j': 2, 'k': 0, 'cost': 42}, {'i': 1, 'j': 2, 'k': 1, 'cost': 7}, {'i': 1, 'j': 2, 'k': 2, 'cost': 52}, {'i': 1, 'j': 2, 'k': 3, 'cost': 41}, {'i': 1, 'j': 3, 'k': 0, 'cost': 6}, {'i': 1, 'j': 3, 'k': 1, 'cost': 0}, {'i': 1, 'j': 3, 'k': 2, 'cost': 68}, {'i': 1, 'j': 3, 'k': 3, 'cost': 16}, {'i': 2, 'j': 0, 'k': 0, 'cost': 7}, {'i': 2, 'j': 0, 'k': 1, 'cost': 0}, {'i': 2, 'j': 0, 'k': 2, 'cost': 0}, {'i': 2, 'j': 0, 'k': 3, 'cost': 74}, {'i': 2, 'j': 1, 'k': 0, 'cost': 1}, {'i': 2, 'j': 1, 'k': 1, 'cost': 58}, {'i': 2, 'j': 1, 'k': 2, 'cost': 44}, {'i': 2, 'j': 1, 'k': 3, 'cost': 77}, {'i': 2, 'j': 2, 'k': 0, 'cost': 11}, {'i': 2, 'j': 2, 'k': 1, 'cost': 91}, {'i': 2, 'j': 2, 'k': 2, 'cost': 92}, {'i': 2, 'j': 2, 'k': 3, 'cost': 34}, {'i': 2, 'j': 3, 'k': 0, 'cost': 99}, {'i': 2, 'j': 3, 'k': 1, 'cost': 26}, {'i': 2, 'j': 3, 'k': 2, 'cost': 56}, {'i': 2, 'j': 3, 'k': 3, 'cost': 85}, {'i': 3, 'j': 0, 'k': 0, 'cost': 90}, {'i': 3, 'j': 0, 'k': 1, 'cost': 70}, {'i': 3, 'j': 0, 'k': 2, 'cost': 34}, {'i': 3, 'j': 0, 'k': 3, 'cost': 37}, {'i': 3, 'j': 1, 'k': 0, 'cost': 0}, {'i': 3, 'j': 1, 'k': 1, 'cost': 33}, {'i': 3, 'j': 1, 'k': 2, 'cost': 0}, {'i': 3, 'j': 1, 'k': 3, 'cost': 15}, {'i': 3, 'j': 2, 'k': 0, 'cost': 72}, {'i': 3, 'j': 2, 'k': 1, 'cost': 57}, {'i': 3, 'j': 2, 'k': 2, 'cost': 31}, {'i': 3, 'j': 2, 'k': 3, 'cost': 69}, {'i': 3, 'j': 3, 'k': 0, 'cost': 87}, {'i': 3, 'j': 3, 'k': 1, 'cost': 55}, {'i': 3, 'j': 3, 'k': 2, 'cost': 0}, {'i': 3, 'j': 3, 'k': 3, 'cost': 11}]}","[[0, 0, 2], [1, 2, 1], [2, 1, 0], [3, 3, 3]]",11,markdown_table,0
AP3,AP3,"Someone in charge of the quarterly push needed to assign each campaign to exactly one outlet and one calendar week, making sure each outlet runs one campaign and each week gets one campaign — nothing gets repeated or skipped. Each campaign+outlet+week combo has a price, so the sensible plan was to choose the arrangement that makes the total spend as low as possible by adding up the costs of all the chosen combos. The full breakdown of campaigns, channels, weeks and costs appears below.

There are 4 campaigns to assign, identified as 0, 1, 2, 3.
Meaning: costs form a 3D tensor. For each fixed campaign_id=i, you are given a channel_id×week_id matrix whose entry at row channel_id=j and column week_id=k equals combo_cost(i,j,k). You must pick exactly one (j,k) for every i, with all channel_id and all week_id used exactly once.
combo_cost_tensor (per-campaign_id markdown matrices):
## campaign_id=0
| channel_id\week_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 69 | 4 | 26 | 55 |
| 1 | 40 | 27 | 79 | 87 |
| 2 | 25 | 46 | 77 | 9 |
| 3 | 94 | 30 | 2 | 42 |

## campaign_id=1
| channel_id\week_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 99 | 88 | 37 | 82 |
| 1 | 40 | 22 | 93 | 58 |
| 2 | 12 | 13 | 64 | 55 |
| 3 | 84 | 97 | 82 | 51 |

## campaign_id=2
| channel_id\week_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 90 | 19 | 43 | 28 |
| 1 | 36 | 35 | 81 | 21 |
| 2 | 94 | 70 | 35 | 16 |
| 3 | 58 | 2 | 19 | 98 |

## campaign_id=3
| channel_id\week_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 10 | 7 | 87 | 83 |
| 1 | 4 | 77 | 46 | 87 |
| 2 | 10 | 93 | 59 | 99 |
| 3 | 65 | 71 | 62 | 59 |
The person in charge will select one campaign+outlet+week triple for each of the 4 campaigns so every outlet and week is used exactly once and the total spend is minimized.

If you want the final plan in a simple, machine-friendly shape, just follow this JSON layout for the reply (keeps everything predictable and easy to check):

{
  ""solution"": [
    [<campaign_id>, <outlet_id>, <week_id>],
    ...
  ]
}

Each inner triple is one chosen combo: the campaign, the outlet assigned to it, and the calendar week it will run in — basically [campaign, outlet, week]. This is just a sketch of the expected shape, not the actual assignment.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like:
- plain numbers such as “1” or “23”
- single capital letters like “A” or “B”
- a capital letter followed by digits like “A1” or “X7”","{'cost_tensor': [[[69, 4, 26, 55], [40, 27, 79, 87], [25, 46, 77, 9], [94, 30, 2, 42]], [[99, 88, 37, 82], [40, 22, 93, 58], [12, 13, 64, 55], [84, 97, 82, 51]], [[90, 19, 43, 28], [36, 35, 81, 21], [94, 70, 35, 16], [58, 2, 19, 98]], [[10, 7, 87, 83], [4, 77, 46, 87], [10, 93, 59, 99], [65, 71, 62, 59]]], 'objective': 42.0}","[[0, 3, 2], [1, 2, 0], [2, 1, 3], [3, 0, 1]]",42.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [0, 1, 2, 3], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 69}, {'i': 0, 'j': 0, 'k': 1, 'cost': 4}, {'i': 0, 'j': 0, 'k': 2, 'cost': 26}, {'i': 0, 'j': 0, 'k': 3, 'cost': 55}, {'i': 0, 'j': 1, 'k': 0, 'cost': 40}, {'i': 0, 'j': 1, 'k': 1, 'cost': 27}, {'i': 0, 'j': 1, 'k': 2, 'cost': 79}, {'i': 0, 'j': 1, 'k': 3, 'cost': 87}, {'i': 0, 'j': 2, 'k': 0, 'cost': 25}, {'i': 0, 'j': 2, 'k': 1, 'cost': 46}, {'i': 0, 'j': 2, 'k': 2, 'cost': 77}, {'i': 0, 'j': 2, 'k': 3, 'cost': 9}, {'i': 0, 'j': 3, 'k': 0, 'cost': 94}, {'i': 0, 'j': 3, 'k': 1, 'cost': 30}, {'i': 0, 'j': 3, 'k': 2, 'cost': 2}, {'i': 0, 'j': 3, 'k': 3, 'cost': 42}, {'i': 1, 'j': 0, 'k': 0, 'cost': 99}, {'i': 1, 'j': 0, 'k': 1, 'cost': 88}, {'i': 1, 'j': 0, 'k': 2, 'cost': 37}, {'i': 1, 'j': 0, 'k': 3, 'cost': 82}, {'i': 1, 'j': 1, 'k': 0, 'cost': 40}, {'i': 1, 'j': 1, 'k': 1, 'cost': 22}, {'i': 1, 'j': 1, 'k': 2, 'cost': 93}, {'i': 1, 'j': 1, 'k': 3, 'cost': 58}, {'i': 1, 'j': 2, 'k': 0, 'cost': 12}, {'i': 1, 'j': 2, 'k': 1, 'cost': 13}, {'i': 1, 'j': 2, 'k': 2, 'cost': 64}, {'i': 1, 'j': 2, 'k': 3, 'cost': 55}, {'i': 1, 'j': 3, 'k': 0, 'cost': 84}, {'i': 1, 'j': 3, 'k': 1, 'cost': 97}, {'i': 1, 'j': 3, 'k': 2, 'cost': 82}, {'i': 1, 'j': 3, 'k': 3, 'cost': 51}, {'i': 2, 'j': 0, 'k': 0, 'cost': 90}, {'i': 2, 'j': 0, 'k': 1, 'cost': 19}, {'i': 2, 'j': 0, 'k': 2, 'cost': 43}, {'i': 2, 'j': 0, 'k': 3, 'cost': 28}, {'i': 2, 'j': 1, 'k': 0, 'cost': 36}, {'i': 2, 'j': 1, 'k': 1, 'cost': 35}, {'i': 2, 'j': 1, 'k': 2, 'cost': 81}, {'i': 2, 'j': 1, 'k': 3, 'cost': 21}, {'i': 2, 'j': 2, 'k': 0, 'cost': 94}, {'i': 2, 'j': 2, 'k': 1, 'cost': 70}, {'i': 2, 'j': 2, 'k': 2, 'cost': 35}, {'i': 2, 'j': 2, 'k': 3, 'cost': 16}, {'i': 2, 'j': 3, 'k': 0, 'cost': 58}, {'i': 2, 'j': 3, 'k': 1, 'cost': 2}, {'i': 2, 'j': 3, 'k': 2, 'cost': 19}, {'i': 2, 'j': 3, 'k': 3, 'cost': 98}, {'i': 3, 'j': 0, 'k': 0, 'cost': 10}, {'i': 3, 'j': 0, 'k': 1, 'cost': 7}, {'i': 3, 'j': 0, 'k': 2, 'cost': 87}, {'i': 3, 'j': 0, 'k': 3, 'cost': 83}, {'i': 3, 'j': 1, 'k': 0, 'cost': 4}, {'i': 3, 'j': 1, 'k': 1, 'cost': 77}, {'i': 3, 'j': 1, 'k': 2, 'cost': 46}, {'i': 3, 'j': 1, 'k': 3, 'cost': 87}, {'i': 3, 'j': 2, 'k': 0, 'cost': 10}, {'i': 3, 'j': 2, 'k': 1, 'cost': 93}, {'i': 3, 'j': 2, 'k': 2, 'cost': 59}, {'i': 3, 'j': 2, 'k': 3, 'cost': 99}, {'i': 3, 'j': 3, 'k': 0, 'cost': 65}, {'i': 3, 'j': 3, 'k': 1, 'cost': 71}, {'i': 3, 'j': 3, 'k': 2, 'cost': 62}, {'i': 3, 'j': 3, 'k': 3, 'cost': 59}]}","[[0, 3, 2], [1, 2, 0], [2, 1, 3], [3, 0, 1]]",12,nl,0
AP3,AP3,"We turned chore night into a little matchmaking problem: every family member needs one specific chore and one specific cleaning day, and every chore and every day has to be claimed by exactly one person. The best arrangement is the one where, after totaling each person’s discomfort score for the task and day they get, that overall sum is as low as possible. No job or day can be left unassigned or duplicated — it’s one person, one task, one day all the way. The exact tasks, days, and the inconvenience scores are listed below.

# family_size=4
# member_ids=1, 2, 3, 4

# Meaning: costs form a 3D tensor. For each fixed member_id=i, you are given a chore_id×cleaning_day_id matrix whose entry at row chore_id=j and column cleaning_day_id=k equals inconvenience_score(i,j,k). You must pick exactly one (j,k) for every i, with all chore_id and all cleaning_day_id used exactly once.
# inconvenience_score_tensor (per-member_id markdown matrices)

## member_id=1
| chore_id\cleaning_day_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 51 | 17 | 30 | 53 |
| 2 | 94 | 17 | 70 | 22 |
| 3 | 49 | 12 | 8 | 38 |
| 4 | 27 | 36 | 98 | 53 |

## member_id=2
| chore_id\cleaning_day_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 76 | 64 | 76 | 78 |
| 2 | 82 | 15 | 62 | 31 |
| 3 | 34 | 91 | 51 | 40 |
| 4 | 60 | 78 | 93 | 86 |

## member_id=3
| chore_id\cleaning_day_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 86 | 67 | 75 | 58 |
| 2 | 38 | 35 | 20 | 82 |
| 3 | 41 | 46 | 97 | 12 |
| 4 | 21 | 95 | 73 | 40 |

## member_id=4
| chore_id\cleaning_day_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 78 | 75 | 95 | 2 |
| 2 | 31 | 75 | 24 | 58 |
| 3 | 4 | 95 | 31 | 5 |
| 4 | 44 | 91 | 57 | 11 |

Also, when you hand back the matching, please use this simple JSON layout so I can read it straight away — just a quick sketch of the shape I expect:

{
  ""solution"": [
    [<person_id>, <chore_id>, <day_id>],
    ...
  ]
}

Think of each triple as one row in a little table: the first spot is the family member, the second is the chore they get, and the third is the day they’ll do it. This block is only a sketch of the expected shape, not the actual answer — I just want the final assignment to follow that exact structure.

Important: use the identifiers exactly as they appear in the instance input — do not rename them and do not 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”.","{'cost_tensor': [[[51, 17, 30, 53], [94, 17, 70, 22], [49, 12, 8, 38], [27, 36, 98, 53]], [[76, 64, 76, 78], [82, 15, 62, 31], [34, 91, 51, 40], [60, 78, 93, 86]], [[86, 67, 75, 58], [38, 35, 20, 82], [41, 46, 97, 12], [21, 95, 73, 40]], [[78, 75, 95, 2], [31, 75, 24, 58], [4, 95, 31, 5], [44, 91, 57, 11]]], 'objective': 46.0}","[[0, 2, 2], [1, 1, 1], [2, 3, 0], [3, 0, 3]]",46.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 51}, {'i': 1, 'j': 1, 'k': 2, 'cost': 17}, {'i': 1, 'j': 1, 'k': 3, 'cost': 30}, {'i': 1, 'j': 1, 'k': 4, 'cost': 53}, {'i': 1, 'j': 2, 'k': 1, 'cost': 94}, {'i': 1, 'j': 2, 'k': 2, 'cost': 17}, {'i': 1, 'j': 2, 'k': 3, 'cost': 70}, {'i': 1, 'j': 2, 'k': 4, 'cost': 22}, {'i': 1, 'j': 3, 'k': 1, 'cost': 49}, {'i': 1, 'j': 3, 'k': 2, 'cost': 12}, {'i': 1, 'j': 3, 'k': 3, 'cost': 8}, {'i': 1, 'j': 3, 'k': 4, 'cost': 38}, {'i': 1, 'j': 4, 'k': 1, 'cost': 27}, {'i': 1, 'j': 4, 'k': 2, 'cost': 36}, {'i': 1, 'j': 4, 'k': 3, 'cost': 98}, {'i': 1, 'j': 4, 'k': 4, 'cost': 53}, {'i': 2, 'j': 1, 'k': 1, 'cost': 76}, {'i': 2, 'j': 1, 'k': 2, 'cost': 64}, {'i': 2, 'j': 1, 'k': 3, 'cost': 76}, {'i': 2, 'j': 1, 'k': 4, 'cost': 78}, {'i': 2, 'j': 2, 'k': 1, 'cost': 82}, {'i': 2, 'j': 2, 'k': 2, 'cost': 15}, {'i': 2, 'j': 2, 'k': 3, 'cost': 62}, {'i': 2, 'j': 2, 'k': 4, 'cost': 31}, {'i': 2, 'j': 3, 'k': 1, 'cost': 34}, {'i': 2, 'j': 3, 'k': 2, 'cost': 91}, {'i': 2, 'j': 3, 'k': 3, 'cost': 51}, {'i': 2, 'j': 3, 'k': 4, 'cost': 40}, {'i': 2, 'j': 4, 'k': 1, 'cost': 60}, {'i': 2, 'j': 4, 'k': 2, 'cost': 78}, {'i': 2, 'j': 4, 'k': 3, 'cost': 93}, {'i': 2, 'j': 4, 'k': 4, 'cost': 86}, {'i': 3, 'j': 1, 'k': 1, 'cost': 86}, {'i': 3, 'j': 1, 'k': 2, 'cost': 67}, {'i': 3, 'j': 1, 'k': 3, 'cost': 75}, {'i': 3, 'j': 1, 'k': 4, 'cost': 58}, {'i': 3, 'j': 2, 'k': 1, 'cost': 38}, {'i': 3, 'j': 2, 'k': 2, 'cost': 35}, {'i': 3, 'j': 2, 'k': 3, 'cost': 20}, {'i': 3, 'j': 2, 'k': 4, 'cost': 82}, {'i': 3, 'j': 3, 'k': 1, 'cost': 41}, {'i': 3, 'j': 3, 'k': 2, 'cost': 46}, {'i': 3, 'j': 3, 'k': 3, 'cost': 97}, {'i': 3, 'j': 3, 'k': 4, 'cost': 12}, {'i': 3, 'j': 4, 'k': 1, 'cost': 21}, {'i': 3, 'j': 4, 'k': 2, 'cost': 95}, {'i': 3, 'j': 4, 'k': 3, 'cost': 73}, {'i': 3, 'j': 4, 'k': 4, 'cost': 40}, {'i': 4, 'j': 1, 'k': 1, 'cost': 78}, {'i': 4, 'j': 1, 'k': 2, 'cost': 75}, {'i': 4, 'j': 1, 'k': 3, 'cost': 95}, {'i': 4, 'j': 1, 'k': 4, 'cost': 2}, {'i': 4, 'j': 2, 'k': 1, 'cost': 31}, {'i': 4, 'j': 2, 'k': 2, 'cost': 75}, {'i': 4, 'j': 2, 'k': 3, 'cost': 24}, {'i': 4, 'j': 2, 'k': 4, 'cost': 58}, {'i': 4, 'j': 3, 'k': 1, 'cost': 4}, {'i': 4, 'j': 3, 'k': 2, 'cost': 95}, {'i': 4, 'j': 3, 'k': 3, 'cost': 31}, {'i': 4, 'j': 3, 'k': 4, 'cost': 5}, {'i': 4, 'j': 4, 'k': 1, 'cost': 44}, {'i': 4, 'j': 4, 'k': 2, 'cost': 91}, {'i': 4, 'j': 4, 'k': 3, 'cost': 57}, {'i': 4, 'j': 4, 'k': 4, 'cost': 11}]}","[[1, 3, 3], [2, 2, 2], [3, 4, 1], [4, 1, 4]]",13,csv,1
AP3,AP3,"Recently the manager asked the team to pair tables, waiters, and wine matchings in a way that keeps the night moving smoothly. The constraint was clear: each table gets a single waiter and a single wine pairing, and every waiter and every wine pairing has to be matched to exactly one table — no repeats, no omissions. Each possible triple has a service-time value, and the aim was to choose the collection of triples that produces the smallest possible total when those times are all added together. The detailed list of tables, waiters, wine choices, and their service times appears below.

# num_tables=5
# table_waiter_wine_identifiers=A, B, C, D, E

# Meaning: costs form a 3D tensor. For each fixed table_id=i, you are given a waiter_id×wine_pairing_id matrix whose entry at row waiter_id=j and column wine_pairing_id=k equals service_time(i,j,k). You must pick exactly one (j,k) for every i, with all waiter_id and all wine_pairing_id used exactly once.
# service_time_tensor (per-table_id markdown matrices)

## table_id=A
| waiter_id\wine_pairing_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 13 | 50 | 42 | 52 | 78 |
| B | 13 | 73 | 23 | 84 | 12 |
| C | 94 | 46 | 27 | 78 | 15 |
| D | 41 | 14 | 35 | 19 | 43 |
| E | 76 | 67 | 13 | 91 | 51 |

## table_id=B
| waiter_id\wine_pairing_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 21 | 46 | 41 | 86 | 17 |
| B | 62 | 53 | 43 | 58 | 37 |
| C | 41 | 37 | 29 | 8 | 96 |
| D | 6 | 68 | 77 | 2 | 54 |
| E | 78 | 13 | 28 | 90 | 42 |

## table_id=C
| waiter_id\wine_pairing_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 42 | 32 | 80 | 6 | 84 |
| B | 69 | 93 | 6 | 94 | 28 |
| C | 83 | 25 | 61 | 38 | 77 |
| D | 41 | 64 | 3 | 21 | 49 |
| E | 69 | 80 | 63 | 94 | 53 |

## table_id=D
| waiter_id\wine_pairing_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 18 | 11 | 56 | 35 | 31 |
| B | 91 | 3 | 46 | 4 | 84 |
| C | 94 | 33 | 69 | 9 | 69 |
| D | 97 | 58 | 4 | 32 | 70 |
| E | 5 | 89 | 17 | 72 | 96 |

## table_id=E
| waiter_id\wine_pairing_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 56 | 66 | 75 | 77 | 26 |
| B | 83 | 49 | 31 | 37 | 67 |
| C | 4 | 17 | 45 | 2 | 79 |
| D | 90 | 16 | 20 | 17 | 71 |
| E | 32 | 38 | 80 | 68 | 33 |

If you want the final matching in a compact, machine-friendly way, I usually just drop it into a tiny JSON snippet like this for clarity.

{
  ""solution"": [
    [<table_id>, <waiter_id>, <wine_id>],
    ...
  ]
}

This is just a sketch of the shape I mean: ""solution"" holds a list of triples, and each triple is the table identifier, the waiter identifier, and the wine-pairing identifier chosen for that table. Think of it like filling out a simple form — one row per table, with the assigned waiter and wine next to it.

This JSON is only the expected shape, not the actual matching — I'll fill in the real triples from the instance when you want them. Please make sure to use the exact identifiers as they appear in 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”.","{'cost_tensor': [[[13, 50, 42, 52, 78], [13, 73, 23, 84, 12], [94, 46, 27, 78, 15], [41, 14, 35, 19, 43], [76, 67, 13, 91, 51]], [[21, 46, 41, 86, 17], [62, 53, 43, 58, 37], [41, 37, 29, 8, 96], [6, 68, 77, 2, 54], [78, 13, 28, 90, 42]], [[42, 32, 80, 6, 84], [69, 93, 6, 94, 28], [83, 25, 61, 38, 77], [41, 64, 3, 21, 49], [69, 80, 63, 94, 53]], [[18, 11, 56, 35, 31], [91, 3, 46, 4, 84], [94, 33, 69, 9, 69], [97, 58, 4, 32, 70], [5, 89, 17, 72, 96]], [[56, 66, 75, 77, 26], [83, 49, 31, 37, 67], [4, 17, 45, 2, 79], [90, 16, 20, 17, 71], [32, 38, 80, 68, 33]]], 'objective': 39.0}","[[0, 1, 4], [1, 4, 1], [2, 0, 3], [3, 3, 2], [4, 2, 0]]",39.0,"{'problem_type': 'AP3', 'n': 5, 'ids': ['A', 'B', 'C', 'D', 'E'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 13}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 50}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 42}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 52}, {'i': 'A', 'j': 'A', 'k': 'E', 'cost': 78}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 13}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 73}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 23}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 84}, {'i': 'A', 'j': 'B', 'k': 'E', 'cost': 12}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 94}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 46}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 27}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 78}, {'i': 'A', 'j': 'C', 'k': 'E', 'cost': 15}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 41}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 14}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 35}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 19}, {'i': 'A', 'j': 'D', 'k': 'E', 'cost': 43}, {'i': 'A', 'j': 'E', 'k': 'A', 'cost': 76}, {'i': 'A', 'j': 'E', 'k': 'B', 'cost': 67}, {'i': 'A', 'j': 'E', 'k': 'C', 'cost': 13}, {'i': 'A', 'j': 'E', 'k': 'D', 'cost': 91}, {'i': 'A', 'j': 'E', 'k': 'E', 'cost': 51}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 21}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 46}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 41}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 86}, {'i': 'B', 'j': 'A', 'k': 'E', 'cost': 17}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 62}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 53}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 43}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 58}, {'i': 'B', 'j': 'B', 'k': 'E', 'cost': 37}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 41}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 37}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 29}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 8}, {'i': 'B', 'j': 'C', 'k': 'E', 'cost': 96}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 6}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 68}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 77}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 2}, {'i': 'B', 'j': 'D', 'k': 'E', 'cost': 54}, {'i': 'B', 'j': 'E', 'k': 'A', 'cost': 78}, {'i': 'B', 'j': 'E', 'k': 'B', 'cost': 13}, {'i': 'B', 'j': 'E', 'k': 'C', 'cost': 28}, {'i': 'B', 'j': 'E', 'k': 'D', 'cost': 90}, {'i': 'B', 'j': 'E', 'k': 'E', 'cost': 42}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 42}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 32}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 80}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 6}, {'i': 'C', 'j': 'A', 'k': 'E', 'cost': 84}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 69}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 93}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 6}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 94}, {'i': 'C', 'j': 'B', 'k': 'E', 'cost': 28}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 83}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 25}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 61}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 38}, {'i': 'C', 'j': 'C', 'k': 'E', 'cost': 77}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 41}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 64}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 3}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 21}, {'i': 'C', 'j': 'D', 'k': 'E', 'cost': 49}, {'i': 'C', 'j': 'E', 'k': 'A', 'cost': 69}, {'i': 'C', 'j': 'E', 'k': 'B', 'cost': 80}, {'i': 'C', 'j': 'E', 'k': 'C', 'cost': 63}, {'i': 'C', 'j': 'E', 'k': 'D', 'cost': 94}, {'i': 'C', 'j': 'E', 'k': 'E', 'cost': 53}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 18}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 11}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 56}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 35}, {'i': 'D', 'j': 'A', 'k': 'E', 'cost': 31}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 91}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 3}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 46}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 4}, {'i': 'D', 'j': 'B', 'k': 'E', 'cost': 84}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 94}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 33}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 69}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 9}, {'i': 'D', 'j': 'C', 'k': 'E', 'cost': 69}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 97}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 58}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 4}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 32}, {'i': 'D', 'j': 'D', 'k': 'E', 'cost': 70}, {'i': 'D', 'j': 'E', 'k': 'A', 'cost': 5}, {'i': 'D', 'j': 'E', 'k': 'B', 'cost': 89}, {'i': 'D', 'j': 'E', 'k': 'C', 'cost': 17}, {'i': 'D', 'j': 'E', 'k': 'D', 'cost': 72}, {'i': 'D', 'j': 'E', 'k': 'E', 'cost': 96}, {'i': 'E', 'j': 'A', 'k': 'A', 'cost': 56}, {'i': 'E', 'j': 'A', 'k': 'B', 'cost': 66}, {'i': 'E', 'j': 'A', 'k': 'C', 'cost': 75}, {'i': 'E', 'j': 'A', 'k': 'D', 'cost': 77}, {'i': 'E', 'j': 'A', 'k': 'E', 'cost': 26}, {'i': 'E', 'j': 'B', 'k': 'A', 'cost': 83}, {'i': 'E', 'j': 'B', 'k': 'B', 'cost': 49}, {'i': 'E', 'j': 'B', 'k': 'C', 'cost': 31}, {'i': 'E', 'j': 'B', 'k': 'D', 'cost': 37}, {'i': 'E', 'j': 'B', 'k': 'E', 'cost': 67}, {'i': 'E', 'j': 'C', 'k': 'A', 'cost': 4}, {'i': 'E', 'j': 'C', 'k': 'B', 'cost': 17}, {'i': 'E', 'j': 'C', 'k': 'C', 'cost': 45}, {'i': 'E', 'j': 'C', 'k': 'D', 'cost': 2}, {'i': 'E', 'j': 'C', 'k': 'E', 'cost': 79}, {'i': 'E', 'j': 'D', 'k': 'A', 'cost': 90}, {'i': 'E', 'j': 'D', 'k': 'B', 'cost': 16}, {'i': 'E', 'j': 'D', 'k': 'C', 'cost': 20}, {'i': 'E', 'j': 'D', 'k': 'D', 'cost': 17}, {'i': 'E', 'j': 'D', 'k': 'E', 'cost': 71}, {'i': 'E', 'j': 'E', 'k': 'A', 'cost': 32}, {'i': 'E', 'j': 'E', 'k': 'B', 'cost': 38}, {'i': 'E', 'j': 'E', 'k': 'C', 'cost': 80}, {'i': 'E', 'j': 'E', 'k': 'D', 'cost': 68}, {'i': 'E', 'j': 'E', 'k': 'E', 'cost': 33}]}","[['A', 'B', 'E'], ['B', 'E', 'B'], ['C', 'A', 'D'], ['D', 'D', 'C'], ['E', 'C', 'A']]",14,csv,names
AP3,AP3,"I was on a team trying to put together a smooth college timetable: every course needs one classroom and one time slot, and there happen to be exactly as many rooms and times as courses. The trick is to pick for each course a room-and-time pair so that no room or time gets used more than once and nothing is left unassigned, and the whole schedule causes as few student clashes as possible — to check that, just add up the clash cost for every course’s chosen room and time. Concrete details for the specific instance are shown below.

# num_courses=5
# course_ids=1, 2, 3, 4, 5

# Meaning: costs form a 3D tensor. For each fixed course_id=i, you are given a room_id×time_slot_id matrix whose entry at row room_id=j and column time_slot_id=k equals conflict_cost(i,j,k). You must pick exactly one (j,k) for every i, with all room_id and all time_slot_id used exactly once.
# conflict_cost_tensor (per-course_id markdown matrices)

## course_id=1
| room_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 37 | 80 | 78 | 22 | 22 |
| 2 | 5 | 95 | 6 | 21 | 5 |
| 3 | 91 | 30 | 79 | 38 | 78 |
| 4 | 4 | 56 | 85 | 68 | 37 |
| 5 | 3 | 48 | 24 | 82 | 19 |

## course_id=2
| room_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 94 | 43 | 50 | 93 | 40 |
| 2 | 84 | 45 | 34 | 16 | 45 |
| 3 | 1 | 72 | 78 | 1 | 71 |
| 4 | 66 | 17 | 56 | 41 | 47 |
| 5 | 28 | 50 | 54 | 98 | 15 |

## course_id=3
| room_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 44 | 95 | 52 | 95 | 31 |
| 2 | 39 | 96 | 69 | 73 | 72 |
| 3 | 23 | 77 | 12 | 7 | 16 |
| 4 | 22 | 53 | 38 | 87 | 24 |
| 5 | 99 | 63 | 27 | 79 | 22 |

## course_id=4
| room_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 25 | 25 | 22 | 17 | 32 |
| 2 | 9 | 36 | 49 | 80 | 25 |
| 3 | 92 | 33 | 17 | 44 | 50 |
| 4 | 10 | 52 | 70 | 94 | 6 |
| 5 | 51 | 74 | 81 | 12 | 79 |

## course_id=5
| room_id\time_slot_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 25 | 56 | 9 | 73 | 71 |
| 2 | 79 | 68 | 31 | 75 | 7 |
| 3 | 61 | 82 | 41 | 10 | 68 |
| 4 | 36 | 1 | 36 | 54 | 54 |
| 5 | 77 | 68 | 8 | 97 | 19 |

If you want the final schedule in a simple, copy-pasteable shape, here's the little JSON sketch I expect for the answer — nothing fancy, just a list of triples showing which course goes to which room and which time.

{
  ""solution"": [
    [<course_id>, <room_id>, <time_id>],
    ...
  ]
}

Think of each triple as ""course, room, time"" in that order. This JSON is just the shape I want you to follow — fill in the actual course/room/time identifiers from the instance when you give the real answer.

Please make sure you use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[37, 80, 78, 22, 22], [5, 95, 6, 21, 5], [91, 30, 79, 38, 78], [4, 56, 85, 68, 37], [3, 48, 24, 82, 19]], [[94, 43, 50, 93, 40], [84, 45, 34, 16, 45], [1, 72, 78, 1, 71], [66, 17, 56, 41, 47], [28, 50, 54, 98, 15]], [[44, 95, 52, 95, 31], [39, 96, 69, 73, 72], [23, 77, 12, 7, 16], [22, 53, 38, 87, 24], [99, 63, 27, 79, 22]], [[25, 25, 22, 17, 32], [9, 36, 49, 80, 25], [92, 33, 17, 44, 50], [10, 52, 70, 94, 6], [51, 74, 81, 12, 79]], [[25, 56, 9, 73, 71], [79, 68, 31, 75, 7], [61, 82, 41, 10, 68], [36, 1, 36, 54, 54], [77, 68, 8, 97, 19]]], 'objective': 47.0}","[[0, 1, 2], [1, 2, 0], [2, 4, 4], [3, 0, 3], [4, 3, 1]]",47.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [1, 2, 3, 4, 5], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 37}, {'i': 1, 'j': 1, 'k': 2, 'cost': 80}, {'i': 1, 'j': 1, 'k': 3, 'cost': 78}, {'i': 1, 'j': 1, 'k': 4, 'cost': 22}, {'i': 1, 'j': 1, 'k': 5, 'cost': 22}, {'i': 1, 'j': 2, 'k': 1, 'cost': 5}, {'i': 1, 'j': 2, 'k': 2, 'cost': 95}, {'i': 1, 'j': 2, 'k': 3, 'cost': 6}, {'i': 1, 'j': 2, 'k': 4, 'cost': 21}, {'i': 1, 'j': 2, 'k': 5, 'cost': 5}, {'i': 1, 'j': 3, 'k': 1, 'cost': 91}, {'i': 1, 'j': 3, 'k': 2, 'cost': 30}, {'i': 1, 'j': 3, 'k': 3, 'cost': 79}, {'i': 1, 'j': 3, 'k': 4, 'cost': 38}, {'i': 1, 'j': 3, 'k': 5, 'cost': 78}, {'i': 1, 'j': 4, 'k': 1, 'cost': 4}, {'i': 1, 'j': 4, 'k': 2, 'cost': 56}, {'i': 1, 'j': 4, 'k': 3, 'cost': 85}, {'i': 1, 'j': 4, 'k': 4, 'cost': 68}, {'i': 1, 'j': 4, 'k': 5, 'cost': 37}, {'i': 1, 'j': 5, 'k': 1, 'cost': 3}, {'i': 1, 'j': 5, 'k': 2, 'cost': 48}, {'i': 1, 'j': 5, 'k': 3, 'cost': 24}, {'i': 1, 'j': 5, 'k': 4, 'cost': 82}, {'i': 1, 'j': 5, 'k': 5, 'cost': 19}, {'i': 2, 'j': 1, 'k': 1, 'cost': 94}, {'i': 2, 'j': 1, 'k': 2, 'cost': 43}, {'i': 2, 'j': 1, 'k': 3, 'cost': 50}, {'i': 2, 'j': 1, 'k': 4, 'cost': 93}, {'i': 2, 'j': 1, 'k': 5, 'cost': 40}, {'i': 2, 'j': 2, 'k': 1, 'cost': 84}, {'i': 2, 'j': 2, 'k': 2, 'cost': 45}, {'i': 2, 'j': 2, 'k': 3, 'cost': 34}, {'i': 2, 'j': 2, 'k': 4, 'cost': 16}, {'i': 2, 'j': 2, 'k': 5, 'cost': 45}, {'i': 2, 'j': 3, 'k': 1, 'cost': 1}, {'i': 2, 'j': 3, 'k': 2, 'cost': 72}, {'i': 2, 'j': 3, 'k': 3, 'cost': 78}, {'i': 2, 'j': 3, 'k': 4, 'cost': 1}, {'i': 2, 'j': 3, 'k': 5, 'cost': 71}, {'i': 2, 'j': 4, 'k': 1, 'cost': 66}, {'i': 2, 'j': 4, 'k': 2, 'cost': 17}, {'i': 2, 'j': 4, 'k': 3, 'cost': 56}, {'i': 2, 'j': 4, 'k': 4, 'cost': 41}, {'i': 2, 'j': 4, 'k': 5, 'cost': 47}, {'i': 2, 'j': 5, 'k': 1, 'cost': 28}, {'i': 2, 'j': 5, 'k': 2, 'cost': 50}, {'i': 2, 'j': 5, 'k': 3, 'cost': 54}, {'i': 2, 'j': 5, 'k': 4, 'cost': 98}, {'i': 2, 'j': 5, 'k': 5, 'cost': 15}, {'i': 3, 'j': 1, 'k': 1, 'cost': 44}, {'i': 3, 'j': 1, 'k': 2, 'cost': 95}, {'i': 3, 'j': 1, 'k': 3, 'cost': 52}, {'i': 3, 'j': 1, 'k': 4, 'cost': 95}, {'i': 3, 'j': 1, 'k': 5, 'cost': 31}, {'i': 3, 'j': 2, 'k': 1, 'cost': 39}, {'i': 3, 'j': 2, 'k': 2, 'cost': 96}, {'i': 3, 'j': 2, 'k': 3, 'cost': 69}, {'i': 3, 'j': 2, 'k': 4, 'cost': 73}, {'i': 3, 'j': 2, 'k': 5, 'cost': 72}, {'i': 3, 'j': 3, 'k': 1, 'cost': 23}, {'i': 3, 'j': 3, 'k': 2, 'cost': 77}, {'i': 3, 'j': 3, 'k': 3, 'cost': 12}, {'i': 3, 'j': 3, 'k': 4, 'cost': 7}, {'i': 3, 'j': 3, 'k': 5, 'cost': 16}, {'i': 3, 'j': 4, 'k': 1, 'cost': 22}, {'i': 3, 'j': 4, 'k': 2, 'cost': 53}, {'i': 3, 'j': 4, 'k': 3, 'cost': 38}, {'i': 3, 'j': 4, 'k': 4, 'cost': 87}, {'i': 3, 'j': 4, 'k': 5, 'cost': 24}, {'i': 3, 'j': 5, 'k': 1, 'cost': 99}, {'i': 3, 'j': 5, 'k': 2, 'cost': 63}, {'i': 3, 'j': 5, 'k': 3, 'cost': 27}, {'i': 3, 'j': 5, 'k': 4, 'cost': 79}, {'i': 3, 'j': 5, 'k': 5, 'cost': 22}, {'i': 4, 'j': 1, 'k': 1, 'cost': 25}, {'i': 4, 'j': 1, 'k': 2, 'cost': 25}, {'i': 4, 'j': 1, 'k': 3, 'cost': 22}, {'i': 4, 'j': 1, 'k': 4, 'cost': 17}, {'i': 4, 'j': 1, 'k': 5, 'cost': 32}, {'i': 4, 'j': 2, 'k': 1, 'cost': 9}, {'i': 4, 'j': 2, 'k': 2, 'cost': 36}, {'i': 4, 'j': 2, 'k': 3, 'cost': 49}, {'i': 4, 'j': 2, 'k': 4, 'cost': 80}, {'i': 4, 'j': 2, 'k': 5, 'cost': 25}, {'i': 4, 'j': 3, 'k': 1, 'cost': 92}, {'i': 4, 'j': 3, 'k': 2, 'cost': 33}, {'i': 4, 'j': 3, 'k': 3, 'cost': 17}, {'i': 4, 'j': 3, 'k': 4, 'cost': 44}, {'i': 4, 'j': 3, 'k': 5, 'cost': 50}, {'i': 4, 'j': 4, 'k': 1, 'cost': 10}, {'i': 4, 'j': 4, 'k': 2, 'cost': 52}, {'i': 4, 'j': 4, 'k': 3, 'cost': 70}, {'i': 4, 'j': 4, 'k': 4, 'cost': 94}, {'i': 4, 'j': 4, 'k': 5, 'cost': 6}, {'i': 4, 'j': 5, 'k': 1, 'cost': 51}, {'i': 4, 'j': 5, 'k': 2, 'cost': 74}, {'i': 4, 'j': 5, 'k': 3, 'cost': 81}, {'i': 4, 'j': 5, 'k': 4, 'cost': 12}, {'i': 4, 'j': 5, 'k': 5, 'cost': 79}, {'i': 5, 'j': 1, 'k': 1, 'cost': 25}, {'i': 5, 'j': 1, 'k': 2, 'cost': 56}, {'i': 5, 'j': 1, 'k': 3, 'cost': 9}, {'i': 5, 'j': 1, 'k': 4, 'cost': 73}, {'i': 5, 'j': 1, 'k': 5, 'cost': 71}, {'i': 5, 'j': 2, 'k': 1, 'cost': 79}, {'i': 5, 'j': 2, 'k': 2, 'cost': 68}, {'i': 5, 'j': 2, 'k': 3, 'cost': 31}, {'i': 5, 'j': 2, 'k': 4, 'cost': 75}, {'i': 5, 'j': 2, 'k': 5, 'cost': 7}, {'i': 5, 'j': 3, 'k': 1, 'cost': 61}, {'i': 5, 'j': 3, 'k': 2, 'cost': 82}, {'i': 5, 'j': 3, 'k': 3, 'cost': 41}, {'i': 5, 'j': 3, 'k': 4, 'cost': 10}, {'i': 5, 'j': 3, 'k': 5, 'cost': 68}, {'i': 5, 'j': 4, 'k': 1, 'cost': 36}, {'i': 5, 'j': 4, 'k': 2, 'cost': 1}, {'i': 5, 'j': 4, 'k': 3, 'cost': 36}, {'i': 5, 'j': 4, 'k': 4, 'cost': 54}, {'i': 5, 'j': 4, 'k': 5, 'cost': 54}, {'i': 5, 'j': 5, 'k': 1, 'cost': 77}, {'i': 5, 'j': 5, 'k': 2, 'cost': 68}, {'i': 5, 'j': 5, 'k': 3, 'cost': 8}, {'i': 5, 'j': 5, 'k': 4, 'cost': 97}, {'i': 5, 'j': 5, 'k': 5, 'cost': 19}]}","[[1, 2, 3], [2, 3, 1], [3, 5, 5], [4, 1, 4], [5, 4, 2]]",15,csv,1
AP3,AP3,"There’s a production puzzle: a set of scenes, a set of DPs, and a set of locations, all the same size. The team must pair each scene with exactly one DP and one location, making sure no DP or location gets reused. Each possible pairing carries a setup charge, and the whole point is to choose the pairings so the sum of those charges across all scenes comes out the lowest. Everything must be assigned exactly once; the detailed options and costs follow below.

There are 5 scenes, identified as 1, 2, 3, 4, 5.
Meaning: costs form a 3D tensor. For each fixed scene_id=i, you are given a dp_id×location_id matrix whose entry at row dp_id=j and column location_id=k equals setup_cost(i,j,k). You must pick exactly one (j,k) for every i, with all dp_id and all location_id used exactly once.
setup_cost_tensor (per-scene_id markdown matrices):
## scene_id=1
| dp_id\location_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 7 | 4 | 63 | 28 | 54 |
| 2 | 34 | 72 | 58 | 0 | 88 |
| 3 | 41 | 2 | 37 | 68 | 52 |
| 4 | 43 | 46 | 88 | 68 | 27 |
| 5 | 84 | 63 | 77 | 4 | 73 |

## scene_id=2
| dp_id\location_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 43 | 27 | 14 | 10 | 97 |
| 2 | 94 | 22 | 82 | 16 | 39 |
| 3 | 84 | 97 | 88 | 21 | 36 |
| 4 | 82 | 91 | 26 | 91 | 93 |
| 5 | 29 | 50 | 12 | 64 | 27 |

## scene_id=3
| dp_id\location_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 7 | 25 | 6 | 39 | 8 |
| 2 | 41 | 86 | 3 | 37 | 63 |
| 3 | 66 | 7 | 93 | 45 | 73 |
| 4 | 9 | 47 | 89 | 44 | 34 |
| 5 | 91 | 76 | 75 | 55 | 6 |

## scene_id=4
| dp_id\location_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 64 | 89 | 92 | 89 | 74 |
| 2 | 9 | 65 | 37 | 1 | 27 |
| 3 | 17 | 55 | 62 | 4 | 35 |
| 4 | 78 | 36 | 76 | 72 | 47 |
| 5 | 54 | 36 | 50 | 58 | 72 |

## scene_id=5
| dp_id\location_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 24 | 79 | 86 | 82 | 60 |
| 2 | 43 | 82 | 36 | 61 | 47 |
| 3 | 7 | 37 | 51 | 72 | 30 |
| 4 | 24 | 15 | 9 | 88 | 32 |
| 5 | 15 | 60 | 46 | 36 | 31 |
Select exactly one line for each of the 5 scenes so every DP and location is used once and the total setup charge is minimized.

Also, when you return the final assignments, please use this simple JSON shape so it's easy to parse and check.

{
  ""solution"": [
    [""<scene_id>"", ""<dp_id>"", ""<location_id>""],
    [""<scene_id>"", ""<dp_id>"", ""<location_id>""],
    [""<scene_id>"", ""<dp_id>"", ""<location_id>""]
  ]
}

Think of ""solution"" as a list of little forms: each inner array is one chosen triple (scene, DP, location) in that order. The angle-bracket placeholders above are just a sketch of the shape — replace them with the actual IDs from the instance when you submit your answer.

Please make sure to use the identifiers exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[7, 4, 63, 28, 54], [34, 72, 58, 0, 88], [41, 2, 37, 68, 52], [43, 46, 88, 68, 27], [84, 63, 77, 4, 73]], [[43, 27, 14, 10, 97], [94, 22, 82, 16, 39], [84, 97, 88, 21, 36], [82, 91, 26, 91, 93], [29, 50, 12, 64, 27]], [[7, 25, 6, 39, 8], [41, 86, 3, 37, 63], [66, 7, 93, 45, 73], [9, 47, 89, 44, 34], [91, 76, 75, 55, 6]], [[64, 89, 92, 89, 74], [9, 65, 37, 1, 27], [17, 55, 62, 4, 35], [78, 36, 76, 72, 47], [54, 36, 50, 58, 72]], [[24, 79, 86, 82, 60], [43, 82, 36, 61, 47], [7, 37, 51, 72, 30], [24, 15, 9, 88, 32], [15, 60, 46, 36, 31]]], 'objective': 36.0}","[[0, 2, 1], [1, 0, 3], [2, 4, 4], [3, 1, 0], [4, 3, 2]]",36.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [1, 2, 3, 4, 5], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 7}, {'i': 1, 'j': 1, 'k': 2, 'cost': 4}, {'i': 1, 'j': 1, 'k': 3, 'cost': 63}, {'i': 1, 'j': 1, 'k': 4, 'cost': 28}, {'i': 1, 'j': 1, 'k': 5, 'cost': 54}, {'i': 1, 'j': 2, 'k': 1, 'cost': 34}, {'i': 1, 'j': 2, 'k': 2, 'cost': 72}, {'i': 1, 'j': 2, 'k': 3, 'cost': 58}, {'i': 1, 'j': 2, 'k': 4, 'cost': 0}, {'i': 1, 'j': 2, 'k': 5, 'cost': 88}, {'i': 1, 'j': 3, 'k': 1, 'cost': 41}, {'i': 1, 'j': 3, 'k': 2, 'cost': 2}, {'i': 1, 'j': 3, 'k': 3, 'cost': 37}, {'i': 1, 'j': 3, 'k': 4, 'cost': 68}, {'i': 1, 'j': 3, 'k': 5, 'cost': 52}, {'i': 1, 'j': 4, 'k': 1, 'cost': 43}, {'i': 1, 'j': 4, 'k': 2, 'cost': 46}, {'i': 1, 'j': 4, 'k': 3, 'cost': 88}, {'i': 1, 'j': 4, 'k': 4, 'cost': 68}, {'i': 1, 'j': 4, 'k': 5, 'cost': 27}, {'i': 1, 'j': 5, 'k': 1, 'cost': 84}, {'i': 1, 'j': 5, 'k': 2, 'cost': 63}, {'i': 1, 'j': 5, 'k': 3, 'cost': 77}, {'i': 1, 'j': 5, 'k': 4, 'cost': 4}, {'i': 1, 'j': 5, 'k': 5, 'cost': 73}, {'i': 2, 'j': 1, 'k': 1, 'cost': 43}, {'i': 2, 'j': 1, 'k': 2, 'cost': 27}, {'i': 2, 'j': 1, 'k': 3, 'cost': 14}, {'i': 2, 'j': 1, 'k': 4, 'cost': 10}, {'i': 2, 'j': 1, 'k': 5, 'cost': 97}, {'i': 2, 'j': 2, 'k': 1, 'cost': 94}, {'i': 2, 'j': 2, 'k': 2, 'cost': 22}, {'i': 2, 'j': 2, 'k': 3, 'cost': 82}, {'i': 2, 'j': 2, 'k': 4, 'cost': 16}, {'i': 2, 'j': 2, 'k': 5, 'cost': 39}, {'i': 2, 'j': 3, 'k': 1, 'cost': 84}, {'i': 2, 'j': 3, 'k': 2, 'cost': 97}, {'i': 2, 'j': 3, 'k': 3, 'cost': 88}, {'i': 2, 'j': 3, 'k': 4, 'cost': 21}, {'i': 2, 'j': 3, 'k': 5, 'cost': 36}, {'i': 2, 'j': 4, 'k': 1, 'cost': 82}, {'i': 2, 'j': 4, 'k': 2, 'cost': 91}, {'i': 2, 'j': 4, 'k': 3, 'cost': 26}, {'i': 2, 'j': 4, 'k': 4, 'cost': 91}, {'i': 2, 'j': 4, 'k': 5, 'cost': 93}, {'i': 2, 'j': 5, 'k': 1, 'cost': 29}, {'i': 2, 'j': 5, 'k': 2, 'cost': 50}, {'i': 2, 'j': 5, 'k': 3, 'cost': 12}, {'i': 2, 'j': 5, 'k': 4, 'cost': 64}, {'i': 2, 'j': 5, 'k': 5, 'cost': 27}, {'i': 3, 'j': 1, 'k': 1, 'cost': 7}, {'i': 3, 'j': 1, 'k': 2, 'cost': 25}, {'i': 3, 'j': 1, 'k': 3, 'cost': 6}, {'i': 3, 'j': 1, 'k': 4, 'cost': 39}, {'i': 3, 'j': 1, 'k': 5, 'cost': 8}, {'i': 3, 'j': 2, 'k': 1, 'cost': 41}, {'i': 3, 'j': 2, 'k': 2, 'cost': 86}, {'i': 3, 'j': 2, 'k': 3, 'cost': 3}, {'i': 3, 'j': 2, 'k': 4, 'cost': 37}, {'i': 3, 'j': 2, 'k': 5, 'cost': 63}, {'i': 3, 'j': 3, 'k': 1, 'cost': 66}, {'i': 3, 'j': 3, 'k': 2, 'cost': 7}, {'i': 3, 'j': 3, 'k': 3, 'cost': 93}, {'i': 3, 'j': 3, 'k': 4, 'cost': 45}, {'i': 3, 'j': 3, 'k': 5, 'cost': 73}, {'i': 3, 'j': 4, 'k': 1, 'cost': 9}, {'i': 3, 'j': 4, 'k': 2, 'cost': 47}, {'i': 3, 'j': 4, 'k': 3, 'cost': 89}, {'i': 3, 'j': 4, 'k': 4, 'cost': 44}, {'i': 3, 'j': 4, 'k': 5, 'cost': 34}, {'i': 3, 'j': 5, 'k': 1, 'cost': 91}, {'i': 3, 'j': 5, 'k': 2, 'cost': 76}, {'i': 3, 'j': 5, 'k': 3, 'cost': 75}, {'i': 3, 'j': 5, 'k': 4, 'cost': 55}, {'i': 3, 'j': 5, 'k': 5, 'cost': 6}, {'i': 4, 'j': 1, 'k': 1, 'cost': 64}, {'i': 4, 'j': 1, 'k': 2, 'cost': 89}, {'i': 4, 'j': 1, 'k': 3, 'cost': 92}, {'i': 4, 'j': 1, 'k': 4, 'cost': 89}, {'i': 4, 'j': 1, 'k': 5, 'cost': 74}, {'i': 4, 'j': 2, 'k': 1, 'cost': 9}, {'i': 4, 'j': 2, 'k': 2, 'cost': 65}, {'i': 4, 'j': 2, 'k': 3, 'cost': 37}, {'i': 4, 'j': 2, 'k': 4, 'cost': 1}, {'i': 4, 'j': 2, 'k': 5, 'cost': 27}, {'i': 4, 'j': 3, 'k': 1, 'cost': 17}, {'i': 4, 'j': 3, 'k': 2, 'cost': 55}, {'i': 4, 'j': 3, 'k': 3, 'cost': 62}, {'i': 4, 'j': 3, 'k': 4, 'cost': 4}, {'i': 4, 'j': 3, 'k': 5, 'cost': 35}, {'i': 4, 'j': 4, 'k': 1, 'cost': 78}, {'i': 4, 'j': 4, 'k': 2, 'cost': 36}, {'i': 4, 'j': 4, 'k': 3, 'cost': 76}, {'i': 4, 'j': 4, 'k': 4, 'cost': 72}, {'i': 4, 'j': 4, 'k': 5, 'cost': 47}, {'i': 4, 'j': 5, 'k': 1, 'cost': 54}, {'i': 4, 'j': 5, 'k': 2, 'cost': 36}, {'i': 4, 'j': 5, 'k': 3, 'cost': 50}, {'i': 4, 'j': 5, 'k': 4, 'cost': 58}, {'i': 4, 'j': 5, 'k': 5, 'cost': 72}, {'i': 5, 'j': 1, 'k': 1, 'cost': 24}, {'i': 5, 'j': 1, 'k': 2, 'cost': 79}, {'i': 5, 'j': 1, 'k': 3, 'cost': 86}, {'i': 5, 'j': 1, 'k': 4, 'cost': 82}, {'i': 5, 'j': 1, 'k': 5, 'cost': 60}, {'i': 5, 'j': 2, 'k': 1, 'cost': 43}, {'i': 5, 'j': 2, 'k': 2, 'cost': 82}, {'i': 5, 'j': 2, 'k': 3, 'cost': 36}, {'i': 5, 'j': 2, 'k': 4, 'cost': 61}, {'i': 5, 'j': 2, 'k': 5, 'cost': 47}, {'i': 5, 'j': 3, 'k': 1, 'cost': 7}, {'i': 5, 'j': 3, 'k': 2, 'cost': 37}, {'i': 5, 'j': 3, 'k': 3, 'cost': 51}, {'i': 5, 'j': 3, 'k': 4, 'cost': 72}, {'i': 5, 'j': 3, 'k': 5, 'cost': 30}, {'i': 5, 'j': 4, 'k': 1, 'cost': 24}, {'i': 5, 'j': 4, 'k': 2, 'cost': 15}, {'i': 5, 'j': 4, 'k': 3, 'cost': 9}, {'i': 5, 'j': 4, 'k': 4, 'cost': 88}, {'i': 5, 'j': 4, 'k': 5, 'cost': 32}, {'i': 5, 'j': 5, 'k': 1, 'cost': 15}, {'i': 5, 'j': 5, 'k': 2, 'cost': 60}, {'i': 5, 'j': 5, 'k': 3, 'cost': 46}, {'i': 5, 'j': 5, 'k': 4, 'cost': 36}, {'i': 5, 'j': 5, 'k': 5, 'cost': 31}]}","[[1, 3, 2], [2, 1, 4], [3, 5, 5], [4, 2, 1], [5, 4, 3]]",16,nl,1
AP3,AP3,"On a busy catering team there are exactly as many menus as there are chefs and as there are suppliers, so the puzzle is to give each menu one chef and one supplier while using every chef and every supplier once. Each possible assignment comes with an ingredient cost, and the plan is to choose those assignments so the grand total of all ingredient costs is as small as it can be — add together the cost for each day’s chosen chef-and-supplier pair to get that total. The exact lineup and cost numbers are shown below.

# num_menus=4
# menu_ids=A, B, C, D

# Meaning: costs form a 3D tensor. For each fixed menu_id=i, you are given a chef_id×supplier_id matrix whose entry at row chef_id=j and column supplier_id=k equals ingredient_cost(i,j,k). You must pick exactly one (j,k) for every i, with all chef_id and all supplier_id used exactly once.
# ingredient_cost_tensor (per-menu_id markdown matrices)

## menu_id=A
| chef_id\supplier_id | A | B | C | D |
|---|---|---|---|---|
| A | 87 | 50 | 49 | 68 |
| B | 14 | 6 | 68 | 95 |
| C | 50 | 18 | 30 | 58 |
| D | 89 | 46 | 66 | 31 |

## menu_id=B
| chef_id\supplier_id | A | B | C | D |
|---|---|---|---|---|
| A | 59 | 36 | 53 | 73 |
| B | 79 | 21 | 93 | 80 |
| C | 97 | 63 | 93 | 33 |
| D | 95 | 95 | 54 | 3 |

## menu_id=C
| chef_id\supplier_id | A | B | C | D |
|---|---|---|---|---|
| A | 31 | 71 | 12 | 51 |
| B | 53 | 96 | 36 | 91 |
| C | 74 | 2 | 49 | 25 |
| D | 1 | 48 | 46 | 2 |

## menu_id=D
| chef_id\supplier_id | A | B | C | D |
|---|---|---|---|---|
| A | 65 | 81 | 22 | 95 |
| B | 54 | 88 | 4 | 96 |
| C | 64 | 18 | 33 | 87 |
| D | 69 | 95 | 87 | 31 |

If you want to hand the solution back in a tidy, machine-friendly way, just drop it into a tiny JSON object like this:

{
  ""solution"": [
    [<menu_id>, <chef_id>, <supplier_id>],
    ...
  ]
}

Think of each inner triple as one menu's pick: the menu, the chef chosen for it, and the supplier chosen for it. This is just a sketch showing the shape I expect — when you give the actual answer, replace those placeholders with the real IDs from the instance.

Please make sure you use the identifiers exactly as they appear in the 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”.""","{'cost_tensor': [[[87, 50, 49, 68], [14, 6, 68, 95], [50, 18, 30, 58], [89, 46, 66, 31]], [[59, 36, 53, 73], [79, 21, 93, 80], [97, 63, 93, 33], [95, 95, 54, 3]], [[31, 71, 12, 51], [53, 96, 36, 91], [74, 2, 49, 25], [1, 48, 46, 2]], [[65, 81, 22, 95], [54, 88, 4, 96], [64, 18, 33, 87], [69, 95, 87, 31]]], 'objective': 41.0}","[[0, 1, 0], [1, 3, 3], [2, 2, 1], [3, 0, 2]]",41.0,"{'problem_type': 'AP3', 'n': 4, 'ids': ['A', 'B', 'C', 'D'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 87}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 50}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 49}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 68}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 14}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 6}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 68}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 95}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 50}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 18}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 30}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 58}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 89}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 46}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 66}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 31}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 59}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 36}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 53}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 73}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 79}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 21}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 93}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 80}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 97}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 63}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 93}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 33}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 95}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 95}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 54}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 3}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 31}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 71}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 12}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 51}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 53}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 96}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 36}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 91}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 74}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 2}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 49}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 25}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 1}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 48}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 46}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 2}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 65}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 81}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 22}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 95}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 54}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 88}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 4}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 96}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 64}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 18}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 33}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 87}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 69}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 95}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 87}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 31}]}","[['A', 'B', 'A'], ['B', 'D', 'D'], ['C', 'C', 'B'], ['D', 'A', 'C']]",17,csv,names
AP3,AP3,"Someone at the front desk needs a clean plan: every incoming patient must be matched to one specialist and one room, and no specialist or room can be assigned more than once. Each trio choice comes with an expected wait plus transfer penalty, and the plan’s quality is just the sum of those penalties across all patients — lower is better. The detailed list of patients, specialists, rooms and the corresponding wait/transfer values appears below.

{
  ""num_patients"": 5,
  ""patient_ids"": [
    1,
    2,
    3,
    4,
    5
  ]
}

# Meaning: costs form a 3D tensor. For each fixed patient_id=i, you are given a specialist_id×room_id matrix whose entry at row specialist_id=j and column room_id=k equals expected_wait_transfer_cost(i,j,k). You must pick exactly one (j,k) for every i, with all specialist_id and all room_id used exactly once.
# expected_wait_transfer_cost_tensor (per-patient_id markdown matrices)

## patient_id=1
| specialist_id\room_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 41 | 40 | 61 | 90 | 40 |
| 2 | 7 | 69 | 28 | 96 | 53 |
| 3 | 5 | 71 | 23 | 73 | 66 |
| 4 | 99 | 80 | 21 | 63 | 90 |
| 5 | 74 | 19 | 0 | 70 | 45 |

## patient_id=2
| specialist_id\room_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 96 | 86 | 9 | 49 | 43 |
| 2 | 69 | 23 | 23 | 14 | 51 |
| 3 | 67 | 7 | 80 | 23 | 34 |
| 4 | 79 | 16 | 88 | 77 | 68 |
| 5 | 54 | 93 | 26 | 20 | 19 |

## patient_id=3
| specialist_id\room_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 59 | 50 | 73 | 28 | 38 |
| 2 | 91 | 26 | 39 | 47 | 17 |
| 3 | 59 | 73 | 88 | 27 | 20 |
| 4 | 69 | 32 | 93 | 93 | 0 |
| 5 | 11 | 68 | 80 | 51 | 98 |

## patient_id=4
| specialist_id\room_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 92 | 94 | 47 | 51 | 99 |
| 2 | 51 | 79 | 4 | 33 | 93 |
| 3 | 23 | 90 | 55 | 17 | 5 |
| 4 | 85 | 51 | 95 | 5 | 21 |
| 5 | 44 | 10 | 17 | 86 | 66 |

## patient_id=5
| specialist_id\room_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 35 | 53 | 16 | 59 | 66 |
| 2 | 34 | 45 | 11 | 37 | 24 |
| 3 | 77 | 45 | 67 | 89 | 73 |
| 4 | 12 | 47 | 80 | 57 | 58 |
| 5 | 63 | 51 | 76 | 68 | 14 |

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

{
  ""solution"": [
    [""<patient_id>"", ""<specialist_id>"", ""<room_id>""],
    ...
  ]
}

Just to keep it friendly: ""solution"" is a list of triples — each triple picks the patient, the specialist, and the room assigned to them. Think of each small array as one filled-out row on a scheduling form.

This is just the expected shape, not the real answer — fill in the real IDs from the instance when you submit the plan. Please use the IDs exactly as they appear in the 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”.","{'cost_tensor': [[[41, 40, 61, 90, 40], [7, 69, 28, 96, 53], [5, 71, 23, 73, 66], [99, 80, 21, 63, 90], [74, 19, 0, 70, 45]], [[96, 86, 9, 49, 43], [69, 23, 23, 14, 51], [67, 7, 80, 23, 34], [79, 16, 88, 77, 68], [54, 93, 26, 20, 19]], [[59, 50, 73, 28, 38], [91, 26, 39, 47, 17], [59, 73, 88, 27, 20], [69, 32, 93, 93, 0], [11, 68, 80, 51, 98]], [[92, 94, 47, 51, 99], [51, 79, 4, 33, 93], [23, 90, 55, 17, 5], [85, 51, 95, 5, 21], [44, 10, 17, 86, 66]], [[35, 53, 16, 59, 66], [34, 45, 11, 37, 24], [77, 45, 67, 89, 73], [12, 47, 80, 57, 58], [63, 51, 76, 68, 14]]], 'objective': 45.0}","[[0, 2, 0], [1, 1, 3], [2, 3, 4], [3, 4, 1], [4, 0, 2]]",45.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [1, 2, 3, 4, 5], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 41}, {'i': 1, 'j': 1, 'k': 2, 'cost': 40}, {'i': 1, 'j': 1, 'k': 3, 'cost': 61}, {'i': 1, 'j': 1, 'k': 4, 'cost': 90}, {'i': 1, 'j': 1, 'k': 5, 'cost': 40}, {'i': 1, 'j': 2, 'k': 1, 'cost': 7}, {'i': 1, 'j': 2, 'k': 2, 'cost': 69}, {'i': 1, 'j': 2, 'k': 3, 'cost': 28}, {'i': 1, 'j': 2, 'k': 4, 'cost': 96}, {'i': 1, 'j': 2, 'k': 5, 'cost': 53}, {'i': 1, 'j': 3, 'k': 1, 'cost': 5}, {'i': 1, 'j': 3, 'k': 2, 'cost': 71}, {'i': 1, 'j': 3, 'k': 3, 'cost': 23}, {'i': 1, 'j': 3, 'k': 4, 'cost': 73}, {'i': 1, 'j': 3, 'k': 5, 'cost': 66}, {'i': 1, 'j': 4, 'k': 1, 'cost': 99}, {'i': 1, 'j': 4, 'k': 2, 'cost': 80}, {'i': 1, 'j': 4, 'k': 3, 'cost': 21}, {'i': 1, 'j': 4, 'k': 4, 'cost': 63}, {'i': 1, 'j': 4, 'k': 5, 'cost': 90}, {'i': 1, 'j': 5, 'k': 1, 'cost': 74}, {'i': 1, 'j': 5, 'k': 2, 'cost': 19}, {'i': 1, 'j': 5, 'k': 3, 'cost': 0}, {'i': 1, 'j': 5, 'k': 4, 'cost': 70}, {'i': 1, 'j': 5, 'k': 5, 'cost': 45}, {'i': 2, 'j': 1, 'k': 1, 'cost': 96}, {'i': 2, 'j': 1, 'k': 2, 'cost': 86}, {'i': 2, 'j': 1, 'k': 3, 'cost': 9}, {'i': 2, 'j': 1, 'k': 4, 'cost': 49}, {'i': 2, 'j': 1, 'k': 5, 'cost': 43}, {'i': 2, 'j': 2, 'k': 1, 'cost': 69}, {'i': 2, 'j': 2, 'k': 2, 'cost': 23}, {'i': 2, 'j': 2, 'k': 3, 'cost': 23}, {'i': 2, 'j': 2, 'k': 4, 'cost': 14}, {'i': 2, 'j': 2, 'k': 5, 'cost': 51}, {'i': 2, 'j': 3, 'k': 1, 'cost': 67}, {'i': 2, 'j': 3, 'k': 2, 'cost': 7}, {'i': 2, 'j': 3, 'k': 3, 'cost': 80}, {'i': 2, 'j': 3, 'k': 4, 'cost': 23}, {'i': 2, 'j': 3, 'k': 5, 'cost': 34}, {'i': 2, 'j': 4, 'k': 1, 'cost': 79}, {'i': 2, 'j': 4, 'k': 2, 'cost': 16}, {'i': 2, 'j': 4, 'k': 3, 'cost': 88}, {'i': 2, 'j': 4, 'k': 4, 'cost': 77}, {'i': 2, 'j': 4, 'k': 5, 'cost': 68}, {'i': 2, 'j': 5, 'k': 1, 'cost': 54}, {'i': 2, 'j': 5, 'k': 2, 'cost': 93}, {'i': 2, 'j': 5, 'k': 3, 'cost': 26}, {'i': 2, 'j': 5, 'k': 4, 'cost': 20}, {'i': 2, 'j': 5, 'k': 5, 'cost': 19}, {'i': 3, 'j': 1, 'k': 1, 'cost': 59}, {'i': 3, 'j': 1, 'k': 2, 'cost': 50}, {'i': 3, 'j': 1, 'k': 3, 'cost': 73}, {'i': 3, 'j': 1, 'k': 4, 'cost': 28}, {'i': 3, 'j': 1, 'k': 5, 'cost': 38}, {'i': 3, 'j': 2, 'k': 1, 'cost': 91}, {'i': 3, 'j': 2, 'k': 2, 'cost': 26}, {'i': 3, 'j': 2, 'k': 3, 'cost': 39}, {'i': 3, 'j': 2, 'k': 4, 'cost': 47}, {'i': 3, 'j': 2, 'k': 5, 'cost': 17}, {'i': 3, 'j': 3, 'k': 1, 'cost': 59}, {'i': 3, 'j': 3, 'k': 2, 'cost': 73}, {'i': 3, 'j': 3, 'k': 3, 'cost': 88}, {'i': 3, 'j': 3, 'k': 4, 'cost': 27}, {'i': 3, 'j': 3, 'k': 5, 'cost': 20}, {'i': 3, 'j': 4, 'k': 1, 'cost': 69}, {'i': 3, 'j': 4, 'k': 2, 'cost': 32}, {'i': 3, 'j': 4, 'k': 3, 'cost': 93}, {'i': 3, 'j': 4, 'k': 4, 'cost': 93}, {'i': 3, 'j': 4, 'k': 5, 'cost': 0}, {'i': 3, 'j': 5, 'k': 1, 'cost': 11}, {'i': 3, 'j': 5, 'k': 2, 'cost': 68}, {'i': 3, 'j': 5, 'k': 3, 'cost': 80}, {'i': 3, 'j': 5, 'k': 4, 'cost': 51}, {'i': 3, 'j': 5, 'k': 5, 'cost': 98}, {'i': 4, 'j': 1, 'k': 1, 'cost': 92}, {'i': 4, 'j': 1, 'k': 2, 'cost': 94}, {'i': 4, 'j': 1, 'k': 3, 'cost': 47}, {'i': 4, 'j': 1, 'k': 4, 'cost': 51}, {'i': 4, 'j': 1, 'k': 5, 'cost': 99}, {'i': 4, 'j': 2, 'k': 1, 'cost': 51}, {'i': 4, 'j': 2, 'k': 2, 'cost': 79}, {'i': 4, 'j': 2, 'k': 3, 'cost': 4}, {'i': 4, 'j': 2, 'k': 4, 'cost': 33}, {'i': 4, 'j': 2, 'k': 5, 'cost': 93}, {'i': 4, 'j': 3, 'k': 1, 'cost': 23}, {'i': 4, 'j': 3, 'k': 2, 'cost': 90}, {'i': 4, 'j': 3, 'k': 3, 'cost': 55}, {'i': 4, 'j': 3, 'k': 4, 'cost': 17}, {'i': 4, 'j': 3, 'k': 5, 'cost': 5}, {'i': 4, 'j': 4, 'k': 1, 'cost': 85}, {'i': 4, 'j': 4, 'k': 2, 'cost': 51}, {'i': 4, 'j': 4, 'k': 3, 'cost': 95}, {'i': 4, 'j': 4, 'k': 4, 'cost': 5}, {'i': 4, 'j': 4, 'k': 5, 'cost': 21}, {'i': 4, 'j': 5, 'k': 1, 'cost': 44}, {'i': 4, 'j': 5, 'k': 2, 'cost': 10}, {'i': 4, 'j': 5, 'k': 3, 'cost': 17}, {'i': 4, 'j': 5, 'k': 4, 'cost': 86}, {'i': 4, 'j': 5, 'k': 5, 'cost': 66}, {'i': 5, 'j': 1, 'k': 1, 'cost': 35}, {'i': 5, 'j': 1, 'k': 2, 'cost': 53}, {'i': 5, 'j': 1, 'k': 3, 'cost': 16}, {'i': 5, 'j': 1, 'k': 4, 'cost': 59}, {'i': 5, 'j': 1, 'k': 5, 'cost': 66}, {'i': 5, 'j': 2, 'k': 1, 'cost': 34}, {'i': 5, 'j': 2, 'k': 2, 'cost': 45}, {'i': 5, 'j': 2, 'k': 3, 'cost': 11}, {'i': 5, 'j': 2, 'k': 4, 'cost': 37}, {'i': 5, 'j': 2, 'k': 5, 'cost': 24}, {'i': 5, 'j': 3, 'k': 1, 'cost': 77}, {'i': 5, 'j': 3, 'k': 2, 'cost': 45}, {'i': 5, 'j': 3, 'k': 3, 'cost': 67}, {'i': 5, 'j': 3, 'k': 4, 'cost': 89}, {'i': 5, 'j': 3, 'k': 5, 'cost': 73}, {'i': 5, 'j': 4, 'k': 1, 'cost': 12}, {'i': 5, 'j': 4, 'k': 2, 'cost': 47}, {'i': 5, 'j': 4, 'k': 3, 'cost': 80}, {'i': 5, 'j': 4, 'k': 4, 'cost': 57}, {'i': 5, 'j': 4, 'k': 5, 'cost': 58}, {'i': 5, 'j': 5, 'k': 1, 'cost': 63}, {'i': 5, 'j': 5, 'k': 2, 'cost': 51}, {'i': 5, 'j': 5, 'k': 3, 'cost': 76}, {'i': 5, 'j': 5, 'k': 4, 'cost': 68}, {'i': 5, 'j': 5, 'k': 5, 'cost': 14}]}","[[1, 3, 1], [2, 2, 4], [3, 4, 5], [4, 5, 2], [5, 1, 3]]",18,json,1
AP3,AP3,"At a busy production house the task is simple to say and tricky to do: give each content creator a single camera kit and a single editing slot, making sure every kit and every slot goes to exactly one creator. Every possible trio of person, kit and slot has a turnaround time, and the right set of choices is the one where the total turnaround — the sum of each chosen trio’s time — comes out the lowest. The full list of creators, kits, slots and their times appears below.

There are 3 creators, 3 camera kits and 3 editing slots, identified as A, B, C.
Meaning: costs form a 3D tensor. For each fixed creator_id=i, you are given a camera_kit_id×editing_slot_id matrix whose entry at row camera_kit_id=j and column editing_slot_id=k equals turnaround_time(i,j,k). You must pick exactly one (j,k) for every i, with all camera_kit_id and all editing_slot_id used exactly once.
turnaround_time_tensor (per-creator_id markdown matrices):
## creator_id=A
| camera_kit_id\editing_slot_id | A | B | C |
|---|---|---|---|
| A | 85 | 78 | 20 |
| B | 84 | 47 | 6 |
| C | 27 | 17 | 81 |

## creator_id=B
| camera_kit_id\editing_slot_id | A | B | C |
|---|---|---|---|
| A | 53 | 83 | 11 |
| B | 8 | 15 | 36 |
| C | 27 | 58 | 84 |

## creator_id=C
| camera_kit_id\editing_slot_id | A | B | C |
|---|---|---|---|
| A | 6 | 1 | 29 |
| B | 36 | 56 | 85 |
| C | 83 | 91 | 37 |
The goal is to pick one kit and one slot for each creator so the sum of the chosen turnaround times is minimized.

If you want to send back the chosen assignment, you can just paste it in a small JSON snippet like this:

{
  ""solution"": [
    [<creator_id>, <kit_id>, <slot_id>],
    ...
  ]
}

This is just a simple sketch: ""solution"" holds a list of triples, and each triple is one creator paired with the kit and the editing slot assigned to them, in that order. Replace the placeholders with the actual IDs from the instance when you reply.

Please be sure to use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[85, 78, 20], [84, 47, 6], [27, 17, 81]], [[53, 83, 11], [8, 15, 36], [27, 58, 84]], [[6, 1, 29], [36, 56, 85], [83, 91, 37]]], 'objective': 34.0}","[[0, 1, 2], [1, 2, 0], [2, 0, 1]]",34.0,"{'problem_type': 'AP3', 'n': 3, 'ids': ['A', 'B', 'C'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 85}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 78}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 20}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 84}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 47}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 6}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 27}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 17}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 81}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 53}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 83}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 11}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 8}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 15}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 36}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 27}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 58}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 84}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 6}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 1}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 29}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 36}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 56}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 85}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 83}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 91}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 37}]}","[['A', 'B', 'C'], ['B', 'C', 'A'], ['C', 'A', 'B']]",19,nl,names
AP3,AP3,"Someone in the team described it like this: every prototype needs one tester and one test rig, and every tester and every rig can only be used once. So the task is to decide, for each prototype, which tester and which rig to pair with it, making sure there are no duplicates or leftovers. What counts as a better plan is simply the one with the smallest combined testing cost — calculate that by summing the cost of each prototype’s assigned tester-and-rig. The concrete cost table is shown below.

The concrete cost table follows for 4 prototypes: A, B, C, D.
Meaning: costs form a 3D tensor. For each fixed prototype_id=i, you are given a tester_id×rig_id matrix whose entry at row tester_id=j and column rig_id=k equals test_cost(i,j,k). You must pick exactly one (j,k) for every i, with all tester_id and all rig_id used exactly once.
test_cost_tensor (per-prototype_id markdown matrices):
## prototype_id=A
| tester_id\rig_id | A | B | C | D |
|---|---|---|---|---|
| A | 4 | 7 | 10 | 64 |
| B | 99 | 67 | 62 | 63 |
| C | 95 | 29 | 98 | 26 |
| D | 10 | 66 | 25 | 64 |

## prototype_id=B
| tester_id\rig_id | A | B | C | D |
|---|---|---|---|---|
| A | 76 | 71 | 83 | 8 |
| B | 28 | 56 | 2 | 35 |
| C | 59 | 81 | 15 | 82 |
| D | 40 | 56 | 12 | 59 |

## prototype_id=C
| tester_id\rig_id | A | B | C | D |
|---|---|---|---|---|
| A | 1 | 76 | 45 | 90 |
| B | 70 | 19 | 86 | 6 |
| C | 89 | 92 | 81 | 71 |
| D | 46 | 71 | 37 | 73 |

## prototype_id=D
| tester_id\rig_id | A | B | C | D |
|---|---|---|---|---|
| A | 49 | 65 | 41 | 16 |
| B | 52 | 18 | 74 | 24 |
| C | 65 | 15 | 52 | 72 |
| D | 52 | 54 | 91 | 15 |
Assign one tester and one rig to each of the 4 prototypes so the total testing cost is minimized.

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

{
  ""solution"": [
    [<prototype_id>, <tester_id>, <rig_id>],
    ...
  ]
}

This just sketches the shape I expect: ""solution"" is a list, and each inner triple picks the prototype together with the tester and the rig you want to pair it with. Think of each triple like filling out a single line on a form: which prototype, which tester, which rig. It's just a template — not the actual assignments.

Please make sure to 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”.""","{'cost_tensor': [[[4, 7, 10, 64], [99, 67, 62, 63], [95, 29, 98, 26], [10, 66, 25, 64]], [[76, 71, 83, 8], [28, 56, 2, 35], [59, 81, 15, 82], [40, 56, 12, 59]], [[1, 76, 45, 90], [70, 19, 86, 6], [89, 92, 81, 71], [46, 71, 37, 73]], [[49, 65, 41, 16], [52, 18, 74, 24], [65, 15, 52, 72], [52, 54, 91, 15]]], 'objective': 37.0}","[[0, 0, 0], [1, 3, 2], [2, 1, 3], [3, 2, 1]]",37.0,"{'problem_type': 'AP3', 'n': 4, 'ids': ['A', 'B', 'C', 'D'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 4}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 7}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 10}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 64}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 99}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 67}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 62}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 63}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 95}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 29}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 98}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 26}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 10}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 66}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 25}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 64}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 76}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 71}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 83}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 8}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 28}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 56}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 2}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 35}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 59}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 81}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 15}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 82}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 40}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 56}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 12}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 59}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 1}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 76}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 45}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 90}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 70}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 19}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 86}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 6}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 89}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 92}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 81}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 71}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 46}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 71}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 37}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 73}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 49}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 65}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 41}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 16}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 52}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 18}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 74}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 24}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 65}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 15}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 52}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 72}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 52}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 54}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 91}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 15}]}","[['A', 'A', 'A'], ['B', 'D', 'C'], ['C', 'B', 'D'], ['D', 'C', 'B']]",20,nl,names
AP3,AP3,"I manage a small photo studio and have a stack of bookings that all need a photographer and an equipment kit. The job is to pick one photographer and one kit for each shoot so that every photographer and every kit gets used once and nothing is left sitting idle or doubled up. For each shoot the cost is the photographer’s fee plus the kit rental, and the idea is to pick pairings that keep the overall bill as low as possible by adding up those fees across all shoots. The exact shoots, people, kits, and prices are shown below.

{
  ""num_shoots"": 5,
  ""index_ids"": [
    0,
    1,
    2,
    3,
    4
  ]
}

# Meaning: costs form a 3D tensor. For each fixed shoot_id=i, you are given a photographer_id×kit_id matrix whose entry at row photographer_id=j and column kit_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all photographer_id and all kit_id used exactly once.
# assignment_cost_tensor (per-shoot_id markdown matrices)

## shoot_id=0
| photographer_id\kit_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 6 | 85 | 67 | 81 | 77 |
| 1 | 85 | 21 | 63 | 23 | 70 |
| 2 | 78 | 92 | 29 | 45 | 5 |
| 3 | 23 | 21 | 64 | 4 | 34 |
| 4 | 75 | 45 | 94 | 20 | 2 |

## shoot_id=1
| photographer_id\kit_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 19 | 15 | 36 | 64 | 13 |
| 1 | 98 | 74 | 25 | 21 | 44 |
| 2 | 79 | 22 | 37 | 90 | 45 |
| 3 | 76 | 95 | 19 | 70 | 6 |
| 4 | 15 | 34 | 37 | 1 | 84 |

## shoot_id=2
| photographer_id\kit_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 23 | 48 | 84 | 7 | 5 |
| 1 | 32 | 39 | 26 | 49 | 95 |
| 2 | 84 | 58 | 4 | 4 | 3 |
| 3 | 67 | 86 | 80 | 30 | 94 |
| 4 | 0 | 6 | 67 | 36 | 20 |

## shoot_id=3
| photographer_id\kit_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 6 | 42 | 9 | 30 | 70 |
| 1 | 89 | 69 | 68 | 62 | 24 |
| 2 | 47 | 75 | 35 | 91 | 33 |
| 3 | 7 | 37 | 71 | 41 | 40 |
| 4 | 76 | 29 | 23 | 74 | 45 |

## shoot_id=4
| photographer_id\kit_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 10 | 83 | 43 | 65 | 87 |
| 1 | 12 | 26 | 47 | 79 | 68 |
| 2 | 36 | 17 | 30 | 76 | 40 |
| 3 | 93 | 94 | 75 | 35 | 66 |
| 4 | 2 | 44 | 90 | 63 | 14 |

Oh, and when you send back the actual matchings, a simple JSON sketch like this works great:

{
  ""solution"": [
    [<shoot_id>, <photographer_id>, <kit_id>],
    ...
  ]
}

""solution"" is just a list of triples: each triple assigns one photographer and one equipment kit to a single shoot. Think of each inner list as [shoot_id, photographer_id, kit_id]. This block is only the expected shape — a template — not the real answer.

Please use the exact identifiers given in the instance input — do not rename them or invent new labels. Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'cost_tensor': [[[6, 85, 67, 81, 77], [85, 21, 63, 23, 70], [78, 92, 29, 45, 5], [23, 21, 64, 4, 34], [75, 45, 94, 20, 2]], [[19, 15, 36, 64, 13], [98, 74, 25, 21, 44], [79, 22, 37, 90, 45], [76, 95, 19, 70, 6], [15, 34, 37, 1, 84]], [[23, 48, 84, 7, 5], [32, 39, 26, 49, 95], [84, 58, 4, 4, 3], [67, 86, 80, 30, 94], [0, 6, 67, 36, 20]], [[6, 42, 9, 30, 70], [89, 69, 68, 62, 24], [47, 75, 35, 91, 33], [7, 37, 71, 41, 40], [76, 29, 23, 74, 45]], [[10, 83, 43, 65, 87], [12, 26, 47, 79, 68], [36, 17, 30, 76, 40], [93, 94, 75, 35, 66], [2, 44, 90, 63, 14]]], 'objective': 42.0}","[[0, 1, 1], [1, 3, 4], [2, 2, 3], [3, 0, 2], [4, 4, 0]]",42.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [0, 1, 2, 3, 4], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 6}, {'i': 0, 'j': 0, 'k': 1, 'cost': 85}, {'i': 0, 'j': 0, 'k': 2, 'cost': 67}, {'i': 0, 'j': 0, 'k': 3, 'cost': 81}, {'i': 0, 'j': 0, 'k': 4, 'cost': 77}, {'i': 0, 'j': 1, 'k': 0, 'cost': 85}, {'i': 0, 'j': 1, 'k': 1, 'cost': 21}, {'i': 0, 'j': 1, 'k': 2, 'cost': 63}, {'i': 0, 'j': 1, 'k': 3, 'cost': 23}, {'i': 0, 'j': 1, 'k': 4, 'cost': 70}, {'i': 0, 'j': 2, 'k': 0, 'cost': 78}, {'i': 0, 'j': 2, 'k': 1, 'cost': 92}, {'i': 0, 'j': 2, 'k': 2, 'cost': 29}, {'i': 0, 'j': 2, 'k': 3, 'cost': 45}, {'i': 0, 'j': 2, 'k': 4, 'cost': 5}, {'i': 0, 'j': 3, 'k': 0, 'cost': 23}, {'i': 0, 'j': 3, 'k': 1, 'cost': 21}, {'i': 0, 'j': 3, 'k': 2, 'cost': 64}, {'i': 0, 'j': 3, 'k': 3, 'cost': 4}, {'i': 0, 'j': 3, 'k': 4, 'cost': 34}, {'i': 0, 'j': 4, 'k': 0, 'cost': 75}, {'i': 0, 'j': 4, 'k': 1, 'cost': 45}, {'i': 0, 'j': 4, 'k': 2, 'cost': 94}, {'i': 0, 'j': 4, 'k': 3, 'cost': 20}, {'i': 0, 'j': 4, 'k': 4, 'cost': 2}, {'i': 1, 'j': 0, 'k': 0, 'cost': 19}, {'i': 1, 'j': 0, 'k': 1, 'cost': 15}, {'i': 1, 'j': 0, 'k': 2, 'cost': 36}, {'i': 1, 'j': 0, 'k': 3, 'cost': 64}, {'i': 1, 'j': 0, 'k': 4, 'cost': 13}, {'i': 1, 'j': 1, 'k': 0, 'cost': 98}, {'i': 1, 'j': 1, 'k': 1, 'cost': 74}, {'i': 1, 'j': 1, 'k': 2, 'cost': 25}, {'i': 1, 'j': 1, 'k': 3, 'cost': 21}, {'i': 1, 'j': 1, 'k': 4, 'cost': 44}, {'i': 1, 'j': 2, 'k': 0, 'cost': 79}, {'i': 1, 'j': 2, 'k': 1, 'cost': 22}, {'i': 1, 'j': 2, 'k': 2, 'cost': 37}, {'i': 1, 'j': 2, 'k': 3, 'cost': 90}, {'i': 1, 'j': 2, 'k': 4, 'cost': 45}, {'i': 1, 'j': 3, 'k': 0, 'cost': 76}, {'i': 1, 'j': 3, 'k': 1, 'cost': 95}, {'i': 1, 'j': 3, 'k': 2, 'cost': 19}, {'i': 1, 'j': 3, 'k': 3, 'cost': 70}, {'i': 1, 'j': 3, 'k': 4, 'cost': 6}, {'i': 1, 'j': 4, 'k': 0, 'cost': 15}, {'i': 1, 'j': 4, 'k': 1, 'cost': 34}, {'i': 1, 'j': 4, 'k': 2, 'cost': 37}, {'i': 1, 'j': 4, 'k': 3, 'cost': 1}, {'i': 1, 'j': 4, 'k': 4, 'cost': 84}, {'i': 2, 'j': 0, 'k': 0, 'cost': 23}, {'i': 2, 'j': 0, 'k': 1, 'cost': 48}, {'i': 2, 'j': 0, 'k': 2, 'cost': 84}, {'i': 2, 'j': 0, 'k': 3, 'cost': 7}, {'i': 2, 'j': 0, 'k': 4, 'cost': 5}, {'i': 2, 'j': 1, 'k': 0, 'cost': 32}, {'i': 2, 'j': 1, 'k': 1, 'cost': 39}, {'i': 2, 'j': 1, 'k': 2, 'cost': 26}, {'i': 2, 'j': 1, 'k': 3, 'cost': 49}, {'i': 2, 'j': 1, 'k': 4, 'cost': 95}, {'i': 2, 'j': 2, 'k': 0, 'cost': 84}, {'i': 2, 'j': 2, 'k': 1, 'cost': 58}, {'i': 2, 'j': 2, 'k': 2, 'cost': 4}, {'i': 2, 'j': 2, 'k': 3, 'cost': 4}, {'i': 2, 'j': 2, 'k': 4, 'cost': 3}, {'i': 2, 'j': 3, 'k': 0, 'cost': 67}, {'i': 2, 'j': 3, 'k': 1, 'cost': 86}, {'i': 2, 'j': 3, 'k': 2, 'cost': 80}, {'i': 2, 'j': 3, 'k': 3, 'cost': 30}, {'i': 2, 'j': 3, 'k': 4, 'cost': 94}, {'i': 2, 'j': 4, 'k': 0, 'cost': 0}, {'i': 2, 'j': 4, 'k': 1, 'cost': 6}, {'i': 2, 'j': 4, 'k': 2, 'cost': 67}, {'i': 2, 'j': 4, 'k': 3, 'cost': 36}, {'i': 2, 'j': 4, 'k': 4, 'cost': 20}, {'i': 3, 'j': 0, 'k': 0, 'cost': 6}, {'i': 3, 'j': 0, 'k': 1, 'cost': 42}, {'i': 3, 'j': 0, 'k': 2, 'cost': 9}, {'i': 3, 'j': 0, 'k': 3, 'cost': 30}, {'i': 3, 'j': 0, 'k': 4, 'cost': 70}, {'i': 3, 'j': 1, 'k': 0, 'cost': 89}, {'i': 3, 'j': 1, 'k': 1, 'cost': 69}, {'i': 3, 'j': 1, 'k': 2, 'cost': 68}, {'i': 3, 'j': 1, 'k': 3, 'cost': 62}, {'i': 3, 'j': 1, 'k': 4, 'cost': 24}, {'i': 3, 'j': 2, 'k': 0, 'cost': 47}, {'i': 3, 'j': 2, 'k': 1, 'cost': 75}, {'i': 3, 'j': 2, 'k': 2, 'cost': 35}, {'i': 3, 'j': 2, 'k': 3, 'cost': 91}, {'i': 3, 'j': 2, 'k': 4, 'cost': 33}, {'i': 3, 'j': 3, 'k': 0, 'cost': 7}, {'i': 3, 'j': 3, 'k': 1, 'cost': 37}, {'i': 3, 'j': 3, 'k': 2, 'cost': 71}, {'i': 3, 'j': 3, 'k': 3, 'cost': 41}, {'i': 3, 'j': 3, 'k': 4, 'cost': 40}, {'i': 3, 'j': 4, 'k': 0, 'cost': 76}, {'i': 3, 'j': 4, 'k': 1, 'cost': 29}, {'i': 3, 'j': 4, 'k': 2, 'cost': 23}, {'i': 3, 'j': 4, 'k': 3, 'cost': 74}, {'i': 3, 'j': 4, 'k': 4, 'cost': 45}, {'i': 4, 'j': 0, 'k': 0, 'cost': 10}, {'i': 4, 'j': 0, 'k': 1, 'cost': 83}, {'i': 4, 'j': 0, 'k': 2, 'cost': 43}, {'i': 4, 'j': 0, 'k': 3, 'cost': 65}, {'i': 4, 'j': 0, 'k': 4, 'cost': 87}, {'i': 4, 'j': 1, 'k': 0, 'cost': 12}, {'i': 4, 'j': 1, 'k': 1, 'cost': 26}, {'i': 4, 'j': 1, 'k': 2, 'cost': 47}, {'i': 4, 'j': 1, 'k': 3, 'cost': 79}, {'i': 4, 'j': 1, 'k': 4, 'cost': 68}, {'i': 4, 'j': 2, 'k': 0, 'cost': 36}, {'i': 4, 'j': 2, 'k': 1, 'cost': 17}, {'i': 4, 'j': 2, 'k': 2, 'cost': 30}, {'i': 4, 'j': 2, 'k': 3, 'cost': 76}, {'i': 4, 'j': 2, 'k': 4, 'cost': 40}, {'i': 4, 'j': 3, 'k': 0, 'cost': 93}, {'i': 4, 'j': 3, 'k': 1, 'cost': 94}, {'i': 4, 'j': 3, 'k': 2, 'cost': 75}, {'i': 4, 'j': 3, 'k': 3, 'cost': 35}, {'i': 4, 'j': 3, 'k': 4, 'cost': 66}, {'i': 4, 'j': 4, 'k': 0, 'cost': 2}, {'i': 4, 'j': 4, 'k': 1, 'cost': 44}, {'i': 4, 'j': 4, 'k': 2, 'cost': 90}, {'i': 4, 'j': 4, 'k': 3, 'cost': 63}, {'i': 4, 'j': 4, 'k': 4, 'cost': 14}]}","[[0, 1, 1], [1, 3, 4], [2, 2, 3], [3, 0, 2], [4, 4, 0]]",21,json,0
AP3,AP3,"A friend who runs a courier service described it this way: there are as many jobs as there are drivers and vans, so each job gets paired with a single driver and a single van, and every driver and van gets used exactly once. Each possible pairing has fuel and time figures attached, and the aim is to choose pairings so that, after summing fuel and time for every job, the overall total is as small as possible. The detailed list of combos and their costs appears below.

{
  ""num_orders"": 3,
  ""index_identifiers"": [
    1,
    2,
    3
  ]
}

# Meaning: costs form a 3D tensor. For each fixed order_id=i, you are given a driver_id×van_id matrix whose entry at row driver_id=j and column van_id=k equals fuel_time_cost(i,j,k). You must pick exactly one (j,k) for every i, with all driver_id and all van_id used exactly once.
# fuel_time_cost_tensor (per-order_id markdown matrices)

## order_id=1
| driver_id\van_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 65 | 50 | 29 |
| 2 | 90 | 92 | 36 |
| 3 | 81 | 44 | 32 |

## order_id=2
| driver_id\van_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 47 | 65 | 16 |
| 2 | 82 | 22 | 53 |
| 3 | 10 | 75 | 77 |

## order_id=3
| driver_id\van_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 61 | 89 | 65 |
| 2 | 36 | 67 | 64 |
| 3 | 44 | 55 | 55 |

If you want to hand the chosen pairings to me in a neat, machine-friendly way, just use this JSON shape:

{
  ""solution"": [
    [<i_id>, <j_id>, <k_id>],
    ...
  ]
}

Here ""solution"" is a list of triples. Each triple [i, j, k] means: job i is done by driver j using van k. Think of it like filling out a simple form — one triple per job, and together they describe all the pairings. This JSON block is only a sketch of the expected shape, not the actual answer.

Please be sure to use the exact identifiers from the instance input — don't rename them or invent new labels. Valid identifiers look like:
- plain numbers such as ""1"" or ""23""
- single capital letters like ""A"" or ""B""
- a capital letter followed by digits like ""A1"" or ""X7""","{'cost_tensor': [[[65, 50, 29], [90, 92, 36], [81, 44, 32]], [[47, 65, 16], [82, 22, 53], [10, 75, 77]], [[61, 89, 65], [36, 67, 64], [44, 55, 55]]], 'objective': 95.0}","[[0, 0, 2], [1, 1, 1], [2, 2, 0]]",95.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [1, 2, 3], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 65}, {'i': 1, 'j': 1, 'k': 2, 'cost': 50}, {'i': 1, 'j': 1, 'k': 3, 'cost': 29}, {'i': 1, 'j': 2, 'k': 1, 'cost': 90}, {'i': 1, 'j': 2, 'k': 2, 'cost': 92}, {'i': 1, 'j': 2, 'k': 3, 'cost': 36}, {'i': 1, 'j': 3, 'k': 1, 'cost': 81}, {'i': 1, 'j': 3, 'k': 2, 'cost': 44}, {'i': 1, 'j': 3, 'k': 3, 'cost': 32}, {'i': 2, 'j': 1, 'k': 1, 'cost': 47}, {'i': 2, 'j': 1, 'k': 2, 'cost': 65}, {'i': 2, 'j': 1, 'k': 3, 'cost': 16}, {'i': 2, 'j': 2, 'k': 1, 'cost': 82}, {'i': 2, 'j': 2, 'k': 2, 'cost': 22}, {'i': 2, 'j': 2, 'k': 3, 'cost': 53}, {'i': 2, 'j': 3, 'k': 1, 'cost': 10}, {'i': 2, 'j': 3, 'k': 2, 'cost': 75}, {'i': 2, 'j': 3, 'k': 3, 'cost': 77}, {'i': 3, 'j': 1, 'k': 1, 'cost': 61}, {'i': 3, 'j': 1, 'k': 2, 'cost': 89}, {'i': 3, 'j': 1, 'k': 3, 'cost': 65}, {'i': 3, 'j': 2, 'k': 1, 'cost': 36}, {'i': 3, 'j': 2, 'k': 2, 'cost': 67}, {'i': 3, 'j': 2, 'k': 3, 'cost': 64}, {'i': 3, 'j': 3, 'k': 1, 'cost': 44}, {'i': 3, 'j': 3, 'k': 2, 'cost': 55}, {'i': 3, 'j': 3, 'k': 3, 'cost': 55}]}","[[1, 1, 3], [2, 2, 2], [3, 3, 1]]",22,json,1
AP3,AP3,"Someone on the events team has to pair each scheduled activity with a single volunteer and a single station so that no volunteer or station is used more than once and nothing is left out. The goal is clear in plain terms — minimize the whole staffing charge by adding up the cost for each activity’s volunteer-and-station match and keeping that overall sum as small as possible. The full list of activities, volunteers, stations and their costs appears below.

There are 4 activities, listed by identifier as 1, 2, 3, 4.
Meaning: costs form a 3D tensor. For each fixed activity_id=i, you are given a volunteer_id×station_id matrix whose entry at row volunteer_id=j and column station_id=k equals staffing_cost(i,j,k). You must pick exactly one (j,k) for every i, with all volunteer_id and all station_id used exactly once.
staffing_cost_tensor (per-activity_id markdown matrices):
## activity_id=1
| volunteer_id\station_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 19 | 77 | 60 | 8 |
| 2 | 46 | 5 | 33 | 59 |
| 3 | 10 | 13 | 30 | 5 |
| 4 | 76 | 15 | 52 | 88 |

## activity_id=2
| volunteer_id\station_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 29 | 54 | 78 | 63 |
| 2 | 98 | 87 | 32 | 69 |
| 3 | 57 | 3 | 94 | 19 |
| 4 | 17 | 6 | 92 | 14 |

## activity_id=3
| volunteer_id\station_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 9 | 79 | 2 | 1 |
| 2 | 41 | 43 | 80 | 87 |
| 3 | 69 | 34 | 68 | 68 |
| 4 | 45 | 97 | 65 | 30 |

## activity_id=4
| volunteer_id\station_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 61 | 87 | 33 | 28 |
| 2 | 54 | 1 | 72 | 81 |
| 3 | 66 | 26 | 97 | 97 |
| 4 | 2 | 69 | 47 | 6 |
Choose one of these triples for each of the 4 activities so every identifier in 1, 2, 3, 4 is covered and each volunteer and station is used exactly once to minimize the total staffing cost.

You can send back the matching in a simple JSON shape like this — casual and machine-friendly at the same time.

{
  ""solution"": [
    [<activity_id>, <volunteer_id>, <station_id>],
    ...
  ]
}

Each little triple is one activity matched with its volunteer and station. The outer array collects one triple per activity so everything is assigned once. This JSON is just a sketch of the shape I want you to use, not the actual answer itself.

Please make sure you use the exact identifiers from the instance input — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[19, 77, 60, 8], [46, 5, 33, 59], [10, 13, 30, 5], [76, 15, 52, 88]], [[29, 54, 78, 63], [98, 87, 32, 69], [57, 3, 94, 19], [17, 6, 92, 14]], [[9, 79, 2, 1], [41, 43, 80, 87], [69, 34, 68, 68], [45, 97, 65, 30]], [[61, 87, 33, 28], [54, 1, 72, 81], [66, 26, 97, 97], [2, 69, 47, 6]]], 'objective': 25.0}","[[0, 2, 3], [1, 3, 0], [2, 0, 2], [3, 1, 1]]",25.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 19}, {'i': 1, 'j': 1, 'k': 2, 'cost': 77}, {'i': 1, 'j': 1, 'k': 3, 'cost': 60}, {'i': 1, 'j': 1, 'k': 4, 'cost': 8}, {'i': 1, 'j': 2, 'k': 1, 'cost': 46}, {'i': 1, 'j': 2, 'k': 2, 'cost': 5}, {'i': 1, 'j': 2, 'k': 3, 'cost': 33}, {'i': 1, 'j': 2, 'k': 4, 'cost': 59}, {'i': 1, 'j': 3, 'k': 1, 'cost': 10}, {'i': 1, 'j': 3, 'k': 2, 'cost': 13}, {'i': 1, 'j': 3, 'k': 3, 'cost': 30}, {'i': 1, 'j': 3, 'k': 4, 'cost': 5}, {'i': 1, 'j': 4, 'k': 1, 'cost': 76}, {'i': 1, 'j': 4, 'k': 2, 'cost': 15}, {'i': 1, 'j': 4, 'k': 3, 'cost': 52}, {'i': 1, 'j': 4, 'k': 4, 'cost': 88}, {'i': 2, 'j': 1, 'k': 1, 'cost': 29}, {'i': 2, 'j': 1, 'k': 2, 'cost': 54}, {'i': 2, 'j': 1, 'k': 3, 'cost': 78}, {'i': 2, 'j': 1, 'k': 4, 'cost': 63}, {'i': 2, 'j': 2, 'k': 1, 'cost': 98}, {'i': 2, 'j': 2, 'k': 2, 'cost': 87}, {'i': 2, 'j': 2, 'k': 3, 'cost': 32}, {'i': 2, 'j': 2, 'k': 4, 'cost': 69}, {'i': 2, 'j': 3, 'k': 1, 'cost': 57}, {'i': 2, 'j': 3, 'k': 2, 'cost': 3}, {'i': 2, 'j': 3, 'k': 3, 'cost': 94}, {'i': 2, 'j': 3, 'k': 4, 'cost': 19}, {'i': 2, 'j': 4, 'k': 1, 'cost': 17}, {'i': 2, 'j': 4, 'k': 2, 'cost': 6}, {'i': 2, 'j': 4, 'k': 3, 'cost': 92}, {'i': 2, 'j': 4, 'k': 4, 'cost': 14}, {'i': 3, 'j': 1, 'k': 1, 'cost': 9}, {'i': 3, 'j': 1, 'k': 2, 'cost': 79}, {'i': 3, 'j': 1, 'k': 3, 'cost': 2}, {'i': 3, 'j': 1, 'k': 4, 'cost': 1}, {'i': 3, 'j': 2, 'k': 1, 'cost': 41}, {'i': 3, 'j': 2, 'k': 2, 'cost': 43}, {'i': 3, 'j': 2, 'k': 3, 'cost': 80}, {'i': 3, 'j': 2, 'k': 4, 'cost': 87}, {'i': 3, 'j': 3, 'k': 1, 'cost': 69}, {'i': 3, 'j': 3, 'k': 2, 'cost': 34}, {'i': 3, 'j': 3, 'k': 3, 'cost': 68}, {'i': 3, 'j': 3, 'k': 4, 'cost': 68}, {'i': 3, 'j': 4, 'k': 1, 'cost': 45}, {'i': 3, 'j': 4, 'k': 2, 'cost': 97}, {'i': 3, 'j': 4, 'k': 3, 'cost': 65}, {'i': 3, 'j': 4, 'k': 4, 'cost': 30}, {'i': 4, 'j': 1, 'k': 1, 'cost': 61}, {'i': 4, 'j': 1, 'k': 2, 'cost': 87}, {'i': 4, 'j': 1, 'k': 3, 'cost': 33}, {'i': 4, 'j': 1, 'k': 4, 'cost': 28}, {'i': 4, 'j': 2, 'k': 1, 'cost': 54}, {'i': 4, 'j': 2, 'k': 2, 'cost': 1}, {'i': 4, 'j': 2, 'k': 3, 'cost': 72}, {'i': 4, 'j': 2, 'k': 4, 'cost': 81}, {'i': 4, 'j': 3, 'k': 1, 'cost': 66}, {'i': 4, 'j': 3, 'k': 2, 'cost': 26}, {'i': 4, 'j': 3, 'k': 3, 'cost': 97}, {'i': 4, 'j': 3, 'k': 4, 'cost': 97}, {'i': 4, 'j': 4, 'k': 1, 'cost': 2}, {'i': 4, 'j': 4, 'k': 2, 'cost': 69}, {'i': 4, 'j': 4, 'k': 3, 'cost': 47}, {'i': 4, 'j': 4, 'k': 4, 'cost': 6}]}","[[1, 3, 4], [2, 4, 1], [3, 1, 3], [4, 2, 2]]",23,nl,1
AP3,AP3,"I run a tiny shipping crew and every morning there’s a stack of packages waiting. The job is to pick one courier and one route for each package so that every courier and every route ends up handling exactly one package — nobody doubles up and nothing gets skipped. Each possible package–courier–route combination has a transit cost, and the plan that’s best is the one with the smallest total bill when all those individual costs are added together. The concrete details are shown below.

There are 5 packages waiting this morning, with IDs A, B, C, D, E.

*Meaning: costs form a 3D tensor. For each fixed package_id=i, you are given a courier_id×route_id matrix whose entry at row courier_id=j and column route_id=k equals transit_cost(i,j,k). You must pick exactly one (j,k) for every i, with all courier_id and all route_id used exactly once.*

**transit_cost_tensor (per-package_id markdown matrices)**

## package_id=A
| courier_id\route_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 20 | 83 | 33 | 58 | 53 |
| B | 67 | 57 | 62 | 25 | 87 |
| C | 51 | 12 | 74 | 52 | 94 |
| D | 37 | 2 | 26 | 76 | 1 |
| E | 45 | 17 | 98 | 4 | 91 |

## package_id=B
| courier_id\route_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 44 | 76 | 2 | 92 | 43 |
| B | 29 | 35 | 59 | 17 | 30 |
| C | 84 | 84 | 53 | 32 | 20 |
| D | 36 | 89 | 77 | 15 | 68 |
| E | 46 | 72 | 56 | 52 | 90 |

## package_id=C
| courier_id\route_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 10 | 82 | 92 | 39 | 12 |
| B | 81 | 5 | 90 | 56 | 62 |
| C | 75 | 80 | 95 | 98 | 81 |
| D | 84 | 23 | 30 | 85 | 81 |
| E | 19 | 10 | 14 | 20 | 46 |

## package_id=D
| courier_id\route_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 82 | 63 | 45 | 47 | 83 |
| B | 78 | 21 | 67 | 46 | 99 |
| C | 12 | 78 | 30 | 73 | 67 |
| D | 64 | 92 | 98 | 94 | 17 |
| E | 28 | 91 | 57 | 18 | 11 |

## package_id=E
| courier_id\route_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 49 | 69 | 92 | 84 | 1 |
| B | 99 | 64 | 39 | 70 | 35 |
| C | 64 | 84 | 40 | 98 | 25 |
| D | 2 | 97 | 28 | 0 | 47 |
| E | 53 | 93 | 55 | 58 | 66 |

I'll pick one courier and one route for each package to minimize the total transit cost.

If you want the plan in a simple, machine-readable form, just follow this little JSON shape — nothing fancy, just a list of triples showing which package goes with which courier and which route:

{
  ""solution"": [
    [<package_id>, <courier_id>, <route_id>],
    ...
  ]
}

Think of each inner triple as a single row on a form: the first entry is the package, the second is the courier assigned to it, and the third is the route they’ll take. This block is just a sketch of the shape I expect, not the actual assignment.

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”.""","{'cost_tensor': [[[20, 83, 33, 58, 53], [67, 57, 62, 25, 87], [51, 12, 74, 52, 94], [37, 2, 26, 76, 1], [45, 17, 98, 4, 91]], [[44, 76, 2, 92, 43], [29, 35, 59, 17, 30], [84, 84, 53, 32, 20], [36, 89, 77, 15, 68], [46, 72, 56, 52, 90]], [[10, 82, 92, 39, 12], [81, 5, 90, 56, 62], [75, 80, 95, 98, 81], [84, 23, 30, 85, 81], [19, 10, 14, 20, 46]], [[82, 63, 45, 47, 83], [78, 21, 67, 46, 99], [12, 78, 30, 73, 67], [64, 92, 98, 94, 17], [28, 91, 57, 18, 11]], [[49, 69, 92, 84, 1], [99, 64, 39, 70, 35], [64, 84, 40, 98, 25], [2, 97, 28, 0, 47], [53, 93, 55, 58, 66]]], 'objective': 46.0}","[[0, 3, 1], [1, 1, 3], [2, 4, 2], [3, 2, 0], [4, 0, 4]]",46.0,"{'problem_type': 'AP3', 'n': 5, 'ids': ['A', 'B', 'C', 'D', 'E'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 20}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 83}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 33}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 58}, {'i': 'A', 'j': 'A', 'k': 'E', 'cost': 53}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 67}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 57}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 62}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 25}, {'i': 'A', 'j': 'B', 'k': 'E', 'cost': 87}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 51}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 12}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 74}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 52}, {'i': 'A', 'j': 'C', 'k': 'E', 'cost': 94}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 37}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 2}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 26}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 76}, {'i': 'A', 'j': 'D', 'k': 'E', 'cost': 1}, {'i': 'A', 'j': 'E', 'k': 'A', 'cost': 45}, {'i': 'A', 'j': 'E', 'k': 'B', 'cost': 17}, {'i': 'A', 'j': 'E', 'k': 'C', 'cost': 98}, {'i': 'A', 'j': 'E', 'k': 'D', 'cost': 4}, {'i': 'A', 'j': 'E', 'k': 'E', 'cost': 91}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 44}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 76}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 2}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 92}, {'i': 'B', 'j': 'A', 'k': 'E', 'cost': 43}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 29}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 35}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 59}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 17}, {'i': 'B', 'j': 'B', 'k': 'E', 'cost': 30}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 84}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 84}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 53}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 32}, {'i': 'B', 'j': 'C', 'k': 'E', 'cost': 20}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 36}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 89}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 77}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 15}, {'i': 'B', 'j': 'D', 'k': 'E', 'cost': 68}, {'i': 'B', 'j': 'E', 'k': 'A', 'cost': 46}, {'i': 'B', 'j': 'E', 'k': 'B', 'cost': 72}, {'i': 'B', 'j': 'E', 'k': 'C', 'cost': 56}, {'i': 'B', 'j': 'E', 'k': 'D', 'cost': 52}, {'i': 'B', 'j': 'E', 'k': 'E', 'cost': 90}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 10}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 82}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 92}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 39}, {'i': 'C', 'j': 'A', 'k': 'E', 'cost': 12}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 81}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 5}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 90}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 56}, {'i': 'C', 'j': 'B', 'k': 'E', 'cost': 62}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 75}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 80}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 95}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 98}, {'i': 'C', 'j': 'C', 'k': 'E', 'cost': 81}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 84}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 23}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 30}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 85}, {'i': 'C', 'j': 'D', 'k': 'E', 'cost': 81}, {'i': 'C', 'j': 'E', 'k': 'A', 'cost': 19}, {'i': 'C', 'j': 'E', 'k': 'B', 'cost': 10}, {'i': 'C', 'j': 'E', 'k': 'C', 'cost': 14}, {'i': 'C', 'j': 'E', 'k': 'D', 'cost': 20}, {'i': 'C', 'j': 'E', 'k': 'E', 'cost': 46}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 82}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 63}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 45}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 47}, {'i': 'D', 'j': 'A', 'k': 'E', 'cost': 83}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 78}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 21}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 67}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 46}, {'i': 'D', 'j': 'B', 'k': 'E', 'cost': 99}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 12}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 78}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 30}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 73}, {'i': 'D', 'j': 'C', 'k': 'E', 'cost': 67}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 64}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 92}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 98}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 94}, {'i': 'D', 'j': 'D', 'k': 'E', 'cost': 17}, {'i': 'D', 'j': 'E', 'k': 'A', 'cost': 28}, {'i': 'D', 'j': 'E', 'k': 'B', 'cost': 91}, {'i': 'D', 'j': 'E', 'k': 'C', 'cost': 57}, {'i': 'D', 'j': 'E', 'k': 'D', 'cost': 18}, {'i': 'D', 'j': 'E', 'k': 'E', 'cost': 11}, {'i': 'E', 'j': 'A', 'k': 'A', 'cost': 49}, {'i': 'E', 'j': 'A', 'k': 'B', 'cost': 69}, {'i': 'E', 'j': 'A', 'k': 'C', 'cost': 92}, {'i': 'E', 'j': 'A', 'k': 'D', 'cost': 84}, {'i': 'E', 'j': 'A', 'k': 'E', 'cost': 1}, {'i': 'E', 'j': 'B', 'k': 'A', 'cost': 99}, {'i': 'E', 'j': 'B', 'k': 'B', 'cost': 64}, {'i': 'E', 'j': 'B', 'k': 'C', 'cost': 39}, {'i': 'E', 'j': 'B', 'k': 'D', 'cost': 70}, {'i': 'E', 'j': 'B', 'k': 'E', 'cost': 35}, {'i': 'E', 'j': 'C', 'k': 'A', 'cost': 64}, {'i': 'E', 'j': 'C', 'k': 'B', 'cost': 84}, {'i': 'E', 'j': 'C', 'k': 'C', 'cost': 40}, {'i': 'E', 'j': 'C', 'k': 'D', 'cost': 98}, {'i': 'E', 'j': 'C', 'k': 'E', 'cost': 25}, {'i': 'E', 'j': 'D', 'k': 'A', 'cost': 2}, {'i': 'E', 'j': 'D', 'k': 'B', 'cost': 97}, {'i': 'E', 'j': 'D', 'k': 'C', 'cost': 28}, {'i': 'E', 'j': 'D', 'k': 'D', 'cost': 0}, {'i': 'E', 'j': 'D', 'k': 'E', 'cost': 47}, {'i': 'E', 'j': 'E', 'k': 'A', 'cost': 53}, {'i': 'E', 'j': 'E', 'k': 'B', 'cost': 93}, {'i': 'E', 'j': 'E', 'k': 'C', 'cost': 55}, {'i': 'E', 'j': 'E', 'k': 'D', 'cost': 58}, {'i': 'E', 'j': 'E', 'k': 'E', 'cost': 66}]}","[['A', 'D', 'B'], ['B', 'B', 'D'], ['C', 'E', 'C'], ['D', 'C', 'A'], ['E', 'A', 'E']]",24,markdown_table,names
AP3,AP3,"There’s a busy day with as many repair jobs as there are technicians and kits, so the crew lead needs to match them up — one technician and one kit per job. Each possible match-up has a cost, every tech and every kit must be used exactly once, and the overall quality of a schedule is judged by adding all those match costs together: the smaller that grand total, the better the schedule. The exact options and numbers are shown below.

# num_requests=5
# index_identifiers=A, B, C, D, E

# Meaning: costs form a 3D tensor. For each fixed request_id=i, you are given a technician_id×kit_id matrix whose entry at row technician_id=j and column kit_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all technician_id and all kit_id used exactly once.
# assignment_cost_tensor (per-request_id markdown matrices)

## request_id=A
| technician_id\kit_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 15 | 0 | 58 | 1 | 1 |
| B | 97 | 99 | 8 | 48 | 60 |
| C | 89 | 95 | 46 | 18 | 46 |
| D | 80 | 0 | 14 | 89 | 88 |
| E | 52 | 33 | 52 | 24 | 36 |

## request_id=B
| technician_id\kit_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 30 | 9 | 42 | 2 | 96 |
| B | 30 | 60 | 71 | 80 | 4 |
| C | 62 | 85 | 89 | 30 | 40 |
| D | 52 | 44 | 4 | 85 | 2 |
| E | 42 | 19 | 22 | 12 | 99 |

## request_id=C
| technician_id\kit_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 85 | 45 | 77 | 98 | 96 |
| B | 30 | 33 | 56 | 51 | 99 |
| C | 21 | 67 | 19 | 78 | 72 |
| D | 21 | 73 | 23 | 43 | 5 |
| E | 90 | 49 | 47 | 84 | 90 |

## request_id=D
| technician_id\kit_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 82 | 53 | 76 | 63 | 88 |
| B | 62 | 0 | 32 | 87 | 77 |
| C | 6 | 28 | 91 | 2 | 76 |
| D | 58 | 60 | 55 | 46 | 22 |
| E | 83 | 88 | 52 | 41 | 9 |

## request_id=E
| technician_id\kit_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 34 | 36 | 74 | 8 | 78 |
| B | 73 | 97 | 97 | 73 | 14 |
| C | 48 | 59 | 35 | 2 | 0 |
| D | 60 | 76 | 17 | 84 | 98 |
| E | 89 | 91 | 34 | 22 | 74 |

When you’re ready to hand the chosen match-ups back, just send them in a little JSON snippet like this so it’s easy to read and reuse:

{
  ""solution"": [
    [<job_id>, <tech_id>, <kit_id>],
    ...
  ]
}

Each inner triple is one job with the technician and kit chosen for it (in that order: job, technician, kit). The outer list contains one triple per job. Think of this as a simple form to fill out — it’s just the shape I expect, not the actual answer.

Quick reminder: use the exact identifiers from the instance input — don’t rename them or introduce 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"".","{'cost_tensor': [[[15, 0, 58, 1, 1], [97, 99, 8, 48, 60], [89, 95, 46, 18, 46], [80, 0, 14, 89, 88], [52, 33, 52, 24, 36]], [[30, 9, 42, 2, 96], [30, 60, 71, 80, 4], [62, 85, 89, 30, 40], [52, 44, 4, 85, 2], [42, 19, 22, 12, 99]], [[85, 45, 77, 98, 96], [30, 33, 56, 51, 99], [21, 67, 19, 78, 72], [21, 73, 23, 43, 5], [90, 49, 47, 84, 90]], [[82, 53, 76, 63, 88], [62, 0, 32, 87, 77], [6, 28, 91, 2, 76], [58, 60, 55, 46, 22], [83, 88, 52, 41, 9]], [[34, 36, 74, 8, 78], [73, 97, 97, 73, 14], [48, 59, 35, 2, 0], [60, 76, 17, 84, 98], [89, 91, 34, 22, 74]]], 'objective': 44.0}","[[0, 0, 3], [1, 4, 2], [2, 3, 0], [3, 1, 1], [4, 2, 4]]",44.0,"{'problem_type': 'AP3', 'n': 5, 'ids': ['A', 'B', 'C', 'D', 'E'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 15}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 0}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 58}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 1}, {'i': 'A', 'j': 'A', 'k': 'E', 'cost': 1}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 97}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 99}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 8}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 48}, {'i': 'A', 'j': 'B', 'k': 'E', 'cost': 60}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 89}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 95}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 46}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 18}, {'i': 'A', 'j': 'C', 'k': 'E', 'cost': 46}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 80}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 0}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 14}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 89}, {'i': 'A', 'j': 'D', 'k': 'E', 'cost': 88}, {'i': 'A', 'j': 'E', 'k': 'A', 'cost': 52}, {'i': 'A', 'j': 'E', 'k': 'B', 'cost': 33}, {'i': 'A', 'j': 'E', 'k': 'C', 'cost': 52}, {'i': 'A', 'j': 'E', 'k': 'D', 'cost': 24}, {'i': 'A', 'j': 'E', 'k': 'E', 'cost': 36}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 30}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 9}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 42}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 2}, {'i': 'B', 'j': 'A', 'k': 'E', 'cost': 96}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 30}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 60}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 71}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 80}, {'i': 'B', 'j': 'B', 'k': 'E', 'cost': 4}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 62}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 85}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 89}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 30}, {'i': 'B', 'j': 'C', 'k': 'E', 'cost': 40}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 52}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 44}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 4}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 85}, {'i': 'B', 'j': 'D', 'k': 'E', 'cost': 2}, {'i': 'B', 'j': 'E', 'k': 'A', 'cost': 42}, {'i': 'B', 'j': 'E', 'k': 'B', 'cost': 19}, {'i': 'B', 'j': 'E', 'k': 'C', 'cost': 22}, {'i': 'B', 'j': 'E', 'k': 'D', 'cost': 12}, {'i': 'B', 'j': 'E', 'k': 'E', 'cost': 99}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 85}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 45}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 77}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 98}, {'i': 'C', 'j': 'A', 'k': 'E', 'cost': 96}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 30}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 33}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 56}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 51}, {'i': 'C', 'j': 'B', 'k': 'E', 'cost': 99}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 21}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 67}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 19}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 78}, {'i': 'C', 'j': 'C', 'k': 'E', 'cost': 72}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 21}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 73}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 23}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 43}, {'i': 'C', 'j': 'D', 'k': 'E', 'cost': 5}, {'i': 'C', 'j': 'E', 'k': 'A', 'cost': 90}, {'i': 'C', 'j': 'E', 'k': 'B', 'cost': 49}, {'i': 'C', 'j': 'E', 'k': 'C', 'cost': 47}, {'i': 'C', 'j': 'E', 'k': 'D', 'cost': 84}, {'i': 'C', 'j': 'E', 'k': 'E', 'cost': 90}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 82}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 53}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 76}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 63}, {'i': 'D', 'j': 'A', 'k': 'E', 'cost': 88}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 62}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 0}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 32}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 87}, {'i': 'D', 'j': 'B', 'k': 'E', 'cost': 77}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 6}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 28}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 91}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 2}, {'i': 'D', 'j': 'C', 'k': 'E', 'cost': 76}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 58}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 60}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 55}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 46}, {'i': 'D', 'j': 'D', 'k': 'E', 'cost': 22}, {'i': 'D', 'j': 'E', 'k': 'A', 'cost': 83}, {'i': 'D', 'j': 'E', 'k': 'B', 'cost': 88}, {'i': 'D', 'j': 'E', 'k': 'C', 'cost': 52}, {'i': 'D', 'j': 'E', 'k': 'D', 'cost': 41}, {'i': 'D', 'j': 'E', 'k': 'E', 'cost': 9}, {'i': 'E', 'j': 'A', 'k': 'A', 'cost': 34}, {'i': 'E', 'j': 'A', 'k': 'B', 'cost': 36}, {'i': 'E', 'j': 'A', 'k': 'C', 'cost': 74}, {'i': 'E', 'j': 'A', 'k': 'D', 'cost': 8}, {'i': 'E', 'j': 'A', 'k': 'E', 'cost': 78}, {'i': 'E', 'j': 'B', 'k': 'A', 'cost': 73}, {'i': 'E', 'j': 'B', 'k': 'B', 'cost': 97}, {'i': 'E', 'j': 'B', 'k': 'C', 'cost': 97}, {'i': 'E', 'j': 'B', 'k': 'D', 'cost': 73}, {'i': 'E', 'j': 'B', 'k': 'E', 'cost': 14}, {'i': 'E', 'j': 'C', 'k': 'A', 'cost': 48}, {'i': 'E', 'j': 'C', 'k': 'B', 'cost': 59}, {'i': 'E', 'j': 'C', 'k': 'C', 'cost': 35}, {'i': 'E', 'j': 'C', 'k': 'D', 'cost': 2}, {'i': 'E', 'j': 'C', 'k': 'E', 'cost': 0}, {'i': 'E', 'j': 'D', 'k': 'A', 'cost': 60}, {'i': 'E', 'j': 'D', 'k': 'B', 'cost': 76}, {'i': 'E', 'j': 'D', 'k': 'C', 'cost': 17}, {'i': 'E', 'j': 'D', 'k': 'D', 'cost': 84}, {'i': 'E', 'j': 'D', 'k': 'E', 'cost': 98}, {'i': 'E', 'j': 'E', 'k': 'A', 'cost': 89}, {'i': 'E', 'j': 'E', 'k': 'B', 'cost': 91}, {'i': 'E', 'j': 'E', 'k': 'C', 'cost': 34}, {'i': 'E', 'j': 'E', 'k': 'D', 'cost': 22}, {'i': 'E', 'j': 'E', 'k': 'E', 'cost': 74}]}","[['A', 'A', 'D'], ['B', 'E', 'C'], ['C', 'D', 'A'], ['D', 'B', 'B'], ['E', 'C', 'E']]",25,csv,names
AP3,AP3,"Recently the planning team faced a neat challenge: match each meeting with a single presenter and a single room, using every presenter once and every room once. The smart schedule is the one that keeps the combined preparation and travel costs for everyone as small as possible — you figure that out by summing the prep+travel cost for each meeting in the plan and comparing totals. The full list of meetings, people, rooms, and costs is shown below.

{
  ""num_meetings"": 3,
  ""meeting_ids"": [
    1,
    2,
    3
  ]
}

# Meaning: costs form a 3D tensor. For each fixed meeting_id=i, you are given a presenter_id×room_id matrix whose entry at row presenter_id=j and column room_id=k equals prep_travel_cost(i,j,k). You must pick exactly one (j,k) for every i, with all presenter_id and all room_id used exactly once.
# prep_travel_cost_tensor (per-meeting_id markdown matrices)

## meeting_id=1
| presenter_id\room_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 24 | 78 | 7 |
| 2 | 61 | 47 | 79 |
| 3 | 74 | 47 | 52 |

## meeting_id=2
| presenter_id\room_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 30 | 68 | 29 |
| 2 | 56 | 60 | 41 |
| 3 | 13 | 3 | 97 |

## meeting_id=3
| presenter_id\room_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 11 | 64 | 35 |
| 2 | 16 | 17 | 55 |
| 3 | 29 | 83 | 84 |

Oh, and when you’re ready to give the matching, please stick to this simple JSON layout so it’s easy to read and check:

{
  ""solution"": [
    [<meeting_id>, <presenter_id>, <room_id>],
    ...
  ]
}

Think of it like a little form: ""solution"" holds a list of triples, and each triple says which meeting goes with which presenter and which room. This is just the expected shape — not the actual assignment itself.

All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[24, 78, 7], [61, 47, 79], [74, 47, 52]], [[30, 68, 29], [56, 60, 41], [13, 3, 97]], [[11, 64, 35], [16, 17, 55], [29, 83, 84]]], 'objective': 26.0}","[[0, 0, 2], [1, 2, 1], [2, 1, 0]]",26.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [1, 2, 3], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 24}, {'i': 1, 'j': 1, 'k': 2, 'cost': 78}, {'i': 1, 'j': 1, 'k': 3, 'cost': 7}, {'i': 1, 'j': 2, 'k': 1, 'cost': 61}, {'i': 1, 'j': 2, 'k': 2, 'cost': 47}, {'i': 1, 'j': 2, 'k': 3, 'cost': 79}, {'i': 1, 'j': 3, 'k': 1, 'cost': 74}, {'i': 1, 'j': 3, 'k': 2, 'cost': 47}, {'i': 1, 'j': 3, 'k': 3, 'cost': 52}, {'i': 2, 'j': 1, 'k': 1, 'cost': 30}, {'i': 2, 'j': 1, 'k': 2, 'cost': 68}, {'i': 2, 'j': 1, 'k': 3, 'cost': 29}, {'i': 2, 'j': 2, 'k': 1, 'cost': 56}, {'i': 2, 'j': 2, 'k': 2, 'cost': 60}, {'i': 2, 'j': 2, 'k': 3, 'cost': 41}, {'i': 2, 'j': 3, 'k': 1, 'cost': 13}, {'i': 2, 'j': 3, 'k': 2, 'cost': 3}, {'i': 2, 'j': 3, 'k': 3, 'cost': 97}, {'i': 3, 'j': 1, 'k': 1, 'cost': 11}, {'i': 3, 'j': 1, 'k': 2, 'cost': 64}, {'i': 3, 'j': 1, 'k': 3, 'cost': 35}, {'i': 3, 'j': 2, 'k': 1, 'cost': 16}, {'i': 3, 'j': 2, 'k': 2, 'cost': 17}, {'i': 3, 'j': 2, 'k': 3, 'cost': 55}, {'i': 3, 'j': 3, 'k': 1, 'cost': 29}, {'i': 3, 'j': 3, 'k': 2, 'cost': 83}, {'i': 3, 'j': 3, 'k': 3, 'cost': 84}]}","[[1, 1, 3], [2, 3, 2], [3, 2, 1]]",26,json,1
AP3,AP3,"Imagine the wardrobe and casting teams spread out on a big table of name tags: each scene needs a single actor tag and a single costume tag, and every tag must be placed exactly once. The trick is to choose which actor goes with which costume in which scene so the overall tab (each scene’s actor fee plus costume charge, added up for all scenes) comes out minimal. The specific costs and scene details are listed below.

Now list the 5 scene→(actor,costume) assignments using these identifiers 1, 2, 3, 4, 5:
Meaning: costs form a 3D tensor. For each fixed scene_id=i, you are given a actor_id×costume_id matrix whose entry at row actor_id=j and column costume_id=k equals total_assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all actor_id and all costume_id used exactly once.
total_assignment_cost_tensor (per-scene_id markdown matrices):
## scene_id=1
| actor_id\costume_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 44 | 84 | 44 | 8 | 35 |
| 2 | 44 | 0 | 23 | 48 | 7 |
| 3 | 77 | 76 | 50 | 62 | 22 |
| 4 | 81 | 35 | 36 | 87 | 54 |
| 5 | 69 | 62 | 53 | 54 | 32 |

## scene_id=2
| actor_id\costume_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 64 | 58 | 9 | 24 | 88 |
| 2 | 74 | 69 | 6 | 22 | 32 |
| 3 | 63 | 27 | 22 | 18 | 74 |
| 4 | 61 | 69 | 3 | 86 | 18 |
| 5 | 81 | 90 | 65 | 74 | 69 |

## scene_id=3
| actor_id\costume_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 21 | 70 | 92 | 54 | 81 |
| 2 | 7 | 47 | 60 | 27 | 21 |
| 3 | 48 | 16 | 94 | 37 | 51 |
| 4 | 5 | 94 | 9 | 42 | 87 |
| 5 | 6 | 38 | 93 | 80 | 66 |

## scene_id=4
| actor_id\costume_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 10 | 87 | 75 | 72 | 33 |
| 2 | 83 | 44 | 85 | 66 | 9 |
| 3 | 40 | 56 | 13 | 58 | 42 |
| 4 | 54 | 39 | 35 | 7 | 41 |
| 5 | 24 | 33 | 0 | 53 | 43 |

## scene_id=5
| actor_id\costume_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 44 | 28 | 7 | 76 | 90 |
| 2 | 6 | 57 | 25 | 54 | 29 |
| 3 | 98 | 44 | 77 | 93 | 86 |
| 4 | 96 | 9 | 44 | 84 | 21 |
| 5 | 77 | 89 | 32 | 31 | 93 |
Arrange the pairings so the overall tab (sum of each scene’s listed costs) is as small as possible.

Oh — and when you send the picks back, a little JSON like this is perfect:

{
  ""solution"": [
    [<scene_id>, <actor_id>, <costume_id>],
    ...
  ]
}

This just says ""solution"" is a list of triples. Each triple picks the scene, the actor tag, and the costume tag for that scene. The angle-bracket placeholders show the shape you should follow — fill them with the actual ids from the instance. This is only a sketch of the expected shape, not the actual assignment.

Please use the identifiers exactly as they appear in the instance input — do not rename or invent new labels. Valid identifiers look like:
- ""1"" or ""23""
- ""A"" or ""B""
- ""A1"" or ""X7""

No renaming, no extra labels — just the ids exactly as given.","{'cost_tensor': [[[44, 84, 44, 8, 35], [44, 0, 23, 48, 7], [77, 76, 50, 62, 22], [81, 35, 36, 87, 54], [69, 62, 53, 54, 32]], [[64, 58, 9, 24, 88], [74, 69, 6, 22, 32], [63, 27, 22, 18, 74], [61, 69, 3, 86, 18], [81, 90, 65, 74, 69]], [[21, 70, 92, 54, 81], [7, 47, 60, 27, 21], [48, 16, 94, 37, 51], [5, 94, 9, 42, 87], [6, 38, 93, 80, 66]], [[10, 87, 75, 72, 33], [83, 44, 85, 66, 9], [40, 56, 13, 58, 42], [54, 39, 35, 7, 41], [24, 33, 0, 53, 43]], [[44, 28, 7, 76, 90], [6, 57, 25, 54, 29], [98, 44, 77, 93, 86], [96, 9, 44, 84, 21], [77, 89, 32, 31, 93]]], 'objective': 48.0}","[[0, 0, 3], [1, 3, 4], [2, 2, 1], [3, 4, 2], [4, 1, 0]]",48.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [1, 2, 3, 4, 5], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 44}, {'i': 1, 'j': 1, 'k': 2, 'cost': 84}, {'i': 1, 'j': 1, 'k': 3, 'cost': 44}, {'i': 1, 'j': 1, 'k': 4, 'cost': 8}, {'i': 1, 'j': 1, 'k': 5, 'cost': 35}, {'i': 1, 'j': 2, 'k': 1, 'cost': 44}, {'i': 1, 'j': 2, 'k': 2, 'cost': 0}, {'i': 1, 'j': 2, 'k': 3, 'cost': 23}, {'i': 1, 'j': 2, 'k': 4, 'cost': 48}, {'i': 1, 'j': 2, 'k': 5, 'cost': 7}, {'i': 1, 'j': 3, 'k': 1, 'cost': 77}, {'i': 1, 'j': 3, 'k': 2, 'cost': 76}, {'i': 1, 'j': 3, 'k': 3, 'cost': 50}, {'i': 1, 'j': 3, 'k': 4, 'cost': 62}, {'i': 1, 'j': 3, 'k': 5, 'cost': 22}, {'i': 1, 'j': 4, 'k': 1, 'cost': 81}, {'i': 1, 'j': 4, 'k': 2, 'cost': 35}, {'i': 1, 'j': 4, 'k': 3, 'cost': 36}, {'i': 1, 'j': 4, 'k': 4, 'cost': 87}, {'i': 1, 'j': 4, 'k': 5, 'cost': 54}, {'i': 1, 'j': 5, 'k': 1, 'cost': 69}, {'i': 1, 'j': 5, 'k': 2, 'cost': 62}, {'i': 1, 'j': 5, 'k': 3, 'cost': 53}, {'i': 1, 'j': 5, 'k': 4, 'cost': 54}, {'i': 1, 'j': 5, 'k': 5, 'cost': 32}, {'i': 2, 'j': 1, 'k': 1, 'cost': 64}, {'i': 2, 'j': 1, 'k': 2, 'cost': 58}, {'i': 2, 'j': 1, 'k': 3, 'cost': 9}, {'i': 2, 'j': 1, 'k': 4, 'cost': 24}, {'i': 2, 'j': 1, 'k': 5, 'cost': 88}, {'i': 2, 'j': 2, 'k': 1, 'cost': 74}, {'i': 2, 'j': 2, 'k': 2, 'cost': 69}, {'i': 2, 'j': 2, 'k': 3, 'cost': 6}, {'i': 2, 'j': 2, 'k': 4, 'cost': 22}, {'i': 2, 'j': 2, 'k': 5, 'cost': 32}, {'i': 2, 'j': 3, 'k': 1, 'cost': 63}, {'i': 2, 'j': 3, 'k': 2, 'cost': 27}, {'i': 2, 'j': 3, 'k': 3, 'cost': 22}, {'i': 2, 'j': 3, 'k': 4, 'cost': 18}, {'i': 2, 'j': 3, 'k': 5, 'cost': 74}, {'i': 2, 'j': 4, 'k': 1, 'cost': 61}, {'i': 2, 'j': 4, 'k': 2, 'cost': 69}, {'i': 2, 'j': 4, 'k': 3, 'cost': 3}, {'i': 2, 'j': 4, 'k': 4, 'cost': 86}, {'i': 2, 'j': 4, 'k': 5, 'cost': 18}, {'i': 2, 'j': 5, 'k': 1, 'cost': 81}, {'i': 2, 'j': 5, 'k': 2, 'cost': 90}, {'i': 2, 'j': 5, 'k': 3, 'cost': 65}, {'i': 2, 'j': 5, 'k': 4, 'cost': 74}, {'i': 2, 'j': 5, 'k': 5, 'cost': 69}, {'i': 3, 'j': 1, 'k': 1, 'cost': 21}, {'i': 3, 'j': 1, 'k': 2, 'cost': 70}, {'i': 3, 'j': 1, 'k': 3, 'cost': 92}, {'i': 3, 'j': 1, 'k': 4, 'cost': 54}, {'i': 3, 'j': 1, 'k': 5, 'cost': 81}, {'i': 3, 'j': 2, 'k': 1, 'cost': 7}, {'i': 3, 'j': 2, 'k': 2, 'cost': 47}, {'i': 3, 'j': 2, 'k': 3, 'cost': 60}, {'i': 3, 'j': 2, 'k': 4, 'cost': 27}, {'i': 3, 'j': 2, 'k': 5, 'cost': 21}, {'i': 3, 'j': 3, 'k': 1, 'cost': 48}, {'i': 3, 'j': 3, 'k': 2, 'cost': 16}, {'i': 3, 'j': 3, 'k': 3, 'cost': 94}, {'i': 3, 'j': 3, 'k': 4, 'cost': 37}, {'i': 3, 'j': 3, 'k': 5, 'cost': 51}, {'i': 3, 'j': 4, 'k': 1, 'cost': 5}, {'i': 3, 'j': 4, 'k': 2, 'cost': 94}, {'i': 3, 'j': 4, 'k': 3, 'cost': 9}, {'i': 3, 'j': 4, 'k': 4, 'cost': 42}, {'i': 3, 'j': 4, 'k': 5, 'cost': 87}, {'i': 3, 'j': 5, 'k': 1, 'cost': 6}, {'i': 3, 'j': 5, 'k': 2, 'cost': 38}, {'i': 3, 'j': 5, 'k': 3, 'cost': 93}, {'i': 3, 'j': 5, 'k': 4, 'cost': 80}, {'i': 3, 'j': 5, 'k': 5, 'cost': 66}, {'i': 4, 'j': 1, 'k': 1, 'cost': 10}, {'i': 4, 'j': 1, 'k': 2, 'cost': 87}, {'i': 4, 'j': 1, 'k': 3, 'cost': 75}, {'i': 4, 'j': 1, 'k': 4, 'cost': 72}, {'i': 4, 'j': 1, 'k': 5, 'cost': 33}, {'i': 4, 'j': 2, 'k': 1, 'cost': 83}, {'i': 4, 'j': 2, 'k': 2, 'cost': 44}, {'i': 4, 'j': 2, 'k': 3, 'cost': 85}, {'i': 4, 'j': 2, 'k': 4, 'cost': 66}, {'i': 4, 'j': 2, 'k': 5, 'cost': 9}, {'i': 4, 'j': 3, 'k': 1, 'cost': 40}, {'i': 4, 'j': 3, 'k': 2, 'cost': 56}, {'i': 4, 'j': 3, 'k': 3, 'cost': 13}, {'i': 4, 'j': 3, 'k': 4, 'cost': 58}, {'i': 4, 'j': 3, 'k': 5, 'cost': 42}, {'i': 4, 'j': 4, 'k': 1, 'cost': 54}, {'i': 4, 'j': 4, 'k': 2, 'cost': 39}, {'i': 4, 'j': 4, 'k': 3, 'cost': 35}, {'i': 4, 'j': 4, 'k': 4, 'cost': 7}, {'i': 4, 'j': 4, 'k': 5, 'cost': 41}, {'i': 4, 'j': 5, 'k': 1, 'cost': 24}, {'i': 4, 'j': 5, 'k': 2, 'cost': 33}, {'i': 4, 'j': 5, 'k': 3, 'cost': 0}, {'i': 4, 'j': 5, 'k': 4, 'cost': 53}, {'i': 4, 'j': 5, 'k': 5, 'cost': 43}, {'i': 5, 'j': 1, 'k': 1, 'cost': 44}, {'i': 5, 'j': 1, 'k': 2, 'cost': 28}, {'i': 5, 'j': 1, 'k': 3, 'cost': 7}, {'i': 5, 'j': 1, 'k': 4, 'cost': 76}, {'i': 5, 'j': 1, 'k': 5, 'cost': 90}, {'i': 5, 'j': 2, 'k': 1, 'cost': 6}, {'i': 5, 'j': 2, 'k': 2, 'cost': 57}, {'i': 5, 'j': 2, 'k': 3, 'cost': 25}, {'i': 5, 'j': 2, 'k': 4, 'cost': 54}, {'i': 5, 'j': 2, 'k': 5, 'cost': 29}, {'i': 5, 'j': 3, 'k': 1, 'cost': 98}, {'i': 5, 'j': 3, 'k': 2, 'cost': 44}, {'i': 5, 'j': 3, 'k': 3, 'cost': 77}, {'i': 5, 'j': 3, 'k': 4, 'cost': 93}, {'i': 5, 'j': 3, 'k': 5, 'cost': 86}, {'i': 5, 'j': 4, 'k': 1, 'cost': 96}, {'i': 5, 'j': 4, 'k': 2, 'cost': 9}, {'i': 5, 'j': 4, 'k': 3, 'cost': 44}, {'i': 5, 'j': 4, 'k': 4, 'cost': 84}, {'i': 5, 'j': 4, 'k': 5, 'cost': 21}, {'i': 5, 'j': 5, 'k': 1, 'cost': 77}, {'i': 5, 'j': 5, 'k': 2, 'cost': 89}, {'i': 5, 'j': 5, 'k': 3, 'cost': 32}, {'i': 5, 'j': 5, 'k': 4, 'cost': 31}, {'i': 5, 'j': 5, 'k': 5, 'cost': 93}]}","[[1, 1, 4], [2, 4, 5], [3, 3, 2], [4, 5, 3], [5, 2, 1]]",27,nl,1
AP3,AP3,"There's a little scheduling puzzle at the community center: a set of clients, a set of interpreters, and a set of available time slots, and each client needs one interpreter at one slot. The aim is to choose those matches so that no interpreter or time appears twice and every client gets exactly one session, and then you add up the cost of each chosen session — the schedule with the lowest total cost is the goal. The full list of who’s available and how much each possible session costs is shown below.

There are 3 of each, labeled A, B, C.

*Meaning: costs form a 3D tensor. For each fixed client_id=i, you are given a interpreter_id×timeslot_id matrix whose entry at row interpreter_id=j and column timeslot_id=k equals session_cost(i,j,k). You must pick exactly one (j,k) for every i, with all interpreter_id and all timeslot_id used exactly once.*

**session_cost_tensor (per-client_id markdown matrices)**

## client_id=A
| interpreter_id\timeslot_id | A | B | C |
|---|---|---|---|
| A | 22 | 8 | 85 |
| B | 69 | 67 | 18 |
| C | 92 | 23 | 58 |

## client_id=B
| interpreter_id\timeslot_id | A | B | C |
|---|---|---|---|
| A | 82 | 6 | 1 |
| B | 9 | 76 | 23 |
| C | 90 | 73 | 80 |

## client_id=C
| interpreter_id\timeslot_id | A | B | C |
|---|---|---|---|
| A | 73 | 32 | 35 |
| B | 51 | 20 | 29 |
| C | 72 | 20 | 51 |

Matches from this list should be chosen so that every client gets exactly one session, no interpreter or time is used more than once, and the total cost is minimized.

You can hand me the final matching in a tiny JSON snippet like this — super simple and just the shape I need:

{
  ""solution"": [
    [<client_id>, <interpreter_id>, <slot_id>],
    ...
  ]
}

Think of each inner array as one chosen session: the client, the interpreter, and the time slot, in that order. The whole ""solution"" list is just the set of sessions that together make the schedule. This is just a sketch of the required format, not the actual schedule — I just need the same shape when you give the answer.

Please use the exact identifiers from the instance input — no renaming, no made-up labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[22, 8, 85], [69, 67, 18], [92, 23, 58]], [[82, 6, 1], [9, 76, 23], [90, 73, 80]], [[73, 32, 35], [51, 20, 29], [72, 20, 51]]], 'objective': 65.0}","[[0, 0, 0], [1, 1, 2], [2, 2, 1]]",65.0,"{'problem_type': 'AP3', 'n': 3, 'ids': ['A', 'B', 'C'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 22}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 8}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 85}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 69}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 67}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 18}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 92}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 23}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 58}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 82}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 6}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 1}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 9}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 76}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 23}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 90}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 73}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 80}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 73}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 32}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 35}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 51}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 20}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 29}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 72}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 20}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 51}]}","[['A', 'A', 'A'], ['B', 'B', 'C'], ['C', 'C', 'B']]",28,markdown_table,names
AP3,AP3,"At the university there’s a little matching task every term: assign a single proctor and a single hall to each exam, with every proctor and every hall used for only one exam. Each possible exam–proctor–hall choice comes with a cost, and once a choice is made for every exam the costs are summed — the better plan is the one with the smallest sum. Nothing can be skipped or duplicated. The full list of exams, proctors, halls, and their costs follows below.

There are 5 exams, 5 proctors and 5 halls, identified by 1, 2, 3, 4, 5.
Meaning: costs form a 3D tensor. For each fixed exam_id=i, you are given a proctor_id×hall_id matrix whose entry at row proctor_id=j and column hall_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all proctor_id and all hall_id used exactly once.
assignment_cost_tensor (per-exam_id markdown matrices):
## exam_id=1
| proctor_id\hall_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 53 | 57 | 28 | 30 | 99 |
| 2 | 23 | 19 | 72 | 31 | 12 |
| 3 | 31 | 58 | 10 | 23 | 59 |
| 4 | 25 | 1 | 85 | 86 | 97 |
| 5 | 20 | 73 | 52 | 11 | 84 |

## exam_id=2
| proctor_id\hall_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 54 | 73 | 19 | 45 | 24 |
| 2 | 79 | 80 | 91 | 23 | 4 |
| 3 | 81 | 93 | 76 | 99 | 67 |
| 4 | 30 | 1 | 66 | 6 | 79 |
| 5 | 12 | 54 | 35 | 29 | 42 |

## exam_id=3
| proctor_id\hall_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 31 | 34 | 95 | 97 | 38 |
| 2 | 29 | 42 | 56 | 28 | 84 |
| 3 | 21 | 29 | 51 | 60 | 23 |
| 4 | 80 | 30 | 34 | 82 | 61 |
| 5 | 45 | 27 | 33 | 85 | 85 |

## exam_id=4
| proctor_id\hall_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 74 | 46 | 8 | 12 | 51 |
| 2 | 72 | 98 | 34 | 89 | 86 |
| 3 | 87 | 57 | 19 | 84 | 74 |
| 4 | 18 | 54 | 95 | 28 | 77 |
| 5 | 13 | 35 | 28 | 25 | 67 |

## exam_id=5
| proctor_id\hall_id | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| 1 | 45 | 17 | 77 | 54 | 1 |
| 2 | 90 | 15 | 97 | 41 | 75 |
| 3 | 42 | 76 | 85 | 20 | 29 |
| 4 | 84 | 87 | 13 | 0 | 98 |
| 5 | 66 | 3 | 9 | 43 | 72 |
Select one triple for each of the 5 exams so that every proctor and every hall in 1, 2, 3, 4, 5 is used exactly once and the summed cost is minimized.

Also, if you could send your choices back in a simple JSON layout, that makes it easy to check — nothing fancy, just a single key with a list of triples, like this:

{
  ""solution"": [
    [<exam_id>, <proctor_id>, <hall_id>],
    ...
  ]
}

Each inner array is one exam paired with the proctor and the hall you picked for it. Think of it like a little form: exam, proctor, hall. This block is just the shape I expect — don’t fill it in yet here, use the actual IDs from the instance when you submit your plan.

Please make sure to use the exact identifiers given in the 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”.","{'cost_tensor': [[[53, 57, 28, 30, 99], [23, 19, 72, 31, 12], [31, 58, 10, 23, 59], [25, 1, 85, 86, 97], [20, 73, 52, 11, 84]], [[54, 73, 19, 45, 24], [79, 80, 91, 23, 4], [81, 93, 76, 99, 67], [30, 1, 66, 6, 79], [12, 54, 35, 29, 42]], [[31, 34, 95, 97, 38], [29, 42, 56, 28, 84], [21, 29, 51, 60, 23], [80, 30, 34, 82, 61], [45, 27, 33, 85, 85]], [[74, 46, 8, 12, 51], [72, 98, 34, 89, 86], [87, 57, 19, 84, 74], [18, 54, 95, 28, 77], [13, 35, 28, 25, 67]], [[45, 17, 77, 54, 1], [90, 15, 97, 41, 75], [42, 76, 85, 20, 29], [84, 87, 13, 0, 98], [66, 3, 9, 43, 72]]], 'objective': 47.0}","[[0, 3, 1], [1, 1, 4], [2, 2, 0], [3, 0, 3], [4, 4, 2]]",47.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [1, 2, 3, 4, 5], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 53}, {'i': 1, 'j': 1, 'k': 2, 'cost': 57}, {'i': 1, 'j': 1, 'k': 3, 'cost': 28}, {'i': 1, 'j': 1, 'k': 4, 'cost': 30}, {'i': 1, 'j': 1, 'k': 5, 'cost': 99}, {'i': 1, 'j': 2, 'k': 1, 'cost': 23}, {'i': 1, 'j': 2, 'k': 2, 'cost': 19}, {'i': 1, 'j': 2, 'k': 3, 'cost': 72}, {'i': 1, 'j': 2, 'k': 4, 'cost': 31}, {'i': 1, 'j': 2, 'k': 5, 'cost': 12}, {'i': 1, 'j': 3, 'k': 1, 'cost': 31}, {'i': 1, 'j': 3, 'k': 2, 'cost': 58}, {'i': 1, 'j': 3, 'k': 3, 'cost': 10}, {'i': 1, 'j': 3, 'k': 4, 'cost': 23}, {'i': 1, 'j': 3, 'k': 5, 'cost': 59}, {'i': 1, 'j': 4, 'k': 1, 'cost': 25}, {'i': 1, 'j': 4, 'k': 2, 'cost': 1}, {'i': 1, 'j': 4, 'k': 3, 'cost': 85}, {'i': 1, 'j': 4, 'k': 4, 'cost': 86}, {'i': 1, 'j': 4, 'k': 5, 'cost': 97}, {'i': 1, 'j': 5, 'k': 1, 'cost': 20}, {'i': 1, 'j': 5, 'k': 2, 'cost': 73}, {'i': 1, 'j': 5, 'k': 3, 'cost': 52}, {'i': 1, 'j': 5, 'k': 4, 'cost': 11}, {'i': 1, 'j': 5, 'k': 5, 'cost': 84}, {'i': 2, 'j': 1, 'k': 1, 'cost': 54}, {'i': 2, 'j': 1, 'k': 2, 'cost': 73}, {'i': 2, 'j': 1, 'k': 3, 'cost': 19}, {'i': 2, 'j': 1, 'k': 4, 'cost': 45}, {'i': 2, 'j': 1, 'k': 5, 'cost': 24}, {'i': 2, 'j': 2, 'k': 1, 'cost': 79}, {'i': 2, 'j': 2, 'k': 2, 'cost': 80}, {'i': 2, 'j': 2, 'k': 3, 'cost': 91}, {'i': 2, 'j': 2, 'k': 4, 'cost': 23}, {'i': 2, 'j': 2, 'k': 5, 'cost': 4}, {'i': 2, 'j': 3, 'k': 1, 'cost': 81}, {'i': 2, 'j': 3, 'k': 2, 'cost': 93}, {'i': 2, 'j': 3, 'k': 3, 'cost': 76}, {'i': 2, 'j': 3, 'k': 4, 'cost': 99}, {'i': 2, 'j': 3, 'k': 5, 'cost': 67}, {'i': 2, 'j': 4, 'k': 1, 'cost': 30}, {'i': 2, 'j': 4, 'k': 2, 'cost': 1}, {'i': 2, 'j': 4, 'k': 3, 'cost': 66}, {'i': 2, 'j': 4, 'k': 4, 'cost': 6}, {'i': 2, 'j': 4, 'k': 5, 'cost': 79}, {'i': 2, 'j': 5, 'k': 1, 'cost': 12}, {'i': 2, 'j': 5, 'k': 2, 'cost': 54}, {'i': 2, 'j': 5, 'k': 3, 'cost': 35}, {'i': 2, 'j': 5, 'k': 4, 'cost': 29}, {'i': 2, 'j': 5, 'k': 5, 'cost': 42}, {'i': 3, 'j': 1, 'k': 1, 'cost': 31}, {'i': 3, 'j': 1, 'k': 2, 'cost': 34}, {'i': 3, 'j': 1, 'k': 3, 'cost': 95}, {'i': 3, 'j': 1, 'k': 4, 'cost': 97}, {'i': 3, 'j': 1, 'k': 5, 'cost': 38}, {'i': 3, 'j': 2, 'k': 1, 'cost': 29}, {'i': 3, 'j': 2, 'k': 2, 'cost': 42}, {'i': 3, 'j': 2, 'k': 3, 'cost': 56}, {'i': 3, 'j': 2, 'k': 4, 'cost': 28}, {'i': 3, 'j': 2, 'k': 5, 'cost': 84}, {'i': 3, 'j': 3, 'k': 1, 'cost': 21}, {'i': 3, 'j': 3, 'k': 2, 'cost': 29}, {'i': 3, 'j': 3, 'k': 3, 'cost': 51}, {'i': 3, 'j': 3, 'k': 4, 'cost': 60}, {'i': 3, 'j': 3, 'k': 5, 'cost': 23}, {'i': 3, 'j': 4, 'k': 1, 'cost': 80}, {'i': 3, 'j': 4, 'k': 2, 'cost': 30}, {'i': 3, 'j': 4, 'k': 3, 'cost': 34}, {'i': 3, 'j': 4, 'k': 4, 'cost': 82}, {'i': 3, 'j': 4, 'k': 5, 'cost': 61}, {'i': 3, 'j': 5, 'k': 1, 'cost': 45}, {'i': 3, 'j': 5, 'k': 2, 'cost': 27}, {'i': 3, 'j': 5, 'k': 3, 'cost': 33}, {'i': 3, 'j': 5, 'k': 4, 'cost': 85}, {'i': 3, 'j': 5, 'k': 5, 'cost': 85}, {'i': 4, 'j': 1, 'k': 1, 'cost': 74}, {'i': 4, 'j': 1, 'k': 2, 'cost': 46}, {'i': 4, 'j': 1, 'k': 3, 'cost': 8}, {'i': 4, 'j': 1, 'k': 4, 'cost': 12}, {'i': 4, 'j': 1, 'k': 5, 'cost': 51}, {'i': 4, 'j': 2, 'k': 1, 'cost': 72}, {'i': 4, 'j': 2, 'k': 2, 'cost': 98}, {'i': 4, 'j': 2, 'k': 3, 'cost': 34}, {'i': 4, 'j': 2, 'k': 4, 'cost': 89}, {'i': 4, 'j': 2, 'k': 5, 'cost': 86}, {'i': 4, 'j': 3, 'k': 1, 'cost': 87}, {'i': 4, 'j': 3, 'k': 2, 'cost': 57}, {'i': 4, 'j': 3, 'k': 3, 'cost': 19}, {'i': 4, 'j': 3, 'k': 4, 'cost': 84}, {'i': 4, 'j': 3, 'k': 5, 'cost': 74}, {'i': 4, 'j': 4, 'k': 1, 'cost': 18}, {'i': 4, 'j': 4, 'k': 2, 'cost': 54}, {'i': 4, 'j': 4, 'k': 3, 'cost': 95}, {'i': 4, 'j': 4, 'k': 4, 'cost': 28}, {'i': 4, 'j': 4, 'k': 5, 'cost': 77}, {'i': 4, 'j': 5, 'k': 1, 'cost': 13}, {'i': 4, 'j': 5, 'k': 2, 'cost': 35}, {'i': 4, 'j': 5, 'k': 3, 'cost': 28}, {'i': 4, 'j': 5, 'k': 4, 'cost': 25}, {'i': 4, 'j': 5, 'k': 5, 'cost': 67}, {'i': 5, 'j': 1, 'k': 1, 'cost': 45}, {'i': 5, 'j': 1, 'k': 2, 'cost': 17}, {'i': 5, 'j': 1, 'k': 3, 'cost': 77}, {'i': 5, 'j': 1, 'k': 4, 'cost': 54}, {'i': 5, 'j': 1, 'k': 5, 'cost': 1}, {'i': 5, 'j': 2, 'k': 1, 'cost': 90}, {'i': 5, 'j': 2, 'k': 2, 'cost': 15}, {'i': 5, 'j': 2, 'k': 3, 'cost': 97}, {'i': 5, 'j': 2, 'k': 4, 'cost': 41}, {'i': 5, 'j': 2, 'k': 5, 'cost': 75}, {'i': 5, 'j': 3, 'k': 1, 'cost': 42}, {'i': 5, 'j': 3, 'k': 2, 'cost': 76}, {'i': 5, 'j': 3, 'k': 3, 'cost': 85}, {'i': 5, 'j': 3, 'k': 4, 'cost': 20}, {'i': 5, 'j': 3, 'k': 5, 'cost': 29}, {'i': 5, 'j': 4, 'k': 1, 'cost': 84}, {'i': 5, 'j': 4, 'k': 2, 'cost': 87}, {'i': 5, 'j': 4, 'k': 3, 'cost': 13}, {'i': 5, 'j': 4, 'k': 4, 'cost': 0}, {'i': 5, 'j': 4, 'k': 5, 'cost': 98}, {'i': 5, 'j': 5, 'k': 1, 'cost': 66}, {'i': 5, 'j': 5, 'k': 2, 'cost': 3}, {'i': 5, 'j': 5, 'k': 3, 'cost': 9}, {'i': 5, 'j': 5, 'k': 4, 'cost': 43}, {'i': 5, 'j': 5, 'k': 5, 'cost': 72}]}","[[1, 4, 2], [2, 2, 5], [3, 3, 1], [4, 1, 4], [5, 5, 3]]",29,nl,1
AP3,AP3,"A nurse manager described it like a game of musical chairs: equal numbers of patients, nurses, and rooms, and when the music stops each patient must have one nurse and one room, with no nurse or room sitting with two people. Each possible patient–nurse–room setup has a cost sticker, so the idea is to select one stickered setup per patient and tally those stickers — the winning arrangement is the one with the lowest total sum. The exact pairings and costs are shown below.

# number_of_patients=4
# patient_nurse_room_ids=A, B, C, D

# Meaning: costs form a 3D tensor. For each fixed patient_id=i, you are given a nurse_id×room_id matrix whose entry at row nurse_id=j and column room_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all nurse_id and all room_id used exactly once.
# assignment_cost_tensor (per-patient_id markdown matrices)

## patient_id=A
| nurse_id\room_id | A | B | C | D |
|---|---|---|---|---|
| A | 30 | 14 | 30 | 53 |
| B | 35 | 10 | 93 | 53 |
| C | 86 | 92 | 3 | 96 |
| D | 94 | 4 | 12 | 60 |

## patient_id=B
| nurse_id\room_id | A | B | C | D |
|---|---|---|---|---|
| A | 19 | 16 | 73 | 42 |
| B | 1 | 35 | 5 | 43 |
| C | 79 | 41 | 43 | 32 |
| D | 61 | 57 | 15 | 2 |

## patient_id=C
| nurse_id\room_id | A | B | C | D |
|---|---|---|---|---|
| A | 48 | 22 | 5 | 96 |
| B | 22 | 74 | 5 | 63 |
| C | 69 | 37 | 15 | 74 |
| D | 59 | 55 | 61 | 54 |

## patient_id=D
| nurse_id\room_id | A | B | C | D |
|---|---|---|---|---|
| A | 69 | 78 | 89 | 78 |
| B | 78 | 56 | 1 | 5 |
| C | 25 | 59 | 15 | 20 |
| D | 55 | 59 | 67 | 90 |

If you want to hand me a result, a handy way to shape it is this little JSON sketch — just shows how I expect the triples to be listed back to you.

{
  ""solution"": [
    [<patient_id>, <nurse_id>, <room_id>],
    ...
  ]
}

Think of each inner triple [<patient_id>, <nurse_id>, <room_id>] as saying “this patient goes with this nurse and this room,” and the outer list just collects one triple per patient. This is only the shape I’m expecting, not the actual answer — fill in the real identifiers from the instance when you reply.

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”.""","{'cost_tensor': [[[30, 14, 30, 53], [35, 10, 93, 53], [86, 92, 3, 96], [94, 4, 12, 60]], [[19, 16, 73, 42], [1, 35, 5, 43], [79, 41, 43, 32], [61, 57, 15, 2]], [[48, 22, 5, 96], [22, 74, 5, 63], [69, 37, 15, 74], [59, 55, 61, 54]], [[69, 78, 89, 78], [78, 56, 1, 5], [25, 59, 15, 20], [55, 59, 67, 90]]], 'objective': 30.0}","[[0, 3, 1], [1, 1, 0], [2, 0, 2], [3, 2, 3]]",30.0,"{'problem_type': 'AP3', 'n': 4, 'ids': ['A', 'B', 'C', 'D'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 30}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 14}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 30}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 53}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 35}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 10}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 93}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 53}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 86}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 92}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 3}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 96}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 94}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 4}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 12}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 60}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 19}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 16}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 73}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 42}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 1}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 35}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 5}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 43}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 79}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 41}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 43}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 32}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 61}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 57}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 15}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 2}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 48}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 22}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 5}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 96}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 22}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 74}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 5}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 63}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 69}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 37}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 15}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 74}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 59}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 55}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 61}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 54}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 69}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 78}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 89}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 78}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 78}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 56}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 1}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 5}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 25}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 59}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 15}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 20}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 55}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 59}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 67}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 90}]}","[['A', 'D', 'B'], ['B', 'B', 'A'], ['C', 'A', 'C'], ['D', 'C', 'D']]",30,csv,names
AP3,AP3,"Picture this: a rehearsal studio, a stack of song sheets, and a roster of musicians and instruments to assign — each song needs one musician and one instrument, and each musician and instrument must be used once and only once. Every possible assignment has a rehearsal cost and an instrument rental cost attached, and the task is to arrange the whole set so the total of those costs (sum rehearsal plus rental for each chosen trio) is as low as it can get. The exact data and costs appear below.

There are 3 songs, 3 musicians, and 3 instruments labeled A, B, C.
Meaning: costs form a 3D tensor. For each fixed song_id=i, you are given a musician_id×instrument_id matrix whose entry at row musician_id=j and column instrument_id=k equals rehearsal_plus_rental_cost(i,j,k). You must pick exactly one (j,k) for every i, with all musician_id and all instrument_id used exactly once.
rehearsal_plus_rental_cost_tensor (per-song_id markdown matrices):
## song_id=A
| musician_id\instrument_id | A | B | C |
|---|---|---|---|
| A | 24 | 78 | 7 |
| B | 61 | 47 | 79 |
| C | 74 | 47 | 52 |

## song_id=B
| musician_id\instrument_id | A | B | C |
|---|---|---|---|
| A | 30 | 68 | 29 |
| B | 56 | 60 | 41 |
| C | 13 | 3 | 97 |

## song_id=C
| musician_id\instrument_id | A | B | C |
|---|---|---|---|
| A | 11 | 64 | 35 |
| B | 16 | 17 | 55 |
| C | 29 | 83 | 84 |
List each triple and its combined cost so the total can be minimized.

Also, when you want to give me the matching, just drop it in this little JSON shape so it's easy to parse and double-check:

{
  ""solution"": [
    [<song_id>, <musician_id>, <instrument_id>],
    ...
  ]
}

Here ""solution"" is a list of triples. Each triple picks one song, one musician, and one instrument — in that order. Think of each inner array as the form you'd fill out for a single song: [which song, which musician, which instrument]. This block is just a sketch of the expected shape, not the actual answer — fill it with the actual identifiers from the instance.

Please be sure to use the exact identifiers from the instance input with no renaming and no invented 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”.","{'cost_tensor': [[[24, 78, 7], [61, 47, 79], [74, 47, 52]], [[30, 68, 29], [56, 60, 41], [13, 3, 97]], [[11, 64, 35], [16, 17, 55], [29, 83, 84]]], 'objective': 26.0}","[[0, 0, 2], [1, 2, 1], [2, 1, 0]]",26.0,"{'problem_type': 'AP3', 'n': 3, 'ids': ['A', 'B', 'C'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 24}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 78}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 7}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 61}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 47}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 79}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 74}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 47}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 52}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 30}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 68}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 29}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 56}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 60}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 41}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 13}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 3}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 97}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 11}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 64}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 35}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 16}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 17}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 55}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 29}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 83}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 84}]}","[['A', 'A', 'C'], ['B', 'C', 'B'], ['C', 'B', 'A']]",31,nl,names
AP3,AP3,"Recently the team had to assign one artist and one frame to each commission, and there happened to be exactly as many artists and frames as jobs, so each artist and each frame is assigned exactly once. Every possible artist+frame choice for a commission carries a specific price; the idea is to decide the pairing for each commission so the sum of those chosen prices (the total cost) ends up as small as possible. The concrete details — who, which frame, and how much — are laid out below.

{
  ""num_commissions"": 3,
  ""commission_ids"": [
    0,
    1,
    2
  ]
}

# Meaning: costs form a 3D tensor. For each fixed commission_id=i, you are given a artist_id×frame_id matrix whose entry at row artist_id=j and column frame_id=k equals commission_price(i,j,k). You must pick exactly one (j,k) for every i, with all artist_id and all frame_id used exactly once.
# commission_price_tensor (per-commission_id markdown matrices)

## commission_id=0
| artist_id\frame_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 87 | 9 | 31 |
| 1 | 88 | 21 | 60 |
| 2 | 87 | 28 | 63 |

## commission_id=1
| artist_id\frame_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 69 | 13 | 51 |
| 1 | 49 | 36 | 84 |
| 2 | 60 | 59 | 15 |

## commission_id=2
| artist_id\frame_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 24 | 86 | 37 |
| 1 | 40 | 68 | 23 |
| 2 | 79 | 52 | 39 |

If you want the result in a predictable, machine-friendly shape, just hand it over like this:

{
  ""solution"": [
    [<commission_id>, <artist_id>, <frame_id>],
    ...
  ]
}

This just means ""solution"" is a list of triples, and each triple says which commission gets which artist and which frame. It's just a sketch of the shape I expect — replace each placeholder with the actual identifier from the instance to show your chosen assignments.

Please use the identifiers exactly as they appear in the instance input — don't rename them or invent new labels.
- For example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'cost_tensor': [[[87, 9, 31], [88, 21, 60], [87, 28, 63]], [[69, 13, 51], [49, 36, 84], [60, 59, 15]], [[24, 86, 37], [40, 68, 23], [79, 52, 39]]], 'objective': 60.0}","[[0, 1, 1], [1, 2, 2], [2, 0, 0]]",60.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [0, 1, 2], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 87}, {'i': 0, 'j': 0, 'k': 1, 'cost': 9}, {'i': 0, 'j': 0, 'k': 2, 'cost': 31}, {'i': 0, 'j': 1, 'k': 0, 'cost': 88}, {'i': 0, 'j': 1, 'k': 1, 'cost': 21}, {'i': 0, 'j': 1, 'k': 2, 'cost': 60}, {'i': 0, 'j': 2, 'k': 0, 'cost': 87}, {'i': 0, 'j': 2, 'k': 1, 'cost': 28}, {'i': 0, 'j': 2, 'k': 2, 'cost': 63}, {'i': 1, 'j': 0, 'k': 0, 'cost': 69}, {'i': 1, 'j': 0, 'k': 1, 'cost': 13}, {'i': 1, 'j': 0, 'k': 2, 'cost': 51}, {'i': 1, 'j': 1, 'k': 0, 'cost': 49}, {'i': 1, 'j': 1, 'k': 1, 'cost': 36}, {'i': 1, 'j': 1, 'k': 2, 'cost': 84}, {'i': 1, 'j': 2, 'k': 0, 'cost': 60}, {'i': 1, 'j': 2, 'k': 1, 'cost': 59}, {'i': 1, 'j': 2, 'k': 2, 'cost': 15}, {'i': 2, 'j': 0, 'k': 0, 'cost': 24}, {'i': 2, 'j': 0, 'k': 1, 'cost': 86}, {'i': 2, 'j': 0, 'k': 2, 'cost': 37}, {'i': 2, 'j': 1, 'k': 0, 'cost': 40}, {'i': 2, 'j': 1, 'k': 1, 'cost': 68}, {'i': 2, 'j': 1, 'k': 2, 'cost': 23}, {'i': 2, 'j': 2, 'k': 0, 'cost': 79}, {'i': 2, 'j': 2, 'k': 1, 'cost': 52}, {'i': 2, 'j': 2, 'k': 2, 'cost': 39}]}","[[0, 1, 1], [1, 2, 2], [2, 0, 0]]",32,json,0
AP3,AP3,"Many people on the floor talk about it like a matching game: each shipment needs one container and one loading bay, and there are exactly as many containers and bays as there are shipments. One container and one bay per shipment, no sharing, no leftovers. Each combination of shipment, container, and bay has a price, and the whole day’s expense is the sum of those prices — the aim is to keep that sum as low as possible. The concrete details are shown below.

{
  ""num_shipments"": 4,
  ""shipment_identifiers"": [
    0,
    1,
    2,
    3
  ]
}

# Meaning: costs form a 3D tensor. For each fixed shipment_id=i, you are given a container_id×loading_dock_id matrix whose entry at row container_id=j and column loading_dock_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all container_id and all loading_dock_id used exactly once.
# assignment_cost_tensor (per-shipment_id markdown matrices)

## shipment_id=0
| container_id\loading_dock_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 38 | 14 | 20 | 74 |
| 1 | 81 | 92 | 45 | 10 |
| 2 | 16 | 39 | 82 | 62 |
| 3 | 36 | 78 | 57 | 22 |

## shipment_id=1
| container_id\loading_dock_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 45 | 49 | 98 | 12 |
| 1 | 63 | 44 | 37 | 47 |
| 2 | 88 | 8 | 70 | 74 |
| 3 | 24 | 67 | 84 | 73 |

## shipment_id=2
| container_id\loading_dock_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 97 | 11 | 87 | 66 |
| 1 | 13 | 64 | 38 | 63 |
| 2 | 9 | 81 | 18 | 56 |
| 3 | 83 | 84 | 6 | 75 |

## shipment_id=3
| container_id\loading_dock_id | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 0 | 87 | 43 | 50 | 79 |
| 1 | 52 | 79 | 61 | 77 |
| 2 | 20 | 31 | 5 | 43 |
| 3 | 70 | 14 | 93 | 3 |

If you want to hand the matching back in a tidy way, just follow this little JSON sketch below — it's an easy, predictable shape that makes it clear which shipment goes with which container and which bay.

{
  ""solution"": [
    [<shipment_id>, <container_id>, <bay_id>],
    ...
  ]
}

Each inner array is one chosen triple: [shipment_id, container_id, bay_id]. Think of each line as ""this shipment gets this container and this bay."" It's just an example of the expected shape — not the actual answer.

Please be sure to use the exact identifiers from the instance input — don't rename them or invent new labels.  
Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'cost_tensor': [[[38, 14, 20, 74], [81, 92, 45, 10], [16, 39, 82, 62], [36, 78, 57, 22]], [[45, 49, 98, 12], [63, 44, 37, 47], [88, 8, 70, 74], [24, 67, 84, 73]], [[97, 11, 87, 66], [13, 64, 38, 63], [9, 81, 18, 56], [83, 84, 6, 75]], [[87, 43, 50, 79], [52, 79, 61, 77], [20, 31, 5, 43], [70, 14, 93, 3]]], 'objective': 44.0}","[[0, 0, 2], [1, 2, 1], [2, 1, 0], [3, 3, 3]]",44.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [0, 1, 2, 3], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 38}, {'i': 0, 'j': 0, 'k': 1, 'cost': 14}, {'i': 0, 'j': 0, 'k': 2, 'cost': 20}, {'i': 0, 'j': 0, 'k': 3, 'cost': 74}, {'i': 0, 'j': 1, 'k': 0, 'cost': 81}, {'i': 0, 'j': 1, 'k': 1, 'cost': 92}, {'i': 0, 'j': 1, 'k': 2, 'cost': 45}, {'i': 0, 'j': 1, 'k': 3, 'cost': 10}, {'i': 0, 'j': 2, 'k': 0, 'cost': 16}, {'i': 0, 'j': 2, 'k': 1, 'cost': 39}, {'i': 0, 'j': 2, 'k': 2, 'cost': 82}, {'i': 0, 'j': 2, 'k': 3, 'cost': 62}, {'i': 0, 'j': 3, 'k': 0, 'cost': 36}, {'i': 0, 'j': 3, 'k': 1, 'cost': 78}, {'i': 0, 'j': 3, 'k': 2, 'cost': 57}, {'i': 0, 'j': 3, 'k': 3, 'cost': 22}, {'i': 1, 'j': 0, 'k': 0, 'cost': 45}, {'i': 1, 'j': 0, 'k': 1, 'cost': 49}, {'i': 1, 'j': 0, 'k': 2, 'cost': 98}, {'i': 1, 'j': 0, 'k': 3, 'cost': 12}, {'i': 1, 'j': 1, 'k': 0, 'cost': 63}, {'i': 1, 'j': 1, 'k': 1, 'cost': 44}, {'i': 1, 'j': 1, 'k': 2, 'cost': 37}, {'i': 1, 'j': 1, 'k': 3, 'cost': 47}, {'i': 1, 'j': 2, 'k': 0, 'cost': 88}, {'i': 1, 'j': 2, 'k': 1, 'cost': 8}, {'i': 1, 'j': 2, 'k': 2, 'cost': 70}, {'i': 1, 'j': 2, 'k': 3, 'cost': 74}, {'i': 1, 'j': 3, 'k': 0, 'cost': 24}, {'i': 1, 'j': 3, 'k': 1, 'cost': 67}, {'i': 1, 'j': 3, 'k': 2, 'cost': 84}, {'i': 1, 'j': 3, 'k': 3, 'cost': 73}, {'i': 2, 'j': 0, 'k': 0, 'cost': 97}, {'i': 2, 'j': 0, 'k': 1, 'cost': 11}, {'i': 2, 'j': 0, 'k': 2, 'cost': 87}, {'i': 2, 'j': 0, 'k': 3, 'cost': 66}, {'i': 2, 'j': 1, 'k': 0, 'cost': 13}, {'i': 2, 'j': 1, 'k': 1, 'cost': 64}, {'i': 2, 'j': 1, 'k': 2, 'cost': 38}, {'i': 2, 'j': 1, 'k': 3, 'cost': 63}, {'i': 2, 'j': 2, 'k': 0, 'cost': 9}, {'i': 2, 'j': 2, 'k': 1, 'cost': 81}, {'i': 2, 'j': 2, 'k': 2, 'cost': 18}, {'i': 2, 'j': 2, 'k': 3, 'cost': 56}, {'i': 2, 'j': 3, 'k': 0, 'cost': 83}, {'i': 2, 'j': 3, 'k': 1, 'cost': 84}, {'i': 2, 'j': 3, 'k': 2, 'cost': 6}, {'i': 2, 'j': 3, 'k': 3, 'cost': 75}, {'i': 3, 'j': 0, 'k': 0, 'cost': 87}, {'i': 3, 'j': 0, 'k': 1, 'cost': 43}, {'i': 3, 'j': 0, 'k': 2, 'cost': 50}, {'i': 3, 'j': 0, 'k': 3, 'cost': 79}, {'i': 3, 'j': 1, 'k': 0, 'cost': 52}, {'i': 3, 'j': 1, 'k': 1, 'cost': 79}, {'i': 3, 'j': 1, 'k': 2, 'cost': 61}, {'i': 3, 'j': 1, 'k': 3, 'cost': 77}, {'i': 3, 'j': 2, 'k': 0, 'cost': 20}, {'i': 3, 'j': 2, 'k': 1, 'cost': 31}, {'i': 3, 'j': 2, 'k': 2, 'cost': 5}, {'i': 3, 'j': 2, 'k': 3, 'cost': 43}, {'i': 3, 'j': 3, 'k': 0, 'cost': 70}, {'i': 3, 'j': 3, 'k': 1, 'cost': 14}, {'i': 3, 'j': 3, 'k': 2, 'cost': 93}, {'i': 3, 'j': 3, 'k': 3, 'cost': 3}]}","[[0, 0, 2], [1, 2, 1], [2, 1, 0], [3, 3, 3]]",33,json,0
AP3,AP3,"There’s a day with a set of tutoring slots that all need a single tutor and a single textbook, and the catch is each tutor and each textbook can be used only once so nothing is repeated or left unused. The best plan is simply the one with the least total expense — get the cost for each session (tutor plus book), add them up, and choose the arrangement with the smallest sum. The concrete numbers are shown below.

{
  ""num_sessions"": 3,
  ""index_labels"": [
    0,
    1,
    2
  ]
}

# Meaning: costs form a 3D tensor. For each fixed session_id=i, you are given a tutor_id×textbook_id matrix whose entry at row tutor_id=j and column textbook_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all tutor_id and all textbook_id used exactly once.
# assignment_cost_tensor (per-session_id markdown matrices)

## session_id=0
| tutor_id\textbook_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 30 | 88 | 3 |
| 1 | 39 | 67 | 73 |
| 2 | 23 | 83 | 96 |

## session_id=1
| tutor_id\textbook_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 27 | 13 | 86 |
| 1 | 20 | 13 | 29 |
| 2 | 21 | 56 | 71 |

## session_id=2
| tutor_id\textbook_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 86 | 89 | 97 |
| 1 | 43 | 12 | 45 |
| 2 | 98 | 65 | 60 |

If you prefer to get the plan in a tidy, machine-friendly snippet, I usually show it in a little JSON object like this.

{
  ""solution"": [
    [<slot_id>, <tutor_id>, <textbook_id>],
    ...
  ]
}

Each inner triple is one tutoring session: the first placeholder is the slot, the second is the tutor assigned to that slot, and the third is the textbook used. Think of it as a simple form where each row says ""slot X gets tutor Y and book Z."" This is just a sketch of the shape the answer should take, not the actual assignment.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[30, 88, 3], [39, 67, 73], [23, 83, 96]], [[27, 13, 86], [20, 13, 29], [21, 56, 71]], [[86, 89, 97], [43, 12, 45], [98, 65, 60]]], 'objective': 36.0}","[[0, 0, 2], [1, 2, 0], [2, 1, 1]]",36.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [0, 1, 2], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 30}, {'i': 0, 'j': 0, 'k': 1, 'cost': 88}, {'i': 0, 'j': 0, 'k': 2, 'cost': 3}, {'i': 0, 'j': 1, 'k': 0, 'cost': 39}, {'i': 0, 'j': 1, 'k': 1, 'cost': 67}, {'i': 0, 'j': 1, 'k': 2, 'cost': 73}, {'i': 0, 'j': 2, 'k': 0, 'cost': 23}, {'i': 0, 'j': 2, 'k': 1, 'cost': 83}, {'i': 0, 'j': 2, 'k': 2, 'cost': 96}, {'i': 1, 'j': 0, 'k': 0, 'cost': 27}, {'i': 1, 'j': 0, 'k': 1, 'cost': 13}, {'i': 1, 'j': 0, 'k': 2, 'cost': 86}, {'i': 1, 'j': 1, 'k': 0, 'cost': 20}, {'i': 1, 'j': 1, 'k': 1, 'cost': 13}, {'i': 1, 'j': 1, 'k': 2, 'cost': 29}, {'i': 1, 'j': 2, 'k': 0, 'cost': 21}, {'i': 1, 'j': 2, 'k': 1, 'cost': 56}, {'i': 1, 'j': 2, 'k': 2, 'cost': 71}, {'i': 2, 'j': 0, 'k': 0, 'cost': 86}, {'i': 2, 'j': 0, 'k': 1, 'cost': 89}, {'i': 2, 'j': 0, 'k': 2, 'cost': 97}, {'i': 2, 'j': 1, 'k': 0, 'cost': 43}, {'i': 2, 'j': 1, 'k': 1, 'cost': 12}, {'i': 2, 'j': 1, 'k': 2, 'cost': 45}, {'i': 2, 'j': 2, 'k': 0, 'cost': 98}, {'i': 2, 'j': 2, 'k': 1, 'cost': 65}, {'i': 2, 'j': 2, 'k': 2, 'cost': 60}]}","[[0, 0, 2], [1, 2, 0], [2, 1, 1]]",34,json,0
AP3,AP3,"Someone working the yard-of-records had to match crews and paint cans to houses so that each crew works once and each color shows up on only one house. The idea was to keep the total expenditure as low as it can be: for each house add up that team’s labor charge and the cost of the chosen paint, and then sum those amounts for every house to get the final cost. Every crew must be used exactly once and every color must be used exactly once, and the detailed instance information follows below.

There are 4 houses to be painted (hence 4 crews and 4 paint colors), identified as 1, 2, 3, 4.

*Meaning: costs form a 3D tensor. For each fixed house_id=i, you are given a crew_id×paint_color_id matrix whose entry at row crew_id=j and column paint_color_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all crew_id and all paint_color_id used exactly once.*

**assignment_cost_tensor (per-house_id markdown matrices)**

## house_id=1
| crew_id\paint_color_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 55 | 19 | 67 | 40 |
| 2 | 64 | 23 | 24 | 84 |
| 3 | 32 | 68 | 88 | 42 |
| 4 | 25 | 30 | 52 | 56 |

## house_id=2
| crew_id\paint_color_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 59 | 79 | 80 | 66 |
| 2 | 6 | 4 | 10 | 24 |
| 3 | 63 | 95 | 98 | 27 |
| 4 | 4 | 51 | 67 | 43 |

## house_id=3
| crew_id\paint_color_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 18 | 36 | 20 | 52 |
| 2 | 6 | 1 | 45 | 79 |
| 3 | 61 | 89 | 81 | 43 |
| 4 | 10 | 13 | 73 | 53 |

## house_id=4
| crew_id\paint_color_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 76 | 82 | 66 | 95 |
| 2 | 12 | 93 | 62 | 76 |
| 3 | 63 | 60 | 43 | 7 |
| 4 | 99 | 5 | 5 | 3 |

All crews and all paint colors are used exactly once across the 4 houses.

If you want to hand me the matching in a tidy, machine-friendly way, just follow this simple shape — nothing fancy, just a list of triples that say which house gets which crew and which color:

{
  ""solution"": [
    [<house_id>, <crew_id>, <color_id>],
    ...
  ]
}

This is just a quick template: each inner array is one triple — the house, the crew assigned to that house, and the paint color used there. It's only the form I expect, not the actual assignment.

Please make sure to use the exact identifiers from the instance input — no renaming and no invented labels.

For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[55, 19, 67, 40], [64, 23, 24, 84], [32, 68, 88, 42], [25, 30, 52, 56]], [[59, 79, 80, 66], [6, 4, 10, 24], [63, 95, 98, 27], [4, 51, 67, 43]], [[18, 36, 20, 52], [6, 1, 45, 79], [61, 89, 81, 43], [10, 13, 73, 53]], [[76, 82, 66, 95], [12, 93, 62, 76], [63, 60, 43, 7], [99, 5, 5, 3]]], 'objective': 46.0}","[[0, 0, 1], [1, 1, 2], [2, 3, 0], [3, 2, 3]]",46.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 55}, {'i': 1, 'j': 1, 'k': 2, 'cost': 19}, {'i': 1, 'j': 1, 'k': 3, 'cost': 67}, {'i': 1, 'j': 1, 'k': 4, 'cost': 40}, {'i': 1, 'j': 2, 'k': 1, 'cost': 64}, {'i': 1, 'j': 2, 'k': 2, 'cost': 23}, {'i': 1, 'j': 2, 'k': 3, 'cost': 24}, {'i': 1, 'j': 2, 'k': 4, 'cost': 84}, {'i': 1, 'j': 3, 'k': 1, 'cost': 32}, {'i': 1, 'j': 3, 'k': 2, 'cost': 68}, {'i': 1, 'j': 3, 'k': 3, 'cost': 88}, {'i': 1, 'j': 3, 'k': 4, 'cost': 42}, {'i': 1, 'j': 4, 'k': 1, 'cost': 25}, {'i': 1, 'j': 4, 'k': 2, 'cost': 30}, {'i': 1, 'j': 4, 'k': 3, 'cost': 52}, {'i': 1, 'j': 4, 'k': 4, 'cost': 56}, {'i': 2, 'j': 1, 'k': 1, 'cost': 59}, {'i': 2, 'j': 1, 'k': 2, 'cost': 79}, {'i': 2, 'j': 1, 'k': 3, 'cost': 80}, {'i': 2, 'j': 1, 'k': 4, 'cost': 66}, {'i': 2, 'j': 2, 'k': 1, 'cost': 6}, {'i': 2, 'j': 2, 'k': 2, 'cost': 4}, {'i': 2, 'j': 2, 'k': 3, 'cost': 10}, {'i': 2, 'j': 2, 'k': 4, 'cost': 24}, {'i': 2, 'j': 3, 'k': 1, 'cost': 63}, {'i': 2, 'j': 3, 'k': 2, 'cost': 95}, {'i': 2, 'j': 3, 'k': 3, 'cost': 98}, {'i': 2, 'j': 3, 'k': 4, 'cost': 27}, {'i': 2, 'j': 4, 'k': 1, 'cost': 4}, {'i': 2, 'j': 4, 'k': 2, 'cost': 51}, {'i': 2, 'j': 4, 'k': 3, 'cost': 67}, {'i': 2, 'j': 4, 'k': 4, 'cost': 43}, {'i': 3, 'j': 1, 'k': 1, 'cost': 18}, {'i': 3, 'j': 1, 'k': 2, 'cost': 36}, {'i': 3, 'j': 1, 'k': 3, 'cost': 20}, {'i': 3, 'j': 1, 'k': 4, 'cost': 52}, {'i': 3, 'j': 2, 'k': 1, 'cost': 6}, {'i': 3, 'j': 2, 'k': 2, 'cost': 1}, {'i': 3, 'j': 2, 'k': 3, 'cost': 45}, {'i': 3, 'j': 2, 'k': 4, 'cost': 79}, {'i': 3, 'j': 3, 'k': 1, 'cost': 61}, {'i': 3, 'j': 3, 'k': 2, 'cost': 89}, {'i': 3, 'j': 3, 'k': 3, 'cost': 81}, {'i': 3, 'j': 3, 'k': 4, 'cost': 43}, {'i': 3, 'j': 4, 'k': 1, 'cost': 10}, {'i': 3, 'j': 4, 'k': 2, 'cost': 13}, {'i': 3, 'j': 4, 'k': 3, 'cost': 73}, {'i': 3, 'j': 4, 'k': 4, 'cost': 53}, {'i': 4, 'j': 1, 'k': 1, 'cost': 76}, {'i': 4, 'j': 1, 'k': 2, 'cost': 82}, {'i': 4, 'j': 1, 'k': 3, 'cost': 66}, {'i': 4, 'j': 1, 'k': 4, 'cost': 95}, {'i': 4, 'j': 2, 'k': 1, 'cost': 12}, {'i': 4, 'j': 2, 'k': 2, 'cost': 93}, {'i': 4, 'j': 2, 'k': 3, 'cost': 62}, {'i': 4, 'j': 2, 'k': 4, 'cost': 76}, {'i': 4, 'j': 3, 'k': 1, 'cost': 63}, {'i': 4, 'j': 3, 'k': 2, 'cost': 60}, {'i': 4, 'j': 3, 'k': 3, 'cost': 43}, {'i': 4, 'j': 3, 'k': 4, 'cost': 7}, {'i': 4, 'j': 4, 'k': 1, 'cost': 99}, {'i': 4, 'j': 4, 'k': 2, 'cost': 5}, {'i': 4, 'j': 4, 'k': 3, 'cost': 5}, {'i': 4, 'j': 4, 'k': 4, 'cost': 3}]}","[[1, 1, 2], [2, 2, 3], [3, 4, 1], [4, 3, 4]]",35,markdown_table,1
AP3,AP3,"I’m juggling the neighborhood grocery deliveries: for every online order there’s a need to pick one courier and one dropoff window. The trick is to choose those pairs so the total delivery bill — the sum of each order’s chosen courier+window cost — ends up as small as possible, and nobody gets left out or double-booked: every courier does exactly one order and every time window is used exactly once. The exact orders, couriers, windows and their costs are listed below.

I'm looking at 3 orders, identified as 1, 2, 3.

*Meaning: costs form a 3D tensor. For each fixed order_id=i, you are given a courier_id×window_id matrix whose entry at row courier_id=j and column window_id=k equals delivery_cost(i,j,k). You must pick exactly one (j,k) for every i, with all courier_id and all window_id used exactly once.*

**delivery_cost_tensor (per-order_id markdown matrices)**

## order_id=1
| courier_id\window_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 84 | 38 | 96 |
| 2 | 8 | 77 | 78 |
| 3 | 63 | 60 | 78 |

## order_id=2
| courier_id\window_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 18 | 27 | 92 |
| 2 | 58 | 19 | 50 |
| 3 | 29 | 77 | 1 |

## order_id=3
| courier_id\window_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 41 | 36 | 2 |
| 2 | 51 | 59 | 36 |
| 3 | 5 | 55 | 28 |

That's the full list — time for me to pick the one-to-one courier/window pairings that minimize the total delivery bill.

Oh, and when you send back the picks, a little JSON like this makes it super easy to read:

{
  ""solution"": [
    [""<order_id>"", ""<courier_id>"", ""<window_id>""],
    [""<order_id>"", ""<courier_id>"", ""<window_id>""],
    [""<order_id>"", ""<courier_id>"", ""<window_id>""]
  ]
}

Each inner triple is just one assignment: which order goes with which courier and which dropoff window. Think of the block above as a form — the shape I expect, not the actual filled-in answer.

Please make sure you use the exact identifiers from the instance input — no renaming and no new labels. 
Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'cost_tensor': [[[84, 38, 96], [8, 77, 78], [63, 60, 78]], [[18, 27, 92], [58, 19, 50], [29, 77, 1]], [[41, 36, 2], [51, 59, 36], [5, 55, 28]]], 'objective': 45.0}","[[0, 1, 0], [1, 2, 2], [2, 0, 1]]",45.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [1, 2, 3], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 84}, {'i': 1, 'j': 1, 'k': 2, 'cost': 38}, {'i': 1, 'j': 1, 'k': 3, 'cost': 96}, {'i': 1, 'j': 2, 'k': 1, 'cost': 8}, {'i': 1, 'j': 2, 'k': 2, 'cost': 77}, {'i': 1, 'j': 2, 'k': 3, 'cost': 78}, {'i': 1, 'j': 3, 'k': 1, 'cost': 63}, {'i': 1, 'j': 3, 'k': 2, 'cost': 60}, {'i': 1, 'j': 3, 'k': 3, 'cost': 78}, {'i': 2, 'j': 1, 'k': 1, 'cost': 18}, {'i': 2, 'j': 1, 'k': 2, 'cost': 27}, {'i': 2, 'j': 1, 'k': 3, 'cost': 92}, {'i': 2, 'j': 2, 'k': 1, 'cost': 58}, {'i': 2, 'j': 2, 'k': 2, 'cost': 19}, {'i': 2, 'j': 2, 'k': 3, 'cost': 50}, {'i': 2, 'j': 3, 'k': 1, 'cost': 29}, {'i': 2, 'j': 3, 'k': 2, 'cost': 77}, {'i': 2, 'j': 3, 'k': 3, 'cost': 1}, {'i': 3, 'j': 1, 'k': 1, 'cost': 41}, {'i': 3, 'j': 1, 'k': 2, 'cost': 36}, {'i': 3, 'j': 1, 'k': 3, 'cost': 2}, {'i': 3, 'j': 2, 'k': 1, 'cost': 51}, {'i': 3, 'j': 2, 'k': 2, 'cost': 59}, {'i': 3, 'j': 2, 'k': 3, 'cost': 36}, {'i': 3, 'j': 3, 'k': 1, 'cost': 5}, {'i': 3, 'j': 3, 'k': 2, 'cost': 55}, {'i': 3, 'j': 3, 'k': 3, 'cost': 28}]}","[[1, 2, 1], [2, 3, 3], [3, 1, 2]]",36,markdown_table,1
AP3,AP3,"On a busy week the theater must pair up rehearsals, rooms, and techs so that each rehearsal gets one room and one technician and each room and technician is used once and only once. Every pairing carries a setup-plus-staff cost, and the aim is to choose the combination of pairings that makes the total of all those costs as small as it can be. The specific entries and cost figures are shown below.

There are 3 rehearsals, identified as 1, 2, 3.
Meaning: costs form a 3D tensor. For each fixed rehearsal_id=i, you are given a room_id×technician_id matrix whose entry at row room_id=j and column technician_id=k equals setup_and_staff_cost(i,j,k). You must pick exactly one (j,k) for every i, with all room_id and all technician_id used exactly once.
setup_and_staff_cost_tensor (per-rehearsal_id markdown matrices):
## rehearsal_id=1
| room_id\technician_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 39 | 25 | 11 |
| 2 | 59 | 3 | 48 |
| 3 | 26 | 73 | 14 |

## rehearsal_id=2
| room_id\technician_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 6 | 19 | 3 |
| 2 | 12 | 97 | 60 |
| 3 | 7 | 78 | 89 |

## rehearsal_id=3
| room_id\technician_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 4 | 8 | 50 |
| 2 | 88 | 30 | 9 |
| 3 | 5 | 17 | 31 |
One triple must be selected for each of the 3 rehearsals (1, 2, 3) so that the total setup-plus-staff cost is minimized.

If you send the final matching back, a nice compact way to show it is in a little JSON snippet like this:

{
  ""solution"": [
    [<rehearsal_id>, <room_id>, <tech_id>],
    ...
  ]
}

This just says ""solution"" is a list of triples — each triple picks one rehearsal, one room, and one technician. Think of each inner array as one complete booking (which rehearsal goes with which room and which tech). This is just the expected shape of the answer, not the actual matching — fill in the real IDs from the instance when you reply.

Please be sure to use the exact identifiers from the instance input — no renaming and no new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[39, 25, 11], [59, 3, 48], [26, 73, 14]], [[6, 19, 3], [12, 97, 60], [7, 78, 89]], [[4, 8, 50], [88, 30, 9], [5, 17, 31]]], 'objective': 11.0}","[[0, 1, 1], [1, 0, 2], [2, 2, 0]]",11.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [1, 2, 3], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 39}, {'i': 1, 'j': 1, 'k': 2, 'cost': 25}, {'i': 1, 'j': 1, 'k': 3, 'cost': 11}, {'i': 1, 'j': 2, 'k': 1, 'cost': 59}, {'i': 1, 'j': 2, 'k': 2, 'cost': 3}, {'i': 1, 'j': 2, 'k': 3, 'cost': 48}, {'i': 1, 'j': 3, 'k': 1, 'cost': 26}, {'i': 1, 'j': 3, 'k': 2, 'cost': 73}, {'i': 1, 'j': 3, 'k': 3, 'cost': 14}, {'i': 2, 'j': 1, 'k': 1, 'cost': 6}, {'i': 2, 'j': 1, 'k': 2, 'cost': 19}, {'i': 2, 'j': 1, 'k': 3, 'cost': 3}, {'i': 2, 'j': 2, 'k': 1, 'cost': 12}, {'i': 2, 'j': 2, 'k': 2, 'cost': 97}, {'i': 2, 'j': 2, 'k': 3, 'cost': 60}, {'i': 2, 'j': 3, 'k': 1, 'cost': 7}, {'i': 2, 'j': 3, 'k': 2, 'cost': 78}, {'i': 2, 'j': 3, 'k': 3, 'cost': 89}, {'i': 3, 'j': 1, 'k': 1, 'cost': 4}, {'i': 3, 'j': 1, 'k': 2, 'cost': 8}, {'i': 3, 'j': 1, 'k': 3, 'cost': 50}, {'i': 3, 'j': 2, 'k': 1, 'cost': 88}, {'i': 3, 'j': 2, 'k': 2, 'cost': 30}, {'i': 3, 'j': 2, 'k': 3, 'cost': 9}, {'i': 3, 'j': 3, 'k': 1, 'cost': 5}, {'i': 3, 'j': 3, 'k': 2, 'cost': 17}, {'i': 3, 'j': 3, 'k': 3, 'cost': 31}]}","[[1, 2, 2], [2, 1, 3], [3, 3, 1]]",37,nl,1
AP3,AP3,"I was the one arranging the reception and had to pick, for every table, exactly one caterer and exactly one dessert so nobody doubles up and nothing gets left out. For each table the caterer-plus-dessert combo has a price, and the trick is to make choices so that when all those table bills are added together the whole catering tab is as small as possible. Every caterer can only be assigned to one table and every dessert choice can only be used once. The exact list of tables, caterers, desserts and their prices is shown below.

{
  ""num_tables"": 3,
  ""table_identifiers"": [
    ""A"",
    ""B"",
    ""C""
  ]
}

# Meaning: costs form a 3D tensor. For each fixed table_id=i, you are given a caterer_id×dessert_id matrix whose entry at row caterer_id=j and column dessert_id=k equals price(i,j,k). You must pick exactly one (j,k) for every i, with all caterer_id and all dessert_id used exactly once.
# price_tensor (per-table_id markdown matrices)

## table_id=A
| caterer_id\dessert_id | A | B | C |
|---|---|---|---|
| A | 39 | 95 | 28 |
| B | 93 | 22 | 50 |
| C | 2 | 88 | 36 |

## table_id=B
| caterer_id\dessert_id | A | B | C |
|---|---|---|---|
| A | 72 | 46 | 90 |
| B | 63 | 25 | 91 |
| C | 61 | 71 | 71 |

## table_id=C
| caterer_id\dessert_id | A | B | C |
|---|---|---|---|
| A | 85 | 89 | 54 |
| B | 32 | 69 | 93 |
| C | 96 | 72 | 21 |

Oh, and when you give the actual matching, just drop it into a tiny JSON object so it's easy to read and reuse. For example:

{
  ""solution"": [
    [<table_id>, <caterer_id>, <dessert_id>],
    ...
  ]
}

This means ""solution"" is a list of triples. Each triple is one table with the caterer and dessert assigned to it — [table, caterer, dessert]. It's just a sketch of the shape I expect, not the real assignment.

Please be sure to use the identifiers exactly as they appear in the instance input — no renaming, no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[39, 95, 28], [93, 22, 50], [2, 88, 36]], [[72, 46, 90], [63, 25, 91], [61, 71, 71]], [[85, 89, 54], [32, 69, 93], [96, 72, 21]]], 'objective': 81.0}","[[0, 2, 0], [1, 1, 1], [2, 0, 2]]",81.0,"{'problem_type': 'AP3', 'n': 3, 'ids': ['A', 'B', 'C'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 39}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 95}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 28}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 93}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 22}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 50}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 2}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 88}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 36}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 72}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 46}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 90}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 63}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 25}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 91}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 61}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 71}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 71}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 85}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 89}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 54}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 32}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 69}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 93}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 96}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 72}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 21}]}","[['A', 'C', 'A'], ['B', 'B', 'B'], ['C', 'A', 'C']]",38,json,names
AP3,AP3,"There’s a stack of class schedules and a roster of classrooms and TAs on the desk, and the task is simple in words: give every class exactly one classroom and exactly one teaching assistant. No classroom or assistant can be assigned twice and nothing should be left unassigned. Each possible triple (class, room, assistant) has a cost, and the goal is to pick triples that lead to the smallest overall running cost — you just add up the cost for each chosen triple to see the total. The detailed options and their costs are shown below.

{
  ""num_classes"": 5,
  ""class_room_ta_ids"": [
    ""A"",
    ""B"",
    ""C"",
    ""D"",
    ""E""
  ]
}

# Meaning: costs form a 3D tensor. For each fixed class_id=i, you are given a room_id×ta_id matrix whose entry at row room_id=j and column ta_id=k equals running_cost(i,j,k). You must pick exactly one (j,k) for every i, with all room_id and all ta_id used exactly once.
# running_cost_tensor (per-class_id markdown matrices)

## class_id=A
| room_id\ta_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 35 | 63 | 93 | 95 | 43 |
| B | 28 | 81 | 9 | 57 | 92 |
| C | 12 | 85 | 20 | 66 | 99 |
| D | 6 | 44 | 46 | 97 | 56 |
| E | 57 | 45 | 52 | 71 | 2 |

## class_id=B
| room_id\ta_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 67 | 13 | 75 | 57 | 99 |
| B | 70 | 94 | 37 | 6 | 56 |
| C | 61 | 48 | 38 | 12 | 84 |
| D | 8 | 12 | 91 | 79 | 69 |
| E | 33 | 48 | 25 | 73 | 49 |

## class_id=C
| room_id\ta_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 52 | 23 | 49 | 85 | 76 |
| B | 87 | 49 | 8 | 30 | 65 |
| C | 13 | 92 | 85 | 47 | 12 |
| D | 88 | 84 | 26 | 22 | 56 |
| E | 68 | 10 | 79 | 57 | 64 |

## class_id=D
| room_id\ta_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 18 | 72 | 33 | 41 | 48 |
| B | 32 | 54 | 41 | 54 | 67 |
| C | 6 | 16 | 81 | 88 | 19 |
| D | 45 | 97 | 74 | 19 | 64 |
| E | 81 | 60 | 85 | 58 | 7 |

## class_id=E
| room_id\ta_id | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 56 | 80 | 27 | 52 | 5 |
| B | 27 | 36 | 31 | 27 | 30 |
| C | 95 | 52 | 25 | 38 | 63 |
| D | 74 | 50 | 60 | 2 | 28 |
| E | 59 | 70 | 10 | 0 | 90 |

If you want the final assignment as a tidy little package, just hand it back in this JSON shape:

{
  ""solution"": [
    [<class_id>, <room_id>, <ta_id>],
    ...
  ]
}

This ""solution"" array should list one triple per class: each triple is the class identifier, the room identifier, and the TA identifier (in that order). Think of it like a simple form: one line per class saying which room and which TA it gets. This JSON is just a sketch of the expected shape — not the actual filled-in answer.

Please use the exact identifiers that appear in the instance input — no renaming and no new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[35, 63, 93, 95, 43], [28, 81, 9, 57, 92], [12, 85, 20, 66, 99], [6, 44, 46, 97, 56], [57, 45, 52, 71, 2]], [[67, 13, 75, 57, 99], [70, 94, 37, 6, 56], [61, 48, 38, 12, 84], [8, 12, 91, 79, 69], [33, 48, 25, 73, 49]], [[52, 23, 49, 85, 76], [87, 49, 8, 30, 65], [13, 92, 85, 47, 12], [88, 84, 26, 22, 56], [68, 10, 79, 57, 64]], [[18, 72, 33, 41, 48], [32, 54, 41, 54, 67], [6, 16, 81, 88, 19], [45, 97, 74, 19, 64], [81, 60, 85, 58, 7]], [[56, 80, 27, 52, 5], [27, 36, 31, 27, 30], [95, 52, 25, 38, 63], [74, 50, 60, 2, 28], [59, 70, 10, 0, 90]]], 'objective': 31.0}","[[0, 4, 4], [1, 0, 1], [2, 1, 2], [3, 2, 0], [4, 3, 3]]",31.0,"{'problem_type': 'AP3', 'n': 5, 'ids': ['A', 'B', 'C', 'D', 'E'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 35}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 63}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 93}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 95}, {'i': 'A', 'j': 'A', 'k': 'E', 'cost': 43}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 28}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 81}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 9}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 57}, {'i': 'A', 'j': 'B', 'k': 'E', 'cost': 92}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 12}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 85}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 20}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 66}, {'i': 'A', 'j': 'C', 'k': 'E', 'cost': 99}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 6}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 44}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 46}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 97}, {'i': 'A', 'j': 'D', 'k': 'E', 'cost': 56}, {'i': 'A', 'j': 'E', 'k': 'A', 'cost': 57}, {'i': 'A', 'j': 'E', 'k': 'B', 'cost': 45}, {'i': 'A', 'j': 'E', 'k': 'C', 'cost': 52}, {'i': 'A', 'j': 'E', 'k': 'D', 'cost': 71}, {'i': 'A', 'j': 'E', 'k': 'E', 'cost': 2}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 67}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 13}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 75}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 57}, {'i': 'B', 'j': 'A', 'k': 'E', 'cost': 99}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 70}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 94}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 37}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 6}, {'i': 'B', 'j': 'B', 'k': 'E', 'cost': 56}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 61}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 48}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 38}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 12}, {'i': 'B', 'j': 'C', 'k': 'E', 'cost': 84}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 8}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 12}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 91}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 79}, {'i': 'B', 'j': 'D', 'k': 'E', 'cost': 69}, {'i': 'B', 'j': 'E', 'k': 'A', 'cost': 33}, {'i': 'B', 'j': 'E', 'k': 'B', 'cost': 48}, {'i': 'B', 'j': 'E', 'k': 'C', 'cost': 25}, {'i': 'B', 'j': 'E', 'k': 'D', 'cost': 73}, {'i': 'B', 'j': 'E', 'k': 'E', 'cost': 49}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 52}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 23}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 49}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 85}, {'i': 'C', 'j': 'A', 'k': 'E', 'cost': 76}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 87}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 49}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 8}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 30}, {'i': 'C', 'j': 'B', 'k': 'E', 'cost': 65}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 13}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 92}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 85}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 47}, {'i': 'C', 'j': 'C', 'k': 'E', 'cost': 12}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 88}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 84}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 26}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 22}, {'i': 'C', 'j': 'D', 'k': 'E', 'cost': 56}, {'i': 'C', 'j': 'E', 'k': 'A', 'cost': 68}, {'i': 'C', 'j': 'E', 'k': 'B', 'cost': 10}, {'i': 'C', 'j': 'E', 'k': 'C', 'cost': 79}, {'i': 'C', 'j': 'E', 'k': 'D', 'cost': 57}, {'i': 'C', 'j': 'E', 'k': 'E', 'cost': 64}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 18}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 72}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 33}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 41}, {'i': 'D', 'j': 'A', 'k': 'E', 'cost': 48}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 32}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 54}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 41}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 54}, {'i': 'D', 'j': 'B', 'k': 'E', 'cost': 67}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 6}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 16}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 81}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 88}, {'i': 'D', 'j': 'C', 'k': 'E', 'cost': 19}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 45}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 97}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 74}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 19}, {'i': 'D', 'j': 'D', 'k': 'E', 'cost': 64}, {'i': 'D', 'j': 'E', 'k': 'A', 'cost': 81}, {'i': 'D', 'j': 'E', 'k': 'B', 'cost': 60}, {'i': 'D', 'j': 'E', 'k': 'C', 'cost': 85}, {'i': 'D', 'j': 'E', 'k': 'D', 'cost': 58}, {'i': 'D', 'j': 'E', 'k': 'E', 'cost': 7}, {'i': 'E', 'j': 'A', 'k': 'A', 'cost': 56}, {'i': 'E', 'j': 'A', 'k': 'B', 'cost': 80}, {'i': 'E', 'j': 'A', 'k': 'C', 'cost': 27}, {'i': 'E', 'j': 'A', 'k': 'D', 'cost': 52}, {'i': 'E', 'j': 'A', 'k': 'E', 'cost': 5}, {'i': 'E', 'j': 'B', 'k': 'A', 'cost': 27}, {'i': 'E', 'j': 'B', 'k': 'B', 'cost': 36}, {'i': 'E', 'j': 'B', 'k': 'C', 'cost': 31}, {'i': 'E', 'j': 'B', 'k': 'D', 'cost': 27}, {'i': 'E', 'j': 'B', 'k': 'E', 'cost': 30}, {'i': 'E', 'j': 'C', 'k': 'A', 'cost': 95}, {'i': 'E', 'j': 'C', 'k': 'B', 'cost': 52}, {'i': 'E', 'j': 'C', 'k': 'C', 'cost': 25}, {'i': 'E', 'j': 'C', 'k': 'D', 'cost': 38}, {'i': 'E', 'j': 'C', 'k': 'E', 'cost': 63}, {'i': 'E', 'j': 'D', 'k': 'A', 'cost': 74}, {'i': 'E', 'j': 'D', 'k': 'B', 'cost': 50}, {'i': 'E', 'j': 'D', 'k': 'C', 'cost': 60}, {'i': 'E', 'j': 'D', 'k': 'D', 'cost': 2}, {'i': 'E', 'j': 'D', 'k': 'E', 'cost': 28}, {'i': 'E', 'j': 'E', 'k': 'A', 'cost': 59}, {'i': 'E', 'j': 'E', 'k': 'B', 'cost': 70}, {'i': 'E', 'j': 'E', 'k': 'C', 'cost': 10}, {'i': 'E', 'j': 'E', 'k': 'D', 'cost': 0}, {'i': 'E', 'j': 'E', 'k': 'E', 'cost': 90}]}","[['A', 'E', 'E'], ['B', 'A', 'B'], ['C', 'B', 'C'], ['D', 'C', 'A'], ['E', 'D', 'D']]",39,json,names
AP3,AP3,"On a busy morning the task is to assign a single nurse and a single equipment kit to each scheduled home visit, ensuring every nurse gets exactly one assignment and every kit is sent out one time only. Because pairings vary in cost, the aim is to arrange the assignments so the total spending — calculated by adding up the cost for each visit’s chosen nurse-and-kit — ends up as small as possible. The concrete list of visits, nurses, kits and their costs is shown below.

{
  ""num_visits"": 3,
  ""visit_ids"": [
    0,
    1,
    2
  ]
}

# Meaning: costs form a 3D tensor. For each fixed visit_id=i, you are given a nurse_id×kit_id matrix whose entry at row nurse_id=j and column kit_id=k equals operational_cost(i,j,k). You must pick exactly one (j,k) for every i, with all nurse_id and all kit_id used exactly once.
# operational_cost_tensor (per-visit_id markdown matrices)

## visit_id=0
| nurse_id\kit_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 24 | 45 | 7 |
| 1 | 47 | 15 | 94 |
| 2 | 74 | 38 | 52 |

## visit_id=1
| nurse_id\kit_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 9 | 59 | 14 |
| 1 | 77 | 71 | 70 |
| 2 | 57 | 63 | 18 |

## visit_id=2
| nurse_id\kit_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 11 | 37 | 35 |
| 1 | 55 | 35 | 47 |
| 2 | 29 | 87 | 84 |

To keep things simple, the final reply should just be a small JSON object showing the chosen triples — one triple per visit, listing the visit, the nurse, and the kit.

{
  ""solution"": [
    [<visit_id>, <nurse_id>, <kit_id>],
    ...
  ]
}

Each inner list is a single assignment: the visit identifier, the nurse identifier assigned to that visit, and the equipment kit identifier sent along. Think of it like filling out a form where each row says ""Visit X gets Nurse Y and Kit Z."" This JSON is just the shape I expect — a sketch, not the actual solved assignments.

Please use the exact identifiers from the instance input — no renaming and no new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[24, 45, 7], [47, 15, 94], [74, 38, 52]], [[9, 59, 14], [77, 71, 70], [57, 63, 18]], [[11, 37, 35], [55, 35, 47], [29, 87, 84]]], 'objective': 44.0}","[[0, 1, 1], [1, 2, 2], [2, 0, 0]]",44.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [0, 1, 2], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 24}, {'i': 0, 'j': 0, 'k': 1, 'cost': 45}, {'i': 0, 'j': 0, 'k': 2, 'cost': 7}, {'i': 0, 'j': 1, 'k': 0, 'cost': 47}, {'i': 0, 'j': 1, 'k': 1, 'cost': 15}, {'i': 0, 'j': 1, 'k': 2, 'cost': 94}, {'i': 0, 'j': 2, 'k': 0, 'cost': 74}, {'i': 0, 'j': 2, 'k': 1, 'cost': 38}, {'i': 0, 'j': 2, 'k': 2, 'cost': 52}, {'i': 1, 'j': 0, 'k': 0, 'cost': 9}, {'i': 1, 'j': 0, 'k': 1, 'cost': 59}, {'i': 1, 'j': 0, 'k': 2, 'cost': 14}, {'i': 1, 'j': 1, 'k': 0, 'cost': 77}, {'i': 1, 'j': 1, 'k': 1, 'cost': 71}, {'i': 1, 'j': 1, 'k': 2, 'cost': 70}, {'i': 1, 'j': 2, 'k': 0, 'cost': 57}, {'i': 1, 'j': 2, 'k': 1, 'cost': 63}, {'i': 1, 'j': 2, 'k': 2, 'cost': 18}, {'i': 2, 'j': 0, 'k': 0, 'cost': 11}, {'i': 2, 'j': 0, 'k': 1, 'cost': 37}, {'i': 2, 'j': 0, 'k': 2, 'cost': 35}, {'i': 2, 'j': 1, 'k': 0, 'cost': 55}, {'i': 2, 'j': 1, 'k': 1, 'cost': 35}, {'i': 2, 'j': 1, 'k': 2, 'cost': 47}, {'i': 2, 'j': 2, 'k': 0, 'cost': 29}, {'i': 2, 'j': 2, 'k': 1, 'cost': 87}, {'i': 2, 'j': 2, 'k': 2, 'cost': 84}]}","[[0, 1, 1], [1, 2, 2], [2, 0, 0]]",40,json,0
AP3,AP3,"Many museums handle exhibit installs like a matching game: each exhibit space gets one artwork and one lighting configuration, and there are exactly as many artworks and lighting options as there are spaces. That means every artwork and every light ends up in exactly one spot — nothing duplicated, nothing omitted. Each possible assignment of space, art, and light has an installation cost, and the preferred arrangement is the one whose costs add up to the least amount. Look below for the concrete list of spaces, artworks, lights, and prices.

# num_spaces=4
# index_identifiers=A, B, C, D

# Meaning: costs form a 3D tensor. For each fixed space_id=i, you are given a artwork_id×lighting_setup_id matrix whose entry at row artwork_id=j and column lighting_setup_id=k equals installation_cost(i,j,k). You must pick exactly one (j,k) for every i, with all artwork_id and all lighting_setup_id used exactly once.
# installation_cost_tensor (per-space_id markdown matrices)

## space_id=A
| artwork_id\lighting_setup_id | A | B | C | D |
|---|---|---|---|---|
| A | 20 | 57 | 4 | 55 |
| B | 16 | 16 | 30 | 37 |
| C | 58 | 55 | 53 | 30 |
| D | 42 | 46 | 97 | 43 |

## space_id=B
| artwork_id\lighting_setup_id | A | B | C | D |
|---|---|---|---|---|
| A | 80 | 41 | 18 | 99 |
| B | 71 | 2 | 70 | 66 |
| C | 11 | 40 | 72 | 18 |
| D | 44 | 32 | 96 | 84 |

## space_id=C
| artwork_id\lighting_setup_id | A | B | C | D |
|---|---|---|---|---|
| A | 11 | 49 | 13 | 18 |
| B | 74 | 20 | 80 | 79 |
| C | 63 | 62 | 19 | 22 |
| D | 7 | 57 | 46 | 95 |

## space_id=D
| artwork_id\lighting_setup_id | A | B | C | D |
|---|---|---|---|---|
| A | 40 | 79 | 22 | 52 |
| B | 21 | 18 | 91 | 46 |
| C | 56 | 11 | 28 | 78 |
| D | 69 | 71 | 8 | 22 |

If you want to give me the final plan, a simple JSON sketch like this is perfect — just list the chosen triples (one per space) in the same shape shown below.

{
  ""solution"": [
    [<space_id>, <art_id>, <light_id>],
    ...
  ]
}

Each inner triple is one installation: which space gets which artwork and which lighting setup. Think of each row as a short form of “space, artwork, light.” This is just the shape I expect — don’t treat the placeholders as the actual choices.

Please be sure to use the exact identifiers from the instance input, with no renaming and no new labels. for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[20, 57, 4, 55], [16, 16, 30, 37], [58, 55, 53, 30], [42, 46, 97, 43]], [[80, 41, 18, 99], [71, 2, 70, 66], [11, 40, 72, 18], [44, 32, 96, 84]], [[11, 49, 13, 18], [74, 20, 80, 79], [63, 62, 19, 22], [7, 57, 46, 95]], [[40, 79, 22, 52], [21, 18, 91, 46], [56, 11, 28, 78], [69, 71, 8, 22]]], 'objective': 47.0}","[[0, 0, 2], [1, 2, 3], [2, 3, 0], [3, 1, 1]]",47.0,"{'problem_type': 'AP3', 'n': 4, 'ids': ['A', 'B', 'C', 'D'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 20}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 57}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 4}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 55}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 16}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 16}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 30}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 37}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 58}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 55}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 53}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 30}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 42}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 46}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 97}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 43}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 80}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 41}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 18}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 99}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 71}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 2}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 70}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 66}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 11}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 40}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 72}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 18}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 44}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 32}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 96}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 84}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 11}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 49}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 13}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 18}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 74}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 20}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 80}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 79}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 63}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 62}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 19}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 22}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 7}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 57}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 46}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 95}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 40}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 79}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 22}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 52}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 21}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 18}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 91}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 46}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 56}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 11}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 28}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 78}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 69}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 71}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 8}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 22}]}","[['A', 'A', 'C'], ['B', 'C', 'D'], ['C', 'D', 'A'], ['D', 'B', 'B']]",41,csv,names
AP3,AP3,"My friend runs a compact assembly line where each incoming order needs to be matched with one machine and one operator, and nothing can be reused: every machine and every operator can only be assigned to a single order. Each possible trio of order, machine and operator has a known processing cost, so they look for the set of assignments that, when adding up the costs of all chosen trios, gives the lowest total. The actual orders, machines, operators and the cost details are listed below.

There are 4 production orders identified as A, B, C, D.
Meaning: costs form a 3D tensor. For each fixed order_id=i, you are given a machine_id×operator_id matrix whose entry at row machine_id=j and column operator_id=k equals processing_cost(i,j,k). You must pick exactly one (j,k) for every i, with all machine_id and all operator_id used exactly once.
processing_cost_tensor (per-order_id markdown matrices):
## order_id=A
| machine_id\operator_id | A | B | C | D |
|---|---|---|---|---|
| A | 2 | 10 | 75 | 68 |
| B | 71 | 58 | 40 | 71 |
| C | 80 | 89 | 83 | 35 |
| D | 92 | 37 | 41 | 22 |

## order_id=B
| machine_id\operator_id | A | B | C | D |
|---|---|---|---|---|
| A | 9 | 33 | 47 | 74 |
| B | 80 | 93 | 29 | 51 |
| C | 94 | 61 | 41 | 14 |
| D | 94 | 68 | 28 | 10 |

## order_id=C
| machine_id\operator_id | A | B | C | D |
|---|---|---|---|---|
| A | 44 | 32 | 29 | 86 |
| B | 65 | 58 | 64 | 17 |
| C | 72 | 92 | 97 | 5 |
| D | 79 | 67 | 21 | 41 |

## order_id=D
| machine_id\operator_id | A | B | C | D |
|---|---|---|---|---|
| A | 72 | 90 | 33 | 86 |
| B | 97 | 59 | 39 | 49 |
| C | 94 | 32 | 90 | 89 |
| D | 81 | 71 | 4 | 25 |
They must select a one-to-one assignment of orders to machines and operators that minimizes the total processing cost.

Oh, and when you send back the chosen assignments, a simple JSON sketch like this is handy — nothing fancy, just a list of the triples we pick:

{
  ""solution"": [
    [<order_id>, <machine_id>, <operator_id>],
    ...
  ]
}

This just means ""solution"" contains a list of triples, and each triple is one order together with the machine and operator assigned to it. It's just a template to show the shape I expect — not the actual answer.

Please make sure to use the exact identifiers from the instance input — don't rename them or invent new 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”.""","{'cost_tensor': [[[2, 10, 75, 68], [71, 58, 40, 71], [80, 89, 83, 35], [92, 37, 41, 22]], [[9, 33, 47, 74], [80, 93, 29, 51], [94, 61, 41, 14], [94, 68, 28, 10]], [[44, 32, 29, 86], [65, 58, 64, 17], [72, 92, 97, 5], [79, 67, 21, 41]], [[72, 90, 33, 86], [97, 59, 39, 49], [94, 32, 90, 89], [81, 71, 4, 25]]], 'objective': 76.0}","[[0, 1, 1], [1, 0, 0], [2, 2, 3], [3, 3, 2]]",76.0,"{'problem_type': 'AP3', 'n': 4, 'ids': ['A', 'B', 'C', 'D'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 2}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 10}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 75}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 68}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 71}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 58}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 40}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 71}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 80}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 89}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 83}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 35}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 92}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 37}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 41}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 22}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 9}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 33}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 47}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 74}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 80}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 93}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 29}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 51}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 94}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 61}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 41}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 14}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 94}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 68}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 28}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 10}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 44}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 32}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 29}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 86}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 65}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 58}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 64}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 17}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 72}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 92}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 97}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 5}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 79}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 67}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 21}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 41}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 72}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 90}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 33}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 86}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 97}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 59}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 39}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 49}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 94}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 32}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 90}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 89}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 81}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 71}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 4}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 25}]}","[['A', 'B', 'B'], ['B', 'A', 'A'], ['C', 'C', 'D'], ['D', 'D', 'C']]",42,nl,names
AP3,AP3,"Someone is organizing a one-day outreach effort and has to pair volunteers and cars with sites. For each site there are different volunteer+vehicle choices, each with a specific travel plus coordination cost; the plan that wins is the one where those costs, summed over every site, come out smallest. It’s crucial that every site gets one volunteer and one vehicle, and no volunteer or vehicle goes to more than one site or gets left out. The specific details and cost table follow below.

There are 3 outreach sites (and 3 volunteers and 3 vehicles) labeled 0, 1, 2; the feasible volunteer+vehicle assignments and their travel+coordination costs are listed below.

*Meaning: costs form a 3D tensor. For each fixed site_id=i, you are given a volunteer_id×vehicle_id matrix whose entry at row volunteer_id=j and column vehicle_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all volunteer_id and all vehicle_id used exactly once.*

**assignment_cost_tensor (per-site_id markdown matrices)**

## site_id=0
| volunteer_id\vehicle_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 17 | 92 | 71 |
| 1 | 55 | 32 | 1 |
| 2 | 41 | 69 | 90 |

## site_id=1
| volunteer_id\vehicle_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 55 | 93 | 67 |
| 1 | 76 | 71 | 14 |
| 2 | 5 | 56 | 0 |

## site_id=2
| volunteer_id\vehicle_id | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 31 | 44 | 11 |
| 1 | 54 | 56 | 32 |
| 2 | 83 | 36 | 89 |

Choose exactly one listed assignment for each of the 3 sites so that the sum of the chosen costs is minimized; no volunteer or vehicle may be used more than once.

Also, when you send back the final plan, please stick to a simple JSON layout so it's easy to check automatically and by eye.

{
  ""solution"": [
    [<site_id>, <volunteer_id>, <car_id>],
    ...
  ]
}

Each inner array is one chosen triple: the site, the volunteer who'll go there, and the car they'll use. Think of it like filling out a short form where each row lists a site and the pair (person + vehicle) assigned to it. This JSON is just a sketch of the shape I need — not the actual assignments.

Please make sure to 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”.","{'cost_tensor': [[[17, 92, 71], [55, 32, 1], [41, 69, 90]], [[55, 93, 67], [76, 71, 14], [5, 56, 0]], [[31, 44, 11], [54, 56, 32], [83, 36, 89]]], 'objective': 48.0}","[[0, 1, 1], [1, 2, 0], [2, 0, 2]]",48.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [0, 1, 2], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 17}, {'i': 0, 'j': 0, 'k': 1, 'cost': 92}, {'i': 0, 'j': 0, 'k': 2, 'cost': 71}, {'i': 0, 'j': 1, 'k': 0, 'cost': 55}, {'i': 0, 'j': 1, 'k': 1, 'cost': 32}, {'i': 0, 'j': 1, 'k': 2, 'cost': 1}, {'i': 0, 'j': 2, 'k': 0, 'cost': 41}, {'i': 0, 'j': 2, 'k': 1, 'cost': 69}, {'i': 0, 'j': 2, 'k': 2, 'cost': 90}, {'i': 1, 'j': 0, 'k': 0, 'cost': 55}, {'i': 1, 'j': 0, 'k': 1, 'cost': 93}, {'i': 1, 'j': 0, 'k': 2, 'cost': 67}, {'i': 1, 'j': 1, 'k': 0, 'cost': 76}, {'i': 1, 'j': 1, 'k': 1, 'cost': 71}, {'i': 1, 'j': 1, 'k': 2, 'cost': 14}, {'i': 1, 'j': 2, 'k': 0, 'cost': 5}, {'i': 1, 'j': 2, 'k': 1, 'cost': 56}, {'i': 1, 'j': 2, 'k': 2, 'cost': 0}, {'i': 2, 'j': 0, 'k': 0, 'cost': 31}, {'i': 2, 'j': 0, 'k': 1, 'cost': 44}, {'i': 2, 'j': 0, 'k': 2, 'cost': 11}, {'i': 2, 'j': 1, 'k': 0, 'cost': 54}, {'i': 2, 'j': 1, 'k': 1, 'cost': 56}, {'i': 2, 'j': 1, 'k': 2, 'cost': 32}, {'i': 2, 'j': 2, 'k': 0, 'cost': 83}, {'i': 2, 'j': 2, 'k': 1, 'cost': 36}, {'i': 2, 'j': 2, 'k': 2, 'cost': 89}]}","[[0, 1, 1], [1, 2, 0], [2, 0, 2]]",43,markdown_table,0
AP3,AP3,"We’re juggling appointments at the shop: every customer must be matched with one stylist and one fitting room, and each stylist and each room can only serve one customer that day. Every possible trio comes with a cost, so the idea is to choose a trio for each customer so the sum of all those trio-costs is as low as it can be. The specific numbers and options follow below.

We have 3 customers, 3 stylists, and 3 fitting rooms labeled 1, 2, 3.

*Meaning: costs form a 3D tensor. For each fixed customer_id=i, you are given a stylist_id×fitting_room_id matrix whose entry at row stylist_id=j and column fitting_room_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all stylist_id and all fitting_room_id used exactly once.*

**assignment_cost_tensor (per-customer_id markdown matrices)**

## customer_id=1
| stylist_id\fitting_room_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 51 | 6 | 49 |
| 2 | 40 | 6 | 89 |
| 3 | 42 | 4 | 96 |

## customer_id=2
| stylist_id\fitting_room_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 82 | 57 | 54 |
| 2 | 76 | 2 | 26 |
| 3 | 78 | 7 | 70 |

## customer_id=3
| stylist_id\fitting_room_id | 1 | 2 | 3 |
|---|---|---|---|
| 1 | 7 | 25 | 76 |
| 2 | 43 | 87 | 42 |
| 3 | 48 | 92 | 38 |

Now let's pick one trio for each customer so the total cost is as low as it can be.

If you want to send back the matching, a simple JSON sketch like this is perfect — one triple per customer showing which stylist and which room they get:

{
  ""solution"": [
    [<customer_id>, <stylist_id>, <room_id>],
    ...
  ]
}

This just means: the ""solution"" field is a list of triples, each triple being the customer, the stylist and the fitting room chosen for that customer. Think of it as a little form: one row per customer, three columns (customer, stylist, room). It's just the expected shape — not the actual answer.

Please use the exact identifiers given in the instance input — do not rename them or invent new labels.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[51, 6, 49], [40, 6, 89], [42, 4, 96]], [[82, 57, 54], [76, 2, 26], [78, 7, 70]], [[7, 25, 76], [43, 87, 42], [48, 92, 38]]], 'objective': 37.0}","[[0, 2, 1], [1, 1, 2], [2, 0, 0]]",37.0,"{'problem_type': 'AP3', 'n': 3, 'ids': [1, 2, 3], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 51}, {'i': 1, 'j': 1, 'k': 2, 'cost': 6}, {'i': 1, 'j': 1, 'k': 3, 'cost': 49}, {'i': 1, 'j': 2, 'k': 1, 'cost': 40}, {'i': 1, 'j': 2, 'k': 2, 'cost': 6}, {'i': 1, 'j': 2, 'k': 3, 'cost': 89}, {'i': 1, 'j': 3, 'k': 1, 'cost': 42}, {'i': 1, 'j': 3, 'k': 2, 'cost': 4}, {'i': 1, 'j': 3, 'k': 3, 'cost': 96}, {'i': 2, 'j': 1, 'k': 1, 'cost': 82}, {'i': 2, 'j': 1, 'k': 2, 'cost': 57}, {'i': 2, 'j': 1, 'k': 3, 'cost': 54}, {'i': 2, 'j': 2, 'k': 1, 'cost': 76}, {'i': 2, 'j': 2, 'k': 2, 'cost': 2}, {'i': 2, 'j': 2, 'k': 3, 'cost': 26}, {'i': 2, 'j': 3, 'k': 1, 'cost': 78}, {'i': 2, 'j': 3, 'k': 2, 'cost': 7}, {'i': 2, 'j': 3, 'k': 3, 'cost': 70}, {'i': 3, 'j': 1, 'k': 1, 'cost': 7}, {'i': 3, 'j': 1, 'k': 2, 'cost': 25}, {'i': 3, 'j': 1, 'k': 3, 'cost': 76}, {'i': 3, 'j': 2, 'k': 1, 'cost': 43}, {'i': 3, 'j': 2, 'k': 2, 'cost': 87}, {'i': 3, 'j': 2, 'k': 3, 'cost': 42}, {'i': 3, 'j': 3, 'k': 1, 'cost': 48}, {'i': 3, 'j': 3, 'k': 2, 'cost': 92}, {'i': 3, 'j': 3, 'k': 3, 'cost': 38}]}","[[1, 3, 2], [2, 2, 3], [3, 1, 1]]",44,markdown_table,1
AP3,AP3,"Many people think staffing a festival is just picking people and gear, but here the director needs to match each screening with one technician and one projector model, making sure nobody or no model gets assigned twice. Every possible triple of screening, technician, and projector carries a cost, and the aim is to pick the set of triples whose prices, when added up across all screenings, give the lowest possible total. The exact match-up options and their costs are shown below.

{
  ""num_screenings"": 4,
  ""index_identifiers"": [
    1,
    2,
    3,
    4
  ]
}

# Meaning: costs form a 3D tensor. For each fixed screening_id=i, you are given a technician_id×projector_model_id matrix whose entry at row technician_id=j and column projector_model_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all technician_id and all projector_model_id used exactly once.
# assignment_cost_tensor (per-screening_id markdown matrices)

## screening_id=1
| technician_id\projector_model_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 59 | 54 | 89 | 46 |
| 2 | 88 | 70 | 35 | 99 |
| 3 | 22 | 80 | 26 | 54 |
| 4 | 5 | 14 | 48 | 60 |

## screening_id=2
| technician_id\projector_model_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 93 | 31 | 45 | 94 |
| 2 | 28 | 51 | 66 | 36 |
| 3 | 90 | 40 | 3 | 34 |
| 4 | 42 | 80 | 71 | 12 |

## screening_id=3
| technician_id\projector_model_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 33 | 34 | 84 | 31 |
| 2 | 50 | 21 | 38 | 34 |
| 3 | 68 | 65 | 76 | 77 |
| 4 | 21 | 55 | 58 | 1 |

## screening_id=4
| technician_id\projector_model_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 83 | 11 | 14 | 55 |
| 2 | 58 | 10 | 93 | 79 |
| 3 | 23 | 70 | 34 | 98 |
| 4 | 26 | 33 | 8 | 49 |

When you send the final matching back, just use this simple JSON shape so it's easy to parse:

{
  ""solution"": [
    [<screening_id>, <technician_id>, <projector_id>],
    ...
  ]
}

Think of the ""solution"" list as a set of triples: each inner list picks one screening, the technician who runs it, and the projector model used. It's just a lightweight way to say ""screening X goes with tech Y and projector Z"" for every screening. This is just the shape I expect — not the actual answer.

Please use the exact identifiers from the instance input — don't rename them or invent new 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"".","{'cost_tensor': [[[59, 54, 89, 46], [88, 70, 35, 99], [22, 80, 26, 54], [5, 14, 48, 60]], [[93, 31, 45, 94], [28, 51, 66, 36], [90, 40, 3, 34], [42, 80, 71, 12]], [[33, 34, 84, 31], [50, 21, 38, 34], [68, 65, 76, 77], [21, 55, 58, 1]], [[83, 11, 14, 55], [58, 10, 93, 79], [23, 70, 34, 98], [26, 33, 8, 49]]], 'objective': 49.0}","[[0, 3, 0], [1, 2, 2], [2, 0, 3], [3, 1, 1]]",49.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 59}, {'i': 1, 'j': 1, 'k': 2, 'cost': 54}, {'i': 1, 'j': 1, 'k': 3, 'cost': 89}, {'i': 1, 'j': 1, 'k': 4, 'cost': 46}, {'i': 1, 'j': 2, 'k': 1, 'cost': 88}, {'i': 1, 'j': 2, 'k': 2, 'cost': 70}, {'i': 1, 'j': 2, 'k': 3, 'cost': 35}, {'i': 1, 'j': 2, 'k': 4, 'cost': 99}, {'i': 1, 'j': 3, 'k': 1, 'cost': 22}, {'i': 1, 'j': 3, 'k': 2, 'cost': 80}, {'i': 1, 'j': 3, 'k': 3, 'cost': 26}, {'i': 1, 'j': 3, 'k': 4, 'cost': 54}, {'i': 1, 'j': 4, 'k': 1, 'cost': 5}, {'i': 1, 'j': 4, 'k': 2, 'cost': 14}, {'i': 1, 'j': 4, 'k': 3, 'cost': 48}, {'i': 1, 'j': 4, 'k': 4, 'cost': 60}, {'i': 2, 'j': 1, 'k': 1, 'cost': 93}, {'i': 2, 'j': 1, 'k': 2, 'cost': 31}, {'i': 2, 'j': 1, 'k': 3, 'cost': 45}, {'i': 2, 'j': 1, 'k': 4, 'cost': 94}, {'i': 2, 'j': 2, 'k': 1, 'cost': 28}, {'i': 2, 'j': 2, 'k': 2, 'cost': 51}, {'i': 2, 'j': 2, 'k': 3, 'cost': 66}, {'i': 2, 'j': 2, 'k': 4, 'cost': 36}, {'i': 2, 'j': 3, 'k': 1, 'cost': 90}, {'i': 2, 'j': 3, 'k': 2, 'cost': 40}, {'i': 2, 'j': 3, 'k': 3, 'cost': 3}, {'i': 2, 'j': 3, 'k': 4, 'cost': 34}, {'i': 2, 'j': 4, 'k': 1, 'cost': 42}, {'i': 2, 'j': 4, 'k': 2, 'cost': 80}, {'i': 2, 'j': 4, 'k': 3, 'cost': 71}, {'i': 2, 'j': 4, 'k': 4, 'cost': 12}, {'i': 3, 'j': 1, 'k': 1, 'cost': 33}, {'i': 3, 'j': 1, 'k': 2, 'cost': 34}, {'i': 3, 'j': 1, 'k': 3, 'cost': 84}, {'i': 3, 'j': 1, 'k': 4, 'cost': 31}, {'i': 3, 'j': 2, 'k': 1, 'cost': 50}, {'i': 3, 'j': 2, 'k': 2, 'cost': 21}, {'i': 3, 'j': 2, 'k': 3, 'cost': 38}, {'i': 3, 'j': 2, 'k': 4, 'cost': 34}, {'i': 3, 'j': 3, 'k': 1, 'cost': 68}, {'i': 3, 'j': 3, 'k': 2, 'cost': 65}, {'i': 3, 'j': 3, 'k': 3, 'cost': 76}, {'i': 3, 'j': 3, 'k': 4, 'cost': 77}, {'i': 3, 'j': 4, 'k': 1, 'cost': 21}, {'i': 3, 'j': 4, 'k': 2, 'cost': 55}, {'i': 3, 'j': 4, 'k': 3, 'cost': 58}, {'i': 3, 'j': 4, 'k': 4, 'cost': 1}, {'i': 4, 'j': 1, 'k': 1, 'cost': 83}, {'i': 4, 'j': 1, 'k': 2, 'cost': 11}, {'i': 4, 'j': 1, 'k': 3, 'cost': 14}, {'i': 4, 'j': 1, 'k': 4, 'cost': 55}, {'i': 4, 'j': 2, 'k': 1, 'cost': 58}, {'i': 4, 'j': 2, 'k': 2, 'cost': 10}, {'i': 4, 'j': 2, 'k': 3, 'cost': 93}, {'i': 4, 'j': 2, 'k': 4, 'cost': 79}, {'i': 4, 'j': 3, 'k': 1, 'cost': 23}, {'i': 4, 'j': 3, 'k': 2, 'cost': 70}, {'i': 4, 'j': 3, 'k': 3, 'cost': 34}, {'i': 4, 'j': 3, 'k': 4, 'cost': 98}, {'i': 4, 'j': 4, 'k': 1, 'cost': 26}, {'i': 4, 'j': 4, 'k': 2, 'cost': 33}, {'i': 4, 'j': 4, 'k': 3, 'cost': 8}, {'i': 4, 'j': 4, 'k': 4, 'cost': 49}]}","[[1, 4, 1], [2, 3, 3], [3, 1, 4], [4, 2, 2]]",45,json,1
AP3,AP3,"Back at the office, the problem was simple to explain over coffee: assign one developer and one test environment to each task, make sure each developer and each environment shows up exactly once across all tasks, and pick combinations that don’t overlap. Each possible grouping has a cost, and the preferred assignment is the one whose total cost (found by adding every task’s chosen grouping cost) is the lowest. Concrete details are shown below.

{
  ""num_tasks"": 4,
  ""index_identifiers"": [
    1,
    2,
    3,
    4
  ]
}

# Meaning: costs form a 3D tensor. For each fixed task_id=i, you are given a developer_id×test_environment_id matrix whose entry at row developer_id=j and column test_environment_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all developer_id and all test_environment_id used exactly once.
# assignment_cost_tensor (per-task_id markdown matrices)

## task_id=1
| developer_id\test_environment_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 73 | 18 | 59 | 75 |
| 2 | 95 | 26 | 70 | 26 |
| 3 | 85 | 59 | 40 | 97 |
| 4 | 39 | 12 | 88 | 40 |

## task_id=2
| developer_id\test_environment_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 34 | 82 | 27 | 26 |
| 2 | 76 | 97 | 90 | 12 |
| 3 | 79 | 42 | 4 | 56 |
| 4 | 76 | 4 | 95 | 5 |

## task_id=3
| developer_id\test_environment_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 81 | 41 | 70 | 22 |
| 2 | 40 | 19 | 65 | 40 |
| 3 | 53 | 59 | 79 | 3 |
| 4 | 55 | 71 | 90 | 67 |

## task_id=4
| developer_id\test_environment_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 70 | 66 | 58 | 40 |
| 2 | 2 | 73 | 37 | 68 |
| 3 | 42 | 58 | 73 | 90 |
| 4 | 91 | 33 | 70 | 47 |

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

{
  ""solution"": [
    [<task_id>, <dev_id>, <env_id>],
    ...
  ]
}

It's just a list called ""solution"" where each item is a triple: the first entry is the task, the second is the developer assigned to that task, and the third is the test environment assigned to that task. Super informal: think of each triple as ""task → developer + environment.""

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

- Please use the exact identifiers that appear in 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”.","{'cost_tensor': [[[73, 18, 59, 75], [95, 26, 70, 26], [85, 59, 40, 97], [39, 12, 88, 40]], [[34, 82, 27, 26], [76, 97, 90, 12], [79, 42, 4, 56], [76, 4, 95, 5]], [[81, 41, 70, 22], [40, 19, 65, 40], [53, 59, 79, 3], [55, 71, 90, 67]], [[70, 66, 58, 40], [2, 73, 37, 68], [42, 58, 73, 90], [91, 33, 70, 47]]], 'objective': 40.0}","[[0, 3, 1], [1, 2, 2], [2, 0, 3], [3, 1, 0]]",40.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 73}, {'i': 1, 'j': 1, 'k': 2, 'cost': 18}, {'i': 1, 'j': 1, 'k': 3, 'cost': 59}, {'i': 1, 'j': 1, 'k': 4, 'cost': 75}, {'i': 1, 'j': 2, 'k': 1, 'cost': 95}, {'i': 1, 'j': 2, 'k': 2, 'cost': 26}, {'i': 1, 'j': 2, 'k': 3, 'cost': 70}, {'i': 1, 'j': 2, 'k': 4, 'cost': 26}, {'i': 1, 'j': 3, 'k': 1, 'cost': 85}, {'i': 1, 'j': 3, 'k': 2, 'cost': 59}, {'i': 1, 'j': 3, 'k': 3, 'cost': 40}, {'i': 1, 'j': 3, 'k': 4, 'cost': 97}, {'i': 1, 'j': 4, 'k': 1, 'cost': 39}, {'i': 1, 'j': 4, 'k': 2, 'cost': 12}, {'i': 1, 'j': 4, 'k': 3, 'cost': 88}, {'i': 1, 'j': 4, 'k': 4, 'cost': 40}, {'i': 2, 'j': 1, 'k': 1, 'cost': 34}, {'i': 2, 'j': 1, 'k': 2, 'cost': 82}, {'i': 2, 'j': 1, 'k': 3, 'cost': 27}, {'i': 2, 'j': 1, 'k': 4, 'cost': 26}, {'i': 2, 'j': 2, 'k': 1, 'cost': 76}, {'i': 2, 'j': 2, 'k': 2, 'cost': 97}, {'i': 2, 'j': 2, 'k': 3, 'cost': 90}, {'i': 2, 'j': 2, 'k': 4, 'cost': 12}, {'i': 2, 'j': 3, 'k': 1, 'cost': 79}, {'i': 2, 'j': 3, 'k': 2, 'cost': 42}, {'i': 2, 'j': 3, 'k': 3, 'cost': 4}, {'i': 2, 'j': 3, 'k': 4, 'cost': 56}, {'i': 2, 'j': 4, 'k': 1, 'cost': 76}, {'i': 2, 'j': 4, 'k': 2, 'cost': 4}, {'i': 2, 'j': 4, 'k': 3, 'cost': 95}, {'i': 2, 'j': 4, 'k': 4, 'cost': 5}, {'i': 3, 'j': 1, 'k': 1, 'cost': 81}, {'i': 3, 'j': 1, 'k': 2, 'cost': 41}, {'i': 3, 'j': 1, 'k': 3, 'cost': 70}, {'i': 3, 'j': 1, 'k': 4, 'cost': 22}, {'i': 3, 'j': 2, 'k': 1, 'cost': 40}, {'i': 3, 'j': 2, 'k': 2, 'cost': 19}, {'i': 3, 'j': 2, 'k': 3, 'cost': 65}, {'i': 3, 'j': 2, 'k': 4, 'cost': 40}, {'i': 3, 'j': 3, 'k': 1, 'cost': 53}, {'i': 3, 'j': 3, 'k': 2, 'cost': 59}, {'i': 3, 'j': 3, 'k': 3, 'cost': 79}, {'i': 3, 'j': 3, 'k': 4, 'cost': 3}, {'i': 3, 'j': 4, 'k': 1, 'cost': 55}, {'i': 3, 'j': 4, 'k': 2, 'cost': 71}, {'i': 3, 'j': 4, 'k': 3, 'cost': 90}, {'i': 3, 'j': 4, 'k': 4, 'cost': 67}, {'i': 4, 'j': 1, 'k': 1, 'cost': 70}, {'i': 4, 'j': 1, 'k': 2, 'cost': 66}, {'i': 4, 'j': 1, 'k': 3, 'cost': 58}, {'i': 4, 'j': 1, 'k': 4, 'cost': 40}, {'i': 4, 'j': 2, 'k': 1, 'cost': 2}, {'i': 4, 'j': 2, 'k': 2, 'cost': 73}, {'i': 4, 'j': 2, 'k': 3, 'cost': 37}, {'i': 4, 'j': 2, 'k': 4, 'cost': 68}, {'i': 4, 'j': 3, 'k': 1, 'cost': 42}, {'i': 4, 'j': 3, 'k': 2, 'cost': 58}, {'i': 4, 'j': 3, 'k': 3, 'cost': 73}, {'i': 4, 'j': 3, 'k': 4, 'cost': 90}, {'i': 4, 'j': 4, 'k': 1, 'cost': 91}, {'i': 4, 'j': 4, 'k': 2, 'cost': 33}, {'i': 4, 'j': 4, 'k': 3, 'cost': 70}, {'i': 4, 'j': 4, 'k': 4, 'cost': 47}]}","[[1, 4, 2], [2, 3, 3], [3, 1, 4], [4, 2, 1]]",46,json,1
AP3,AP3,"I worked with the housing crew to picture a simple scene: every incoming student needs to be handed one dorm room and one choice of a roommate setup, and the rule is strict — each room can go to only one student and each roommate option can only be used once. The trick is to pick those room-plus-roommate pairings so the whole semester’s housing bill is as small as possible — that total comes from adding the cost attached to each student’s chosen room-and-roommate combo. The better plan is the one with the lowest combined cost, and no student, room, or pairing can be skipped or doubled up. Concrete details for the specific students, rooms, roommate options, and costs are shown below.

I list the 5 students, rooms, and roommate options by their identifiers 0, 1, 2, 3, 4.
Meaning: costs form a 3D tensor. For each fixed student_id=i, you are given a room_id×roommate_option_id matrix whose entry at row room_id=j and column roommate_option_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all room_id and all roommate_option_id used exactly once.
assignment_cost_tensor (per-student_id markdown matrices):
## student_id=0
| room_id\roommate_option_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 85 | 13 | 51 | 24 | 68 |
| 1 | 94 | 74 | 19 | 95 | 63 |
| 2 | 34 | 8 | 73 | 64 | 41 |
| 3 | 10 | 8 | 78 | 84 | 81 |
| 4 | 35 | 56 | 68 | 91 | 88 |

## student_id=1
| room_id\roommate_option_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 40 | 83 | 38 | 59 | 3 |
| 1 | 46 | 2 | 0 | 96 | 4 |
| 2 | 41 | 71 | 45 | 68 | 74 |
| 3 | 0 | 34 | 19 | 39 | 35 |
| 4 | 78 | 53 | 94 | 71 | 21 |

## student_id=2
| room_id\roommate_option_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 24 | 15 | 44 | 50 | 33 |
| 1 | 28 | 32 | 83 | 75 | 31 |
| 2 | 13 | 84 | 25 | 2 | 75 |
| 3 | 57 | 45 | 9 | 15 | 36 |
| 4 | 11 | 29 | 35 | 87 | 6 |

## student_id=3
| room_id\roommate_option_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 40 | 11 | 83 | 92 | 99 |
| 1 | 29 | 90 | 55 | 81 | 99 |
| 2 | 16 | 2 | 60 | 87 | 42 |
| 3 | 65 | 20 | 13 | 35 | 79 |
| 4 | 42 | 62 | 20 | 10 | 70 |

## student_id=4
| room_id\roommate_option_id | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| 0 | 41 | 37 | 17 | 50 | 57 |
| 1 | 29 | 37 | 69 | 87 | 76 |
| 2 | 10 | 46 | 44 | 94 | 55 |
| 3 | 79 | 84 | 6 | 96 | 22 |
| 4 | 57 | 74 | 78 | 31 | 19 |
I will pick one triple per student so the sum of these costs is minimized.

I'll sketch the shape of the reply I need in case it helps — just a simple JSON list showing which student gets which room and which roommate option.

{
  ""solution"": [
    [<student_id>, <room_id>, <roommate_option_id>]
  ]
}

This is just a lightweight example: ""solution"" is an array of triples, and each triple is one student's final pick — first the student, then the room they get, then the roommate option chosen. Think of it like filling out a form for each incoming student: one line per student with those three labels.

The JSON above is only a sketch of the expected shape, not the actual answer. Also, please use the identifiers exactly as they appear in the instance input — don't rename them or invent new 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”.""","{'cost_tensor': [[[85, 13, 51, 24, 68], [94, 74, 19, 95, 63], [34, 8, 73, 64, 41], [10, 8, 78, 84, 81], [35, 56, 68, 91, 88]], [[40, 83, 38, 59, 3], [46, 2, 0, 96, 4], [41, 71, 45, 68, 74], [0, 34, 19, 39, 35], [78, 53, 94, 71, 21]], [[24, 15, 44, 50, 33], [28, 32, 83, 75, 31], [13, 84, 25, 2, 75], [57, 45, 9, 15, 36], [11, 29, 35, 87, 6]], [[40, 11, 83, 92, 99], [29, 90, 55, 81, 99], [16, 2, 60, 87, 42], [65, 20, 13, 35, 79], [42, 62, 20, 10, 70]], [[41, 37, 17, 50, 57], [29, 37, 69, 87, 76], [10, 46, 44, 94, 55], [79, 84, 6, 96, 22], [57, 74, 78, 31, 19]]], 'objective': 42.0}","[[0, 3, 0], [1, 1, 2], [2, 2, 3], [3, 0, 1], [4, 4, 4]]",42.0,"{'problem_type': 'AP3', 'n': 5, 'ids': [0, 1, 2, 3, 4], 'costs': [{'i': 0, 'j': 0, 'k': 0, 'cost': 85}, {'i': 0, 'j': 0, 'k': 1, 'cost': 13}, {'i': 0, 'j': 0, 'k': 2, 'cost': 51}, {'i': 0, 'j': 0, 'k': 3, 'cost': 24}, {'i': 0, 'j': 0, 'k': 4, 'cost': 68}, {'i': 0, 'j': 1, 'k': 0, 'cost': 94}, {'i': 0, 'j': 1, 'k': 1, 'cost': 74}, {'i': 0, 'j': 1, 'k': 2, 'cost': 19}, {'i': 0, 'j': 1, 'k': 3, 'cost': 95}, {'i': 0, 'j': 1, 'k': 4, 'cost': 63}, {'i': 0, 'j': 2, 'k': 0, 'cost': 34}, {'i': 0, 'j': 2, 'k': 1, 'cost': 8}, {'i': 0, 'j': 2, 'k': 2, 'cost': 73}, {'i': 0, 'j': 2, 'k': 3, 'cost': 64}, {'i': 0, 'j': 2, 'k': 4, 'cost': 41}, {'i': 0, 'j': 3, 'k': 0, 'cost': 10}, {'i': 0, 'j': 3, 'k': 1, 'cost': 8}, {'i': 0, 'j': 3, 'k': 2, 'cost': 78}, {'i': 0, 'j': 3, 'k': 3, 'cost': 84}, {'i': 0, 'j': 3, 'k': 4, 'cost': 81}, {'i': 0, 'j': 4, 'k': 0, 'cost': 35}, {'i': 0, 'j': 4, 'k': 1, 'cost': 56}, {'i': 0, 'j': 4, 'k': 2, 'cost': 68}, {'i': 0, 'j': 4, 'k': 3, 'cost': 91}, {'i': 0, 'j': 4, 'k': 4, 'cost': 88}, {'i': 1, 'j': 0, 'k': 0, 'cost': 40}, {'i': 1, 'j': 0, 'k': 1, 'cost': 83}, {'i': 1, 'j': 0, 'k': 2, 'cost': 38}, {'i': 1, 'j': 0, 'k': 3, 'cost': 59}, {'i': 1, 'j': 0, 'k': 4, 'cost': 3}, {'i': 1, 'j': 1, 'k': 0, 'cost': 46}, {'i': 1, 'j': 1, 'k': 1, 'cost': 2}, {'i': 1, 'j': 1, 'k': 2, 'cost': 0}, {'i': 1, 'j': 1, 'k': 3, 'cost': 96}, {'i': 1, 'j': 1, 'k': 4, 'cost': 4}, {'i': 1, 'j': 2, 'k': 0, 'cost': 41}, {'i': 1, 'j': 2, 'k': 1, 'cost': 71}, {'i': 1, 'j': 2, 'k': 2, 'cost': 45}, {'i': 1, 'j': 2, 'k': 3, 'cost': 68}, {'i': 1, 'j': 2, 'k': 4, 'cost': 74}, {'i': 1, 'j': 3, 'k': 0, 'cost': 0}, {'i': 1, 'j': 3, 'k': 1, 'cost': 34}, {'i': 1, 'j': 3, 'k': 2, 'cost': 19}, {'i': 1, 'j': 3, 'k': 3, 'cost': 39}, {'i': 1, 'j': 3, 'k': 4, 'cost': 35}, {'i': 1, 'j': 4, 'k': 0, 'cost': 78}, {'i': 1, 'j': 4, 'k': 1, 'cost': 53}, {'i': 1, 'j': 4, 'k': 2, 'cost': 94}, {'i': 1, 'j': 4, 'k': 3, 'cost': 71}, {'i': 1, 'j': 4, 'k': 4, 'cost': 21}, {'i': 2, 'j': 0, 'k': 0, 'cost': 24}, {'i': 2, 'j': 0, 'k': 1, 'cost': 15}, {'i': 2, 'j': 0, 'k': 2, 'cost': 44}, {'i': 2, 'j': 0, 'k': 3, 'cost': 50}, {'i': 2, 'j': 0, 'k': 4, 'cost': 33}, {'i': 2, 'j': 1, 'k': 0, 'cost': 28}, {'i': 2, 'j': 1, 'k': 1, 'cost': 32}, {'i': 2, 'j': 1, 'k': 2, 'cost': 83}, {'i': 2, 'j': 1, 'k': 3, 'cost': 75}, {'i': 2, 'j': 1, 'k': 4, 'cost': 31}, {'i': 2, 'j': 2, 'k': 0, 'cost': 13}, {'i': 2, 'j': 2, 'k': 1, 'cost': 84}, {'i': 2, 'j': 2, 'k': 2, 'cost': 25}, {'i': 2, 'j': 2, 'k': 3, 'cost': 2}, {'i': 2, 'j': 2, 'k': 4, 'cost': 75}, {'i': 2, 'j': 3, 'k': 0, 'cost': 57}, {'i': 2, 'j': 3, 'k': 1, 'cost': 45}, {'i': 2, 'j': 3, 'k': 2, 'cost': 9}, {'i': 2, 'j': 3, 'k': 3, 'cost': 15}, {'i': 2, 'j': 3, 'k': 4, 'cost': 36}, {'i': 2, 'j': 4, 'k': 0, 'cost': 11}, {'i': 2, 'j': 4, 'k': 1, 'cost': 29}, {'i': 2, 'j': 4, 'k': 2, 'cost': 35}, {'i': 2, 'j': 4, 'k': 3, 'cost': 87}, {'i': 2, 'j': 4, 'k': 4, 'cost': 6}, {'i': 3, 'j': 0, 'k': 0, 'cost': 40}, {'i': 3, 'j': 0, 'k': 1, 'cost': 11}, {'i': 3, 'j': 0, 'k': 2, 'cost': 83}, {'i': 3, 'j': 0, 'k': 3, 'cost': 92}, {'i': 3, 'j': 0, 'k': 4, 'cost': 99}, {'i': 3, 'j': 1, 'k': 0, 'cost': 29}, {'i': 3, 'j': 1, 'k': 1, 'cost': 90}, {'i': 3, 'j': 1, 'k': 2, 'cost': 55}, {'i': 3, 'j': 1, 'k': 3, 'cost': 81}, {'i': 3, 'j': 1, 'k': 4, 'cost': 99}, {'i': 3, 'j': 2, 'k': 0, 'cost': 16}, {'i': 3, 'j': 2, 'k': 1, 'cost': 2}, {'i': 3, 'j': 2, 'k': 2, 'cost': 60}, {'i': 3, 'j': 2, 'k': 3, 'cost': 87}, {'i': 3, 'j': 2, 'k': 4, 'cost': 42}, {'i': 3, 'j': 3, 'k': 0, 'cost': 65}, {'i': 3, 'j': 3, 'k': 1, 'cost': 20}, {'i': 3, 'j': 3, 'k': 2, 'cost': 13}, {'i': 3, 'j': 3, 'k': 3, 'cost': 35}, {'i': 3, 'j': 3, 'k': 4, 'cost': 79}, {'i': 3, 'j': 4, 'k': 0, 'cost': 42}, {'i': 3, 'j': 4, 'k': 1, 'cost': 62}, {'i': 3, 'j': 4, 'k': 2, 'cost': 20}, {'i': 3, 'j': 4, 'k': 3, 'cost': 10}, {'i': 3, 'j': 4, 'k': 4, 'cost': 70}, {'i': 4, 'j': 0, 'k': 0, 'cost': 41}, {'i': 4, 'j': 0, 'k': 1, 'cost': 37}, {'i': 4, 'j': 0, 'k': 2, 'cost': 17}, {'i': 4, 'j': 0, 'k': 3, 'cost': 50}, {'i': 4, 'j': 0, 'k': 4, 'cost': 57}, {'i': 4, 'j': 1, 'k': 0, 'cost': 29}, {'i': 4, 'j': 1, 'k': 1, 'cost': 37}, {'i': 4, 'j': 1, 'k': 2, 'cost': 69}, {'i': 4, 'j': 1, 'k': 3, 'cost': 87}, {'i': 4, 'j': 1, 'k': 4, 'cost': 76}, {'i': 4, 'j': 2, 'k': 0, 'cost': 10}, {'i': 4, 'j': 2, 'k': 1, 'cost': 46}, {'i': 4, 'j': 2, 'k': 2, 'cost': 44}, {'i': 4, 'j': 2, 'k': 3, 'cost': 94}, {'i': 4, 'j': 2, 'k': 4, 'cost': 55}, {'i': 4, 'j': 3, 'k': 0, 'cost': 79}, {'i': 4, 'j': 3, 'k': 1, 'cost': 84}, {'i': 4, 'j': 3, 'k': 2, 'cost': 6}, {'i': 4, 'j': 3, 'k': 3, 'cost': 96}, {'i': 4, 'j': 3, 'k': 4, 'cost': 22}, {'i': 4, 'j': 4, 'k': 0, 'cost': 57}, {'i': 4, 'j': 4, 'k': 1, 'cost': 74}, {'i': 4, 'j': 4, 'k': 2, 'cost': 78}, {'i': 4, 'j': 4, 'k': 3, 'cost': 31}, {'i': 4, 'j': 4, 'k': 4, 'cost': 19}]}","[[0, 3, 0], [1, 1, 2], [2, 2, 3], [3, 0, 1], [4, 4, 4]]",47,nl,0
AP3,AP3,"There's a busy week at the garden center where each landscaping project needs a single plant source and a single delivery slot. No supplier or delivery slot can be stretched across multiple projects, and every project must get exactly one supplier and one delivery date. Each possible pairing of project, supplier, and date carries a cost, so better choices are the ones that make the overall bill — calculated by adding up the cost for each project's chosen pairing — smaller. The specific jobs, suppliers, dates, and their costs follow below.

{
  ""job_count"": 4,
  ""index_identifiers"": [
    1,
    2,
    3,
    4
  ]
}

# Meaning: costs form a 3D tensor. For each fixed job_id=i, you are given a supplier_id×delivery_date_id matrix whose entry at row supplier_id=j and column delivery_date_id=k equals procurement_and_delivery_cost(i,j,k). You must pick exactly one (j,k) for every i, with all supplier_id and all delivery_date_id used exactly once.
# procurement_and_delivery_cost_tensor (per-job_id markdown matrices)

## job_id=1
| supplier_id\delivery_date_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 87 | 78 | 10 | 18 |
| 2 | 27 | 21 | 34 | 32 |
| 3 | 0 | 65 | 44 | 86 |
| 4 | 78 | 60 | 12 | 78 |

## job_id=2
| supplier_id\delivery_date_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 15 | 39 | 85 | 55 |
| 2 | 90 | 92 | 11 | 22 |
| 3 | 37 | 39 | 71 | 56 |
| 4 | 54 | 73 | 78 | 29 |

## job_id=3
| supplier_id\delivery_date_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 49 | 14 | 98 | 82 |
| 2 | 30 | 60 | 17 | 66 |
| 3 | 85 | 61 | 46 | 2 |
| 4 | 71 | 10 | 58 | 6 |

## job_id=4
| supplier_id\delivery_date_id | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
| 1 | 26 | 74 | 88 | 86 |
| 2 | 55 | 12 | 2 | 98 |
| 3 | 15 | 8 | 51 | 13 |
| 4 | 22 | 47 | 85 | 88 |

Also, when you send the final matching, a relaxed little JSON snippet like this is perfect — a single list of triples, each triple saying which project gets which supplier and which delivery slot:

{
  ""solution"": [
    [<project_id>, <supplier_id>, <date_id>],
    ...
  ]
}

Each inner array is one assignment: the first entry is the project, the second is the chosen plant supplier, and the third is the delivery date/slot. Think of it like filling out a tiny form for each job. This JSON is just the shape I expect, not the actual solution — replace the placeholders with the actual identifiers from the instance when you submit your answer.

Please use the exact identifiers from the instance input — no renaming and no new labels. 
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'cost_tensor': [[[87, 78, 10, 18], [27, 21, 34, 32], [0, 65, 44, 86], [78, 60, 12, 78]], [[15, 39, 85, 55], [90, 92, 11, 22], [37, 39, 71, 56], [54, 73, 78, 29]], [[49, 14, 98, 82], [30, 60, 17, 66], [85, 61, 46, 2], [71, 10, 58, 6]], [[26, 74, 88, 86], [55, 12, 2, 98], [15, 8, 51, 13], [22, 47, 85, 88]]], 'objective': 41.0}","[[0, 3, 2], [1, 0, 0], [2, 2, 3], [3, 1, 1]]",41.0,"{'problem_type': 'AP3', 'n': 4, 'ids': [1, 2, 3, 4], 'costs': [{'i': 1, 'j': 1, 'k': 1, 'cost': 87}, {'i': 1, 'j': 1, 'k': 2, 'cost': 78}, {'i': 1, 'j': 1, 'k': 3, 'cost': 10}, {'i': 1, 'j': 1, 'k': 4, 'cost': 18}, {'i': 1, 'j': 2, 'k': 1, 'cost': 27}, {'i': 1, 'j': 2, 'k': 2, 'cost': 21}, {'i': 1, 'j': 2, 'k': 3, 'cost': 34}, {'i': 1, 'j': 2, 'k': 4, 'cost': 32}, {'i': 1, 'j': 3, 'k': 1, 'cost': 0}, {'i': 1, 'j': 3, 'k': 2, 'cost': 65}, {'i': 1, 'j': 3, 'k': 3, 'cost': 44}, {'i': 1, 'j': 3, 'k': 4, 'cost': 86}, {'i': 1, 'j': 4, 'k': 1, 'cost': 78}, {'i': 1, 'j': 4, 'k': 2, 'cost': 60}, {'i': 1, 'j': 4, 'k': 3, 'cost': 12}, {'i': 1, 'j': 4, 'k': 4, 'cost': 78}, {'i': 2, 'j': 1, 'k': 1, 'cost': 15}, {'i': 2, 'j': 1, 'k': 2, 'cost': 39}, {'i': 2, 'j': 1, 'k': 3, 'cost': 85}, {'i': 2, 'j': 1, 'k': 4, 'cost': 55}, {'i': 2, 'j': 2, 'k': 1, 'cost': 90}, {'i': 2, 'j': 2, 'k': 2, 'cost': 92}, {'i': 2, 'j': 2, 'k': 3, 'cost': 11}, {'i': 2, 'j': 2, 'k': 4, 'cost': 22}, {'i': 2, 'j': 3, 'k': 1, 'cost': 37}, {'i': 2, 'j': 3, 'k': 2, 'cost': 39}, {'i': 2, 'j': 3, 'k': 3, 'cost': 71}, {'i': 2, 'j': 3, 'k': 4, 'cost': 56}, {'i': 2, 'j': 4, 'k': 1, 'cost': 54}, {'i': 2, 'j': 4, 'k': 2, 'cost': 73}, {'i': 2, 'j': 4, 'k': 3, 'cost': 78}, {'i': 2, 'j': 4, 'k': 4, 'cost': 29}, {'i': 3, 'j': 1, 'k': 1, 'cost': 49}, {'i': 3, 'j': 1, 'k': 2, 'cost': 14}, {'i': 3, 'j': 1, 'k': 3, 'cost': 98}, {'i': 3, 'j': 1, 'k': 4, 'cost': 82}, {'i': 3, 'j': 2, 'k': 1, 'cost': 30}, {'i': 3, 'j': 2, 'k': 2, 'cost': 60}, {'i': 3, 'j': 2, 'k': 3, 'cost': 17}, {'i': 3, 'j': 2, 'k': 4, 'cost': 66}, {'i': 3, 'j': 3, 'k': 1, 'cost': 85}, {'i': 3, 'j': 3, 'k': 2, 'cost': 61}, {'i': 3, 'j': 3, 'k': 3, 'cost': 46}, {'i': 3, 'j': 3, 'k': 4, 'cost': 2}, {'i': 3, 'j': 4, 'k': 1, 'cost': 71}, {'i': 3, 'j': 4, 'k': 2, 'cost': 10}, {'i': 3, 'j': 4, 'k': 3, 'cost': 58}, {'i': 3, 'j': 4, 'k': 4, 'cost': 6}, {'i': 4, 'j': 1, 'k': 1, 'cost': 26}, {'i': 4, 'j': 1, 'k': 2, 'cost': 74}, {'i': 4, 'j': 1, 'k': 3, 'cost': 88}, {'i': 4, 'j': 1, 'k': 4, 'cost': 86}, {'i': 4, 'j': 2, 'k': 1, 'cost': 55}, {'i': 4, 'j': 2, 'k': 2, 'cost': 12}, {'i': 4, 'j': 2, 'k': 3, 'cost': 2}, {'i': 4, 'j': 2, 'k': 4, 'cost': 98}, {'i': 4, 'j': 3, 'k': 1, 'cost': 15}, {'i': 4, 'j': 3, 'k': 2, 'cost': 8}, {'i': 4, 'j': 3, 'k': 3, 'cost': 51}, {'i': 4, 'j': 3, 'k': 4, 'cost': 13}, {'i': 4, 'j': 4, 'k': 1, 'cost': 22}, {'i': 4, 'j': 4, 'k': 2, 'cost': 47}, {'i': 4, 'j': 4, 'k': 3, 'cost': 85}, {'i': 4, 'j': 4, 'k': 4, 'cost': 88}]}","[[1, 4, 3], [2, 1, 1], [3, 3, 4], [4, 2, 2]]",48,json,1
AP3,AP3,"We were tasked with sorting the dressing-room chaos: assign one outfit and one helper to each model, with each outfit and helper going to only one model. The goal is simple in plain terms — pick the pairings so that when you add every model’s outfit cost and assistant cost together, the sum is as small as it can be. Everything must be used exactly once, so no duplicates and no model left without something. The concrete lineup and cost numbers are listed below.

{
  ""num_models"": 4,
  ""model_outfit_assistant_ids"": [
    ""A"",
    ""B"",
    ""C"",
    ""D""
  ]
}

# Meaning: costs form a 3D tensor. For each fixed model_id=i, you are given a outfit_id×assistant_id matrix whose entry at row outfit_id=j and column assistant_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all outfit_id and all assistant_id used exactly once.
# assignment_cost_tensor (per-model_id markdown matrices)

## model_id=A
| outfit_id\assistant_id | A | B | C | D |
|---|---|---|---|---|
| A | 62 | 43 | 48 | 87 |
| B | 96 | 66 | 18 | 54 |
| C | 54 | 95 | 19 | 58 |
| D | 88 | 64 | 60 | 68 |

## model_id=B
| outfit_id\assistant_id | A | B | C | D |
|---|---|---|---|---|
| A | 73 | 2 | 29 | 37 |
| B | 17 | 40 | 17 | 94 |
| C | 3 | 21 | 48 | 82 |
| D | 51 | 38 | 86 | 65 |

## model_id=C
| outfit_id\assistant_id | A | B | C | D |
|---|---|---|---|---|
| A | 61 | 67 | 98 | 60 |
| B | 42 | 30 | 68 | 8 |
| C | 34 | 93 | 59 | 50 |
| D | 73 | 71 | 24 | 18 |

## model_id=D
| outfit_id\assistant_id | A | B | C | D |
|---|---|---|---|---|
| A | 60 | 62 | 36 | 83 |
| B | 55 | 53 | 12 | 21 |
| C | 76 | 67 | 88 | 91 |
| D | 89 | 92 | 36 | 75 |

Also, when you give the final answer, just stick to a simple JSON layout so it's easy to check automatically. Something like this will do:

{
  ""solution"": [
    [<model_id>, <outfit_id>, <helper_id>],
    ...
  ]
}

Here the ""solution"" list is just a rundown of every assignment. Each inner triple [<model_id>, <outfit_id>, <helper_id>] means: that model gets that outfit and that helper. It's just a sketch of the shape we expect — you'll replace those placeholders with the actual identifiers from the instance when you submit the real solution.

Please make sure you use the exact identifiers from the instance input, with no renaming and no invented labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'cost_tensor': [[[62, 43, 48, 87], [96, 66, 18, 54], [54, 95, 19, 58], [88, 64, 60, 68]], [[73, 2, 29, 37], [17, 40, 17, 94], [3, 21, 48, 82], [51, 38, 86, 65]], [[61, 67, 98, 60], [42, 30, 68, 8], [34, 93, 59, 50], [73, 71, 24, 18]], [[60, 62, 36, 83], [55, 53, 12, 21], [76, 67, 88, 91], [89, 92, 36, 75]]], 'objective': 76.0}","[[0, 0, 1], [1, 2, 0], [2, 3, 3], [3, 1, 2]]",76.0,"{'problem_type': 'AP3', 'n': 4, 'ids': ['A', 'B', 'C', 'D'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 62}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 43}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 48}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 87}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 96}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 66}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 18}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 54}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 54}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 95}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 19}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 58}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 88}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 64}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 60}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 68}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 73}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 2}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 29}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 37}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 17}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 40}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 17}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 94}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 3}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 21}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 48}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 82}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 51}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 38}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 86}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 65}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 61}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 67}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 98}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 60}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 42}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 30}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 68}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 8}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 34}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 93}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 59}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 50}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 73}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 71}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 24}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 18}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 60}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 62}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 36}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 83}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 55}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 53}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 12}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 21}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 76}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 67}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 88}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 91}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 89}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 92}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 36}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 75}]}","[['A', 'A', 'B'], ['B', 'C', 'A'], ['C', 'D', 'D'], ['D', 'B', 'C']]",49,json,names
AP3,AP3,"I run the community library’s events, and for each reading session I need to pick exactly one storyteller and one seating layout. Every storyteller should lead just one session and every seating plan should be used for exactly one session, so nothing gets repeated or left out. Each possible pairing of session, storyteller, and seating has a price, and the plan that’s best is the one where, when the price for every session is added up, that total is as small as possible. The exact lists and costs are shown below.

# num_reading_sessions=4
# index_identifiers=A, B, C, D

# Meaning: costs form a 3D tensor. For each fixed session_id=i, you are given a storyteller_id×seating_layout_id matrix whose entry at row storyteller_id=j and column seating_layout_id=k equals assignment_cost(i,j,k). You must pick exactly one (j,k) for every i, with all storyteller_id and all seating_layout_id used exactly once.
# assignment_cost_tensor (per-session_id markdown matrices)

## session_id=A
| storyteller_id\seating_layout_id | A | B | C | D |
|---|---|---|---|---|
| A | 51 | 17 | 30 | 53 |
| B | 94 | 17 | 70 | 22 |
| C | 49 | 12 | 8 | 38 |
| D | 27 | 36 | 98 | 53 |

## session_id=B
| storyteller_id\seating_layout_id | A | B | C | D |
|---|---|---|---|---|
| A | 76 | 64 | 76 | 78 |
| B | 82 | 15 | 62 | 31 |
| C | 34 | 91 | 51 | 40 |
| D | 60 | 78 | 93 | 86 |

## session_id=C
| storyteller_id\seating_layout_id | A | B | C | D |
|---|---|---|---|---|
| A | 86 | 67 | 75 | 58 |
| B | 38 | 35 | 20 | 82 |
| C | 41 | 46 | 97 | 12 |
| D | 21 | 95 | 73 | 40 |

## session_id=D
| storyteller_id\seating_layout_id | A | B | C | D |
|---|---|---|---|---|
| A | 78 | 75 | 95 | 2 |
| B | 31 | 75 | 24 | 58 |
| C | 4 | 95 | 31 | 5 |
| D | 44 | 91 | 57 | 11 |

Also, when you send the final plan back, just follow this simple JSON layout.

{
  ""solution"": [
    [<session_id>, <storyteller_id>, <layout_id>],
    ...
  ]
}

Each inner array is a triple: [session, storyteller, seating layout] — so one triple per reading session showing which storyteller and which seating plan you picked. This is just a sketch of the shape I expect, not the actual answer.

Please make sure you 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”.""","{'cost_tensor': [[[51, 17, 30, 53], [94, 17, 70, 22], [49, 12, 8, 38], [27, 36, 98, 53]], [[76, 64, 76, 78], [82, 15, 62, 31], [34, 91, 51, 40], [60, 78, 93, 86]], [[86, 67, 75, 58], [38, 35, 20, 82], [41, 46, 97, 12], [21, 95, 73, 40]], [[78, 75, 95, 2], [31, 75, 24, 58], [4, 95, 31, 5], [44, 91, 57, 11]]], 'objective': 46.0}","[[0, 2, 2], [1, 1, 1], [2, 3, 0], [3, 0, 3]]",46.0,"{'problem_type': 'AP3', 'n': 4, 'ids': ['A', 'B', 'C', 'D'], 'costs': [{'i': 'A', 'j': 'A', 'k': 'A', 'cost': 51}, {'i': 'A', 'j': 'A', 'k': 'B', 'cost': 17}, {'i': 'A', 'j': 'A', 'k': 'C', 'cost': 30}, {'i': 'A', 'j': 'A', 'k': 'D', 'cost': 53}, {'i': 'A', 'j': 'B', 'k': 'A', 'cost': 94}, {'i': 'A', 'j': 'B', 'k': 'B', 'cost': 17}, {'i': 'A', 'j': 'B', 'k': 'C', 'cost': 70}, {'i': 'A', 'j': 'B', 'k': 'D', 'cost': 22}, {'i': 'A', 'j': 'C', 'k': 'A', 'cost': 49}, {'i': 'A', 'j': 'C', 'k': 'B', 'cost': 12}, {'i': 'A', 'j': 'C', 'k': 'C', 'cost': 8}, {'i': 'A', 'j': 'C', 'k': 'D', 'cost': 38}, {'i': 'A', 'j': 'D', 'k': 'A', 'cost': 27}, {'i': 'A', 'j': 'D', 'k': 'B', 'cost': 36}, {'i': 'A', 'j': 'D', 'k': 'C', 'cost': 98}, {'i': 'A', 'j': 'D', 'k': 'D', 'cost': 53}, {'i': 'B', 'j': 'A', 'k': 'A', 'cost': 76}, {'i': 'B', 'j': 'A', 'k': 'B', 'cost': 64}, {'i': 'B', 'j': 'A', 'k': 'C', 'cost': 76}, {'i': 'B', 'j': 'A', 'k': 'D', 'cost': 78}, {'i': 'B', 'j': 'B', 'k': 'A', 'cost': 82}, {'i': 'B', 'j': 'B', 'k': 'B', 'cost': 15}, {'i': 'B', 'j': 'B', 'k': 'C', 'cost': 62}, {'i': 'B', 'j': 'B', 'k': 'D', 'cost': 31}, {'i': 'B', 'j': 'C', 'k': 'A', 'cost': 34}, {'i': 'B', 'j': 'C', 'k': 'B', 'cost': 91}, {'i': 'B', 'j': 'C', 'k': 'C', 'cost': 51}, {'i': 'B', 'j': 'C', 'k': 'D', 'cost': 40}, {'i': 'B', 'j': 'D', 'k': 'A', 'cost': 60}, {'i': 'B', 'j': 'D', 'k': 'B', 'cost': 78}, {'i': 'B', 'j': 'D', 'k': 'C', 'cost': 93}, {'i': 'B', 'j': 'D', 'k': 'D', 'cost': 86}, {'i': 'C', 'j': 'A', 'k': 'A', 'cost': 86}, {'i': 'C', 'j': 'A', 'k': 'B', 'cost': 67}, {'i': 'C', 'j': 'A', 'k': 'C', 'cost': 75}, {'i': 'C', 'j': 'A', 'k': 'D', 'cost': 58}, {'i': 'C', 'j': 'B', 'k': 'A', 'cost': 38}, {'i': 'C', 'j': 'B', 'k': 'B', 'cost': 35}, {'i': 'C', 'j': 'B', 'k': 'C', 'cost': 20}, {'i': 'C', 'j': 'B', 'k': 'D', 'cost': 82}, {'i': 'C', 'j': 'C', 'k': 'A', 'cost': 41}, {'i': 'C', 'j': 'C', 'k': 'B', 'cost': 46}, {'i': 'C', 'j': 'C', 'k': 'C', 'cost': 97}, {'i': 'C', 'j': 'C', 'k': 'D', 'cost': 12}, {'i': 'C', 'j': 'D', 'k': 'A', 'cost': 21}, {'i': 'C', 'j': 'D', 'k': 'B', 'cost': 95}, {'i': 'C', 'j': 'D', 'k': 'C', 'cost': 73}, {'i': 'C', 'j': 'D', 'k': 'D', 'cost': 40}, {'i': 'D', 'j': 'A', 'k': 'A', 'cost': 78}, {'i': 'D', 'j': 'A', 'k': 'B', 'cost': 75}, {'i': 'D', 'j': 'A', 'k': 'C', 'cost': 95}, {'i': 'D', 'j': 'A', 'k': 'D', 'cost': 2}, {'i': 'D', 'j': 'B', 'k': 'A', 'cost': 31}, {'i': 'D', 'j': 'B', 'k': 'B', 'cost': 75}, {'i': 'D', 'j': 'B', 'k': 'C', 'cost': 24}, {'i': 'D', 'j': 'B', 'k': 'D', 'cost': 58}, {'i': 'D', 'j': 'C', 'k': 'A', 'cost': 4}, {'i': 'D', 'j': 'C', 'k': 'B', 'cost': 95}, {'i': 'D', 'j': 'C', 'k': 'C', 'cost': 31}, {'i': 'D', 'j': 'C', 'k': 'D', 'cost': 5}, {'i': 'D', 'j': 'D', 'k': 'A', 'cost': 44}, {'i': 'D', 'j': 'D', 'k': 'B', 'cost': 91}, {'i': 'D', 'j': 'D', 'k': 'C', 'cost': 57}, {'i': 'D', 'j': 'D', 'k': 'D', 'cost': 11}]}","[['A', 'C', 'C'], ['B', 'B', 'B'], ['C', 'D', 'A'], ['D', 'A', 'D']]",50,csv,names