use std::{
    fs::File,
    io::{BufRead, BufReader, Write},
};

fn read_input() -> (Vec<u32>, u32) {
    let f = File::open("transport.in").unwrap();
    let reader = BufReader::new(f);

    let mut lines = reader
        .lines()
        .map_while(Result::ok)
        .filter_map(|line| (!line.is_empty()).then_some(line));

    let [n, k]: [usize; 2] = lines
        .next()
        .unwrap()
        .split_whitespace()
        .map(|x| x.parse().unwrap())
        .take(2)
        .collect::<Vec<_>>()
        .try_into()
        .unwrap();

    // lines.take(n).map(|line| line.parse().unwrap()).collect()
    let stack = lines
        .take(n)
        .map(|line| line.parse().unwrap())
        .collect::<Vec<u32>>();

    (stack, k as u32)
}

fn write_output(inv_count: u32) {
    let mut f = File::create("transport.out").unwrap();
    writeln!(f, "{}", inv_count).unwrap();
}

fn get_min_cap(stack: &[u32], k: u32) -> u32 {
    let is_valid_weight = |w: u32| -> bool {
        let mut cur_avail_weight = w;
        let mut avail_transports = k;
        for &m in stack.iter() {
            if m > cur_avail_weight {
                cur_avail_weight = w;
                avail_transports -= 1;
            }

            if avail_transports == 0 || m > w {
                return false;
            }
            cur_avail_weight -= m;
        }
        true
    };

    let mut l = 0;
    let mut r = stack.iter().sum::<u32>();

    while l < r {
        let m = l + (r - l) / 2;
        if is_valid_weight(m) {
            r = m;
        } else {
            l = m + 1;
        }
    }

    l
}

fn main() {
    let (stack, k) = read_input();
    let min_cap = get_min_cap(&stack, k);
    write_output(min_cap);
}