feat: add solutions to lc problem: No.1756

No.1756.Design Most Recently Used Queue

Author: yanglbme

solution/1700-1799/1756.Design Most Recently Used Queue/README.md

@@ -53,7 +53,11 @@ mRUQueue.fetch(8); // 第 8 个元素 (2) 已经在队列尾部了，所以直
 
 **方法一：树状数组 + 二分查找**
 
+我们用一个数组 $q$ 维护当前队列中的元素，移动第 $k$ 个元素时，我们考虑不删除该元素，而是直接将其追加到数组末尾。如果不删除，我们如何知道第 $k$ 个元素在数组 $q$ 中的位置呢？
 
+我们可以用一个树状数组维护数组 $q$ 中每个位置的元素是否被删除，如果第 $i$ 个位置的元素被删除，那么我们更新树状数组中的第 $i$ 个位置，表示该位置被移动的次数增加 $1$。这样，我们每次要删除第 $k$ 个元素时，可以用二分查找，找到第一个满足 $i - tree.query(i) \geq k$ 的位置 $i$，即为第 $k$ 个元素在数组 $q$ 中的位置。不妨记 $x=q[i]$，那么我们将 $x$ 追加到数组 $q$ 的末尾，同时更新树状数组中第 $i$ 个位置的值，表示该位置被移动的次数增加 $1$。最后，我们返回 $x$ 即可。
+
+时间复杂度 $(\log ^2 n)$，空间复杂度 $O(n)$。其中 $n$ 为队列的长度。
 
 <!-- tabs:start -->
 
@@ -80,44 +84,41 @@ class MRUQueue:
 
 ```python
 class BinaryIndexedTree:
-    def __init__(self, n):
+    def __init__(self, n: int):
         self.n = n
         self.c = [0] * (n + 1)
 
-    @staticmethod
-    def lowbit(x):
-        return x & -x
-
-    def update(self, x, delta):
+    def update(self, x: int, v: int):
         while x <= self.n:
-            self.c[x] += delta
-            x += BinaryIndexedTree.lowbit(x)
+            self.c[x] += v
+            x += x & -x
 
-    def query(self, x):
+    def query(self, x: int) -> int:
         s = 0
-        while x > 0:
+        while x:
             s += self.c[x]
-            x -= BinaryIndexedTree.lowbit(x)
+            x -= x & -x
         return s
 
 
 class MRUQueue:
+
     def __init__(self, n: int):
-        self.data = list(range(n + 1))
+        self.q = list(range(n + 1))
         self.tree = BinaryIndexedTree(n + 2010)
 
     def fetch(self, k: int) -> int:
-        left, right = 1, len(self.data)
-        while left < right:
-            mid = (left + right) >> 1
+        l, r = 1, len(self.q)
+        while l < r:
+            mid = (l + r) >> 1
             if mid - self.tree.query(mid) >= k:
-                right = mid
+                r = mid
             else:
-                left = mid + 1
-        self.data.append(self.data[left])
-        self.tree.update(left, 1)
-        return self.data[left]
-
+                l = mid + 1
+        x = self.q[l]
+        self.q.append(x)
+        self.tree.update(l, 1)
+        return x
 
 # Your MRUQueue object will be instantiated and called as such:
 # obj = MRUQueue(n)
@@ -135,58 +136,54 @@ class BinaryIndexedTree {
 
     public BinaryIndexedTree(int n) {
         this.n = n;
-        c = new int[n + 1];
+        this.c = new int[n + 1];
     }
 
-    public void update(int x, int delta) {
+    public void update(int x, int v) {
         while (x <= n) {
-            c[x] += delta;
-            x += lowbit(x);
+            c[x] += v;
+            x += x & -x;
         }
     }
 
     public int query(int x) {
         int s = 0;
         while (x > 0) {
             s += c[x];
-            x -= lowbit(x);
+            x -= x & -x;
         }
         return s;
     }
-
-    public static int lowbit(int x) {
-        return x & -x;
-    }
 }
 
 class MRUQueue {
     private int n;
-    private int[] data;
+    private int[] q;
     private BinaryIndexedTree tree;
 
     public MRUQueue(int n) {
         this.n = n;
-        data = new int[n + 2010];
+        q = new int[n + 2010];
         for (int i = 1; i <= n; ++i) {
-            data[i] = i;
+            q[i] = i;
         }
         tree = new BinaryIndexedTree(n + 2010);
     }
 
     public int fetch(int k) {
-        int left = 1;
-        int right = n++;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 1, r = n;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (mid - tree.query(mid) >= k) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        data[n] = data[left];
-        tree.update(left, 1);
-        return data[left];
+        int x = q[l];
+        q[++n] = x;
+        tree.update(l, 1);
+        return x;
     }
 }
 
@@ -202,60 +199,58 @@ class MRUQueue {
 ```cpp
 class BinaryIndexedTree {
 public:
-    int n;
-    vector<int> c;
-
     BinaryIndexedTree(int _n)
         : n(_n)
-        , c(_n + 1) { }
+        , c(_n + 1) {}
 
     void update(int x, int delta) {
         while (x <= n) {
             c[x] += delta;
-            x += lowbit(x);
+            x += x & -x;
         }
     }
 
     int query(int x) {
         int s = 0;
-        while (x > 0) {
+        while (x) {
             s += c[x];
-            x -= lowbit(x);
+            x -= x & -x;
         }
         return s;
     }
 
-    int lowbit(int x) {
-        return x & -x;
-    }
+private:
+    int n;
+    vector<int> c;
 };
 
 class MRUQueue {
 public:
-    int n;
-    vector<int> data;
-    BinaryIndexedTree* tree;
-
     MRUQueue(int n) {
-        this->n = n;
-        data.resize(n + 1);
-        for (int i = 1; i <= n; ++i) data[i] = i;
+        q.resize(n + 1);
+        iota(q.begin() + 1, q.end(), 1);
         tree = new BinaryIndexedTree(n + 2010);
     }
 
     int fetch(int k) {
-        int left = 1, right = data.size();
-        while (left < right) {
-            int mid = (left + right) >> 1;
-            if (mid - tree->query(mid) >= k)
-                right = mid;
-            else
-                left = mid + 1;
+        int l = 1, r = q.size();
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (mid - tree->query(mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
         }
-        data.push_back(data[left]);
-        tree->update(left, 1);
-        return data[left];
+        int x = q[l];
+        q.push_back(x);
+        tree->update(l, 1);
+        return x;
     }
+
+private:
+    vector<int> q;
+    BinaryIndexedTree* tree;
 };
 
 /**
@@ -278,52 +273,49 @@ func newBinaryIndexedTree(n int) *BinaryIndexedTree {
 	return &BinaryIndexedTree{n, c}
 }
 
-func (this *BinaryIndexedTree) lowbit(x int) int {
-	return x & -x
-}
-
 func (this *BinaryIndexedTree) update(x, delta int) {
 	for x <= this.n {
 		this.c[x] += delta
-		x += this.lowbit(x)
+		x += x & -x
 	}
 }
 
 func (this *BinaryIndexedTree) query(x int) int {
 	s := 0
 	for x > 0 {
 		s += this.c[x]
-		x -= this.lowbit(x)
+		x -= x & -x
 	}
 	return s
 }
 
 type MRUQueue struct {
-	data []int
+	q    []int
 	tree *BinaryIndexedTree
 }
 
 func Constructor(n int) MRUQueue {
-	data := make([]int, n+1)
-	for i := range data {
-		data[i] = i
+	q := make([]int, n+1)
+	for i := 1; i <= n; i++ {
+		q[i] = i
 	}
-	return MRUQueue{data, newBinaryIndexedTree(n + 2010)}
+	return MRUQueue{q, newBinaryIndexedTree(n + 2010)}
 }
 
 func (this *MRUQueue) Fetch(k int) int {
-	left, right := 1, len(this.data)
-	for left < right {
-		mid := (left + right) >> 1
+	l, r := 1, len(this.q)
+	for l < r {
+		mid := (l + r) >> 1
 		if mid-this.tree.query(mid) >= k {
-			right = mid
+			r = mid
 		} else {
-			left = mid + 1
+			l = mid + 1
 		}
 	}
-	this.data = append(this.data, this.data[left])
-	this.tree.update(left, 1)
-	return this.data[left]
+	x := this.q[l]
+	this.q = append(this.q, x)
+	this.tree.update(l, 1)
+	return x
 }
 
 /**
@@ -333,6 +325,72 @@ func (this *MRUQueue) Fetch(k int) int {
  */
 ```
 
+### **TypeScript**
+
+```ts
+class BinaryIndexedTree {
+    private n: number;
+    private c: number[];
+
+    constructor(n: number) {
+        this.n = n;
+        this.c = new Array(n + 1).fill(0);
+    }
+
+    public update(x: number, v: number): void {
+        while (x <= this.n) {
+            this.c[x] += v;
+            x += x & -x;
+        }
+    }
+
+    public query(x: number): number {
+        let s = 0;
+        while (x > 0) {
+            s += this.c[x];
+            x -= x & -x;
+        }
+        return s;
+    }
+}
+
+class MRUQueue {
+    private q: number[];
+    private tree: BinaryIndexedTree;
+
+    constructor(n: number) {
+        this.q = new Array(n + 1);
+        for (let i = 1; i <= n; ++i) {
+            this.q[i] = i;
+        }
+        this.tree = new BinaryIndexedTree(n + 2010);
+    }
+
+    fetch(k: number): number {
+        let l = 1;
+        let r = this.q.length;
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (mid - this.tree.query(mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        const x = this.q[l];
+        this.q.push(x);
+        this.tree.update(l, 1);
+        return x;
+    }
+}
+
+/**
+ * Your MRUQueue object will be instantiated and called as such:
+ * var obj = new MRUQueue(n)
+ * var param_1 = obj.fetch(k)
+ */
+```
+
 ### **...**
 
 ```