#include<bits/stdc++.h>

#define FOR(i,a,b) for(auto i=a; i!=b+1-2*(a>b); i+=1-2*(a>b))
#define REP(i,a,b) for(auto i=a-(a>b); i!=b-(a>b); i+=1-2*(a>b))
#define ALL(v) v.begin(),v.end()
#define what_is(x) cout<<#x<<" is "<<x<<endl;
#define min3(a,b,c) min(min(a,b),c)
#define max3(a,b,c) max(max(a,b),c)
#define SIZE 300010
#define MAXN 1000010
#define PI 3.141592653589793
#define open_read1 freopen("C:\\Users\\Hepic\\Desktop\\a.txt","r",stdin)
#define open_write1 freopen("C:\\Users\\Hepic\\Desktop\\b.txt","w",stdout)
#define open_read freopen("rblock.in","r",stdin)
#define open_write freopen("rblock.out","w",stdout)

using namespace std;


typedef long long LL;
typedef pair<int,int> PII;


struct info
{
    int nde,edge_id;
    LL dst;

    bool friend operator < (const info &in1, const info &in2)
    {
        return in1.dst > in2.dst;
    }
};


int N,M,A,B,stNode,cnt;
int node,Tid;
int conn_node,conn_id;
bool visited[SIZE];
LL dist,conn_dist,whole_dist,min_cost,C;
LL min_dist[SIZE], edge_cost[SIZE];
set<PII> keep_edges;
vector<info> tree[SIZE];
priority_queue<info> que;


void dijkstra(int starting_node)
{
    REP(i,0,SIZE)
    {
        visited[i] = false;
        min_dist[i] = -1;
    }

    que.push( info{starting_node, -1, 0} );


    while(!que.empty())
    {
        node = que.top().nde;
        dist = que.top().dst;
        Tid = que.top().edge_id;
        que.pop();


        if(min_dist[node] == -1  ||  dist < min_dist[node])
        {
            min_dist[node] = dist;

            if(Tid != -1)
                keep_edges.insert( make_pair(node, Tid) );
        }

        else if(min_dist[node] == dist)
        {
            auto itr = lower_bound( ALL(keep_edges), make_pair(node, -1) );

            if(edge_cost[Tid] < edge_cost[itr->second])
            {
                keep_edges.erase(itr);
                keep_edges.insert( make_pair(node, Tid) );
            }
        }


        if(visited[node] == true)
            continue;

        visited[node]=true;


        REP(i,0,tree[node].size())
        {
            conn_node  = tree[node][i].nde;
            conn_dist = tree[node][i].dst;
            conn_id = tree[node][i].edge_id;

            whole_dist = dist + conn_dist;

            if(!visited[conn_node])
                que.push( info{conn_node, conn_id, whole_dist} );
        }
    }
}


int main()
{
    scanf("%d%d",&N,&M);

    for(int i=1; i<=M; ++i)
    {
        scanf("%d%d%I64d",&A,&B,&C);

        ++cnt;

        tree[A].push_back( info{B, cnt, C} );
        tree[B].push_back( info{A, cnt, C} ) ;
        edge_cost[cnt] = C;
    }

    scanf("%d",&stNode);



    dijkstra(stNode);

    for(auto val:keep_edges)
        min_cost += edge_cost[val.second];



    printf("%I64d\n",min_cost);

    for(auto val:keep_edges)
        cout<<val.second<<" ";

    printf("\n");


    return 0;
}