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 `ith` 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:**

**Input**
\[ "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\]\]
**Output**
\[null, true, false, true, true, true, false\]

**Explanation**
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.

**Constraints:**

*   `n == parent.length`
*   `2 <= n <= 2000`
*   `0 <= parent[i] <= n - 1` for `i != 0`
*   `parent[0] == -1`
*   `0 <= num <= n - 1`
*   `1 <= user <= 104`
*   `parent` represents a valid tree.
*   At most `2000` calls **in total** will be made to `lock`, `unlock`, and `upgrade`.

0`부터 `n - 1`까지 번호가 매겨진 `n`개의 노드가 있는 트리가 부모 배열 `부모`의 형태로 주어지며, 여기서 `부모[i]`는 `ith` 노드의 부모입니다. 트리의 루트는 노드 `0`이므로 부모가 없으므로 `parent[0] = -1`입니다. 사용자가 트리의 노드를 잠그고, 잠금을 해제하고, 업그레이드할 수 있는 데이터 구조를 설계하려고 합니다.

데이터 구조는 다음 기능을 지원해야 합니다:

**잠금: **지정된 사용자에 대해 지정된 노드를 **잠금**하고 다른 사용자가 동일한 노드를 잠그지 못하도록 합니다. 노드가 잠금 해제된 경우에만 이 함수를 사용하여 노드를 잠글 수 있습니다.
* **잠금해제: 지정된 사용자에 대해 지정된 노드를 잠금 해제**합니다. 현재 동일한 사용자가 노드를 잠근 경우에만 이 함수를 사용하여 노드를 잠금 해제할 수 있습니다.
**Upgrade****: 지정된 사용자에 대해 지정된 노드를 잠그고, 누가 잠갔는지에 관계없이 모든 하위 노드를 **잠금 해제**합니다. 3가지 조건이 **모두** 참인 경우에만 노드를 업그레이드할 수 있습니다:
    * 노드가 잠금 해제됨,
    잠긴 하위 노드가 하나 이상 있고(**모든** 사용자에 의해), *잠긴 하위 노드가 하나 이상 있으며.
    * 잠긴 조상이 없습니다.

LockingTree` 클래스를 구현합니다:

* `LockingTree(int[] parent)`는 부모 배열로 데이터 구조를 초기화합니다.
* lock(int num, int user)`은 `user` 아이디를 가진 사용자가 `num` 노드를 잠글 수 있는 경우 `true`를 반환하고, 그렇지 않은 경우 `false`를 반환합니다. 가능하다면, `user` 아이디를 가진 사용자가 `num` 노드를 **잠금**합니다.
* unlock(int num, int user)`은 `user` 아이디를 가진 사용자가 `num` 노드의 잠금을 해제할 수 있으면 `true`를 반환하고, 그렇지 않으면 `false`를 반환합니다. 가능하면 노드 `num`은 **잠금해제** 됩니다.
* upgrade(int num, int user)` 는 `user` 아이디를 가진 사용자가 `num` 노드를 업그레이드할 수 있으면 `true`를 반환하고, 그렇지 않으면 `false`를 반환합니다. 가능하면 노드 `num`이 **업그레이드** 됩니다.

**예제 1:**

**입력**
\["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\]\]
**출력**
\[널, 참, 거짓, 참, 참, 참, 참, 참, 거짓\]

설명** **설명
LockingTree lockingTree = new LockingTree(\[-1, 0, 0, 1, 1, 2, 2\]);
lockingTree.lock(2, 2); // 노드 2가 잠금 해제되었으므로 참을 반환합니다.
                           // 이제 노드 2는 사용자 2에 의해 잠겼습니다.
lockingTree.unlock(2, 3); // 사용자 3은 사용자 2에 의해 잠긴 노드를 잠금 해제할 수 없으므로 false를 반환합니다.
lockingTree.unlock(2, 2); // 노드 2는 이전에 사용자 2에 의해 잠겼기 때문에 참을 반환합니다.
                           // 이제 노드 2의 잠금이 해제됩니다.
lockingTree.lock(4, 5); // 노드 4가 잠금 해제되었으므로 참을 반환합니다.
                           // 이제 노드 4는 사용자 5에 의해 잠깁니다.
lockingTree.upgrade(0, 1); // 노드 0이 잠금 해제되고 잠긴 자손(노드 4)이 하나 이상 있기 때문에 참을 반환합니다.
                           // 이제 노드 0은 사용자 1에 의해 잠기고 노드 4는 잠금 해제됩니다.
lockingTree.lock(0, 1); // 노드 0이 이미 잠겨있기 때문에 false를 반환합니다.

**제약 조건:**

* `n == 부모.길이`
* `2 <= n <= 2000`
* 0 <= parent[i] <= n - 1` for `i != 0`
* `parent[0] == -1`
* `0 <= num <= n - 1`
* `1 <= user <= 104`
* `parent`는 유효한 트리를 나타냅니다.
* 잠금`, `잠금해제`, `업그레이드`를 위해 최대 `2000`번의 호출이 **전체적으로** 수행됩니다.
