有n个框，编号为1-n。每个盒子都被锁定，因此只能通过一种相应类型的钥匙（也编号为1-n）打开它。这些密钥随机散布在框中（一个盒子可以具有任意数量的密钥，一个密钥可以具有任意数量的重复项），然后关闭所有盒子。许多盒子中也锁着一个宝物（编号0）。

您已雇了一个锁匠来取回所有宝藏。他为打开的每个盒子收费。打开一个已经有钥匙的盒子是免费的。

输入是每个框的内容。您可以决定输入的格式。

输出获得宝藏所需的最低成本。

笔记

1. 您的算法可能会花费很长时间，但这无关紧要。
2. 最短的代码获胜。
3. 无需担心无效输入。

样本数据

第i行代表框i中显示的键。

输入值

2 0
3
4 0
5 6 0
6
0

输出量

1

输入值

2 0
3 0

4 0
6
5 0

输出量

3

输入值

2 4 0
3 0

1 0
6
5 0

输出量

2

输入值

1
3 4


2 6
5

输出量

0

CJam，59 52 50 49 45 43 42字节

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

感谢@MartinBüttner打出3个字节并为另外4个字节铺平了道路！

在CJam解释器中在线尝试。

怎么运行的

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字节）

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

对于在线口译员来说，这太慢了。

解剖

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个字节

l 是你想打电话的那个。

不知道我是否应该使用伪Map代替（[(Int,[Int])]代替[[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)