Ada n kotak, bernomor 1-n . Setiap kotak dikunci, sehingga hanya dapat dibuka oleh satu jenis kunci yang sesuai (juga bernomor 1-n ). Kunci-kunci ini tersebar secara acak di dalam kotak-kotak (satu kotak mungkin memiliki sejumlah kunci, satu kunci mungkin memiliki jumlah duplikat), dan kemudian semua kotak ditutup. Harta karun (bernomor 0 ) juga telah dikunci di banyak kotak.

Anda telah menyewa tukang kunci untuk mengambil semua harta karun itu. Dia menagih untuk setiap kotak yang dia buka. Tidak ada biaya untuk membuka kotak yang kuncinya sudah tersedia.

Input adalah isi dari setiap kotak. Anda dapat memutuskan format input.

Keluarkan biaya minimum yang diperlukan untuk mendapatkan harta.

Catatan

1. Algoritme Anda mungkin memakan waktu lama, tetapi itu tidak relevan.
2. Kode terpendek menang.
3. Tidak perlu repot tentang input yang tidak valid.

Contoh data

Di sini baris saya mewakili kunci yang ada di kotak i .

Memasukkan

2 0
3
4 0
5 6 0
6
0

Keluaran

1

Memasukkan

2 0
3 0

4 0
6
5 0

Keluaran

3

Memasukkan

2 4 0
3 0

1 0
6
5 0

Keluaran

2

Memasukkan

1
3 4


2 6
5

Keluaran

0

CJam, 59 52 50 49 45 43 42 byte

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

Terima kasih kepada @ MartinBüttner untuk bermain golf 3 byte dan membuka jalan untuk 4 lainnya!

Cobalah online di penerjemah CJam .

Bagaimana itu bekerja

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 byte)

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

Ini agak lambat untuk penerjemah online.

Pembedahan

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 byte

l adalah orang yang ingin Anda panggil.

Tidak yakin apakah saya seharusnya tidak menggunakan pseudo- Mapsebagai gantinya ( [(Int,[Int])]bukan [[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)