Two Problems Solutions - "Insert Delete GetRandom O(1)"

Author: haoel

README.md

@@ -15,6 +15,8 @@ LeetCode
 |384|[Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | [C++](./algorithms/cpp/shuffleAnArray/ShuffleAnArray.cpp)|Medium|
 |383|[Ransom Note](https://leetcode.com/problems/ransom-note/) | [C++](./algorithms/cpp/ransomNote/RansomNote.cpp)|Easy|
 |382|[Linked List Random Node](https://leetcode.com/problems/linked-list-random-node/) | [C++](./algorithms/cpp/linkedListRandomNode/LinkedListRandomNode.cpp)|Medium|
+|381|[Insert Delete GetRandom O(1) - Duplicates allowed](https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/) | [C++](./algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1DuplicatesAllowed.cpp)|Hard|
+|380|[Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/) | [C++](./algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1.cpp)|Hard|
 |377|[Combination Sum IV](https://leetcode.com/problems/combination-sum-iv/) | [C++](./algorithms/cpp/combinationSumIV/combinationSumIV.cpp)|Medium|
 |376|[Wiggle Subsequence](https://leetcode.com/problems/wiggle-subsequence/) | [C++](./algorithms/cpp/wiggleSubsequence/wiggleSubsequence.cpp)|Medium|
 |350|[Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) | [C++](./algorithms/cpp/intersectionOfTwoArraysII/intersectionOfTwoArraysII.cpp)|Easy|

algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1.cpp

@@ -0,0 +1,98 @@
+// Source : https://leetcode.com/problems/insert-delete-getrandom-o1/
+// Author : Hao Chen
+// Date   : 2016-08-25
+
+/*************************************************************************************** 
+ *
+ * Design a data structure that supports all following operations in average O(1) time.
+ * 
+ * insert(val): Inserts an item val to the set if not already present.
+ * remove(val): Removes an item val from the set if present.
+ * getRandom: Returns a random element from current set of elements. Each element must 
+ * have the same probability of being returned.
+ * 
+ * Example:
+ * 
+ * // Init an empty set.
+ * RandomizedSet randomSet = new RandomizedSet();
+ * 
+ * // Inserts 1 to the set. Returns true as 1 was inserted successfully.
+ * randomSet.insert(1);
+ * 
+ * // Returns false as 2 does not exist in the set.
+ * randomSet.remove(2);
+ * 
+ * // Inserts 2 to the set, returns true. Set now contains [1,2].
+ * randomSet.insert(2);
+ * 
+ * // getRandom should return either 1 or 2 randomly.
+ * randomSet.getRandom();
+ * 
+ * // Removes 1 from the set, returns true. Set now contains [2].
+ * randomSet.remove(1);
+ * 
+ * // 2 was already in the set, so return false.
+ * randomSet.insert(2);
+ * 
+ * // Since 1 is the only number in the set, getRandom always return 1.
+ * randomSet.getRandom();
+ ***************************************************************************************/
+
+
+class RandomizedSet {
+public:
+    /** Initialize your data structure here. */
+    RandomizedSet() {
+        srand(time(NULL));
+    }
+    
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        if ( find(val) ) return false; 
+        data.push_back(val);
+        valpos[val] = data.size() - 1;
+        return true;
+    }
+    
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if ( !find(val) ) return false; 
+        
+		/*
+         * Tricky
+         * ------
+         * 1) Copy the data from the last one to the place need be removed.
+         * 2) Remove the last one.
+         */
+        int _idx = valpos[val];
+        int _val = data.back();
+        
+        data[_idx] = _val;
+        valpos[_val] = _idx;
+        
+        valpos.erase(val);
+        data.pop_back();
+        return true;
+    }
+    
+    /** Get a random element from the set. */
+    int getRandom() {
+        return data[ rand() % data.size() ];
+    }
+    
+private:    
+    unordered_map<int, int> valpos; //value position map
+    vector<int> data;
+    bool find(int val) {
+        return (valpos.find(val) != valpos.end());
+    }
+    
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet obj = new RandomizedSet();
+ * bool param_1 = obj.insert(val);
+ * bool param_2 = obj.remove(val);
+ * int param_3 = obj.getRandom();
+ */

algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1DuplicatesAllowed.cpp

@@ -0,0 +1,102 @@
+// Source : https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/
+// Author : Hao Chen
+// Date   : 2016-08-25
+
+/*************************************************************************************** 
+ *
+ * Design a data structure that supports all following operations in average O(1) time.
+ * Note: Duplicate elements are allowed.
+ * 
+ * insert(val): Inserts an item val to the collection.
+ * remove(val): Removes an item val from the collection if present.
+ * 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();
+ ***************************************************************************************/
+
+class RandomizedCollection {
+public:
+    /** Initialize your data structure here. */
+    RandomizedCollection() {
+        srand(time(NULL));
+    }
+    
+    /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
+    bool insert(int val) {
+        data.push_back(val);
+        valpos[val].insert( data.size() - 1 );
+        return (valpos[val].size() == 1);
+    }
+    
+    /** Removes a value from the collection. Returns true if the collection contained the specified element. */
+    bool remove(int val) {
+        // not found
+        if (!find(val)) return false;
+        
+        
+        //same idea with non-duplication version, but need be careful with some edge case
+        int _idx = *(valpos[val].begin());
+        int _val = data.back();
+        
+        valpos[_val].insert(_idx);
+        data[_idx] = _val;
+        
+        valpos[val].erase(_idx);
+        if (valpos[val].size()==0){
+            valpos.erase(val);
+        }
+        
+        data.pop_back();
+        if ( _idx < data.size() ){
+            valpos[_val].erase(data.size());
+            valpos[_val].insert(_idx);
+        }
+        
+        return true;        
+    }
+    
+    /** Get a random element from the collection. */
+    int getRandom() {
+        return data[ rand() % data.size() ];
+    }
+private:
+    unordered_map<int, unordered_set<int>> valpos; //value position map
+    vector<int> data;
+    bool find(int val) {
+        return (valpos.find(val) != valpos.end());
+    }
+   
+};
+
+/**
+ * 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();
+ */