from collections import deque

def max_beauty_sum(N, K, T):
    # dp[i] will store the max sum of the minimums when partitioning first i tulips into up to K bouquets
    dp = [[-float('inf')] * (K + 1) for _ in range(N + 1)]
    
    # Base case: 0 tulips, 0 bouquets has a sum of 0
    dp[0][0] = 0
    
    # Iterate over the number of bouquets
    for k in range(1, K + 1):
        # We want to keep track of the minimum value efficiently using a deque
        # min_deque will store tuples (min_value, index)
        for i in range(k, N + 1):
            current_min = float('inf')
            min_deque = deque()
            
            for j in range(i, k - 1, -1):
                # Update current_min
                current_min = min(current_min, T[j - 1])
                
                # Maintain the deque to ensure it's strictly increasing
                while min_deque and min_deque[-1][0] >= T[j - 1]:
                    min_deque.pop()
                
                # Add the current element to the deque
                min_deque.append((T[j - 1], j - 1))
                
                # The minimum element is always at the front of the deque
                current_min = min_deque[0][0]
                
                # Update dp[i][k] by considering this partition
                dp[i][k] = max(dp[i][k], dp[j - 1][k - 1] + current_min)
    
    # The answer is dp[N][K] which stores the maximum possible sum
    return dp[N][K]

# Input parsing
N, K = map(int, input().split())
T = list(map(int, input().split()))

# Output the result
print(max_beauty_sum(N, K, T))