output_description: Print the costs of SSSP in the following format.
  
      
      
      c0
      c1
      :
      c|V|-1
      
  
  The output consists of |V| lines. Print the cost of the shortest path from the
  source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the
  source to a vertex, print INF.
input_description: An edge-weighted graph G (V, E) and the source r.
  
      
      
      |V| |E| r
      s0 t0 d0
      s1 t1 d1
      :
      s|E|-1 t|E|-1 d|E|-1
      
  
  |V| is the number of vertices and |E| is the number of edges in G. The graph
  vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the
  source of the graph.
  
  si and ti represent source and target vertices of i-th edge (directed) and di
  represents the cost of the i-th edge.
attempt: from collections import defaultdict
  import heapq
  
  with open("input.txt", "r") as f:
      vertice, edge, source = map(int, input().split(" "))
      link = [[] for n in range(vertice)]
      weight = defaultdict(dict)
      for e in range(edge):
          i, j, w = map(int, input().split(" "))
          link[i].append(j)
          weight[i].update({j: w})
      # print(weight,link)
      for v in range(vertice):
          goal = v
          queue = []
          heapq.heappush(queue, [0, source])
          went = set()
  
          while queue != []:
              # print(queue)
              now_cost, here = heapq.heappop(queue)
              # print(now_cost,here,queue)
              if here == goal:
                  print(now_cost)
                  break
  
              can_go = link[here]
              not_went = set(can_go) - went
              # print(v,here,now_cost,not_went,queue)
              for nw in not_went:
                  next_cost = now_cost + weight[here][nw]
                  heapq.heappush(queue, (next_cost, nw))
              went = went | {here}
              queue.sort(key=lambda x: x[1], reverse=True)
          else:
              print("INF")
  
problem_description: Single Source Shortest Path
  
  For a given weighted graph G(V, E) and a source r, find the source shortest
  path to each vertex from the source (SSSP: Single Source Shortest Path).
samples: [{"input": "4 5 0\n    0 1 1\n    0 2 4\n    1 2 2\n    2 3 1\n    1 3 5", "output": "0\n    1\n    3\n    4"}, {"input": "4 6 1\n    0 1 1\n    0 2 4\n    2 0 1\n    1 2 2\n    3 1 1\n    3 2 5", "output": "3\n    0\n    2\n    INF"}]