#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#define INF 25000000
using namespace std;
FILE *f,*g;
struct cp{int y,c; }ax;
vector <cp> a[30200],b[30200];
int n,m,st,dr;
int H[30200];
int Pos[30200];
int D[30200];
int L;



inline cp mkcp(int a,int b){
    cp ax;
    ax.y=a;
    ax.c=b;
    return ax;
}

bool cmp(cp a, cp b){
    return a.y<=b.y;
}


void read()
{
    int i,x,y,z;
    f=fopen("sate.in","r");
    g=fopen("sate.out","w");

    fscanf(f,"%d%d%d%d",&n,&m,&st,&dr);
    if (st>dr) swap(st,dr);

    for (i=1;i<=m;i++)
    {
        fscanf(f,"%d%d%d",&x,&y,&z);
        if (x<y)
            a[x].push_back(mkcp(y,z));
        else
            a[y].push_back(mkcp(x,z));
    }
}

void solve()
{
    int i,j,d,x;

    for (i=1;i<=n;i++)
        if (a[i].size()>0)
        {
            stable_sort(a[i].begin(),a[i].end(),cmp);
            for (j=0,d=0,x=i;j<a[i].size();j++)
            {
                b[x].push_back(mkcp(a[i][j].y,a[i][j].c-d));
                b[a[i][j].y].push_back(mkcp(x,-(a[i][j].c-d)));
                d=a[i][j].c;
                x=a[i][j].y;
            }
        }

}

void up(int x)
{
    int ax;
    while (x/2>0 && D[H[x/2]]>D[H[x]])
    {
        swap(H[x],H[x/2]);
        Pos[H[x]]=x;
        Pos[H[x/2]]=x/2;
        x=x/2;
    }
}

void down(int x)
{
    int y=0;
    while (y!=x)
    {
        y=x;
        if (y*2<=L && D[H[y*2]]<D[H[x]]) x=y*2;
        if (y*2+1<=L && D[H[y*2+1]]<D[H[x]]) x=y*2+1;
        swap(H[x],H[y]);
        Pos[H[x]]=x;
        Pos[H[y]]=y;
    }
}

void cut()
{
    H[1]=H[L--];
    down(1);
}


void dijkstra()
{
    int i,j,x;

    for (i=1;i<=n;i++)
    {
        Pos[i]=i;
        D[i]=INF;
        H[i]=i;
    }
    L=n;

    D[st]=0;
    swap(H[1],H[st]);
    Pos[st]=1;
    Pos[1]=st;

    for (i=1;i<=n;i++)
    {
        x=H[1];
        cut();
        if (D[x]==INF) break;

        for (j=0;j<b[x].size();j++)
            if (D[b[x][j].y]==INF)
            {
                D[b[x][j].y]=b[x][j].c+D[x];
                up(Pos[b[x][j].y]);
            }
    }


}



int main()
{
    read();
    solve();
    dijkstra();

    fprintf(g,"%d",D[dr]);

	return 0;
}