output_description: For each dataset in the input, one line should be output as specified below.
  An output line should not contain extra characters such as spaces.
  
  If the traveler can reach the destination, the time needed for the best route
  (a route with the shortest time) should be printed. The answer should not have
  an error greater than 0.001. You may output any number of digits after the
  decimal point, provided that the above accuracy condition is satisfied.
  
  If the traveler cannot reach the destination, the string "`Impossible`" should
  be printed. One cannot reach the destination either when there are no routes
  leading to the destination, or when the number of tickets is not sufficient.
  Note that the first letter of "`Impossible`" is in uppercase, while the other
  letters are in lowercase.
input_description: The input consists of multiple datasets, each in the following format. The
  last dataset is followed by a line containing five zeros (separated by a
  space).
  
  > _n m p a b_  
  >  _t_ 1 _t_ 2 ... _t n_  
  >  _x_ 1 _y_ 1 _z_ 1  
  >  _x_ 2 _y_ 2 _z_ 2  
  >  ...  
  >  _x p_ _y p_ _z p_  
  >
  
  Every input item in a dataset is a non-negative integer. If a line contains
  two or more input items, they are separated by a space.
  
  _n_ is the number of coach tickets. You can assume that the number of tickets
  is between 1 and 8. _m_ is the number of cities in the network. You can assume
  that the number of cities is between 2 and 30. _p_ is the number of roads
  between cities, which may be zero.
  
  _a_ is the city index of the starting city. _b_ is the city index of the
  destination city. _a_ is not equal to _b_. You can assume that all city
  indices in a dataset (including the above two) are between 1 and _m_.
  
  The second line of a dataset gives the details of coach tickets. _t i_ is the
  number of horses specified in the _i_ -th coach ticket (1<=_i_ <=_n_). You can
  assume that the number of horses is between 1 and 10.
  
  The following _p_ lines give the details of roads between cities. The _i_ -th
  road connects two cities with city indices _x i_ and _y i_, and has a distance
  _z i_ (1<=_i_ <=_p_). You can assume that the distance is between 1 and 100.
  
  No two roads connect the same pair of cities. A road never connects a city
  with itself. Each road can be traveled in both directions.
attempt: from collections import defaultdict
  
  
  class Edge:
      def __init__(self, inputs):
          start, end, self.dist = [int(i) for i in inputs]
          self.nodes = [start, end]
  
      def isConnect(self, node):
          return node in self.nodes
  
      def other_side(self, node):
          if self.nodes[0] == node:
              return self.nodes[1]
          else:
              return self.nodes[0]
  
      def __str__(self):
          return "%d - %d (%d)" % (self.nodes[0], self.nodes[1], self.dist)
  
  
  def calc_cost(list, tickets):
      s_list = sorted(list, reverse=True)
      return sum(c / t for c, t in zip(s_list, tickets))
  
  
  while True:
      n, m, p, a, b = [int(i) for i in input().split()]
  
      print("ticktes: %d, m: %d, edge_num: %d, %d -> %d)" % (n, m, p, a, b))
  
      if n == m == p == a == b == 0:
          quit()
  
      tickets = sorted([int(i) for i in input().split()], reverse=True)
  
      e = defaultdict(list)
  
      for i in range(p):
          start, end, cost = [int(i) for i in input().split()]
          e[start].append((end, cost))
          e[end].append((start, cost))
  
      m_cost = defaultdict(lambda: float("inf"))
  
      # edges = [ Edge(input().split()) for i in range(p) ]
  
      # print(tickets)
  
      result = (a, [a], [], float("inf"))
  
      if p == 0:
          print("Impossible")
          continue
  
      q = [(e[0], [a, e[0]], [e[1]], calc_cost([e[1]], tickets)) for e in e[a]]
  
      while len(q) != 0:
          now = q.pop()
  
          # print("now: ", now)
  
          # ?????±????????°????¶?????????´???
          if len(now[1]) - 1 > n:
              continue
  
          if m_cost[now[0]] < now[3]:
              continue
          else:
              m_cost[now[0]] = now[3]
  
          # ??????????????????????????£?????´???
          if now[0] == b and now[3] < result[3]:
              result = now
  
          q.extend(
              [
                  (
                      e[0],
                      now[1] + [e[0]],
                      now[2] + [e[1]],
                      calc_cost(now[2] + [e[1]], tickets),
                  )
                  for e in e[now[0]]
                  if e[0] not in now[1]
              ]
          )
  
      if result[0] == b:
          print(result[3])
      else:
          print("Impossible")
  
problem_description: D: Traveling by Stagecoach
  
  Once upon a time, there was a traveler.
  
  He plans to travel using stagecoaches (horse wagons). His starting point and
  destination are fixed, but he cannot determine his route. Your job in this
  problem is to write a program which determines the route for him.
  
  There are several cities in the country, and a road network connecting them.
  If there is a road between two cities, one can travel by a stagecoach from one
  of them to the other. A coach ticket is needed for a coach ride. The number of
  horses is specified in each of the tickets. Of course, with more horses, the
  coach runs faster.
  
  At the starting point, the traveler has a number of coach tickets. By
  considering these tickets and the information on the road network, you should
  find the best possible route that takes him to the destination in the shortest
  time. The usage of coach tickets should be taken into account.
  
  The following conditions are assumed.
  
    * A coach ride takes the traveler from one city to another directly connected by a road. In other words, on each arrival to a city, he must change the coach. 
    * Only one ticket can be used for a coach ride between two cities directly connected by a road. 
    * Each ticket can be used only once. 
    * The time needed for a coach ride is the distance between two cities divided by the number of horses. 
    * The time needed for the coach change should be ignored.
samples: [{"input": "4 3 1 4\n    3 1 2\n    1 2 10\n    2 3 30\n    3 4 20\n    2 4 4 2 1\n    3 1\n    2 3 3\n    1 3 3\n    4 1 2\n    4 2 5\n    2 4 3 4 1\n    5 5\n    1 2 10\n    2 3 10\n    3 4 10\n    1 2 0 1 2\n    1\n    8 5 10 1 5\n    2 7 1 8 4 5 6 3\n    1 2 5\n    2 3 4\n    3 4 7\n    4 5 3\n    1 3 25\n    2 4 23\n    3 5 22\n    1 4 45\n    2 5 51\n    1 5 99\n    0 0 0 0 0", "output": ".000\n    3.667\n    Impossible\n    Impossible\n    2.856"}]