Tikut

use std::{cmp, collections::HashMap, io, usize};

// Memoization storage to avoid recomputation
type Memo = HashMap<(Vec<(usize, usize)>, usize), usize>;

fn max_length_difference_for_cuts(lengths: Vec<(usize, usize)>, max_cuts: usize) -> Vec<usize> {
    let mut memo = Memo::new();
    let mut results = vec![0; max_cuts];

    for cuts in 1..=max_cuts {
        results[cuts-1] = max_length_difference(lengths.clone(), cuts, &mut memo);
    }

    results
}

fn max_length_difference(
    mut lengths: Vec<(usize, usize)>,
    cuts: usize,
    memo: &mut Memo,
) -> usize {
    if let Some(&result) = memo.get(&(lengths.clone(), cuts)) {
        return result;
    }

    let largest = lengths.pop().unwrap();

    let result = if largest.1 > cuts {
        if cuts > 0 {
            if lengths.len() == 0 {
                largest.0 - largest.0 / 2
            } else {
                largest.0 - cmp::min(lengths.first().unwrap().0, largest.0 / 2)
            }
        } else if lengths.len() == 0 {
            0
        } else {
            largest.0 - lengths.first().unwrap().0
        }
    } else {
        let mut min = usize::MAX;

        for p in 1..=largest.0 / 2 {
            let mut new_lengths = lengths.clone();
            insert_length(&mut new_lengths, largest.0 - p, largest.1);
            insert_length(&mut new_lengths, p, largest.1);

            min = cmp::min(
                min,
                max_length_difference(new_lengths, cuts - largest.1, memo),
            );
        }

        return min
    };

    // Memoize result for this state
    memo.insert((lengths, cuts), result);
    return result
}

// Helper function to insert a length into a sorted `lengths` vector
fn insert_length(lengths: &mut Vec<(usize, usize)>, length: usize, count: usize) {
    for i in (0..lengths.len()).rev() {
        if lengths[i].0 < length {
            lengths.insert(i + 1, (length, count));
            return;
        } else if lengths[i].0 == length {
            lengths[i].1 += count;
            return;
        }
    }
    lengths.insert(0, (length, count));
}

fn main() {
    let mut in_str = String::new();
    io::stdin().read_line(&mut in_str).unwrap();
    in_str = in_str.trim().to_string();
    let (n_str, m_str) = in_str.trim().split_once(' ').unwrap();

    let _n: usize = n_str.parse().unwrap();
    let m: usize = m_str.parse().unwrap();

    let mut lengths_map: HashMap<usize, usize> = HashMap::new();

    let mut lengths_str = String::new();
    io::stdin().read_line(&mut lengths_str).unwrap();

    for l in lengths_str.split_whitespace() {
        let key = l.parse().unwrap();
        if lengths_map.contains_key(&key) {
            *lengths_map.get_mut(&key).unwrap() += 1;
        } else {
            lengths_map.insert(key, 1);
        }
    }

    let mut lengths_vec: Vec<(usize, usize)> = lengths_map.into_iter().collect();
    lengths_vec.sort_by_key(|k| k.0);

    println!("{}", max_length_difference_for_cuts(lengths_vec.clone(), m).iter().map(|v| v.to_string()).collect::<Vec<String>>().join(" "));
}

Test 1

Group: 1, 3, 4, 5, 6

Verdict: ACCEPTED

Test 2

Group: 1, 4, 5, 6

Verdict: ACCEPTED

Test 3

Group: 1, 4, 5, 6

Verdict: ACCEPTED

Test 4

Group: 1, 4, 5, 6

Verdict: ACCEPTED

Test 5

Group: 2, 5, 6

Verdict: ACCEPTED

Test 6

Group: 2, 5, 6

Verdict: ACCEPTED

Test 7

Group: 3, 5, 6

Verdict: ACCEPTED

Test 8

Group: 3, 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 3, 5, 6

Verdict: ACCEPTED

Test 10

Group: 3, 5, 6

Verdict: ACCEPTED

Test 11

Group: 3, 5, 6

Verdict: ACCEPTED

Test 12

Group: 4, 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 4, 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 4, 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 4, 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 6

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 6

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 6

Verdict: TIME LIMIT EXCEEDED