#include <iostream>
#include <iomanip>
#include <random>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <numeric>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <sstream>
#include <bitset>
#include <cassert>
#include <fstream>
#include <queue>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <limits>

#define len(X) ((int)(X).size())

#ifdef __LOCAL
#define DBG(X) cout << #X << "=" << (X) << '\n';
#define SAY(X) cout << (X) << '\n';
#else
#define DBG(X)
#define SAY(X)
#endif

#define M_PI       3.14159265358979323846

using namespace std;

using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

const int INT_INF = (int)(2e9);
const ll  LL_INF = (ll)(2e18);

const int NIL = -1;
static mt19937 _g(time(nullptr));

inline ll randint(ll a, ll b) { ll w = (_g() << 31LL) ^ _g(); return a + w % (b - a + 1); }
inline void fast_io() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); };
template<typename T> inline T sign(T x) { return T(x > 0) - T(x < 0); }
template<typename T, typename S> inline ostream& operator<<(ostream& os, const pair<T, S> p) { cout << "[" << p.first << ";" << p.second << "]"; return os; }
template<typename T> inline ostream& operator<<(ostream& os, const vector<T>& v) { for (auto el : v) cout << el << " "; return os; }
template<typename T> inline T fetch() { T ret; cin >> ret; return ret; }
template<typename T> inline vector<T> fetch_vec(int sz) { vector<T> ret(sz); for (auto& elem : ret) cin >> elem; return ret; }

int solve(int locks, int keys, std::map<int, std::pair<int, vector<int>>>& keyMap)
{
    vector<ll> dp(1 << locks, std::numeric_limits<int>::max());
    dp[0] = 0;

    for (int i = 0; i < keys; ++i)
    {
        int newKeys = 0;
        for (int k: keyMap[i].second)
            newKeys |= 1 << (k - 1);

        for (int j = 0; j < 1 << locks; ++j)
        {
            dp[j | newKeys] = std::min(dp[j | newKeys], dp[j] + keyMap[i].first);
        }
    }

    if (dp[(1 << locks) - 1] == std::numeric_limits<int>::max())
        std::cout << -1 << std::endl;
    else
        std::cout << dp[(1 << locks) - 1] << std::endl;

    return 0;
}


int main()
{
    int locks, keys;
    std::cin >> locks >> keys;

    std::map<int, std::pair<int, vector<int>>> keyMap;

    for (int i = 0; i < keys; ++i)
    {
        int cost, opens;
        std::cin >> cost >> opens;

        keyMap[i] = std::make_pair(cost, vector<int>());

        for (int j = 0; j < opens; ++j)
        {
            int opened;
            std::cin >> opened;
            keyMap[i].second.push_back(opened);
        }
    }
    /*
    std::unordered_set<int> openedLocks;
    int totalCost = 0;

    while (openedLocks.size() != locks && keyMap.size() != 0)
    {
        double minCost = std::numeric_limits<double>::max();
        auto itMin = keyMap.begin();
        auto it = keyMap.begin();

        while (it != keyMap.end())
        {
            int addedItems = 0;
            for (int item: it->second.second)
            {
                if (openedLocks.find(item) == openedLocks.end())
                    ++addedItems;
            }

            double relativeCost = static_cast<double>(it->second.first) / addedItems;

            if (relativeCost < minCost)
            {
                minCost = relativeCost;
                itMin = it;
            }

            ++it;
        }

        for (int item : itMin->second.second)
            openedLocks.insert(item);
        
        totalCost += itMin->second.first;
        keyMap.erase(itMin);
    }

    if (keyMap.empty() && openedLocks.size() < locks)
        totalCost = -1;
    
    std::cout << totalCost << std::endl;
    */

    solve(locks, keys, keyMap);

    return 0;
}


Measured memory_bytes: 384