#include <bits/stdc++.h>
// #include <atcoder/all>
// using namespace atcoder;
#ifdef LOCAL
#include <debug.h>
#define dbg(...) debug::dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define dbg(...) void(0)
#endif
using namespace std;

// #define int ll

#define rep(i, a, b) for(auto i=static_cast<signed>(a), i##_end__=static_cast<signed>(b); i < i##_end__; i++)
#define rep_r(i, a, b) for(auto i=static_cast<signed>(a), i##_end__=static_cast<signed>(b); i >= i##_end__; i--)
#define fore(i, a) for(auto& i: a)
#define forei(i, it, a) for(auto [i, it] = std::pair{0, std::begin(a)}; it != std::end(a); i++, it++)
#define all(x) std::begin(x), std::end(x)

using ll = long long; // __int128;
using ull = unsigned long long;
template<class T> using priority_queue_asc = priority_queue<T, vector<T>, greater<T>>;

template<class T> ostream& operator<<(ostream& os, const vector<T>& v){ rep(i, 0, v.size()){ os << (i == 0 ? "" : " ") << v[i]; } return os; }
template<class T, class S> istream& operator>>(istream& is, pair<T, S>& p) { is >> p.first >> p.second; return is; }
template<class T> istream& operator>>(istream& is, vector<T>& v) { fore(e, v){ is >> e; } return is; }

template<class C> int siz(const C& c) { return static_cast<int>(c.size()); }
template<class T, size_t N> constexpr int siz(const T (&)[N]) { return static_cast<int>(N); }
template<class A, class V> constexpr void fil(A& a, const V &v){ if constexpr(is_array_v<A>) for(auto& s: a) fil(s, v); else a = v; };
template<class V> constexpr auto vct(size_t n, const V& v){ return vector(n, v); } template <class... A> constexpr auto vct(size_t n, A... a){ return vector(n, vct(a...)); }
template<class T, class S> constexpr bool chmax(T& a, S b) { if (a < b) { a = b; return 1; } return 0; }
template<class T, class S> constexpr bool chmin(T& a, S b) { if (a > b) { a = b; return 1; } return 0; }
template<class T> constexpr T pow2(T x){ return x * x; }
template<class T, class S> constexpr T divceil(T x, S div) { return (x % div == 0) ? x / div : (x >= 0) ? (x / div) + 1 : -((-x) / div); }
template<class T, class S> constexpr T divfloor(T x, S div){ return (x % div == 0) ? x / div : (x >= 0) ? (x / div) : -((-x) / div) - 1; }
template<class T, class S> inline void outif(bool c, T t, S f){ if(c) cout << t << endl; else cout << f << endl; }
inline void yesno(bool x){ cout << (x ? "Yes" : "No") << endl; }
constexpr long long INF = 1LL << 60; // 1.15e18
constexpr int MOD = (int)1e9 + 7;

// 最短路木 - 密グラフバージョン O(N^2)
// 戻り値: d[v]=最短距離(重み), p[v]=親頂点(rootの場合、-1), l[v]=通る経路の色分け。最初の頂点(root直下の頂点番号) 
template<class T> tuple<vector<T>, vector<int>, vector<int>> shortest_path_tree(const vector<vector<T>>& g, int root, T inf = numeric_limits<T>::max()){
    const int n = siz(g);
    vector<T> d(n, inf);
    vector<int> p(n, -1), l(n, -1);
    vector<bool> done(n);
    d[root] = 0;
    while(true){
        int v = -1;
        T mn = inf;
        rep(i, 0, n) if(!done[i] && d[i] < mn) v = i, mn = d[i];
        if(v == -1) break;
        done[v] = true;
        rep(i, 0, n){
            auto w = g[v][i];
            if(done[i] || i == v || w >= inf) continue;
            if(d[i] <= mn + w) continue;
            d[i] = mn + w;
            p[i] = v;
            l[i] = v == root ? i : l[v];
        }
    }
    return {d, p, l};
}

// 無向グラフ 最小サイクル - 密グラフバージョン O(N^2)
template<class T> pair<T, vector<int>> shortest_cycle_undirected(const vector<vector<T>>& g, int root, T inf = numeric_limits<T>::max()){
    const int n = siz(g);

    auto [d, p, l] = shortest_path_tree(g, root, inf);

    T mn = inf;
    int mu = -1, mv = -1;
    rep(u, 0, n) rep(v, u + 1, n){
        auto w = g[u][v];
        if(u == root || v == root || l[u] == l[v] || d[u] >= inf || d[v] >= inf || w >= inf) continue;
        if(chmin(mn, d[u] + d[v] + w)) mu = u, mv = v;
    }
    if(mn == inf) return {inf, {}};

    vector<int> path;
    int v = mu;
    while(v != root) path.push_back(v), v = p[v];
    path.push_back(root);
    reverse(all(path));
    v = mv;
    while(v != root) path.push_back(v), v = p[v];

    return {mn, path};
}
template<class T> pair<T, vector<int>> shortest_cycle_undirected_all(const vector<vector<T>>& g, T inf = numeric_limits<T>::max()){
    T mn = inf;
    vector<int> path;
    rep(i, 0, siz(g)){
        auto [m, p] = shortest_cycle_undirected(g, i, inf);
        if(mn > m) mn = m, path = p;
    }
    return {mn, path};
}

// 有向グラフ 最小サイクル - 密グラフバージョン O(N^2)
template<class T> pair<T, vector<int>> shortest_cycle_directed(const vector<vector<T>>& g, int root, T inf = numeric_limits<T>::max()){
    const int n = siz(g);

    auto [d, p, l] = shortest_path_tree(g, root, inf);

    T mn = inf;
    int v = -1;
    rep(i, 0, n){
        if(i == root || d[i] >= inf || g[i][root] >= inf) continue;
        if(mn <= d[i] + g[i][root]) continue;
        mn = d[i] + g[i][root];
        v = i;
    }
    if(mn == inf) return {inf, {}};

    vector<int> path;
    while(v != root) path.push_back(v), v = p[v];
    path.push_back(root);
    reverse(all(path));

    return {mn, path};
}
template<class T> pair<T, vector<int>> shortest_cycle_directed_all(const vector<vector<T>>& g, T inf = numeric_limits<T>::max()){
    T mn = inf;
    vector<int> path;
    rep(i, 0, siz(g)){
        auto [m, p] = shortest_cycle_directed(g, i, inf);
        if(mn > m) mn = m, path = p;
    }
    return {mn, path};
}

void _main() {
    int T, N, M;
    cin >> T >> N >> M;
    constexpr auto inf = numeric_limits<ll>::max();
    vector g(N, vector(N, inf));
    rep(i, 0, M){
        int u, v, w;
        cin >> u >> v >> w;
        u--; v--;
        g[u][v] = w;
        if(T == 0) g[v][u] = w;
    }

    if(T == 0){
        auto [mn, path] = shortest_cycle_undirected_all(g, inf);
        outif(mn < inf, mn, -1);
    }
    else{
        auto [mn, path] = shortest_cycle_directed_all(g, inf);
        outif(mn < inf, mn, -1);
    }
}

signed main() { 
    cin.tie(nullptr); ios::sync_with_stdio(false);
    cout << fixed << setprecision(15); cerr << fixed << setprecision(15);
    _main();
}