MFU Cache Implementation - Problem

Implement a Most Frequently Used (MFU) Cache data structure that supports the following operations:

get(key): Get the value of the key if it exists in the cache, otherwise return -1
put(key, value): Set or insert the value if the key is not already present. When the cache reaches its capacity, it should invalidate the most frequently used item before inserting a new item

The cache should track the frequency of access for each key. When multiple keys have the same highest frequency, remove the least recently used among them.

Both get and put operations must run in O(1) average time complexity.

Input & Output

Example 1 — Basic Operations

$ Input: capacity = 2, operations = [["put",1,10],["put",2,20],["get",1],["put",3,30],["get",2]]

› Output: [10,-1]

💡 Note: Put (1,10), put (2,20), get 1 returns 10 (freq becomes 2). Put (3,30) evicts key 2 (freq 1 < freq 2). Get 2 returns -1 (not found).

Example 2 — Frequency Ties

$ Input: capacity = 2, operations = [["put",1,10],["put",2,20],["get",1],["get",2],["put",3,30]]

› Output: [10,20]

💡 Note: Both keys have freq 2 after gets. When putting (3,30), evict key 1 (inserted earlier than key 2, so less recently used among ties).

Example 3 — Single Capacity

$ Input: capacity = 1, operations = [["put",1,10],["get",1],["put",2,20],["get",1],["get",2]]

› Output: [10,-1,20]

💡 Note: Get 1 increases its frequency to 2. Put (2,20) cannot evict key 1 (freq 2 > freq 1 of new key), so key 1 stays. Wait, this is MFU so we evict the MORE frequent - key 1 gets evicted. Get 1 returns -1, get 2 returns 20.

Constraints

0 ≤ capacity ≤ 10⁴
1 ≤ key, value ≤ 10⁵
At most 2 × 10⁵ calls to get and put

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is using hash maps for O(1) key lookup combined with frequency-grouped linked lists for O(1) eviction. Unlike LRU which evicts least recent, MFU evicts the most frequently used item. Best approach uses hash map + frequency groups: Time O(1), Space O(n)

Common Approaches

✓ Brute Force with Linear Search

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

Use a simple list to store cache entries with frequency counters. On every eviction, scan through all entries to find the most frequently used item, breaking ties by selecting the least recently used.

Hash Map + Frequency Groups

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

Combine a hash map for O(1) key lookup with frequency-based groupings. Each frequency level maintains a list of keys in insertion order, allowing O(1) identification of eviction candidates.

Brute Force with Linear Search — Algorithm Steps

Store entries in a list with frequency and timestamp
On get: scan list to find key, update frequency and timestamp
On put: if full, scan entire list to find MFU (then LRU among ties) for eviction

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Entries

Keep cache entries with frequency and timestamp

Linear Scan

Check every entry to find maximum frequency

Find LRU

Among tied frequencies, pick oldest timestamp

Code -

solution.c — C

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

typedef struct {
    int key;
    int value;
    int frequency;
    int timestamp;
} CacheEntry;

typedef struct {
    int capacity;
    CacheEntry* cache;
    int size;
    int time;
} MFUCache;

MFUCache* createCache(int capacity) {
    MFUCache* cache = (MFUCache*)malloc(sizeof(MFUCache));
    cache->capacity = capacity;
    cache->cache = (CacheEntry*)malloc(capacity * sizeof(CacheEntry));
    cache->size = 0;
    cache->time = 0;
    return cache;
}

int get(MFUCache* cache, int key) {
    for (int i = 0; i < cache->size; i++) {
        if (cache->cache[i].key == key) {
            cache->time++;
            cache->cache[i].frequency++;
            cache->cache[i].timestamp = cache->time;
            return cache->cache[i].value;
        }
    }
    return -1;
}

void put(MFUCache* cache, int key, int value) {
    cache->time++;
    
    // Update existing key
    for (int i = 0; i < cache->size; i++) {
        if (cache->cache[i].key == key) {
            cache->cache[i].value = value;
            cache->cache[i].frequency++;
            cache->cache[i].timestamp = cache->time;
            return;
        }
    }
    
    // Add new key
    if (cache->size < cache->capacity) {
        cache->cache[cache->size] = (CacheEntry){key, value, 1, cache->time};
        cache->size++;
    } else {
        // Find MFU item (LRU among ties)
        int maxFreq = 0;
        for (int i = 0; i < cache->size; i++) {
            if (cache->cache[i].frequency > maxFreq) {
                maxFreq = cache->cache[i].frequency;
            }
        }
        
        int evictIdx = -1;
        int minTime = INT_MAX;
        
        for (int i = 0; i < cache->size; i++) {
            if (cache->cache[i].frequency == maxFreq && cache->cache[i].timestamp < minTime) {
                minTime = cache->cache[i].timestamp;
                evictIdx = i;
            }
        }
        
        cache->cache[evictIdx] = (CacheEntry){key, value, 1, cache->time};
    }
}

int* solution(int capacity, int operations[][3], int operationsSize, int* returnSize) {
    MFUCache* cache = createCache(capacity);
    int* results = (int*)malloc(operationsSize * sizeof(int));
    int resultCount = 0;
    
    for (int i = 0; i < operationsSize; i++) {
        if (operations[i][0] == 1) { // get
            results[resultCount++] = get(cache, operations[i][1]);
        } else { // put
            put(cache, operations[i][1], operations[i][2]);
        }
    }
    
    *returnSize = resultCount;
    free(cache->cache);
    free(cache);
    return results;
}

int main() {
    int capacity;
    scanf("%d", &capacity);
    
    // Simplified input handling
    int operations[100][3];
    int operationsSize = 0;
    
    int* returnSize = (int*)malloc(sizeof(int));
    int* result = solution(capacity, operations, operationsSize, returnSize);
    
    printf("[");
    for (int i = 0; i < *returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    free(returnSize);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation requires scanning through all cache entries

✓ Linear Growth

Space Complexity

O(n)

Storage for n cache entries with metadata

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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

MFU Cache Implementation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler