#include <stdio.h>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <sstream>
#include <cstring>

using namespace std;

#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) (EQ((a).real(),(b).real()) && EQ((a).imag(),(b).imag()))

typedef long long ll;

const int MAX_SIZE = 10000;

//struct edge{
//	int to;
//	int head;
//};

//vector<edge> G[31];

int d[31][31];
const int INF=10000000;

int main(){
	int n,m,p,a,b;
	while((cin >> n >> m >> p >> a >> b) && !(n == 0 && m == 0 && p == 0 && a == 0 && b == 0)){
		int tickets[10];
		for(int i = 0; i < n; i++)
			cin>>tickets[i];
		a--;
		b--;
		for(int i = 0; i < 31; i++)
			for(int j = 0; j < 31; j++)
				d[i][j]=-INF;
		for(int i = 0; i < p; i++){
			int from,to,dist;
			cin>>from>>to>>dist;
			from--;
			to--;
			d[from][to]=dist;
			d[to][from]=dist;
		}
		double dp[31][1<<8];
		int s=0;
		for(int i = 0; i < n; i++){
			if(tickets[i])
				s|=(1<<i);
		}

		for(int i = 0; i < 31; i++)
			for(int j = 0; j < (1<<8); j++)
				dp[i][j]=INF;

		dp[a][(1<<n)-1]=0;
		for(int S=(1<<n)-1; S >=0; S--){
			for(int u = 0; u < m; u++){
				for(int i = 0; i < n; i++){
					if(!(S&(1<<i)))
						continue;
					for(int v = 0; v < m; v++){
						if(u==v||d[u][v]<0) continue;
						if(u==a){
					//		cout<<endl;
						}
						dp[v][S&~(1<<i)]=min(dp[v][S&~(1<<i)],dp[u][S]+(double)d[u][v]/tickets[i]);
					}
				}
			}
		}
		double minDist=INF;
		for(int i = 0; i < (1<<n); i++){
			minDist=min(minDist,dp[b][i]);
		}
		if(EQ(minDist,INF))
			cout<<"Impossible"<<endl;
		else
			printf("%.6f\n",minDist);
	}

	return 0;
}

//struct edge{
//	int to;
//	double cost;
//	int kipKind;
//};
//
//// ツノツーツドツづ個暗環置
//vector<edge> G[31][256];
//double d[31][256];
//const int INF = 1000000000;
//
//
//class Situation{
//public:
//	Situation(double _cost,int _node,int _used){
//		cost = _cost;
//		node = _node;
//		used = _used;
//	}
//
//	Situation();
//
//	double cost;
//	int node;
//	int used;
//
//	bool operator<(const Situation &sit)const{
//		return sit.cost < (this->cost);
//	}
//};
//
//void dijkstra(int s,int g){
//	priority_queue<Situation> que;
//
//	for(int i = 0; i < 31; i++)
//		fill(d[i],d[i]+256,INF);
//	d[s][0] = 0;
//
//	que.push(Situation(0.0,s,0));
//	while(!que.empty()){
//
//		Situation p = que.top();
//		que.pop();
//		int v = p.node;
//		int used = p.used;
//		if(d[v][used] < p.cost)
//			continue;
//		for(int i = 0; i < G[v][used].size(); i++){
//			edge e = G[v][used][i];
//			if(d[e.to][used | (1 << e.kipKind)] > d[v][used] + e.cost){
//
//					d[e.to][used | (1 << e.kipKind)] = d[v][used] + e.cost;
//				que.push(Situation(d[e.to][used | (1 << e.kipKind)],e.to,(used | (1 << e.kipKind))));
//			}
//		}
//
//	}
//	double minCost = INF;
//
//
//	for(int i = 0; i < 256; i++){
//		minCost = min(minCost,d[g][i]);
//	}
//	if(minCost != INF)
//		cout << minCost << endl;
//	else
//		cout << "Impossible" << endl;
//}
//
//int main(){
//
//
//	int n,m,p,a,b;
//	int cnt=0;
//	while((cin >> n >> m >> p >> a >> b) && !(n == 0 && m == 0 && p == 0 && a == 0 && b == 0)){
//		int tickets[10];
//		for(int i = 0; i < n; i++)
//			cin >> tickets[i];
//		for(int i = 0; i < 31; i++)
//			for(int j = 0; j < 256; j++)
//				G[i][j].clear();
//
//		cnt++;
//		for(int i = 0; i < p; i++){
//			int to,from,cost;
//			cin >> from >> to >> cost;
//			from--;
//			to--;
//			for(int j = 0; j < (1 << n); j++){
//				for(int k = 0; k < n; k++){
//					// connect
//					edge e;
//					e.to = to;
//					e.cost = (double)cost/tickets[k];
//					e.kipKind = k;
//					if(((j >> k) & 1) == 0){
//						G[from][j].push_back(e);
//						e.to = from;
//						G[to][j].push_back(e);
//					}
//				}
//			}
//		}
//		if(cnt==2){
//			cout<<endl;
//		}
//		dijkstra(a-1,b-1);
//	}
//	
//	return 0;
//}

Measured memory_bytes: 992