#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
#include <queue>
int N;
using namespace std;
/*
void Dijkstra() { // O(n^2 + m) для полных графов
    int d[N];
    bool used[N];
    vector<vector<pair<int, int>>> g;
    for (int it = 0; it < N; ++it) {
        int v = -1;
        for (int i = 0; i < N; ++i) {
            if (!used[i] && (v == -1 || d[i] < d[v])) {
                v = i;
            }
        }
        if (d[v] == INT_MAX) {
            break;
        }
        used[v] = true;
        for (auto[to, w] : g[v]) {
            if (d[to] > d[v] + w) {
                d[to] = d[to] + w;
            }
        }
    }

}*/
struct vertex {
    int num;
    int weight;
};

void Dijkstra2(int s, vector<vector<vertex>>& g) { // O(m log n + n log n)
    vector<int> d(N, INT_MAX);
    priority_queue<pair<int, int>> q;
    vector<int> p(N, -1);
    d[s] = 0;
    q.emplace(d[s], s);
    while (!q.empty()) {
        int v = q.top().second;
        q.pop();
        for (auto& [to, w] : g[v]) {
            if (d[to] > d[v] + w && d[v] != INT_MAX) {
                p[to] = v;
                d[to] = d[v] + w;
                q.emplace(d[to], to);
            }
        }
    }
    if (p[N - 1] == -1) {
        cout << -1;
        return;
    }
    vector<int> ans;
    for (int i = N - 1; i > 0; i = p[i]) {
        ans.push_back(i);
    }
    ans.push_back(0);
    reverse(ans.begin(), ans.end());
    for (int i : ans) {
        cout << i + 1 << " ";
    }
}

void Floyd() {
    vector<vector<vector<int>>> d(N, vector<vector<int>>(N, vector<int>(N)));
    for (int i = 0; i < N; ++i) {
        d[0][i][i] = 0;
    }
}
int main() {
    int m, u, c, b;
    vertex a;
    cin >> N >> m;
    vector<vector<vertex>> g(N);
    for (int i = 0; i < m; ++i) {
        cin >> u >> c >> b;
        a.num = c - 1;
        a.weight = b;
        g[u - 1].emplace_back(a);
        a.num = u - 1;
        g[c - 1].emplace_back(a);
    }
    Dijkstra2(0, g);
    return 0;
}