Design a Stack With Increment Operation

Design a Stack With Increment Operation - Problem

Design a stack that supports increment operations on its elements.

Implement the CustomStack class:

CustomStack(int maxSize) - Initializes the object with maxSize which is the maximum number of elements in the stack.
void push(int x) - Adds x to the top of the stack if the stack has not reached the maxSize.
int pop() - Pops and returns the top of the stack or -1 if the stack is empty.
void inc(int k, int val) - Increments the bottom k elements of the stack by val. If there are less than k elements in the stack, increment all the elements in the stack.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["CustomStack","push","push","pop","increment","pop","pop","pop"], values = [[3],[1],[2],[],[2,100],[],[],[]]

› Output: [null,null,null,2,null,101,100,-1]

💡 Note: Create stack with maxSize=3, push 1 and 2, pop returns 2, increment bottom 2 elements by 100, then pop returns 101, 100, and -1 (empty)

Example 2 — Full Stack

$ Input: operations = ["CustomStack","push","push","push","push"], values = [[2],[1],[2],[3],[4]]

› Output: [null,null,null,null,null]

💡 Note: Stack has maxSize=2, so only first 2 push operations add elements, remaining pushes are ignored

Example 3 — Empty Stack Operations

$ Input: operations = ["CustomStack","pop","increment"], values = [[1],[],[3,100]]

› Output: [null,-1,null]

💡 Note: Pop from empty stack returns -1, increment on empty stack does nothing

Constraints

1 ≤ maxSize ≤ 1000
1 ≤ x ≤ 1000
1 ≤ k ≤ 1000
0 ≤ val ≤ 100
At most 1000 calls will be made to each method of push, pop and increment.

Visualization

Tap to expand

Asked in

a Amazon 12 G Google 8 M Microsoft 6 f Facebook 4

The key insight is to use lazy propagation with an additional increment array. Instead of updating elements immediately, store increment values and apply them during pop operations. The optimal approach uses lazy propagation achieving O(1) time for all operations. Time: O(1), Space: O(maxSize).

Common Approaches

✓ Bit Manipulation

⏱️ Time: N/A Space: N/A

Array with Direct Increment

⏱️ Time: O(k) Space: O(n)

Store elements in an array and track the current size. For increment operations, iterate through the bottom k elements and add the value directly to each element.

Lazy Propagation with Increment Array

⏱️ Time: O(1) Space: O(n)

Maintain a separate increment array where inc[i] stores the increment value to be added to elements at index i and below. Apply increments lazily during pop operations for optimal performance.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int* stack;
    int* increment;
    int top;
    int maxSize;
} CustomStack;

CustomStack* customStackCreate(int maxSize) {
    CustomStack* obj = (CustomStack*)malloc(sizeof(CustomStack));
    obj->stack = (int*)malloc(maxSize * sizeof(int));
    obj->increment = (int*)calloc(maxSize, sizeof(int));
    obj->top = -1;
    obj->maxSize = maxSize;
    return obj;
}

void customStackPush(CustomStack* obj, int x) {
    if (obj->top < obj->maxSize - 1) {
        obj->top++;
        obj->stack[obj->top] = x;
    }
}

int customStackPop(CustomStack* obj) {
    if (obj->top == -1) {
        return -1;
    }
    
    int result = obj->stack[obj->top] + obj->increment[obj->top];
    
    if (obj->top > 0) {
        obj->increment[obj->top - 1] += obj->increment[obj->top];
    }
    
    obj->increment[obj->top] = 0;
    obj->top--;
    
    return result;
}

void customStackIncrement(CustomStack* obj, int k, int val) {
    if (obj->top == -1) return;
    
    int idx = (k - 1 < obj->top) ? k - 1 : obj->top;
    obj->increment[idx] += val;
}

void customStackFree(CustomStack* obj) {
    free(obj->stack);
    free(obj->increment);
    free(obj);
}

int parseNextInt(char** ptr) {
    while (**ptr && (**ptr < '0' || **ptr > '9') && **ptr != '-') (*ptr)++;
    if (!**ptr) return 0;
    
    int sign = 1;
    if (**ptr == '-') {
        sign = -1;
        (*ptr)++;
    }
    
    int num = 0;
    while (**ptr >= '0' && **ptr <= '9') {
        num = num * 10 + (**ptr - '0');
        (*ptr)++;
    }
    return num * sign;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    char* ptr2 = line2;
    int maxSize = parseNextInt(&ptr2);
    CustomStack* stack = customStackCreate(maxSize);
    
    printf("[");
    bool first = true;
    
    char* ptr1 = line1;
    while (*ptr1) {
        if (strncmp(ptr1, "push", 4) == 0) {
            int val = parseNextInt(&ptr2);
            customStackPush(stack, val);
            ptr1 += 4;
        } else if (strncmp(ptr1, "pop", 3) == 0) {
            int result = customStackPop(stack);
            if (!first) printf(",");
            printf("%d", result);
            first = false;
            ptr1 += 3;
        } else if (strncmp(ptr1, "increment", 9) == 0) {
            int k = parseNextInt(&ptr2);
            int val = parseNextInt(&ptr2);
            customStackIncrement(stack, k, val);
            ptr1 += 9;
        } else {
            ptr1++;
        }
    }
    
    printf("]\n");
    
    customStackFree(stack);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

89.6K Views

Medium Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen