#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
} Node;

typedef struct {
    Node* front;
    Node* back;
} Deque;

Deque* createDeque() {
    Deque* deque = (Deque*)malloc(sizeof(Deque));
    deque->front = NULL;
    deque->back = NULL;
    return deque;
}

int isEmpty(const Deque* deque) {
    return (deque->front == NULL && deque->back == NULL);
}

void pushFront(Deque* deque, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = deque->front;
    newNode->prev = NULL;

    if (isEmpty(deque)) {
        deque->front = newNode;
        deque->back = newNode;
    } else {
        deque->front->prev = newNode;
        deque->front = newNode;
    }
}

void pushBack(Deque* deque, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    newNode->prev = deque->back;

    if (isEmpty(deque)) {
        deque->front = newNode;
        deque->back = newNode;
    } else {
        deque->back->next = newNode;
        deque->back = newNode;
    }
}

int popFront(Deque* deque) {
    if (isEmpty(deque)) {
        return -1; // Error: Deque vacío
    }

    Node* frontNode = deque->front;
    int frontData = frontNode->data;

    deque->front = frontNode->next;

    if (deque->front == NULL) {
        deque->back = NULL;
    } else {
        deque->front->prev = NULL;
    }

    free(frontNode);

    return frontData;
}

int popBack(Deque* deque) {
    if (isEmpty(deque)) {
        return -1; // Error: Deque vacío
    }

    Node* backNode = deque->back;
    int backData = backNode->data;

    deque->back = backNode->prev;

    if (deque->back == NULL) {
        deque->front = NULL;
    } else {
        deque->back->next = NULL;
    }

    free(backNode);

    return backData;
}

int front(const Deque* deque) {
    if (isEmpty(deque)) {
        return -1; // Error: Deque vacío
    }

    return deque->front->data;
}

int back(const Deque* deque) {
    if (isEmpty(deque)) {
        return -1; // Error: Deque vacío
    }

    return deque->back->data;
}

void destroyDeque(Deque* deque) {
    while (!isEmpty(deque)) {
        popFront(deque);
    }

    free(deque);
}

int main() {
    FILE* inputFile, * outputFile;
    inputFile = fopen("deque.in", "r");
    outputFile = fopen("deque.out", "w");

    int N, K;
    fscanf(inputFile, "%d %d", &N, &K);

    int* vector = (int*)malloc(N * sizeof(int));

    // Leer los elementos del vector y almacenarlos en un arreglo
    for (int i = 0; i < N; i++) {
        fscanf(inputFile, "%d", &vector[i]);
    }

    Deque* deque = createDeque();
    long long int sum = 0;

    // Calcular la suma de los elementos mínimos en cada subsecuencia
    for (int i = 0; i < N; i++) {
        // Mantener el tamaño máximo de la ventana
        if (i >= K) {
            int frontNum = front(deque);
            if (vector[i - K] == frontNum) {
                popFront(deque);
            }
        }

        // Eliminar los elementos mayores al elemento actual del deque
        while (!isEmpty(deque) && back(deque) > vector[i]) {
            popBack(deque);
        }

        pushBack(deque, vector[i]);

        // Calcular la suma de los elementos mínimos cuando se alcanza el tamaño de la ventana
        if (i >= K - 1) {
            sum += front(deque);
        }
    }

    fprintf(outputFile, "%lld\n", sum);

    fclose(inputFile);
    fclose(outputFile);

    destroyDeque(deque);
    free(vector);

    return 0;
}