Problem:


Problem 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. 

Input

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

t1 t2 ... tn

x1 y1 z1

x2 y2 z2

...

xp yp zp

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.
ti 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
xi and yi,
and has a distance zi (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.

Output

 
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.

Sample Input

3 4 3 1 4
3 1 2
1 2 10
2 3 30
3 4 20
2 4 4 2 1
3 1
2 3 3
1 3 3
4 1 2
4 2 5
2 4 3 4 1
5 5
1 2 10
2 3 10
3 4 10
1 2 0 1 2
1
8 5 10 1 5
2 7 1 8 4 5 6 3
1 2 5
2 3 4
3 4 7
4 5 3
1 3 25
2 4 23
3 5 22
1 4 45
2 5 51
1 5 99
0 0 0 0 0

Output for the Sample Input

30.000
3.667
Impossible
Impossible
2.856



Sample input:
3 4 3 1 4
3 1 2
1 2 10
2 3 30
3 4 20
2 4 4 2 1
3 1
2 3 3
1 3 3
4 1 2
4 2 5
2 4 3 4 1
5 5
1 2 10
2 3 10
3 4 10
1 2 0 1 2
1
8 5 10 1 5
2 7 1 8 4 5 6 3
1 2 5
2 3 4
3 4 7
4 5 3
1 3 25
2 4 23
3 5 22
1 4 45
2 5 51
1 5 99
0 0 0 0 0


Sample output:
30.000
3.667
Impossible
Impossible
2.856

Submission status: Wrong Answer

Solution code:
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")

Submission status: Time Limit Exceeded

Solution code:

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)
    edges = [ Edge(input().split()) for i in range(p) ]

    # print(tickets)

    result = (a, [a], [], float('inf'))

    if p == 0:
        print("Impossible")
        continue

    q = [ (e.other_side(a), [a, e.other_side(a)], [e.dist], calc_cost([e.dist], tickets)) for e in edges if e.isConnect(a) ]

    while len(q) != 0:
        now = q.pop()

        # print("now: ", now)

        # ?????±????????°????¶?????????´???
        if len(now[1]) - 1 > n:
            continue

        # ??????????????????????????£?????´???
        if now[0] == b and now[3] < result[3]:
            result = now

        q.extend([ (e.other_side(now[0]), now[1] + [e.other_side(now[0])], now[2] + [e.dist],  calc_cost(now[2] + [e.dist], tickets))
            for e in edges if e.isConnect(now[0]) and e.other_side(now[0]) not in now[1] ])

    if result[0] == b:
        print(result[3])
    else:
        print("Impossible")

Submission status: Time Limit Exceeded

Solution code:
# -*- coding: utf-8 -*-

import sys

'''

'''


def func():
    '''

    '''

    def dfs(result, current, visited, used, road, end):
        # print current, visited, used

        if current == end:
            #print visited
            if len(used) < len(visited) - 1:
                return 10000
                
            dist = []
            
            for i in range(len(visited) - 1):
                dist.append(road[visited[i]][visited[i+1]])
            dist.sort()
            dist.reverse()
                

            for i in range(len(dist)):
                dist[i] = float(dist[i]) / used[i]
            #print dist

            if sum(dist) < result:
                return sum(dist)
            else:
                return result



        for j in range(m):
            if road[current][j] < 10000 and (not j in visited):
                res = dfs(result, j, visited + [j], used, road, end)
                if res == 10000:
                    continue
                else:
                    return res
        else:
            return 10000

    while True:
        n, m, p, a, b = map(int, raw_input().split())
        if n == 0 and m == 0 and p == 0 and a == 0 and b == 0:
            break

        t = map(int, raw_input().split())
        t.sort()
        t.reverse()

        road = [[10000 for j in range(m)] for i in range(m)]
        for i in range(p):
            x, y, z = map(int, raw_input().split())

            road[x-1][y-1] = z

            road[y-1][x-1] = z

        res = dfs(10000, a-1, [a-1], t, road, b-1)
        
        if res == 10000:
            print 'Impossible'
        else:
            print res

if __name__ == '__main__':
    func()

Submission status: Memory Limit Exceeded

Solution code:
from queue import Queue

while True:
    n, m, p, a, b = map(int, input().split())
    if n == 0:
        exit()
    a -= 1
    b -= 1
    adj = [[0] * 31 for _ in range(31)]
    t = list(map(int, input().split()))
    for i in range(p):
        x, y, z = map(int, input().split())
        x -= 1
        y -= 1
        adj[x][y] = z
        adj[y][x] = z
    
    paths = []
    q = Queue()
    q.put([a])
    while not q.empty():
        path = q.get()
        u = path[-1]
        if u == b:
            paths.append(path)
        for v in range(31):
            if v not in path and adj[u][v] > 0:
                q.put(path + [v])

    ans = 10**9
    t.sort(reverse=True)
    for path in paths:
        li = []
        for i in range(len(path) - 1):
            frm = path[i]
            to = path[i + 1]
            li.append(adj[frm][to])
        
        if len(t) < len(li):
            continue
        
        li.sort(reverse=True)
        tmp = 0
        for i in range(len(li)):
            tmp += li[i] / t[i]

        if tmp == 0:
            continue

        ans = min(ans, tmp)
    
    if ans == 10**9:
        print('Impossible')
    else:
        print(ans)

Submission status: Accepted

Solution code:
INF = 10 ** 20

def search(rest, now, goal, dp, edges):
  if now == goal:
    return 0
  if rest == ():
    if now == goal:
      return 0
    else:
      return INF

  if (rest, now) in dp:
    return dp[(rest, now)]

  ret = INF
  for i, t in enumerate(rest):
    for dist, to in edges[now]:
      ret = min(ret, search(tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges) + dist / t)
  dp[(rest, now)] = ret
  return ret

while True:
  n, m, p, a, b = map(int, input().split())
  if n == 0:
    break
  a -= 1
  b -= 1
  tlst = list(map(int, input().split()))
  edges = [[] for _ in range(m)]
  for _ in range(p):
    x, y, z = map(int, input().split())
    x -= 1
    y -= 1
    edges[x].append((z, y))
    edges[y].append((z, x))
  tlst.sort()
  rest = tuple(tlst)
  dp = {}
  ans = search(rest, a, b, dp, edges)
  if ans == INF:
    print("Impossible")
  else:
    print(ans)

Submission status: Accepted

Solution code:
INF = 10 ** 20

def search(rest, now, goal, dp, edges):
  if now == goal:
    return 0
  if rest == ():
    if now == goal:
      return 0
    else:
      return INF

  if (rest, now) in dp:
    return dp[(rest, now)]

  ret = INF
  for i, t in enumerate(rest):
    for dist, to in edges[now]:
      ret = min(ret, search(tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges) + dist / t)
  dp[(rest, now)] = ret
  return ret

def main():
  while True:
    n, m, p, a, b = map(int, input().split())
    if n == 0:
      break
    a -= 1
    b -= 1
    tlst = list(map(int, input().split()))
    edges = [[] for _ in range(m)]
    for _ in range(p):
      x, y, z = map(int, input().split())
      x -= 1
      y -= 1
      edges[x].append((z, y))
      edges[y].append((z, x))
    tlst.sort()
    rest = tuple(tlst)
    dp = {}
    ans = search(rest, a, b, dp, edges)
    if ans == INF:
      print("Impossible")
    else:
      print(ans)
main()

Submission status: Accepted

Solution code:
INF = 10 ** 20

def search(rest, now, goal, dp, edges):
  if now == goal:
    return 0
  if rest == ():
    if now == goal:
      return 0
    else:
      return INF

  if (rest, now) in dp:
    return dp[(rest, now)]

  ret = INF
  for i, t in enumerate(rest):
    for dist, to in edges[now]:
      tmp = search(tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges) + dist / t
      if ret > tmp:
        ret = tmp
  dp[(rest, now)] = ret
  return ret

def main():
  while True:
    n, m, p, a, b = map(int, input().split())
    if n == 0:
      break
    a -= 1
    b -= 1
    tlst = list(map(int, input().split()))
    edges = [[] for _ in range(m)]
    for _ in range(p):
      x, y, z = map(int, input().split())
      x -= 1
      y -= 1
      edges[x].append((z, y))
      edges[y].append((z, x))
    tlst.sort()
    rest = tuple(tlst)
    dp = {}
    ans = search(rest, a, b, dp, edges)
    if ans == INF:
      print("Impossible")
    else:
      print(ans)
main()

Submission status: Accepted

Solution code:
INF = 10 ** 20

def search(rest, now, goal, dp, edges):
  if now == goal:
    return 0
  if rest == ():
    return INF

  if (rest, now) in dp:
    return dp[(rest, now)]

  ret = INF
  for i, t in enumerate(rest):
    for dist, to in edges[now]:
      tmp = search(tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges) + dist / t
      if ret > tmp:
        ret = tmp
  dp[(rest, now)] = ret
  return ret

def main():
  while True:
    n, m, p, a, b = map(int, input().split())
    if n == 0:
      break
    a -= 1
    b -= 1
    tlst = list(map(int, input().split()))
    edges = [[] for _ in range(m)]
    for _ in range(p):
      x, y, z = map(int, input().split())
      x -= 1
      y -= 1
      edges[x].append((z, y))
      edges[y].append((z, x))
    tlst.sort()
    rest = tuple(tlst)
    dp = {}
    ans = search(rest, a, b, dp, edges)
    if ans == INF:
      print("Impossible")
    else:
      print(ans)
main()

Submission status: Accepted

Solution code:
# AOJ 1138: Traveling by Stagecoach
# Python3 2018.7.15 bal4u

INF = 0x7fffffff
import heapq
def dijkstra(V, start, goal, to, ti):
	n = len(ti)
	node = [[INF for j in range(1<<n)] for i in range(V)]
	Q = []
	heapq.heappush(Q, (0, start, 0))
	while Q:
		t, s, c = heapq.heappop(Q)
		for i in range(n):
			if c & (1<<i): continue
			nc = c|(1<<i)
			for e, cost in to[s]:
				nt = t + cost/ti[i]
				if node[e][nc] > nt:
					node[e][nc] = nt
					heapq.heappush(Q, (nt, e, nc))
	return node[goal]
	
while True:
	N, M, P, A, B = map(int, input().split())
	if N == 0: break
	A -= 1; B -= 1
	ti = list(map(int, input().split()))
	to = [[] for i in range(M)]
	for i in range(P):
		x, y, z = map(int, input().split())
		x -= 1; y -= 1
		to[x].append((y, z))
		to[y].append((x, z))
	node = dijkstra(M, A, B, to, ti)
	ans = INF
	for i in range(1<<N): ans = min(ans, node[i])
	print(ans if ans < INF else "Impossible")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    dp = [[float("inf")] * M for _ in range(1 << N)]
    dp[0][A] = 0
    D = [[float('inf')] * M for _ in range(M)]
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        D[s][t] = D[t][s] = c

    for state in range(1 << N):
        for i in range(M):
            for j in range(M):
                for k in range(N):
                    if not (state >> k & 1):
                        next_s = state | (1 << k)
                        dp[next_s][j] = min(dp[next_s][j], dp[state][i] + D[i][j] / T[k])
    ans = float('inf')
    for state in range(1 << N):
        ans = min(ans, dp[state][B])
    print("Impossible" if ans == float("inf") else "{:.020f}".format(ans))

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    dp = [[float("inf")] * M for _ in range(1 << N)]
    dp[0][A] = 0
    edges = []
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        edges.append((s, t, c))
        edges.append((t, s, c))

    for state in range(1 << N):
        for s, t, c in edges:
            for k in range(N):
                if not (state >> k & 1):
                    next_s = state | (1 << k)
                    dp[next_s][t] = min(dp[next_s][t], dp[state][s] + c / T[k])
    ans = float('inf')
    for state in range(1 << N):
        ans = min(ans, dp[state][B])
    print("Impossible" if ans == float("inf") else "{:.020f}".format(ans))

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    dp = [[float("inf")] * M for _ in range(1 << N)]
    dp[0][A] = 0
    edges = []
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        edges.append((s, t, c))
        edges.append((t, s, c))
    ans = float('inf')
    for state in range(1 << N):
        for s, t, c in edges:
            for k in range(N):
                if not (state >> k & 1):
                    next_s = state | (1 << k)
                    dp[next_s][t] = min(dp[next_s][t], dp[state][s] + c / T[k])
            if t == B and dp[state][t] < ans:
                ans = dp[state][t]
    print("Impossible" if ans == float("inf") else "{:.020f}".format(ans))

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    dp = [[float("inf")] * M for _ in range(1 << N)]
    dp[0][A] = 0
    edges = []
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        edges.append((s, t, c))
        edges.append((t, s, c))
    ans = float('inf')
    for state in range(1 << N):
        for s, t, c in edges:
            for k in range(N):
                if not (state >> k & 1):
                    next_s = state | (1 << k)
                    dp[next_s][t] = min(dp[next_s][t], dp[state][s] + c / T[k])
    ans = min(dp[state][B] for state in range(1 << N))
    print("Impossible" if ans == float("inf") else "{:.010f}".format(ans))

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    dp = [[float("inf")] * M for _ in range(1 << N)]
    dp[0][A] = 0
    edges = []
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        edges.append((s, t, c))
        edges.append((t, s, c))
    ans = float('inf')
    for state in range(1 << N):
        for s, t, c in edges:
            for k in range(N):
                if state >> k & 1:
                    dp[state][t] = min(dp[state][t], dp[state & ~(1 << k)][s] + c / T[k])
    ans = min(dp[state][B] for state in range(1 << N))
    print("Impossible" if ans == float("inf") else "{:.05f}".format(ans))

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    dp = [[float("inf")] * M for _ in range(1 << N)]
    dp[0][A] = 0
    edges = []
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        edges.append((s, t, c))
        edges.append((t, s, c))
    ans = float('inf')
    for state in range(1 << N):
        for s, t, c in edges:
            for k in range(N):
                if state >> k & 1 and dp[state][t] > dp[state & ~(1 << k)][s] + c / T[k]:
                    dp[state][t] = dp[state & ~(1 << k)][s] + c / T[k]
    ans = min(dp[state][B] for state in range(1 << N))
    print("Impossible" if ans == float("inf") else "{:.05f}".format(ans))

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    dp = [[float("inf")] * M for _ in range(1 << N)]
    dp[0][A] = 0
    edges = []
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        edges.append((s, t, c))
        edges.append((t, s, c))
    ans = float('inf')
    for state in range(1 << N):
        for s, t, c in edges:
            for k in range(N):
                if state >> k & 1 and dp[state][t] > dp[state & ~(1 << k)][s] + c / T[k]:
                    dp[state][t] = dp[state & ~(1 << k)][s] + c / T[k]
    ans = min(dp[state][B] for state in range(1 << N))
    print("Impossible" if ans == float("inf") else "{:.04f}".format(ans))

Submission status: Accepted

Solution code:
while True:
    N, M, P, A, B = map(int, input().split())
    if not (N | M | P | A | B):
        break
    A, B = A - 1, B - 1
    T = [int(x) for x in input().split()]
    INF = 1000
    dp = [[INF] * M for _ in range(1 << N)]
    dp[0][A] = 0
    edges = []
    for _ in range(P):
        s, t, c = map(int, input().split())
        s, t = s - 1, t - 1
        edges.append((s, t, c))
        edges.append((t, s, c))
    ans = INF
    for state in range(1 << N):
        for s, t, c in edges:
            for k in range(N):
                if state >> k & 1 and dp[state][t] > dp[state & ~(1 << k)][s] + c / T[k]:
                    dp[state][t] = dp[state & ~(1 << k)][s] + c / T[k]
    ans = min(dp[state][B] for state in range(1 << N))
    print("Impossible" if ans == INF else "{:.05f}".format(ans))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
from heapq import heappop, heappush
def inpl(): return list(map(int, input().split()))
N, M, P, A, B = inpl()
INF = 10**6

while N:
    T = inpl()
    G = [[] for _ in range(M+1)]
    D = [2**i for i in range(N)]

    for _ in range(P):
        x, y, z = inpl()
        G[x].append([y, z])
        G[y].append([x, z])
    HQ = [[0, A, 0]] # time, where, used_ticket
    memo = [[INF]*(2**N) for _ in range(M+1)]

    while HQ:
        t, p, u = heappop(HQ)
        if memo[p][u] < t:
            continue
        if p == B:
            print(t)
            break
        for q, c in G[p]:
            for i in range(N):
                nu = u&D[i]
                if u&D[i] == 0 and t + c/T[i] < memo[q][u^D[i]]:
                    memo[q][u^D[i]] = t + c/T[i]
                    heappush(HQ, [t + c/T[i], q, u^D[i]])
    else:
        print("Impossible")
    N, M, P, A, B = inpl()

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

def main():
    rr = []


    while True:
        n,m,p,s,t = LI()
        if m == 0:
            break
        ta = LI()
        e = collections.defaultdict(list)
        for _ in range(p):
            a,b,c = LI()
            e[a].append((b,c))
            e[b].append((a,c))

        def search(s):
            d = collections.defaultdict(lambda: inf)
            d[s] = 0
            q = []
            heapq.heappush(q, (0, s))
            v = collections.defaultdict(bool)
            while len(q):
                k, u = heapq.heappop(q)
                if v[u]:
                    continue
                if u[0] == t:
                    return d
                v[u] = True
                if len(u[1]) == 0:
                    continue

                for uu, ud in e[u[0]]:
                    for i in range(len(u[1])):
                        uv = (uu, tuple(u[1][:i] + u[1][i+1:]))
                        if v[uv]:
                            continue
                        vd = k + ud / u[1][i]
                        if d[uv] > vd:
                            d[uv] = vd
                            heapq.heappush(q, (vd, uv))

            return d

        d = search((s,tuple(ta)))
        r = inf
        for k,v in d.items():
            if k[0] == t and r > v:
                r = v

        if r == inf:
            r = 'Impossible'
        else:
            r = '{:0.99999f}'.format(r)
        rr.append(r)

    return '\n'.join(map(str, rr))



print(main())

Submission status: Accepted

Solution code:

import heapq

def main():

    n,v,e,a,b = 0,0,0,0,0
    g = []
    t = []
    inf = (1<<32)-1

    def solve():
        d = [[inf]*(1<<n) for _ in range(v)]
        pq = [[0.0,a,0]]
        d[a][0] = 0.0
        heapq.heapify(pq)
        while pq:
            cost,ver,bits = heapq.heappop(pq)
            if d[ver][bits] < cost:continue
            if ver == b:return cost

            for i in range(len(g[ver])):
                n_ver = g[ver][i][0]
                for j in range(n):
                    if bits&(1<<j):continue
                    n_bits = bits|(1<<j)
                    n_cost = cost+g[ver][i][1]/t[j]
                    if n_cost < d[n_ver][n_bits]:
                        d[n_ver][n_bits] = n_cost
                        heapq.heappush(pq,[n_cost,n_ver,n_bits])
        return 'Impossible'

    while True:
        n,v,e,a,b = map(int,input().split())
        if n == 0:break
        a -= 1
        b -= 1
        t = list(map(int,input().split()))
        g = [[] for _ in range(v)]
        for _ in range(e):
            x,y,d = map(int,input().split())
            g[x-1].append([y-1,d])
            g[y-1].append([x-1,d])
        print(solve())


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(input())
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

def cal(bit,i):
    return bit*N + i


def dijkstra(lines,N,s):
    weight = [INF]*N
    weight[s] = 0
    def search(s,w_0,q,weight):
        for t,w in lines[s]:
            w += w_0
            if weight[t] > w:
                heapq.heappush(q,[w,t])
                weight[t] = w
    q = [[0,s]]
    heapq.heapify(q)
    while q:
        w,n = heapq.heappop(q)
        search(n,w,q,weight)
    return weight

while True:
    L,N,M,S,T = inpl()
    if N == 0 and M == 0:
        break
    tt = inpl()
    S -= 1
    T -= 1
    lines = defaultdict(set)
    for _ in range(M):
        x,y,z = inpl()
        x,y = x-1,y-1
        lines[x].add((y,z))
        lines[y].add((x,z))

    lines2 = defaultdict(set)
    for s in range(N):
        for bit in range(1<<L):
            val_s = cal(bit,s)
            for b in range(L):
                if bit&(1<<b): # b番目の馬券を持ってる
                    bbit = bit - (1<<b)
                    for t,c in lines[s]:
                        val_t = cal(bbit,t)
                        #print(bin(bit),s,'->',bin(bbit),t,'  ',c/tt[b])
                        lines2[val_s].add((val_t,c/tt[b]))

    weights = dijkstra(lines2,(1<<L)*N,cal((1<<L)-1,S))
    ans = INF
    for bit in range(1<<L):
        ans = min(ans,weights[cal(bit,T)])

    if ans == INF:
        print('Impossible')
    else:
        print(ans)