Operations on Tree - Practice Coding Problems

Operations on Tree - Problem

Imagine you're building a hierarchical access control system for a corporate network! You have a tree structure with n nodes numbered from 0 to n-1, where each node represents a resource in the system.

Given a parent array where parent[i] is the parent of the i-th node, you need to design a data structure that supports three critical operations:

Lock: 🔒 Lock a node for a specific user (only if currently unlocked)
Unlock: 🔓 Unlock a node (only by the same user who locked it)
Upgrade: ⬆️ Lock a node and unlock ALL its descendants, but only if: the node is unlocked, has locked descendants, and no locked ancestors

The root is always node 0 with parent[0] = -1. Your task is to implement the LockingTree class that efficiently handles these operations while maintaining the tree's access control rules.

Input & Output

example_1.py — 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), lock(0, 1)

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

💡 Note: Lock node 2 for user 2 (success), unlock node 2 by user 3 (fail - wrong user), unlock by user 2 (success), lock node 4 for user 5 (success), upgrade node 0 for user 1 (success - unlocks node 4), lock node 0 for user 1 (fail - already locked)

example_2.py — Upgrade with Ancestors

$ Input: parent = [-1, 0, 1, 1, 2, 2] Operations: lock(2, 2), lock(3, 3), upgrade(0, 1), upgrade(1, 1)

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

💡 Note: Lock nodes 2 and 3, upgrade root (success - unlocks both), then try upgrade node 1 (fail - no locked descendants after previous upgrade)

example_3.py — Complex Hierarchy

$ Input: parent = [-1, 0, 0, 1, 1, 2, 2, 3, 3] Operations: lock(4, 1), lock(7, 2), upgrade(1, 3), lock(2, 4), upgrade(0, 5)

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

💡 Note: Lock leaf nodes, upgrade middle node (success), lock another middle node, then fail to upgrade root because node 1 is locked (locked ancestor check)

Constraints

n == parent.length
2 ≤ n ≤ 2000
0 ≤ parent[i] ≤ n - 1 for i ≠ 0
parent[0] == -1
The parent array represents a valid tree
At most 2000 calls in total will be made to lock, unlock, and upgrade

Visualization

Tap to expand

Understanding the Visualization

Department Hierarchy

The tree represents organizational structure with parent-child relationships between departments

Access Control Rules

Users can lock departments they have access to, but can't override their superiors

Upgrade Authorization

Upgrading gives exclusive access but requires: no boss interference, unlocked target, and locked subordinates

Efficient Implementation

Preprocessing the hierarchy enables fast permission checks and batch operations

Key Takeaway

🎯 Key Insight: Preprocessing the tree structure during initialization enables O(1) lock/unlock operations and efficient upgrade operations by caching parent-child relationships and using targeted DFS traversal.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal approach uses preprocessing during initialization to build a children adjacency list, enabling efficient tree operations. The key insight is to maintain the tree structure explicitly rather than rebuilding it for each operation. Lock and unlock operations are O(1) using a hash map, while upgrade operations efficiently check ancestors by following the parent chain and traverse descendants using the precomputed children relationships.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Tree with Preprocessing	O(n) worst case per upgrade	O(n)	Precompute children relationships and use efficient tree traversal
Brute Force Tree Traversal	O(n) per operation	O(n)	Build tree structure and traverse entire tree for each operation

Optimized Tree with Preprocessing — Algorithm Steps

Build children adjacency list during initialization
Maintain lock state using hash map for O(1) access
For upgrade: check ancestors by following parent chain
Use DFS on precomputed children for descendant operations
Batch unlock all locked descendants efficiently

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialization

Build children adjacency list during construction

Ancestor Check

Follow parent chain efficiently to check for locks

Descendant DFS

Use precomputed children for fast descendant traversal

Batch Operations

Lock target and unlock all found descendants atomically

Code -

solution.c — C

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

typedef struct {
    int* parent;
    int n;
    int* locked;
    int* lockedUsers;
    int** children;
    int* childCount;
} LockingTree;

LockingTree* lockingTreeCreate(int* parent, int parentSize) {
    LockingTree* obj = (LockingTree*)malloc(sizeof(LockingTree));
    obj->parent = (int*)malloc(parentSize * sizeof(int));
    obj->locked = (int*)calloc(parentSize, sizeof(int));
    obj->lockedUsers = (int*)malloc(parentSize * sizeof(int));
    obj->n = parentSize;
    
    // Precompute children
    obj->children = (int**)malloc(parentSize * sizeof(int*));
    obj->childCount = (int*)calloc(parentSize, sizeof(int));
    
    for (int i = 0; i < parentSize; i++) {
        obj->parent[i] = parent[i];
        obj->children[i] = (int*)malloc(parentSize * sizeof(int));
    }
    
    for (int i = 0; i < parentSize; i++) {
        if (parent[i] != -1) {
            obj->children[parent[i]][obj->childCount[parent[i]]++] = i;
        }
    }
    
    return obj;
}

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

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

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

void findLockedDescendants(LockingTree* obj, int num, int* lockedDesc, int* descCount) {
    for (int i = 0; i < obj->childCount[num]; i++) {
        int child = obj->children[num][i];
        if (obj->locked[child]) {
            lockedDesc[(*descCount)++] = child;
        }
        findLockedDescendants(obj, child, lockedDesc, descCount);
    }
}

bool lockingTreeUpgrade(LockingTree* obj, int num, int user) {
    if (obj->locked[num]) {
        return false;
    }
    
    if (hasLockedAncestor(obj, num)) {
        return false;
    }
    
    int* lockedDesc = (int*)malloc(obj->n * sizeof(int));
    int descCount = 0;
    findLockedDescendants(obj, num, lockedDesc, &descCount);
    
    if (descCount == 0) {
        free(lockedDesc);
        return false;
    }
    
    obj->locked[num] = 1;
    obj->lockedUsers[num] = user;
    for (int i = 0; i < descCount; i++) {
        obj->locked[lockedDesc[i]] = 0;
    }
    
    free(lockedDesc);
    return true;
}

void lockingTreeFree(LockingTree* obj) {
    for (int i = 0; i < obj->n; i++) {
        free(obj->children[i]);
    }
    free(obj->children);
    free(obj->childCount);
    free(obj->parent);
    free(obj->locked);
    free(obj->lockedUsers);
    free(obj);
}

int main() {
    printf("Implementation depends on input format\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n) worst case per upgrade

Upgrade operation may need to check all ancestors and traverse all descendants in worst case

✓ Linear Growth

Space Complexity

O(n)

Space for children adjacency list and lock state mapping

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Optimized Tree with Preprocessing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler