Maximum Frequency Stack

Maximum Frequency Stack - Problem

Design a stack-like data structure to push elements to the stack and pop the most frequent element from the stack.

Implement the FreqStack class:

FreqStack() constructs an empty frequency stack.
void push(int val) pushes an integer val onto the top of the stack.
int pop() removes and returns the most frequent element in the stack. If there is a tie for the most frequent element, the element closest to the stack's top is removed and returned.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["FreqStack", "push", "push", "push", "push", "push", "push", "pop", "pop", "pop", "pop"], values = [null, 5, 7, 5, 7, 4, 5, null, null, null, null]

› Output: [null, null, null, null, null, null, null, 5, 7, 5, 4]

💡 Note: After pushes: 5(freq=3), 7(freq=2), 4(freq=1). Pop returns most frequent: 5, then 7, then 5, then 4.

Example 2 — Tie Breaking

$ Input: operations = ["FreqStack", "push", "push", "push", "pop", "pop"], values = [null, 1, 2, 3, null, null]

› Output: [null, null, null, null, 3, 2]

💡 Note: All elements have frequency 1, so pop returns most recent: 3, then 2.

Example 3 — Same Element Multiple Times

$ Input: operations = ["FreqStack", "push", "push", "pop", "pop"], values = [null, 1, 1, null, null]

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

💡 Note: Push 1 twice (freq=2), pop returns 1 (freq becomes 1), pop returns 1 again.

Constraints

1 ≤ val ≤ 10⁹
At most 2 × 10⁴ calls to push and pop
It is guaranteed that there will be at least one element in the stack before calling pop

Visualization

Tap to expand

Asked in

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

The key insight is to group elements by frequency in separate stacks, enabling O(1) operations. Best approach uses frequency map with frequency-level stacks. Time: O(1), Space: O(n)

Common Approaches

✓ Backtracking

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

Brute Force with Linear Search

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

Keep all elements in a list and maintain a frequency count. For each pop operation, scan through all elements to find the most frequent one, breaking ties by position.

Frequency Map with Stacks

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

Maintain a frequency map and create separate stacks for each frequency level. This allows O(1) push and pop operations by always knowing the maximum frequency.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_NODES 1000
#define MAX_LINE 10000

struct Edge {
    int to;
    int time;
    struct Edge* next;
};

struct Edge* graph[MAX_NODES];
int values[MAX_NODES];
bool visited[MAX_NODES];
int shortestToZero[MAX_NODES];
int maxQuality;
int n;

void addEdge(int from, int to, int time) {
    struct Edge* edge = malloc(sizeof(struct Edge));
    edge->to = to;
    edge->time = time;
    edge->next = graph[from];
    graph[from] = edge;
}

void bfsShortestToZero() {
    for (int i = 0; i < n; i++) {
        shortestToZero[i] = INT_MAX;
    }
    shortestToZero[0] = 0;
    
    int queue[MAX_NODES];
    int front = 0, rear = 0;
    queue[rear++] = 0;
    
    while (front < rear) {
        int node = queue[front++];
        struct Edge* edge = graph[node];
        
        while (edge) {
            int nextNode = edge->to;
            int time = edge->time;
            if (shortestToZero[node] + time < shortestToZero[nextNode]) {
                shortestToZero[nextNode] = shortestToZero[node] + time;
                queue[rear++] = nextNode;
            }
            edge = edge->next;
        }
    }
}

void dfs(int node, int timeLeft, int currentQuality, int maxTime) {
    // If at node 0, update max quality (including initial call)
    if (node == 0) {
        if (currentQuality > maxQuality) {
            maxQuality = currentQuality;
        }
    }
    
    // Pruning: if we can't return to 0, skip this path
    if (timeLeft < shortestToZero[node]) {
        return;
    }
    
    // Try all neighbors
    struct Edge* edge = graph[node];
    while (edge) {
        int nextNode = edge->to;
        int travelTime = edge->time;
        
        if (timeLeft >= travelTime) {
            int newQuality = currentQuality;
            bool wasVisited = visited[nextNode];
            
            if (!wasVisited) {
                newQuality += values[nextNode];
            }
            
            visited[nextNode] = true;
            dfs(nextNode, timeLeft - travelTime, newQuality, maxTime);
            
            if (!wasVisited) {
                visited[nextNode] = false;
            }
        }
        
        edge = edge->next;
    }
}

int parseArray(char* line, int* arr) {
    int count = 0;
    int len = strlen(line);
    if (len <= 2) return 0; // Empty array []
    
    int i = 1; // Skip [
    int num = 0;
    bool inNumber = false;
    
    while (i < len - 1) {
        if (line[i] >= '0' && line[i] <= '9') {
            num = num * 10 + (line[i] - '0');
            inNumber = true;
        } else if (line[i] == ',' || i == len - 2) {
            if (inNumber) {
                arr[count++] = num;
                num = 0;
                inNumber = false;
            }
        }
        i++;
    }
    
    return count;
}

int parse2DArray(char* line, int edges[][3]) {
    int count = 0;
    int len = strlen(line);
    if (len <= 2) return 0;
    
    int i = 1;
    while (i < len - 1) {
        if (line[i] == '[') {
            int j = i + 1;
            int nums[3];
            int numCount = 0;
            int num = 0;
            bool inNumber = false;
            
            while (j < len && line[j] != ']') {
                if (line[j] >= '0' && line[j] <= '9') {
                    num = num * 10 + (line[j] - '0');
                    inNumber = true;
                } else if (line[j] == ',') {
                    if (inNumber) {
                        nums[numCount++] = num;
                        num = 0;
                        inNumber = false;
                    }
                }
                j++;
            }
            if (inNumber) {
                nums[numCount++] = num;
            }
            
            if (numCount == 3) {
                edges[count][0] = nums[0];
                edges[count][1] = nums[1];
                edges[count][2] = nums[2];
                count++;
            }
            i = j;
        }
        i++;
    }
    
    return count;
}

int main() {
    char line[MAX_LINE];
    
    // Parse values
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    n = parseArray(line, values);
    
    // Parse edges
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int edges[2000][3];
    int edgeCount = parse2DArray(line, edges);
    
    // Parse maxTime
    fgets(line, sizeof(line), stdin);
    int maxTime = atoi(line);
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graph[i] = NULL;
        visited[i] = false;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgeCount; i++) {
        addEdge(edges[i][0], edges[i][1], edges[i][2]);
        addEdge(edges[i][1], edges[i][0], edges[i][2]);
    }
    
    bfsShortestToZero();
    maxQuality = values[0];
    visited[0] = true;
    dfs(0, maxTime, values[0], maxTime);
    
    printf("%d\n", maxQuality);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

89.5K Views

Medium Frequency

~25 min Avg. Time

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