#include <bits/stdc++.h>

using namespace std;

ifstream fin("pitici.in");
ofstream fout("pitici.out");

int n,m,k;

int a[200020];
int b[200020];
int c[200020];

vector <int> g[1020];
int ind[1020];
vector <int> gt[1020];

bool viz[1020];

int dp1[1020];
int dpn[1020];

vector <int> h[1020];
vector <int> hh[1020];

void dfsn(int u)
{
    dpn[u]=(int)1e9;
    viz[u]=1;
    for(int e:g[u])
    {
        int v=a[e]+b[e]-u;
        if(viz[v]==0)
            dfsn(v);

        dpn[u]=min(dpn[u],dpn[v]+c[e]);
    }

    for(int e:g[u])
    {
        int v=a[e]+b[e]-u;
        if(dpn[u]==dpn[v]+c[e])
        {
            h[u].push_back(u);
            for(auto it:h[v])
                h[u].push_back(it);

            hh[u].push_back(e);
            for(auto it:hh[v])
                hh[u].push_back(it);
            break;
        }
    }
}

void dfs1(int u)
{
    dp1[u]=(int)1e9;
    viz[u]=1;

    for(int e:gt[u])
    {
        int v=a[e]+b[e]-u;
        if(viz[v]==0)
            dfs1(v);

        dp1[u]=min(dp1[u],dp1[v]+c[e]);
    }
}

bool cmp(int i,int j)
{
    return (dp1[a[i]]+dpn[b[i]]+c[i]<dp1[a[j]]+dpn[b[j]]+c[j]);
}

bool inaux[200020];
bool used[200020];

vector <int> aux={1};

int main()
{
    fin>>n>>m>>k;
    for(int i=1; i<=m; i++)
    {
        fin>>a[i]>>b[i]>>c[i];
        g[a[i]].push_back(i);
        gt[b[i]].push_back(i);
    }

    viz[n]=1;
    dpn[n]=0;
    dfsn(1);

    for(int i=1; i<=n; i++)
        viz[i]=0;

    viz[1]=1;
    dp1[1]=0;
    dfs1(n);

    for(int i=1; i<=n; i++)
        sort(g[i].begin(),g[i].end(),cmp);

    while(k--)
    {
        int minim=(int)1e9;
        int emin=0;
        for(auto it:aux)
        {
            if(ind[it]<g[it].size())
            {
                int e=g[it][ind[it]];
                if(dp1[a[e]]+dpn[b[e]]+c[e]<minim)
                {
                    minim=dp1[a[e]]+dpn[b[e]]+c[e];
                    emin=e;
                }
            }
        }

        fout<<minim<<" ";

        for(auto it:h[b[emin]])
        {
            if(inaux[it]==0)
            {
                inaux[it]=1;
                aux.push_back(it);
            }
        }

        used[emin]=1;
        for(auto it:hh[b[emin]])
            if(used[it]==0)
                used[it]=1;

        for(int i=1; i<=n; i++)
            while(ind[i]<g[i].size() && used[g[i][ind[i]]]==1)
                ind[i]++;
    }

    fout<<"\n";
    return 0;
}