Create 900._RLE_Iterator.md

docs/Leetcode_Solutions/900._RLE_Iterator.md

+# 900. RLE Iterator
+
+**<font color=red>难度: Medium</font>**
+
+## 刷题内容
+
+> 原题连接
+
+* https://leetcode.com/problems/rle-iterator/description/
+
+> 内容描述
+
+```
+
+Write an iterator that iterates through a run-length encoded sequence.
+
+The iterator is initialized by RLEIterator(int[] A), where A is a run-length encoding of some sequence.  More specifically, for all even i, A[i] tells us the number of times that the non-negative integer value A[i+1] is repeated in the sequence.
+
+The iterator supports one function: next(int n), which exhausts the next n elements (n >= 1) and returns the last element exhausted in this way.  If there is no element left to exhaust, next returns -1 instead.
+
+For example, we start with A = [3,8,0,9,2,5], which is a run-length encoding of the sequence [8,8,8,5,5].  This is because the sequence can be read as "three eights, zero nines, two fives".
+
+ 
+
+Example 1:
+
+Input: ["RLEIterator","next","next","next","next"], [[[3,8,0,9,2,5]],[2],[1],[1],[2]]
+Output: [null,8,8,5,-1]
+Explanation: 
+RLEIterator is initialized with RLEIterator([3,8,0,9,2,5]).
+This maps to the sequence [8,8,8,5,5].
+RLEIterator.next is then called 4 times:
+
+.next(2) exhausts 2 terms of the sequence, returning 8.  The remaining sequence is now [8, 5, 5].
+
+.next(1) exhausts 1 term of the sequence, returning 8.  The remaining sequence is now [5, 5].
+
+.next(1) exhausts 1 term of the sequence, returning 5.  The remaining sequence is now [5].
+
+.next(2) exhausts 2 terms, returning -1.  This is because the first term exhausted was 5,
+but the second term did not exist.  Since the last term exhausted does not exist, we return -1.
+
+Note:
+
+0 <= A.length <= 1000
+A.length is an even integer.
+0 <= A[i] <= 10^9
+There are at most 1000 calls to RLEIterator.next(int n) per test case.
+Each call to RLEIterator.next(int n) will have 1 <= n <= 10^9.
+```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(N)******- 空间复杂度: O(len(A))******
+
+
+
+周赛的时候做的这道题，刚开始很sb，抱着试试的想法直接全部装起来然后一个个返回，果然太 naive
+
+
+```
+class RLEIterator(object):
+
+    def __init__(self, A):
+        """
+        :type A: List[int]
+        """
+        self.lst = A
+        self.tmp = []
+        for i in range(0, len(self.lst), 2):
+            self.tmp.extend([self.lst[i+1]]*self.lst[i])
+            
+        
+
+    def next(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if len(self.tmp) < n:
+            return -1
+        else:
+            for i in range(n):
+                if i == n-1:
+                    return self.tmp.pop(0)
+                self.tmp.pop(0)
+```
+
+
+> 思路 2
+******- 时间复杂度: O(N)******- 空间复杂度: O(len(A))******
+
+
+然后写了半天，每次只取一个的逻辑，还是超时了。真的蠢。。。。
+
+```
+class RLEIterator(object):
+
+    def __init__(self, A):
+        """
+        :type A: List[int]
+        """
+        self.lst = A
+        self.tmp = []
+        self.cnt, self.num = 0, 0
+
+            
+        
+
+    def next(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if self.tmp:
+            if n == 1:
+                return self.tmp.pop(0)
+            else:
+                self.tmp.pop(0)
+                return self.next(n-1)
+        else:
+            if self.cnt > 0:
+                self.tmp.append(self.num)
+                self.cnt -= 1
+                return self.next(n)
+            else:
+                if self.lst:
+                    self.cnt, self.num = self.lst.pop(0), self.lst.pop(0)
+                    return self.next(n)
+                else:
+                    return -1
+```
+
+> 思路 3
+******- 时间复杂度: O(N)******- 空间复杂度: O(len(A))******
+
+
+利用python built-in数据结构deque的性质，直接AC, beats 100%
+
+```python
+class RLEIterator(object):
+
+    def __init__(self, A):
+        """
+        :type A: List[int]
+        """
+        self._deque = collections.deque(A)
+        
+
+    def next(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        while self._deque and n:
+            count = self._deque.popleft()
+            val = self._deque[0]
+            if count >= n:
+                self._deque.appendleft(count-n)
+                return val
+            else:
+                n -= count
+                self._deque.popleft()
+        return -1
+            
+        
+
+
+# Your RLEIterator object will be instantiated and called as such:
+# obj = RLEIterator(A)
+# param_1 = obj.next(n)
+```