Leetcode 381: Insert Delete GetRandom O(1) - Duplicates allowed

Design a data structure that supports all following operations in average O(1) time.

Note: Duplicate elements are allowed.

 

1. insert(val): Inserts an item val to the collection.
2. remove(val): Removes an item val from the collection if present.
3. getRandom: Returns a random element from current collection of elements. The probability of each element being returned is linearly related to the number of same value the collection contains.

 

Example:

// Init an empty collection.
RandomizedCollection collection = new RandomizedCollection();

// Inserts 1 to the collection. Returns true as the collection did not contain 1.
collection.insert(1);

// Inserts another 1 to the collection. Returns false as the collection contained 1. Collection now contains [1,1].
collection.insert(1);

// Inserts 2 to the collection, returns true. Collection now contains [1,1,2].
collection.insert(2);

// getRandom should return 1 with the probability 2/3, and returns 2 with the probability 1/3.
collection.getRandom();

// Removes 1 from the collection, returns true. Collection now contains [1,2].
collection.remove(1);

// getRandom should return 1 and 2 both equally likely.
collection.getRandom();

 

 

 

public class RandomizedCollection {
    private Dictionary<int, IList<int>> dict = new Dictionary<int, IList<int>>();
    
    // first parameter is the key, second parameter is index in above dict's value (list)
    private IList<Tuple<int, int>> list = new List<Tuple<int, int>>(1000); 
    
    private Random random = new Random();
    
    /** Initialize your data structure here. */
    public RandomizedCollection() {
        
    }
    
    /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
    public bool Insert(int val) {
        if (!dict.ContainsKey(val))
        {
            dict[val] = new List<int>();
            dict[val].Add(list.Count);
            list.Add(new Tuple<int, int>(val, 0));
            
            return true;
        }
        else
        {
            dict[val].Add(list.Count);
            list.Add(new Tuple<int, int>(val, dict[val].Count - 1));
            
            return false;
        }
    }
    
    /** Removes a value from the collection. Returns true if the collection contained the specified element. */
    public bool Remove(int val) {
        if (dict.ContainsKey(val) && dict[val].Count > 0)
        {
            int toRemoveIndex = dict[val][dict[val].Count - 1];           
            var last = list[list.Count - 1];
            
            // swap last element with the element to remove
            this.list[toRemoveIndex] = last;
            dict[last.Item1][last.Item2] = toRemoveIndex;
            list.RemoveAt(list.Count - 1);
            
            // remove val from dict
            dict[val].RemoveAt(dict[val].Count - 1);          
            if (dict[val].Count == 0)
            {
                dict.Remove(val);
            }
            
            return true;
        }
        else
        {
            return false;
        }
    }
    
    /** Get a random element from the collection. */
    public int GetRandom() {
        if (list.Count == 0)
        {
            throw new Exception();
        }
        else
        {
            return this.list[random.Next() % list.Count].Item1;
        }
    }
}

/**
 * Your RandomizedCollection object will be instantiated and called as such:
 * RandomizedCollection obj = new RandomizedCollection();
 * bool param_1 = obj.Insert(val);
 * bool param_2 = obj.Remove(val);
 * int param_3 = obj.GetRandom();
 */