Problem:
Score : 500 points

Problem Statement

We have N locked treasure boxes, numbered 1 to N.

A shop sells M keys. The i-th key is sold for a_i yen (the currency of Japan), and it can unlock b_i of the boxes: Box c_{i1}, c_{i2}, ..., c_{i{b_i}}. Each key purchased can be used any number of times.

Find the minimum cost required to unlock all the treasure boxes. If it is impossible to unlock all of them, print -1.

Constraints

All values in input are integers.

1 \leq N \leq 12

1 \leq M \leq 10^3

1 \leq a_i \leq 10^5

1 \leq b_i \leq N

1 \leq c_{i1} < c_{i2} < ... < c_{i{b_i}} \leq N

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1
c_{11} c_{12} ... c_{1{b_1}}
:
a_M b_M
c_{M1} c_{M2} ... c_{M{b_M}}

Output

Print the minimum cost required to unlock all the treasure boxes.
If it is impossible to unlock all of them, print -1.

Sample Input 1

2 3
10 1
1
15 1
2
30 2
1 2

Sample Output 1

25

We can unlock all the boxes by purchasing the first and second keys, at the cost of 25 yen, which is the minimum cost required.

Sample Input 2

12 1
100000 1
2

Sample Output 2

-1

We cannot unlock all the boxes.

Sample Input 3

4 6
67786 3
1 3 4
3497 1
2
44908 3
2 3 4
2156 3
2 3 4
26230 1
2
86918 1
3

Sample Output 3

69942

Solution in Haskell (GHC 7.10.3) (judge verdict: Accepted)

module Main where

import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.ByteString.Char8         as BS
import           Data.List
import           Data.Char
import           Control.Monad
import           Data.Bits
import           Data.Function
import           Debug.Trace

ub = 1145141919

main :: IO ()
main = do
  [n, m] <- unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
  keys   <- replicateM m $ do
    [a, b] <- unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
    cs     <- unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
    let bits = foldl' setBit zeroBits $ map pred cs
    return (a, bits)
  let full = bit n - 1
  let ans = solve full keys VU.! full
  print $ if ans == ub then -1 else ans

solve :: Int -> [(Int, Int)] -> VU.Vector Int
solve full keys = VU.create $ do
  dp <- VUM.replicate (full + 1) ub
  VUM.write dp 0 0
  forM_ [0 .. full - 1] $ \j ->
    forM_ keys $ \(ai, di) -> do
      let j_or_di = j .|. di
      candidate1 <- VUM.read dp j_or_di
      candidate2 <- VUM.read dp j
      let candidate2' = candidate2 + ai
      when (candidate1 > candidate2') $ 
        VUM.write dp j_or_di candidate2'
  return dp