#include<iostream>
#include<fstream>
#include<set>
#include<algorithm>
#include<vector>
#define inf 1e9
using namespace std;
int i, m ;

struct dublu
{
    int dist;
    int nod;
    bool operator<(const dublu & a) const
    {
        return dist < a.dist;
    }

};
vector<dublu> vec[100000];

int d[100000], proces[100000], n, p, x, y, cost;
void dijkstra(int v)
{
    for(int i=1;i<=n;i++)
    {
        d[i] = inf;
    }
    d[v] = 0;
    int u;
    set<pair<int, int>> s;
    s.insert({d[v], v});
    while (!s.empty()) {
        int crt = s.begin()->second;
        s.erase(s.begin());
        if (proces[crt]) {
            continue;
        }
        proces[crt] = 1;
        for (auto v: vec[crt]) {
            if (d[v.nod] > d[crt] + v.dist) {
                s.erase({d[v.nod], v.nod});
                d[v.nod] = d[crt] + v.dist;
                s.insert({d[v.nod], v.nod});
            }
        }
    }
    /**while(!s.empty())
    {
        dublu x = *(s.begin());

        u = x.nod;
        s.erase(s.begin());
        if(proces[u])
            continue;
        proces[u] = 1;

        int l = vec[u].size();

        for(int j = 0; j < l; j++ )
        {
            int vecin = vec[u][j].nod;
            if(d[vecin] > d[u] + vec[u][j].dist )
            {
                s.erase({d[vecin], vecin});

                d[vecin] = min(d[vecin], d[u] + vec[u][j].dist);
                s.insert({d[vecin], vecin});
            }
        }
    }*/
}
int main()
{
    freopen("dijkstra.in", "r", stdin);
    freopen("dijkstra.out", "w", stdout);
    cin >> n >> p;

    while(cin >> x >> y >> cost)
    {
        vec[x].push_back({cost, y});

    }

    dijkstra(p);

    for(int i = 1; i <= n; i++)
    {
        if(d[i] == inf)
            cout << -1 << " ";
        else
            cout << d[i] << " ";
    }
    return 0;
}