```go
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"math/bits"
)

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

func query(st [][]int, l, r int) int {
	sz := r - l + 1
	j := bits.Len(uint(sz)) - 1
	return max(st[j][l], st[j][r-(1<<j)+1])
}

func compute(L, R, kl, kr, days int, dp [][]int, pred [][]int, st [][]int) {
	if L > R {
		return
	}
	mid := (L + R) / 2
	best_val := math.MinInt32 / 2
	best_k := -1
	for cand_k := max(kl, days-1); cand_k <= min(kr, mid-1); cand_k++ {
		cost := query(st, cand_k+1, mid)
		val := dp[days-1][cand_k] + cost
		if val > best_val {
			best_val = val
			best_k = cand_k
		}
	}
	dp[days][mid] = best_val
	pred[days][mid] = best_k
	compute(L, mid-1, kl, best_k, days, dp, pred, st)
	compute(mid+1, R, best_k, kr, days, dp, pred, st)
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, k int
	fmt.Fscan(in, &n, &k)
	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(in, &a[i])
	}
	const logn = 11
	st := make([][]int, logn)
	for i := range st {
		st[i] = make([]int, n+1)
	}
	for i := 1; i <= n; i++ {
		st[0][i] = a[i]
	}
	for j := 1; j < logn; j++ {
		for i := 1; i+(1<<j)-1 <= n; i++ {
			st[j][i] = max(st[j-1][i], st[j-1][i+(1<<(j-1))])
		}
	}
	dp := make([][]int, k+1)
	pred := make([][]int, k+1)
	for i := 0; i <= k; i++ {
		dp[i] = make([]int, n+1)
		pred[i] = make([]int, n+1)
	}
	max_so_far := 0
	for p := 1; p <= n; p++ {
		max_so_far = max(max_so_far, a[p])
		dp[1][p] = max_so_far
		pred[1][p] = 0
	}
	for days := 2; days <= k; days++ {
		compute(days, n, days-1, n-1, days, dp, pred, st)
	}
	fmt.Println(dp[k][n])
	var sizes []int
	cur_days := k
	cur_p := n
	for cur_days >= 1 {
		prev_p := pred[cur_days][cur_p]
		problems_this_day := cur_p - prev_p
		sizes = append([]int{problems_this_day}, sizes...)
		cur_p = prev_p
		cur_days--
	}
	for i, t := range sizes {
		if i > 0 {
			fmt.Print(" ")
		}
		fmt.Print(t)
	}
	fmt.Println()
}
```