package main

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

type Hole struct {
	p int64
	c int
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0

	readInt := func() int64 {
		for idx < len(data) && (data[idx] == ' ' || data[idx] == '\n' || data[idx] == '\r' || data[idx] == '\t') {
			idx++
		}
		sign := int64(1)
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		var v int64
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			v = v*10 + int64(data[idx]-'0')
			idx++
		}
		return sign * v
	}

	n := int(readInt())
	m := int(readInt())

	x := make([]int64, n)
	for i := 0; i < n; i++ {
		x[i] = readInt()
	}
	sort.Slice(x, func(i, j int) bool { return x[i] < x[j] })

	holes := make([]Hole, m)
	totalCap := 0
	for i := 0; i < m; i++ {
		p := readInt()
		c := int(readInt())
		if c > n {
			c = n
		}
		holes[i] = Hole{p: p, c: c}
		totalCap += c
	}

	if totalCap < n {
		os.Stdout.WriteString("-1")
		return
	}

	sort.Slice(holes, func(i, j int) bool { return holes[i].p < holes[j].p })

	const INF int64 = 1 << 62

	dpOld := make([]int64, n+1)
	dpNew := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		dpOld[i] = INF
	}

	pref := make([]int64, n+1)
	val := make([]int64, n+1)
	dq := make([]int, n+1)

	for _, h := range holes {
		pref[0] = 0
		for i := 1; i <= n; i++ {
			d := x[i-1] - h.p
			if d < 0 {
				d = -d
			}
			pref[i] = pref[i-1] + d
		}

		head, tail := 0, 0
		for j := 0; j <= n; j++ {
			if dpOld[j] >= INF/2 {
				val[j] = INF
			} else {
				val[j] = dpOld[j] - pref[j]
			}

			for tail > head && val[dq[tail-1]] >= val[j] {
				tail--
			}
			dq[tail] = j
			tail++

			limit := j - h.c
			for head < tail && dq[head] < limit {
				head++
			}

			best := val[dq[head]]
			if best >= INF/2 {
				dpNew[j] = INF
			} else {
				dpNew[j] = pref[j] + best
			}
		}

		dpOld, dpNew = dpNew, dpOld
	}

	ans := dpOld[n]
	if ans >= INF/2 {
		os.Stdout.WriteString("-1")
	} else {
		os.Stdout.WriteString(strconv.FormatInt(ans, 10))
	}
}