using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using static System.Math;
using static System.Array;
using static AtCoder.Tool;

namespace AtCoder
{
    class AC
    {
        const int mod = 1000000007;
        const int INF = int.MaxValue / 2;
        const long SINF = long.MaxValue / 2;

        static long ans;
        static int N, M;
        static long[] a;
        static uint[] c;

        static void Main(string[] args)
        {
            //var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            //Console.SetOut(sw);
            var cin = new Scanner();

            var p = cin.SplitReader();
            N = p[0];
            M = p[1];
            a = new long[M];
            c = new uint[M];
            for(var i = 0; i < M; i++)
            {
                var input = cin.SplitReader();
                a[i] = input[0];
                var cc = cin.SplitReader();
                for(var j = 0; j < input[1]; j++)
                {
                    c[i] += (uint)Pow(2, cc[j] - 1);
                }
            }

            long[,] dp = new long[M + 1, (1 << N)];
            for(var i = 0; i <= M; i++)
            {
                for(var j = 0; j < 1 << N; j++)
                {
                    dp[i, j] = j == 0 ? 0 : INF;
                }
            }

            for (var i = 1; i <= M; i++) 
            {
                for(uint j = 0; j < (1 << N); j++)
                {
                    dp[i, j | c[i - 1]] = Min(dp[i, j | c[i - 1]], Min(dp[i - 1, j | c[i - 1]], dp[i - 1, j] + a[i - 1]));
                    dp[i, j] = Min(dp[i, j], dp[i - 1, j]);
                    //Console.WriteLine($"{i} {Convert.ToString(j | c[i - 1], 2)} {dp[i, j | c[i - 1]]}");
                }
            }
            /*for (var i = 0; i <= M; i++)
            {
                for (var j = 0; j < 1 << N; j++)
                {
                    Console.Write($"{dp[i, j]} ");
                }
                Console.WriteLine();
            }*/

            Console.WriteLine(dp[M, (1 << N) - 1] >= INF ? -1 : dp[M, (1 << N) - 1]);

            //Console.Out.Flush();
        }

        

        


    }
    public class Scanner
    {
        public int[] SplitReader()
        {
            int[] array = Console.ReadLine().Split().Select(int.Parse).ToArray();
            return array;
        }
        public long[] SplitReaderL()
        {
            long[] array = Console.ReadLine().Split().Select(long.Parse).ToArray();
            return array;
        }
    }

    public static class Tool
    {
        static public void Initialize<T>(ref T[] array, T initialvalue)
        {
            for (var i = 0; i < array.Length; i++)
            {
                array[i] = initialvalue;
            }
        }
        static public long ModuloP(long value, long mod)
        {
            long r = value % mod;

            if (r * mod < 0)
            {
                r += mod;
            }
            return r;
        }

    }

   struct Pair<T> : IComparable<Pair<T>> where T : IComparable<T>
   {
        public T variable;
        public int index;

        public Pair(T val, int i)
        {
            variable = val;
            index = i;
        }

        public int CompareTo(Pair<T> otherPair)
        {
            return variable.CompareTo(otherPair.variable);
        }

        public int CompareIndex(Pair<T> otherPair)
        {
            return index.CompareTo(otherPair.index);
        }
   }

    


}






Measured memory_bytes: 43104