#include <cstddef>

template<typename T>
class Deque
{
public:
    Deque() = default;
    Deque(const std::size_t count, const T& value)
        : capacity(count)
    {
        data = new T[count];
        for(std::size_t i = 0; i < count; ++i)
        {
            data[i] = value;
        }
        endidx = count;
    }
    ~Deque()
    {
        if(data != nullptr)
        {
            delete[] data;
        }
    }

    void push_back(const T& value)
    {
        if(data != nullptr)
        {
            if(endidx == capacity)
            {
                extend_right(capacity * 2);
            }
            data[endidx] = value;
            ++endidx;
        }
        else
        {
            data = new T[1];
            *data = value;
            capacity = 1;
            endidx = 1;
        }
    }

    void push_front(const T& value)
    {
        if(data != nullptr)
        {
            if(begidx == 0)
            {
                extend_left(size(), size() * 2);
            }
            --begidx;
            data[begidx] = value;
        }
        else
        {
            data = new T[1];
            *data = value;
            capacity = 1;
            endidx = 1;
        }
    }

    void pop_back()
    {
        --endidx;
    }

    void pop_front()
    {
        ++begidx;
    }

    T& front()
    {
        return data[begidx];
    }

    T& back()
    {
        return data[endidx - 1];
    }

    const T& front() const
    {
        return data[begidx];
    }

    const T& back() const
    {
        return data[endidx - 1];
    }

    T* begin()
    {
        return (data + begidx);
    }

    T* end()
    {
        return (data + endidx);
    }

    const T* begin() const
    {
        return (data + begidx);
    }

    const T* end() const
    {
        return (data + endidx);
    }

    std::size_t size() const
    {
        if(data != nullptr)
        {
            return endidx - begidx;
        }
        return 0;
    }

    bool empty() const
    {
        return (data == nullptr || begidx == endidx);
    }

private:
    void extend_left(const std::size_t currentsize, const std::size_t newsize)
    {
        T* newdata = new T[newsize];

        const std::size_t difference = newsize - currentsize;
        for(std::size_t i = begidx + difference; i < endidx + difference; ++i)
        {
            newdata[i] = data[i - difference];
        }

        delete[] data;

        data = newdata;
        begidx += difference;
        endidx += difference;
        capacity = newsize;
    }

    void extend_right(const std::size_t newsize)
    {
        T* newdata = new T[newsize];
        for(std::size_t i = begidx; i < endidx; ++i)
        {
            newdata[i] = data[i];
        }

        delete[] data;

        data = newdata;
        capacity = newsize;
    }

private:
    T* data = nullptr;
    std::size_t begidx = 0;
    std::size_t endidx = 0;
    std::size_t capacity = 0;
};

#include <fstream>

int main()
{
    std::ifstream fin("deque.in");
    std::ofstream fout("deque.out");

    std::size_t N;
    std::size_t K;
    fin >> N >> K;

    int* vec = new int[N];
    for(std::size_t i = 0; i < N; ++i)
    {
        fin >> vec[i];
    }

    Deque<std::size_t> deq;
    std::int64_t suma = 0;

    for(std::size_t i = 0; i < N; ++i)
    {
        while(!deq.empty() && vec[i] <= vec[deq.back()])
        {
            deq.pop_back();
        }
        deq.push_back(i);

        if(i - deq.front() == K)
        {
            deq.pop_front();
        }
        if(i + 1 >= K)
        {
            suma += vec[deq.front()];
        }
    }

    fout << suma << '\n';
    delete[] vec;
}