#include <bits/stdc++.h>

using i64 = long long;
using i128 = __int128_t;

constexpr i64 inf = 1e12;

using P = std::complex<i64>;
auto dot(const P &a, const P &b) {
    return (std::conj(a) * b).real();
}
auto cross(const P &a, const P &b) {
    return (std::conj(a) * b).imag();
}
struct ConvexHull {
    std::vector<P> s;
    int pos = 0;
    void add(const P &x) {
        assert(s.empty() || s.back().real() <= x.real());
        while (s.size() >= 2 && cross(x - s.back(), x - s.end()[-2]) <= 0) {
            s.pop_back();
        }
        s.push_back(x);
    }
    i64 lst = -inf;
    i64 query(i64 x) {
        assert(lst <= x);
        lst = x;
        if (s.empty()) {
            return -inf;
        }
        P p(x, 1);
        while (pos + 1 < int(s.size()) && dot(s[pos], p) <= dot(s[pos + 1], p)) {
            ++pos;
        }
        return dot(s[pos], p);
    }
};

struct Interval {
    int l, r, b, e, x;
};
struct Solver {
    std::vector<std::vector<P>> sf;
    std::vector<std::vector<int>> sg;
    std::vector<ConvexHull> f, g;
    std::vector<P> points;
    Solver() {}
    void addF(int u, int l, int r, int p, const P &x) {
        sf[u].push_back(x);
        if (p == r - 1) {
            std::reverse(sf[u].begin(), sf[u].end());
            for (auto x : sf[u]) {
                f[u].add(x);
            }
        }
        if (r - l == 1) {
            return;
        }
        int m = (l + r) / 2;
        if (p < m) {
            addF(u << 1, l, m, p, x);
        } else {
            addF(u << 1 | 1, m, r, p, x);
        }
    }
    void addG(int u, int l, int r, int ql, int qr, int x) {
        if (r <= ql || qr <= l) {
            return;
        }
        if (ql <= l && r <= qr) {
            sg[u].push_back(x);
            return;
        }
        int m = (l + r) / 2;
        addG(u << 1, l, m, ql, qr, x);
        addG(u << 1 | 1, m, r, ql, qr, x);
    }
    i64 queryF(int u, int l, int r, int ql, int qr, i64 x) {
        if (r <= ql || qr <= l) {
            return -inf;
        }
        if (ql <= l && r <= qr) {
            return f[u].query(x);
        }
        int m = (l + r) / 2;
        return std::max(queryF(u << 1, l, m, ql, qr, x), queryF(u << 1 | 1, m, r, ql, qr, x));
    }
    i64 queryG(int u, int l, int r, int p, i64 x) {
        if (p == l) {
            for (auto x : sg[u]) {
                g[u].add(points[x]);
            }
        }
        i64 res = g[u].query(x);
        if (r - l > 1) {
            int m = (l + r) / 2;
            if (p < m) {
                res = std::max(res, queryG(u << 1, l, m, p, x));
            } else {
                res = std::max(res, queryG(u << 1 | 1, m, r, p, x));
            }
        }
        return res;
    }
    void solve(int n, const std::vector<i64> &sum, const std::vector<Interval> &intervals) {
        sf.resize(4 << std::__lg(n));
        f.resize(4 << std::__lg(n));
        sg.resize(4 << std::__lg(n + 1));
        g.resize(4 << std::__lg(n + 1));

        const int m = int(intervals.size());
        points.resize(m);
        std::vector<int> ord(m);
        std::iota(ord.begin(), ord.end(), 0);
        std::sort(ord.begin(), ord.end(), [&](int x, int y) {
            return intervals[x].x < intervals[y].x;
        });
        for (auto i : ord) {
            addG(1, 0, n + 1, intervals[i].b, intervals[i].e, i);
        }

        std::sort(ord.begin(), ord.end(), [&](int x, int y) {
            return intervals[x].b < intervals[y].b;
        });
        for (int i = 0, j = 0; i <= n; ++i) {
            i64 dp = i == 0 ? 0 : queryG(1, 0, n + 1, i, sum[i]);
            // std::cerr << "dp " << i << ": " << dp << "\n";
            if (i == n) {
                std::cout << dp << "\n";
                return;
            }
            addF(1, 0, n, i, P(-sum[i], dp));
            while (j < m && intervals[ord[j]].b == i + 1) {
                auto v = intervals[ord[j]];
                // std::cerr << i << ": " << ord[j] << " " << v.l << " " << v.r << " = " <<
                // queryF(1, 0, n, v.l, v.r, v.x) << "\n";
                points[ord[j]] = P(v.x, queryF(1, 0, n, v.l, v.r, v.x));
                assert(points[ord[j]].imag() >= -inf / 2);
                // std::cerr << ord[j] << ": " << points[ord[j]] << "\n";
                ++j;
            }
        }
    }
};

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int n, k;
    std::cin >> n >> k;

    std::vector<int> a(n);
    std::vector<std::vector<int>> pos(n + 1, {-1});
    for (int i = 0; i < n; ++i) {
        std::cin >> a[i];
        pos[a[i]].push_back(i);
    }

    std::map<int, int> mp;
    for (int i = 0; i <= n; ++i) {
        mp[i] = i;
    }
    std::vector<Interval> intervals;
    auto add = [&](int l, int r, int b, int e, int x) {
        // L: [l, r), R: [b, e), mex[L, R) = x
        l = std::max(l, r - k);
        if (b - r >= k) {
            return;
        }
        intervals.push_back({l, r, b, std::min(e, l + k + 1), x});
        for (int i = l + k + 1; i < e && i - r < k; ++i) {
            intervals.push_back({i - k, r, i, i + 1, x});
        }
    };
    for (int x = 0; x <= n; ++x) {
        pos[x].push_back(n);
        for (int i = 0; i < int(pos[x].size()) - 1; ++i) {
            int l = pos[x][i] + 1, r = pos[x][i + 1];
            int v = std::prev(mp.upper_bound(l))->second;
            if (v >= r) {
                continue;
            }
            for (auto it = mp.emplace(l, v).first; it->second < r; it = mp.erase(it)) {
                add(it->first, std::next(it)->first, it->second + 1, r + 1, x);
            }
            mp[l] = r;
        }
    }

    std::vector<i64> sum(n + 1);
    for (int i = 0; i < n; ++i) {
        sum[i + 1] = sum[i] + a[i];
    }

    // for (auto [l, r, b, e, x] : intervals) {
    //     std::cerr << l << " " << r << " " << b << " " << e << " " << x << "\n";
    // }

    Solver().solve(n, sum, intervals);

    return 0;
}