#include<iostream>

#include<string.h>

#include<iostream>

#include<queue>

#include<cmath>

#include<unordered_map>

#include<unordered_set>

#include<string>

#include<vector>

#include<algorithm>

using namespace std;

const int inf = 1 << 29;

const int kEdgeMax = 20005;

const int kNodeMax = 1005;

struct Edge{

	int to;

	int dist;

	int next;

	Edge(int t=0, int d=0, int n=0) :to(t), dist(d), next(n){};

};

Edge gEdges[kEdgeMax];

int gEdgesIndex;

int gHead[kNodeMax];

int gDist[kNodeMax];

bool gVisited[kNodeMax];

struct Cmp{

	bool operator()(const Edge& e1, const Edge& e2){

		return e1.dist > e2.dist;

	}

};

void InsertEdge(int u, int v, int d){

	int e = gEdgesIndex++;

	gEdges[e].to = v;

	gEdges[e].dist = d;

	gEdges[e].next = gHead[u];

	gHead[u] = e;

}

//dijkstra 算法求最短路

int Dijkstra(int s, int t){

	priority_queue<Edge, vector<Edge>, Cmp> pq;

	gDist[s] = 0;

	Edge e = Edge(s, 0, 0);

	pq.push(e);

	while (!pq.empty()){

		e = pq.top();

		pq.pop();

		int cur_v = e.to;

		if (gVisited[cur_v]){

			continue;

		}

		if (cur_v == t){

			break;

		}

		gVisited[cur_v] = true;

		for (int eid = gHead[cur_v]; eid != -1; eid = gEdges[eid].next){

			int next_v = gEdges[eid].to;

			if (!gVisited[next_v] && gDist[next_v] > gDist[cur_v] + gEdges[eid].dist){

				gDist[next_v] = gDist[cur_v] + gEdges[eid].dist;

				pq.push(Edge(next_v, gDist[next_v], 0));

			}

		}

	}

	return gDist[t];

}

void Init(){

	memset(gHead, -1, sizeof(gHead));

	memset(gVisited, false, sizeof(gVisited));

	memset(gDist, 0x7F, sizeof(gDist));

	gEdgesIndex = 0;

}

int main(){

	int n, m, s, t, u, v, d;

	Init();

	scanf("%d %d %d %d", &n, &m, &s, &t);

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

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

		InsertEdge(u, v, d);

		InsertEdge(v, u, d);

	}

	int min_dist = Dijkstra(s, t);

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

	return 0;

}