feat: add solutions to lc problem: No.1172

No.1172.Dinner Plate Stacks

Author: yanglbme

solution/1100-1199/1172.Dinner Plate Stacks/README.md

@@ -77,22 +77,258 @@ D.pop()            // 返回 -1。仍然没有栈。
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：栈数组 + 有序集合**
+
+我们定义以下数据结构或变量：
+
+-   `capacity`：每个栈的容量；
+-   `stacks`：栈数组，用于存储所有的栈，其中每个栈的最大容量都是 `capacity`；
+-   `not_full`：有序集合，用于存储所有未满的栈在栈数组中的下标。
+
+对于 `push(val)` 操作：
+
+-   我们首先判断 `not_full` 是否为空，如果为空，则说明没有未满的栈，需要新建一个栈，然后将 `val` 压入该栈中，此时判断容量 `capacity` 是否大于 $1$，如果大于 $1$，则将该栈的下标加入 `not_full` 中。
+-   如果 `not_full` 不为空，则说明有未满的栈，我们取出 `not_full` 中最小的下标 `index`，将 `val` 压入 `stacks[index]` 中，此时如果 `stacks[index]` 的容量等于 `capacity`，则将 `index` 从 `not_full` 中删除。
+
+对于 `popAtStack(index)` 操作：
+
+-   我们首先判断 `index` 是否在 `stacks` 的下标范围内，如果不在，则直接返回 $-1$。如果 `stacks[index]` 为空，同样直接返回 $-1$。
+-   如果 `stacks[index]` 不为空，则取出 `stacks[index]` 的栈顶元素 `val`，并将其从栈中删除。如果 `index` 等于 `stacks` 的长度减 $1$，则说明 `stacks[index]` 是最后一个栈，如果此时 `stacks[index]` 为空，我们循环将 `index` 从 `stacks` 中删除，并且将 `index` 从 `not_full` 中删除，直到 `stacks[index]` 不为空或者 `stacks` 为空为止。否则，如果 `stacks[index]` 不是最后一个栈，我们将 `index` 加入 `not_full` 中。
+-   最后返回 `val`。
+
+对于 `pop()` 操作：
+
+-   我们直接调用 `popAtStack(stacks.length - 1)` 即可。
+
+时间复杂度 $(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为操作次数。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+from sortedcontainers import SortedSet
+
+
+class DinnerPlates:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.stacks = []
+        self.not_full = SortedSet()
+
+    def push(self, val: int) -> None:
+        if not self.not_full:
+            self.stacks.append([val])
+            if self.capacity > 1:
+                self.not_full.add(len(self.stacks) - 1)
+        else:
+            index = self.not_full[0]
+            self.stacks[index].append(val)
+            if len(self.stacks[index]) == self.capacity:
+                self.not_full.discard(index)
+
+    def pop(self) -> int:
+        return self.popAtStack(len(self.stacks) - 1)
 
+    def popAtStack(self, index: int) -> int:
+        if index < 0 or index >= len(self.stacks) or not self.stacks[index]:
+            return -1
+        val = self.stacks[index].pop()
+        if index == len(self.stacks) - 1 and not self.stacks[-1]:
+            while self.stacks and not self.stacks[-1]:
+                self.not_full.discard(len(self.stacks) - 1)
+                self.stacks.pop()
+        else:
+            self.not_full.add(index)
+        return val
+
+
+# Your DinnerPlates object will be instantiated and called as such:
+# obj = DinnerPlates(capacity)
+# obj.push(val)
+# param_2 = obj.pop()
+# param_3 = obj.popAtStack(index)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class DinnerPlates {
+    private int capacity;
+    private List<Deque<Integer>> stacks = new ArrayList<>();
+    private TreeSet<Integer> notFull = new TreeSet<>();
+
+    public DinnerPlates(int capacity) {
+        this.capacity = capacity;
+    }
+
+    public void push(int val) {
+        if (notFull.isEmpty()) {
+            stacks.add(new ArrayDeque<>());
+            stacks.get(stacks.size() - 1).push(val);
+            if (capacity > 1) {
+                notFull.add(stacks.size() - 1);
+            }
+        } else {
+            int index = notFull.first();
+            stacks.get(index).push(val);
+            if (stacks.get(index).size() == capacity) {
+                notFull.pollFirst();
+            }
+        }
+    }
+
+    public int pop() {
+        return popAtStack(stacks.size() - 1);
+    }
+
+    public int popAtStack(int index) {
+        if (index < 0 || index >= stacks.size() || stacks.get(index).isEmpty()) {
+            return -1;
+        }
+        int val = stacks.get(index).pop();
+        if (index == stacks.size() - 1 && stacks.get(stacks.size() - 1).isEmpty()) {
+            while (!stacks.isEmpty() && stacks.get(stacks.size() - 1).isEmpty()) {
+                notFull.remove(stacks.size() - 1);
+                stacks.remove(stacks.size() - 1);
+            }
+        } else {
+            notFull.add(index);
+        }
+        return val;
+    }
+}
+
+/**
+ * Your DinnerPlates object will be instantiated and called as such:
+ * DinnerPlates obj = new DinnerPlates(capacity);
+ * obj.push(val);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.popAtStack(index);
+ */
+```
+
+### **C++**
+
+```cpp
+class DinnerPlates {
+public:
+    DinnerPlates(int capacity) {
+        this->capacity = capacity;
+    }
+
+    void push(int val) {
+        if (notFull.empty()) {
+            stacks.emplace_back(stack<int>());
+            stacks.back().push(val);
+            if (capacity > 1) {
+                notFull.insert(stacks.size() - 1);
+            }
+        } else {
+            int index = *notFull.begin();
+            stacks[index].push(val);
+            if (stacks[index].size() == capacity) {
+                notFull.erase(index);
+            }
+        }
+    }
+
+    int pop() {
+        return popAtStack(stacks.size() - 1);
+    }
+
+    int popAtStack(int index) {
+        if (index < 0 || index >= stacks.size() || stacks[index].empty()) {
+            return -1;
+        }
+        int val = stacks[index].top();
+        stacks[index].pop();
+        if (index == stacks.size() - 1 && stacks[index].empty()) {
+            while (!stacks.empty() && stacks.back().empty()) {
+                notFull.erase(stacks.size() - 1);
+                stacks.pop_back();
+            }
+        } else {
+            notFull.insert(index);
+        }
+        return val;
+    }
+
+private:
+    int capacity;
+    vector<stack<int>> stacks;
+    set<int> notFull;
+};
+
+/**
+ * Your DinnerPlates object will be instantiated and called as such:
+ * DinnerPlates* obj = new DinnerPlates(capacity);
+ * obj->push(val);
+ * int param_2 = obj->pop();
+ * int param_3 = obj->popAtStack(index);
+ */
+```
+
+### **Go**
+
+```go
+type DinnerPlates struct {
+	capacity int
+	stacks   [][]int
+	notFull  *redblacktree.Tree
+}
+
+func Constructor(capacity int) DinnerPlates {
+	return DinnerPlates{capacity: capacity, notFull: redblacktree.NewWithIntComparator()}
+}
+
+func (this *DinnerPlates) Push(val int) {
+	if this.notFull.Size() == 0 {
+		this.stacks = append(this.stacks, []int{val})
+		if this.capacity > 1 {
+			this.notFull.Put(len(this.stacks)-1, nil)
+		}
+	} else {
+		index, _ := this.notFull.Left().Key.(int)
+		this.stacks[index] = append(this.stacks[index], val)
+		if len(this.stacks[index]) == this.capacity {
+			this.notFull.Remove(index)
+		}
+	}
+}
+
+func (this *DinnerPlates) Pop() int {
+	return this.PopAtStack(len(this.stacks) - 1)
+}
+
+func (this *DinnerPlates) PopAtStack(index int) int {
+	if index < 0 || index >= len(this.stacks) || len(this.stacks[index]) == 0 {
+		return -1
+	}
+	val := this.stacks[index][len(this.stacks[index])-1]
+	this.stacks[index] = this.stacks[index][:len(this.stacks[index])-1]
+	if index == len(this.stacks)-1 && len(this.stacks[index]) == 0 {
+		for len(this.stacks) > 0 && len(this.stacks[len(this.stacks)-1]) == 0 {
+			this.notFull.Remove(len(this.stacks) - 1)
+			this.stacks = this.stacks[:len(this.stacks)-1]
+		}
+	} else {
+		this.notFull.Put(index, nil)
+	}
+	return val
+}
 
+/**
+ * Your DinnerPlates object will be instantiated and called as such:
+ * obj := Constructor(capacity);
+ * obj.Push(val);
+ * param_2 := obj.Pop();
+ * param_3 := obj.PopAtStack(index);
+ */
 ```
 
 ### **...**