#include <cmath>
#include <iostream>
#include <fstream>
#include <vector>
#include <stack>

using namespace std;

// parcurge elementele din stiva si incarca tractorul
int stackTraverse (stack<int> saltele, int drumuri, int max_cargo)
{
    int drum_curent = max_cargo;
    int saltea;
    int sol = 0;

    while (!saltele.empty() && drumuri > 0)
    {
        saltea = saltele.top();
        saltele.pop();

        // daca mai incape o saltea scadem din limita
        if (drum_curent - saltea >= 0)
        {
            drum_curent -= saltea;
        }
        else 
        {
            // ne mutam pe urmatorul drum
            drum_curent = max_cargo - saltea;
            sol++;
            drumuri--;
        }
    }

    if (saltele.empty())
    {
        return sol;
    }

    return 0;
}

int binarySearch (stack<int> saltele, int drumuri, int max_saltea)
{
    int cargo_low = max_saltea;
    int cargo_high = cargo_low * 2;
    int cargo_mid;

    int sol_low = stackTraverse(saltele, drumuri, cargo_low);

    // daca avem solutie pentru incarcatura = cea mai mare saltea, aceea e solutia minima
    if (sol_low != 0)
    {
        return cargo_low;
    }

    int sol_mid = 0, sol_high = 0;

    while (true)
    {
        // cautare binara - cele doua capete
        sol_low = stackTraverse(saltele, drumuri, cargo_low);
        sol_high = stackTraverse(saltele, drumuri, cargo_high);

        // cand capetele sunt consecutive, solutia e cea mai mare din ele
        if (cargo_low + 1 == cargo_high)
        {
            return cargo_high;
        }

        // daca solutia e cu mult mai mare fata de salteaua cea mai mare
        if (sol_high == 0)
        {
            cargo_low = cargo_high;
            cargo_high = cargo_low * 2;
        }

        cargo_mid = cargo_low + (cargo_high - cargo_low) / 2;
        sol_mid = stackTraverse(saltele, drumuri, cargo_mid);

        if (sol_mid == 0)
        {
            cargo_low = cargo_mid;
        }
        else
        {
            cargo_high = cargo_mid;
        }
    }

    return 0;
}

int main() {

    ifstream fin("transport.in");
    ofstream fout("transport.out");

    stack<int> saltele, saltele_reversed;
    int n, drumuri, saltea, max_saltea = 0;

    fin >> n >> drumuri;

    for (int i = 0; i <= n; i++)
    {
        fin >> saltea;
        saltele_reversed.push(saltea);

        if (saltea > max_saltea)
        {
            max_saltea = saltea;
        }
    }

    for (int i = 0; i <= n; i++)
    {
        saltele.push(saltele_reversed.top());
        saltele_reversed.pop();
    }

    fout << binarySearch(saltele, drumuri, max_saltea);

    return 0;
}