from collections import defaultdict
H_dist ={}
def aStarAlgo(start_node, stop_node):
    open_set = set(start_node)
    closed_set = set()
    g = {}               # store distance from starting node
    parents = {}         # parents contains an adjacency map of all nodes
    #distance of starting node from itself is zero
    g[start_node] = 0  #start_node is root node i.e it has no parent nodes
    parents[start_node] = start_node #so start_node is set to its own parent node
    while len(open_set) > 0:
        n = None #node with lowest f() is found
        for v in open_set:
            if n == None or g[v] + heuristic(v) < g[n] + heuristic(n):
                n = v
        if n == stop_node or Graph_nodes[n] == None:
            pass
        else:
            for (m, weight) in get_neighbors(n): #nodes 'm' not in first and last set are added to first
                if m not in open_set and m not in closed_set: #n is set its parent
                    open_set.add(m)
                    parents[m] = n
                    g[m] = g[n] + weight   #for each node m,compare its distance from start i.e g(m) to the
                else:                      #from start through n node
                    if g[m] > g[n] + weight:
                        #update g(m)
                        g[m] = g[n] + weight
                        #change parent of m to n
                        parents[m] = n
                        if m in closed_set: #if m in closed set,remove and add to open
                            closed_set.remove(m)
                            open_set.add(m)
        if n == None:
            print('Path does not exist!')
            return None
        if n == stop_node:    # if the current node is the stop_node
            path = []     # then we begin reconstructin the path from it to the start_node
            while parents[n] != n:
                path.append(n)
                n = parents[n]
            path.append(start_node)
            path.reverse()
            print('Path found: {}'.format(path))
            return path
        open_set.remove(n) # remove n from the open_list, and add it to closed_list
        closed_set.add(n) # because all of his neighbors were inspected
    print('Path does not exist!')
    return None
def get_neighbors(v): #define fuction to return neighbor and its distance
    if v in Graph_nodes: #from the passed node
        return Graph_nodes[v]
    else:
        return None
def heuristic(n):
    return H_dist[n]
'''Graph_nodes = {                     #Describe your graph here
    'A': [('B', 6), ('F', 3)],
    'B': [('A', 6), ('C', 3), ('D', 2)],
    'C': [('B', 3), ('D', 1), ('E', 5)],
    'D': [('B', 2), ('C', 1), ('E', 8)],
    'E': [('C', 5), ('D', 8), ('I', 5), ('J', 5)],
    'F': [('A', 3), ('G', 1), ('H', 7)],
    'G': [('F', 1), ('I', 3)],
    'H': [('F', 7), ('I', 2)],
    'I': [('E', 5), ('G', 3), ('H', 2), ('J', 3)],
}
'''
graph = defaultdict(list)
n,e = map(int,input().split())
for i in range(e):
    u,v,cost = map(str,input().split())
    t=(v,float(cost))
    graph[u].append(t)
    t1=(u,float(cost))
    graph[v].append(t1)
for i in range(n):
    node,h=map(str,input().split())
    H_dist[node]=float(h)
print(H_dist) 
Graph_nodes=graph
print(graph)
aStarAlgo('S', 'G')