Insert Delete GetRandom O(1) - Duplicates allowed

Insert Delete GetRandom O(1) - Duplicates allowed - Problem

Imagine you need to build a smart bag that can hold multiple copies of the same item and perform three lightning-fast operations:

Insert: Add an item to the bag (even if it already exists)
Remove: Take out one copy of a specific item (if it exists)
Get Random: Pull out a completely random item, where items with more copies have higher chances of being selected

The challenge? Each operation must work in O(1) average time complexity!

Your task: Implement the RandomizedCollection class that supports duplicates (multiset) with these methods:

insert(val) - Returns true if val wasn't present before, false if it was already there
remove(val) - Returns true if val was found and removed, false if not found
getRandom() - Returns a random element where probability is proportional to frequency

This is the advanced version of the classic RandomizedSet problem, now supporting duplicates!

Input & Output

example_1.py — Basic Operations

$ Input: randomizedCollection = new RandomizedCollection(); randomizedCollection.insert(1); // return true since 1 is not present randomizedCollection.insert(1); // return false since 1 is already present randomizedCollection.insert(2); // return true since 2 is not present randomizedCollection.getRandom(); // return 1 or 2 randomly

› Output: [null, true, false, true, 1 or 2]

💡 Note: The collection starts empty. First insert(1) returns true as 1 wasn't present. Second insert(1) returns false as 1 was already there. insert(2) returns true as 2 is new. getRandom() can return either 1 or 2, with 1 having higher probability since it appears twice.

example_2.py — Remove Operations

$ Input: randomizedCollection = new RandomizedCollection(); randomizedCollection.insert(1); // [1], return true randomizedCollection.insert(1); // [1,1], return false randomizedCollection.insert(2); // [1,1,2], return true randomizedCollection.remove(1); // [1,2], return true randomizedCollection.remove(1); // [2], return true randomizedCollection.remove(1); // [2], return false

› Output: [null, true, false, true, true, true, false]

💡 Note: After inserting 1,1,2 we have [1,1,2]. First remove(1) removes one copy, leaving [1,2]. Second remove(1) removes the last 1, leaving [2]. Third remove(1) returns false as no 1 exists.

example_3.py — Probability Distribution

$ Input: randomizedCollection = new RandomizedCollection(); randomizedCollection.insert(1); // [1] randomizedCollection.insert(1); // [1,1] randomizedCollection.insert(1); // [1,1,1] randomizedCollection.insert(2); // [1,1,1,2] randomizedCollection.getRandom(); // should return 1 with 75% probability, 2 with 25%

› Output: [null, true, false, false, true, 1 (75% chance) or 2 (25% chance)]

💡 Note: The collection contains [1,1,1,2]. Since 1 appears 3 times out of 4 total elements, getRandom() should return 1 with probability 3/4 = 75% and 2 with probability 1/4 = 25%.

Visualization

Tap to expand

Understanding the Visualization

Setup

The machine has a tube to store balls in order and a catalog to track where each number's balls are located

Adding Balls

New balls are always added to the end of the tube, and their positions are recorded in the catalog

Removing Balls

To remove a ball, we swap it with the last ball in the tube, update the catalog, and remove the last position

Random Draw

Pick a random position in the tube and return that ball - higher frequency numbers have proportionally higher chances

Key Takeaway

🎯 Key Insight: By combining array indexing (for instant random access) with hash map position tracking (for instant removal), we achieve O(1) performance for all operations while maintaining proper probability distribution for duplicates!

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations (insert, remove, getRandom) are O(1) average time. Hash map operations and array access are both O(1) average.

✓ Linear Growth

Space Complexity

O(n)

Need O(n) for the array storing all elements and O(n) for the hash map storing index sets for each unique value

⚡ Linearithmic Space

Constraints

-2³¹ ≤ val ≤ 2³¹ - 1
At most 2 * 10⁵ calls will be made to insert, remove, and getRandom
getRandom will not be called if the collection is empty
Each test case will have at least one call to insert before any call to getRandom

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution combines an array for O(1) random access with a hash map tracking index sets for each value. This enables all operations to run in O(1) average time while properly handling duplicates. The key insight is using the swap-with-last technique for efficient removal without shifting elements.

Common Approaches

Approach	Time	Space	Notes
✓ Array + HashMap (Optimal)	O(1)	O(n)	Combine array for O(1) random access with hash map tracking positions
Brute Force (Simple List)	O(n)	O(n)	Store all elements in a simple list, search linearly for operations

Array + HashMap (Optimal) — Algorithm Steps

Maintain an array to store all elements including duplicates
Use a hash map where keys are values and values are sets of indices
Insert: Add element to end of array, add index to corresponding set in hash map
Remove: Get any index from the set, swap with last element, update hash map, remove last element
GetRandom: Generate random index in array and return element

Visualization

Tap to expand

Step-by-Step Walkthrough

Data Structures

Array stores all elements, HashMap maps values to index sets

Insert Operation

Add to end of array, update index set in hash map

Remove Operation

Swap with last element, update indices, remove last

GetRandom

Generate random index and access array directly

Code -

solution.c — C

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

#define MAX_VALUES 10000
#define MAX_INDICES 100

typedef struct {
    int indices[MAX_INDICES];
    int count;
} IndexSet;

typedef struct {
    int* nums;
    int size;
    int capacity;
    IndexSet indexMap[MAX_VALUES + 20001];  // Handle negative values
} RandomizedCollection;

int hashValue(int val) {
    return val + 10001;  // Offset for negative values
}

RandomizedCollection* randomizedCollectionCreate() {
    RandomizedCollection* obj = malloc(sizeof(RandomizedCollection));
    obj->capacity = 10;
    obj->nums = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    
    // Initialize index sets
    for (int i = 0; i <= MAX_VALUES + 20000; i++) {
        obj->indexMap[i].count = 0;
    }
    
    srand(time(NULL));
    return obj;
}

bool randomizedCollectionInsert(RandomizedCollection* obj, int val) {
    int hash = hashValue(val);
    bool wasPresent = obj->indexMap[hash].count > 0;
    
    // Expand array if needed
    if (obj->size == obj->capacity) {
        obj->capacity *= 2;
        obj->nums = realloc(obj->nums, obj->capacity * sizeof(int));
    }
    
    obj->nums[obj->size] = val;
    obj->indexMap[hash].indices[obj->indexMap[hash].count++] = obj->size;
    obj->size++;
    
    return !wasPresent;
}

bool randomizedCollectionRemove(RandomizedCollection* obj, int val) {
    int hash = hashValue(val);
    if (obj->indexMap[hash].count == 0) {
        return false;
    }
    
    // Get last index of val and remove it
    int removeIdx = obj->indexMap[hash].indices[--obj->indexMap[hash].count];
    int lastElement = obj->nums[obj->size - 1];
    
    // Swap with last element
    obj->nums[removeIdx] = lastElement;
    
    // Update index for the last element
    int lastHash = hashValue(lastElement);
    for (int i = 0; i < obj->indexMap[lastHash].count; i++) {
        if (obj->indexMap[lastHash].indices[i] == obj->size - 1) {
            obj->indexMap[lastHash].indices[i] = removeIdx;
            break;
        }
    }
    
    obj->size--;
    return true;
}

int randomizedCollectionGetRandom(RandomizedCollection* obj) {
    int index = rand() % obj->size;
    return obj->nums[index];
}

void randomizedCollectionFree(RandomizedCollection* obj) {
    free(obj->nums);
    free(obj);
}

// Example usage:
// RandomizedCollection* collection = randomizedCollectionCreate();
// printf("%d\n", randomizedCollectionInsert(collection, 1)); // 1
// printf("%d\n", randomizedCollectionInsert(collection, 1)); // 0
// printf("%d\n", randomizedCollectionInsert(collection, 2)); // 1
// printf("%d\n", randomizedCollectionGetRandom(collection)); // 1 or 2

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations (insert, remove, getRandom) are O(1) average time. Hash map operations and array access are both O(1) average.

✓ Linear Growth

Space Complexity

O(n)

Need O(n) for the array storing all elements and O(n) for the hash map storing index sets for each unique value

⚡ Linearithmic Space

Constraints

-2³¹ ≤ val ≤ 2³¹ - 1
At most 2 * 10⁵ calls will be made to insert, remove, and getRandom
getRandom will not be called if the collection is empty
Each test case will have at least one call to insert before any call to getRandom

89.6K Views

High Frequency

~35 min Avg. Time

1.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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Array + HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler