번호가 1-n 인 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<

3 바이트를 골라 내고 4 개 더 길을 포장 한 @ MartinBüttner에게 감사합니다!

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

하스켈, 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)