CareerCup

The tree will look something like this

class Tree {
   private: 
      
        // Tree Structure related.
        List <TreeNode *> _children;
        TreeNode * _parent;
        
        // Locking related.
        bool _locked = false;
        uint _numDescendantsLocked = 0;
};

The IsLocked method will just check the flag;

bool Tree::IsLocked() {
    return _locked;
}

The Lock method would walk up the path and increment the _numDescendantsLocked variable.

Something like

bool Tree::Lock() {
    // Any descendants locked?
    if (_numDescendantsLocked > 0) { return false;}
  
    // Check if any ancestor is locked.  
    Tree *parent = _parent;
    while (parent) {
        if (parent->IsLocked()) {
            return false;
        }
        parent = parent->_parent;
    }
    // Can lock now.
    parent = _parent;
    while(parent) {
        parent->_numDescendantsLocked++;
        parent = parent->_parent;
    }
    _locked = true;
    return true;
}

Unlocked will walk up the path and decrement the _numDescendantsLocked count.

Methods can be written better etc, but you get the idea.

Clarification is needed. Does unLock require you to remove locks from ancestors and descendants? isLocked returns false even if ancestor/descendants are locked?

No requirement to remove locks from ancestor or descendants
IsLocked - just returns true or false based on the node to checked

I don't think above complexities are possible. This can be done only in
IsLock - O(log n)
Lock - O(n)
unLock - O(log n)

Islock is possible in O(1)
Considering the general tree data structure with a father field and a locked boolean variable

Lock (node, root)
{
   p=node;
   do{
      while(p!=NULL)
       {  push(p);
          if(islock(p))
            {print cant be lockd and return false}
          p=p->child;
       }
     p=pop(stack);
     p=p->next;
    }while(p!=NULL or not empty stack)
   p=node;
   if(p!=root)
     {
       p=p->father;
        if(islock(p))
            {print cant be lockd and return false}
     }
     node->locked=true;
     return true;
}

O(log n)

class NodeLockUnlock:
    def __init__(self, d):
        self.val = d
        self.left = self.right = self.parent = None
        self.Count_of_locked_descendants = 0
        self.isLocked = False

    def isLock(self):
        return self.isLocked

    def _increase_lock_count_ancestor(self):
        node = self
        while node:
            node.Count_of_locked_descendants += 1

    def _decrease_lock_count_ancestor(self):
        node = self
        while node:
            node.Count_of_locked_descendants -= 1

    def lock(self):
        cur = self
        while cur and not cur.isLocked:
            cur = cur.parent
        if cur == None and self.Count_of_locked_descendants == 0:
            self.isLocked = True
            self._increase_lock_count_ancestor()
            return True
        return False

    def unLock(self):
        self.isLocked = False
        self._decrease_lock_count_ancestor()
        return True