#include <iostream>
#include <bitset>
using namespace std;

const int INF = 100000000; // 十分大きな値

/* 入力 */
int N;
int dist[21][21];

/* メモ再帰 */
int dp[(1<<20) + 1][21]; // dpテーブルは余裕をもったサイズにする
int rec(int bit, int v)
{
    // すでに探索済みだったらリターン
    if (dp[bit][v] != -1) return dp[bit][v];

    // 初期値
    if (bit == (1<<v)) {
        // std::cout << "bit "<< bit << std::endl;
        // std::cout << "init v with 0 "<< v << std::endl;
        // return dp[bit][v] = 0;
        return dp[bit][v] = dist[0][v];
    }

    // 答えを格納する変数
    int res = INF;

    // bit の v を除いたもの
    int prev_bit = bit & ~(1<<v);

    // v の手前のノードとして u を全探索
    int min_root = -1;
    for (int u = 0; u < N; ++u) {
        if (!(prev_bit & (1<<u))) continue; // u が prev_bit になかったらダメ
        // if(dist[u][v]==INF) continue;
        // std::cout << "u "<< u <<" v " << v<< std::endl;
        // 再帰的に探索
        // if (res > rec(bit ^ (1 << v), u) + dist[u][v]) {
        //     res = rec(bit ^ (1 << v), u) + dist[u][v];
        if (res > rec(prev_bit, u) + dist[u][v]) {
            res = rec(prev_bit, u) + dist[u][v];
            min_root = u;
        }
    }
    // std::cout << "min root "<< min_root<< " to "<< v <<" res " << res<< std::endl;

    return dp[bit][v] = res; // メモしながらリターン
}

int main()
{
    // 入力
    cin >> N;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            dist[i][j] = INF;
        }
    }
    int e;
    std::cin >> e;
    for (int i = 0; i < e; i++){
        int s, t, d;
        std::cin >> s >> t >> d;
        dist[s][t] = d;
    }

    // テーブルを全部 -1 にしておく (-1 でなかったところは探索済)
    for (int bit = 0; bit < (1<<N); ++bit) for (int v = 0; v < N; ++v) dp[bit][v] = -1;

    // 探索
        int a = rec((1<<N)-1, 0);
    // std::cout << "res "<< a << " root "<< 0  << std::endl;
    if(a < INF){
        std::cout << a << std::endl;
    } else{
      std::cout << -1 << std::endl;
    }
    // int res = INF;
    // for (int v = 0; v < N; ++v) {
    //     if (res > rec((1<<N)-1, v)) {
    //         res = rec((1<<N)-1, v);
    //     }
    // }
    // cout << res << endl;
}


// #include <bits/stdc++.h>
// #define LOOP(n) for (int _i = 0; _i < (n); _i++)
// #define REP(i, n) for (int i = 0; i < (n); ++i)
// #define RREP(i, n) for (int i = (n); i >= 0; --i)
// #define FOR(i, r, n) for (int i = (r); i < (n); ++i)
// #define ALL(obj) begin(obj), end(obj)
// using namespace std;
// using ll = long long;
// const int INF = 1000100100;
// template <class T>
// bool chmin(T &a, const T &b) {
//     if (b < a) {
//         a = b;
//         return 1;
//     }
//     return 0;
// }
// int V, E;
// int G[20][20];  // グラフ
// int dp[50000][20];
// // メモ化再帰
// int rec(int bit, int v) {
//     if (bit == 0) {
//         if (v == 0) {
//             return 0;
//         } else {
//             return INF;
//         }
//     }
//     if ((bit & (1 << v)) == 0) {  // bitに{v}が含まれていない
//         return INF;
//     }
//     int &ret = dp[bit][v];
//     if (ret != 0) return ret;
//     ret = INF;
//     REP(u, V) { chmin(ret, rec(bit ^ (1 << v), u) + G[u][v]); }
//     return ret;
// }
// int main() {
//     cin >> V >> E;
//     // グラフの初期化
//     REP(i, 20) {
//         REP(j, 20) { G[i][j] = INF; }
//     }
//     REP(i, E) {
//         int s, t, d;
//         cin >> s >> t >> d;
//         G[s][t] = d;
//     }
//     // int ans = rec((1 << V) - 1, 0);
//     int ans = rec((1 << V) - 1, 1);
//     // int b = rec((1 << V) - 1, 2);
//     // int c = rec((1 << V) - 1, 3);
//     // std::cout << "a "<< a << std::endl;
//     // std::cout << "a "<< a << " b "<< b <<" c "<<c<< std::endl;
//     if (ans != INF) {
//         cout << ans << endl;
//     } else {
//         cout << -1 << endl;
//     }
//     return 0;
// }



Measured memory_bytes: 5780