#include<cstdio>
#include<vector>
#define MAXN 1030
#define INF 1000000000
using namespace std;
vector<pair<int,int> > g[MAXN],gt[MAXN];
int n,m,k;
int order[MAXN],inDegree[MAXN],best[MAXN][MAXN],index[MAXN],road[MAXN],HeapSize;
struct HeapNode{
    int node;
    int sum;
};
HeapNode Heap[MAXN];
void TopologicalSort(){
    int i,left=1,right=0,node;
    for(i=1;i<=n;i++)
        if(inDegree[i]==0){
            right++;
            order[right]=i;
        }
    while(left<=right){
        node=order[left];
        left++;
        for(i=0;i<g[node].size();i++){
            inDegree[g[node][i].first]--;
            if(inDegree[g[node][i].first]==0){
                right++;
                order[right]=g[node][i].first;
            }
        }
    }
}
int Compare(int x,int y){
    int costX,costY;
    if(x>HeapSize)
        costX=INF;
    else
        costX=best[Heap[x].node][road[Heap[x].node]]+Heap[x].sum;
    if(y>HeapSize)
        costY=INF;
    else
        costY=best[Heap[y].node][road[Heap[y].node]]+Heap[y].sum;
    if(costX<costY)
        return x;
    return y;
}
void Ascend(int x){
    HeapNode temp;
    while(x!=1&&Compare(x,x/2)==x){
        temp=Heap[x];
        Heap[x]=Heap[x/2];
        Heap[x/2]=temp;
        x/=2;
    }
}
void Descend(int x){
    HeapNode temp;
    int bestSon=Compare(2*x,2*x+1);
    while(x<=HeapSize&&Compare(bestSon,x)==bestSon){
        temp=Heap[bestSon];
        Heap[bestSon]=Heap[x];
        Heap[x]=temp;
        x=bestSon;
        bestSon=Compare(2*x,2*x+1);
    }
}
void Solve(){
    int i,j,node;
    HeapNode temp;
    for(i=1;i<=n;i++)
        for(j=1;j<=k;j++)
            best[i][j]=INF;
    best[1][1]=0;
    index[1]=1;
    for(i=2;i<=n;i++){
        node=order[i];
        for(j=1;j<=n;j++)
            road[j]=1;
        HeapSize=0;
        for(j=0;j<gt[node].size();j++){
            HeapSize++;
            Heap[HeapSize].node=gt[node][j].first;
            Heap[HeapSize].sum=gt[node][j].second;
            Ascend(HeapSize);
        }
        while(HeapSize>0&&index[node]<=k){
            index[node]++;
            best[node][index[node]]=best[Heap[1].node][road[Heap[1].node]]+Heap[1].sum;
            road[Heap[1].node]++;
            if(road[Heap[1].node]<=index[Heap[1].node])
                Descend(1);
            else{
                temp=Heap[1];
                Heap[1]=Heap[HeapSize];
                Heap[HeapSize]=temp;
                HeapSize--;
                Descend(1);
            }
        }
    }
}
int main(){
    freopen("pitici.in","r",stdin);
    freopen("pitici.out","w",stdout);
    int i,a,b,c;
    scanf("%d%d%d",&n,&m,&k);
    for(i=1;i<=m;i++){
        scanf("%d%d%d",&a,&b,&c);
        inDegree[b]++;
        g[a].push_back(make_pair(b,c));
        gt[b].push_back(make_pair(a,c));
    }
    TopologicalSort();
    Solve();
    for(i=1;i<=k;i++)
        printf("%d ",best[n][i]);
    return 0;
}