```go
package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"sort"
)

type Item struct {
	val int64
	idx int
}

type Int64Heap []Item

func (h Int64Heap) Len() int           { return len(h) }
func (h Int64Heap) Less(i, j int) bool { return h[i].val < h[j].val }
func (h Int64Heap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *Int64Heap) Push(x interface{}) {
	*h = append(*h, x.(Item))
}

func (h *Int64Heap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var K, N int
	fmt.Fscan(in, &K, &N)

	t := make([]int, N)
	for i := 0; i < N; i++ {
		fmt.Fscan(in, &t[i])
	}

	sort.Ints(t)

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

	M := N - 1
	d := make([]int64, M)
	for i := 0; i < M; i++ {
		d[i] = int64(t[i+1] - t[i])
	}

	left := make([]int, M)
	right := make([]int, M)
	for i := 0; i < M; i++ {
		left[i] = i - 1
		right[i] = i + 1
	}
	right[M-1] = -1

	h := &Int64Heap{}
	heap.Init(h)
	for i := 0; i < M; i++ {
		heap.Push(h, Item{d[i], i})
	}

	var ans int64 = 0

	for k := 0; k < K; k++ {
		var item Item
		for {
			item = heap.Pop(h).(Item)
			if item.val == d[item.idx] {
				break
			}
		}
		idx := item.idx
		ans += d[idx]

		l := left[idx]
		r := right[idx]

		if l != -1 {
			right[l] = r
		}
		if r != -1 {
			left[r] = l
		}

		if l != -1 && r != -1 {
			newVal := d[l] + d[r] - d[idx]
			d[idx] = newVal

			left[idx] = left[l]
			right[idx] = right[r]

			if left[l] != -1 {
				right[left[l]] = idx
			}
			if right[r] != -1 {
				left[right[r]] = idx
			}

			heap.Push(h, Item{newVal, idx})
		} else {
			d[idx] = -1
		}
	}

	fmt.Println(ans)
}
```