package main

import (
	"io"
	"os"
	"strconv"
)

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	readInt := func() int {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') {
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return val
	}

	n := readInt()
	q := readInt()

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

	m := n - 1
	head := make([]int, n+1)
	for i := 0; i <= n; i++ {
		head[i] = -1
	}
	to := make([]int, 2*m)
	nxt := make([]int, 2*m)
	w := make([]int64, 2*m)
	ec := 0
	addEdge := func(u, v int, ww int64) {
		to[ec] = v
		w[ec] = ww
		nxt[ec] = head[u]
		head[u] = ec
		ec++
	}

	for i := 0; i < m; i++ {
		u := readInt()
		v := readInt()
		ww := int64(readInt())
		addEdge(u, v, ww)
		addEdge(v, u, ww)
	}

	LOG := 1
	for (1 << LOG) <= n {
		LOG++
	}
	up := make([][]int, LOG)
	for i := 0; i < LOG; i++ {
		up[i] = make([]int, n+1)
	}

	parent := make([]int, n+1)
	depth := make([]int, n+1)
	parentW := make([]int64, n+1)

	order := make([]int, 0, n)
	stack := make([]int, 0, n)
	stack = append(stack, 1)

	for len(stack) > 0 {
		x := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, x)
		for e := head[x]; e != -1; e = nxt[e] {
			y := to[e]
			if y == parent[x] {
				continue
			}
			parent[y] = x
			depth[y] = depth[x] + 1
			parentW[y] = w[e]
			up[0][y] = x
			for k := 1; k < LOG; k++ {
				up[k][y] = up[k-1][up[k-1][y]]
			}
			stack = append(stack, y)
		}
	}

	sumChildPos := make([]int64, n+1)
	posToParent := make([]int64, n+1)

	for i := len(order) - 1; i >= 0; i-- {
		x := order[i]
		var sum int64
		for e := head[x]; e != -1; e = nxt[e] {
			y := to[e]
			if parent[y] == x {
				sum += posToParent[y]
			}
		}
		sumChildPos[x] = sum
		if x != 1 {
			v := a[x] - 2*parentW[x] + sum
			if v > 0 {
				posToParent[x] = v
			}
		}
	}

	C := make([]int64, n+1)
	pref := make([]int64, n+1)

	C[1] = a[1] + sumChildPos[1]
	pref[1] = C[1]

	for _, x := range order {
		for e := head[x]; e != -1; e = nxt[e] {
			y := to[e]
			if parent[y] != x {
				continue
			}
			base := a[y] + sumChildPos[y]
			raw := C[x] - 2*w[e] - posToParent[y]
			if raw < 0 {
				raw = 0
			}
			C[y] = base + raw
			pref[y] = pref[x] + base - w[e] - posToParent[y]
		}
	}

	lca := func(u, v int) int {
		if depth[u] < depth[v] {
			u, v = v, u
		}
		diff := depth[u] - depth[v]
		k := 0
		for diff > 0 {
			if diff&1 != 0 {
				u = up[k][u]
			}
			diff >>= 1
			k++
		}
		if u == v {
			return u
		}
		for k = LOG - 1; k >= 0; k-- {
			if up[k][u] != up[k][v] {
				u = up[k][u]
				v = up[k][v]
			}
		}
		return parent[u]
	}

	out := make([]byte, 0, q*24)
	for i := 0; i < q; i++ {
		u := readInt()
		v := readInt()
		l := lca(u, v)
		ans := pref[u] + pref[v] - 2*pref[l] + C[l]
		out = strconv.AppendInt(out, ans, 10)
		out = append(out, '\n')
	}

	_, _ = os.Stdout.Write(out)
}