using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using E = System.Linq.Enumerable;


class Program
{
    static long max = 10000000000;
    static void Main(string[] args)
    {
        var NM = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
        var N = NM[0];
        var M = NM[1];

        var cost = new long[M];
        var key  = new long[M];
        for (int i = 0; i < M; i++)
        {
            var AB = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            cost[i] = AB[0];

            var C = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            for (int j = 0; j < AB[1]; j++)
            {
                key[i] += (long)Math.Pow(2, C[j] - 1);
            }
        }

        var dp = new long[M + 1, (int)Math.Pow(2, N)];
        for (int i = 0; i < M + 1; i++)
        {
            for (int j = 0; j < (int)Math.Pow(2, N); j++)
            {
                dp[i, j] = max;
            }
        }
        dp[0, 0] = 0;

        for (int i = 0; i < M; i++)
        {
            for (int j = 0; j < (int)Math.Pow(2, N); j++)
            {
                
                if(dp[i + 1, j] > dp[i, j])
                {
                    dp[i + 1, j] = dp[i, j];
                }
                var k = (int)(j |(int)key[i]);
                if(dp[i + 1, k] > dp[i, j] + cost[i])
                {
                    dp[i + 1, k] = dp[i, j] + cost[i];
                }
            }
        }
        Console.WriteLine(dp[M, (int)Math.Pow(2, N)-1] < max ? dp[M, (int)Math.Pow(2, N) - 1] : -1);

    }

    


}

class UnionFind



{



    // 親要素のインデックスを保持する



    // 親要素が存在しない(自身がルートである)とき、マイナスでグループの要素数を持つ



    public long[] Parents { get; set; }



    public UnionFind(long n)



    {



        this.Parents = new long[n];



        for (int i = 0; i < n; i++)



        {



            // 初期状態ではそれぞれが別のグループ(ルートは自分自身)



            // ルートなのでマイナスで要素数(1個)を保持する



            this.Parents[i] = -1;



        }



    }







    // 要素xのルート要素はどれか



    public long Find(long x)



    {



        // 親がマイナスの場合は自分自身がルート



        if (this.Parents[x] < 0) return x;



        // ルートが見つかるまで再帰的に探す



        // 見つかったルートにつなぎかえる



        this.Parents[x] = Find(this.Parents[x]);



        return this.Parents[x];



    }







    // 要素xの属するグループの要素数を取得する



    public long Size(long x)



    {



        // ルート要素を取得して、サイズを取得して返す



        return -this.Parents[this.Find(x)];



    }







    // 要素x, yが同じグループかどうか判定する



    public bool Same(long x, long y)



    {



        return this.Find(x) == this.Find(y);



    }







    // 要素x, yが属するグループを同じグループにまとめる



    public bool Union(long x, long y)



    {



        // x, y のルート



        x = this.Find(x);



        y = this.Find(y);



        // すでに同じグループの場合処理しない



        if (x == y) return false;







        // 要素数が少ないグループを多いほうに書き換えたい



        if (this.Size(x) < this.Size(y))



        {



            var tmp = x;



            x = y;



            y = tmp;



        }



        // まとめる先のグループの要素数を更新



        this.Parents[x] += this.Parents[y];



        // まとめられるグループのルートの親を書き換え



        this.Parents[y] = x;



        return true;



    }



}



Measured memory_bytes: 43104