```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const INF int64 = 1e18

type Edge struct {
	to   int
	cap  int64
	flow int64
	rev  int
}

var graph [][]Edge
var level []int
var ptr []int

func addEdge(from, to int, cap int64) {
	graph[from] = append(graph[from], Edge{to, cap, 0, len(graph[to])})
	graph[to] = append(graph[to], Edge{from, 0, 0, len(graph[from]) - 1})
}

func bfs(s, t int) bool {
	for i := range level {
		level[i] = -1
	}
	level[s] = 0
	queue := make([]int, 0, len(level))
	queue = append(queue, s)
	for len(queue) > 0 {
		v := queue[0]
		queue = queue[1:]
		for _, edge := range graph[v] {
			if edge.cap-edge.flow > 0 && level[edge.to] == -1 {
				level[edge.to] = level[v] + 1
				queue = append(queue, edge.to)
			}
		}
	}
	return level[t] != -1
}

func dfs(v, t int, pushed int64) int64 {
	if pushed == 0 {
		return 0
	}
	if v == t {
		return pushed
	}
	for cid := ptr[v]; cid < len(graph[v]); cid++ {
		ptr[v] = cid
		edge := graph[v][cid]
		tr := edge.to
		if level[v]+1 != level[tr] || edge.cap-edge.flow == 0 {
			continue
		}
		push := pushed
		if edge.cap-edge.flow < push {
			push = edge.cap - edge.flow
		}
		p := dfs(tr, t, push)
		if p == 0 {
			continue
		}
		graph[v][cid].flow += p
		graph[tr][edge.rev].flow -= p
		return p
	}
	return 0
}

func dinic(s, t int) int64 {
	var flow int64 = 0
	for bfs(s, t) {
		for i := range ptr {
			ptr[i] = 0
		}
		for {
			pushed := dfs(s, t, INF)
			if pushed == 0 {
				break
			}
			flow += pushed
		}
	}
	return flow
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}

	if n == 0 {
		fmt.Println(0)
		return
	}

	nodes := n + m + 2
	graph = make([][]Edge, nodes)
	level = make([]int, nodes)
	ptr = make([]int, nodes)

	s := 0
	t := nodes - 1

	for i := 1; i <= n; i++ {
		var a int64
		fmt.Fscan(in, &a)
		addEdge(m+i, t, a)
	}

	var totalW int64 = 0
	for i := 1; i <= m; i++ {
		var u, v int
		var w int64
		fmt.Fscan(in, &u, &v, &w)
		totalW += w
		addEdge(s, i, w)
		addEdge(i, m+u, INF)
		addEdge(i, m+v, INF)
	}

	ans := totalW - dinic(s, t)
	if ans < 0 {
		ans = 0
	}
	fmt.Println(ans)
}
```