use std::io::BufRead;

pub struct StdinReader<R: BufRead> {
    pub buf_reader: R,
    pub buf: String,
}
impl<R: BufRead> StdinReader<R> {
    pub fn new(r: R) -> Self {
        StdinReader {
            buf_reader: r,
            buf: String::with_capacity(10000),
        }
    }
}

#[macro_export]
macro_rules! input {
    ($reader : expr, $t : ty) => { // one variable
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: $t = reader.buf.trim().parse().unwrap(); 
                reader.buf.clear();
                tmp_var
            },
        }
    };
    ($reader : expr, $t0 : ty, $t1 : ty) => { // 2 tuple
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: Vec<$t0> = reader.buf.trim().split_whitespace().map(|a| a.parse().unwrap()).collect();
                reader.buf.clear();
                (tmp_var[0], tmp_var[1])
            }
        }
    };
    ($reader : expr, $t0 : ty, $t1 : ty, $t2 : ty) => { // 3 tuple
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: Vec<$t0> = reader.buf.trim().split_whitespace().map(|a| a.parse().unwrap()).collect();
                reader.buf.clear();
                (tmp_var[0], tmp_var[1], tmp_var[2])
            }
        }
    };
    ($reader : expr, $t : ty; $size : expr) => { // Vector
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: $t = reader.buf.trim().split_whitespace().map(|a| a.parse().unwrap()).collect();
                reader.buf.clear();
                tmp_var
            }
        }
    };
}

use std::cmp::Ordering;
#[derive(Debug, Hash)]
struct SomeType {
    s: usize, // index of small
    l: usize, // index of large
    value: isize, // distance
}
impl Eq for SomeType {}
impl PartialEq for SomeType {
    fn eq(&self, other: &Self) -> bool {
        self.value == other.value
    }
}
impl PartialOrd for SomeType {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.value.partial_cmp(&other.value)
    }
}
impl Ord for SomeType {
    fn cmp(&self, other: &Self) -> Ordering {
        self.value.cmp(&other.value)
    }
}

fn main() {
    let handle = std::io::stdin();
    let mut r = StdinReader::new(handle.lock());

    let (n, m) = input!(r, usize, usize);
    if n >= m {
        println!("{}", 0);
        return;
    }
    let mut xs: Vec<isize> = input!(r, Vec<isize>; m);
    xs.sort();
    use std::collections::BinaryHeap;
    let mut distances: BinaryHeap<SomeType> = BinaryHeap::with_capacity(m);
    for i in 0..xs.len()-1 {
        let distance = xs[i+1] - xs[i];
        distances.push(SomeType { s: i, l: i+1, value: distance, });
    }
    use std::collections::HashSet;
    let mut hops: HashSet<(usize, usize)> = HashSet::with_capacity(n-1);
    for _ in 0..n-1 {
        let hop = distances.pop().unwrap();
        hops.insert((hop.s, hop.l));
    }
    let mut total_dis = 0;
    for i in 0..m-1 {
        let item = (i, i+1);
        if hops.contains(&item) {
            continue;
        }
        total_dis += xs[i+1]-xs[i];
    }
    println!("{}", total_dis);
}


Measured memory_bytes: 14588