Operations on Tree

Operations on Tree - Problem

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 need to design a data structure that supports three operations:

Lock: Locks the given node for the given user and prevents other users from locking the same node. You may only lock a node if it is currently unlocked.
Unlock: Unlocks the given node for the given user. You may only unlock a node if it is currently locked by the same user.
Upgrade: Locks the given node for the given user and unlocks all of its descendants. You may only upgrade a node if: (1) the node is unlocked, (2) it has at least one locked descendant, and (3) it does not have any locked ancestors.

Implement the LockingTree class with constructor and three methods as described above.

Input & Output

Example 1 — Basic Operations

$ Input: parent = [-1,0,0,1,1,2,2], operations = [["lock",2,2],["unlock",2,3],["unlock",2,2],["lock",4,5],["upgrade",0,1]]

› Output: [true,false,true,true,true]

💡 Note: Lock node 2 for user 2 (success). Try unlock node 2 by user 3 (fail - wrong user). Unlock node 2 by user 2 (success). Lock node 4 for user 5 (success). Upgrade node 0 for user 1 (success - unlocks node 4, locks node 0).

Example 2 — Upgrade Conditions

$ Input: parent = [-1,0,3,1,1], operations = [["lock",4,2],["lock",3,3],["upgrade",1,1]]

› Output: [true,true,false]

💡 Note: Lock nodes 4 and 3. Try upgrade node 1 - fails because ancestor 0 could be locked or node 3 (child of 1) is locked but 3 is not a descendant through the upgrade path.

Constraints

n == parent.length
2 ≤ n ≤ 1000
0 ≤ parent[i] ≤ n - 1 for i ≠ 0
parent[0] == -1
0 ≤ num ≤ n - 1
1 ≤ user ≤ 10⁴
At most 2000 calls will be made to lock, unlock, and upgrade

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is to build a children adjacency list for efficient descendant traversal and use parent pointers for ancestor checking. The optimal approach uses DFS on the subtree rather than checking all nodes. Time: O(n) per operation, Space: O(n) for the tree structure and lock tracking.

Common Approaches

✓ Brute Force Tree Traversal

⏱️ Time: O(n) Space: O(n)

For each operation, traverse the entire tree to check ancestors and descendants. Use simple arrays to track which nodes are locked and by whom.

Optimized with Children Map

⏱️ Time: O(n) Space: O(n)

Pre-build a children map from parent array to avoid checking all nodes for descendants. Use DFS on children for upgrade operations.

Brute Force Tree Traversal — Algorithm Steps

Store parent array and lock states
For upgrade: traverse entire tree to find descendants
For ancestor check: traverse up to root

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Store parent array and empty lock map

Check Ancestors

Traverse up parent chain

Find Descendants

Check all nodes for descendant relationship

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct {
    int* parent;
    int* locked;  // -1 means unlocked, otherwise user_id
    int n;
} LockingTree;

LockingTree* lockingTreeCreate(int* parent, int parentSize) {
    LockingTree* obj = (LockingTree*)malloc(sizeof(LockingTree));
    obj->parent = (int*)malloc(parentSize * sizeof(int));
    obj->locked = (int*)malloc(parentSize * sizeof(int));
    obj->n = parentSize;
    
    for (int i = 0; i < parentSize; i++) {
        obj->parent[i] = parent[i];
        obj->locked[i] = -1;
    }
    
    return obj;
}

bool lockingTreeLock(LockingTree* obj, int num, int user) {
    if (obj->locked[num] != -1) {
        return false;
    }
    obj->locked[num] = user;
    return true;
}

bool lockingTreeUnlock(LockingTree* obj, int num, int user) {
    if (obj->locked[num] != user) {
        return false;
    }
    obj->locked[num] = -1;
    return true;
}

bool isDescendant(LockingTree* obj, int node, int ancestor) {
    int curr = node;
    while (obj->parent[curr] != -1) {
        curr = obj->parent[curr];
        if (curr == ancestor) {
            return true;
        }
    }
    return false;
}

bool lockingTreeUpgrade(LockingTree* obj, int num, int user) {
    // Check if node is unlocked
    if (obj->locked[num] != -1) {
        return false;
    }
    
    // Check if any ancestor is locked
    int curr = num;
    while (obj->parent[curr] != -1) {
        curr = obj->parent[curr];
        if (obj->locked[curr] != -1) {
            return false;
        }
    }
    
    // Find all descendants and check if any are locked
    int descendants[1000];
    int descendantCount = 0;
    bool hasLockedDescendant = false;
    
    for (int i = 0; i < obj->n; i++) {
        if (isDescendant(obj, i, num) && obj->locked[i] != -1) {
            descendants[descendantCount++] = i;
            hasLockedDescendant = true;
        }
    }
    
    if (!hasLockedDescendant) {
        return false;
    }
    
    // Unlock all descendants and lock current node
    for (int i = 0; i < descendantCount; i++) {
        obj->locked[descendants[i]] = -1;
    }
    obj->locked[num] = user;
    return true;
}

LockingTree* solution(int* parent, int parentSize) {
    return lockingTreeCreate(parent, parentSize);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple array parsing
    int parent[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        parent[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    LockingTree* lt = lockingTreeCreate(parent, size);
    printf("LockingTree initialized\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation may traverse entire tree

✓ Linear Growth

Space Complexity

O(n)

Store parent array and lock information

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Tree Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler