package main

import (
	"fmt"
	"io"
	"math"
	"os"
	"sort"
)

type Edge struct {
	u, v int
	w    int64
}

var data []byte
var pos int

func nextInt() int64 {
	for pos < len(data) && data[pos] <= ' ' {
		pos++
	}
	if pos >= len(data) {
		return 0
	}
	var res int64
	for pos < len(data) && data[pos] > ' ' {
		res = res*10 + int64(data[pos]-'0')
		pos++
	}
	return res
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func main() {
	data, _ = io.ReadAll(os.Stdin)
	n := int(nextInt())
	m := int(nextInt())

	if n == 0 {
		return
	}

	c := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		c[i] = nextInt()
	}

	edges := make([]Edge, m)
	for i := 0; i < m; i++ {
		edges[i] = Edge{
			u: int(nextInt()),
			v: int(nextInt()),
			w: nextInt(),
		}
	}

	sort.Slice(edges, func(i, j int) bool {
		return edges[i].w > edges[j].w
	})

	dsu := make([]int, 2*n)
	for i := 1; i < 2*n; i++ {
		dsu[i] = i
	}
	var find func(i int) int
	find = func(i int) int {
		if dsu[i] == i {
			return i
		}
		dsu[i] = find(dsu[i])
		return dsu[i]
	}

	val := make([]int64, 2*n)
	sum_c := make([]int64, 2*n)
	for i := 1; i <= n; i++ {
		sum_c[i] = c[i]
	}

	children := make([][2]int, 2*n)

	idx := n
	for _, e := range edges {
		ru := find(e.u)
		rv := find(e.v)
		if ru != rv {
			idx++
			dsu[ru] = idx
			dsu[rv] = idx
			val[idx] = e.w
			sum_c[idx] = sum_c[ru] + sum_c[rv]
			children[idx] = [2]int{ru, rv}
		}
	}

	max_W := make([]int64, 2*n)
	max_W[idx] = math.MaxInt64

	for i := idx; i > n; i-- {
		u := children[i][0]
		v := children[i][1]
		max_W[u] = min(max_W[i], val[i]+sum_c[u])
		max_W[v] = min(max_W[i], val[i]+sum_c[v])
	}

	ans := int64(-1)
	total_c := sum_c[idx]
	for i := 1; i <= n; i++ {
		w_start := max_W[i] - total_c
		if w_start > ans {
			ans = w_start
		}
	}

	if ans <= 0 {
		fmt.Println("-1")
	} else {
		fmt.Println(ans)
	}
}