Có n hộp, được đánh số 1-n . Mỗi hộp bị khóa, sao cho nó chỉ có thể được mở bằng một loại khóa tương ứng (cũng được đánh số 1-n ). Các khóa này được phân tán ngẫu nhiên trong các hộp (một hộp có thể có bất kỳ số lượng khóa nào, một khóa có thể có bất kỳ số lượng trùng lặp nào), và sau đó tất cả các hộp đều bị đóng. Một kho báu (được đánh số 0 ) cũng đã bị khóa trong nhiều hộp.

Bạn đã thuê một thợ khóa để lấy tất cả các kho báu. Anh ta tính phí cho mỗi hộp anh ta mở ra. Không có phí để mở một hộp mà chìa khóa đã có sẵn.

Đầu vào là nội dung của mỗi hộp. Bạn có thể quyết định định dạng của đầu vào.

Đầu ra chi phí tối thiểu cần thiết để có được kho báu.

Ghi chú

1. Thuật toán của bạn có thể mất nhiều thời gian, nhưng điều đó không liên quan.
2. Mã ngắn nhất sẽ thắng.
3. Không cần phải bận tâm về đầu vào không hợp lệ.

Dữ liệu mẫu

Ở đây dòng i đại diện cho các phím có trong hộp i .

Đầu vào

2 0
3
4 0
5 6 0
6
0

Đầu ra

1

Đầu vào

2 0
3 0

4 0
6
5 0

Đầu ra

3

Đầu vào

2 4 0
3 0

1 0
6
5 0

Đầu ra

2

Đầu vào

1
3 4


2 6
5

Đầu ra

0

CJam, 59 52 50 49 45 43 42 byte

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

Cảm ơn @ MartinBüttner vì đã chơi golf 3 byte và mở đường cho 4 người nữa!

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

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&!}#=,

Điều này là quá chậm cho phiên dịch trực tuyến.

Mổ xẻ

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 là người bạn muốn gọi.

Không chắc chắn liệu tôi không nên sử dụng giả - Mapthay vào đó ( [(Int,[Int])]thay vì [[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)