import sys
import heapq

def solve():
    # 入力の一括読み込み（高速化のため）
    input_data = sys.stdin.read().split()
    if not input_data:
        return

    N = int(input_data[0])
    M = int(input_data[1])
    
    # 基本コスト P (1-indexedにするため先頭に0を追加)
    P = [0] + [int(x) for x in input_data[2:N+2]]
    
    idx = N + 2
    edges = []
    for _ in range(M):
        u = int(input_data[idx])
        v = int(input_data[idx+1])
        t = int(input_data[idx+2])
        edges.append((u, v, t))
        idx += 3

    # 1. Bellman-Ford法によるポテンシャル h の計算
    h = [0] * (N + 1)
    for _ in range(N):
        updated = False
        for u, v, t in edges:
            if h[v] > h[u] + t:
                h[v] = h[u] + t
                updated = True
        if not updated:
            break

    # 2. 辺の重みの書き換え (非負化) と隣接リストの構築
    adj_prime = [[] for _ in range(N + 1)]
    for u, v, t in edges:
        w_prime = t + h[u] - h[v]
        adj_prime[u].append((v, w_prime))

    # 3. 各頂点からのDijkstra法
    min_cost = float('inf')
    min_count = 0

    # ループ内でのルックアップ高速化のためのローカル変数化
    heappush = heapq.heappush
    heappop = heapq.heappop

    for A in range(1, N + 1):
        d = [float('inf')] * (N + 1)
        d[A] = 0
        hq = [(0, A)]
        visited_nodes = []
        
        while hq:
            d_u, u = heappop(hq)
            if d_u > d[u]:
                continue
            if u != A:
                visited_nodes.append(u)
            
            for v, w_prime in adj_prime[u]:
                v_dist = d_u + w_prime
                if d[v] > v_dist:
                    d[v] = v_dist
                    heappush(hq, (v_dist, v))
        
        # 始点 A から到達できた頂点に対してコストを計算・集計
        const_A = P[A] - h[A]
        for v in visited_nodes:
            cost = d[v] + const_A + P[v] + h[v]
            if cost < min_cost:
                min_cost = cost
                min_count = 1
            elif cost == min_cost:
                min_count += 1

    # 出力処理
    if min_cost == float('inf'):
        print(-1)
    else:
        print(f"{min_cost} {min_count}")

if __name__ == '__main__':
    solve()