//Dijktras版本
#include <cstdio>
#include <vector>
#include<queue>
#include<algorithm>
using namespace std;
const int maxv = 1010,INF = 0x3fffffff;
int rnum[maxv]={0};
bool vis[maxv]{false};
int num[maxv]={0},rescum[maxv]={0};
int n,m,c1,c2;
struct node
{
    int x;
    int dis;
};
vector<node>G[maxv];

void Dij(int s)
{
    int d[maxv];
    fill(d,d+maxv,INF);

    num[s] = 1;
    rescum[s] = rnum[s];
    d[s] = 0;
    for(int i = 0;i<n;i++)
    {
        int u = -1,minn = INF;
        for(int j = 0;j<n;j++)
        {
            if(vis[j] == false && d[j] < minn)
            {
                u = j;
                minn = d[j];
            }
        }
        if(u == -1) break;
        vis[u] = true;
        for(int j = 0;j<G[u].size();j++)
        {
            int v = G[u][j].x;
            if(vis[v] == false)
            {
                if(d[v] > d[u] + G[u][j].dis)
                {
                    d[v] =d[u] + G[u][j].dis;
                    num[v] = num[u];
                    rescum[v] = rescum[u] + rnum[v];
                }
                else if(d[v] == d[u] + G[u][j].dis)
                {
                    num[v] += num[u];
                    if(rescum[u] + rnum[v] > rescum[v])
                        rescum[v] = rescum[u] + rnum[v];
                }

            }
        }


    }
}

int main()
{
//    freopen("in.txt","r",stdin);


    scanf("%d%d%d%d",&n,&m,&c1,&c2);
    for(int i = 0;i<n;i++)
    {
        scanf("%d",&rnum[i]);
    }
    for(int i = 0;i<m;i++)
    {
        int id1,id2,l;
        scanf("%d%d%d",&id1,&id2,&l);
        node s1,s2;
        s1.dis = l;
        s1.x = id2;
        G[id1].push_back(s1);
        s2.dis = l;
        s2.x = id1;
        G[id2].push_back(s2);
    }
    Dij(c1);
    printf("%d %d",num[c2],rescum[c2]);



}

//Bellman ford版本
#include <cstdio>
#include <queue>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <set>
using namespace std;
const int maxv = 1011,inf = 1<<30;

struct node
{
    int v;
    int dis;
};
vector<node>G[maxv];
int n,m,c1,c2,teamN[maxv]={0},d[maxv],ans[maxv],num[maxv];
set<int>pre[maxv];
bool Bellman(int s)
{
    fill(d,d+maxv,inf);
    fill(ans,ans+maxv,0);
    fill(num,num+maxv,0);
    d[s] = 0;
    ans[s] = teamN[s];
    num[s] = 1;
    for(int i = 0;i<n-1;i++)
    {
        for(int u = 0;u<n;u++)
        {
            for(int j = 0;j<G[u].size();j++)
            {
                int v = G[u][j].v;
                if(d[v] > d[u] + G[u][j].dis)
                {
                    d[v] = d[u] + G[u][j].dis;
                    ans[v] = ans[u] + teamN[v];
                    num[v] = num[u];
                    pre[v].clear();
                    pre[v].insert(u);
                }
                else if(d[v] == d[u] + G[u][j].dis )
                {
                    if(ans[v] < ans[u] + teamN[v])
                        ans[v] = ans[u] + teamN[v];
                    num[v] = 0;
                    pre[v].insert(u);
                    for(set<int>::iterator it = pre[v].begin();it!=pre[v].end();it++)
                    {
                        num[v] += num[*it];
                    }
                }
            }
        }
    }

    for(int u = 0;u<n;u++)
    {
        for(int j =0;j<G[u].size();j++)
        {
            int v = G[u][j].v;
            if(d[v] > G[u][j].dis + d[u])
                return false;
        }
    }
    return true;
}
vector<int>path;
//void DFS(int ed)
//{
//    if(ed == c1)
//    {
//        path.push_back(ed);
//        return;
//    }
//    path.push_back(ed);
//    DFS(pre[ed]);
//}

int main()
{
    freopen("1.txt","r",stdin);
    cin>>n>>m>>c1>>c2;
    for(int i = 0;i<n;i++)
    {
        cin>>teamN[i];
    }
    for(int i = 0;i<m;i++)
    {
        int id1,id2,l;
        cin>>id1>>id2>>l;
        node s;
        s.v = id2;
        s.dis = l;
        G[id1].push_back(s);
        s.v = id1;
        G[id2].push_back(s);
    }
    Bellman(c1);
//    DFS(c2);
//    cout<<<<"\n";
    cout<<num[c2]<<" "<<ans[c2];
//    for(int i = path.size() - 1;i>=0;i--)
//    {
//        cout<<path[i]<<" ";
//    }
    return 0;
}