/*
 *  James Bond (via mjd@cs.auckland.ac.nz)
 */
#include <iostream>
#include <vector>
#include <queue>
#include <sstream>
#include <assert.h>

using namespace std;

typedef vector<int> NLIST;    		// node (neighbor) list
typedef vector< NLIST > ADJLIST;  	// graph data structure

const static int MAXNODES=100;
const static int LLEN=1024;
const static int BIGINT=0xFFFFFFF;
static int N, M, S, T;  // global game parameters

class Game
{
  public:  

   ADJLIST adj;
   NLIST bomb;  
   int adjCost[MAXNODES][MAXNODES];
  
   // creators + destroyers
   //
   Game(int n = 0 ) : adj(n), bomb(n) { }
   ~Game() {}

   // stream I/0
   //
   friend ostream& operator<<(ostream&, const Game&);
   friend istream& operator>>(istream&, Game&);

   int order() const 	// number of vertices
   { return adj.size(); }

   int edgeCost(int u, int v) const
   {
     int n = order();
     assert(u >= 1 && u <= n);
     assert(v >= 1 && v <= n);
     assert(u != v);
     assert(adjCost[u-1][v-1]==adjCost[v-1][u-1]);
  
     return adjCost[u-1][v-1];
   }

   bool addEdge(int u, int v, int t)  // false if already exists
   {
     if ( edgeCost(u, v) > 0 ) { assert(false); return false; }
  
     adj[u-1].push_back(v-1);
     adj[v-1].push_back(u-1);
     adjCost[u-1][v-1] = adjCost[v-1][u-1] = t;
     return true;
   }

   int degree(int u) const
   {
     return adj[u-1].size();
   }
};

ostream& operator<<(ostream& o, const Game& G)
{
  int n=G.order();
  o << n << "\n";
  for (int i=0; i<n; i++) 
  {
    o << i+1 << " (" << G.bomb[i] << ") : ";
    for (int j=0; j<G.adj[i].size(); j++) 
       o << G.adj[i][j]+1 << "(" << G.adjCost[i][G.adj[i][j]] << ") ";
    o << "\n";
  }
  return o;
}

//
istream& operator>>(istream& in, Game& G) 
{
   char line[LLEN];
   in.getline(line, LLEN);
   istringstream lineIn(line);
   lineIn >> N >> M >> S >> T;
   
   G.adj.resize(N); G.bomb.resize(N);

   // get nodes
   for (int i=0; i<N; i++) 
   {
     in.getline(line, LLEN);
     istringstream lineIn(line);

     int b; lineIn >> b; G.bomb[i] = (b==0 ? BIGINT : b);
     G.adj[i].resize(0);
     for (int j=0; j<N; j++) G.adjCost[i][j]=0;
   }

   // get edges
   for (int e=0; e<M; e++)
   {
      in.getline(line, LLEN);    
//      cerr << line << endl;
      istringstream lineIn(line);

      int v1, v2, t; lineIn >> v1 >> v2 >> t;
      G.addEdge(v1,v2,t);
   }
   return in;
}


int main()
{
  Game G;

  while (true)
  {
    cin >> G;
    int n = G.order();
    if (n==0) break; 
#ifdef DEBUG
cerr << G;
#endif
    NLIST reach(n);  
 
    for (int i=0; i<n; i++) reach[i]=BIGINT;
    reach[S-1] = 0;

    // dijkstra type alg.
    int minNextNode, minSrc, minDest;
    //
    do {
       minNextNode = BIGINT;
   
       for (int i=0; i<n; i++)
       {
         if (reach[i]==BIGINT) continue;

         for (int j=0; j<G.adj[i].size(); j++)
         {
           int dest = G.adj[i][j];
#ifdef DEBUG
cerr << "src =" << i << " dest =" << dest << endl;
#endif
           if (reach[dest]<BIGINT) continue;
           if (reach[i]+G.edgeCost(i+1,dest+1) < minNextNode &&
               reach[i]+G.edgeCost(i+1,dest+1) < G.bomb[dest])
           {
             minNextNode = reach[i]+G.edgeCost(i+1,dest+1);
             minSrc = i; minDest = dest;
           }
#ifdef DEBUG
cerr << minNextNode << ' ' <<  minSrc << ' ' << minDest << endl;
#endif
         }
       }
       if (minNextNode < BIGINT) 
       {
         reach[minDest] = minNextNode;
         if (minDest==T-1) { minNextNode=BIGINT; break; }
       }
    } while (minNextNode < BIGINT);
  
    if (reach[T-1] < BIGINT) cout << reach[T-1] << endl;
    else cout << "0\n";
  }
}