#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#define MAXN 2020
#define MAXM 55000
#define INF 0x3f3f3f3f
using namespace std;

struct node
{
    int x, y, v;
}w[MAXM * 2];

int f[MAXN], n, m, s, t, maxE;
int dis[MAXN], map[MAXN][MAXN], vis[MAXN];

int
 
 cmp(node a, node b)
{
    return a.v < b.v;
}

int find(int x)
{
    return f[x] == x ? x : (f[x] = find(f[x]));
}

int cal()
{
    int me = 0;
    for(int i = 1; i <= n; i++) f[i] = i;
    sort(w, w + m, cmp);
    for(int i = 0; i < m; i++)
    {
        int x = find(w[i].x);
        int y = find(w[i].y);
        if
 
(x != y)
        {
            f[x] = y;
            me = max(me, w[i].v);
            if(find(s) == find(t))
            {
                return me;
            }
        }
    }
    return me;
}

int dijkstra()
{
    memset(vis, 0, sizeof(vis));
    memset(dis, 0x3f, sizeof(dis));
    for(int i = 1
 
; i <= n; i++)
    {
        if(map[s][i] > maxE) continue;
        dis[i] = map[s][i];
    }
    vis[s] = 1;
    dis[s] = 0;
    while(true)
    {
        int k = -1, mixv = INF;
        for(int i = 1; i <= n; i++)
        {
            if(!vis[i] && mixv > dis[i])
            {
                k = i;
                mixv = dis[i];
            }
        }
        if(k == -1) break;
        vis[k] = 1;
        for(int i = 1; i <= n; i++)
        {
            if(!vis[i] && (dis[i] > dis[k] + map[k][i]) && map[k][i] <= maxE)
            {
                dis[i] = dis[k] + map[k][i];
            }
        }
    }
    /*for(int i = 1; i <= n; i++)
    {
        printf("%d ", dis[i]);
    }
    printf("\n");*/
    return dis[t];
}

int main()
{
    while(scanf("%d%d%d%d", &n, &m, &s, &t) != EOF)
    {
        memset(map, 0x3f, sizeof(map));
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &w[i].x, &w[i].y, &w[i].v);
            if(w[i].v < map[w[i].x][w[i].y])
                map[w[i].x][w[i].y] = map[w[i].y][w[i].x] = w[i].v;
        }
        maxE = cal();
        //printf("%d\n", maxE);
        printf("%d\n", dijkstra());
    }
    return 0;
}
/**********************************************************************
	Problem: 1307
	User: 3901140225
	Language: C++
	Result: AC
	Time:112 ms
	Memory:19276 kb
**********************************************************************/

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<cmath>
using namespace std;

const int maxn = 100000 + 10;
const double INF = 1000000000 * 2.0;

struct Node {
    double x;
    double y;
    bool type;//0超人，1怪獸
}node[maxn],node2[maxn];
int n;

double Min(double a,double b)
{
    return a > b ? b : a;
}

double Count(Node a,Node b)
{
    return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}

double cmpX(Node a,Node b)
{
    return a.x < b.x;
}

double cmpY(Node a,Node b)
{
    return a.y < b.y;
}

double Clost(int begin,int end)
{
    if(begin + 1 == end && node[begin].type != node[end].type)
    {
        return Count(node[begin],node[end]);
    }
    else if(node[begin].type == node[end].type)
    {
        return INF;
    }
    if(begin + 2 == end)
    {
        int ans1 = INF;
        int ans2 = INF;
        int ans3 = INF;
        if(node[begin].type != node[end].type)
        {
            ans1 = Count(node[begin],node[end]);
        }
        if(node[begin+1].type != node[end].type)
        {
            ans2 = Count(node[begin+1],node[end]);
        }
        if(node[begin].type != node[begin+1].type)
        {
            ans3 = Count(node[begin],node[begin+1]);
        }
        return Min(ans1,Min(ans2,ans3));
    }
    int mid = (begin + end) / 2;
    double ans = Min(Clost(begin,mid),Clost(mid+1,end));
    int i;
    int cnt = 0;
    for(i=begin; i<=end; i++)
    {
        if(node[i].x >= node[mid].x - ans && node[i].x <= node[mid].x + ans)
        {
            node2[cnt++] = node[i];
        }
    }
    sort(node2,node2+cnt,cmpY);
    int j;
    for(i=0; i<cnt; i++)
    {
        for(j=i+1; j<cnt; j++)
        {
            if(node2[j].y - node2[i].y >= ans)
            {
                break;
            }
            if(node2[j].type != node2[i].type)
            {
                ans = Min(ans,Count(node2[i],node2[j]));
            }    
        }
    }
    return ans;
}

int main()
{
    int a;
    int b;
    while(scanf("%d%d%d",&n,&a,&b) != EOF)
    {
        int i;
        for(i=0; i<n; i++)
        {
            scanf("%lf%lf",&node[i].x,&node[i].y);
            node[i].type = 0;
        }
        for(i=n; i<2*n; i++)
        {
            scanf("%lf%lf",&node[i].x,&node[i].y);
            node[i].type = 1;
        }
        sort(node,node+n,cmpX);
        double ans = Clost(0,2*n-1);
        printf("%.3lf\n",ans/abs(a+b));
    }
    return 0;
}
/**********************************************************************
	Problem: 1309
	User: 3901140225
	Language: C++
	Result: AC
	Time:52 ms
	Memory:6728 kb
**********************************************************************/

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

struct node
{
    int num;
    int t;
} ans[30];

int cmp(node x,node y)//先按時間，在按序數
{
    if(x.t !=y.t)
        return x.t<y.t;
    return x.num<y.num;
}

int main()
{
    int n,i,j,sum,k;
    while(~scanf("%d",&n))
    {
        for(i = 0; i<n; i++)
        {
            scanf("%d",&ans[i].t);
            ans[i].num = i+1;
        }
        sort(ans,ans+n,cmp);
        sum = 0;
        k = 0;
        for(i = 0; i<n; i++)
        {
            if(k+ans[i].t>300)//總時間大於300則跳出
                break;
            k+=ans[i].t;
        }
        int f = i,tem = i;
        for(i = 0; i<f; i++)//計算罰時
        {
            sum += ans[i].t*tem--;
        }
        printf("%d %d\n",f,sum);
        for(i = 0; i<f; i++)
        {
            printf("%d\n",ans[i].num);
        }

    }

    return 0;
}
/**********************************************************************
	Problem: 1315
	User: 3901140225
	Language: C++
	Result: AC
	Time:4 ms
	Memory:1120 kb
**********************************************************************/