+ problem 1993

fruit-in · fruit-in · commit 507f2ebf5295 · 2023-10-26T22:27:29.000+08:00
diff --git a/Problemset/1993-Operations on Tree/README.md b/Problemset/1993-Operations on Tree/README.md
@@ -0,0 +1,143 @@
+# 1993. Operations on Tree
+You are given a tree with `n` nodes numbered from `0` to `n - 1` in the form of a parent array `parent` where `parent[i]` is the parent of the <code>i<sup>th</sup></code> node. The root of the tree is node `0`, so `parent[0] = -1` since it has no parent. You want to design a data structure that allows users to lock, unlock, and upgrade nodes in the tree.
+
+The data structure should support the following functions:
+
+* **Lock: Locks** the given node for the given user and prevents other users from locking the same node. You may only lock a node using this function if the node is unlocked.
+* **Unlock: Unlocks** the given node for the given user. You may only unlock a node using this function if it is currently locked by the same user.
+* **Upgrade: Locks** the given node for the given user and **unlocks** all of its descendants **regardless** of who locked it. You may only upgrade a node if **all** 3 conditions are true:
+    * The node is unlocked,
+    * It has at least one locked descendant (by **any** user), and
+    * It does not have any locked ancestors.
+
+Implement the `LockingTree` class:
+
+* `LockingTree(int[] parent)` initializes the data structure with the parent array.
+* `lock(int num, int user)` returns `true` if it is possible for the user with id `user` to lock the node `num`, or `false` otherwise. If it is possible, the node `num` will become **locked** by the user with id `user`.
+* `unlock(int num, int user)` returns `true` if it is possible for the user with id `user` to unlock the node `num`, or `false` otherwise. If it is possible, the node `num` will become **unlocked**.
+* `upgrade(int num, int user)` returns `true` if it is possible for the user with id `user` to upgrade the node `num`, or `false` otherwise. If it is possible, the node `num` will be **upgraded**.
+
+#### Example 1:
+![](https://assets.leetcode.com/uploads/2021/07/29/untitled.png)
+<pre>
+<strong>Input:</strong>
+["LockingTree", "lock", "unlock", "unlock", "lock", "upgrade", "lock"]
+[[[-1, 0, 0, 1, 1, 2, 2]], [2, 2], [2, 3], [2, 2], [4, 5], [0, 1], [0, 1]]
+<strong>Output:</strong>
+[null, true, false, true, true, true, false]
+<strong>Explanation:</strong>
+LockingTree lockingTree = new LockingTree([-1, 0, 0, 1, 1, 2, 2]);
+lockingTree.lock(2, 2);    // return true because node 2 is unlocked.
+                           // Node 2 will now be locked by user 2.
+lockingTree.unlock(2, 3);  // return false because user 3 cannot unlock a node locked by user 2.
+lockingTree.unlock(2, 2);  // return true because node 2 was previously locked by user 2.
+                           // Node 2 will now be unlocked.
+lockingTree.lock(4, 5);    // return true because node 4 is unlocked.
+                           // Node 4 will now be locked by user 5.
+lockingTree.upgrade(0, 1); // return true because node 0 is unlocked and has at least one locked descendant (node 4).
+                           // Node 0 will now be locked by user 1 and node 4 will now be unlocked.
+lockingTree.lock(0, 1);    // return false because node 0 is already locked.
+</pre>
+
+#### Constraints:
+* `n == parent.length`
+* `2 <= n <= 2000`
+* `0 <= parent[i] <= n - 1` for `i != 0`
+* `parent[0] == -1`
+* `0 <= num <= n - 1`
+* <code>1 <= user <= 10<sup>4</sup></code>
+* `parent` represents a valid tree.
+* At most `2000` calls **in total** will be made to `lock`, `unlock`, and `upgrade`.
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+struct LockingTree {
+    parent: Vec<i32>,
+    children: Vec<Vec<i32>>,
+    locked: Vec<i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl LockingTree {
+    fn new(parent: Vec<i32>) -> Self {
+        let n = parent.len();
+        let mut children = vec![vec![]; n];
+
+        for i in 1..n {
+            children[parent[i] as usize].push(i as i32);
+        }
+
+        Self {
+            parent: parent,
+            children: children,
+            locked: vec![-1; n],
+        }
+    }
+
+    fn lock(&mut self, num: i32, user: i32) -> bool {
+        if self.locked[num as usize] == -1 {
+            self.locked[num as usize] = user;
+
+            true
+        } else {
+            false
+        }
+    }
+
+    fn unlock(&mut self, num: i32, user: i32) -> bool {
+        if self.locked[num as usize] == user {
+            self.locked[num as usize] = -1;
+
+            true
+        } else {
+            false
+        }
+    }
+
+    fn upgrade(&mut self, num: i32, user: i32) -> bool {
+        let mut curr = num;
+        let mut nodes = self.children[num as usize].clone();
+        let mut locked_descendants = vec![];
+
+        while curr != -1 {
+            if self.locked[curr as usize] != -1 {
+                return false;
+            }
+
+            curr = self.parent[curr as usize];
+        }
+
+        while let Some(node) = nodes.pop() {
+            nodes.append(&mut self.children[node as usize].clone());
+
+            if self.locked[node as usize] != -1 {
+                locked_descendants.push(node as usize);
+            }
+        }
+
+        if !locked_descendants.is_empty() {
+            self.lock(num, user);
+            for node in locked_descendants {
+                self.locked[node] = -1;
+            }
+
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/**
+ * Your LockingTree object will be instantiated and called as such:
+ * let obj = LockingTree::new(parent);
+ * let ret_1: bool = obj.lock(num, user);
+ * let ret_2: bool = obj.unlock(num, user);
+ * let ret_3: bool = obj.upgrade(num, user);
+ */
+```
diff --git a/Problemset/1993-Operations on Tree/README_CN.md b/Problemset/1993-Operations on Tree/README_CN.md
@@ -0,0 +1,143 @@
+# 1993. 树上的操作
+给你一棵 `n` 个节点的树，编号从 `0` 到 `n - 1` ，以父节点数组 `parent` 的形式给出，其中 `parent[i]` 是第 `i` 个节点的父节点。树的根节点为 `0` 号节点，所以 `parent[0] = -1` ，因为它没有父节点。你想要设计一个数据结构实现树里面对节点的加锁，解锁和升级操作。
+
+数据结构需要支持如下函数：
+
+* **Lock：**指定用户给指定节点 **上锁** ，上锁后其他用户将无法给同一节点上锁。只有当节点处于未上锁的状态下，才能进行上锁操作。
+* **Unlock：**指定用户给指定节点 **解锁** ，只有当指定节点当前正被指定用户锁住时，才能执行该解锁操作。
+* **Upgrade：**指定用户给指定节点 **上锁** ，并且将该节点的所有子孙节点 **解锁** 。只有如下 3 个条件 **全部** 满足时才能执行升级操作：
+    * 指定节点当前状态为未上锁。
+    * 指定节点至少有一个上锁状态的子孙节点（可以是 **任意** 用户上锁的）。
+    * 指定节点没有任何上锁的祖先节点。
+
+请你实现 `LockingTree` 类：
+
+* `LockingTree(int[] parent)` 用父节点数组初始化数据结构。
+* `lock(int num, int user)` 如果 id 为 `user` 的用户可以给节点 `num` 上锁，那么返回 `true` ，否则返回 `false` 。如果可以执行此操作，节点 `num` 会被 id 为 `user` 的用户 **上锁** 。
+* `unlock(int num, int user)` 如果 id 为 `user` 的用户可以给节点 `num` 解锁，那么返回 `true` ，否则返回 `false` 。如果可以执行此操作，节点 `num` 变为 **未上锁** 状态。
+* `upgrade(int num, int user)` 如果 id 为 `user` 的用户可以给节点 `num` 升级，那么返回 `true` ，否则返回 `false` 。如果可以执行此操作，节点 `num` 会被 **升级** 。
+
+#### 示例 1:
+![](https://assets.leetcode.com/uploads/2021/07/29/untitled.png)
+<pre>
+<strong>输入:</strong>
+["LockingTree", "lock", "unlock", "unlock", "lock", "upgrade", "lock"]
+[[[-1, 0, 0, 1, 1, 2, 2]], [2, 2], [2, 3], [2, 2], [4, 5], [0, 1], [0, 1]]
+<strong>输出:</strong>
+[null, true, false, true, true, true, false]
+<strong>解释:</strong>
+LockingTree lockingTree = new LockingTree([-1, 0, 0, 1, 1, 2, 2]);
+lockingTree.lock(2, 2);    // 返回 true ，因为节点 2 未上锁。
+                           // 节点 2 被用户 2 上锁。
+lockingTree.unlock(2, 3);  // 返回 false ，因为用户 3 无法解锁被用户 2 上锁的节点。
+lockingTree.unlock(2, 2);  // 返回 true ，因为节点 2 之前被用户 2 上锁。
+                           // 节点 2 现在变为未上锁状态。
+lockingTree.lock(4, 5);    // 返回 true ，因为节点 4 未上锁。
+                           // 节点 4 被用户 5 上锁。
+lockingTree.upgrade(0, 1); // 返回 true ，因为节点 0 未上锁且至少有一个被上锁的子孙节点（节点 4）。
+                           // 节点 0 被用户 1 上锁，节点 4 变为未上锁。
+lockingTree.lock(0, 1);    // 返回 false ，因为节点 0 已经被上锁了。
+</pre>
+
+#### 提示:
+* `n == parent.length`
+* `2 <= n <= 2000`
+* 对于 `i != 0` ，满足 `0 <= parent[i] <= n - 1`
+* `parent[0] == -1`
+* `0 <= num <= n - 1`
+* <code>1 <= user <= 10<sup>4</sup></code>
+* `parent` 表示一棵合法的树。
+* `lock` ，`unlock` 和 `upgrade` 的调用 **总共** 不超过 `2000` 次。
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+struct LockingTree {
+    parent: Vec<i32>,
+    children: Vec<Vec<i32>>,
+    locked: Vec<i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl LockingTree {
+    fn new(parent: Vec<i32>) -> Self {
+        let n = parent.len();
+        let mut children = vec![vec![]; n];
+
+        for i in 1..n {
+            children[parent[i] as usize].push(i as i32);
+        }
+
+        Self {
+            parent: parent,
+            children: children,
+            locked: vec![-1; n],
+        }
+    }
+
+    fn lock(&mut self, num: i32, user: i32) -> bool {
+        if self.locked[num as usize] == -1 {
+            self.locked[num as usize] = user;
+
+            true
+        } else {
+            false
+        }
+    }
+
+    fn unlock(&mut self, num: i32, user: i32) -> bool {
+        if self.locked[num as usize] == user {
+            self.locked[num as usize] = -1;
+
+            true
+        } else {
+            false
+        }
+    }
+
+    fn upgrade(&mut self, num: i32, user: i32) -> bool {
+        let mut curr = num;
+        let mut nodes = self.children[num as usize].clone();
+        let mut locked_descendants = vec![];
+
+        while curr != -1 {
+            if self.locked[curr as usize] != -1 {
+                return false;
+            }
+
+            curr = self.parent[curr as usize];
+        }
+
+        while let Some(node) = nodes.pop() {
+            nodes.append(&mut self.children[node as usize].clone());
+
+            if self.locked[node as usize] != -1 {
+                locked_descendants.push(node as usize);
+            }
+        }
+
+        if !locked_descendants.is_empty() {
+            self.lock(num, user);
+            for node in locked_descendants {
+                self.locked[node] = -1;
+            }
+
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/**
+ * Your LockingTree object will be instantiated and called as such:
+ * let obj = LockingTree::new(parent);
+ * let ret_1: bool = obj.lock(num, user);
+ * let ret_2: bool = obj.unlock(num, user);
+ * let ret_3: bool = obj.upgrade(num, user);
+ */
+```
diff --git a/Problemset/1993-Operations on Tree/Solution.rs b/Problemset/1993-Operations on Tree/Solution.rs
@@ -0,0 +1,87 @@
+struct LockingTree {
+    parent: Vec<i32>,
+    children: Vec<Vec<i32>>,
+    locked: Vec<i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl LockingTree {
+    fn new(parent: Vec<i32>) -> Self {
+        let n = parent.len();
+        let mut children = vec![vec![]; n];
+
+        for i in 1..n {
+            children[parent[i] as usize].push(i as i32);
+        }
+
+        Self {
+            parent: parent,
+            children: children,
+            locked: vec![-1; n],
+        }
+    }
+
+    fn lock(&mut self, num: i32, user: i32) -> bool {
+        if self.locked[num as usize] == -1 {
+            self.locked[num as usize] = user;
+
+            true
+        } else {
+            false
+        }
+    }
+
+    fn unlock(&mut self, num: i32, user: i32) -> bool {
+        if self.locked[num as usize] == user {
+            self.locked[num as usize] = -1;
+
+            true
+        } else {
+            false
+        }
+    }
+
+    fn upgrade(&mut self, num: i32, user: i32) -> bool {
+        let mut curr = num;
+        let mut nodes = self.children[num as usize].clone();
+        let mut locked_descendants = vec![];
+
+        while curr != -1 {
+            if self.locked[curr as usize] != -1 {
+                return false;
+            }
+
+            curr = self.parent[curr as usize];
+        }
+
+        while let Some(node) = nodes.pop() {
+            nodes.append(&mut self.children[node as usize].clone());
+
+            if self.locked[node as usize] != -1 {
+                locked_descendants.push(node as usize);
+            }
+        }
+
+        if !locked_descendants.is_empty() {
+            self.lock(num, user);
+            for node in locked_descendants {
+                self.locked[node] = -1;
+            }
+
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/**
+ * Your LockingTree object will be instantiated and called as such:
+ * let obj = LockingTree::new(parent);
+ * let ret_1: bool = obj.lock(num, user);
+ * let ret_2: bool = obj.unlock(num, user);
+ * let ret_3: bool = obj.upgrade(num, user);
+ */
diff --git a/README.md b/README.md
@@ -976,6 +976,7 @@
 [1984][1984l]|[Minimum Difference Between Highest and Lowest of K Scores][1984]                     |![rs]
 [1985][1985l]|[Find the Kth Largest Integer in the Array][1985]                                     |![py]
 [1991][1991l]|[Find the Middle Index in Array][1991]                                                |![py]
+[1993][1993l]|[Operations on Tree][1993]                                                            |![rs]
 [1995][1995l]|[Count Special Quadruplets][1995]                                                     |![py]
 [2000][2000l]|[Reverse Prefix of Word][2000]                                                        |![py]
 [2001][2001l]|[Number of Pairs of Interchangeable Rectangles][2001]                                 |![py]
@@ -2226,6 +2227,7 @@
 [1984]:Problemset/1984-Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores/README.md#1984-minimum-difference-between-highest-and-lowest-of-k-scores
 [1985]:Problemset/1985-Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array/README.md#1985-find-the-kth-largest-integer-in-the-array
 [1991]:Problemset/1991-Find%20the%20Middle%20Index%20in%20Array/README.md#1991-find-the-middle-index-in-array
+[1993]:Problemset/1993-Operations%20on%20Tree/README.md#1993-operations-on-tree
 [1995]:Problemset/1995-Count%20Special%20Quadruplets/README.md#1995-count-special-quadruplets
 [2000]:Problemset/2000-Reverse%20Prefix%20of%20Word/README.md#2000-reverse-prefix-of-word
 [2001]:Problemset/2001-Number%20of%20Pairs%20of%20Interchangeable%20Rectangles/README.md#2001-number-of-pairs-of-interchangeable-rectangles
@@ -3479,6 +3481,7 @@
 [1984l]:https://leetcode.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/
 [1985l]:https://leetcode.com/problems/find-the-kth-largest-integer-in-the-array/
 [1991l]:https://leetcode.com/problems/find-the-middle-index-in-array/
+[1993l]:https://leetcode.com/problems/operations-on-tree/
 [1995l]:https://leetcode.com/problems/count-special-quadruplets/
 [2000l]:https://leetcode.com/problems/reverse-prefix-of-word/
 [2001l]:https://leetcode.com/problems/number-of-pairs-of-interchangeable-rectangles/
diff --git a/README_CN.md b/README_CN.md
