from sys import stdin
input = stdin.readline
from heapq import heappush, heappop
from collections import deque

class Convex_Hull_Trick:
    def __init__(self):
        self.que = deque()

    def check(self, f1, f2, f3):
        return (f2[0] - f1[0]) * (f3[1] - f2[1]) >= (f2[1] - f1[1]) * (f3[0] - f2[0])
    
    def f(self, f1, x):
        return f1[0]*x + f1[1]
    
    # add f_i(x) = a*x + b
    def add_line(self, a, b):
        f1 = (a, b)
        while len(self.que) >= 2 and self.check(self.que[-2], self.que[-1], f1):
            self.que.pop()
        self.que.append(f1)

    # min f_i(x)
    def query(self, x):
        while len(self.que) >= 2 and self.f(self.que[0], x) >= self.f(self.que[1], x):
            self.que.popleft()
        return self.f(self.que[0], x)

INF = 1<<60

N, M = map(int, input().split())
W = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(M):
    u, v, c = map(int, input().split())
    u, v = u-1, v-1
    G[u].append((v, c))
    G[v].append((u, c))

def dijkstra(dist):
    visited = [False]*N
    que = []
    for i in range(N):
        if dist[i] != INF:
            heappush(que, (dist[i], i))
    while que:
        d, now = heappop(que)
        if visited[now]:
            continue
        visited[now] = True
        for next, weight in G[now]:
            if dist[now]+weight < dist[next]:
                dist[next] = dist[now]+weight
                heappush(que, (dist[next], next))
    return dist

dist1 = [INF]*N
dist1[0] = 0
dist1 = dijkstra(dist1)
ans = dist1[-1]
dist1 = sorted([(W[i], dist1[i]) for i in range(N)])

CHT = Convex_Hull_Trick()
pre = -1
for w, d in dist1:
    if pre == w: continue
    CHT.add_line(w, d)
    pre = w

IDX = sorted(range(N), key=lambda x:W[x])
dist2 = [INF]*N
for idx in IDX:
    dist2[idx] = CHT.query(W[idx])

dist2 = dijkstra(dist2)
ans = min(ans, dist2[-1])

print(ans)