/*
    题目描述：有n+1个城市，从0到n标号，并给出m条这n + 1个城市之间的双向边，1——n每个城市都有一个匪徒，0城市有k名警察，现要求警察
                    捕捉所有匪徒后并回到0城市的最短路径，其中k名警察可以全部出动，也可以出动一部分。另外有一个限制：若警察捕捉i城市的匪徒
                    之后，则i-1的匪徒就会逃走，任务失败。但是警察可以经过某个城市但不捕捉该城市当中的匪徒。
    分析：用费用流解决，设置源点、汇点、0城市点、其他各城市点（1——n城市）拆为2*i和2*i+1；
            源点连向0点，容量为k，费用为0；
            0点连向其他城市的2*i点，容量为1，费用为dis[0][i]；
            所有其他城市的2*i点连向其他城市的2*i+1点，容量为1，费用为-inf；
            所有其他城市的2*i+1连向汇点，容量为1，费用为dis[0][i];
            对于所有其他城市点i和j，若i<j，由2*i+1连向2*j，容量为1，费用为dis[i][j]；
            跑一遍源点到汇点的费用流，ans = mincostmaxflow + n * inf；


    理解：图中的单位一的流量，代表一个警察，然而，流量的走向并不是警察的路线，比如某流从i到j，并不是警察的路线是从i走到j，而是警察抓完
               i的匪徒又去抓j的匪徒，但中间走的路线却不一定是怎样的。这样看来一个城市点只需被经过一遍——不是只被走到一次，而是这里的匪徒
               只需被抓一次，因此拆点后的中路容量为1；
    收获：1、这个题是k个警察不需要都用，那么怎么办？连一条从0到汇点的容量为k的边，让不用的警察直接从这里流走；
             2、每个点必须都要经过怎么实现？拆点后将费用置为-inf；
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int maxn = 500 + 5;
const int inf = 1000000000;
typedef long long ll ;
ll dis[maxn][maxn];                 //存储任意两个城市之间的最短距离
int n,m,k;
struct Edge
{
    int from,to,cap,flow,cost;
};
struct MCMF
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[maxn];
    int p[maxn],a[maxn],inq[maxn];
    ll d[maxn];




    void init(int n)
    {
        this -> n = n;
        for(int i=0;i<=n;i++)       G[i].clear();
        edges.clear();
    }




    void AddEdge(int from,int to,int cap,int cost)
    {
        Edge e1 = {from , to , cap , 0 , cost};
        Edge e2 = {to , from , 0 ,  0 , -cost};
        edges.push_back(e1);
        edges.push_back(e2);
        int m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }




    bool BellmanFord(int s,int t,int &flow , ll& cost)
    {
        for(int i=0;i<=n;i++){
            d[i] = inf;
        }
        d[s] = 0;   p[s] = 0;    a[s] = inf;
        mem(inq,0);     inq[s] = 1;
        queue<int>Q;
        Q.push(s);
        while(!Q.empty()){
            int x = Q.front();      Q.pop();
            inq[x] = 0;
            for(int i= 0;i<G[x].size();i++){
                Edge &e  =  edges[G[x][i]];
                if(e.cap>e.flow && d[e.to]>d[x]+e.cost){
                    d[e.to] = d[x] + e.cost;
                    p[e.to] = G[x][i];
                    a[e.to] = min(a[x],e.cap - e.flow);
                    if(!inq[e.to]){
                        Q.push(e.to);
                        inq[e.to] = 1;
                    }
                }
            }
        }
        if(d[t]==inf)       return false;
        flow += a[t];
        cost += (ll)a[t]*(ll)d[t];
        int u = t;
        while(u!=s){
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -= a[t];
            u = edges[p[u]].from;
        }
        return true;
    }




    ll Mincost(int s,int t,int & flow)
    {
        flow = 0;
        ll cost = 0;
        while(BellmanFord(s,t,flow,cost))    ;
        return cost;
    }




};
MCMF g;
void Floyd(int n)
{
    for(int i=0;i<=n;i++)
        dis[i][i] = 0;


    for(int k= 0;k<=n;k++){
        for(int i = 0;i<=n;i++){
            for(int j = 0;j<=n;j++){
                dis[i][j] = min(dis[i][j],dis[i][k] + dis[k][j]);
            }
        }
    }
    return ;
}
int main()
{
    while(scanf("%d %d %d",&n,&m,&k)==3&&n){
        int s,e,len;
        g.init(2 * n + 2);
        for(int i=0;i<=n;i++){
            for(int j = 0;j<=n;j++){
                dis[i][j] = inf;
            }
        }
        for(int i = 0;i<m;i++){
            scanf("%d %d %d",&s,&e,&len);
            if(dis[s][e]>len)                                  //输入一张图的时候要问自己：有重边吗？有自环吗？
                dis[s][e] = dis[e][s] = len;
        }
        Floyd(n);
        int source = 0, sink = 2 * n + 2;
        g.AddEdge(source,1,k,0);
        g.AddEdge(1,sink,k,0);
        for(int i = 1;i<=n;i++){
            g.AddEdge(1,2*i,1,dis[0][i]);
            g.AddEdge(2*i,2*i + 1,1,-inf);
            g.AddEdge(2*i + 1, sink , 1 , dis[0][i]);
        }
        for(int i = 1;i<=n;i++){
            for(int j = i + 1;j<=n;j++){
                g.AddEdge(2*i + 1, 2 * j , 1,dis[i][j]);
            }
        }
        int flow;
        ll ans = g.Mincost(source,sink,flow) ;
        ans += (ll)n * (ll)inf;
        printf("%lld\n",ans);
    }
    return 0;
}