use std::{fs::File, io::{BufReader, Bytes, Error, Read, Write}};

struct NumReader {
    bytes: Bytes<BufReader<File>>,
}

type NumReaderType = u32;

impl Iterator for NumReader {
    type Item = Result<NumReaderType, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut ret: NumReaderType = 0;
        while let Some(chr_result) = self.bytes.next() {
            if let Err(err) = chr_result {
                return Some(Err(err));
            }
            let chr = chr_result.unwrap(); // dbg!(
            if chr == 0 { return None; }
            if let Some(digit) = char::from(chr).to_digit(10) {
                ret *= 10;
                ret += digit as NumReaderType
            }
            if chr.is_ascii_whitespace() {
                return Some(Ok(ret));
            }
        }
        None
    }
}

fn create_num_reader(f: File) -> NumReader {
    return NumReader { bytes: BufReader::new(f).bytes() };
}

fn read_data() -> (NumReaderType, Vec<NumReaderType>, NumReaderType, NumReaderType) {
    let f = File::open("transport.in").expect("No input file");
    let mut nrd = create_num_reader(f);
    let mut n = nrd.next().unwrap().unwrap();
    let k = nrd.next().unwrap().unwrap();
    let mut vec = Vec::with_capacity(n as usize);
    let mut left = 0;
    let mut right = 0;
    for int in nrd {
        let int= int.unwrap();
        if n == 0 {
            break;
        }
        n -= 1;
        vec.push(int);
        if int > left {
            left = int;
        }
        right += int;
    }
    assert!(n == 0);
    return (k, vec, left, right);
}

fn verify(res: NumReaderType, k: NumReaderType, vec: &Vec<NumReaderType>) -> bool {
    let mut way = 0;
    let mut loaded = 0;
    for int in vec {
        loaded += *int;
        if loaded > res {
            loaded = *int;
            way += 1;
            if way == k {
                break;
            }
        }
    }
    way < k
}

fn solve((k, vec, left, right) : (NumReaderType, Vec<NumReaderType>, NumReaderType, NumReaderType)) -> NumReaderType {
    let mut left = left;
    let mut right = right;
    let mut res: NumReaderType = 0;
    while left < right {
        let mid = left + (right - left) / 2;
        if verify(mid, k, &vec) {
            res = mid;
            right = mid;
        } else {
            left = mid + 1;
        }
    };
    res
}

fn main() {
    //let mut buf = String::new();
    //io::stdin().read_line(&mut buf).expect("AAaa");
    //print!("{}", buf);

    let sol = solve(read_data());
    File::create("transport.out").expect("Failed to open output file")
        .write_all((sol.to_string() + "\n").as_bytes())
        .expect("Failed to write");
}