N,S = map(int,input().split())
a = list(map(int,input().split()))

def check(P):
    time_need = 1
    con_T = 0
    for T in a:
        if T>P:
            return False
        if con_T+T>P:
            time_need+=1
            con_T = T
        else:
            con_T+=T
    return time_need<=S

l,r = 0,50000
while l<=r:
    mid = (l+r)//2
    if check(mid):
        r = mid-1
    else:
        l = mid+1
print(l)
    

// 读取输入，并将其拆分为字符串数组
let input = readline().split(' ');
// 将输入的第一个值转换为整数 N，表示任务数量
let N = parseInt(input[0]);
// 将输入的第二个值转换为整数 T，表示可用的时刻数
let T = parseInt(input[1]);
// 读取任务的算力需求，并将其转换为数字数组 a
let a = readline().split(' ').map(Number);

// 初始化二分查找的左右边界
let l = 1; // 最小算力
let r = 1e9; // 最大算力

// 定义检查函数 check(y)，用于判断当前算力 y 是否能够在 T 时刻内完成所有任务
function check(y) {
    let cur = 0; // 当前时刻内的算力总和
    let res = 1; // 当前使用的时刻数

    // 遍历每个任务的算力需求
    for (let x of a) {
        // 如果当前任务的算力加上当前总和超出 y
        if (cur + x > y) {
            res += 1; // 需要增加一个时刻
            cur = 0; // 重置当前算力总和
        }

        cur += x; // 将当前任务的算力加到当前总和

        // 如果在分配任务时当前算力超过了 y，返回 false
        if (cur > y) {
            return false;
        }
    }

    // 返回使用的时刻数是否小于等于 T
    return res <= T;
}

// 进行二分查找
while (l < r) {
    // 计算中间值
    let mid = (l + r) >> 1;

    // 如果当前算力 mid 能满足条件
    if (check(mid)) {
        r = mid; // 尝试更小的算力
    } else {
        l = mid + 1; // 否则，增加算力
    }
}

// 输出找到的最低算力
print(l);

import java.util.Scanner; // 导入 Scanner 类用于输入处理

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建 Scanner 对象以接收输入

        // 读取任务数量 N 和可用的时刻数 T
        int N = scanner.nextInt();
        int T = scanner.nextInt();

        // 创建数组 a 存储每个任务的算力需求
        int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            a[i] = scanner.nextInt(); // 读取每个任务的算力需求
        }

        // 初始化二分查找的左右边界
        int l = 1; // 最小算力
        int r = (int) 1e9; // 最大算力

        // 进行二分查找
        while (l < r) {
            int mid = (l + r) >> 1; // 计算中间值

            // 检查当前算力 mid 是否满足条件
            if (check(a, mid, T)) {
                r = mid; // 如果满足条件，尝试更小的算力
            } else {
                l = mid + 1; // 否则，增加算力
            }
        }

        // 输出找到的最低算力
        System.out.println(l);
    }

    // 检查给定算力 y 是否能够在 T 时刻内完成所有任务
    private static boolean check(int[] a, int y, int T) {
        int cur = 0; // 当前时刻内的算力总和
        int res = 1; // 当前使用的时刻数

        // 遍历每个任务的算力需求
        for (int x : a) {
            // 如果当前任务的算力加上当前总和超出 y
            if (cur + x > y) {
                res += 1; // 需要增加一个时刻
                cur = 0; // 重置当前算力总和
            }

            cur += x; // 将当前任务的算力加到当前总和

            // 如果在分配任务时当前算力超过了 y，返回 false
            if (cur > y) {
                return false;
            }
        }

        // 返回使用的时刻数是否小于等于 T
        return res <= T;
    }
}

# 读取输入：N 为任务数量，T 为可用的时刻数
N, T = map(int, input().split())
# 读取每个任务的算力需求，并存储在列表 a 中
a = list(map(int, input().split()))

# 初始化二分查找的左右边界
l, r = 1, int(1e9)

# 定义检查函数 check(y)，用于判断当前算力 y 是否能够在 T 时刻内完成所有任务
def check(y):
    cur, res = 0, 1  # cur 表示当前时刻的算力总和，res 表示当前使用的时刻数
    for x in a:  # 遍历每个任务的算力需求
        # 如果当前任务的算力加上当前总和超出 y
        if cur + x > y:
            res += 1  # 需要增加一个时刻
            cur = 0  # 重置当前算力总和
        cur += x  # 将当前任务的算力加到当前总和
        # 如果在分配任务时当前算力超过了 y，说明不满足条件
        if cur > y:
            return False
    # 返回使用的时刻数是否小于等于 T
    return res <= T

# 进行二分查找
while l < r:
    mid = (l + r) >> 1  # 计算中间值
    if check(mid):  # 如果当前算力 mid 能满足条件
        r = mid  # 尝试更小的算力
    else:  # 否则，增加算力
        l = mid + 1  # 尝试更大的算力

# 输出找到的最低算力
print(l)

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int N, T; // N为任务数量，T为时刻数量
    cin >> N >> T;

    vector<int> a(N); // 存储每个任务的算力需求
    for (int i = 0; i < N; ++i) {
        cin >> a[i];
    }

    int l = 1; // 最小算力
    int r = 1e9; // 最大算力

    // 检查给定算力y是否能够在T时刻内完成所有任务
    auto check = [&](int y) {
        int cur = 0; // 当前时刻内的算力总和
        int res = 1; // 当前时刻数

        for (int x : a) {
            // 如果当前任务的算力加上当前总和超出y
            if (cur + x > y) {
                res += 1; // 需要新增一个时刻
                cur = 0; // 重置当前算力
            }

            cur += x; // 增加当前任务的算力

            // 如果在分配任务时当前算力超过了y，返回false
            if (cur > y) {
                return false;
            }
        }

        // 返回使用的时刻数是否小于等于T
        return res <= T;
    };

    // 二分查找
    while (l < r) {
        int mid = (l + r) >> 1; // 计算中间值

        if (check(mid)) { // 如果满足条件，说明算力可以更低
            r = mid; // 缩小右边界
        } else { // 否则，增加算力
            l = mid + 1; // 缩小左边界
        }
    }

    cout << l << endl; // 输出找到的最低算力

    return 0;
}