#include<cstdio>

 #include<cstring>

 #include<vector>

 #include<queue>

 #include<algorithm>

 using namespace std;

 typedef long long ll;

 const ll INF = (ll) << ;

 const int maxv =  + ;    //最大顶点数

 const int maxe =  * + ;    //最大边数

 ll dis[maxv];            //源到各顶点的最短距离

 int vis[maxv];            //记录是否被收录，用来代替集合S

 int head[maxv];            //采用链式前向星建图

 int pre[maxv];                //最短路树，记录前一个节点

 vector<int>ans;            //记录答案

 int n, m, k;            //顶点数、边数、最大保留的边数

 struct Node

 {

     int u;

     ll d;            //该节点的编号与距离

     bool operator < (const Node x) const

     {

         return  d > x.d;

     }

 };

 struct Edge

 {

     int to, w, next;

 }edge[maxe];

 inline void addedge(int u, int v, int w, int id)

 {

     edge[id].to = v;

     edge[id].w = w;

     edge[id].next = head[u];

     head[u] = id;

 }

 //s为起点

 void Dijsktra(int s)

 {

     priority_queue<Node>q;            //取出集合T中的最小值

     memset(vis, , sizeof(vis));

     memset(pre, -, sizeof(pre));

     //memset(dis, INF, sizeof(dis));    //与邻接矩阵不同，这里初始化为INF就可以，原因自己想

     for (int i = ; i <= n; i++)  dis[i] = INF;

     dis[s] = ;

     q.push(Node{ s, dis[s] });

     while (!q.empty())

     {

         Node x = q.top(); q.pop();

         int u = x.u;

         if (vis[u])    continue;

         vis[u] = true;

         for (int i = head[u]; i != -; i = edge[i].next)    //松弛与u直接相邻的顶点

         {

             int v = edge[i].to;

             int w = edge[i].w;

             if (!vis[v] && dis[u] + w < dis[v])

             {

                 dis[v] = dis[u] + w;

                 pre[v] = u;                            //记录最短路树的父节点

                 q.push(Node{ v,dis[v] });

             }

         }

     }

 }

 //从s出发找出最短路树上的k个节点（不到k个就是全部节点）

 void bfs(int s)

 {

     queue<int>q;

     q.push(s);

     while (!q.empty())

     {

         int u = q.front(); q.pop();

         for (int e = head[u]; e != -; e = edge[e].next)

         {

             int v = edge[e].to;

             if (pre[v] == u && ans.size() < k)

             {

                 q.push(edge[e].to);

                 ans.push_back(e /  + );        //无向边建图时存了两遍，真实序号位e/2+1

             }

         }

         if (ans.size() >= k)  break;

     }

 }

 int main()

 {

     while (scanf("%d%d%d",&n,&m,&k) == )

     {

         memset(head, -, sizeof(head));

         int id = ;

         for (int i = ; i < m; i++)

         {

             int u, v, w;

             scanf("%d%d%d", &u, &v, &w);

             addedge(u, v, w,id++); addedge(v, u, w,id++);

         }

         Dijsktra();

         ans.clear();

         bfs();

         int cnt = ans.size();

         printf("%d\n", cnt);

         for (int i = ; i < cnt; i++)

             printf("%d%c", ans[i], i == cnt -  ? '\n' : ' ');

     }

     return ;

 }