BOP

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

int arrmax[1000001];
int agebaby_list[1000001];

typedef struct dnode_t {
    int data;
    struct dnode_t      \
        *next,
        *prev;
} DListNode, *DListNodePtr;

typedef struct deque_t {
    DListNodePtr _head, _tail;
    unsigned _size;
} Deque, *DequePtr;

DListNodePtr __dlist_createNode(int value)
{
    DListNodePtr newNode = (DListNodePtr) malloc (sizeof(DListNode));

    if (!newNode) return NULL;
    newNode->data = value;
    newNode->next = NULL;
    newNode->prev = NULL;

    return (DListNodePtr) newNode;
}

void deq_init(DequePtr deque)
{
    deque->_head = NULL;
    deque->_tail = NULL;
    deque->_size = (unsigned) 0;
}

bool deq_isEmpty(DequePtr deque) {
    return (deque->_head == NULL && deque->_tail == NULL);
}

void deq_pushFront(DequePtr deque, int value)
{
    DListNodePtr newNode = __dlist_createNode(value);
    if (newNode) {
        deque->_size++;
        if (deq_isEmpty(deque)) {
            deque->_head = newNode;
            deque->_tail = newNode;
            return;
        }

        newNode->next = deque->_head;
        deque->_head->prev = newNode;
        deque->_head = newNode;
    }
}

DListNodePtr deq_pushBack(DequePtr deque, int value)
{
    DListNodePtr newNode = __dlist_createNode(value);
    if (newNode) {
        deque->_size++;
        if (deq_isEmpty(deque)) {
            deque->_head = newNode;
            deque->_tail = newNode;
            return newNode;
        }

        deque->_tail->next = newNode;
        newNode->prev = deque->_tail;
        deque->_tail = newNode;
        return newNode;
    }
}

void deq_pushAt(DequePtr deque, int value, int position)
{

    if(position == 0){
        deq_pushFront(deque, value);
    }else if(position == deque->_size){
        deq_pushBack(deque, value);
    }else{
        DListNodePtr newNode = __dlist_createNode(value);
        DListNodePtr temp = deque->_head;
        if (newNode) {
            position--;
            while(position--){
                temp=temp->next;
                if(temp == NULL){
                    printf("Error : position out of range!\n");
                    return;
                }
            }

            newNode->prev = temp;
            newNode->next = temp->next;

            newNode->next->prev = newNode;
            temp->next=newNode;

            deque->_size++;
        }
    }
}

int deq_front(DequePtr deque) {
    if (!deq_isEmpty(deque)) {
        return (deque->_head->data);
    }
    return 0;
}

int deq_back(DequePtr deque) {
    if (!deq_isEmpty(deque)) {
        return (deque->_tail->data);
    }
    return 0;
}

void deq_popFront(DequePtr deque)
{
    if (!deq_isEmpty(deque)) {
        DListNodePtr temp = deque->_head;
        if (deque->_head == deque->_tail) {
            deque->_head = NULL;
            deque->_tail = NULL;
            free(temp);
        }
        else {
            deque->_head = deque->_head->next;
            deque->_head->prev = NULL;
            free(temp);
        }
        deque->_size--;
    }
}

void deq_popBack(DequePtr deque)
{
    if (!deq_isEmpty(deque)) {
        DListNodePtr temp;
        if (deque->_head == deque->_tail) {
            temp = deque->_head;
            deque->_head = NULL;
            deque->_tail = NULL;
            free(temp);
        }
        else {
            temp = deque->_tail;
            deque->_tail = deque->_tail->prev;
            deque->_tail->next = NULL;
            free(temp);
        }
        deque->_size--;
    }
}

void deq_popAt(DequePtr deque, int position)
{
    if (!deq_isEmpty(deque)) {

        if (position == 0){
            deq_popFront(deque);
        }
        else if(position==deque->_size-1){
            deq_popBack(deque);
        }else{
            DListNodePtr temp;
            temp = deque->_head;
            while(position--){
                temp=temp->next;
                if(temp==NULL){
                    printf("Error : position out of range\n");
                    return;
                }
            }

            temp->prev->next = temp->next;
            temp->next->prev = temp->prev;
            free(temp);
        }

        deque->_size--;
    }
}

void deq_Print(DequePtr deque){
    DListNodePtr temp;
    temp = deque->_head;
    printf("[!] Value of deque : ");
    while(temp!=NULL){
        printf("%d ", temp->data);
        temp=temp->next;
    }
    printf("\n");
}

void slidingWindows(int arr[], int n, int k)
{
    int j, max;
    int i;
    for (i = 0; i <= n - k; i++)
    {
        max = arr[i];

        for (j = 1; j < k; j++)
        {
            if (arr[i + j] > max)
                max = arr[i + j];
        }
        arrmax[i] = max;
    }
}

typedef struct Blockt {
    int value, localMax;
} Block, *BlockPtr;

typedef struct Stacks{
    BlockPtr S;
    int size, top;
}Stack,*StackPtr;

void Stack_init(StackPtr stk, int size){
    // Setting size of stack and
    // initial value of top
    stk->size=size;
    stk->S = malloc(size * sizeof(BlockPtr) );
    stk->top = -1;
}

void Stack_push(StackPtr stk, int value){
    if(stk->top == stk->size-1){
        // printf("STK is full\n");
    }else{
        stk->top++;
        if(stk->top == 0){
            stk->S[stk->top].value = value;
            stk->S[stk->top].localMax = value;
        }else{
            if( stk->S[stk->top -1].localMax > value ){
                stk->S[stk->top].value =value;
                stk->S[stk->top].localMax = stk->S[stk->top-1].localMax;
            }else{
                stk->S[stk->top].value =value;
                stk->S[stk->top].localMax =value;
            }
        }
        // printf("[!] Stack push : %d\n", value);
    }
}

void Stack_pop(StackPtr stk){
    if (stk->top == -1) {
        printf("Mau direfill, gan\n");
    }

    else {
        stk->top--;
        printf("Segera Dikirim\n");
    }
}

void Stack_max(StackPtr stk){
    if (stk->top == -1) {
        printf("Mau direfill, gan\n");
    }
    else {
        printf("%d\n", stk->S[stk->top].localMax);
    }
}

void Stack_top(StackPtr stk){
    if (stk->top == -1) {
        printf("Mau direfill, gan\n");
    }
    else {
        printf("%d\n", stk->S[stk->top].value);
    }
}

void printKMax(int arr[], int n, int k)
{
    Deque deqQi;
    deq_init(&deqQi);

    int i;
    for (i = 0; i < k; ++i) {
        while(!deq_isEmpty(&deqQi) && arr[i] >= arr[deq_back(&deqQi)]  ){
            deq_popBack(&deqQi);
        }
        deq_pushBack(&deqQi,i);
    }

    int counter=0;
    for (; i < n; ++i) {
        //printf("%d ", arr[deq_front(&deqQi)]);
        arrmax[counter]=arr[deq_front(&deqQi)];
        while(!deq_isEmpty(&deqQi) && deq_front(&deqQi) <= i-k ){
            deq_popFront(&deqQi);
        }

        while(!deq_isEmpty(&deqQi) && arr[i] >= arr[deq_back(&deqQi)]  ){
            deq_popBack(&deqQi);
        }

        deq_pushBack(&deqQi, i);
        counter++;
    }
    arrmax[counter]=arr[deq_front(&deqQi)];
}

int main(int argc, char const *argv[])
{
    int i;
    int M,N;
    scanf("%d %d", &M, &N);
    StackPtr stax = (StackPtr) malloc (sizeof(Stack));

    Stack_init(stax, M-N+1);

    for(i=0; i<M; i++){
        scanf("%d", &agebaby_list[i]);
    }

    printKMax(agebaby_list, M, N);

    int startat = 0;

    while(1){
        int D;
        int A;
        scanf("%d %d", &D, &A);

        if(A==-1 && D ==-1){
            break;
        }

        int ii;
        for(ii=startat; ii<D; ii++){
            Stack_push(stax, arrmax[ii]);
            startat++;
        }

        int j;
        for(j=0; j<A; j++){
            int K;
            scanf("%d", &K);
            if(K == 1){
                Stack_pop(stax);
            }else if(K == 2){
                Stack_max(stax);
            }
        }
    }
    return 0;