Update 380. Insert Delete GetRandom O(1).md

Author: 0xkookoo

docs/Leetcode_Solutions/Python/380. Insert Delete GetRandom O(1).md

@@ -1,159 +1,144 @@
-### 380. Insert Delete GetRandom O(1)
+# 380. Insert Delete GetRandom O(1)
 
+**<font color=red>难度: Medium</font>**
 
+## 刷题内容
 
-题目： 
-<https://leetcode.com/problems/insert-delete-getrandom-o1/>
+> 原题连接
 
+* https://leetcode.com/problems/insert-delete-getrandom-o1/description/
 
+> 内容描述
 
-难度 : Hard
+```
+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();
 
-我的naive TLE代码，关键还是在想这个getRandom,这就不是O(1)的：
+// 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);
 
-```
-class RandomizedSet(object):
+// getRandom should return either 1 or 2 randomly.
+randomSet.getRandom();
 
-    def __init__(self):
-        """
-        Initialize your data structure here.
-        """
-        self.container = {}
-        
+// Removes 1 from the set, returns true. Set now contains [2].
+randomSet.remove(1);
 
-    def insert(self, val):
-        """
-        Inserts a value to the set. Returns true if the set did not already contain the specified element.
-        :type val: int
-        :rtype: bool
-        """
-        # 1 stands for present
-        if val in self.container and self.container[val] == 1:
-            return False
-        else:
-            self.container[val] = 1
-            return True
-        
+// 2 was already in the set, so return false.
+randomSet.insert(2);
 
-    def remove(self, val):
-        """
-        Removes a value from the set. Returns true if the set contained the specified element.
-        :type val: int
-        :rtype: bool
-        """
-        if self.container.get(val,0) == 1:
-            self.container[val] = 0
-            return True
-        else:
-            return False
+// Since 2 is the only number in the set, getRandom always return 2.
+randomSet.getRandom();
+```
 
-        
+## 解题方案
 
-    def getRandom(self):
-        """
-        Get a random element from the set.
-        :rtype: int
-        """
-        import random
-        keys = self.container.keys()
-        rd = random.randint(0, len(keys) - 1)
-        if self.container[keys[rd]] == 1:
-            return keys[rd]
-        elif self.container.get(keys[rd],0) == 0:
-            return self.getRandom()
-```
+> 思路 1
+******- 时间复杂度: O(1)******- 空间复杂度: O(N)******
 
 
 
-也是有[stackoverflow问题界面的题目](http://stackoverflow.com/questions/5682218/data-structure-insert-remove-contains-get-random-element-all-at-o1#comment18171331_5684892)：
+因为对于插入，删除还有同可能性返回数都要O(1)，我们知道以下几种典型的数据结构
+```
+dictionary
+list
+set
+LinkedList
+```
+想要删除确定数字必须要知道数字的index，所以list肯定需要，然后怎么通过O(1)时间得到要删除元素的index呢？
+就想到用字典，key,value分别是element和其index
 
-> Consider a data structure composed of a hashtable H and an array A. The hashtable keys are the elements in the data structure, and the values are their positions in the array.
->
-> 1.insert(value): append the value to array and let i be its index in A. Set H[value]=i.
->
-> 2.remove(value): We are going to replace the cell that contains value in A with the last element in A. let d be the last element in the array A at index m. let i be H[value], the index in the array of the value to be removed. Set A[i]=d, H[d]=i, decrease the size of the array by one, and remove value from H.
->
-> 3.contains(value): return H.contains(value)
->
-> 4.getRandomElement(): let r=random(current size of A). return A[r].
->
-> 
->
-> since the array needs to auto-increase in size, it's going to be amortize O(1) to add an element, but I guess that's OK.
+然后想要O(1)时间同可能性返回数都要，必须要知道总共有多少个数字，那么就要维护一个self.length才行
 
 
 
 
 
-按照以答案AC代码
 
-```
+```python
+import random
 class RandomizedSet(object):
 
     def __init__(self):
         """
         Initialize your data structure here.
         """
-        self.hashtable = {}
-        self.array = []
-        self.arraySize = 0
+        self.cache = {}
+        self.lst = []
+        self.length = 0
+        
 
     def insert(self, val):
         """
         Inserts a value to the set. Returns true if the set did not already contain the specified element.
         :type val: int
         :rtype: bool
         """
-        # already in the set
-        if val in self.hashtable:
-            return False
-        else:
-            self.hashtable[val] = self.arraySize
-            self.array.append(val)
-            self.arraySize += 1
+        # if this element is not in our RandomizedSet
+        if val not in self.cache:
+            # just insert into both of our self.cache and self.lst
+            self.cache[val] = self.length
+            self.lst.append(val)
+            self.length += 1
             return True
-
+        else:
+            return False
+        
 
     def remove(self, val):
         """
         Removes a value from the set. Returns true if the set contained the specified element.
         :type val: int
         :rtype: bool
         """
-        if val not in self.hashtable:
-            return False
-        else:
-            removeIdx = self.hashtable[val]
-            if self.arraySize == 1:
-                self.__init__()
-            else:
-                self.array[removeIdx] = self.array[-1]
-                self.hashtable[self.array[-1]] = removeIdx
-                self.arraySize -= 1
-                del self.hashtable[val]
-                del self.array[-1]
+        # if the elment is in our RandomizedSet
+        if val in self.cache:
+          # get the index of element in our self.lst
+            idx = self.cache[val]
+          # use the index to update our self.lst
+            self.lst[idx] = self.lst[-1] # swap the value in index and self.length-1
+            # this should be done before pop() operation
+            # because we may only have one element is self.lst
+            self.cache[self.lst[idx]] = idx 
+            self.lst.pop()
+            del self.cache[val]
+            self.length -= 1
             return True
+        else:
+            return False
 
 
-
     def getRandom(self):
         """
         Get a random element from the set.
         :rtype: int
         """
-        import random
-        rd = random.randint(0, self.arraySize-1)
-        return self.array[rd]
-```
-
+        # 这种是常规方法
+        # idx = random.randint(0, self.length-1)
+        # return self.lst[idx]
+        # 神奇函数
+        return random.choice(self.lst)
+        
 
 
+# Your RandomizedSet object will be instantiated and called as such:
+# obj = RandomizedSet()
+# param_1 = obj.insert(val)
+# param_2 = obj.remove(val)
+# param_3 = obj.getRandom()
+```
 
 
-最后getRandom也可以写成：
 
-`return random.choice(self.array)`