Design a Stack With Increment Operation - Practice Coding Problems

Design a Stack With Increment Operation - Problem

Design a custom stack data structure that supports traditional stack operations (push and pop) along with a special increment operation that can modify multiple elements at once.

Your task is to implement the CustomStack class with the following methods:

CustomStack(int maxSize): Initialize the stack with a maximum capacity
void push(int x): Add element x to the top of the stack (only if capacity allows)
int pop(): Remove and return the top element, or -1 if empty
void inc(int k, int val): Add val to the bottom k elements of the stack

Challenge: The increment operation should be efficient even when performed frequently on large stacks!

Input & Output

basic_operations.py — Python

$ Input: ["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"] [[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]

› Output: [null,null,null,2,null,null,null,null,null,103,202,201,-1]

💡 Note: CustomStack stk = new CustomStack(3); // Stack is Empty [] stk.push(1); // stack becomes [1] stk.push(2); // stack becomes [1, 2] stk.pop(); // return 2 --> Return top of the stack, stack becomes [1] stk.push(2); // stack becomes [1, 2] stk.push(3); // stack becomes [1, 2, 3] stk.push(4); // stack still [1, 2, 3], Don't add another element as size is 4 stk.increment(5,100); // stack becomes [101, 102, 103] stk.increment(2,100); // stack becomes [201, 202, 103] stk.pop(); // return 103 --> Return top of the stack, stack becomes [201, 202] stk.pop(); // return 202 --> Return top of the stack, stack becomes [201] stk.pop(); // return 201 --> Return top of the stack, stack becomes [] stk.pop(); // return -1 --> Stack is empty return -1.

capacity_limits.py — Python

$ Input: ["CustomStack","push","push","push","push","increment","pop"] [[2],[1],[2],[3],[4],[2,10],[]]

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

💡 Note: Stack with capacity 2. Push 1,2 successfully, push 3,4 ignored due to capacity. increment(2,10) adds 10 to bottom 2 elements. Pop returns 2+10=12.

empty_stack_edge_case.py — Python

$ Input: ["CustomStack","pop","increment","pop"] [[1],[],[1,100],[]]

› Output: [null,-1,null,-1]

💡 Note: Operations on empty stack. Pop returns -1, increment on empty stack does nothing, pop still returns -1.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Stack Setup

Initialize empty stack with maximum capacity

Push Operations

Add elements to top of stack (like stacking plates)

Increment Magic

Mark bottom k elements for future bonus (lazy approach)

Pop with Bonus

Remove top element and apply accumulated bonuses

Key Takeaway

🎯 Key Insight: Lazy propagation transforms an O(k) increment operation into O(1) by deferring the actual work until elements are popped

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses lazy propagation to achieve O(1) time complexity for all operations. Instead of immediately applying increments, we defer them using an auxiliary array and apply them during pop operations, making this approach highly efficient for frequent increment calls.

Common Approaches

Approach	Time	Space	Notes
✓ Lazy Propagation (Optimal)	O(1) for all operations	O(maxSize)	Use auxiliary array to defer increment operations until pop
Direct Array Modification	O(k) per increment, O(1) for push/pop	O(maxSize)	Modify elements directly during increment operation

Lazy Propagation (Optimal) — Algorithm Steps

Maintain main stack array and auxiliary increment array
For increment(k, val), add val to increment[k-1] position only
During pop, apply accumulated increments and propagate to previous element
Reset increment value after applying it during pop

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Stack: [1,2,3,4], Increments: [0,0,0,0]

Increment Operation

increment(3,10) only modifies increment[2] = 10

Pop Operation

Pop applies and propagates increments lazily

Code -

solution.c — C

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

CustomStack* customStackCreate(int maxSize) {
    CustomStack* obj = (CustomStack*)malloc(sizeof(CustomStack));
    obj->stack = (int*)malloc(maxSize * sizeof(int));
    obj->incrementArr = (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->stack[++obj->top] = x;
    }
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(1) for all operations

Push, pop, and increment all execute in constant time using lazy propagation

✓ Linear Growth

Space Complexity

O(maxSize)

Need space for both stack and increment arrays, both size maxSize

✓ Linear Space

46.2K Views

Medium Frequency

~15 min Avg. Time

1.6K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Lazy Propagation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler