Buggy python submission (verdict: Time Limit Exceeded):
import heapq

n, m = map(int, input().split())
tail = []
head = []
cost = []
for _ in range(m):
  l, r, c = map(int, input().split())
  tail.append(l - 1)
  head.append(r - 1)
  cost.append(c)
tail += list(range(1, n))
head += list(range(n - 1))
cost += [0] * (n - 1)

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue:
  _, act = heapq.heappop(queue)
  check[act] = True
  for edge in range(n + m - 1):
    if tail[edge] != act:
      continue
    vertex = head[edge]
    if check[vertex]:
      continue
    dist = dp[act] + cost[edge]
    if dp[vertex] > dist:
      heapq.heappush(queue, (dist, vertex))
      dp[vertex] = dist
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Fixed submission:
import heapq

n, m = map(int, input().split())
edge = [[]] + [[(0, i)] for i in range(n-1)]
for _ in range(m):
  l, r, c = map(int, input().split())
  edge[l-1].append((c, r-1))

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue and not check[-1]:
  dist, act = heapq.heappop(queue)
  check[act] = True
  for cost, vertex in edge[act]:
    if check[vertex]:
      continue
    d = dist + cost
    if dp[vertex] > d:
      heapq.heappush(queue, (d, vertex))
      dp[vertex] = d
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np

n, m = map(int, input().split())
tail = []
head = []
cost = []
for _ in range(m):
  l, r, c = map(int, input().split())
  tail.append(l - 1)
  head.append(r - 1)
  cost.append(c)
tail += list(range(1, n))
head += list(range(n - 1))
cost += [0] * (n - 1)

tail = np.array(tail, dtype=np.int)
head = np.array(head, dtype=np.int)
cost = np.array(cost, dtype=np.int)

inf = cost.sum() + 1
dp = np.ones(n, dtype=np.int) * inf
dp[0] = 0
act = 0
unexplr = np.ones(n, dtype=np.bool)
unexplr[0] = False
while unexplr[-1]:
  edge = (tail == act)
  dp[head[edge]] = np.minimum(dp[head[edge]], dp[act] + cost[edge])
  tmp = np.ones(n, dtype=np.int) * inf
  tmp[unexplr] = dp[unexplr]
  act = tmp.argmin()
  if not unexplr[act]:
    break
  unexplr[act] = False
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Fixed submission:
import heapq

n, m = map(int, input().split())
edge = [[]] + [[(0, i)] for i in range(n-1)]
for _ in range(m):
  l, r, c = map(int, input().split())
  edge[l-1].append((c, r-1))

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue and not check[-1]:
  dist, act = heapq.heappop(queue)
  check[act] = True
  for cost, vertex in edge[act]:
    if check[vertex]:
      continue
    d = dist + cost
    if dp[vertex] > d:
      heapq.heappush(queue, (d, vertex))
      dp[vertex] = d
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np

n, m = map(int, input().split())
tail = []
head = []
cost = []
for _ in range(m):
  l, r, c = map(int, input().split())
  tail.append(l - 1)
  head.append(r - 1)
  cost.append(c)
tail += list(range(1, n))
head += list(range(n - 1))
cost += [0] * (n - 1)

tail = np.array(tail, dtype=np.int)
head = np.array(head, dtype=np.int)
cost = np.array(cost, dtype=np.int)

inf = cost.sum() + 1
dp = np.ones(n, dtype=np.int) * inf
dp[0] = 0
act = 0
unexplr = np.ones(n, dtype=np.bool)
unexplr[0] = False
while unexplr[-1]:
  edge = (tail == act)
  dp[head[edge]] = np.minimum(dp[head[edge]], dp[act] + cost[edge])
  tmp = np.ones(n, dtype=np.int) * inf
  tmp[unexplr] = dp[unexplr]
  act = tmp.argmin()
  unexplr[act] = False
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Fixed submission:
import heapq

n, m = map(int, input().split())
edge = [[]] + [[(0, i)] for i in range(n-1)]
for _ in range(m):
  l, r, c = map(int, input().split())
  edge[l-1].append((c, r-1))

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue and not check[-1]:
  dist, act = heapq.heappop(queue)
  check[act] = True
  for cost, vertex in edge[act]:
    if check[vertex]:
      continue
    d = dist + cost
    if dp[vertex] > d:
      heapq.heappush(queue, (d, vertex))
      dp[vertex] = d
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Buggy python submission (verdict: Time Limit Exceeded):
n, m = map(int, input().split())
tail = []
head = []
cost = []
for _ in range(m):
  l, r, c = map(int, input().split())
  tail.append(l - 1)
  head.append(r - 1)
  cost.append(c)
tail += list(range(1, n))
head += list(range(n - 1))
cost += [0] * (n - 1)

inf = sum(cost) + 1
dp = [0] + [inf] * (n - 1)
act = 0
unexplr = [False] + [True] * (n - 1)
while unexplr[-1]:
  for edge in range(m + n - 1):
    to = head[edge]
    if act == tail[edge] and unexplr[to]:
      if dp[to] > dp[act] + cost[edge]:
        dp[to] = dp[act] + cost[edge]
  short = inf
  for vertex in range(n):
    if unexplr[vertex] and dp[vertex] < short:
      act = vertex
      short = dp[vertex]
  unexplr[act] = False
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Fixed submission:
import heapq

n, m = map(int, input().split())
edge = [[]] + [[(0, i)] for i in range(n-1)]
for _ in range(m):
  l, r, c = map(int, input().split())
  edge[l-1].append((c, r-1))

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue and not check[-1]:
  dist, act = heapq.heappop(queue)
  check[act] = True
  for cost, vertex in edge[act]:
    if check[vertex]:
      continue
    d = dist + cost
    if dp[vertex] > d:
      heapq.heappush(queue, (d, vertex))
      dp[vertex] = d
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np

n, m = map(int, input().split())
edge_l = []
edge_r = []
edge_c = []
for _ in range(m):
  l, r, c = map(int, input().split())
  edge_l.append(l - 1)
  edge_r.append(r - 1)
  edge_c.append(c)
l = np.array(edge_l, dtype=np.int)
r = np.array(edge_r, dtype=np.int)
c = np.array(edge_c, dtype=np.int)

dp = np.ones(n, dtype=np.int) * (c.sum() + 1)
dp[0] = 0
active = np.zeros(n, dtype=np.bool)
active[0] = True
while np.any(active[:-1]):
  act = active.argmax()
  use = (l <= act) * (r > act)
  dp[r[use]] = np.minimum(dp[act] + c[use], dp[r[use]])
  active[r[use]] = True
if active[-1]:
  print(dp[-1])
else:
  print(-1)

Fixed submission:
import heapq

n, m = map(int, input().split())
edge = [[]] + [[(0, i)] for i in range(n-1)]
for _ in range(m):
  l, r, c = map(int, input().split())
  edge[l-1].append((c, r-1))

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue and not check[-1]:
  dist, act = heapq.heappop(queue)
  check[act] = True
  for cost, vertex in edge[act]:
    if check[vertex]:
      continue
    d = dist + cost
    if dp[vertex] > d:
      heapq.heappush(queue, (d, vertex))
      dp[vertex] = d
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np

n, m = map(int, input().split())
edge_l = []
edge_r = []
edge_c = []
for _ in range(m):
  l, r, c = map(int, input().split())
  edge_l.append(l - 1)
  edge_r.append(r - 1)
  edge_c.append(c)
l = np.array(edge_l, dtype=np.int)
r = np.array(edge_r, dtype=np.int)
c = np.array(edge_c, dtype=np.int)

dp = np.ones(n, dtype=np.int) * (c.sum() + 1)
dp[0] = 0
flag = True
for i in range(1, n):
  use = (l < i) * (r >= i)
  if np.all(~use):
    flag = False
    break
  dp[i] = np.min(dp[l[use]] + c[use])
  
if flag:
  print(dp[-1])
else:
  print(-1)

Fixed submission:
import heapq

n, m = map(int, input().split())
edge = [[]] + [[(0, i)] for i in range(n-1)]
for _ in range(m):
  l, r, c = map(int, input().split())
  edge[l-1].append((c, r-1))

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue and not check[-1]:
  dist, act = heapq.heappop(queue)
  check[act] = True
  for cost, vertex in edge[act]:
    if check[vertex]:
      continue
    d = dist + cost
    if dp[vertex] > d:
      heapq.heappush(queue, (d, vertex))
      dp[vertex] = d
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)

Buggy python submission (verdict: Runtime Error):
import numpy as np

n, m = map(int, input().split())
edge_l = []
edge_r = []
edge_c = []
for _ in range(m):
  l, r, c = map(int, input().split())
  edge_l.append(l - 1)
  edge_r.append(r - 1)
  edge_c.append(c)
l = np.array(edge_l, dtype=np.int)
r = np.array(edge_r, dtype=np.int)
c = np.array(edge_c, dtype=np.int)

dp = np.ones(n, dtype=np.int) * (c.sum() + 1)
dp[0] = 0
active = np.zeros(n, dtype=np.bool)
active[0] = True
while np.any(active):
  act = np.argmax(active)
  use = (l <= act) * (r > act)
  dp[r] = np.minimum(np.min(dp[r[use]] + c[use]), dp[r])
  active[act] = False
  
if dp[-1] > c.sum():
  print(-1)
else:
  print(dp[-1])

Fixed submission:
import heapq

n, m = map(int, input().split())
edge = [[]] + [[(0, i)] for i in range(n-1)]
for _ in range(m):
  l, r, c = map(int, input().split())
  edge[l-1].append((c, r-1))

inf = 1 << 60
dp = [0] + [inf] * (n - 1)
queue = [(0, 0)]
check = [False] * n
while queue and not check[-1]:
  dist, act = heapq.heappop(queue)
  check[act] = True
  for cost, vertex in edge[act]:
    if check[vertex]:
      continue
    d = dist + cost
    if dp[vertex] > d:
      heapq.heappush(queue, (d, vertex))
      dp[vertex] = d
if dp[-1] < inf:
  print(dp[-1])
else:
  print(-1)