Il y a n cases, numérotées de 1 à n . Chaque boîte est verrouillée, de sorte qu'elle peut être ouverte par un seul type de clé correspondant (également numéroté 1-n ). Ces clés sont dispersées au hasard dans les boîtes (une boîte peut avoir n'importe quel nombre de clés, une clé peut avoir un nombre quelconque de doublons), puis toutes les boîtes sont fermées. Un trésor (numéroté 0 ) a également été enfermé dans de nombreuses boîtes.

Vous avez engagé un serrurier pour récupérer tous les trésors. Il facture pour chaque boîte qu'il ouvre. L'ouverture d'une boîte pour laquelle la clé est déjà disponible est gratuite.

L'entrée est le contenu de chaque boîte. Vous pouvez décider du format de l'entrée.

Produisez le coût minimum requis pour obtenir les trésors.

Remarques

1. Votre algorithme peut prendre beaucoup de temps, mais ce n'est pas pertinent.
2. Le code le plus court gagne.
3. Pas besoin de s'inquiéter d'une entrée invalide.

Exemples de données

Ici, la ligne i représente les clés présentes dans la case i .

Contribution

2 0
3
4 0
5 6 0
6
0

Production

1

Contribution

2 0
3 0

4 0
6
5 0

Production

3

Contribution

2 4 0
3 0

1 0
6
5 0

Production

2

Contribution

1
3 4


2 6
5

Production

0

CJam, 59 52 50 49 45 43 42 octets

qN/ee::~e!{_0+{0a&}#>W%_{1$|(z@-},,\;}%:e<

Merci à @ MartinBüttner pour avoir joué au golf sur 3 octets et ouvert la voie à 4 autres!

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

qN/      e# Read all input and split it at linefeeds.
ee       e# Enumerate the lines.
         e# STACK: [[0 "i0 i1 ..."] [1 "j0 j1 ..."] ...]
::~      e# Apply ~ (bitwise NOT/evaluate) to each item of the pairs.
         e# STACK: [[-1 i0 i1 ...] [-2 j0 j1 ...] ...]
e!       e# Push all unique permutations of the resulting array.
{        e# For each permutation:
  _0+    e#   Push a copy and append 0 to it.
  {0a&}# e#   Find the first index of an element that contains 0.
  >      e#   Discard all previous elements of the array.
  W%     e#   Reverse the resulting array.
         e#   We now have a (partial) permutation that contains
         e#   all treasures and ends with a treasure.
  _      e#   Push a copy. The original (which contains lists, but no 
              numbers) will serve as accumulator.
  {      e#   Filter; for each list in the array:
    1$|  e#     Push a copy of the accumulator and perform set union.
    (    e#     Shift out the first element (bitwise NOT of 0-based index).
    z    e#     Apply absolute value to push the 1-based index.
    @-   e#     Perform set difference with the former state of the 
         e#     accumulator. This pushes an empty list iff the 1-based
         e#     index was already in the accumulator, i.e., iff we already
         e#     had a key.
  },     e#   Keep the element if we did not have the key.
  ,      e#   Count the kept elements.
  \;     e#   Discard the accumulator from the stack.
}%       e#
:e<      e# Get the minimum of all results.

CJam (53 octets)

Nq+N/:a::~:A,_m*_.&{,}$_{{_Af=e_|}:PA,*A,,^0-P0&!}#=,

C'est un peu trop lent pour l'interprète en ligne.

Dissection

Nq+N/:a::~:A      e# Parse the input into arrays and store in A
,_m*_.&           e# Generate (with duplicates) a powerset of [0 1 ... n]
{,}$              e# Sort by size
_{                e# Create a copy and search for first index satisfying...
  {_Af=e_|}:P     e#   Store in P a block which does a reachability expansion
  A,*             e#   Apply it n times (no path can be longer than n)
  A,,^0-          e#   Invert to get the unreached nodes (except 0)
  P               e#   Apply P again to see what's reached from the unreached nodes
  0&!             e#   Check that it doesn't include [0]
}#
=,                e# Look up the powerset element at that index and find length

Haskell, 173 octets

l est celui que tu veux appeler.

Je ne sais pas si je ne devrais pas utiliser un pseudo- à la Mapplace ( [(Int,[Int])]au lieu de [[Int]]).

l=o[].map(map read).map words.lines
o[]b|0`notElem`concat b=0|0<1=1+minimum[o[n]b|n<-[1..length b],b!!(n-1)/=[]]
o(n:k)b=o(filter(/=0)(k++b!!(n-1)))(take(n-1)b++[]:drop n b)